مواصفات 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}

تتضمن الدوال الثابتة (التي تُسمى أيضًا الدوال المُسمّاة) المعرف والمدخلات/المخرجات ونص. في المستقبل، نخطط وتقديم بيانات وصفية إضافية للدوال لتحقيق توافق أفضل باستخدام 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 طبيعة خاصة بالنطاق والتي ينتج عنها بعض النتائج غير المعتادة (مثل الأنواع العددية ليست أنواع قيم).

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 ::= IntegerConstant
QuantizationStorageMax ::= IntegerConstant
QuantizationExpressedType ::= FloatType
QuantizationDimension ::= IntegerConstant
QuantizationParameters ::= QuantizationParameter
                         | '{' QuantizationParameter {',' QuantizationParameter} '}'
QuantizationParameter ::= QuantizationScale ':' QuantizationZeroPoint
QuantizationScale ::= FloatConstant
QuantizationZeroPoint ::= IntegerConstant

تمثّل أنواع العناصر الكمية قيمًا أعدادًا صحيحة لـ نوع التخزين في النطاق من 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.
• (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}]

تمثل أنواع الصفوف الصفوف، أي القوائم غير المتجانسة. الصفوف هي نظام قديم الموجودة فقط للتوافق مع HLO. في HLO، الصفوف لتمثيل المدخلات والمخرجات المتباينة. في StableHLO، تتنوع المدخلات يتم دعم المخرجات محليًا، ولا يمكن استخدام الصفوف في StableHLO إلا من خلال تمثل واجهة التطبيق الثنائية (HLO ABI) بشكل شامل حيث يمكن، على سبيل المثال، 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 ::= 'f8E4M3FN' | 'f8E5M2' | 'f8E4M3FNUZ' | 'f8E5M2FNUZ'
            | 'f8E4M3B11FNUZ' | 'bf16' | 'f16' | 'f32' | 'f64'
TensorFloat32 ::= 'tf32'
ComplexType ::= 'complex' '<' ComplexElementType '>'
ComplexElementType ::= 'f32' | 'f64'

تمثّل أنواع العناصر عناصر أنواع أداة "المنسِّر". على عكس العديد من البرامج اللغات، فهذه الأنواع ليست من الدرجة الأولى في StableHLO. هذا يعني أنّ ولا يمكن لبرامج StableHLO أن تمثل قيمًا من هذه الأنواع بشكل مباشر (نتيجةً لذلك، يكون من الاصطلاحي تمثيل القيم العددية من النوع T باستخدام متوتر 0 الأبعاد القيم من النوع 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 بشكل شامل.
• يمكن أن تكون أنواع النقاط العائمة أيًا مما يلي:
  • النوعان f8E4M3FN وf8E5M2 المتوافقان مع الترميزان E4M3 وE5M2 للتنسيق FP8 الموضح في تنسيقات FP8 للتعلّم المتعمق
  • النوعان f8E4M3FNUZ وf8E5M2FNUZ المتوافقان مع السمتَين E4M3 وE5M2 ترميزات تنسيقات FP8 الموضحة في تنسيقات رقمية 8 بت للشبكات العصبية العميقة
  • النوع f8E4M3B11FNUZ المقابل لترميز E4M3 لتنسيقات FP8. موصوفة في تدريب واستنتاج النقطة العائمة المختلطة (HFP8) للشبكات العصبية العميقة.
  • نوع bf16 متوافق مع تنسيق bfloat16 الموضّح في. BFloat16: سر تحقيق الأداء العالي في وحدات معالجة الموتّرات في السحابة الإلكترونية
  • أنواع f16 وf32 وf64 مناظرة على التوالي binary16 ("نصف الدقة") وbinary32 ("دقة واحدة") تنسيقات binary64 ("الدقة المزدوجة") الموضّحة في معيار IEEE 754
  • يتوافق النوع tf32 مع تنسيق TensorFloat32. ولديها دعم محدود في StableHLO
• الأنواع المعقّدة تمثّل قيمًا معقدة تتضمّن جزءًا حقيقيًا. وجزء خيالي من نوع العنصر نفسه. المجمّع المدعوم النوعان هما complex<f32> (كلا الجزأين من النوع f32) وcomplex<f64>. (كلا الجزأين من النوع f64).

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

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

StringType ::= 'string'

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

العمليات

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

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

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

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

تستهلك العمليات الإدخالات وتُنتج المخرجات. يتم تصنيف الإدخالات إلى قيم الإدخال (المحسوبة أثناء التنفيذ)، دوال الإدخال (المقدمة بشكلٍ ثابت، لأن الدوال الثابتة HLO ليست قيمًا من الدرجة الأولى) سمات الإدخال (يتم تقديمها أيضًا بشكل ثابت). نوع المدخلات والمخرجات تعتمد العملية التي يتم استهلاكها وإنتاجها على ذاكرتها. على سبيل المثال، 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}] ')'

