مواصفات StableHLO

‫StableHLO هي مجموعة عمليات للعمليات العالية المستوى (HLO) في نماذج تعلُّم الآلة (ML). تعمل StableHLO كطبقة لنقل البرامج بين مختلف إطارات عمل تعلُّم الآلة وبرامج التحويل الخاصة به: إنّ إطارات عمل تعلُّم الآلة التي تُنشئ برامج StableHLO تكون متوافقة مع برامج التحويل الخاصة بتعلُّم الآلة التي تستخدِم برامج StableHLO.

هدفنا هو تبسيط تطوير تعلُّم الآلة وتسريعه من خلال توفير المزيد من إمكانية التشغيل التفاعلي بين أُطر عمل تعلُّم الآلة المختلفة (مثل TensorFlow وJAX و PyTorch) وبرامج تجميع تعلُّم الآلة (مثل XLA وIREE). لتحقيق هذا الهدف، يقدّم هذا المستند مواصفات لغة البرمجة StableHLO.

تحتوي هذه المواصفة على ثلاثة أقسام رئيسية. أولاً، يصف قسم البرامج بنية برامج StableHLO التي تتألف من دوالّ StableHLO التي تتألف بدورها من عمليات StableHLO. ضمن هذه البنية، يحدد قسم العمليات دلالات العمليات الفردية. يقدّم قسم التنفيذ دلالات لجميع عمليات التنفيذ هذه التي يتم تنفيذها معًا ضمن برنامج. وأخيرًا، يناقش قسم التدوين العلامة المستخدمة في المواصفات.

للاطّلاع على المواصفات من إصدار سابق من StableHLO، افتح المستودع في الإصدار الذي يحمل علامة من الاهتمام. على سبيل المثال، مواصفات StableHLO v0.19.0. لعرض التغييرات التي حدثت في كل إصدار ثانوي من StableHLO، يُرجى الرجوع إلى سجلّ الإصدار في VhloDialect.td.

البرامج

Program ::= {Func}

تتألف برامج StableHLO من عدد عشوائي من دوال StableHLO. في ما يلي مثال على برنامج يتضمّن الدالة @main التي تتضمّن 3 إدخالات (%image و%weights و%bias) ومخرجًا واحدًا. يحتوي نص الدالة على 6 عمليات.

func.func @main(
  %image: tensor<28x28xf32>,
  %weights: tensor<784x10xf32>,
  %bias: tensor<1x10xf32>
) -> tensor<1x10xf32> {
  %0 = "stablehlo.reshape"(%image) : (tensor<28x28xf32>) -> tensor<1x784xf32>
  %1 = "stablehlo.dot"(%0, %weights) : (tensor<1x784xf32>, tensor<784x10xf32>) -> tensor<1x10xf32>
  %2 = "stablehlo.add"(%1, %bias) : (tensor<1x10xf32>, tensor<1x10xf32>) -> tensor<1x10xf32>
  %3 = "stablehlo.constant"() {value = dense<0.0> : tensor<1x10xf32>} : () -> tensor<1x10xf32>
  %4 = "stablehlo.maximum"(%2, %3) : (tensor<1x10xf32>, tensor<1x10xf32>) -> tensor<1x10xf32>
  "func.return"(%4): (tensor<1x10xf32>) -> ()
}

الدوال

Func        ::= 'func' '.' 'func' FuncId FuncInputs FuncOutputs '{' FuncBody '}'
FuncInputs  ::= '(' [FuncInput {',' FuncInput}] `)`
FuncInput   ::= ValueId ':' ValueType
FuncOutputs ::= ['->' FuncOutput, {',' FuncOutput}]
FuncOutput  ::= ValueType
FuncBody    ::= {Op}

تحتوي وظائف StableHLO (المعروفة أيضًا باسم الدوال المُسمّاة) على معرّف وعناصر إدخال/إخراج ونص. في المستقبل، نخطّط لطرح بيانات وصفية إضافية للوظائف من أجل تحقيق توافق أفضل مع HLO (‎#425 و‎#626 و‎#740 و‎#744).

المعرفات

FuncId  ::= '@' letter {letter | digit}
ValueId ::= '%' digit {digit}
          | '%' letter {letter | digit}
letter  ::= 'a' | ... | 'z' | 'A' | ... | 'Z' | '_'
digit   ::= '0' | ... | '9'

تتشابه معرّفات SttableHLO مع المعرّفات في العديد من لغات البرمجة، مع خاصيتَين هما: 1) كل المعرِّفات تتضمن sigil تميّز الأنواع المختلفة من المعرّفات، 2) ويمكن أن تكون معرّفات القيمة رقمية بالكامل لتبسيط عملية إنشاء برامج StableHLO.

الأنواع

Type         ::= ValueType | NonValueType
ValueType    ::= TensorType | QuantizedTensorType | TokenType | TupleType
NonValueType ::= TensorElementType | QuantizedTensorElementType | FunctionType | StringType

يتم تصنيف أنواع StableHLO إلى أنواع القيم (التي تُعرف أيضًا باسم أنواع الفئة الأولى) التي تمثّل قيم StableHLO وأنواع القيم غير المحدّدة التي تصف عناصر البرنامج الأخرى. وتشبه أنواع StableHLO الأنواع في العديد من لغات البرمجة، حيث تتمثّل الخصوصية الرئيسية في طبيعة StableHLO الخاصة بالنطاق والتي ينتج عنها بعض النتائج غير المعتادة (على سبيل المثال، لا تكون الأنواع العددية أنواعًا من القيم).

TensorType ::= 'tensor' '<' Shape TensorElementType '>'
Shape ::= {DimensionSize 'x'}
DimensionSize ::= digit {digit} | '?'

تمثّل أنواع مصفوفات السلاسل المتسلسلة مصفوفات السلاسل المتسلسلة، أي الصفائف متعددة الأبعاد. وتتضمّن شكلًا ونوع عنصر، حيث يمثّل الشكل أحجام السمات غير السالبة أو غير المعروفة بترتيب تصاعدي للسمات (المعروفة أيضًا باسم المحاور) التي تتراوح أرقامها من 0 إلى R-1. يُطلق على عدد السمات R اسم الرتبة. على سبيل المثال، tensor<2x3xf32> هو نوع مصفوفة سِنتر مع شكل 2x3 ونوع العنصر f32. ويحتوي على بُعدين (أو بعبارةٍ أخرى محوران) - البعد 0 والبعد الأول، وحجمهما 2 و3. ترتيبها هو 2.

يمكن أن تكون الأشكال غير معروفة جزئيًا أو كليًا (ديناميكية)، على سبيل المثال، tensor<?x2xf64> غير معروفة جزئيًا وtensor<?x?xf64> غير معروفة كليًا. يتم تمثيل أحجام السمات الديناميكية باستخدام ?. لا يمكن للأشكال أن تكون غير مرتبة.

