'mhlo' گویش

عملیات

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

عملیات AddDependency

نحو:

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)

عملیات AfterAll

نحو:

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.async_done (mhlo::AsyncDoneOp)

عملیات AsyncDone

این عملیات برای کامپایلر XLA خصوصی است، بنابراین هنوز مشخصاتی ندارد.

به طور غیر رسمی، این عملیات تا پایان یک محاسبات ناهمزمان مسدود می شود. نتیجه نهایی محاسبات ناهمزمان را برمی گرداند.

برای اطلاعات بیشتر به مستندات AsyncStart مراجعه کنید.

رابط ها: InferTypeOpInterface

عملگرها:

نتایج:

mhlo.async_start (mhlo::AsyncStartOp)

عملیات AsyncStart

این عملیات برای کامپایلر XLA خصوصی است، بنابراین هنوز مشخصاتی ندارد.

به طور غیر رسمی، این عملیات یک محاسبات ناهمزمان را آغاز می کند.

این زمانی استفاده می شود که توابعی وجود داشته باشد که شامل انتظارات ناهمزمان (مانند DMA) و محاسبات درون رشته ای باشد. به عنوان مثال، یک تابع ممکن است از یک محاسبه، یک DMA، یک محاسبات دیگر، یک DMA دوم و یک محاسبه نهایی تشکیل شده باشد. این به عنوان async_start و به دنبال آن async_update و async_done نمایش داده می شود. async_start اولین محاسبات را روی رشته انجام می دهد و سپس DMA را شروع می کند. async_update منتظر می ماند تا DMA تکمیل شود اگر هنوز انجام نشده باشد، سپس دومین محاسبه را در تابع اجرا می کند و DMA دوم را شروع می کند. در نهایت، async_done در آخرین DMA منتظر می‌ماند و سپس آخرین محاسباتی را که باید روی رشته اجرا شود اجرا می‌کند و نتیجه محاسبات نهایی را برمی‌گرداند.

operands به طور مستقیم به محاسبات منتقل می called_computation execution_thread نخ اصلی "اصلی" نامیده می شود. همه رشته ها نام دارند.

این همه حالت مورد نیاز بین عملیات async را برمی گرداند. پس از تخصیص بافر، مقادیر بازگشتی نشان‌دهنده فضای مورد نیاز برای نگهداری ورودی، نتایج، و هرگونه صفحه خراش مورد نیاز یا ویرایش شده توسط async op است.

ویژگی ها:

عملگرها:

نتایج:

mhlo.async_update (mhlo::AsyncUpdateOp)

عملیات AsyncUpdate

این عملیات برای کامپایلر XLA خصوصی است، بنابراین هنوز مشخصاتی ندارد.

به طور غیررسمی، این عملیات در یک محاسبات ناهمزمان تا زمانی که مانع همگام‌سازی شود، مسدود می‌شود. این bundle پس از عمل بر روی آن برمی گرداند.

برای اطلاعات بیشتر به مستندات AsyncStart مراجعه کنید.

رابط ها: InferTypeOpInterface

عملگرها:

نتایج:

mhlo.atan2 (mhlo::Atan2Op)

عملیات Atan2

نحو:

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 را که از 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)

عملیات 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 :: پخش)

عملیات پخش

این عملیات در راه خروج از 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)

عملیات پخش کننده

ابعاد و/یا رتبه یک تانسور ورودی را با کپی کردن داده ها در تانسور 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)

عمل

بسته به مقدار index خروجی را از اجرای دقیقاً یک function از branches تولید می کند.

مشاهده کنید: 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 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

رابط ها: InferShapedTypeOpInterface ، InferTypeOpInterface

ویژگی ها:

عملیات:

نتایج:

mhlo.collective_permute (mhlo :: collectionpermuteop)

عملیات جمع آوری

در هر گروه فرآیند در شبکه فرآیند ، مقدار تانسور 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 SpeculatableImpltrait ، CompatibleOperandsAndResultType

رابط ها: ConditionallySpeculatable ، InferShapedTypeOpInterface ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: MemoryEffects::Effect{}

ویژگی ها:

عملیات:

نتایج:

mhlo.compare (mhlo :: مقایسه)

عملکرد را مقایسه کنید

نحو:

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 تولید می کند. معناشناسی OP توسط ویژگی decomposition اجرا می شود. composite OP را می توان با تجزیه آن بدون تغییر معانی برنامه جایگزین کرد. در مواردی که در حال تجزیه تجزیه ، همان معانی 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)

تبدیل عمل

نحو:

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

تبدیل عناصر عاقلانه از یک عنصر به نوع دیگر در تانسور operand را انجام می دهد و یک تانسور result تولید می کند.

مشاهده کنید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convert

مثال:

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

صفات: AlwaysSpeculatableImplTrait ، Elementwise ، SameOperandsAndResultShape

رابط ها: ConditionallySpeculatable ، InferShapedTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

رابط ها: ConditionallySpeculatable ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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

صفات: AlwaysSpeculatableImplTrait

رابط ها: ConditionallySpeculatable ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

رابط ها: ConditionallySpeculatable ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

رابط ها: ConditionallySpeculatable ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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.

صفات: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

رابط ها: ConditionallySpeculatable ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

رابط ها: ConditionallySpeculatable ، InferTypeOpInterface ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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)

جلوه ها: 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>

صفات: AlwaysSpeculatableImplTrait

رابط ها: ConditionallySpeculatable ، NoMemoryEffect (MemoryEffectOpInterface)

جلوه ها: 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)

جلوه ها: 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)

جلوه ها: MemoryEffects::Effect{}

Operands:

نتایج: