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

العمليات

mhlo.abs (mhlo::AbsOp)

عملية القيمة المطلقة

بناء الجملة:

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

ينفذ عملية القيمة المطلقة للعناصر على موتر 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.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)

كل تقليل العملية

داخل كل مجموعة عمليات في شبكة العمليات، يتم تطبيق 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)

عملية الكل للكل

داخل كل مجموعة عمليات في شبكة العملية، يتم تقسيم قيم موتر 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))

ينفذ عنصرًا حكيمًا وممتدين 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.async_done (mhlo::AsyncDoneOp)

عملية غير متزامنة

هذه العملية خاصة بمترجم 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 هو اسم مؤشر الترابط الذي سيتم تشغيله فيه. الخيط الرئيسي يسمى "الرئيسي". جميع المواضيع لها أسماء.

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

صفات:

المعاملات:

نتائج:

mhlo.async_update (mhlo::AsyncUpdateOp)

عملية AsyncUpdate

هذه العملية خاصة بمترجم 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.batch_norm_grad (mhlo::BatchNormGradOp)

عملية BatchNormGrad

يحسب التدرجات لعدة مدخلات من BatchNormTrainingOp backpropagating من grad_output وينتج grad_operand و grad_scale و grad_offset Tensors.

راجع: 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)

عملية bitcast

بناء الجملة:

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)

يؤدي عملية bitcast على الموتر 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)

عملية البث

هذه العملية في طريقها للخروج من مستقر ، لذلك لا يتم تضمينها في المواصفات: 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)

عملية البث

يوسع أبعاد و/أو رتبة موتر إدخال عن طريق تكرار البيانات في الموتر 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 speculatableImpltrait ، 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 speculatableImpltrait ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

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

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

المعاملات:

نتائج:

mhlo.cholesky (Mhlo :: choleskyop)

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

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

انظر: 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 speculatableImpltrait ، 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

واجهات InferTypeOpInterface InferShapedTypeOpInterface

صفات:

المعاملات:

نتائج:

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)

يؤدي مقارنة العناصر من Tensors 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)

يتغلف عملية مكونة (مكونة) من عمليات مستقرة أخرى ، وأخذ inputs و composite_attributes وإنتاج results . يتم تنفيذ دلالات OP بواسطة سمة decomposition . يمكن استبدال OP composite بالتحلل دون تغيير دلالات البرنامج. في الحالات التي لا يوفر فيها تحديد التحلل نفس دلالات OP ، تفضل استخدام 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)

عملية التسلسل

يسلط عدد المتنوع من الموترات في inputs على طول dimension في نفس الترتيب مثل الوسائط المحددة وينتج عن موتر result .

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

مثال:

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

السمات: AlwaysSpeculatableImplTrait ، SameOperandsAndResultElementType

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

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

صفات:

المعاملات:

نتائج:

mhlo.constant (mhlo :: constantop)

عملية مستمرة

ينتج موتر output من value ثابتة.

انظر: 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>

السمات: AlwaysSpeculatableImplTrait ، ConstantLike

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

التأثيرات: 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{}

Operands:

نتائج:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

بناء الجملة:

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{}

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

Operands:

نتائج:

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{}

Operands:

نتائج:

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

Interfaces: 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{}

صفات:

Operands:

نتائج:

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

صفات:

Operands:

نتائج:

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{}

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

Operands:

نتائج:

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{}

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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.

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

مثال:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

نتائج:

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{}

Operands:

نتائج:

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{}

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

Operands:

نتائج:

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.

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

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{}

صفات:

Operands:

نتائج:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

بناء الجملة:

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

Extracts element at index position of the operand tuple and produces a result .

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

مثال:

%result = mhlo.get_tuple_element %operand[0] : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

Operands:

نتائج:

mhlo.if (mhlo::IfOp)

If operation

Produces the output from executing exactly one branch from true_branch or false_branch depending on the value of pred .

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

Example: %result = "mhlo.if"(%pred) ({ "mhlo.return"(%result_true_branch) : (tensor ) -> () }, { "mhlo.return"(%result_false_branch) : (tensor ) -> () }) : (tensor ) -> tensor

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operands:

نتائج:

mhlo.imag (mhlo::ImagOp)

Imag operation

بناء الجملة:

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

Extracts the imaginary part, element-wise, from the operand and produces a result tensor.

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

مثال:

%result = mhlo.imag %operand : (tensor<2xcomplex<f32>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

نتائج:

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

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

مثال:

%results:2 = "mhlo.infeed"(%token) {
  infeed_config = ""
} : (!mhlo.token) -> (tensor<3x3x3xi32>, !mhlo.token)

صفات:

Operands:

نتائج:

mhlo.iota (mhlo::IotaOp)

Iota operation

Fills an output tensor with values in increasing order starting from zero along the iota_dimension dimension.

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

مثال:

%output = mhlo.iota dim = 0 : tensor<4x5xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

صفات:

نتائج:

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

بناء الجملة:

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

Performs element-wise check whether the value in x is finite (ie is neither +Inf, -Inf, nor NaN) and produces a y tensor.

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

مثال:

%y = mhlo.is_finite %x : (tensor<7xf32>) -> tensor<7xi1>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

نتائج:

mhlo.log (mhlo::LogOp)

Log operation

بناء الجملة:

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

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

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

مثال:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

نتائج: