'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.acos (mhlo::AcosOp)

عملیات آکوس

نحو:

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

عملیات acos را به صورت عنصر به عنصر روی تانسور operand انجام می‌دهد و یک تانسور result تولید می‌کند.

مثال:

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

صفات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

رابط‌ها: InferShapedTypeOpInterface ، InferTypeOpInterface

عملوندها:

نتایج:

mhlo.acosh (mhlo::AcoshOp)

عملیات آکوش

نحو:

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

عملیات acosh را به صورت عنصر به عنصر روی تانسور operand انجام می‌دهد و یک تانسور result تولید می‌کند.

مثال:

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

صفات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

رابط‌ها: InferShapedTypeOpInterface ، InferTypeOpInterface

عملوندها:

نتایج:

mhlo.add (mhlo::AddOp)

عملیات را اضافه کنید

نحو:

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

جمع دو تانسور lhs و rhs را به صورت عنصر به عنصر انجام می‌دهد و یک تانسور result تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

مثال:

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

ویژگی‌ها: AlwaysSpeculatableImplTrait ، Commutative ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

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

اثرات: MemoryEffects::Effect{}

عملوندها:

نتایج:

mhlo.add_dependency (mhlo::AddDependencyOp)

عملیات 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.asin (mhlo::AsinOp)

عملیات آسین

نحو:

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

عملیات آسین (asin) را به صورت عنصر به عنصر روی تانسور operand انجام می‌دهد و یک تانسور result تولید می‌کند.

مثال:

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

صفات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

رابط‌ها: InferShapedTypeOpInterface ، InferTypeOpInterface

عملوندها:

نتایج:

mhlo.asinh (mhlo::AsinhOp)

عملیات آسین

نحو:

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

عملیات آسین (asinh) را به صورت عنصر به عنصر روی تانسور operand انجام می‌دهد و یک تانسور result تولید می‌کند.

مثال:

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

صفات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

رابط‌ها: InferShapedTypeOpInterface ، InferTypeOpInterface

عملوندها:

نتایج:

mhlo.async_done (mhlo::AsyncDoneOp)

عملیات AsyncDone

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

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

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

رابط‌ها: InferTypeOpInterface

عملوندها:

نتایج:

mhlo.async_start (mhlo::AsyncStartOp)

عملیات AsyncStart

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

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

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

operands مستقیماً به محاسبه ارسال می‌شوند که به called_computation و تابعی است که به صورت ناهمگام اجرا خواهد شد. execution_thread نام نخی است که در آن اجرا خواهد شد. نخ اصلی "main" نامیده می‌شود. همه نخ‌ها نام دارند.

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

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.async_update (mhlo::AsyncUpdateOp)

عملیات AsyncUpdate

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

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

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

رابط‌ها: InferTypeOpInterface

عملوندها:

نتایج:

mhlo.atan2 (mhlo::Atan2Op)

عملیات آتان۲

نحو:

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

عملیات atan2 را به صورت عنصر به عنصر روی تانسورهای lhs و rhs انجام می‌دهد و یک تانسور result تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

مثال:

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

ویژگی‌ها: AlwaysSpeculatableImplTrait ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

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

اثرات: MemoryEffects::Effect{}

عملوندها:

نتایج:

mhlo.atanh (mhlo::AtanhOp)

عملیات آتانه

نحو:

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

عملیات atanh را به صورت عنصر به عنصر روی تانسور operand انجام می‌دهد و یک تانسور result تولید می‌کند.

مثال:

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

صفات: CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

رابط‌ها: InferShapedTypeOpInterface ، InferTypeOpInterface

عملوندها:

نتایج:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

عملیات BatchNormGrad

گرادیان‌های چندین ورودی BatchNormTrainingOp را که از grad_output به عقب انتشار می‌یابند، محاسبه می‌کند و تنسورهای grad_operand ، grad_scale و grad_offset را تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

مثال:

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

صفات: AlwaysSpeculatableImplTrait ، InferTensorType

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

عملیات استنتاج BatchNorm

تنسور operand در تمام ابعاد به جز بعد feature_index نرمال‌سازی می‌کند و یک تنسور result تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

مثال:

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

صفات: AlwaysSpeculatableImplTrait ، InferTensorType

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

عملیات BatchNormTraining

میانگین و واریانس را در ابعاد دسته‌ای و مکانی محاسبه می‌کند و تانسور operand را برای هر ویژگی در بعد feature_index نرمال‌سازی می‌کند و output ، تانسورهای batch_mean و batch_var تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

مثال:

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

صفات: AlwaysSpeculatableImplTrait ، InferTensorType

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.bitcast (mhlo::BitcastOp)

عملیات بیت‌کست

نحو:

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

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

به طور غیررسمی، این عملیات شکل ورودی را به گونه‌ای تغییر می‌دهد که چیدمان فیزیکی عناصر بدون تغییر باقی بماند.

این عملیات برای درک «چیدمان فیزیکی عناصر» به اطلاعات طرح‌بندی نیاز دارد و پشتیبانی از طرح‌بندی در MHLO در حال حاضر در حال انجام است.

مثال:

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

ویژگی‌ها: AlwaysSpeculatableImplTrait

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

اثرات: MemoryEffects::Effect{}

عملوندها:

نتایج:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

عملیات BitcastConvert

نحو:

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

یک عملیات تبدیل بیت (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)

عملیات پخش

