مواصفات StableHLO

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

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

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

للاطّلاع على المواصفات من إصدار سابق من StableHLO، افتح المستودع في الإصدار الذي تم وضع علامة عليه. على سبيل المثال، مواصفات الإصدار 0.19.0 من StableHLO. للاطّلاع على التغييرات التي حدثت في كل إصدار ثانوي من 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'

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

الأنواع

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

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

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

تمثّل أنواع الموتر الموترات، أي المصفوفات المتعددة الأبعاد. تتضمّن هذه المصفوفات شكلاً ونوع عنصر، حيث يمثّل الشكل أحجام الأبعاد غير السالبة أو غير المعروفة بترتيب تصاعدي للأبعاد المقابلة (المعروفة أيضًا باسم المحاور) المرقمة من 0 إلى R-1. يُطلق على عدد الأبعاد R اسم الرتبة. على سبيل المثال، tensor<2x3xf32> هو نوع موتر ذو شكل 2x3 ونوع عنصر f32. يتضمّن هذا المثال بُعدَين (أو محورَين)، وهما البُعد 0 والبُعد 1، ويبلغ حجم كل منهما 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)" على التوالي. تتضمّن أنواع العناصر المحدّدة الكمية القيود التالية:

• (C1) type(storage_min) = storage_type
• (C2) type(storage_max) = storage_type
• (C3) min_value(storage_type) <= storage_min < storage_max <= max_value(storage_type)
• (C4) type(scales...) = expressed_type
• (C5) 0 < scales.
• (C6) is_finite(scales...)
• (C7) storage_min <= zero_points <= storage_max
• (C8) type(zero_points...) = storage_type
• (C9) 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}]

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

يمكن تخصيص المخازن المؤقتة باستخدام custom_call إلى CreateBuffer أو Pin، ويمكن إلغاء تخصيصها باستخدام custom_call إلى Unpin. يمكن لمشغّلي custom_call فقط قراءة المحتوى وكتابته داخل المخازن المؤقتة. لمزيد من التفاصيل، يُرجى الاطّلاع على custom_call.

تمثّل أنواع الصفوف الصفوف، أي القوائم غير المتجانسة. تُعدّ الصفوف ميزة قديمة تتوفّر فقط للتوافق مع 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: The secret to high performance on Cloud TPUs
  • أنواع f16 وf32 وf64 التي تتوافق على التوالي مع تنسيقات binary16 ("نصف الدقة") وbinary32 ("الدقة الفردية") وbinary64 ("الدقة المزدوجة") الموضّحة في معيار IEEE 754
  • يتوافق النوع tf32 مع تنسيق TensorFloat32 ويعمل بشكل محدود في StableHLO.
  • أنواع f4E2M1FN وf6E2M3FN وf6E3M2FN وf8E8M0FNU MX (التقليص الدقيق) الموضّحة في مواصفات تنسيقات التقليص الدقيق في OCP
• تمثّل الأنواع المركّبة قيمًا مركّبة تتضمّن جزءًا حقيقيًا وجزءًا تخيليًا من نوع العنصر نفسه. تشمل الأنواع المعقّدة المتوافقة complex<f32> (يكون كلا الجزأين من النوع f32) وcomplex<f64> (يكون كلا الجزأين من النوع f64).

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

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

StringType ::= 'string'

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

العمليات

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

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

عمليات StableHLO (المعروفة أيضًا باسم العمليات) لها اسم ومدخلات/مخرجات وتوقيع. يتألف الاسم من البادئة 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 قيم إدخال و2 من دوال الإدخال و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}] ')'

تتألف توقيع العملية من أنواع جميع قيم الإدخال (قائمة الأنواع على الجانب الأيمن من ->) وأنواع جميع قيم الإخراج (قائمة الأنواع على الجانب الأيسر من ->). وبشكل عام، تكون أنواع الإدخال غير ضرورية، كما أنّ أنواع الإخراج تكون غير ضرورية في معظم الحالات (لأنّه بالنسبة إلى معظم عمليات StableHLO، يمكن استنتاج أنواع الإخراج من الإدخالات). ومع ذلك، فإنّ توقيع العملية هو جزء من بنية 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'

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

