'مهلو' اللهجة

العمليات

mhlo.abs (mhlo::AbsOp)

عملية عضلات البطن

بناء الجملة:

operation ::= `mhlo.abs` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

يقوم بإجراء عملية abs على كل عنصر على موتر operand وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

مثال:

%result = mhlo.abs %operand : tensor<3xi32>

السمات: AlwaysSpeculatableImplTrait ، Elementwise ، SameOperandsAndResultShape

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.acos (mhlo::AcosOp)

عملية أكوس

بناء الجملة:

operation ::= `mhlo.acos` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

يقوم بإجراء عملية acos لكل عنصر على موتر operand وينتج موتر result .

مثال:

%result = mhlo.acos %operand : tensor<2x2xf32>

السمات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: InferShapedTypeOpInterface ، InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.acosh (mhlo::AcoshOp)

عملية أكوش

بناء الجملة:

operation ::= `mhlo.acosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

يقوم بإجراء عملية acosh على كل عنصر على موتر operand وينتج موتر result .

مثال:

%result = mhlo.acosh %operand : tensor<2x2xf32>

السمات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: InferShapedTypeOpInterface ، InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.add (mhlo::AddOp)

إضافة عملية

بناء الجملة:

operation ::= `mhlo.add` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

يقوم بإجراء عملية إضافة عنصرية لموترين lhs rhs وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

مثال:

%result = mhlo.add %lhs, %rhs : tensor<2x2xi32>

السمات: AlwaysSpeculatableImplTrait ، Commutative ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.add_dependency (mhlo::AddDependencyOp)

عملية إضافة التبعية

بناء الجملة:

operation ::= `mhlo.add_dependency` operands attr-dict `:` functional-type(operands, results)

هذه العملية خاصة بمترجم XLA، لذا فهي لا تحتوي على مواصفات محددة حتى الآن.

بشكل غير رسمي، هذه العملية تحتوي على عاملين: عامل بيانات ورمز. ناتج العملية هو عامل البيانات. عند استخدامها مع AfterAll، تُمكّن هذه العملية من ترتيب العمليات غير ذات التأثير الجانبي (التي لا تُنتج قيمًا رمزية).

مثال:

%1 = mhlo.add_dependency %arg0, %0 : (tensor<3x4xf32>, !mhlo.token) -> tensor<3x4xf32>

السمات: AlwaysSpeculatableImplTrait

الواجهات: ConditionallySpeculatable ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.after_all (mhlo::AfterAllOp)

بعد كل العملية

بناء الجملة:

operation ::= `mhlo.after_all` $inputs attr-dict
              `:` custom<VariadicSameOperandsAndResultType>(ref($inputs), type($inputs), type($result))

يتأكد من أن العمليات التي تنتج inputs يتم تنفيذها قبل أي عمليات تعتمد على result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

مثال:

%result = mhlo.after_all %input0, %input1 : !mhlo.token

السمات: AlwaysSpeculatableImplTrait

الواجهات: ConditionallySpeculatable ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.all_gather (mhlo::AllGatherOp)

عملية AllGather

ضمن كل مجموعة عمليات في شبكة العمليات، تُجمع قيم موتر المتعامل من كل عملية على طول all_gather_dim ، وتُنتج موتر النتيجة. تُطبق computation بشكل منفصل لكل متعامل في operands ، مما يُنتج نتيجة واحدة لكل متعامل.

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

مثال:

%result = "mhlo.all_gather"(%operand) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>,
  // use_global_device_ids = false
} : (tensor<2x2xf32>) -> tensor<2x4xf32>

السمات: SameOperandsAndResultElementType

صفات:

المتعاملات:

نتائج:

mhlo.all_reduce (mhlo::AllReduceOp)

عملية AllReduce

ضمن كل مجموعة عمليات في شبكة العمليات، تُطبّق computation الاختزال على قيم موتر المتعامل من كل عملية، ويُنتج موتر النتيجة. يُطبّق computation بشكل منفصل لكل متعامل في operands ، مما يُنتج نتيجة واحدة لكل متعامل.

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

مثال:

%result = "mhlo.all_reduce"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
    %0 = mhlo.add %arg1, %arg2 : tensor<f32>
    mhlo.return %0 : tensor<f32>
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xf32>) -> tensor<4xf32>

السمات: InferTensorType ، SingleBlockImplicitTerminator<ReturnOp> ، SingleBlock

الواجهات: InferShapedTypeOpInterface ، InferTypeOpInterface

صفات:

المتعاملات:

نتائج:

mhlo.all_to_all (mhlo::AllToAllOp)

عملية AllToAll

داخل كل مجموعة عملية في شبكة العملية، يتم تقسيم قيم موتر operand على طول split_dimension إلى أجزاء، ويتم توزيع الأجزاء المنقسمة بين العمليات، ويتم ربط الأجزاء المتناثرة على طول concat_dimension وإنتاج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

مثال:

%result = "mhlo.all_to_all"(%operand) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<2x4xf32>) -> tensor<4x2xf32>

السمات: AlwaysSpeculatableImplTrait و InferTensorType و SameOperandsElementType و SameOperandsShape و SameVariadicOperandSize

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.and (mhlo::AndOp)

والعملية

بناء الجملة:

operation ::= `mhlo.and` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

ينفذ عملية AND على أساس عنصرين من الموترين lhs rhs وينتج موتر result

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

مثال:

%result = mhlo.and %lhs, %rhs : tensor<2x2xi32>

السمات: AlwaysSpeculatableImplTrait ، Commutative ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.asin (mhlo::AsinOp)

عملية أسين

بناء الجملة:

operation ::= `mhlo.asin` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

يقوم بإجراء عملية asin على كل عنصر على موتر operand وينتج موتر result .

مثال:

%result = mhlo.asin %operand : tensor<2x2xf32>

السمات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: InferShapedTypeOpInterface ، InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.asinh (mhlo::AsinhOp)

عملية أسينه

بناء الجملة:

operation ::= `mhlo.asinh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

يقوم بإجراء عملية asinh على كل عنصر على موتر operand وينتج موتر result .

مثال:

%result = mhlo.asinh %operand : tensor<2x2xf32>

السمات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: InferShapedTypeOpInterface ، InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.async_done (mhlo::AsyncDoneOp)

عملية AsyncDone

هذه العملية خاصة بمترجم XLA، لذا فهي لا تحتوي على مواصفات محددة حتى الآن.

بشكل غير رسمي، تُوقف هذه العملية حتى نهاية عملية حسابية غير متزامنة. تُرجع النتيجة النهائية لهذه العملية.

راجع وثائق AsyncStart للحصول على مزيد من المعلومات.

الواجهات: InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.async_start (mhlo::AsyncStartOp)

عملية AsyncStart

هذه العملية خاصة بمترجم XLA، لذا فهي لا تحتوي على مواصفات محددة حتى الآن.

بشكل غير رسمي، تعمل هذه العملية على بدء عملية حسابية غير متزامنة.

يُستخدم هذا عند وجود دوال تحتوي على كلٍّ من الانتظارات غير المتزامنة (مثل DMAs) والحسابات على خيط التنفيذ. على سبيل المثال، قد تتكون الدالة من عملية حسابية، وDMA، وحساب آخر، وDMA ثانٍ، وحساب نهائي. يُمثَّل هذا بـ async_start متبوعًا بـ async_update وasync_done. يُجري async_start الحساب الأول على خيط التنفيذ، ثم يُشغِّل DMA. ينتظر async_update اكتمال DMA إذا لم يكن قد اكتمل بعد، ثم يُنفِّذ الحساب الثاني في الدالة، ويبدأ DMA الثاني. وأخيرًا، ينتظر async_done على DMA الأخير، ثم يُشغِّل الحساب الأخير المطلوب تنفيذه على خيط التنفيذ، ويُعيد نتيجة الحساب النهائي.

تُمرَّر operands إلى العملية الحسابية مباشرةً. الدالة التي ستُشغَّل بشكل غير متزامن هي الدالة called_computation execution_thread هو اسم الخيط الذي سيُشغَّل فيه. يُسمَّى الخيط الرئيسي "main". جميع السلاسل لها أسماء.

يُرجع هذا جميع الحالات المطلوبة بين العمليات غير المتزامنة. بعد تعيين المخزن المؤقت، تُمثل قيم الإرجاع المساحة اللازمة لحفظ المُدخلات والنتائج وأي سجلات مطلوبة أو مُحررة بواسطة العملية غير المتزامنة.

صفات:

المتعاملات:

نتائج:

mhlo.async_update (mhlo::AsyncUpdateOp)

عملية التحديث غير المتزامن

هذه العملية خاصة بمترجم XLA، لذا فهي لا تحتوي على مواصفات محددة حتى الآن.

بشكل غير رسمي، تمنع هذه العملية الحوسبة غير المتزامنة حتى يتم الوصول إلى حاجز مزامنة. تُرجع هذه العملية bundle بعد تنفيذها.

راجع وثائق AsyncStart للحصول على مزيد من المعلومات.

الواجهات: InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.atan2 (mhlo::Atan2Op)

عملية أتان2

بناء الجملة:

operation ::= `mhlo.atan2` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

يقوم بإجراء عملية atan2 على كل عنصر على موتر الجانب lhs rhs وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

مثال:

%result = mhlo.atan2 %lhs, %rhs : tensor<3xf32>

السمات: AlwaysSpeculatableImplTrait ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.atanh (mhlo::AtanhOp)

عملية أتانه

بناء الجملة:

operation ::= `mhlo.atanh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

يقوم بإجراء عملية atanh على كل عنصر على موتر operand وينتج موتر result .

مثال:

%result = mhlo.atanh %operand : tensor<2x2xf32>

السمات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: InferShapedTypeOpInterface ، InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

عملية BatchNormGrad

يحسب تدرجات العديد من مدخلات BatchNormTrainingOp التي تنتشر للخلف من grad_output ، وينتج متجهات grad_operand و grad_scale و grad_offset .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

مثال:

%grad_operand, %grad_scale, %grad_offset =
"mhlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>,
    tensor<2x2x2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

السمات: AlwaysSpeculatableImplTrait و InferTensorType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

عملية BatchNormInference

يقوم بتطبيع موتر operand عبر جميع الأبعاد باستثناء بُعد feature_index وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

مثال:

%result = "mhlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>) -> tensor<2x2x2xf32>

السمات: AlwaysSpeculatableImplTrait و InferTensorType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

عملية BatchNormTraining

يحسب المتوسط ​​والتباين عبر أبعاد الدفعة والأبعاد المكانية ويقوم بتطبيع موتر operand ، لكل ميزة في بُعد feature_index وينتج output و batch_mean و batch_var .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

مثال:

%output, %batch_mean, %batch_var = "mhlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

السمات: AlwaysSpeculatableImplTrait و InferTensorType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.bitcast (mhlo::BitcastOp)

عملية البث المباشر

بناء الجملة:

operation ::= `mhlo.bitcast` operands attr-dict `:` functional-type(operands, results)

هذه العملية خاصة بمترجم XLA، لذا فهي لا تحتوي على مواصفات محددة حتى الآن.

بشكل غير رسمي، تقوم هذه العملية بتغيير شكل المدخلات بالطريقة التي يظل بها الترتيب المادي للعناصر دون تغيير.

تحتاج هذه العملية إلى معلومات التخطيط لفهم "الترتيب المادي للعناصر"، ودعم التخطيط في MHLO هو حاليًا عمل قيد التقدم.

مثال:

%0 = mhlo.bitcast %arg0 : (tensor<3x4xf32>) -> tensor<3x4x1xf32>

السمات: AlwaysSpeculatableImplTrait

الواجهات: ConditionallySpeculatable ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

عملية BitcastConvert

بناء الجملة:

operation ::= `mhlo.bitcast_convert` operands attr-dict `:` functional-type(operands, results)

يقوم بإجراء عملية بث بتات على موتر operand وينتج موتر result حيث يتم إعادة تفسير بتات موتر operand بأكمله باستخدام نوع موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

مثال:

%result = mhlo.bitcast_convert %operand : (tensor<2xf32>) -> tensor<2x4xi8>

السمات: AlwaysSpeculatableImplTrait

الواجهات: ConditionallySpeculatable و InferShapedTypeOpInterface و NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.broadcast (mhlo::BroadcastOp)

عملية البث

هذه العملية في طريقها للخروج من StableHLO، لذا فهي غير مدرجة في المواصفات: https://github.com/openxla/stablehlo/issues/3

بشكل غير رسمي، تقوم هذه العملية بنفس الشيء الذي تقوم به عملية البث الخاصة بـ XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

مثال:

%result = mhlo.broadcast %operand, sizes = [1, 2] : (tensor<3xi32>) -> tensor<1x2x3xi32>

السمات: AlwaysSpeculatableImplTrait و InferTensorType و SameOperandsAndResultElementType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

عملية BroadcastInDim

يقوم بتوسيع أبعاد و/أو رتبة موتر الإدخال عن طريق تكرار البيانات في موتر operand وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

مثال:

%result = mhlo.broadcast_in_dim %operand, dims = [2, 1] : (tensor<1x3xi32>) -> tensor<2x3x2xi32>

السمات: AlwaysSpeculatableImplTrait و HLO_CompatibleOperandsAndResultElementType

الواجهات: ConditionallySpeculatable ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.case (mhlo::CaseOp)

عملية الحالة

ينتج الناتج عن تنفيذ function واحدة فقط من branches اعتمادًا على قيمة index .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

مثال:

%result0, %result1 = "mhlo.case"(%index) ({
  mhlo.return %result_branch0, %result_branch0 : tensor<2xi64>, tensor<2xi64>
}, {
  mhlo.return %result_branch1, %result_branch1 : tensor<2xi64>, tensor<2xi64>
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)

السمات: RecursiveMemoryEffects ، SingleBlockImplicitTerminator<ReturnOp> ، SingleBlock

الواجهات: InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.cbrt (mhlo::CbrtOp)

عملية Cbrt

بناء الجملة:

operation ::= `mhlo.cbrt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

يقوم بإجراء عملية الجذر التكعيبي لكل عنصر على موتر operand وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

مثال:

%result = mhlo.cbrt %operand : tensor<4xf32>

السمات: AlwaysSpeculatableImplTrait ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.ceil (mhlo::CeilOp)

عملية السقف

بناء الجملة:

operation ::= `mhlo.ceil` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

يقوم بتنفيذ سقف عنصر الموتر operand وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

مثال:

%result = mhlo.ceil %operand : tensor<5xf32>

السمات: AlwaysSpeculatableImplTrait ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.cholesky (mhlo::CholeskyOp)

عملية تشوليسكي

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

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

مثال:

%result = mhlo.cholesky %a, lower = true : tensor<3x3xf32>

السمات: AlwaysSpeculatableImplTrait و InferTensorType و SameOperandsAndResultElementType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.clamp (mhlo::ClampOp)

عملية المشبك

بناء الجملة:

operation ::= `mhlo.clamp` $min `,` $operand `,` $max attr-dict
              `:` custom<SameOperandsAndResultType>(type($min), type($operand), type($max), type($result))

يقوم بتثبيت كل عنصر من عناصر موتر operand بين الحد الأدنى والحد الأقصى للقيمة وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

مثال:

%result = mhlo.clamp %min, %operand, %max : tensor<3xi32>

السمات: AlwaysSpeculatableImplTrait ، HLO_BroadcastingElementwise ، InferTensorType ، SameOperandsAndResultElementType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

عملية البث الجماعي

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

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

مثال:

%result = "mhlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<1x2xi64>) -> tensor<1x2xi64>

السمات: CompatibleOperandsAndResultType

الواجهات: InferShapedTypeOpInterface ، InferTypeOpInterface

صفات:

المتعاملات:

نتائج:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

عملية CollectivePermute

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

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

مثال:

%result = "mhlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<4x2xf32>) -> tensor<4x2xf32>

السمات: AlwaysSpeculatableImplTrait و CompatibleOperandsAndResultType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.compare (mhlo::CompareOp)

مقارنة العملية

بناء الجملة:

operation ::= `mhlo.compare` $comparison_direction `,` $lhs `,` $rhs (`,` $compare_type^)?
              attr-dict `:` functional-type(operands, results)

يقوم بإجراء مقارنة على أساس كل عنصر لموترات lhs rhs وفقًا لـ comparison_direction و compare_type ، وينتج موتر result .

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

مثال:

%result = mhlo.compare LT, %lhs, %rhs, FLOAT : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>

السمات: AlwaysSpeculatableImplTrait ، Elementwise ، InferTensorType ، SameOperandsAndResultShape ، SameOperandsElementType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.complex (mhlo::ComplexOp)

عملية معقدة

بناء الجملة:

operation ::= `mhlo.complex` operands attr-dict
              `:` custom<ComplexOpType>(type($lhs), type($rhs), type($result))

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

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

مثال:

%result = mhlo.complex %lhs, %rhs : tensor<2xcomplex<f32>>

السمات: AlwaysSpeculatableImplTrait ، Elementwise ، SameOperandsAndResultShape ، SameOperandsElementType

الواجهات: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

التأثيرات: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.composite (mhlo::CompositeOp)

عملية مركبة

بناء الجملة:

operation ::= `mhlo.composite` $name $inputs attr-dict `:` functional-type(operands, results)

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

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

انظر: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#composite

مثال:

%results = mhlo.composite "my.op" %arg0, %arg1 {
  decomposition = @my_op,
  composite_attributes = { my_attribute = "my_value" },
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

الواجهات: SymbolUserOpInterface

صفات:

المتعاملات:

نتائج:

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

Concatenates a variadic number of tensors in inputs along dimension dimension in the same order as the given arguments and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#concatenate

مثال:

%result = mhlo.concatenate %input0, %input1, dim = 0 : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.constant (mhlo::ConstantOp)

Constant operation

Produces an output tensor from a constant value .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

مثال:

%output = mhlo.constant dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , ConstantLike

الواجهات: ConditionallySpeculatable ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

نتائج:

mhlo.convert (mhlo::ConvertOp)

Convert operation

بناء الجملة:

operation ::= `mhlo.convert` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs an element-wise conversion from one element type to another on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convert

مثال:

%result = mhlo.convert %operand : (tensor<3xi32>) -> tensor<3xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.convolution (mhlo::ConvolutionOp)

عملية الالتفاف

بناء الجملة:

operation ::= `mhlo.convolution` `(`operands`)`
              `dim_numbers` `=` custom<ConvolutionDimensions>($dimension_numbers) `,`
              `window` `=` `{` custom<WindowAttributes>($window_strides, $padding,
              $lhs_dilation, $rhs_dilation,
              $window_reversal) `}`
              attr-dict `:` functional-type(operands, results)

Computes dot products between windows of lhs and slices of rhs and produces result .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

مثال:

%result = "mhlo.convolution"(%lhs, %rhs) {
  window_strides = dense<4> : tensor<2xi64>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.copy (mhlo::CopyOp)

Copy operation

بناء الجملة:

operation ::= `mhlo.copy` operands attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation a copy of operand . Depending on the metadata attached to the operation, it can behave quite differently from a no-op.

مثال:

%0 = mhlo.copy %arg0 : tensor<f32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.cosh (mhlo::CoshOp)

Cosh operation

بناء الجملة:

operation ::= `mhlo.cosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosh operation on operand tensor and produces a result tensor.

مثال:

%result = mhlo.cosh %operand : tensor<2x2xf32>

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

المتعاملات:

نتائج:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

بناء الجملة:

operation ::= `mhlo.cosine` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosine operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cosine

مثال:

%result = mhlo.cosine %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

بناء الجملة:

operation ::= `mhlo.count_leading_zeros` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise count of the number of leading zero bits in the operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#count_leading_zeros

مثال:

%result = mhlo.count_leading_zeros %operand : tensor<2x2xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

بناء الجملة:

operation ::= `mhlo.create_token` attr-dict `:` type(results)

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AfterAllOp with 0 inputs: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

مثال:

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

الواجهات: ConditionallySpeculatable ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

نتائج:

mhlo.cross-replica-sum (mhlo::CrossReplicaSumOp)

CrossReplicaSum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AllReduceOp with channel_id = 0 , use_global_device_ids = false and computation implementing addition: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

مثال:

%result = "mhlo.cross-replica-sum"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<4xf32>) -> tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

بناء الجملة:

operation ::= `mhlo.custom_call` custom<CustomCallTarget>($call_target_name) `(` $inputs `)`
              attr-dict `:` functional-type(operands, results)

Encapsulates an implementation-defined operation call_target_name that takes inputs and called_computations and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#custom_call

مثال:

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

A custom call invokes code external to XLA. The `inputs` are passed to the
external code, and the external code is expected to produce a result of the
given type. The exact mechanism is backend-specific. For example, in the CPU
backend, a call instruction is emitted which targets a symbol with the name
`call_target_name`.

If XLA runtime is enabled for a backend, then custom calls use the runtime
custom call calling convention to call into the external functions. This
calling convention defines an ABI for encoding arguments, attributes and
results.

Depending on the API version there are two ways to pass extra bits of static
information to the external function:

1. For `API_VERSION_TYPED_FFI` custom calls `backend_config` must be a
   dictionary attribute, that will be encoded according to the custom call
   calling convention and passed to the external function as the attributes
   argument. External code is expected to use declarative bindings (see
   `xla/runtime/custom_call.h`) to decode them at run time. These custom
   calls are only supported if XLA uses XLA runtime.

2. For previous API versions it is the user responsibility to encode extra
   bits of static information as a string `backend_config` attribute, and
   decode it at run time.

Interfaces: MemoryEffectOpInterface

صفات:

المتعاملات:

نتائج:

mhlo.divide (mhlo::DivOp)

Div operation

بناء الجملة:

operation ::= `mhlo.divide` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise division of dividend lhs and divisor rhs tensors and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#divide

مثال:

%result = mhlo.divide %lhs, %rhs : tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.domain (mhlo::DomainOp)

Domain operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, these operations are used to group instructions with the same DomainMetadata property. ShardingMetadata is the main use case today to group instructions on the same device. Domain instructions provide two major benefits:

• Prevent unintentionally optimizing instructions across domains.
• Automatically assign the metadata of the instructions created in the domain. Without domain instructions, each HLO optimization pass would have to check and propagate the metadata, which would be easy to miss and also adds complexity to the compiler. Since domain instructions connect two different domains, each domain instruction is associated with two DomainMetadata -- one on the operand side and one on the user side of the domain.

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.dot (mhlo::DotOp)

Dot operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as XLA's Dot: https://www.tensorflow.org/xla/operation_semantics#dot

مثال:

%0 = mhlo.dot %arg0, %arg1 : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<1x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

Computes dot products between slices of lhs and slices of rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dot_general

مثال:

%result = "mhlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #mhlo.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>]
} : (tensor<2x2x2xi32>, tensor<2x2x2xi32>) -> tensor<2x2x2xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

This operation is functionally identical to broadcast_in_dim op, but the result shape is specified dynamically via output_dimensions .

It also accepts optional attributes to express static knowledge about the expanding behavior of dimensions. If not specified, all dimensions are assumed to be possibly expanding. The sets of dimensions that are known to be expanding and the set of dimensions that are known to be non-expanding must be disjoint and they must be a subset of the operand's dimensions.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_broadcast_in_dim

مثال:

%operand = mhlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = mhlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "mhlo.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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as ConvolutionOp except that padding is specified dynamically via d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

مثال:

%result = "mhlo.dynamic_conv"(%lhs, %rhs, %d_padding) {
  window_strides = dense<4> : tensor<2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>, tensor<2x2xi64>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as GatherOp except that slice_sizes are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

مثال:

%result = "mhlo.dynamic_gather"(%operand, %start_indices, %slice_sizes) {
  dimension_numbers = #mhlo.gather<
    offset_dims = [2, 3],
    collapsed_slice_dims = [0],
    start_index_map = [0, 2],
    index_vector_dim = 2>,
  indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>, tensor<3xi64>) -> tensor<2x3x2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

This operation is functionally identical to iota op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_iota

مثال:

%0 = mhlo.dynamic_iota %arg0, dim = 0 : (tensor<1xindex>) -> tensor<4xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

بناء الجملة:

operation ::= `mhlo.dynamic_pad` operands attr-dict `:` functional-type(operands, results)

Dynamically Pads the operand , with amount of padding added at low-end/high-end/interior is passed through input tensors.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

بناء الجملة:

operation ::= `mhlo.dynamic_reshape` operands attr-dict `:` functional-type(operands, results)

This operation is functionally identical to reshape op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_reshape

مثال:

%output_shape = mhlo.constant dense<[3, 2]> : tensor<2xi64>
%result = mhlo.dynamic_reshape %operand, %output_shape : (tensor<2x3xi64>, tensor<2xi64>) -> tensor<3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

Extracts a slice from the operand using dynamically-computed starting indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_slice

مثال:

%result = mhlo.dynamic_slice %operand, %start_indices0, %start_indices1, sizes = [2, 2]
  : (tensor<4x4xi32>, tensor<i64>, tensor<i64>) -> tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

بناء الجملة:

operation ::= `mhlo.dynamic_update_slice` operands attr-dict `:` functional-type(operands, results)

Produces a result tensor which is equal to the operand tensor except that the slice starting at start_indices is updated with the values in update .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_update_slice

مثال:

%result = mhlo.dynamic_update_slice %operand, %update, %start_indices0, %start_indices1
  : (tensor<4x4xi32>, tensor<2x2xi32>, tensor<i64>, tensor<i64>) -> tensor<4x4xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.einsum (mhlo::EinsumOp)

Einsum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as TF's einsum: https://www.tensorflow.org/api_docs/python/tf/einsum

مثال:

%result = "mhlo.einsum"(%lhs, %rhs) {
  einsum_config = "ab,bc->ac"
} : (tensor<4x16xf32>, tensor<16x4xf32>) -> tensor<4x4xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.erf (mhlo::ErfOp)

Erf operation

بناء الجملة:

operation ::= `mhlo.erf` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise erf operation on operand tensor and produces a result tensor.

مثال:

%result = mhlo.erf %operand : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.exponential (mhlo::ExpOp)

Exp operation

بناء الجملة:

operation ::= `mhlo.exponential` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential

مثال:

%result = mhlo.exponential %operand : tensor<2x2xf64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

بناء الجملة:

operation ::= `mhlo.exponential_minus_one` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential minus one operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential_minus_one

مثال:

%result = mhlo.exponential_minus_one %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.fft (mhlo::FftOp)

Fft operation

Performs the forward and inverse Fourier transforms for real and complex inputs/outputs.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#fft

مثال:

%result = mhlo.fft %operand, type = FFT, length = [4] : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.floor (mhlo::FloorOp)

Floor operation

بناء الجملة:

operation ::= `mhlo.floor` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise floor of operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#floor

مثال:

%result = mhlo.floor %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

المتعاملات:

نتائج:

mhlo.fusion (mhlo::FusionOp)

Fusion operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation consists of a group of basic ops (represented as a region attached to it). It serves as a hint to the backend that it is beneficial to emit the contained ops into a single loop nest or kernel.

صفات:

المتعاملات:

نتائج:

mhlo.gather (mhlo::GatherOp)

Gather operation

Gathers slices from operand tensor from offsets specified in start_indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

مثال:

%result = "mhlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [3, 4],
    collapsed_slice_dims = [1],
    operand_batching_dims = [0],
    start_indices_batching_dims = [1],
    start_index_map = [2, 1],
    index_vector_dim = 3>,
  slice_sizes = dense<[0, 2, 2]> : tensor<3xi64>,
  indices_are_sorted = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>) -> tensor<2x2x3x2x2xi64>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.get_dimension_size (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

Produces the size of the given dimension of the operand .

See https://github.com/openxla/stablehlo/blob/main/docs/spec.md#get_dimension_size

مثال:

%result = mhlo.get_dimension_size %operand, dim = 1 : (tensor<2x3xf32>) -> tensor<i32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

المتعاملات:

نتائج:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

بناء الجملة:

operation ::= `mhlo.get_tuple_element` $operand `[` $index `]` attr-dict `:` functional-type(operands, results)