این عملیات در حال خروج از StableHLO است، بنابراین در مشخصات آن لحاظ نشده است: https://github.com/openxla/stablehlo/issues/3

به طور غیررسمی، این عملیات همان کار Broadcast مربوط به XLA را انجام می‌دهد: https://www.tensorflow.org/xla/operation_semantics#broadcast

مثال:

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

ویژگی‌ها: AlwaysSpeculatableImplTrait ، InferTensorType ، SameOperandsAndResultElementType

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

عملیات BroadcastInDim

ابعاد و/یا رتبه یک تانسور ورودی را با کپی کردن داده‌ها در تانسور operand گسترش می‌دهد و یک تانسور result تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

مثال:

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

صفات: AlwaysSpeculatableImplTrait ، HLO_CompatibleOperandsAndResultElementType

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.case (mhlo::CaseOp)

عملیات موردی

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

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

مثال:

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

ویژگی‌ها: RecursiveMemoryEffects ، SingleBlockImplicitTerminator<ReturnOp> ، SingleBlock

رابط‌ها: InferTypeOpInterface

عملوندها:

نتایج:

mhlo.cbrt (mhlo::CbrtOp)

عملیات Cbrt

نحو:

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

عملیات ریشه سوم عنصر به عنصر را روی تانسور operand انجام می‌دهد و یک تانسور result تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

مثال:

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

ویژگی‌ها: AlwaysSpeculatableImplTrait ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.ceil (mhlo::CeilOp)

عملیات سقف

نحو:

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

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

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

مثال:

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

ویژگی‌ها: AlwaysSpeculatableImplTrait ، CompatibleOperandsAndResultType ، Elementwise ، SameOperandsAndResultShape

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

اثرات: MemoryEffects::Effect{}

عملوندها:

نتایج:

mhlo.cholesky (mhlo::CholeskyOp)

عملیات چولسکی

تجزیه چولسکی دسته‌ای از ماتریس‌ها را محاسبه می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

مثال:

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

ویژگی‌ها: AlwaysSpeculatableImplTrait ، InferTensorType ، SameOperandsAndResultElementType

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.clamp (mhlo::ClampOp)

عملکرد گیره

نحو:

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

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

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

مثال:

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

صفات: AlwaysSpeculatableImplTrait ، HLO_BroadcastingElementwise ، InferTensorType ، SameOperandsAndResultElementType

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

اثرات: MemoryEffects::Effect{}

عملوندها:

نتایج:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

عملیات پخش جمعی

در هر گروه فرآیند در شبکه فرآیند، مقدار تانسور operand را از فرآیند مبدا به فرآیندهای هدف ارسال کنید و یک تانسور result تولید کنید.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

مثال:

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

صفات: CompatibleOperandsAndResultType

رابط‌ها: InferShapedTypeOpInterface ، InferTypeOpInterface

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

عملیات CollectivePermute

در هر گروه فرآیند در شبکه فرآیند، مقدار تانسور operand از فرآیند مبدا به فرآیند مقصد ارسال می‌کند و یک تانسور result تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

مثال:

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

صفات: AlwaysSpeculatableImplTrait ، CompatibleOperandsAndResultType

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.compare (mhlo::CompareOp)

عملیات مقایسه

نحو:

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

مقایسه عنصر به عنصر تانسورهای lhs و rhs را طبق comparison_direction و compare_type انجام می‌دهد و یک تانسور result تولید می‌کند.

ببینید: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

مثال:

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

ویژگی‌ها: AlwaysSpeculatableImplTrait ، Elementwise ، InferTensorType ، SameOperandsAndResultShape ، SameOperandsElementType

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

اثرات: MemoryEffects::Effect{}

ویژگی‌ها:

عملوندها:

نتایج:

mhlo.complex (mhlo::ComplexOp)

عملیات پیچیده

نحو:

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

Performs element-wise conversion to a complex value from a pair of real and imaginary values, lhs and rhs , and produces a result tensor.

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

مثال:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Effects: MemoryEffects::Effect{}

Operands:

نتایج:

mhlo.composite (mhlo::CompositeOp)

Composite operation

Syntax:

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

Encapsulates an operation made up (composed) of other StableHLO operations, taking inputs and composite_attributes and producing results . The semantics of the op are implemented by the decomposition attribute. The composite op can be replaced with its decomposition without changing program semantics. In cases where inlining the decomposition does not provide the same op semantics, prefer using custom_call .

The version field (defaults to 0 ) is used to denote when a composite's semantics change.

See: 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>

Interfaces: SymbolUserOpInterface

ویژگی‌ها:

Operands:

نتایج:

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

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

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

مثال:

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

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

ویژگی‌ها:

Operands:

نتایج:

mhlo.constant (mhlo::ConstantOp)

Constant operation

Produces an output tensor from a constant value .

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

مثال:

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

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ویژگی‌ها:

نتایج:

mhlo.convert (mhlo::ConvertOp)

Convert operation

Syntax:

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

Syntax:

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

Syntax:

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.cosh (mhlo::CoshOp)

Cosh operation

Syntax:

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

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

مثال:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

نتایج:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

Syntax:

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

Syntax:

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

Syntax:

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

Syntax:

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

Syntax:

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

Syntax:

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

Syntax:

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

Syntax:

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

Syntax:

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

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

مثال:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

نتایج:

mhlo.exponential (mhlo::ExpOp)

Exp operation

Syntax:

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

Syntax:

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

Syntax:

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

Syntax:

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