• (C1) 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]

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

• (C1) في حال استخدام ترميز غير سداسي عشري، 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. ويتم تحديد ترتيب تخزين هذه الأجزاء في الذاكرة حسب التنفيذ. تتضمّن الثوابت المعقّدة القيود التالية:

• (C1) is_wellformed(real_part, complex_element_type(complex_type))
• (C2) 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) '>'

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

• (C1) has_syntax(quantized_tensor_literal, storage_type(quantized_tensor_type))
• (C2) 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)).

المدخلات

النواتج

القيود

• (C1) 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. استنادًا إلى نوع العنصر، نفِّذ ما يلي:

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

المدخلات

النواتج

القيود

• إذا كانت العملية تستخدم موترات غير كمّية:
  • (C1) type(lhs) = type(rhs) = type(result)
• إذا كانت العملية تستخدم موترات كمية:
  • (C2) is_quantized(lhs) and is_quantized(rhs) and is_quantized(result)
  • (C3) storage_type(lhs) = storage_type(rhs) = storage_type(result)
  • (C4) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result)
  • (C5) (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) if channel_id <= 0 and use_global_device_ids = false
• cross_replica_and_partition(replica_groups) if channel_id > 0 and use_global_device_ids = false
• flattened_ids(replica_groups) if 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

المدخلات

النواتج

القيود

• (C1) 0 <= all_gather_dim < rank(operands...)
• (C2) 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)
• (C5) إذا كان 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) if channel_id <= 0 and use_global_device_ids = false
• cross_replica_and_partition(replica_groups) if channel_id > 0 and use_global_device_ids = false
• flattened_ids(replica_groups) if 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])).

المدخلات

النواتج

القيود

• (C1) is_unique(replica_groups)
• يتم تعريف (C2) size(replica_groups) على النحو التالي:
  • num_replicas في حال استخدام cross_replica
  • num_replicas في حال استخدام cross_replica_and_partition
  • num_processes في حال استخدام flattened_ids
• (C3) 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).

المدخلات

النواتج

القيود

• (C1) 0 <= split_dimension < rank(operands...)
• (C2) dim(operands..., split_dimension) % split_count = 0
• (C3) 0 <= concat_dimension < rank(operands...)
• (C4) 0 < split_count
• (C5) is_unique(replica_groups).
• يتم تعريف (C6) size(replica_groups) على النحو التالي:
  • num_replicas في حال استخدام cross_replica
  • num_partitions في حال استخدام cross_partition
• (C7) 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]]

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

و

الدلالات

تُجري هذه الدالة عملية AND على مستوى العناصر في موترَين lhs وrhs، وتنتج موترًا result. استنادًا إلى نوع العنصر، نفِّذ ما يلي:

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

المدخلات

النواتج

القيود

• (C1) 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)).

المدخلات

النواتج

القيود

• (C1) 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 التي يتم نشرها عكسيًا من 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)).

المدخلات

النواتج

القيود

• (C1) 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 لها الشكل نفسه.
• (C5) 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)).

المدخلات

النواتج

القيود

• (C1) 0 <= feature_index < rank(operand)
• (C2) تحتوي operand وscale وoffset وmean وvariance وresult على baseline_element_type نفسه.
• (C3) size(scale) = dim(operand, feature_index)
• (C4) size(offset) = dim(operand, feature_index)
• (C5) size(mean) = dim(operand, feature_index).
• (C6) size(variance) = dim(operand, feature_index)
• (C7) 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)).

المدخلات

النواتج

القيود

• (C1) 0 <= feature_index < rank(operand)
• (C2) تحتوي operand وscale وoffset وbatch_mean وbatch_var وoutput على baseline_element_type نفسه.
• (C3) size(scale) = dim(operand, feature_index)
• (C4) size(offset) = dim(operand, feature_index)
• (C5) size(batch_mean) = dim(operand, feature_index).
• (C6) size(batch_var) = dim(operand, feature_index)
• (C7) 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