يتكون توقيع العمليات من أنواع جميع قيم الإدخال (قائمة الأنواع على الجانب الأيسر لـ ->) وأنواع جميع قيم الإخراج (قائمة على الجانب الأيسر من ->). وعلى وجه التحديد، تُعد أنواع المدخلات متكررة، وأنواع الإخراج تكون متكررة دائمًا تقريبًا أيضًا (لأن في معظم عمليات 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

تضم الثوابت الثابتة HLO قيمة حرفية ونوع يمثلان معًا قيمة 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]

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

• (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". الترتيب الذي يتم تحديد تنفيذ هذه الأجزاء في الذاكرة. الثوابت المعقدة للقيود التالية:

• (ج1) 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

تمثل ثوابت المستشعر قيم التوتر باستخدام قوائم متداخلة محددة عبر تدوين نمباي. على سبيل المثال: 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)).
• (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)).

مدخلات

المُخرَجات

القيود

• (ج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 حسب نوع العنصر، يتم إجراء ما يلي:

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

مدخلات

المُخرَجات

القيود

• إذا كانت العملية تستخدم موتّرات غير كَمية:
  • (ج1) 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) إذا كانت القيمة هي 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...).
• (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) إذا كانت القيمة هي 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.
• (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).

مدخلات

المُخرَجات

القيود

• (ج1) 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 على مستوى البت.

مدخلات

المُخرَجات

القيود

• (ج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 Tensor وينتج عن ذلك متوتر 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 من 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 لديهم نفس الشكل.
• (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 الحالية باستخدام بناء جملة بايثون على النحو التالي:

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

مدخلات

المُخرَجات

القيود

• (ج1) 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

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

لإجراء عملية بث بت على المغناطيس 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] بخلاف ذلك.

مدخلات

المُخرَجات

القيود

• (ج1) 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))

مدخلات

المُخرَجات

القيود

• (ج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]

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

كولسكي

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

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

بشكل رسمي، لجميع 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).
• (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).

مدخلات

المُخرَجات

القيود

• (ج1) 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)) وإلا.

مدخلات

المُخرَجات

القيود

• (ج1) 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)) وإلا.

مدخلات

المُخرَجات

القيود

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

مدخلات

المُخرَجات

القيود

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

مدخلات

المُخرَجات

القيود

• (ج1) 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 بتحليلها بدون تغيير البرنامج. الدلالة. وفي الحالات التي لا يوفر فيها التحلل النموذج نفسه علم الدلالات، يُفضَّل استخدام 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.

مدخلات

المُخرَجات

القيود

• (ج1) 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 ثابت.

مدخلات

المُخرَجات

القيود

• (ج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. انظر أدناه لمعرفة كيف يمكنك تحقيق ذلك تناسب الأنواع المعقدة.

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

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

تتبع الإحالات الناجحة التي تشتمل على معقد إلى معقد سلوك الإحالات الناجحة floating-point-to-floating-point لتحويل الأجزاء الخيالية.

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

من حيث المبدأ، يمكن لهذه العملية التعبير عن إلغاء التحديد (تحويل من المقوّمات الكميّة إلى موتّرات عادية)، الكمي (تحويل من منتظم) المقوّسات إلى قياسات التوتر الكمّية) وإعادة الكمّية (التحويل بين الكميّة الكمية) الأساسية)، ولكن في الوقت الحالي، خصصنا عمليات من أجل ذلك 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.
• (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) نظرًا إلى 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]]

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

count_leading_zeros

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

تؤدي إلى إجراء العدد من حيث العناصر في عدد وحدات البت البادئة الصفرية في 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 لتوفير خيارات إضافية بيانات التعريف المحددة للتنفيذ.

في الوقت الحالي، تحتوي هذه العملية على مجموعة غير منظمة إلى حد ما من بيانات التعريف التي تعكس التطور العضوي لعملية نظيرتها في المحول البرمجي لـ 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، والدقة التي تلاحظها LHS يتم تقريب RHS للعملية إلى. تكون أنواع الدقة مستقلّة عن أنواع التخزين للمدخلات والمخرجات.
• accumulation_type الدقة المستخدمة في التراكم.
• lhs_component_count وrhs_component_count وnum_primitive_operations عندما نقوم بخوارزمية تفكيك LHS و/أو RHS إلى عدة مكونات ويقوم بتنفيذ العديد من "الأساسيات" العمليات النقطية على تلك القيم - عادةً لمحاكاة دقة أعلى (على سبيل المثال الاستفادة من نوع بيانات 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).
• (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) إذا كانت 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_non_expanding_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_non_expanding_dimensions).
• (C9) 0 <= known_expanding_dimensions < rank(operand).
• (C10) 0 <= known_non_expanding_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_non_expanding_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.

مدخلات

المُخرَجات

القيود

• (ج1) 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) نظرًا إلى 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]]
//          ]]