في المستقبل، نخطّط لاستكشاف توسيع نطاق أنواع مصفوفات السلاسل إلى ما بعد أحجام السمات وأنواع العناصر، على سبيل المثال، لتضمين التنسيقات (#629) والكثافة (#1078).

QuantizedTensorType ::= 'tensor' '<' Shape QuantizedTensorElementType '>'
QuantizedTensorElementType ::= '!quant.uniform' '<'
                  QuantizationStorageType
                  ['<' QuantizationStorageMin ':' QuantizationStorageMax '>']
                  ':' QuantizationExpressedType
                  [':' QuantizationDimension]
                  ',' QuantizationParameters '>'
QuantizationStorageType ::= IntegerType
QuantizationStorageMin ::= IntegerLiteral
QuantizationStorageMax ::= IntegerLiteral
QuantizationExpressedType ::= FloatType
QuantizationDimension ::= IntegerLiteral
QuantizationParameters ::= QuantizationParameter
                         | '{' QuantizationParameter {',' QuantizationParameter} '}'
QuantizationParameter ::= QuantizationScale [':' QuantizationZeroPoint]
QuantizationScale ::= FloatLiteral
QuantizationZeroPoint ::= IntegerLiteral

تمثّل أنواع العناصر المقسّمة القيم الصحيحة لنوع التخزين في النطاق من storage_min إلى storage_max (شاملاً) والتي تتوافق مع قيم الكسور العشرية لنوع معرَّف. بالنسبة إلى قيمة عدد صحيح معيّنة i، يمكن احتساب القيمة f ذات النقطة العائمة المقابلة على النحو التالي: f = (i - zero_point) * scale، حيث يُطلق على scale وzero_point اسم مَعلمات التقريب. تكون القيمتان storage_min وstorage_max اختياريتين في القواعد النحوية، ولكنّهما تتضمّنان قيمتَي min_value(storage_type) max_value(storage_type) التلقائيتَين على التوالي. تخضع أنواع العناصر الكمية للقيود التالية:

• (ج1) type(storage_min) = storage_type.
• (ج2) type(storage_max) = storage_type.
• (ج3) min_value(storage_type) <= storage_min < storage_max <= max_value(storage_type).
• (C4) type(scales...) = expressed_type.
• (ج5) 0 < scales.
• (C6) is_finite(scales...).
• (ج7) storage_min <= zero_points <= storage_max.
• (C8) type(zero_points...) = storage_type.
• (ج9) size(scales) = size(zero_points).
• (C10) إذا كان is_empty(quantization_dimension)، ثم size(scales) = 1.
• (C11) 0 <= quantization_dimension.

في الوقت الحالي، QuantizationScale هو ثابت بنقطة عائمة، ولكن هناك اهتمامًا كبيرًا بالمقاييس المستندة إلى الأعداد الصحيحة، والتي يتم تمثيلها بالمضاعِفات ومقدّمات الضرب . نحن نخطّط لاستكشاف هذه الميزة في المستقبل القريب (#1404).

هناك مناقشة جارية حول دلالة QuantizationZeroPoint، بما في ذلك النوع والقيم وما إذا كان يمكن أن يكون هناك نقطة واحدة فقط أو نقاط صفرية متعددة محتملة في نوع مصفوفة كمية. واستنادًا إلى نتائج هذه المناقشة، قد تتغير المواصفات المتعلقة بالنقاط الصفرية في المستقبل (#1405).

هناك مناقشة أخرى جارية حول دلالة QuantizationStorageMin وQuantizationStorageMax لتحديد ما إذا كان يجب فرض أي قيود على هذه القيم وعلى قيم مصفوفات الكمّان (#1406).

وأخيرًا، نخطط لاستكشاف ميزة تمثيل المقاييس غير المعروفة والنقاط الصفرية، على نحو مشابه للطريقة التي نخطط بها لاستكشاف أحجام السمات غير المعروفة (#1407).

تمثّل أنواع مأخذ التوتر الكمّي قوات التوتر التي تتضمّن عناصر كمية. إنّ مكونات هذه المصفوفات هي نفسها تمامًا مثل مكونات المصفوفات العادية، باستثناء أنّ مكوناتها تتضمّن أنواعًا مكمّنة للعناصر بدلاً من أنواع العناصر العادية.

في قياسات الكمّية، يمكن أن يكون القياس لكلّ متسلل، بمعنى أنّه يمكن أن يكون هناك scale وzero_point واحد لماور كامل أو لكل محور، بمعنى أن يتضمّن العديد من scales وzero_points، زوجًا واحدًا لكل شريحة من بُعد معيّن quantization_dimension. وبشكل أكثر رسمية، في الخوارزمية t التي يتم فيها تحديد كمية كل محور، تتوفّر dim(t, quantization_dimension) شريحة من quantization_dimension: t[:, ..., 0, ..., :], t[:, ..., 1, ..., :]، وما إلى ذلك. تستخدم جميع العناصر في الشريحة iالسمة scales[i] وzero_points[i] كمَعلمتَين للقياس الكمي. تنطبق المقيّدات التالية على أنواع مصفوفات الخلاصات المحوَّلة:

• بالنسبة إلى تقليل عدد الأرقام لكل مصفوفة كثافة:
  • ما مِن قيود إضافية.
• بالنسبة إلى التجزئة حسب المحور:
  • (C12) quantization_dimension < rank(self).
  • (C13) dim(self, quantization_dimension) = size(scales).

TokenType ::= 'token'

تمثّل أنواع الرموز المميّزة الرموز المميّزة، أي القيم غير الشفافة التي تنتجها بعض العمليات وتستهلكها. تُستخدَم الرموز لفرض ترتيب التنفيذ على العمليات، كما هو موضّح في قسم التنفيذ.

TupleType ::= 'tuple' '<' TupleElementTypes '>'
TupleElementTypes ::= [ValueType {',' ValueType}]

تمثّل أنواع المجموعات المجموعات، أي القوائم غير المتجانسة. مجموعات السلاسل هي ميزة قديمة لا تتوفر إلا للتوافق مع HLO. في لغة HLO، يتم استخدام المصفوفات الترتيبية لتمثيل المدخلات والمخرجات المتغيّرة. في StableHLO، تكون المدخلات والمخرجات المتغيّرة متاحة بشكل أساسي، والاستخدام الوحيد للقوائم في StableHLO هو تمثيل ABI لـ HLO بشكل شامل، حيث قد يختلف T وtuple<T> و tuple<tuple<T>> بشكلٍ كبير استنادًا إلى تنفيذ معيّن. ونخطّط في المستقبل لإجراء تغييرات على واجهة التطبيق الثنائية (HLO ABI) والتي قد تتيح لنا إزالة أنواع الصفوف من StableHLO (#598).

TensorElementType ::= BooleanType | IntegerType | FloatType | ComplexType
BooleanType ::= 'i1'
IntegerType ::= SignedIntegerType | UnsignedIntegerType
SignedIntegerType ::= 'si2' | 'si4' | 'si8' | 'si16' | 'si32' | 'si64'
UnsignedIntegerType ::= 'ui2' | 'ui4' | 'ui8' | 'ui16' | 'ui32' | 'ui64'
FloatType ::= 'f4E2M1FN' | 'f6E2M3FN' | 'f6E3M2FN' | 'f8E3M4' | 'f8E4M3'
            | 'f8E4M3FN' | 'f8E4M3FNUZ' | 'f8E4M3B11FNUZ' | 'f8E5M2'
            | 'f8E5M2FNUZ' | 'f8E8M0FNU' | 'bf16' | 'f16' | 'f32' | 'f64'
TensorFloat32 ::= 'tf32'
ComplexType ::= 'complex' '<' ComplexElementType '>'
ComplexElementType ::= 'f32' | 'f64'

تمثّل أنواع العناصر عناصر أنواع أداة "المنسِّر". وعلى عكس العديد من لغات البرمجة، لا تعتبر هذه الأنواع من الدرجة الأولى في StableHLO. وهذا يعني أنّه لا يمكن لبرامج StableHLO تمثيل قيم هذه الأنواع مباشرةً (نتيجةً لذلك، من الشائع تمثيل القيم العدية من النوع T باستخدام قيم ناتجة عن مصفوفة خماسية الأبعاد من النوع tensor<T>).

• يمثّل النوع المنطقي القيم المنطقية true وfalse.
• يمكن أن تكون أنواع الأعداد الصحيحة إما ذات علامة (si) أو بدون علامة (ui) وأن يكون لها أحد مساحات البتات المتوافقة (2 أو 4 أو 8 أو 16 أو 32 أو 64). تمثّل أنواع siN ذات العلامة قيمًا صحيحة من -2^(N-1) إلى 2^(N-1)-1 شاملة، وتمثّل أنواع uiN بدون علامة قيمًا صحيحة من 0 إلى 2^N-1 شاملة.
• يمكن أن تكون أنواع النقاط العائمة أيًا مما يلي:
  • ‫f8E3M4 وf8E4M3 وf8E5M2 أرقام بنقطة عائمة 8 بت تتبع اصطلاحات IEEE-754
  • نوعَا f8E4M3FN وf8E5M2 اللذان يتوافقان مع ترميزَي E4M3 وE5M2 لتنسيق FP8 الموضّحَين في تنسيقات FP8 للتعلم العميق.
  • النوعان f8E4M3FNUZ وf8E5M2FNUZ المتوافقان مع الترميزَين E4M3 وE5M2 للترميزَين FP8 الموضّحَين في التنسيقات الرقمية 8 بت للشبكات العصبية العميقة
  • نوع f8E4M3B11FNUZ المطابق لترميز E4M3 لتنسيقات FP8 описан في التدريب والاستنتاج باستخدام النقطة العائمة المختلطة 8 بت (HFP8) للشبكات العصبية العميقة
  • نوع bf16 المطابق لتنسيق bfloat16 الموضّح في مقالة BFloat16: سر الأداء العالي على وحدات Cloud TPUs
  • أنواع f16 وf32 وf64 التي تتوافق مع التنسيقات binary16 ("نصف الدقة") وbinary32 ("دقة واحدة") و binary64 ("دقة مزدوجة") الموضّحة في معيار IEEE 754
  • يتوافق نوع tf32 مع تنسيق TensorFloat32 ويكون متوافقًا بشكل محدود مع StableHLO.
  • أنواع MX (التصغير) f4E2M1FN وf6E2M3FN وf6E3M2FN وf8E8M0FNU описанные в описанные в OCP Microscaling Formats Specification
• تمثّل الأنواع المعقدة القيم المعقدة التي تحتوي على جزء حقيقي وجزء تخيلي من نوع العنصر نفسه. الأنواع المركّبة المسموح بها هي complex<f32> (كلا الجزأين من النوع f32) وcomplex<f64> (كلا الجزأين من النوع f64).

FunctionType ::= '(' InputTypes ')' '->' '(' OutputTypes ')'
InputTypes ::= [ValueType {',' ValueType}]
OutputTypes ::= [ValueType {',' ValueType}]

تمثّل أنواع الدوال كلًّا من الدوال المُسمّاة والدوالّ المجهولة. وتتضمّن أنواع الإدخال (قائمة الأنواع على الجانب الأيسر من ->) وأنواع النتائج (قائمة الأنواع على الجانب الأيمن من ->). وفي العديد من لغات البرمجة، تكون أنواع الدوال من الفئة الأولى، ولكنها ليست في StableHLO.

StringType ::= 'string'

يمثّل نوع السلسلة تسلسلات البايتات. على عكس العديد من لغات البرمجة، لا يُعدّ نوع السلسلة من الفئة الأولى في StableHLO، ولا يُستخدم إلا لتحديد بيانات وصفية ثابتة لعناصر البرنامج.

العمليات

تمثّل عمليات StableHLO (المعروفة أيضًا باسم ops) مجموعة مغلقة من العمليات العالية المستوى في نماذج تعلُّم الآلة. كما ناقشنا أعلاه، يستوحي أسلوب StableHLO من MLIR بشكل كبير، وهو ليس بالضرورة البديل الأكثر ملاءمةً للاستخدام، ولكن يمكن القول إنّه الأنسب لتحقيق هدف StableHLO المتمثل في زيادة إمكانية التشغيل التفاعلي بين إطارات عمل تعلُّم الآلة وبرامج التحويل الخاصة به.

Op            ::= [OpOutputs] OpName OpInputs ':' OpSignature
OpName        ::= '"' 'stablehlo' '.' OpMnemonic '"'
OpMnemonic    ::= 'abs' | 'add' | ...

تتضمّن عمليات StableHLO (المعروفة أيضًا باسم ops) اسمًا، ومدخلات/مخرجات وتوقيعًا. يتألّف الاسم من البادئة stablehlo. و عبارة مساعدة تُحدِّد بشكل فريد إحدى العمليات المتوافقة. يمكنك الاطّلاع أدناه على قائمة شاملة بكلّ العمليات المتوافقة.

OpInputs        ::= OpInputValues OpInputFuncs OpInputAttrs
OpInputValues   ::= '(' [OpInputValue {',' OpInputValue}] ')'
OpInputValue    ::= ValueId
OpInputFuncs    ::= ['(' OpInputFunc {',' OpInputFunc} ')']
OpInputAttrs    ::= ['{' OpInputAttr {',' OpInputAttr} '}']
OpOutputs       ::= [OpOutput {',' OpOutput} '=']
OpOutput        ::= ValueId

تستهلك العمليات الإدخالات وتُنتج المخرجات. يتم تصنيف المدخلات إلى قيم المدخلات (المحسوبة أثناء التنفيذ) ودوال المدخلات (المقدَّمة بشكل ثابت، لأنّ الدوال في StableHLO ليست قيمًا من الدرجة الأولى) وسمات المدخلات (المقدَّمة أيضًا بشكل ثابت). يعتمد نوع المدخلات والمخرجات التي يتم استهلاكها وإنتاجها على العملية على الذاكرة. على سبيل المثال، تستهلك العملية add قيمتَي إدخال وينتج عنها قيمة واحدة للمخرجات. في المقابل، تستهلك عملية select_and_scatter 3 قيم إدخال ودالتَي إدخال و 3 سمات إدخال.

OpInputFunc ::= '{' Unused FuncInputs ':' FuncBody '}'
Unused      ::= '^' digit {digit}
              | '^' letter {letter | digit}

دوالّ الإدخال (التي تُعرف أيضًا باسم الدوالّ المجهولة) مشابهة جدًا للدوالّ المُسمّاة باستثناء أنّها: 1) لا تحتوي على معرّف (من هنا جاء اسمها "مجهولة")، 2) لا تحدّد أنواع النتائج (يتم استنتاج أنواع النتائج من عملية return ضمن الدالة).

تتضمّن بنية جملة دوال الإدخال جزءًا غير مستخدَم حاليًا (راجِع العبارة Unused أعلاه) وهو متوفر للتوافق مع MLIR. في MLIR، يتوفر مفهوم أكثر عمومية "للمناطق" التي يمكن أن تتضمّن عدة "كتل" من العمليات متصلة معًا من خلال عمليات القفزة. تحتوي هذه الكتل على أرقام تعريف تتوافق مع عملية إنتاج Unused، حتى يمكن تمييزها عن بعضها. لا يحتوي StableHLO على عمليات الانتقال، لذا فإن الجزء المقابل من بناء جملة MLIR غير مستخدم (لكنه لا يزال موجودًا).

OpInputAttr      ::= OpInputAttrName '=' OpInputAttrValue
OpInputAttrName  ::= letter {letter | digit}
OpInputAttrValue ::= Constant

يكون لسمات الإدخال اسمًا وقيمة وتُعتبر إحدى الثوابت المتوافقة. إنها الطريقة الأساسية لتحديد بيانات التعريف الثابتة لعناصر البرنامج. على سبيل المثال، يستخدم الإجراء concatenate السمة dimension لتحديد السمة التي يتم تسلسل قيم الإدخال على طولها. وبالمثل، تستخدِم عملية slice سمات متعدّدة مثل start_indices وlimit_indices لتحديد الحدود المستخدَمة لتقسيم قيمة الإدخال.

في الوقت الحالي، تحتوي برامج StableHLO المتوفّرة في الوقت الحالي أحيانًا على سمات لم يتم وصفها في هذا المستند. في المستقبل، نخطّط ل إما دمج هذه السمات في مجموعة أوامر StableHLO أو منع ظهورها في برامج StableHLO. في غضون ذلك، إليك قائمة بهذه السمات:

• layout (‎#629)
• mhlo.frontend_attributes (‎#628).
• mhlo.sharding (#619).
• output_operand_aliases (#740).
• البيانات الوصفية للموقع الجغرافي (#594)

OpSignature ::= '(' [ValueType {',' ValueType}] ')' '->' '(' [ValueType {',' ValueType}] ')'

يتكون توقيع Op من أنواع جميع قيم الإدخال (قائمة الأنواع التي تظهر على الجانب الأيسر من ->) وأنواع كل قيم الإخراج (قائمة الأنواع على الجانب الأيمن من ->). بالإضافة إلى ذلك، تكون أنواع الإدخالات متكررة، كما أن أنواع الإخراج تكون متكررة دائمًا تقريبًا أيضًا (لأنّه بالنسبة إلى معظم عمليات HLO الثابتة، يمكن استنتاج أنواع الإخراج من الإدخالات). ومع ذلك، يعد توقيع العملية جزءًا عن قصد من بناء جملة StableHLO للتوافق مع MLIR.

في ما يلي مثال على عملية رمزها التعريفي select_and_scatter. ويستهلك هذا الإجراء 3 قيم إدخال (%operand و%source و%init_value) ودالتَي إدخال و3 سمات إدخال (window_dimensions وwindow_strides وpadding). يُرجى ملاحظة أنّ توقيع العملية لا يتضمّن سوى أنواع قيم الإدخال (وليس أنواع دوالّ الإدخال والسمات التي يتم تقديمها مضمّنة).

%result = "stablehlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "stablehlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "stablehlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "stablehlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

الثوابت

Constant ::= BooleanConstant
           | IntegerConstant
           | FloatConstant
           | ComplexConstant
           | TensorConstant
           | QuantizedTensorConstant
           | StringConstant
           | EnumConstant

تحتوي ثوابت StableHLO على تعبير حرفي ونوع يمثّلان معًا قيمة StableHLO. بشكل عام، يكون النوع جزءًا من بنية الثابت، إلا عندما يكون واضحًا (على سبيل المثال، يكون الثابت المنطقي من النوع i1 بوضوح، في حين يمكن أن يكون للثابت الصحيح أنواع متعددة محتملة).

BooleanConstant ::= BooleanLiteral
BooleanLiteral  ::= 'true' | 'false'

تمثل الثوابت المنطقية القيمتين المنطقيتين true وfalse. تحتوي الثوابت المنطقية على النوع i1.

IntegerConstant   ::= IntegerLiteral ':' IntegerType
IntegerLiteral    ::= ['-' | '+'] DecimalDigits
                    | ['-' | '+'] '0x' HexadecimalDigits
DecimalDigits     ::= decimalDigit {decimalDigit}
HexadecimalDigits ::= hexadecimalDigit {hexadecimalDigit}
decimalDigit      ::= '0' | ... | '9'
hexadecimalDigit  ::= decimalDigit | 'a' | ... | 'f' | 'A' | ... | 'F'

تمثِّل الثوابت الصحيحة القيم الصحيحة من خلال سلاسل تستخدم الترميز العشري أو السداسي العشري. ولا يمكن استخدام القواعد الأخرى، مثل النظام الثنائي أو الثماني. تنطبق القيود التالية على الثوابت الصحيحة:

• (ج1) is_wellformed(integer_literal, integer_type).

FloatConstant  ::= FloatLiteral ':' FloatType
FloatLiteral   ::= SignPart IntegerPart FractionalPart ScientificPart
                 | '0x' [HexadecimalDigits]
SignPart       ::= ['-' | '+']
IntegerPart    ::= DecimalDigits
FractionalPart ::= ['.' [DecimalDigits]]
ScientificPart ::= [('e' | 'E') ['-' | '+'] DecimalDigits]

تمثل الثوابت العائمة قيم النقطة العائمة من خلال السلاسل التي تستخدم الترميز العشري أو العلمي. بالإضافة إلى ذلك، يمكن استخدام الترميز السداسي عشري لتحديد وحدات البت الأساسية مباشرةً في تنسيق النقطة العائمة للنوع المقابل. تنطبق القيود التالية على الثوابت الكسورية:

• (ج1) في حال استخدام ترميز غير سداسي عشري، is_wellformed(float_literal, float_type).
• (C2) في حال استخدام الترميز السداسي العشري، size(hexadecimal_digits) = num_bits(float_type) / 4.

ComplexConstant ::= ComplexLiteral ':' ComplexType
ComplexLiteral  ::= '(' RealPart ',' ImaginaryPart ')'
RealPart        ::= FloatLiteral
ImaginaryPart   ::= FloatLiteral

تمثّل الثوابت المركّبة القيم المركّبة باستخدام قوائم بالجزء الحقيقي (يأتي أولاً) والجزء التخيّلي (يأتي ثانيًا). على سبيل المثال، يمثّل (1.0, 0.0) : complex<f32> الرمز1.0 + 0.0i، ويمثّل (0.0, 1.0) : complex<f32> الرمز0.0 + 1.0i. إنّ ترتيب تخزين هذه الأجزاء في الذاكرة يعتمد على طريقة التنفيذ. تنطبق القيود التالية على الثوابت المعقدة:

• (ج1) is_wellformed(real_part, complex_element_type(complex_type)).
• (ج2) is_wellformed(imaginary_part, complex_element_type(complex_type)).

TensorConstant ::= TensorLiteral ':' TensorType
TensorLiteral  ::= 'dense' '<' (DenseLiteral | ElementLiteral) '>'
DenseLiteral   ::= DenseDimension | DenseElements
DenseDimension ::= '[' [DenseLiteral {',' DenseLiteral}] ']'
DenseElements  ::= [ElementLiteral {',' ElementLiteral}]
ElementLiteral ::= BooleanLiteral | IntegerLiteral | FloatLiteral | ComplexLiteral

تمثّل ثوابت مصفوفة تانسور قيم مصفوفة تانسور باستخدام قوائم متداخلة محدّدة من خلال رمز NumPy. على سبيل المثال، يمثّل dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> قيمة مصفوفة باستخدام التعيين التالي من الفهارس إلى العناصر: {0, 0} => 1 و{0, 1} => 2 و{0, 2} => 3 و{1, 0} => 4 و{1, 1} => 5 {1, 2} => 6. إنّ ترتيب تخزين هذه العناصر في الذاكرة يتم تحديده حسب التنفيذ. تنطبق القيود التالية على الثوابت المصفوفية:

• (C1) has_syntax(tensor_literal, element_type(tensor_type))، حيث:
  • has_syntax(element_literal: Syntax, element_type: Type) = is_wellformed(element_literal, type).
  • has_syntax(tensor_literal: List, element_type: Type) = has_syntax(tensor_literal..., element_type).
• (C2) has_shape(tensor_literal, shape(tensor_type))، حيث:
  • has_shape(element_literal: Syntax, []) = true.
  • has_shape(tensor_literal: List, shape: List) = size(tensor_literal) = shape[0] and has_shape(tensor_literal..., shape[1:]).
  • بخلاف ذلك، false.

QuantizedTensorConstant ::= QuantizedTensorLiteral ':' QuantizedTensorType
QuantizedTensorLiteral  ::= 'dense' '<' (DenseLiteral | ElementLiteral) '>'

تمثّل ثوابت مصفوفات الكمّية المُعدَّلة قيم مصفوفات الكمّية المُعدَّلة باستخدام الترميز نفسه المُستخدَم في الثوابت المصفوفات، مع تحديد العناصر ثوابتًا لنوع تخزينها. تنطبق القيود التالية على الثوابت المتسلسلة المقسّمة:

• (ج1) has_syntax(quantized_tensor_literal, storage_type(quantized_tensor_type)).
• (ج2) has_shape(quantized_tensor_literal, shape(quantized_tensor_type)).

StringConstant  ::= StringLiteral
StringLiteral   ::= '"' {stringCharacter | escapeSequence} '"'
stringCharacter ::= all ASCII characters except '\00', '\01', ... '\1f' and '"'
escapeSequence  ::= '\' ('"' | '\' | 'n' | 't' | (hexadecimalDigit hexadecimalDigit))

تتألف السلاسل الثابتة من وحدات بايت محدّدة باستخدام أحرف ASCII وسلسلات الهروب. وهي لا تعتمد على ترميز معيّن، لذا فإنّ تفسير هذه الكلمات الثماني يتم تحديده حسب التنفيذ. تكون سلاسل الأحرف الثابتة من النوع string.

العمليات

abs

دلالات الألفاظ

تُجري عملية القيمة المطلقة لكل عنصر على مصفوفة operand وتُنشئ مصفوفة result . بناءً على نوع العنصر، نفِّذ ما يلي:

• بالنسبة إلى الأعداد الصحيحة الموجبة: عدد صحيح موجب
• بالنسبة إلى الأعداد العشرية العائمة: abs من IEEE-754
• بالنسبة إلى الأعداد المركبة: معامل عدد مركّب
• بالنسبة إلى الأنواع التي تم تحويلها إلى قيم عددية: dequantize_op_quantize(abs, operand, type(result)).

مدخلات

النواتج

القيود

• (ج1) shape(result) = shape(operand).
• (C2) يتم تعريف baseline_element_type(result) على النحو التالي:
  • complex_element_type(element_type(operand)) إذا is_complex(operand)
  • baseline_element_type(operand) بخلاف ذلك.

أمثلة

// %operand: [-2, 0, 2]
%result = "stablehlo.abs"(%operand) : (tensor<3xi32>) -> tensor<3xi32>
// %result: [2, 0, 2]

 مزيد من الأمثلة

إضافة

الدلالات

تُجري عملية إضافة عنصرية لفترتين lhs وrhs وتُنشئ result. بناءً على نوع العنصر، نفِّذ ما يلي:

• بالنسبة إلى القيم المنطقية: "أو" منطقي
• بالنسبة للأعداد الصحيحة: إضافة عدد صحيح.
• بالنسبة إلى الأعداد العشرية العائمة: addition من IEEE-754
• بالنسبة إلى الأعداد المركبة: جمع الأعداد المركبة
• بالنسبة إلى الأنواع الكَمية: dequantize_op_quantize(add, lhs, rhs, type(result)).

مدخلات

النواتج

القيود

• إذا كانت العملية تستخدم مصفوفات غير مُكثَّفة:
  • (ج1) type(lhs) = type(rhs) = type(result).
• إذا كانت العملية تستخدم مصفوفات كمية:
  • (ج2) is_quantized(lhs) and is_quantized(rhs) and is_quantized(result).
  • (ج3) storage_type(lhs) = storage_type(rhs) = storage_type(result).
  • (C4) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result).
  • (ج5) (is_per_axis_quantized(lhs) or is_per_axis_quantized(rhs)) = is_per_axis_quantized(result).
  • (C6) إذا كانت is_per_axis_quantized(lhs)، يتم عندها quantization_dimension(lhs) = quantization_dimension(result).
  • (C7) إذا كان is_per_axis_quantized(rhs)، فإنّ quantization_dimension(rhs) = quantization_dimension(result).

أمثلة

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.add"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[6, 8], [10, 12]]

 مزيد من الأمثلة

after_all

دلالات الألفاظ

يضمن تنفيذ العمليات التي تؤدي إلى إنشاء inputs قبل أي عمليات تعتمد على result. لا يؤدي تنفيذ هذه العملية إلى أيّ إجراء، بل إنّها متوفّرة فقط لإنشاء التبعيات للبيانات من result إلى inputs.

مدخلات

النواتج

أمثلة

// %input0: !stablehlo.token
// %input1: !stablehlo.token
%result = "stablehlo.after_all"(%input0, %input1) : (!stablehlo.token, !stablehlo.token) -> !stablehlo.token

مزيد من الأمثلة

all_gather

دلالات الألفاظ

ضمن كل مجموعة عمليات في شبكة عمليات StableHLO، يتم تسلسل قيم مصفوفات operands من كل عملية على طول all_gather_dim وإنشاء مصفوفات results.

تقسم العملية شبكة عملية StableHLO إلى process_groups التي يتم تعريفها على النحو التالي:

• cross_replica(replica_groups) إذا channel_id <= 0 and use_global_device_ids = false.
• cross_replica_and_partition(replica_groups) إذا channel_id > 0 and use_global_device_ids = false.
• flattened_ids(replica_groups) إذا channel_id > 0 and use_global_device_ids = true.

بعد ذلك، ضمن كل process_group:

• operands...@receiver = [operand@sender for sender in process_group] لكل receiver في process_group.
• results...@process = concatenate(operands...@process, all_gather_dim) لجميع process في process_group

مدخلات

النواتج

القيود

• (ج1) 0 <= all_gather_dim < rank(operands...).
• (ج2) is_unique(replica_groups).
• (C3) يتم تعريف size(replica_groups) على النحو التالي:
  • num_replicas في حال استخدام cross_replica.
  • num_replicas في حال استخدام cross_replica_and_partition
  • num_processes في حال استخدام flattened_ids
• (C4) 0 <= replica_groups < size(replica_groups).
• (ج5) إذا كان use_global_device_ids = true، فإنّ channel_id > 0.
• (C6) type(results...) = type(operands...) باستثناء:
  • dim(results..., all_gather_dim) = dim(operands..., all_gather_dim) * dim(process_groups, 1).

أمثلة

// num_replicas: 2
// num_partitions: 1
// %operand0@(0, 0): [[1, 2], [3, 4]]
// %operand0@(1, 0): [[5, 6], [7, 8]]
// %operand1@(0, 0): [[11, 12], [13, 14]]
// %operand1@(1, 0): [[15, 16], [17, 18]]
%result:2 = "stablehlo.all_gather"(%operand0, %operand1) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<2x2xi64>, tensor<2x2xi64>) -> (tensor<2x4xi64>, tensor<2x4xi64>)
// %result0@(0, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
// %result0@(1, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
// %result1@(0, 0): [[11, 12, 15, 16], [13, 14, 17, 18]]
// %result1@(1, 0): [[11, 12, 15, 16], [13, 14, 17, 18]]

 مزيد من الأمثلة

all_reduce

الدلالات

ضمن كل مجموعة عمليات في شبكة عمليات StableHLO، تُطبِّق دالة التقليل computation على قيم مصفوفات operands من كل عملية وتُنشئ مصفوفات results.

تقسم العملية شبكة عملية StableHLO إلى process_groups التي يتم تعريفها على النحو التالي:

• cross_replica(replica_groups) إذا channel_id <= 0 and use_global_device_ids = false.
• cross_replica_and_partition(replica_groups) إذا channel_id > 0 and use_global_device_ids = false.
• flattened_ids(replica_groups) إذا channel_id > 0 and use_global_device_ids = true.

بعد ذلك، ضمن كل process_group:

• results...@process[result_index] = exec(schedule) لبعض الشجرة الثنائية schedule حيث:
  • exec(node) = computation(exec(node.left), exec(node.right)).
  • exec(leaf) = leaf.value.
• schedule عبارة عن شجرة ثنائية معرفة تنفيذية يكون اجتيازها بالترتيب to_destination_type(operands...@process_group...[result_index], type(func_inputs(computation)[0])).

مدخلات

النواتج

القيود

• (ج1) is_unique(replica_groups).
• (C2) يتم تعريف size(replica_groups) على النحو التالي:
  • num_replicas في حال استخدام cross_replica
  • num_replicas في حال استخدام cross_replica_and_partition
  • num_processes في حال استخدام flattened_ids
• (ج3) 0 <= replica_groups < size(replica_groups).
• (C4) إذا كان use_global_device_ids = true، فإنّ channel_id > 0.
• (C5) computation من النوع (tensor<E>, tensor<E>) -> (tensor<E>) حيث is_promotable(element_type(operand), E).
• (C6) shape(results...) = shape(operands...).
• (C7) element_type(results...) = E.

أمثلة

// num_replicas: 2
// num_partitions: 1
// %operand0@(0, 0): [1, 2, 3, 4]
// %operand0@(1, 0): [5, 6, 7, 8]
// %operand1@(0, 0): [9, 10, 11, 12]
// %operand1@(1, 0): [13, 14, 15, 16]
%result:2 = "stablehlo.all_reduce"(%operand0, %operand0) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
    "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xi64>, tensor<4xi64>) -> (tensor<4xi64>, tensor<4xi64>)
// %result0@(0, 0): [6, 8, 10, 12]
// %result0@(1, 0): [6, 8, 10, 12]
// %result1@(0, 0): [22, 24, 26, 28]
// %result1@(1, 0): [22, 24, 26, 28]

مزيد من الأمثلة

all_to_all

الدلالات

ضمن كل مجموعة عمليات في شبكة عمليات StableHLO، يتم تقسيم قيم ملفّات operands التدرّجية على طول split_dimension إلى أجزاء، ويتم نثر الأجزاء المقسّمة بين العمليات، وتسلسل الأجزاء المتناثرة على طول concat_dimension، وإنشاء ملفات results التدرّجية. تقسم العملية شبكة عملية StableHLO إلى process_groups التي يتم تعريفها على النحو التالي:

• cross_replica(replica_groups) إذا channel_id <= 0
• cross_partition(replica_groups) إذا channel_id > 0.

بعد ذلك، ضمن كل process_group:

• split_parts...@sender = split(operands...@sender, split_count, split_dimension) لجميع sender في process_group
• scattered_parts...@receiver = [split_parts...@sender[receiver_index] for sender in process_group] حيث receiver_index = process_group.index(receiver).
• results...@process = concatenate(scattered_parts...@process, concat_dimension).

مدخلات

النواتج

القيود

• (ج1) 0 <= split_dimension < rank(operands...).
• (C2) dim(operands..., split_dimension) % split_count = 0.
• (ج3) 0 <= concat_dimension < rank(operands...).
• (C4) 0 < split_count.
• (ج5) is_unique(replica_groups).
• (C6) يتم تعريف size(replica_groups) على النحو التالي:
  • num_replicas في حال استخدام cross_replica.
  • num_partitions في حال استخدام cross_partition.
• (ج7) 0 <= replica_groups < size(replica_groups).
• (C8) dim(replica_groups, 1) = split_count.
• (C9) type(results...) = type(operands...) باستثناء، إذا split_dimension != concat_dimension:
  • dim(results..., split_dimension) = dim(operands..., split_dimension) / split_count.
  • dim(results..., concat_dimension) = dim(operands..., concat_dimension) * split_count.

أمثلة

// num_replicas: 2
// num_partitions: 1
// %operand1@(0, 0): [[1, 2, 3, 4],
//                    [5, 6, 7, 8]]
// %operand1@(1, 0): [[9, 10, 11, 12],
//                    [13, 14, 15, 16]]
// %operand2@(0, 0): [[17, 18, 19, 20],
//                    [21, 22, 23, 24]]
// %operand2@(1, 0): [[25, 26, 27, 28],
//                    [29, 30, 31, 32]]
%result:2 = "stablehlo.all_to_all"(%operand1, %operand2) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
} : (tensor<2x4xi64>, tensor<2x4xi64>) -> (tensor<4x2xi64>, tensor<4x2xi64>)
// %result#0@(0, 0): [[1, 2], [5, 6], [9, 10], [13, 14]]
// %result#0@(1, 0): [[3, 4], [7, 8], [11, 12], [15, 16]]
// %result#1@(0, 0): [[17, 18], [21, 22], [25, 26], [29, 30]]
// %result#1@(1, 0): [[19, 20], [23, 24], [27, 28], [31, 32]]

 مزيد من الأمثلة

و

الدلالات

تُنفِّذ عملية "و" بين مصفوفتَي lhs وrhs على مستوى العنصر الواحد، وتُنشئ مصفوفة result . بناءً على نوع العنصر، نفِّذ ما يلي:

• بالنسبة إلى القيم المنطقية: "الواو المنطقي"
• بالنسبة إلى الأعداد الصحيحة: استخدام AND على مستوى البت

مدخلات

النواتج

القيود

• (ج1) type(lhs) = type(rhs) = type(result).

أمثلة

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.and"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[1, 2], [3, 0]]

مزيد من الأمثلة

atan2

دلالات الألفاظ

تُنفِّذ عملية atan2 على كل عنصر من عناصر مصفوفة lhs وrhs، وتُنشئ مصفوفة result. بناءً على نوع العنصر، نفِّذ ما يلي:

• بالنسبة إلى الأعداد العشرية العائمة: atan2 من IEEE-754
• للأعداد المركبة: دالة atan2 المركّبة
• بالنسبة إلى الأنواع التي تم تحويلها إلى قيم عددية: dequantize_op_quantize(atan2, lhs, rhs, type(result)).

مدخلات

النواتج

القيود

• (ج1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result).

أمثلة

// %lhs: [0.0, 1.0, -1.0]
// %rhs: [0.0, 0.0, 0.0]
%result = "stablehlo.atan2"(%lhs, %rhs) : (tensor<3xf64>, tensor<3xf64>) -> tensor<3xf64>
// %result: [0.0, 1.57079637, -1.57079637] // [0.0, pi/2, -pi/2]

مزيد من الأمثلة

batch_norm_grad

الدلالات

تُحسِّب التدرّجات لعدّة مدخلات من batch_norm_training backpropagating من grad_output، وتُنشئ مصفوفات grad_operand وgrad_scale وgrad_offset . بشكل أكثر رسمية، يمكن التعبير عن هذه العملية على أنّها تحليل لعمليات StableHLO الحالية باستخدام بنية Python على النحو التالي:

def compute_sum(operand, feature_index):
  (sum,) = reduce(
      inputs=[operand],
      init_values=[constant(0, element_type(operand))],
      dimensions=[i for i in range(rank(operand)) if i != feature_index],
      body=lambda x, y: add(x, y))
  return sum

def compute_mean(operand, feature_index):
  sum = compute_sum(operand, feature_index)
  divisor = constant(size(operand) / dim(operand, feature_index),
                     element_type(operand))
  divisor_bcast = broadcast_in_dim(divisor, [], type(sum))
  return divide(sum, divisor_bcast)

def batch_norm_grad(operand, scale, mean, variance, grad_output, epsilon, feature_index):
  # Broadcast inputs to type(operand)
  scale_bcast = broadcast_in_dim(scale, [feature_index], type(operand))
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  variance_bcast = broadcast_in_dim(variance, [feature_index], type(operand))
  epsilon_bcast = broadcast_in_dim(constant(epsilon, element_type(operand)), [],
                                   type(operand))

  # Perform normalization using the provided `mean` and `variance`
  # Intermediate values will be useful for computing gradients
  centered_operand = subtract(operand, mean_bcast)
  stddev = sqrt(add(variance_bcast, epsilon_bcast))
  normalized_operand = divide(centered_operand, stddev)

  # Use the implementation from batchnorm_expander.cc in XLA
  # Temporary variables have exactly the same names as in the C++ code
  elements_per_feature = broadcast_in_dim(
      constant(divide(size(operand), dim(operand, feature_index)),
               element_type(grad_output)),
      [], type(operand))
  i1 = multiply(grad_output, elements_per_feature)
  i2 = broadcast_in_dim(
      compute_sum(grad_output, feature_index), [feature_index], type(operand))
  i3 = broadcast_in_dim(
      compute_sum(multiply(grad_output, centered_operand), feature_index),
      [feature_index], type(operand))
  i4 = multiply(i3, centered_operand)
  i5 = divide(i4, add(variance_bcast, epsilon_bcast))
  i6 = subtract(subtract(i1, i2), i5)

  grad_operand =
      multiply(divide(divide(scale_bcast, stddev), elements_per_feature), i6)
  grad_scale =
      compute_sum(multiply(grad_output, normalized_operand), feature_index)
  grad_offset = compute_sum(grad_output, feature_index)

  return grad_operand, grad_scale, grad_offset

بالنسبة إلى الأنواع المحدَّدة القيمة، يتم تنفيذ dequantize_batch_norm_grad_or_training_quantize(lambda operand, scale, mean, variance, grad_output: batch_norm_grad(operand, scale, mean, variance, grad_output, epsilon, feature_index), operand, scale, mean, variance, grad_output, type(grad_operand), type(grad_scale), type(feature_index)).

مدخلات

النواتج

القيود

• (ج1) 0 <= feature_index < rank(operand).
• (C2) تحتوي operand وscale وmean وvariance وgrad_output وgrad_operand grad_scale وgrad_offset على baseline_element_type نفسه.
• (C3) الشكل نفسه لكل من operand وgrad_output وgrad_operand
• (C4) scale وmean وvariance وgrad_scale وgrad_offset لها الشكل نفسه.
• (ج5) size(scale) = dim(operand, feature_index).

أمثلة

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %mean: [2.0, 3.0]
// %variance: [1.0, 1.0]
// %grad_output: [
//                [[0.1, 0.1], [0.1, 0.1]],
//                [[0.1, 0.1], [0.1, 0.1]]
//               ]
%grad_operand, %grad_scale, %grad_offset =
"stablehlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>,
     tensor<2x2x2xf64>) -> (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>)
// %grad_operand: [
//                 [[0.0, 0.0], [0.0, 0.0]],
//                 [[0.0, 0.0], [0.0, 0.0]]
//                ]
// %grad_scale:  [0.0, 0.0]
// %grad_offset: [0.4, 0.4]

batch_norm_inference

الدلالات

تعمل هذه الدالة على تسوية موتر operand على مستوى جميع السمات باستثناء السمة feature_index، وينتج عن ذلك موتّر result. بشكل أكثر رسمية، يمكن التعبير عن هذه العبارة كتحليل لعمليات StableHLO الحالية باستخدام بنية جملة Python على النحو التالي:

def batch_norm_inference(operand, scale, offset, mean, variance, epsilon, feature_index):
  # Broadcast inputs to shape(operand)
  scale_bcast = broadcast_in_dim(scale, [feature_index], type(operand))
  offset_bcast = broadcast_in_dim(offset, [feature_index], type(operand))
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  variance_bcast = broadcast_in_dim(variance, [feature_index], type(operand))
  epsilon_bcast = broadcast_in_dim(constant(epsilon, element_type(operand)), [],
                                   type(operand))

  # Perform normalization using the provided `mean` and `variance` instead of
  # computing them like `batch_norm_training` does.
  centered_operand = subtract(operand, mean_bcast)
  stddev = sqrt(add(variance_bcast, epsilon_bcast))
  normalized_operand = divide(centered_operand, stddev)
  return add(multiply(scale_bcast, normalized_operand), offset_bcast)

بالنسبة إلى الأنواع المحدَّدة القيمة، يتم تنفيذ dequantize_op_quantize(lambda operand, scale, offset, mean, variance: batch_norm_inference(operand, scale, offset, mean, variance, epsilon, feature_index), operand, scale, offset, mean, variance, type(result)).

مدخلات

النواتج

القيود

• (ج1) 0 <= feature_index < rank(operand).
• (ج2) تحتوي operand وscale وoffset وmean وvariance وresult على baseline_element_type نفسه.
• (ج3) size(scale) = dim(operand, feature_index).
• (C4) size(offset) = dim(operand, feature_index).
• (ج5) size(mean) = dim(operand, feature_index).
• (C6) size(variance) = dim(operand, feature_index).
• (ج7) baseline_type(operand) = baseline_type(result).

أمثلة

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %offset: [1.0, 1.0]
// %mean: [2.0, 3.0]
// %variance: [1.0, 1.0]
%result = "stablehlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>) -> tensor<2x2x2xf64>
// %result: [
//           [[0.0, 0.0], [2.0, 2.0]],
//           [[2.0, 2.0], [0.0, 0.0]]
//          ]

batch_norm_training

الدلالات

تُحسِب هذه الدالة المتوسط والتباين في جميع السمات باستثناء سمة feature_index وتُطبِّق التطبيع على مصفوفة operand، ما يؤدي إلى إنشاء مصفوفات output وbatch_mean وbatch_var. بشكل أكثر رسمية، يمكن التعبير عن هذه العملية على أنّها تقسيم إلى عمليات StableHLO الحالية باستخدام بنية Python على النحو التالي:

def compute_mean(operand, feature_index):
  (sum,) = reduce(
      inputs=[operand],
      init_values=[constant(0, element_type(operand))],
      dimensions=[i for i in range(rank(operand)) if i != feature_index],
      body=lambda x, y: add(x, y))
  divisor = constant(size(operand) / dim(operand, feature_index),
                     element_type(operand))
  divisor_bcast = broadcast_in_dim(divisor, [], type(sum))
  return divide(sum, divisor_bcast)

def compute_variance(operand, feature_index):
  mean = compute_mean(operand, feature_index)
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  centered_operand = subtract(operand, mean_bcast)
  return compute_mean(mul(centered_operand, centered_operand), feature_index)

def batch_norm_training(operand, scale, offset, epsilon, feature_index):
  mean = compute_mean(operand, feature_index)
  variance = compute_variance(operand, feature_index)
  return batch_norm_inference(operand, scale, offset, mean, variance, epsilon,
                              feature_index),
         mean, variance

بالنسبة إلى الأنواع الكَمية، يتم تنفيذ dequantize_batch_norm_grad_or_training_quantize(lambda operand, scale, offset: batch_norm_training(operand, scale, offset, epsilon, feature_index), operand, scale, offset, type(output), type(batch_mean), type(batch_var)).

مدخلات

النواتج

القيود

• (ج1) 0 <= feature_index < rank(operand).
• (C2) operand وscale وoffset وbatch_mean وbatch_var وoutput لديهم baseline_element_type نفسها.
• (ج3) size(scale) = dim(operand, feature_index).
• (C4) size(offset) = dim(operand, feature_index).
• (ج5) size(batch_mean) = dim(operand, feature_index).
• (C6) size(batch_var) = dim(operand, feature_index).
• (ج7) baseline_type(output) = baseline_type(operand).

أمثلة

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %offset: [1.0, 1.0]
%output, %batch_mean, %batch_var = "stablehlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>) ->
    (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>)
// %output: [
//           [[0.0, 0.0], [2.0, 2.0]],
//           [[2.0, 2.0], [0.0, 0.0]]
//          ]
// %batch_mean: [2.0, 3.0]
// %batch_var: [1.0, 1.0]

bitcast_convert

دلالات الألفاظ

تُنفِّذ عملية تحويل بت على مصفوفة operand وتُنشئ مصفوفة result حيث تتم إعادة تفسير بتات مصفوفة operand بالكامل باستخدام نوع مصفوفة result.

وبشكل رسمي، استنادًا إلى E = element_type(operand) وE' = element_type(result) وR = rank(operand):

• إذا num_bits(E') < num_bits(E)، bits(result[i0, ..., iR-1, :]) = bits(operand[i0, ..., iR-1]).
• إذا num_bits(E') > num_bits(E)، bits(result[i0, ..., iR-2]) = bits(operand[i0, ..., iR-2, :]).
• إذا كان num_bits(E') = num_bits(E)، bits(result[i0, ..., iR-1]) = bits(operand[i0, ..., iR-1]).

تُعرِض دالة bits تمثيلًا في الذاكرة لقيمة معيّنة، ويكون سلوكها محددًا من خلال التنفيذ لأنّ التمثيل الدقيق للمتسلسلات العقدية يكون محددًا من خلال التنفيذ، والتمثيل الدقيق لأنواع العناصر يكون محددًا من خلال التنفيذ أيضًا.

مدخلات

النواتج

القيود

• (ج1) بالنظر إلى E = is_quantized(operand) ? storage_type(operand) : element_type(operand) وE' = is_quantized(result) ? storage_type(result) : element_type(result) وR = rank(operand):
  • إذا num_bits(E') = num_bits(E)، shape(result) = shape(operand).
  • إذا num_bits(E') < num_bits(E):
  • rank(result) = R + 1.
  • dim(result, i) = dim(operand, i) لجميع 0 <= i < R
  • dim(result, R) * num_bits(E') = num_bits(E).
  • إذا num_bits(E') > num_bits(E):
  • rank(result) = R - 1.
  • dim(result, i) = dim(operand, i) لجميع 0 <= i < R
  • dim(operand, R - 1) * num_bits(E) = num_bits(E').
• (C2) إذا كان is_complex(operand) or is_complex(result)، ثم is_complex(operand) and is_complex(result).

أمثلة

// %operand: 0x0123456789ABCDEF
%result = "stablehlo.bitcast_convert"(%operand) : (tensor<f64>) -> tensor<4xf16>
// %result: [0xCDEF, 0x89AB, 0x4567, 0x0123] // little-endian representation

 مزيد من الأمثلة

broadcast_in_dim

الدلالات

لتوسيع أبعاد و/أو ترتيب مُتّصِل الإدخال عن طريق تكرار البيانات في موجِّه operand وينتج موجِّه result. بشكل رسمي، result[result_index] = operand[operand_index] في ما يتعلق بجميع d في axes(operand):

• operand_index[d] = 0 إذا dim(operand, d) = 1
• operand_index[d] = result_index[broadcast_dimensions[d]] بخلاف ذلك

مدخلات

النواتج

القيود

• (C1) يتم الحصول على element_type(result) من خلال:
  • element_type(operand)، إذا !is_per_axis_quantized(operand)
  • element_type(operand) باستثناء أنّ quantization_dimension(operand) وscales(operand) وzero_points(operand) قد يختلفان عن quantization_dimension(result) وscales(result) وzero_points(result). بخلاف ذلك.
• (ج2) size(broadcast_dimensions) = rank(operand).
• (ج3) 0 <= broadcast_dimensions < rank(result).
• (C4) is_unique(broadcast_dimensions).
• (ج5) بالنسبة إلى جميع d في axes(operand):
  • dim(operand, d) = 1 أو
  • dim(operand, d) = dim(result, broadcast_dimensions[d]).
• (C6) إذا كان is_per_axis_quantized(result):
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)].
  • إذا dim(operand, quantization_dimension(operand)) = 1، ثم scales(result)[i] = scales(operand)[0] and zero_points(result)[i] = zero_points(operand)[0] for i in range(dim(result, quantization_dimension(result))).

أمثلة

// %operand: [
//            [1, 2, 3]
//           ]
%result = "stablehlo.broadcast_in_dim"(%operand) {
  broadcast_dimensions = array<i64: 2, 1>
} : (tensor<1x3xi32>) -> tensor<2x3x2xi32>
// %result: [
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ],
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ]
//          ]

 مزيد من الأمثلة

حافظة

الدلالات

تُنشئ هذه الدالة الإخراج من تنفيذ دالة واحدة بالضبط من branches استنادًا إلى قيمة index. بشكل رسمي، result = selected_branch() حيث:

• selected_branch = branches[index] إذا 0 <= index < size(branches)
• selected_branch = branches[-1] بخلاف ذلك.

مدخلات

النواتج

القيود

• (ج1) 0 < size(branches).
• (ج2) input_types(branches...) = [].
• (C3) same(output_types(branches...)):
• (C4) type(results...) = output_types(branches[0]).

أمثلة

// %index: -1
// %result_branch0: [0, 0]
// %result_branch1: [1, 1]
%result0, %result1 = "stablehlo.case"(%index) ({
  "stablehlo.return"(%result_branch0, %result_branch0) : (tensor<2xi64>, tensor<2xi64>) -> ()
}, {
  "stablehlo.return"(%result_branch1, %result_branch1) : (tensor<2xi64>, tensor<2xi64>) -> ()
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)
// %result0: [1, 1]
// %result1: [1, 1]

 مزيد من الأمثلة

cbrt

الدلالات

تُجري عملية الجذر التكعيبي لكل عنصر في مصفوفة operand وتُنشئ مصفوفة result. حسب نوع العنصر، يتم إجراء ما يلي:

• بالنسبة إلى الأعداد العشرية العائمة: rootn(x, 3) من IEEE-754
• بالنسبة إلى الأعداد المركبة: الجذر التكعيبي المركب
• بالنسبة إلى الأنواع المحوَّلة إلى قيم عددية: dequantize_op_quantize(cbrt, operand, type(result))

مدخلات

النواتج

القيود

• (ج1) baseline_type(operand) = baseline_type(result).

أمثلة

// %operand: [0.0, 1.0, 8.0, 27.0]
%result = "stablehlo.cbrt"(%operand) : (tensor<4xf64>) -> tensor<4xf64>
// %result: [0.0, 1.0, 2.0, 3.0]

 مزيد من الأمثلة

ceil

الدلالات

يؤدي هذا الإجراء إلى إنشاء تسلسل هرمي من ناحية العناصر في متسابق operand وينتج عنه متسابق result. لتنفيذ عملية roundToIntegralTowardPositive من مواصفات IEEE-754. بالنسبة إلى الأنواع المحدَّدة القيمة، يتم تنفيذ dequantize_op_quantize(ceil, operand, type(result)).

مدخلات

النواتج

القيود

• (ج1) baseline_type(operand) = baseline_type(result).

أمثلة

// %operand: [-0.8166, -0.2530, 0.2530, 0.8166, 2.0]
%result = "stablehlo.ceil"(%operand) : (tensor<5xf32>) -> tensor<5xf32>
// %result: [-0.0, -0.0, 1.0, 1.0, 2.0]

مزيد من الأمثلة

cholesky

الدلالات

تحسب هذه الدالة عملية تقسيم Cholesky لمجموعة من المصفوفات.

وبشكل أكثر رسمًا، بالنسبة إلى جميع i في index_space(result)، يشير result[i0, ..., iR-3, :, :] إلى انحلال كلسكي بقيمة a[i0, ..., iR-3, :, :]، في شكل مصفوفة مثلث صغيرة (إذا كانت lower هي true) أو مصفوفة مثلثية أعلى (إذا كانت lower هي false). إنّ قيم الإخراج في المثلث المقابل، أي المثلث العلوي الصارم أو المثلث السفلي الصارم وفقًا لذلك، يتم تحديدها من خلال التنفيذ.

إذا كان هناك i حيث تكون مصفوفة الإدخال ليست مصفوفة هيرميتية موجبة القيمة، يكون السلوك غير محدّد.

بالنسبة إلى الأنواع المحدَّدة القيمة، يتم تنفيذ dequantize_op_quantize(lambda operand: cholesky(operand, lower), a, type(result)).

مدخلات

النواتج

القيود

• (ج1) baseline_type(a) = baseline_type(result).
• (ج2) 2 <= rank(a).
• (ج3) dim(a, -2) = dim(a, -1).

أمثلة

// %a: [
//      [1.0, 2.0, 3.0],
//      [2.0, 20.0, 26.0],
//      [3.0, 26.0, 70.0]
//     ]
%result = "stablehlo.cholesky"(%a) {
  lower = true
} : (tensor<3x3xf32>) -> tensor<3x3xf64>
// %result: [
//           [1.0, 0.0, 0.0],
//           [2.0, 4.0, 0.0],
//           [3.0, 5.0, 6.0]
//          ]

مشبك

الدلالات

تُثبِّت كل عنصر من مصفوفة operand بين الحد الأدنى والحد الأقصى لقيمة ، وتُنشئ مصفوفة result. بشكل أكثر رسمية، result[result_index] = minimum(maximum(operand[result_index], min_element), max_element)، حيث min_element = rank(min) = 0 ? min[] : min[result_index]، max_element = rank(max) = 0 ? max[] : max[result_index]. بالنسبة إلى الأنواع الكَمية، ينفِّذ dequantize_op_quantize(clamp, min, operand, max, type(result)).

ويتضمّن فرض ترتيب الأعداد المركّبة دلالات مدهشة، لذلك نخطّط في المستقبل لإلغاء إتاحة الأعداد المركّبة لهذه العملية (#560).

مدخلات

النواتج

القيود

• (ج1) rank(min) = 0 or shape(min) = shape(operand).
• (ج2) rank(max) = 0 or shape(max) = shape(operand).
• (ج3) baseline_element_type(min) = baseline_element_type(operand) = baseline_element_type(max).
• (C4) baseline_type(operand) = baseline_type(result).

أمثلة

// %min: [5, 10, 15]
// %operand: [3, 13, 23]
// %max: [10, 15, 20]
%result = "stablehlo.clamp"(%min, %operand, %max) : (tensor<3xi32>, tensor<3xi32>, tensor<3xi32>) -> tensor<3xi32>
// %result: [5, 13, 20]

 مزيد من الأمثلة

collective_broadcast

دلالات الألفاظ

ضمن كل مجموعة عمليات في شبكة عمليات StableHLO، أرسِل قيمة مصفوفة operand من العملية المصدر إلى العمليات المستهدَفة وأطلِق مصفوفة result.

تقسم هذه العملية شبكة عملية StableHLO إلى process_groups التي يتم تعريفها على النحو التالي:

• cross_replica(replica_groups) إذا channel_id <= 0
• cross_partition(replica_groups) إذا channel_id > 0

بعد ذلك، يتم احتساب result@process على النحو التالي:

• operand@process_groups[i, 0] إذا كان هناك i بحيث تكون العملية في process_groups[i].
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) وإلا.

مدخلات

النواتج

القيود

• (ج1) is_unique(replica_groups).
• (C2) 0 <= replica_groups < N حيث يتم تعريف N على النحو التالي:
  • num_replicas في حال استخدام cross_replica
  • num_partitions في حال استخدام cross_partition
• (ج3) type(result) = type(operand).

أمثلة

// num_replicas: 4
// num_partitions: 1
// %operand@(0, 0): [[1, 2]]
// %operand@(1, 0): [[3, 4]]
// %operand@(2, 0): [[5, 6]]
// %operand@(3, 0): [[7, 8]]
%result = "stablehlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[2, 1]]> : tensor<1x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor1x2xi64>) -> tensor<1x2xi64>
// %result@(0, 0): [[0, 0]]
// %result@(1, 0): [[5, 6]]
// %result@(2, 0): [[5, 6]]
// %result@(3, 0): [[0, 0]]

collective_permute

الدلالات

ضمن كل مجموعة عمليات في شبكة عمليات StableHLO، تُرسِل قيمة مصفوفة operand من العملية المصدر إلى العملية الهدف وتُنشئ مصفوفة result.

تقسم العملية شبكة عملية StableHLO إلى process_groups التي يتم تعريفها على النحو التالي:

• cross_replica(source_target_pairs) إذا channel_id <= 0
• cross_partition(source_target_pairs) إذا channel_id > 0

بعد ذلك، يتم احتساب result@process على النحو التالي:

• operand@process_groups[i, 0]، إذا كان هناك i بحيث process_groups[i, 1] = process.
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) بخلاف ذلك

مدخلات

النواتج

القيود

• (ج1) dim(source_target_pairs, 1) = 2.
• (ج2) is_unique(source_target_pairs[:, 0]).
• (ج3) is_unique(source_target_pairs[:, 1]).
• (C4) 0 <= source_target_pairs < N، حيث يتم تعريف N على النحو التالي:
  • num_replicas في حال استخدام cross_replica.
  • num_partitions في حال استخدام cross_partition
• (C5) type(result) = type(operand).

أمثلة

// num_replicas: 3
// num_partitions: 1
// %operand@(0, 0): [[1, 2], [3, 4]]
// %operand@(1, 0): [[5, 6], [7, 8]]
// %operand@(2, 0): [[9, 10], [11, 12]]
%result = "stablehlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor<2x2xi64>) -> tensor<2x2xi64>
//
// %result@(0, 0): [[0, 0], [0, 0]]
// %result@(1, 0): [[1, 2], [3, 4]]
// %result@(2, 0): [[5, 6], [7, 8]]

 مزيد من الأمثلة

مقارنة

الدلالات

تُجري مقارنة بين عناصر مصفوفتَي lhs وrhs وفقًا ل comparison_direction وcompare_type، وتُنشئ مصفوفة result.

تملك قيمتَي comparison_direction وcompare_type الدلالات التالية:

بالنسبة إلى أنواع العناصر المنطقية والصحيحة:

• EQ: lhs = rhs.
• NE: lhs != rhs.
• GE: lhs >= rhs.
• GT: lhs > rhs.
• LE: lhs <= rhs.
• LT: lhs < rhs.

بالنسبة إلى أنواع العناصر ذات النقطة العائمة التي تحتوي على compare_type = FLOAT، تنفِّذ عملية المعالجة عمليات IEEE-754 التالية:

• EQ: compareQuietEqual.
• NE: compareQuietNotEqual.
• GE: compareQuietGreaterEqual.
• GT: compareQuietGreater.
• LE: compareQuietLessEqual.
• LT: compareQuietLess.

بالنسبة إلى أنواع العناصر ذات النقطة العائمة التي تحتوي على compare_type = TOTALORDER، يستخدم op مزيجًا من عمليتَي totalOrder وcompareQuietEqual من IEEE-754.

بالنسبة إلى أنواع العناصر المعقّدة، يتم إجراء مقارنة معجمية لأزواج (real, imag) باستخدام الترميزَين comparison_direction وcompare_type المقدَّمَين. إنّ فرض ترتيب على الأرقام المعقدة يتضمن دلالات مفاجئة، لذلك نخطّط في المستقبل لإزالة إمكانية استخدام الأرقام المعقدة عندما يكون comparison_direction هو GE أو GT أو LE أو LT (‎#560).

بالنسبة إلى الأنواع الكَمية. يتم تنفيذ الإجراء dequantize_compare(lhs, rhs, comparison_direction).

مدخلات

النواتج

القيود

• (ج1) baseline_element_type(lhs) = baseline_element_type(rhs).
• (ج2) shape(lhs) = shape(rhs) = shape(result).
• (C3) يتم تعريف compare_type على النحو التالي:
  • SIGNED إذا is_signed_integer(element_type(lhs))
  • UNSIGNED إذا is_unsigned_integer(element_type(lhs)) or is_boolean(element_type(lhs))
  • FLOAT أو TOTALORDER إذا is_float(element_type(lhs))
  • FLOAT إذا is_complex(element_type(lhs)).

أمثلة

// %lhs: [1.0, 3.0]
// %rhs: [1.1, 2.9]
%result = "stablehlo.compare"(%lhs, %rhs) {
  comparison_direction = #stablehlo<comparison_direction LT>,
  compare_type = #stablehlo<comparison_type FLOAT>
} : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>
// %result: [true, false]

 مزيد من الأمثلة

معقّد

الدلالات

تُجري عملية تحويل على مستوى العنصر إلى قيمة معقدة من زوج من القيم الحقيقية والتخييلية، lhs وrhs، وتُنشئ مصفوفة result.

مدخلات

النواتج

القيود

• (ج1) type(lhs) = type(rhs).
• (ج2) shape(result) = shape(lhs).
• (C3) element_type(result) له النوع complex<E> حيث يكون E = element_type(lhs).

أمثلة

// %lhs: [1.0, 3.0]
// %rhs: [2.0, 4.0]
%result = "stablehlo.complex"(%lhs, %rhs) : (tensor<2xf64>, tensor<2xf64>) -> tensor<2xcomplex<f64>>
// %result: [(1.0, 2.0), (3.0, 4.0)]

 مزيد من الأمثلة

مُركّب

دلالات الألفاظ

تُغلِّف عملية مكوّنة من عمليات StableHLO أخرى، ويأخذ العنصران inputs وcomposite_attributes وينتجان results. يتم تنفيذ دلالات العملية من خلال السمة decomposition. يمكن استبدال عملية composite بتحليلها بدون تغيير دلالات البرنامج. في الحالات التي لا يوفّر فيها تضمين عملية التقسيم معنى op نفسه، يُفضّل استخدام custom_call.

يُستخدَم الحقل version (التلقائي هو 0) للإشارة إلى الحالات التي تتغيّر فيها الدلالات المركبة.

مدخلات

النواتج

القيود

• (C1) is_namespaced_op_name(name)
• (ج2) is_defined_in_parent_scope(decomposition)
• (C3) types(inputs...) == input_types(decomposition)
• (ج4) types(results...) == output_types(decomposition)

أمثلة

%results = "stablehlo.composite"(%input0, %input1) {
  name = "my_namespace.my_op",
  composite_attributes = {
    my_attribute = "my_value"
  },
  decomposition = @my_op,
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

 مزيد من الأمثلة

إنشاء تسلسل

دلالات الألفاظ

تُجمِّع inputs على طول سمة dimension بالترتيب نفسه للوسيطات المُعطاة، وتُنشئ مصفوفة result. بشكل أكثر رسمية، result[i0, ..., id, ..., iR-1] = inputs[k][i0, ..., kd, ..., iR-1]، حيث:

1. id = d0 + ... + dk-1 + kd.
2. تساوي d dimension، وd0، و... هي أحجام السمة d لجدول inputs.

مدخلات

النواتج

القيود

• (ج1) same(element_type(inputs...)).
• (C2) same(shape(inputs...)) باستثناء dim(inputs..., dimension).
• (ج3) 0 < size(inputs).
• (C4) 0 <= dimension < rank(inputs[0]).
• (ج5) element_type(result) = element_type(inputs[0]).
• (C6) shape(result) = shape(inputs[0]) باستثناء:
  • dim(result, dimension) = dim(inputs[0], dimension) + ....

أمثلة

// %input0: [[1, 2], [3, 4], [5, 6]]
// %input1: [[7, 8]]
%result = "stablehlo.concatenate"(%input0, %input1) {
  dimension = 0 : i64
} : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>
// %result: [[1, 2], [3, 4], [5, 6], [7, 8]]

مزيد من الأمثلة

الثابت

دلالات الألفاظ

تُنشئ مصفوفة output من عدد ثابت value.

مدخلات

النواتج

القيود

• (ج1) type(value) = type(output).

أمثلة

%output = "stablehlo.constant"() {
  value = dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>
} : () -> tensor<2x2xf32>
// %output: [[0.0, 1.0], [2.0, 3.0]]

 مزيد من الأمثلة

إجراء إحالة ناجحة

الدلالات

تُجري عملية تحويل على مستوى العنصر من نوع عنصر إلى آخر على مصفوفة operand وتُنشئ مصفوفة result.

بالنسبة إلى الإحالات الناجحة boolean-to-any-supported-type، يتم تحويل القيمة false إلى صفر، ويتم تحويل القيمة true إلى واحد. بالنسبة إلى عمليات التحويل any-supported-type-to-boolean، يتم تحويل القيمة صفر إلى false، ويتم تحويل القيم غير الصفرية إلى true. اطّلِع أدناه على كيفية عمل ذلك مع الأنواع المعقّدة.

بالنسبة إلى عمليات التحويل التي تتضمّن تحويل عدد صحيح إلى عدد صحيح أو تحويل عدد صحيح إلى عدد عشري أو تحويل عدد عشري إلى عدد عشري، إذا كان بالإمكان تمثيل القيمة المصدر بدقة في نوع الوجهة، تكون قيمة النتيجة هي هذا التمثيل الدقيق. بخلاف ذلك، سيتم تحديد السلوك لاحقًا (#180).

بالنسبة إلى الإحالات الناجحة التي تتضمّن floating-point-to-integer، يتم اقتطاع الجزء الكسري. إذا تعذّر تمثيل القيمة المقتطعة في نوع الوجهة، يكون السلوك غير محدّد (#180).

إنّ التحويل الذي يتضمن الأعداد المركّبة إلى الأعداد المركّبة يتّبع السلوك نفسه لعمليات التحويل التي تتضمن الأعداد الكسورية العائمة إلى الأعداد الكسورية العائمة لتحويل الأجزاء الحقيقية والأجزاء الخيالية.

بالنسبة إلى عمليات التحويل من نوع معقد إلى أي نوع آخر وأي نوع آخر إلى نوع معقد، يتم تجاهل القيمة الخيالية للمصدر أو يتم تعيين القيمة الخيالية للوجهة على صفر، على التوالي. تتبع عملية تحويل الجزء الحقيقي عمليات تحويل النقطة العائمة.

من حيث المبدأ، يمكن أن تعبِّر هذه العملية عن التحليل الكمي (التحويل من عشرات الكميات إلى عشرات الكميات العادية) والقياس الكمي (التحويل من موتّرات عادية إلى موتّرات كَمية) وإعادة الكمي (التحويل بين العشرات الكمي)، ولكننا لدينا في الوقت الحالي عمليات مخصّصة لذلك - uniform_dequantize لحالة الاستخدام الأولى وuniform_quantize لحالات الاستخدام الثانية والثالثة. في المستقبل، قد يتم دمج هاتين العملتين في convert (#1576).

مدخلات

النواتج

القيود

• (ج1) shape(operand) = shape(result).

أمثلة

// %operand: [-1, 0, 1]
%result = "stablehlo.convert"(%operand) : (tensor<3xi64>) -> tensor<3xcomplex<f64>>
// %result: [(-1.0, 0.0), (0.0, 0.0), (1.0, 0.0)]

 مزيد من الأمثلة

الالتفاف

الدلالات

تُحتسب حواصل الضرب النقطي بين نوافذ lhs وشرائح rhs وتُنشئ result. يوضِّح الرسم البياني التالي كيفية احتساب العناصر في result من lhs وrhs باستخدام مثال محدّد.

بشكل أكثر رسمية، ننصحك بإعادة صياغة الإدخالات من حيث lhs لكي تتمكن من التعبير عن نوافذ lhs:

• lhs_window_dimensions = lhs_shape(dim(lhs, input_batch_dimension), dim(rhs, kernel_spatial_dimensions), dim(lhs, input_feature_dimension)).
• lhs_window_strides = lhs_shape(1, window_strides, 1).
• lhs_padding = lhs_shape([0, 0], padding, [0, 0]).
• lhs_base_dilations = lhs_shape(1, lhs_dilation, 1).
• lhs_window_dilations = lhs_shape(1, rhs_dilation, 1).

تستخدم عملية إعادة الصياغة هذه الدوال المساعدة التالية:

• lhs_shape(n, hw, c) = permute([n] + hw + [c], [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension]).
• result_shape(n1, hw, c1) = permute([n1] + hw + [c1], [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension]).
• permute([j0, j1, ..., jR-1], permutation) = [i0, i1, ..., iR-1] حيث j[d] = i[permutation[d]].

إذا كانت feature_group_count = 1 وbatch_group_count = 1، يتم تحصيلها لجميع output_spatial_index في index_space(dim(result, output_spatial_dimensions...))، result[result_shape(:, output_spatial_index, :)] = dot_product حيث:

• padding_value = constant(0, element_type(lhs)).
• padded_lhs = pad(lhs, padding_value, lhs_padding[:, 0], lhs_padding[:, 1], lhs_base_dilations - 1).
• lhs_window_start = lhs_shape(0, output_spatial_index, 0) * lhs_window_strides.
• lhs_window = slice(padded_lhs, lhs_window_start, lhs_window_start + lhs_window_dimensions, lhs_window_dilations).
• reversed_lhs_window = reverse(lhs_window, [input_spatial_dimensions[dim] for dim in range(size(window_reversal)) if window_reversal[dim] = true]). يبدو أنّ هذه الميزة غير مستخدَمة، لذا ننوي إزالتها في المستقبل (‎#1181).
• dot_product = dot_general(reversed_lhs_window, rhs, lhs_batching_dimensions=[], lhs_contracting_dimensions=input_spatial_dimensions + [input_feature_dimension], rhs_batching_dimensions=[], rhs_contracting_dimensions=kernel_spatial_dimensions + [kernel_input_feature_dimension]).

إذا feature_group_count > 1:

• lhses = split(lhs, feature_group_count, input_feature_dimension).
• rhses = split(rhs, feature_group_count, kernel_output_feature_dimension).
• results... = convolution(lhses..., rhses..., ..., feature_group_count=1, ...).
• result = concatenate(results, output_feature_dimension).

إذا batch_group_count > 1:

• lhses = split(lhs, batch_group_count, input_batch_dimension).
• rhses = split(rhs, batch_group_count, kernel_output_feature_dimension).
• results... = convolution(lhses..., rhses..., ..., batch_group_count=1, ...).
• result = concatenate(results, output_feature_dimension).

بالنسبة إلى الأنواع المحدَّدة القيمة، يتم تنفيذ dequantize_op_quantize( lambda lhs, rhs: convolution(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, window_reversal, input_batch_dimension, input_feature_dimension, input_spatial_dimensions, kernel_input_feature_dimension, kernel_output_feature_dimension, kernel_spatial_dimensions, output_batch_dimension, output_feature_dimension, output_spatial_dimensions, feature_group_count, batch_group_count, precision_config), lhs, rhs, type(result)).

بالنسبة إلى الأنواع الكمية المختلطة، تحقّق قيمة hybrid_dequantize_then_op( lambda lhs, rhs: convolution(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, window_reversal, input_batch_dimension, input_feature_dimension, input_spatial_dimensions, kernel_input_feature_dimension, kernel_output_feature_dimension, kernel_spatial_dimensions, output_batch_dimension, output_feature_dimension, output_spatial_dimensions, feature_group_count, batch_group_count, precision_config), lhs, rhs).

مدخلات

النواتج

القيود

• (ج1) N = rank(lhs) = rank(rhs).
• (C2) size(window_strides) = N - 2.
• (ج3) 0 < window_strides.
• (C4) shape(padding) = [N - 2, 2].
• (ج5) size(lhs_dilation) = N - 2.
• (C6) 0 < lhs_dilation.
• (ج7) size(rhs_dilation) = N - 2.
• (ج8) 0 < rhs_dilation.
• (ج9) size(window_reversal) = N - 2.
• (C10) dim(lhs, input_batch_dimension) % batch_group_count = 0.
• (C11) dim(lhs, input_feature_dimension) % feature_group_count = 0.
• (C12) size(input_spatial_dimensions) = N - 2.
• (C13) بالنظر إلى input_dimensions = [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension]:
  • is_unique(input_dimensions).
  • 0 <= input_dimensions < N.
• (C14) dim(rhs, kernel_input_feature_dimension) = dim(lhs, input_feature_dimension) / feature_group_count.
• (C15) dim(rhs, kernel_output_feature_dimension) % batch_group_count = 0.
• (C16) dim(rhs, kernel_output_feature_dimension) % feature_group_count = 0.
• (C17) size(kernel_spatial_dimensions) = N - 2.
• (C18) بالنظر إلى kernel_dimensions = kernel_spatial_dimensions + [kernel_input_feature_dimension] + [kernel_output_feature_dimension]:
  • is_unique(kernel_dimensions).
  • 0 <= kernel_dimensions < N.
• (C19) size(output_spatial_dimensions) = N - 2.
• (C20) بالنظر إلى output_dimensions = [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension]:
  • is_unique(output_dimensions).
  • 0 <= output_dimensions < N.
• (C21) 0 < feature_group_count.
• (C22) 0 < batch_group_count.
• (C23) feature_group_count = 1 or batch_group_count = 1.
• (C24) size(precision_config) = 2.
• (C25) يتم تعريف dim(result, result_dim) على النحو التالي:
  • dim(lhs, input_batch_dimension) / batch_group_count إذا result_dim = output_batch_dimension
  • dim(rhs, kernel_output_feature_dimension) إذا result_dim = output_feature_dimension
  • num_windows في الحالات الأخرى، حيث:
  • output_spatial_dimensions[spatial_dim] = result_dim.
  • lhs_dim = input_spatial_dimensions[spatial_dim].
  • rhs_dim = kernel_spatial_dimensions[spatial_dim].
  • dilated_input_shape[lhs_dim] = dim(lhs, lhs_dim) = 0 ? 0 : (dim(lhs, lhs_dim) - 1) * lhs_dilation[spatial_dim] + 1.
  • padded_input_shape[lhs_dim] = padding[spatial_dim, 0] + dilated_input_shape[lhs_dim] + padding[spatial_dim, 1].
  • dilated_window_shape[lhs_dim] = dim(rhs, rhs_dim) = 0 ? 0 : (dim(rhs, rhs_dim) - 1) * rhs_dilation[spatial_dim] + 1.
  • is_empty_window[lhs_dim] = padded_input_shape[lhs_dim] = 0 || dilated_window_shape[lhs_dim] > padded_input_shape[lhs_dim].
  • num_windows = is_empty_window[lhs_dim] ? 0 : floor((padded_input_shape[lhs_dim] - dilated_window_shape[lhs_dim]) / window_strides[spatial_dim]) + 1.
• (C26) rank(result) = N.
• إذا كانت العملية تستخدم مصفوفات غير مُكثَّفة:
  • (C27) element_type(lhs) = element_type(rhs) = element_type(result).
• إذا كانت العملية تستخدم موتّرات كميّة:
  • (C28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs).
  • (C29) إذا كانت is_per_axis_quantized(rhs)، ثم quantization_dimension(rhs) = kernel_output_feature_dimension.
  • (C30) إذا كانت السمة is_per_axis_quantized(result)، يتم عندها quantization_dimension(result) = output_feature_dimension.
  • إذا is_quantized(lhs):
  • (C31) storage_type(lhs) = storage_type(rhs).
  • (C32) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result).
  • (C33) إذا كان is_per_tensor_quantized(rhs)، ثم is_per_tensor_quantized(result).
  • إذا !is_quantized(lhs):
  • (C34) element_type(lhs) = expressed_type(rhs) = element_type(result).

أمثلة

// %lhs: [[
//        [
//          [1], [2], [5], [6]
//        ],
//        [
//          [3], [4], [7], [8]
//        ],
//        [
//          [10], [11], [14], [15]
//        ],
//        [
//          [12], [13], [16], [17]
//        ]
//      ]]
//
// %rhs: [
//        [[[1]], [[1]], [[1]]],
//        [[[1]], [[1]], [[1]]],
//        [[[1]], [[1]], [[1]]]
//       ]
%result = "stablehlo.convolution"(%lhs, %rhs) {
  window_strides = array<i64: 4, 4>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = array<i64: 2, 2>,
  rhs_dilation = array<i64: 1, 1>,
  window_reversal = array<i1: false, false>,
  // In the StableHLO dialect, dimension numbers are encoded via:
  // `[<input dimensions>]x[<kernel dimensions>]->[output dimensions]`.
  // "b" is batch dimension, "f" is feature dimension,
  // "i" is input feature dimension, "o" is output feature dimension,
  // "0/1/etc" are spatial dimensions.
  dimension_numbers = #stablehlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  batch_group_count = 1 : i64,
  feature_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi64>, tensor<3x3x1x1xi64>) -> tensor<1x2x2x1xi64>
// %result: [[
//            [[10], [26]],
//            [[46], [62]]
//          ]]

مزيد من الأمثلة

جيب التمام

الدلالات

تؤدي هذه الدالة عملية جيب التمام بناءً على العناصر في موتر operand وينتج عنها متسابق result. حسب نوع العنصر، يتم إجراء ما يلي:

• بالنسبة إلى الأعداد العشرية العائمة: cos من IEEE-754
• للأعداد المركبة: جيب التمام المركب
• بالنسبة إلى الأنواع التي تم تحويلها إلى قيم عددية: dequantize_op_quantize(cosine, operand, type(result)).

مدخلات

النواتج

القيود

• (ج1) baseline_type(operand) = baseline_type(result).

أمثلة

// %operand: [
//            [0.0, 1.57079632],       // [0, pi/2]
//            [3.14159265, 4.71238898] // [pi, 3pi/2]
//           ]
%result = "stablehlo.cosine"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[1.0, 0.0], [-1.0, 0.0]]

مزيد من الأمثلة

عدد_الأصفار_الأولية

الدلالات

تُجري عملية احتساب عدد الوحدات الثنائية الصفرية الأولى في مصفوفة operand وتنشئ مصفوفة result.

مدخلات

النواتج

القيود

• (ج1) type(operand) = type(result).

أمثلة

// %operand: [[0, 1], [128, -1]]
%result = "stablehlo.count_leading_zeros"(%operand) : (tensor<2x2xi64>) -> tensor<2x2xi64>
// %result: [[64, 63], [56, 0]]

 مزيد من الأمثلة

custom_call

دلالات الألفاظ

تُغلِّف عملية call_target_name التي يحدِّدها التنفيذ وتستخدِم inputs وcalled_computations وتُنشئ results. يمكن استخدام has_side_effect وbackend_config وapi_version لتوفير بيانات وصفية إضافية تحدّدها عملية التنفيذ.

في الوقت الحالي، تحتوي هذه العملية على مجموعة غير منظمة إلى حدٍ كبير من البيانات الوصفية التي تعكس التطور العضوي لعملية المعالجة المقابلة لها في compiler (المجمّع) XLA. ونحن نخطّط لتوحيد هذه البيانات الوصفية في المستقبل (#741).

مدخلات

النواتج

أمثلة

%results = "stablehlo.custom_call"(%input0) {
  call_target_name = "foo",
  has_side_effect = false,
  backend_config = {bar = 42 : i32},
  api_version = 4 : i32,
  called_computations = [@foo]
} : (tensor<f64>) -> tensor<f64>

قسمة

الدلالات

تُجري عملية قسمة العناصر من حيث العناصر لمعادلات المقسم lhs وقسمة القاسم rhs وينتج مضارب result. بناءً على نوع العنصر، نفِّذ ما يلي:

• بالنسبة إلى الأعداد الصحيحة: قسمة الأعداد الصحيحة التي تؤدي إلى الناتج الجبري مع تجاهل أي جزء كسري
• بالنسبة إلى الأعداد العشرية العائمة: division من IEEE-754
• بالنسبة إلى الأعداد المركّبة: القسمة المركّبة.
• بالنسبة إلى الأنواع التي تم تحويلها إلى قيم عددية:
  • dequantize_op_quantize(divide, lhs, rhs, type(result)).

مدخلات

النواتج

القيود

• (ج1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result).

أمثلة

// %lhs: [17.1, -17.1, 17.1, -17.1]
// %rhs: [3.0, 3.0, -3.0, -3.0]
%result = "stablehlo.divide"(%lhs, %rhs) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
// %result: [5.66666651, -5.66666651, -5.66666651, 5.66666651]

مزيد من الأمثلة

dot_general

الدلالات

لحساب ضربات النقاط بين شرائح lhs وشرائح rhs وينتج عن ذلك result متّجه.

بشكل أكثر رسمية، result[result_index] = dot_product، حيث:

• lhs_result_dimensions = [d for d in axes(lhs) and d not in lhs_batching_dimensions and d not in lhs_contracting_dimensions].
• rhs_result_dimensions = [d for d in axes(rhs) and d not in rhs_batching_dimensions and d not in rhs_contracting_dimensions].
• result_batching_index + result_lhs_index + result_rhs_index = result_index حيث size(result_batching_index) = size(lhs_batching_dimensions) و size(result_lhs_index) = size(lhs_result_dimensions) و size(result_rhs_index) = size(rhs_result_dimensions)
• transposed_lhs = transpose(lhs, lhs_batching_dimensions + lhs_result_dimensions + lhs_contracting_dimensions).
• transposed_lhs_slice = slice(transposed_lhs, result_batching_index + result_lhs_index + [:, ..., :]).
• reshaped_lhs_slice = reshape(transposed_lhs_slice, dims(lhs, lhs_contracting_dimensions)).
• transposed_rhs = transpose(rhs, rhs_batching_dimensions + rhs_result_dimensions + rhs_contracting_dimensions).
• transposed_rhs_slice = slice(transposed_rhs, result_batching_index + result_rhs_index + [:, ..., :]).
• reshaped_rhs_slice = reshape(transposed_rhs_slice, dims(rhs, rhs_contracting_dimensions)).
• dot_product = reduce( inputs=[multiply(reshaped_lhs_slice, reshaped_rhs_slice)], init_values=[constant(0, element_type(result))], dimensions=range(size(lhs_contracting_dimensions)), body=lambda x, y: add(x, y)).

بالنسبة إلى الأنواع المحدَّدة القيمة، يتم تنفيذ dequantize_op_quantize( lambda lhs, rhs: dot_general(lhs, rhs, lhs_batching_dimensions, rhs_batching_dimensions, lhs_contracting_dimensions, rhs_contracting_dimensions, precision_config), lhs, rhs, type(result)).

بالنسبة إلى الأنواع الكمية المختلطة، تحقّق قيمة hybrid_dequantize_then_op( lambda lhs, rhs: dot_general(lhs, rhs, lhs_batching_dimensions, rhs_batching_dimensions, lhs_contracting_dimensions, rhs_contracting_dimensions, precision_config), lhs, rhs).

يتحكّم precision_config في الموازنة بين السرعة والدقة للعمليات الحسابية على الخلفيات الخاصة بمسرِّعات الأعمال. يمكن أن تكون هذه إحدى القيم التالية (في الوقت الحالي، لم يتم تحديد دلالات قيم التعداد هذه بشكل كافٍ، ولكننا نخطّط لمعالجة ذلك في #755):

• DEFAULT: أسرع عملية حسابية، ولكن أقل دقة من القيمة التقريبية للرقم الأصلي.
• HIGH: عملية حسابية أبطأ، لكنّها تقريبية أكثر دقة من الرقم الأصلي.
• HIGHEST: أبطأ طريقة حساب، ولكنها الطريقة الأقرب إلى القيمة الحقيقية للرقم الأصلي.

تحدِّد السمة DotAlgorithm السمات الرئيسية للخوارزمية المستخدَمة لتنفيذ عملية النقطة، والتي تحدِّد أيضًا الدقة. في حال ضبط حقول سمة الخوارزمية، يجب أن تكون قيمة precision_config هي DEFAULT. لا تتضمّن السمة DotAlgorithms قيمة تلقائية، لأنّ المَعلمات التلقائية يتم تحديدها عند التنفيذ. بالتالي، يمكن ضبط جميع حقول خوارزمية النقاط على None لتحديد خوارزمية النقاط الفارغة التي ستستخدم القيمة precision_config بدلاً من ذلك.

تتضمّن DotAlgorithm حقول ما يلي:

• lhs_precision_type وrhs_precision_type، هما دقتَا التقريب اللتان يتم تقريب التعبيرَين "الأيمن" و"الأيسر" للعملية إليهما. تكون أنواع الدقة مستقلّة عن أنواع التخزين للمدخلات والمخرجات.
• accumulation_type الدقة المستخدَمة في التجميع
• تنطبق lhs_component_count وrhs_component_count وnum_primitive_operations عندما نستخدم خوارزمية تُحلِّل الجانب الأيمن و/أو الجانب الأيسر إلى مكونات متعدّدة وتُجري عمليات ضرب "بدائية" متعدّدة على تلك القيم، وذلك عادةً لمحاكاة دقة أعلى (مثل الاستفادة من نوع بيانات الذكاء الاصطناعي bfloat16 لإجراء عمليات حسابية بدقة أعلى: bf16_6x tf32_3x، وما إلى ذلك). بالنسبة إلى الخوارزميات التي لا تتضمّن أيّ عملية تحليل، يجب ضبط هذه القيم على 1.
• ‫allow_imprecise_accumulation لتحديد ما إذا كان التراكم بدقة أقل مسموحًا به لبعض الخطوات (مثل CUBLASLT_MATMUL_DESC_FAST_ACCUM).

أمثلة على سمات DotAlgorithm:

// Inputs are casted to tf32, and then accumulated in f32:
{lhs_precision_type = tf32,
 rhs_precision_type = tf32,
 accumulation_type = f32,
 lhs_component_count = 1,
 rhs_component_count = 1,
 num_primitive_operations = 1,
 allow_imprecise_accumulation = false}


// bf16_6x: each input is decomposed to 3 bf16 components, then 6 dot operations are done on those components, and the result is accumulated in f32.
{lhs_precision_type = bf16,
 rhs_precision_type = bf16,
 accumulation_type = f32,
 lhs_component_count = 3,
 rhs_component_count = 3,
 num_primitive_operations = 6,
 allow_imprecise_accumulation = false}


// Inputs are (casted to) f8e5m2, and we accumulate in f32, but for some steps we may accumulate in lower precision.
{lhs_precision_type = f8e5m2,
 rhs_precision_type = f8e5m2,
 accumulation_type = f32,
 lhs_component_count = 1,
 rhs_component_count = 1,
 num_primitive_operations = 1,
 allow_imprecise_accumulation = true}

ويعود الأمر إلى عمليات التنفيذ لتحديد التركيبات المتوافقة. بشكلٍ عام، لا يمكن ضمان توافق كل خوارزمية مع كل نوع من أنواع مسرعات الأداء من قِبل مستخدِم StableHLO. إذا كانت إحدى الخوارزميات غير متوفرة، يجب عرض رسالة خطأ بدلاً من الرجوع إلى بديل. سيقدّم التحقّق من StableHLO أفضل تأكيد ممكن، ويمنع استخدام الخوارزميات غير المعروف أنّها متوافقة مع أي جهاز.

راجِع xla_data.proto > Algorithm للاطّلاع على بعض قيم الخوارزمية المتوافقة. يوضّح طلب الدعم رقم 2483 الخطة لإنشاء مستند مركزي حول الخوارزميات المتوافقة حسب الواجهة الخلفية.

مدخلات

النواتج

القيود

• (ج1) size(lhs_batching_dimensions) = size(rhs_batching_dimensions).
• (C2) size(lhs_contracting_dimensions) = size(rhs_contracting_dimensions).
• (ج3) is_unique(lhs_batching_dimensions + lhs_contracting_dimensions).
• (C4) is_unique(rhs_batching_dimensions + rhs_contracting_dimensions).
• (ج5) 0 <= lhs_batching_dimensions < rank(lhs).
• (C6) 0 <= lhs_contracting_dimensions < rank(lhs).
• (ج7) 0 <= rhs_batching_dimensions < rank(rhs).
• (C8) 0 <= rhs_contracting_dimensions < rank(rhs).
• (ج9) dim(lhs, lhs_batching_dimensions...) = dim(rhs, rhs_batching_dimensions...).
• (C10) dim(lhs, lhs_contracting_dimensions...) = dim(rhs, rhs_contracting_dimensions...).
• (C11) size(precision_config) = 2.
• (C12) shape(result) = dim(lhs, lhs_batching_dimensions) + dim(lhs, lhs_result_dimensions) + dim(rhs, rhs_result_dimensions).
• إذا كانت العملية تستخدم مصفوفات غير مُكثَّفة:
  • (C13) element_type(lhs) = element_type(rhs).
• إذا كانت العملية تستخدم مصفوفات كمية:
  • (C14) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs).
  • (C15) zero_points(rhs) = 0.
  • (C16) إذا كانت القيمة is_per_axis_quantized(rhs)، وليس quantization_dimension(rhs) في rhs_contracting_dimensions.
  • إذا is_quantized(lhs):
  • (C17) storage_type(lhs) = storage_type(rhs).
  • (C18) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result).
  • (C19) إذا كان is_per_tensor_quantized(rhs)، ثم is_per_tensor_quantized(result).
  • إذا !is_quantized(lhs):
  • (C20) element_type(lhs) = expressed_type(rhs) = element_type(result).
• في حال !is_empty_algorithm(lhs_precision_type, rhs_precision_type, accumulation_type, lhs_component_count, rhs_component_count, num_primitive_operations allow_imprecise_accumulation):
  • (C21) precision_config... = DEFAULT.
  • (C22) 0 < lhs_component_count.
  • (C23) 0 < rhs_component_count.
  • (C24) 0 < num_primitive_operations.

أمثلة

// %lhs: [
//        [[1, 2],
//         [3, 4]],
//        [[5, 6],
//         [7, 8]]
//       ]
// %rhs: [
//        [[1, 0],
//         [0, 1]],
//        [[1, 0],
//         [0, 1]]
//       ]
%result = "stablehlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #stablehlo.dot<
    lhs_batching_dimensions = [0],
    rhs_batching_dimensions = [0],
    lhs_contracting_dimensions = [2],
    rhs_contracting_dimensions = [1]
  >,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>],
  algorithm = #stablehlo.dot_algorithm<
    lhs_precision_type = tf32,
    rhs_precision_type = tf32,
    accumulation_type = f32,
    lhs_component_count = 1,
    rhs_component_count = 1,
    num_primitive_operations = 1,
    allow_imprecise_accumulation = false
  >
} : (tensor<2x2x2xi64>, tensor<2x2x2xi64>) -> tensor<2x2x2xi64>
// %result: [
//           [[1, 2],
//            [3, 4]],
//           [[5, 6],
//            [7, 8]]
//          ]

 مزيد من الأمثلة

dynamic_broadcast_in_dim

الدلالات

هذه العملية متطابقة من الناحية الوظيفية مع عملية broadcast_in_dim ، ولكن يتم تحديد شكل النتيجة ديناميكيًا من خلال output_dimensions.

تقبل العملية أيضًا السمتَين الاختياريتين known_expanding_dimensions وknown_nonexpanding_dimensions لالتعبير عن المعرفة الثابتة حول سلوك توسيع السمات. في حال عدم تحديدها، يُفترض أنّ جميع السمات قابلة للتوسيع.

مدخلات

النواتج

القيود

• (C1) يتم الحصول على element_type(result) من خلال:
  • element_type(operand)، إذا !is_per_axis_quantized(operand)
  • element_type(operand) باستثناء أنّ quantization_dimension(operand) وscales(operand) وzero_points(operand) قد يختلفان عن quantization_dimension(result) وscales(result) وzero_points(result). بخلاف ذلك.
• (ج2) size(broadcast_dimensions) = rank(operand).
• (ج3) 0 <= broadcast_dimensions < rank(result).
• (C4) is_unique(broadcast_dimensions).
• (ج5) بالنسبة إلى جميع d في axes(operand):
  • dim(operand, d) = 1 أو
  • dim(operand, d) = dim(result, broadcast_dimensions[d]).
• (C6) إذا كان is_per_axis_quantized(result):
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)].
  • إذا كانت dim(operand, quantization_dimension(operand)) = 1، سيتم عندها scales(result)[i] = scales(operand)[0] and zero_points(result)[i] = zero_points(operand)[0] for i in range(dim(result, quantization_dimension(result))).
• (ج7) size(output_dimensions) = rank(result).
• (ج8) is_unique(known_expanding_dimensions + known_nonexpanding_dimensions).
• (C9) 0 <= known_expanding_dimensions < rank(operand).
• (C10) 0 <= known_nonexpanding_dimensions < rank(operand).

أمثلة

// %operand: [
//            [1, 2, 3]
//           ]
%operand = stablehlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = stablehlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "stablehlo.dynamic_broadcast_in_dim"(%operand, %output_dimensions) {
  broadcast_dimensions = array<i64: 2, 1>,
  known_expanding_dimensions = array<i64: 0>,
  known_nonexpanding_dimensions = array<i64: 1>
} : (tensor<1x3xi64>, tensor<3xi64>) -> tensor<2x3x2xi64>
// %result: [
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ],
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ]
//          ]

مزيد من الأمثلة

dynamic_conv

الدلالات

هذه العملية متطابقة من الناحية الوظيفية مع عملية التفاف op، ولكن يتم تحديد الحشو ديناميكيًا من خلال padding.

مدخلات

النواتج

القيود

• (ج1) N = rank(lhs) = rank(rhs).
• (C2) size(window_strides) = N - 2.
• (ج3) 0 < window_strides.
• (C4) shape(padding) = [N - 2, 2].
• (ج5) size(lhs_dilation) = N - 2.
• (C6) 0 < lhs_dilation.
• (ج7) size(rhs_dilation) = N - 2.
• (ج8) 0 < rhs_dilation.
• (ج9) size(window_reversal) = N - 2.
• (C10) dim(lhs, input_batch_dimension) % batch_group_count = 0.
• (C11) dim(lhs, input_feature_dimension) % feature_group_count = 0.
• (C12) size(input_spatial_dimensions) = N - 2.
• (C13) بالنظر إلى input_dimensions = [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension]:
  • is_unique(input_dimensions).
  • 0 <= input_dimensions < N.
• (C14) dim(rhs, kernel_input_feature_dimension) = dim(lhs, input_feature_dimension) / feature_group_count.
• (C15) dim(rhs, kernel_output_feature_dimension) % batch_group_count = 0.
• (C16) dim(rhs, kernel_output_feature_dimension) % feature_group_count = 0.
• (C17) size(kernel_spatial_dimensions) = N - 2.
• (C18) بالنظر إلى kernel_dimensions = kernel_spatial_dimensions + [kernel_input_feature_dimension] + [kernel_output_feature_dimension]:
  • is_unique(kernel_dimensions).
  • 0 <= kernel_dimensions < N.
• (C19) size(output_spatial_dimensions) = N - 2.
• (C20) بالنظر إلى output_dimensions = [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension]:
  • is_unique(output_dimensions).
  • 0 <= output_dimensions < N.
• (C21) 0 < feature_group_count.
• (C22) 0 < batch_group_count.
• (C23) feature_group_count = 1 or batch_group_count = 1.
• (C24) size(precision_config) = 2.
• (C25) يتم تعريف dim(result, result_dim) على النحو التالي:
  • dim(lhs, input_batch_dimension) / batch_group_count إذا result_dim = output_batch_dimension
  • dim(rhs, kernel_output_feature_dimension) إذا result_dim = output_feature_dimension
  • num_windows في الحالات الأخرى، حيث:
  • output_spatial_dimensions[spatial_dim] = result_dim.
  • lhs_dim = input_spatial_dimensions[spatial_dim].
  • rhs_dim = kernel_spatial_dimensions[spatial_dim].
  • dilated_input_shape[lhs_dim] = dim(lhs, lhs_dim) = 0 ? 0 : (dim(lhs, lhs_dim) - 1) * lhs_dilation[spatial_dim] + 1.
  • padded_input_shape[lhs_dim] = padding[spatial_dim, 0] + dilated_input_shape[lhs_dim] + padding[spatial_dim, 1].
  • dilated_window_shape[lhs_dim] = dim(rhs, rhs_dim) = 0 ? 0 : (dim(rhs, rhs_dim) - 1) * rhs_dilation[spatial_dim] + 1.
  • is_empty_window[lhs_dim] = padded_input_shape[lhs_dim] = 0 || dilated_window_shape[lhs_dim] > padded_input_shape[lhs_dim].
  • num_windows = is_empty_window[lhs_dim] ? 0 : floor((padded_input_shape[lhs_dim] - dilated_window_shape[lhs_dim]) / window_strides[spatial_dim]) + 1.
• (C26) rank(result) = N.
• إذا كانت العملية تستخدم مصفوفات غير مُكثَّفة:
  • (C27) element_type(lhs) = element_type(rhs) = element_type(result).
• إذا كانت العملية تستخدم موتّرات كميّة:
  • (C28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs).
  • (C29) إذا كانت is_per_axis_quantized(rhs)، ثم quantization_dimension(rhs) = kernel_output_feature_dimension.
  • (C30) إذا كانت السمة is_per_axis_quantized(result)، يتم عندها quantization_dimension(result) = output_feature_dimension.
  • إذا is_quantized(lhs):
  • (C31) storage_type(lhs) = storage_type(rhs).
  • (C32) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result).
  • (C33) إذا كان is_per_tensor_quantized(rhs)، ثم is_per_tensor_quantized(result).
  • إذا !is_quantized(lhs):
  • (C34) element_type(lhs) = expressed_type(rhs) = element_type(result).

أمثلة

// %lhs: [[
//        [[1], [2], [5], [6]],
//        [[3], [4], [7], [8]],
//        [[10], [11], [14], [15]],
//        [[12], [13], [16], [17]]
//      ]]
//
// %rhs: [
//         [[[1]], [[1]], [[1]]],
//         [[[1]], [[1]], [[1]]],
//         [[[1]], [[1]], [[1]]]
//        ]
// %padding: [[1, 1],
//            [1, 1]]
%result = "stablehlo.dynamic_conv"(%lhs, %rhs, %padding) {
  window_strides = array<i64: 4, 4>,
  lhs_dilation = array<i64: 2, 2>,
  rhs_dilation = array<i64: 1, 1>,
  window_reversal = array<i1: false, false>,
  dimension_numbers = #stablehlo.conv<raw
    input_batch_dimension = 0,
    input_feature_dimension = 3,
    input_spatial_dimensions = [0, 1],
    kernel_input_feature_dimension = 2,
    kernel_output_feature_dimension = 3,
    kernel_spatial_dimensions = [0, 1],
    output_batch_dimension = 0,
    output_feature_dimension = 3,
    output_spatial_dimensions = [1, 2]
  >,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi64>, tensor<3x3x1x1xi64>, tensor<2x2xi64>) -> tensor<1x2x2x1xi64>
// %result: [[
//            [[1], [5]],
//            [[10], [14]]
//          ]]