「ムロ」方言

オペレーション

mhlo.abs (mhlo::AbsOp)

腹筋手術

構文：

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

operandテンソルに対して要素ごとの絶対値演算を実行し、 resultテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

例：

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

特性: AlwaysSpeculatableImplTrait 、 Elementwise 、 SameOperandsAndResultShape

インターフェース: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.acos (mhlo::AcosOp)

Acos操作

構文：

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

operandテンソルに対して要素ごとの acos 演算を実行し、 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))

operandテンソルに対して要素ごとの acosh 演算を実行し、 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))

2 つのテンソル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 コンパイラ専用なので、まだ仕様がありません。

非公式には、この演算はデータオペランドとトークンの2つのオペランドを持ちます。演算の出力はデータオペランドです。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内の各オペランドに対して個別に適用され、オペランドごとに1つの結果が生成されます。

参照: 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内の各オペランドに対して個別に適用され、オペランドごとに1つの結果が生成されます。

参照: 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))

2つのテンソルlhsとrhsの要素ごとのANDを実行し、 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)

ASIN操作

構文：

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

operandテンソルに対して要素ごとの asin 演算を実行し、 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))

operandテンソルに対して要素ごとの asinh 演算を実行し、 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、別の計算、2番目のDMA、そして最後の計算で構成されるとします。これは、async_start、async_update、async_doneの順に記述されます。async_startはオンスレッドで最初の計算を実行し、その後DMAを開始します。async_updateは、DMAがまだ完了していない場合は完了を待機し、関数内の2番目の計算を実行して2番目のDMAを開始します。最後に、async_doneは最後のDMAを待機し、オンスレッドで実行する必要がある最後の計算を実行し、その最終計算の結果を返します。

operands計算に直接渡されますcalled_computation非同期に実行される関数です。execution_thread execution_thread実行されるスレッドの名前です。メインスレッドは「main」と呼ばれます。すべてのスレッドには名前があります。

これは非同期処理間で必要なすべての状態を返します。バッファへの代入後、戻り値は入力、結果、そして非同期処理で必要または編集されたスクラッチパッドを保持するために必要な領域を表します。

属性:

オペランド:

結果：

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

lhsおよびrhsテンソルに対して要素ごとに atan2 演算を実行し、 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))

operandテンソルに対して要素ごとの atanh 演算を実行し、 resultテンソルを生成します。

例：

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

特性: CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

インターフェース: InferShapedTypeOpInterface 、 InferTypeOpInterface

オペランド:

結果：

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

BatchNormGrad操作

grad_outputからバックプロパゲーションする BatchNormTrainingOp の複数の入力の勾配を計算し、 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操作

feature_index次元を除くすべての次元にわたってoperandテンソルを正規化し、 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操作

バッチ次元と空間次元全体の平均と分散を計算し、 feature_index次元の各特徴に対してoperandテンソルを正規化して、 output 、 batch_mean 、 batch_varテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

例：

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

特性: AlwaysSpeculatableImplTrait 、 InferTensorType

インターフェース: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

属性:

オペランド:

結果：

mhlo.bitcast (mhlo::BitcastOp)

ビットキャスト操作

構文：

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

この操作は XLA コンパイラ専用なので、まだ仕様がありません。

非公式には、この操作は要素の物理的な配置を変更せずに入力の形状を変更します。

この操作では、「要素の物理的な配置」を理解するためにレイアウト情報が必要であり、MHLO でのレイアウト サポートは現在進行中です。

例：

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

特性: AlwaysSpeculatableImplTrait

インターフェース: ConditionallySpeculatable 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

BitcastConvert操作

構文：

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

operandテンソルに対してビットキャスト演算を実行し、 resultテンソルの型を使用してoperandテンソル全体のビットが再解釈されたresultテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

例：

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

特性: AlwaysSpeculatableImplTrait

インターフェース: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.broadcast (mhlo::BroadcastOp)

放送操作

この操作は StableHLO から削除される予定であるため、仕様には含まれていません: https://github.com/openxla/stablehlo/issues/3

非公式には、この操作は XLA のブロードキャストと同じことを行います: https://www.tensorflow.org/xla/operation_semantics#broadcast

例：

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

特性: AlwaysSpeculatableImplTrait 、 InferTensorType 、 SameOperandsAndResultElementType

インターフェース: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

属性:

オペランド:

結果：

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

BroadcastInDim操作

operandテンソルのデータを複製して入力テンソルの次元やランクを拡張し、 resultテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

例：

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

特性: AlwaysSpeculatableImplTrait 、 HLO_CompatibleOperandsAndResultElementType

インターフェース: ConditionallySpeculatable 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

属性:

オペランド:

結果：

mhlo.case (mhlo::CaseOp)

ケース操作

indexの値に応じて、 branchesから 1 つのfunctionだけを実行して出力を生成します。

参照: 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テンソルに対して要素ごとの 3 次根演算を実行し、 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テンソルの要素ごとの ceil を実行し、 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)

CollectiveBroadcast 運用

プロセス グリッドの各プロセス グループ内で、 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)

comparison_directionとcompare_typeに従ってlhsとrhsテンソルの要素ごとの比較を実行し、 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

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

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.composite (mhlo::CompositeOp)

Composite operation

構文：

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

Attributes:

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

Attributes:

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

Attributes:

結果：

mhlo.convert (mhlo::ConvertOp)

Convert operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.copy (mhlo::CopyOp)

Copy operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.cosh (mhlo::CoshOp)

Cosh operation

構文：

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

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

例：

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

結果：

mhlo.cosine (mhlo::CosineOp)

Cosine operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

構文：

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

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

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

例：

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

結果：

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

CrossReplicaSum operation

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

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

Attributes:

Operands:

結果：

mhlo.divide (mhlo::DivOp)

Div operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.domain (mhlo::DomainOp)

Domain operation

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

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

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

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

Attributes:

Operands:

結果：

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

構文：

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

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.einsum (mhlo::EinsumOp)

Einsum operation

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

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.

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.exponential (mhlo::ExpOp)

Exp operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

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

Attributes:

Operands:

結果：

mhlo.floor (mhlo::FloorOp)

Floor operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.fusion (mhlo::FusionOp)

Fusion operation

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

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

Attributes:

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

Attributes:

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

Attributes:

Operands:

結果：

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

構文：

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