الدلالات

تُجري عملية bitcast على موتر 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 تمثيلاً في الذاكرة لقيمة معيّنة، ويكون سلوكها محدّدًا حسب التنفيذ لأنّ التمثيل الدقيق للموترات محدّد حسب التنفيذ، والتمثيل الدقيق لأنواع العناصر محدّد حسب التنفيذ أيضًا.

المدخلات

النواتج

القيود

• (C1) في حال توفّر 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) على التوالي.
• (C2) size(broadcast_dimensions) = rank(operand)
• (C3) 0 <= broadcast_dimensions < rank(result)
• (C4) is_unique(broadcast_dimensions)
• (C5) لكل 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] في ما عدا ذلك.

المدخلات

النواتج

القيود

• (C1) 0 < size(branches)
• (C2) 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))

المدخلات

النواتج

القيود

• (C1) 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)).

المدخلات

النواتج

القيود

• (C1) 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

الدلالات

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

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

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

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

المدخلات

النواتج

القيود

• (C1) baseline_type(a) = baseline_type(result)
• (C2) 2 <= rank(a)
• (C3) 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).

المدخلات

النواتج

القيود

• (C1) rank(min) = 0 or shape(min) = shape(operand)
• (C2) rank(max) = 0 or shape(max) = shape(operand)
• (C3) 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)) في ما عدا ذلك.

المدخلات

النواتج

القيود

• (C1) is_unique(replica_groups)
• (C2) 0 <= replica_groups < N حيث يتم تعريف N على النحو التالي:
  • num_replicas في حال استخدام cross_replica
  • num_partitions في حال استخدام cross_partition
• (C3) 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)) في ما عدا ذلك.

المدخلات

النواتج

القيود

• (C1) dim(source_target_pairs, 1) = 2
• (C2) is_unique(source_target_pairs[:, 0])
• (C3) 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، تستخدم العملية الحسابية مجموعة العمليتين totalOrder وcompareQuietEqual من معيار IEEE-754.

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

بالنسبة إلى الأنواع المحدَّدة الكمية، يتم تنفيذ dequantize_compare(lhs, rhs, comparison_direction).

المدخلات

النواتج

القيود

• (C1) baseline_element_type(lhs) = baseline_element_type(rhs)
• (C2) 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.

المدخلات

النواتج

القيود

• (C1) type(lhs) = type(rhs)
• (C2) 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)
• (C2) is_defined_in_parent_scope(decomposition)
• (C3) types(inputs...) == input_types(decomposition)
• (C4) 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.

المدخلات

النواتج

القيود

• (C1) same(element_type(inputs...))
• (C2) same(shape(inputs...)) باستثناء dim(inputs..., dimension)
• (C3) 0 < size(inputs)
• (C4) 0 <= dimension < rank(inputs[0])
• (C5) 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.

المدخلات

النواتج

القيود

• (C1) 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).

المدخلات

النواتج

القيود

• (C1) 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).

المدخلات

النواتج

القيود

• (C1) N = rank(lhs) = rank(rhs)
• (C2) size(window_strides) = N - 2
• (C3) 0 < window_strides
• (C4) shape(padding) = [N - 2, 2]
• (C5) size(lhs_dilation) = N - 2.
• (C6) 0 < lhs_dilation
• (C7) size(rhs_dilation) = N - 2
• (C8) 0 < rhs_dilation
• (C9) 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) Given 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) Given 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) If is_per_tensor_quantized(rhs), then 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)).

المدخلات

النواتج

القيود

• (C1) 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]]

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

count_leading_zeros

الدلالات

تُجري هذه العملية حسابًا على مستوى العناصر لعدد وحدات البت الصفرية الأولية في موتر operand وتنتج موتر result.

المدخلات

النواتج

القيود

• (C1) 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 لتوفير بيانات وصفية إضافية يحدّدها التنفيذ.

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

المدخلات

النواتج

(دعم وحدة معالجة الرسومات في XLA) استهدافات خاصة في custom_call

هناك ثلاثة أنواع خاصة من call_target_name مرتبطة بأنواع buffer: ينشئ CreateBuffer buffer غير مهيأ، وينشئ Pin buffer مهيأ، ويزيل Unpin تخصيص buffer ويعرض محتوى buffer.

%uninitialized_buffer = "stablehlo.custom_call"() {
  call_target_name = "CreateBuffer",
  api_version = 4 : i32,
} : () -> memref<4xf64>

%initialized_buffer = "stablehlo.custom_call"(%init_value) {
  call_target_name = "Pin",
  api_version = 4 : i32,
} : (tensor<4xf64>) -> memref<4xf64>

%dealloc_buffer = "stablehlo.custom_call"(%initialized_buffer) {
  call_target_name = "Unpin",
  api_version = 4 : i32,
} : (memref<4xf64>) -> tensor<4xf64>

الاسم المستعار

قد تتطلّب بعض عمليات custom_call جزءًا في النواتج وجزءًا في المعامِلات لمشاركة الذاكرة نفسها. ويمكن التعبير عن ذلك باستخدام output_operand_aliases. يتألف تمثيل زوج الأسماء المستعارة من قائمة بفهارس الصفوف الناتجة التي تمثّل الجزء الناتج، وفهرس operand_index مع قائمة بفهارس صفوف المعامِلات التي تمثّل جزء المعامِلات. تكون قائمة فهارس مجموعة البيانات الناتجة أو مجموعة البيانات الخاصة بالمعامل فارغة إذا لم يكن النوع المقابل نوع tuple، ويمكن أن تكون طويلة بشكل عشوائي لنوع مجموعة بيانات متداخلة بشكل عشوائي. وهذا مشابه لتمثيل الاسم المستعار XLA.

يجب أن يكون لجزء الإخراج وجزء الإدخال في زوج الاسم المستعار النوع نفسه. بالنسبة إلى عمليات custom_call التي لا تتضمّن استدعاءً إلى CreateBuffer وPin وUnpin، يمكن أن يظهر المعامل buffer في زوج واحد على الأكثر من الأسماء المستعارة، ويجب أن يظهر الناتج buffer في زوج واحد من الأسماء المستعارة.

أمثلة

%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>

%updated_buffer = "stablehlo.custom_call"(%buffer) {
  call_target_name = "Update",
  api_version = 4 : i32,
  output_operand_aliases = [
    #stablehlo.output_operand_alias<output_tuple_indices = [],
      operand_index = 0,
      operand_tuple_indices = []>]
} : (memref<4xf64>) -> memref<4xf64>

قسمة

الدلالات

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

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

المدخلات

النواتج

القيود

• (C1) 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 خطة لإنشاء مستند مركزي حول الخوارزميات المتوافقة مع الواجهة الخلفية.

المدخلات

النواتج

القيود

• (C1) size(lhs_batching_dimensions) = size(rhs_batching_dimensions)
• (C2) size(lhs_contracting_dimensions) = size(rhs_contracting_dimensions)
• (C3) is_unique(lhs_batching_dimensions + lhs_contracting_dimensions)
• (C4) is_unique(rhs_batching_dimensions + rhs_contracting_dimensions)
• (C5) 0 <= lhs_batching_dimensions < rank(lhs).
• (C6) 0 <= lhs_contracting_dimensions < rank(lhs)
• (C7) 0 <= rhs_batching_dimensions < rank(rhs)
• (C8) 0 <= rhs_contracting_dimensions < rank(rhs)
• (C9) 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) If is_per_tensor_quantized(rhs), then 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) على التوالي.
• (C2) size(broadcast_dimensions) = rank(operand)
• (C3) 0 <= broadcast_dimensions < rank(result)
• (C4) is_unique(broadcast_dimensions)
• (C5) لكل 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))).
• (C7) size(output_dimensions) = rank(result)
• (C8) 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

الدلالات

هذه العملية مماثلة وظيفيًا لعملية الالتفاف، ولكن يتم تحديد المساحة المتروكة ديناميكيًا من خلال padding.

المدخلات