「ムロ」方言

オペレーション

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

オペランド:

オペランド	説明
operand	2/4/8/16/32/64 ビットの符号なし整数、4/6/8/16/32/64 ビットの浮動小数点数、または 32/64 ビットの浮動小数点数要素を持つ複素数型のランク付きテンソル、2/4/8/16/32 ビットの一様量子化符号付き整数、2/4/8/16/32 ビットの軸ごとに一様量子化された符号付き整数、2/4/8/16/32 ビットの一様量子化符号なし整数、または 2/4/8/16/32 ビットの軸ごとに一様量子化された符号なし整数値のランク付きテンソル

結果：

結果	説明
result	2/4/8/16/32/64 ビットの符号なし整数、4/6/8/16/32/64 ビットの浮動小数点数、2/4/8/16/32 ビットの一様量子化符号整数、2/4/8/16/32 ビットの軸ごとに一様量子化された符号整数、2/4/8/16/32 ビットの一様量子化符号なし整数、または 2/4/8/16/32 ビットの軸ごとに一様量子化された符号なし整数値のランク付けされたテンソル

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点要素値を持つ複素数のテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点要素値を持つ複素数のテンソル

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点要素値を持つ複素数のテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点要素値を持つ複素数のテンソル

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

オペランド:

オペランド	説明
lhs	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル
rhs	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値のランク付けされたテンソル、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに整数で量子化された値、または軸ごとに整数で量子化された値のランク付けされたテンソル、トークン、または stablehlo トークン
token	トークンまたはstablehloトークン

結果：

結果	説明
output	4/6/8/16/32/64 ビットの浮動小数点数またはブール値のランク付けされたテンソル、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに整数で量子化された値、または軸ごとに整数で量子化された値のランク付けされたテンソル、トークン、または stablehlo トークン

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

オペランド:

オペランド	説明
inputs	トークンの可変長引数

結果：

結果	説明
result	トークン

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

属性:

属性	MLIRタイプ	説明
all_gather_dim	::mlir::整数属性	値が負でない64ビットの符号なし整数属性
replica_groups	::mlir::DenseIntElementsAttr	64ビット符号なし整数要素属性
channel_handle	::mlir::mhlo::チャネルハンドル属性	2つの64ビット整数「ハンドル」と「タイプ」
use_global_device_ids	::mlir::ユニット属性	ユニット属性

オペランド:

オペランド	説明
operands	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの浮動小数点数要素を持つ複素数、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付きテンソルの可変長引数

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの浮動小数点数要素を持つ複素数、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付きテンソルの可変長引数

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

属性:

属性	MLIRタイプ	説明
replica_groups	::mlir::DenseIntElementsAttr	64ビット符号なし整数要素属性
channel_handle	::mlir::mhlo::チャネルハンドル属性	2つの64ビット整数「ハンドル」と「タイプ」
use_global_device_ids	::mlir::ユニット属性	ユニット属性

オペランド:

オペランド	説明
operands	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの浮動小数点数要素を持つ複素数、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付きテンソルの可変長引数

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの浮動小数点数要素を持つ複素数、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付きテンソルの可変長引数

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

属性:

属性	MLIRタイプ	説明
split_dimension	::mlir::整数属性	値が負でない64ビットの符号なし整数属性
concat_dimension	::mlir::整数属性	値が負でない64ビットの符号なし整数属性
split_count	::mlir::整数属性	正の値が入る64ビットの符号なし整数属性
replica_groups	::mlir::DenseIntElementsAttr	64ビット符号なし整数要素属性
channel_handle	::mlir::mhlo::チャネルハンドル属性	2つの64ビット整数「ハンドル」と「タイプ」

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの浮動小数点数要素を持つ複素数、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付きテンソルの可変長引数

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの浮動小数点数要素を持つ複素数、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付きテンソルの可変長引数

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

オペランド:

オペランド	説明
lhs	bool または 2/4/8/16/32/64 ビット整数値のランク付きテンソル
rhs	bool または 2/4/8/16/32/64 ビット整数値のランク付きテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点要素値を持つ複素数のテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点要素値を持つ複素数のテンソル

mhlo.async_done (mhlo::AsyncDoneOp)

AsyncDone操作

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

非公式には、この操作は非同期計算が終了するまでブロックし、非同期計算の最終結果を返します。

詳細については、AsyncStart のドキュメントを参照してください。

インターフェース: InferTypeOpInterface

オペランド:

オペランド	説明
bundle	4/6/8/16/32/64 ビットの float または bool のランク付けされたテンソル、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの float 要素を持つ複素数、またはテンソルごとに量子化された整数値、軸ごとに量子化された整数値、トークン値、または stablehlo トークン値の任意の組み合わせを持つ async_bundle

結果：

結果

説明

「無名」

4/6/8/16/32/64 ビットの float または bool のランク付けされたテンソル、または 32/64 ビットの float 要素を持つ 2/4/8/16/32/64 ビットの整数または複素数、またはテンソルごとに量子化された整数値、軸ごとに量子化された整数値、またはトークン、stablehlo トークン、または 4/6/8/16/32/64 ビットの float または bool のランク付けされたテンソル、または 32/64 ビットの float 要素を持つ 2/4/8/16/32/64 ビットの整数または複素数、またはテンソルごとに量子化された整数値、または 4/6/8/16/32/64 ビットの float または bool の memref、または 32/64 ビットの float 要素を持つ 2/4/8/16/32/64 ビットの整数または複素数、またはテンソルごとに量子化された整数値、またはランク付けされたテンソルの任意の組み合わせを持つネストされたタプル軸ごとの整数量子化値またはトークン値

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」と呼ばれます。すべてのスレッドには名前があります。

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

属性:

属性	MLIRタイプ	説明
called_computation	::mlir::フラットシンボル参照属性	フラットシンボル参照属性
execution_thread	::mlir::文字列属性	文字列属性

オペランド:

オペランド

説明

inputs

4/6/8/16/32/64 ビットの float または bool のランク付けされたテンソル、または 32/64 ビットの float 要素を持つ 2/4/8/16/32/64 ビットの整数または複素数、またはテンソルごとに量子化された整数値、軸ごとに量子化された整数値、またはトークン、stablehlo トークン、または 4/6/8/16/32/64 ビットの float または bool のランク付けされたテンソル、または 32/64 ビットの float 要素を持つ 2/4/8/16/32/64 ビットの整数または複素数、またはテンソルごとに量子化された整数値、または 4/6/8/16/32/64 ビットの float または bool の memref、または 32/64 ビットの float 要素を持つ 2/4/8/16/32/64 ビットの整数または複素数、またはテンソルごとに量子化された整数値、またはランク付けされたテンソルの任意の組み合わせを持つネストされたタプル軸ごとの整数量子化値またはトークン値

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの float または bool のランク付けされたテンソル、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの float 要素を持つ複素数、またはテンソルごとに量子化された整数値、軸ごとに量子化された整数値、トークン値、または stablehlo トークン値の任意の組み合わせを持つ async_bundle

mhlo.async_update (mhlo::AsyncUpdateOp)

AsyncUpdate操作

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

非公式には、この操作は同期バリアに到達するまで非同期計算をブロックします。操作後にbundleを返します。

詳細については、AsyncStart のドキュメントを参照してください。

インターフェース: InferTypeOpInterface

オペランド:

オペランド	説明
bundle	4/6/8/16/32/64 ビットの float または bool のランク付けされたテンソル、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの float 要素を持つ複素数、またはテンソルごとに量子化された整数値、軸ごとに量子化された整数値、トークン値、または stablehlo トークン値の任意の組み合わせを持つ async_bundle

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの float または bool のランク付けされたテンソル、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの float 要素を持つ複素数、またはテンソルごとに量子化された整数値、軸ごとに量子化された整数値、トークン値、または stablehlo トークン値の任意の組み合わせを持つ async_bundle

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

オペランド:

オペランド	説明
lhs	4/6/8/16/32/64 ビット浮動小数点数または 32/64 ビット浮動小数点数要素またはテンソルごとに量子化された整数値を持つ複素数のランク付きテンソル
rhs	4/6/8/16/32/64 ビット浮動小数点数または 32/64 ビット浮動小数点数要素またはテンソルごとに量子化された整数値を持つ複素数のランク付きテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット浮動小数点数または 32/64 ビット浮動小数点数要素またはテンソルごとに量子化された整数値を持つ複素数のランク付きテンソル

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点要素値を持つ複素数のテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点要素値を持つ複素数のテンソル

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

属性:

属性	MLIRタイプ	説明
epsilon	::mlir::FloatAttr	32ビット浮動小数点属性
feature_index	::mlir::整数属性	値が負でない64ビットの符号なし整数属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64ビット浮動小数点値のランク付きテンソル
scale	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
mean	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
variance	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
grad_output	4/6/8/16/32/64ビット浮動小数点値のランク付きテンソル

結果：

結果	説明
grad_operand	4/6/8/16/32/64ビット浮動小数点値のランク付きテンソル
grad_scale	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
grad_offset	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル

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

属性:

属性	MLIRタイプ	説明
epsilon	::mlir::FloatAttr	32ビット浮動小数点属性
feature_index	::mlir::整数属性	値が負でない64ビットの符号なし整数属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64ビット浮動小数点値のランク付きテンソル
scale	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
offset	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
mean	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
variance	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル

結果：

結果	説明
result	4/6/8/16/32/64ビット浮動小数点値のランク付きテンソル

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

属性:

属性	MLIRタイプ	説明
epsilon	::mlir::FloatAttr	32ビット浮動小数点属性
feature_index	::mlir::整数属性	値が負でない64ビットの符号なし整数属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64ビット浮動小数点値のランク付きテンソル
scale	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
offset	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル

結果：

結果	説明
output	4/6/8/16/32/64ビット浮動小数点値のランク付きテンソル
batch_mean	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル
batch_var	4/6/8/16/32/64 ビット浮動小数点値の 1D テンソル

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

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

属性:

属性	MLIRタイプ	説明
broadcast_sizes	::mlir::DenseIntElementsAttr	64ビット符号なし整数要素属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

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

属性:

属性	MLIRタイプ	説明
broadcast_dimensions	::mlir::DenseIntElementsAttr	64ビット符号なし整数要素属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
「無名」	静的に形作られた、または単一の境界次元テンソル。4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数、または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値

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

オペランド:

オペランド	説明
index	32ビットの符号なし整数値のテンソル

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値のランク付きテンソル、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに整数で量子化された値、または軸ごとに整数で量子化された値またはトークンのランク付きテンソルの可変長引数

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

属性:

属性	MLIRタイプ	説明
result_accuracy	::mlir::mhlo::結果精度属性	単項演算に要求される精度。

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット浮動小数点数または 32/64 ビット浮動小数点数要素またはテンソルごとに量子化された整数値を持つ複素数のランク付きテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット浮動小数点数または 32/64 ビット浮動小数点数要素またはテンソルごとに量子化された整数値を持つ複素数のランク付きテンソル

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはテンソルごとの整数量子化値のランク付けされたテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビットの浮動小数点数またはテンソルごとの整数量子化値のランク付けされたテンソル

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

属性:

属性	MLIRタイプ	説明
lower	::mlir::ブール属性	bool属性

オペランド:

オペランド	説明
a	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点型要素値を持つ複素数のランク付きテンソル

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビット浮動小数点型または 32/64 ビット浮動小数点型要素値を持つ複素数のランク付きテンソル

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

オペランド:

オペランド	説明
min	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル
max	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

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

属性:

属性	MLIRタイプ	説明
replica_groups	::mlir::DenseIntElementsAttr	64ビット符号なし整数要素属性
channel_handle	::mlir::mhlo::チャネルハンドル属性	2つの64ビット整数「ハンドル」と「タイプ」

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

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

属性:

属性	MLIRタイプ	説明
source_target_pairs	::mlir::DenseIntElementsAttr	64ビット符号なし整数要素属性
channel_handle	::mlir::mhlo::チャネルハンドル属性	2つの64ビット整数「ハンドル」と「タイプ」

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
「無名」	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

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

属性:

属性	MLIRタイプ	説明
comparison_direction	::mlir::mhlo::比較方向属性	実行する比較演算。
compare_type	::mlir::mhlo::ComparisonTypeAttr	使用する比較タイプ。

オペランド:

オペランド	説明
lhs	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル
rhs	4/6/8/16/32/64 ビットの浮動小数点数またはブール値、または 2/4/8/16/32/64 ビットの整数または 32/64 ビットの浮動小数点数要素を持つ複素数型、またはテンソルごとに量子化された整数値、または軸ごとに量子化された整数値のランク付けされたテンソル

結果：

結果	説明
「無名」	ブール値のランク付きテンソル

mhlo.complex (mhlo::ComplexOp)

複雑な操作

構文：

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

実数値と虚数値のペア ( lhsとrhs ) から複素数値への要素単位の変換を実行し、 resultテンソルを生成します。

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

例：

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

特性: AlwaysSpeculatableImplTrait 、 Elementwise 、 SameOperandsAndResultShape 、 SameOperandsElementType

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

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

オペランド:

オペランド	説明
lhs	32/64ビット浮動小数点値のランク付きテンソル
rhs	32/64ビット浮動小数点値のランク付きテンソル

結果：

結果	説明
result	32/64ビット浮動小数点値を持つ複素数のランク付きテンソル

mhlo.composite (mhlo::CompositeOp)

複合操作

構文：

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

他の StableHLO 操作で構成された (構成された) 操作をカプセル化し、 inputsとcomposite_attributesを取得してresultsを生成します。演算のセマンティクスは、 decomposition属性によって実装されます。 composite演算は、プログラムのセマンティクスを変更せずに、その分解で置き換えることができます。分解をインライン化しても同じ操作セマンティクスが提供されない場合は、 custom_call使用を優先します。

versionフィールド (デフォルトは0 ) は、コンポジットのセマンティクスがいつ変更されたかを示すために使用されます。

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

例：

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

インターフェイス: SymbolUserOpInterface

属性:

属性	MLIRタイプ	説明
name	::mlir::StringAttr	文字列属性
composite_attributes	::mlir::DictionaryAttr	名前付き属性値の辞書
decomposition	::mlir::FlatSymbolRefAttr	フラット シンボル参照属性
version	::mlir::IntegerAttr	32 ビットの符号なし整数属性

オペランド:

オペランド

説明

inputs

4/6/8/16/32/64 ビットの float または bool、または 2/4/8/16/32/64 ビットの整数または 32/64 ビット float 要素を含む複素数型のランク付けされたテンソルの可変個数、またはテンソルごとの整数量子化または軸ごとの整数量子化値、またはランク付けされたテンソルの任意の組み合わせを含むトークンまたはネストされたタプル4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型、またはテンソルごとの整数量子化値、または 4/6/8/16/32/64 ビット float または bool または 2/4/8/16/32/64 ビット整数または複素数型の memref 32/64 ビット float 要素、またはテンソルごとの整数量子化値、または軸ごとの整数のランク付けされたテンソルを使用 量子化された値またはトークン値

結果：

結果

説明

«無名»

4/6/8/16/32/64 ビットの float または bool、または 2/4/8/16/32/64 ビットの整数または 32/64 ビット float 要素を含む複素数型のランク付けされたテンソルの可変個数、またはテンソルごとの整数量子化または軸ごとの整数量子化値、またはランク付けされたテンソルの任意の組み合わせを含むトークンまたはネストされたタプル4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型、またはテンソルごとの整数量子化値、または 4/6/8/16/32/64 ビット float または bool または 2/4/8/16/32/64 ビット整数または複素数型の memref 32/64 ビット float 要素、またはテンソルごとの整数量子化値、または軸ごとの整数のランク付けされたテンソルを使用 量子化された値またはトークン値

mhlo.concatenate (mhlo::ConcatenateOp)

連結操作

inputsの可変個数のテンソルをdimension次元に沿って指定された引数と同じ順序で連結し、 resultテンソルを生成します。

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

例：

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

特性: AlwaysSpeculatableImplTrait 、 SameOperandsAndResultElementType

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

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

属性:

属性	MLIRタイプ	説明
dimension	::mlir::IntegerAttr	値が負でない 64 ビットの符号なし整数属性

オペランド:

オペランド	説明
val	4/6/8/16/32/64 ビット float または bool、または 32/64 ビット float 要素を持つ 2/4/8/16/32/64 ビット整数または複素数型のランク付けされたテンソルの可変個数、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.constant (mhlo::ConstantOp)

常時運転

定valueからoutputテンソルを生成します。

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

例：

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

特性: AlwaysSpeculatableImplTrait 、 ConstantLike

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

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

属性:

属性	MLIRタイプ	説明
value	::mlir::ElementsAttr	定数ベクトル/テンソル属性

結果：

結果	説明
output	4/6/8/16/32/64 ビット float または bool、または 32/64 ビット float 要素を持つ 2/4/8/16/32/64 ビット整数または複素数型の静的に整形されたテンソル、あるいはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.convert (mhlo::ConvertOp)

変換操作

構文：

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

operandテンソルに対してある要素型から別の要素型への要素ごとの変換を実行し、 resultテンソルを生成します。

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

例：

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

特性: AlwaysSpeculatableImplTrait 、 Elementwise 、 SameOperandsAndResultShape

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

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.convolution (mhlo::ConvolutionOp)

畳み込み演算

構文：

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

lhsのウィンドウとrhsのスライスの間のドット積を計算し、 resultを生成します。

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

例：

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

特性: AlwaysSpeculatableImplTrait

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

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

属性:

属性	MLIRタイプ	説明
window_strides	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
padding	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
lhs_dilation	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
rhs_dilation	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
window_reversal	::mlir::DenseElementsAttr	定数ブール値ベクトル/テンソル属性
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	変換用のディメンション情報の構造
feature_group_count	::mlir::IntegerAttr	値が正の 64 ビットの符号なし整数属性
batch_group_count	::mlir::IntegerAttr	値が正の 64 ビットの符号なし整数属性
precision_config	::mlir::ArrayAttr	精度構成属性

オペランド:

オペランド	説明
lhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
rhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.copy (mhlo::CopyOp)

コピー操作

構文：

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

この操作は XLA コンパイラーにプライベートなものであるため、まだ仕様がありません。

非公式には、この操作はoperandのコピーです。操作に付加されたメタデータによっては、無操作とはまったく異なる動作をする可能性があります。

例：

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

特性: AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType 、 Elementwise

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

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

属性:

属性	MLIRタイプ	説明
cross_program_prefetch_index	::mlir::IntegerAttr	32 ビットの符号なし整数属性

オペランド:

オペランド

説明

operand

4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化または軸ごとの整数量子化値、またはランク付けされたテンソルの任意の組み合わせを含むトークンまたはネストされたタプル4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型、またはテンソルごとの整数量子化値、または 4/6/8/16/32/64 ビット float または bool または 2/4/8/16/32/64 ビット整数または複素数型の memref 32/64 ビット float 要素、テンソルごとの整数量子化値、または軸ごとの整数量子化値のランク付けされたテンソルまたはトークンを使用 価値観

結果：

結果

説明

result

4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化または軸ごとの整数量子化値、またはランク付けされたテンソルの任意の組み合わせを含むトークンまたはネストされたタプル4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型、またはテンソルごとの整数量子化値、または 4/6/8/16/32/64 ビット float または bool または 2/4/8/16/32/64 ビット整数または複素数型の memref 32/64 ビット float 要素、テンソルごとの整数量子化値、または軸ごとの整数量子化値のランク付けされたテンソルまたはトークンを使用 価値観

mhlo.cosh (mhlo::CoshOp)

コッシュ操作

構文：

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

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

例：

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

特性: CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または 32/64 ビット float 要素値を持つ複素数型のテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または 32/64 ビット float 要素値を持つ複素数型のテンソル

mhlo.cosine (mhlo::CosineOp)

コサイン演算

構文：

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

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

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

例：

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

特性: AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

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

属性:

属性	MLIRタイプ	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	単項演算の要求された精度。

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または 32/64 ビット float 要素またはテンソルごとの整数量子化値を持つ複素数型のランク付けされたテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または 32/64 ビット float 要素またはテンソルごとの整数量子化値を持つ複素数型のランク付けされたテンソル

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz操作

構文：

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

operandテンソル内の先行ゼロ ビットの数を要素ごとにカウントし、 resultテンソルを生成します。

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

例：

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

特性: AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

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

オペランド:

オペランド	説明
operand	2/4/8/16/32/64 ビット整数値のランク付けされたテンソル

結果：

結果	説明
result	2/4/8/16/32/64 ビット整数値のランク付けされたテンソル

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken オペレーション

構文：

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

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

非公式には、この操作は入力が 0 の AfterAllOp と同じことを行います: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

例：

%output = mhlo.create_token : !mhlo.token

特性: AlwaysSpeculatableImplTrait

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

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

結果：

結果	説明
output	トークン

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

CrossReplicaSum 操作

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

非公式には、この操作は、 channel_id = 0 、 use_global_device_ids = falseおよびcomputation実装追加を使用した AllReduceOp と同じことを行います: 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>

特性: AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType

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

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

属性:

属性	MLIRタイプ	説明
replica_groups	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall オペレーション

構文：

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

inputsとcalled_computations受け取り、 resultsを生成する実装定義のオペレーションcall_target_nameをカプセル化します。

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

インターフェース: MemoryEffectOpInterface

属性:

属性	MLIRタイプ	説明
call_target_name	::mlir::StringAttr	文字列属性
has_side_effect	::mlir::BoolAttr	ブール属性
backend_config	::mlir::属性	文字列属性または名前付き属性値の辞書
api_version	::mlir::mhlo::CustomCallApiVersionAttr	カスタム呼び出し API バージョン
called_computations	::mlir::ArrayAttr	フラット シンボルの ref 配列属性
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	カスタム呼び出しに必要なスケジュールを指定します。
operand_layouts	::mlir::ArrayAttr	レイアウト (インデックス タイプの 1D テンソル) 属性の配列
result_layouts	::mlir::ArrayAttr	レイアウト (インデックス タイプの 1D テンソル) 属性の配列
output_operand_aliases	::mlir::ArrayAttr	CustomCall の出力およびオペランドのエイリアス属性

オペランド:

オペランド

説明

inputs

4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のテンソルの可変個数、またはテンソルごとの整数量子化値または軸ごとの整数量子化値、または 4/6/8/16/32/64 ビット float または bool の memref または32/64 ビット float 要素を含む 2/4/8/16/32/64 ビット整数または複合型、またはテンソルごとの整数量子化値、または 4/6/8/16/32/64 ビット float または bool のテンソルの任意の組み合わせを含むトークンまたはネストされたタプル、または 2/4/8/16/32/64 ビット整数または 32/64 ビット浮動小数点を含む複合型要素、テンソルごとの整数量子化、または軸ごとの整数量子化値、または memref 4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素またはテンソルごとの整数量子化値またはトークン値を含む複合型

結果：

結果

説明

«無名»

4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のテンソルの可変個数、またはテンソルごとの整数量子化値または軸ごとの整数量子化値、または 4/6/8/16/32/64 ビット float または bool の memref または32/64 ビット float 要素を含む 2/4/8/16/32/64 ビット整数または複合型、またはテンソルごとの整数量子化値、または 4/6/8/16/32/64 ビット float または bool のテンソルの任意の組み合わせを含むトークンまたはネストされたタプル、または 2/4/8/16/32/64 ビット整数または 32/64 ビット浮動小数点を含む複合型要素、テンソルごとの整数量子化、または軸ごとの整数量子化値、または memref 4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素またはテンソルごとの整数量子化値またはトークン値を含む複合型

mhlo.divide (mhlo::DivOp)

除算演算

構文：

operation ::= `mhlo.divide` $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#divide

例：

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

特性: AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

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

オペランド:

オペランド	説明
lhs	2/4/8/16/32/64 ビット整数、または 4/6/8/16/32/64 ビット浮動小数点数、または 32/64 ビット浮動小数点要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
rhs	2/4/8/16/32/64 ビット整数、または 4/6/8/16/32/64 ビット浮動小数点数、または 32/64 ビット浮動小数点要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
result	2/4/8/16/32/64 ビット整数、または 4/6/8/16/32/64 ビット浮動小数点数、または 32/64 ビット浮動小数点要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.domain (mhlo::DomainOp)

ドメインの運用

この操作は XLA コンパイラーにプライベートなものであるため、まだ仕様がありません。

非公式には、これらの操作は、同じ DomainMetadata プロパティを持つ命令をグループ化するために使用されます。 ShardingMetadata は、同じデバイス上で命令をグループ化するための今日の主な使用例です。ドメイン命令には、次の 2 つの大きな利点があります。

• ドメイン間で命令が意図せず最適化されることを防ぎます。
• ドメイン内で作成された命令のメタデータを自動的に割り当てます。ドメイン命令がないと、各 HLO 最適化パスでメタデータをチェックして伝播する必要がありますが、これは見逃されやすく、コンパイラーも複雑になります。ドメイン命令は 2 つの異なるドメインを接続するため、各ドメイン命令は 2 つの DomainMetadata (ドメインのオペランド側とユーザー側に 1 つ) に関連付けられます。

特性: AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType

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

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

属性:

属性	MLIRタイプ	説明
kind	::mlir::mhlo::DomainKindAttr	HLO ドメインに添付されるドメイン メタデータの種類。
entry_metadata	::mlir::StringAttr	文字列属性
exit_metadata	::mlir::StringAttr	文字列属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値、または軸ごとの整数量子化値またはトークンのランク付けされたテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値、または軸ごとの整数量子化値またはトークンのランク付けされたテンソル

mhlo.dot (mhlo::DotOp)

ドット操作

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

非公式には、この操作は XLA の Dot と同じことを行います: https://www.tensorflow.org/xla/operation_semantics#dot

例：

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

特性: AlwaysSpeculatableImplTrait

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

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

属性:

属性	MLIRタイプ	説明
precision_config	::mlir::ArrayAttr	精度構成属性

オペランド:

オペランド	説明
lhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
rhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dot_general (mhlo::DotGeneralOp)

ドット一般操作

lhsのスライスとrhsのスライスの間の内積を計算し、 resultテンソルを生成します。

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

例：

%result = "mhlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #mhlo.dot<
    lhs_batching_dimensions = [0],
    rhs_batching_dimensions = [0],
    lhs_contracting_dimensions = [2],
    rhs_contracting_dimensions = [1]
  >,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<2x2x2xi32>, tensor<2x2x2xi32>) -> tensor<2x2x2xi32>

特性: AlwaysSpeculatableImplTrait

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

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

属性:

属性	MLIRタイプ	説明
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	ドットの寸法情報をモデル化する属性。
precision_config	::mlir::ArrayAttr	精度構成属性
algorithm	::mlir::mhlo::DotAlgorithmAttr	ドットの計算に使用するアルゴリズム制約をモデル化する属性。

オペランド:

オペランド	説明
lhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
rhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

動的BroadcastInDim操作

この操作は機能的にはBroadcast_in_dim opと同じですが、結果の形状はoutput_dimensionsを介して動的に指定されます。

また、ディメンションの拡張動作に関する静的な知識を表現するためのオプションの属性も受け入れます。指定しない場合、すべての次元が拡張している可能性があると想定されます。拡張していることがわかっている次元のセットと拡張していないことがわかっている次元のセットは互いに素であり、オペランドの次元のサブセットである必要があります。

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

例：

%operand = mhlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = mhlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "mhlo.dynamic_broadcast_in_dim"(%operand, %output_dimensions) {
  broadcast_dimensions = array<i64: 2, 1>,
  known_expanding_dimensions = array<i64: 0>,
  known_nonexpanding_dimensions = array<i64: 1>
} : (tensor<1x3xi64>, tensor<3xi64>) -> tensor<2x3x2xi64>

特性: AlwaysSpeculatableImplTrait

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

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

属性:

属性	MLIRタイプ	説明
broadcast_dimensions	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
known_expanding_dimensions	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
output_dimensions	インデックスまたは 2/4/8/16/32/64 ビット整数値の 1D テンソル

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv 操作

この操作は進行中の作業であるため、まだ仕様には含まれていません: https://github.com/openxla/stablehlo/issues/8

非公式には、この操作は ConvolutionOp と同じことを行いますが、 paddingがd_padding経由で動的に指定される点が異なります: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

例：

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

特性: AlwaysSpeculatableImplTrait

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

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

属性:

属性	MLIRタイプ	説明
window_strides	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
padding	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
lhs_dilation	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
rhs_dilation	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性
window_reversal	::mlir::DenseElementsAttr	定数ブール値ベクトル/テンソル属性
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	変換用のディメンション情報の構造
feature_group_count	::mlir::IntegerAttr	値が正の 64 ビットの符号なし整数属性
batch_group_count	::mlir::IntegerAttr	値が正の 64 ビットの符号なし整数属性
precision_config	::mlir::ArrayAttr	精度構成属性

オペランド:

オペランド	説明
lhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
rhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
d_padding	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

動的収集操作

この操作は進行中の作業であるため、まだ仕様には含まれていません: https://github.com/openxla/stablehlo/issues/8

非公式には、この操作は、 slice_sizesが動的に指定されることを除いて、GatherOp と同じことを行います: 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>

特性: AlwaysSpeculatableImplTrait 、 InferTensorType

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

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

属性:

属性	MLIRタイプ	説明
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	収集するディメンション情報をモデル化する属性
indices_are_sorted	::mlir::BoolAttr	ブール属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
start_indices	2/4/8/16/32/64 ビット整数値のランク付けされたテンソル
slice_sizes	2/4/8/16/32/64 ビット整数値の静的に整形された 1 次元整数テンソル

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

動的Iota操作

この操作は機能的にはiota op と同じですが、結果の形状はoutput_shapeを介して動的に指定されます。

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

例：

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

特性: AlwaysSpeculatableImplTrait

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

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

属性:

属性	MLIRタイプ	説明
iota_dimension	::mlir::IntegerAttr	値が負でない 64 ビットの符号なし整数属性

オペランド:

オペランド	説明
output_shape	インデックスまたは 2/4/8/16/32/64 ビット整数値の 1D テンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dynamic_pad (mhlo::DynamicPadOp)

ダイナミックパッドの操作

構文：

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

operandを動的にパディングします。ローエンド/ハイエンド/内部で追加されるパディング量は、入力テンソルを介して渡されます。

特性: AlwaysSpeculatableImplTrait

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

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
padding_value	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
edge_padding_low	インデックスまたは 2/4/8/16/32/64 ビット整数値の 1D テンソル
edge_padding_high	インデックスまたは 2/4/8/16/32/64 ビット整数値の 1D テンソル
interior_padding	インデックスまたは 2/4/8/16/32/64 ビット整数値の 1D テンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

動的変形操作

構文：

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

この操作は機能的にはreshape操作と同じですが、結果の形状はoutput_shapeを介して動的に指定されます。

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

例：

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

特性: AlwaysSpeculatableImplTrait

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

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
output_shape	インデックスまたは 2/4/8/16/32/64 ビット整数値の 1D テンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

ダイナミックスライス操作

動的に計算された開始インデックスを使用してoperandからスライスを抽出し、 resultテンソルを生成します。

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

特性: AlwaysSpeculatableImplTrait 、 InferTensorType

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

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

属性:

属性	MLIRタイプ	説明
slice_sizes	::mlir::DenseIntElementsAttr	64 ビット符号なし整数要素属性

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
start_indices	2/4/8/16/32/64 ビット整数値の 0D テンソルの可変個数

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

動的UpdateSliceオペレーション

構文：

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

start_indicesで始まるスライスがupdateの値で更新されることを除き、 operandテンソルと等しいresultテンソルを生成します。

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

特性: AlwaysSpeculatableImplTrait 、 InferTensorType

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

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
update	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
start_indices	2/4/8/16/32/64 ビット整数値の 0D テンソルの可変個数

結果：

結果	説明
result	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.einsum (mhlo::EinsumOp)

Einsum 操作

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

非公式には、この操作は TF の einsum と同じことを行います: https://www.tensorflow.org/api_docs/python/tf/einsum

例：

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

特性: AlwaysSpeculatableImplTrait

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

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

属性:

属性	MLIRタイプ	説明
einsum_config	::mlir::StringAttr	文字列属性

オペランド:

オペランド	説明
lhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値
rhs	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

結果：

結果	説明
«無名»	4/6/8/16/32/64 ビット float または bool、または 2/4/8/16/32/64 ビット整数または 32/64 ビット float 要素を持つ複素数型のランク付けされたテンソル、またはテンソルごとの整数量子化値または軸ごとの整数量子化値

mhlo.erf (mhlo::ErfOp)

erf 操作

構文：

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

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

例：

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

特性: AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

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

オペランド:

オペランド	説明
operand	4/6/8/16/32/64 ビット浮動小数点値のランク付けされたテンソル

結果：

結果	説明
result	4/6/8/16/32/64 ビット浮動小数点値のランク付けされたテンソル

mhlo.exponential (mhlo::ExpOp)

経験値演算

構文：

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

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

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

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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:

属性	MLIR Type	説明
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

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:

属性	MLIR Type	説明
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

Operands:

オペランド	説明
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

結果：

結果

説明

results

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

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:

属性	MLIR Type	説明
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
slice_sizes	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
indices_are_sorted	::mlir::BoolAttr	bool attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	ranked tensor of 2/4/8/16/32/64-bit integer values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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:

属性	MLIR Type	説明
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	tensor of 32-bit signless integer values

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

オペランド

説明

operand

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

結果：

結果

説明

«unnamed»

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.if (mhlo::IfOp)

If operation

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

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

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

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operands:

オペランド	説明
pred	ranked tensor of bool values

結果：

結果	説明
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.imag (mhlo::ImagOp)

Imag operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

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

例：

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

Attributes:

属性	MLIR Type	説明
infeed_config	::mlir::StringAttr	string attribute
layout	::mlir::ArrayAttr	array attribute

Operands:

オペランド	説明
token	トークン

結果：

結果

説明

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

mhlo.iota (mhlo::IotaOp)

Iota operation

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

結果：

結果	説明
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
x	ranked tensor of 4/6/8/16/32/64-bit float values

結果：

結果	説明
y	ranked tensor of bool values

mhlo.log (mhlo::LogOp)

Log operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.log_plus_one (mhlo::Log1pOp)

Log1p operation

構文：

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

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

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

例：

%result = mhlo.log_plus_one %operand : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.logistic (mhlo::LogisticOp)

Logistic operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.map (mhlo::MapOp)

Map operation

Applies a map function computation to inputs along the dimensions and produces a result tensor.

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

例：

%result = "mhlo.map"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.multiply %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  dimensions = dense<[0, 1]> : tensor<2xi64>
} : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.maximum (mhlo::MaxOp)

Max operation

構文：

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

Performs element-wise max operation on tensors lhs and rhs and produces a result tensor.

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

例：

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum (mhlo::MinOp)

Min operation

構文：

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

Performs element-wise min operation on tensors lhs and rhs and produces a result tensor.

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

例：

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum_broadcast_shapes (mhlo::MinimumBroadcastShapesOp)

Minimizes the rank of two or more shapes to be broadcasted

構文：

operation ::= `mhlo.minimum_broadcast_shapes` $shapes attr-dict `:` type($shapes) `->` type($results)

Given two or more 1D tensors representing shapes, returns one 1D tensor for each operand, where operand i corresponds to output i .

The returned tensors have the property that they specify a shape which is a reshape of the corresponding input shape, and the broadcasted output shape (using shape::BroadcastOp) of the returned shapes is a reshape of the broadcasted output shape of the input shapes. Among all possibilities with this property, the one is chosen which minimizes the rank of each returned shape.

The general idea of this op is that it can be used for ops which have a broadcasting semantic to operate on shapes with a possibly smaller rank while preserving equivalence of the computed values. After computing the result of the op using reshaped operands, the result can be reshaped to the result that would have been originally computed.

Here is an example with two input shapes:

mhlo.minimum_broadcast_shapes [1, 2, 3, 1, 2, 1],
                                 [1, 1, 1, 2, 3] -> [6, 2, 1], [2, 3]

The broadcasted output shape of the operands is [1, 2, 3, 1, 2, 3], the broadcasted output shape of the outputs is [6, 2, 3]. These two shapes are reshapes of each other, and also each output is a reshape of the corresponding input.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
shapes	variadic of 1D tensor of index values

結果：

結果	説明
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

構文：

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

Performs element-wise product of two tensors lhs and rhs and produces a result tensor.

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

例：

%result = mhlo.multiply %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.negate (mhlo::NegOp)

Neg operation

構文：

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

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

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

例：

%result = mhlo.negate %operand : tensor<2x3xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.not (mhlo::NotOp)

Not operation

構文：

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

Performs element-wise NOT of tensor operand of type integer and produces a result tensor.

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

例：

%result = mhlo.not %operand : tensor<5x3x1xi1>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

構文：

operation ::= `mhlo.optimization_barrier` attr-dict ($operand^ `:` custom<PairwiseOpType>(type($operand), type($result))):(`(` `)`)?

Ensures that the operations that produce the operand are executed before any operations that depend on the result and prevents compiler transformations from moving operations across the barrier. Other than that, the operation is an identity, ie result = operand .

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

例：

%result0, %result1 = mhlo.optimization_barrier %operand0, %operand1 : tensor<f32>, tensor<f32>

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

結果：

結果	説明
result	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.or (mhlo::OrOp)

Or operation

構文：

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

Performs element-wise OR of two tensors lhs and rhs and produces a result tensor.

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

例：

%result = mhlo.or %lhs, %rhs : tensor<2xi1>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.outfeed (mhlo::OutfeedOp)

Outfeed operation

Writes inputs to the outfeed and produces a result token.

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

例：

%result = "mhlo.outfeed"(%input0, %token) {
  outfeed_config = ""
} : (tensor<3x3x3xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
outfeed_config	::mlir::StringAttr	string attribute

Operands:

オペランド	説明
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	トークン

結果：

結果	説明
«unnamed»	トークン

mhlo.pad (mhlo::PadOp)

Pad operation

Expands operand by padding around the tensor as well as between the elements of the tensor with the given padding_value .

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

例：

%0 = mhlo.pad %arg0, %arg1, low = [0, 1], high = [2, 1], interior = [1, 2]
  : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
edge_padding_low	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
edge_padding_high	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
interior_padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
padding_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.partition_id (mhlo::PartitionIdOp)

PartitionId operation

構文：

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

Produces partition_id of the current process.

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

例：

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

結果：

結果	説明
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

構文：

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

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

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

例：

%result = mhlo.popcnt %operand : tensor<4xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

構文：

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

Performs element-wise exponentiation of lhs tensor by rhs tensor and produces a result tensor.

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

例：

%result = mhlo.power %lhs, %rhs : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.ragged_dot (mhlo::RaggedDotOp)

Ragged matrix multiplication over a single ragged dimension

This operation takes three tensor args---lhs, rhs, and group_sizes---and a "ragged_dot_dimension_numbers" attribute. Like dot_general, the lhs and rhs are allowed arbitrary batch and contracting dimensions. Additionally, the lhs is required to have one ragged dimension, and the rhs may have at most one group dimension. The op has three modes, depending on the kind of the lhs ragged dimension.

In mode 1, the shape-signature is [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] . Here the ragged dimension is an lhs non-contracting dimension ( m ). The dimensions b and k represent batch and contracting dimensions respectively. The rhs is required to have a group dimension ( g ).

In mode 2, the shape-signature is [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] . Here the ragged dimension is an lhs/rhs contracting dimension ( k ).

In mode 3, the shape-signature is [b,m,k], [b,k,n], [g] -> [b,m,n] . Here the ragged dimension is an lhs/rhs batch dimension ( b ).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
ragged_dot_dimension_numbers	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

オペランド	説明
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
group_sizes	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.real (mhlo::RealOp)

Real operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

構文：

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

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 SliceOp except that start_indices , limit_indices and strides are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

例：

%result = mhlo.real_dynamic_slice %operand,
            %start_indices, %limit_indices, %strides
       : (tensor<256x?xf32>, tensor<2xindex>, tensor<2xindex>, tensor<2xindex>) -> tensor<256x?xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
limit_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
strides	1D tensor of index or 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.recv (mhlo::RecvOp)

Recv operation

Receives data from a channel with channel_id and produces results .

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

例：

%results:2 = "mhlo.recv"(%token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (!mhlo.token) -> (tensor<3x4xi32>, !mhlo.token)

Attributes:

属性	MLIR Type	説明
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
token	トークン

結果：

結果

説明

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

mhlo.reduce (mhlo::ReduceOp)

Reduce operation

Applies a reduction function body to inputs and init_values along the dimensions and produces a result tensor.

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

例：

%result = "mhlo.reduce"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  dimensions = dense<1> : tensor<1xi64>
} : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_precision (mhlo::ReducePrecisionOp)

ReducePrecision operation

構文：

operation ::= `mhlo.reduce_precision` $operand `,` `format` `=` custom<ExponentMantissa>($exponent_bits, $mantissa_bits)
              attr-dict `:` custom<SameOperandsAndResultType>(type($operand), type($output))

Performs element-wise conversion of operand to another floating-point type that uses exponent_bits and mantissa_bits and back to the original floating-point type and produces an output tensor.

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

例：

%output = mhlo.reduce_precision %operand, format = e5m2 : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
exponent_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is positive
mantissa_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float values

結果：

結果	説明
output	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.reduce_scatter (mhlo::ReduceScatterOp)

ReduceScatter operation

Within each process group in the process grid, performs reduction, using computations , over the values of the operand tensor from each process, splits the reduction result along scatter_dimension into parts, and scatters the split parts between the processes to produce the result .

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

例：

%result = "mhlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
  %0 = mhlo.add %arg0, %arg1 : tensor<f32>
  mhlo.return %0 : tensor<f32>
}) {
  scatter_dimension = 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<2x4xf32>) -> tensor<2x2xf32>

Attributes:

属性	MLIR Type	説明
scatter_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
replica_groups	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
use_global_device_ids	::mlir::UnitAttr	unit attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_window (mhlo::ReduceWindowOp)

ReduceWindow operation

Applies a reduction function body to windows of inputs and init_values and produces results .

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

例：

%result = "mhlo.reduce_window"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  window_dimensions = dense<[2, 1]> : tensor<2xi64>,
  window_strides = dense<[4, 1]> : tensor<2xi64>,
  base_dilations = dense<[2, 1]> : tensor<2xi64>,
  window_dilations = dense<[3, 1]> : tensor<2xi64>,
  padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi32>, tensor<i32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
base_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.remainder (mhlo::RemOp)

Rem operation

構文：

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

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

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

例：

%result = mhlo.remainder %lhs, %rhs : tensor<4xi64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.replica_id (mhlo::ReplicaIdOp)

ReplicaId operation

構文：

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

Produces replica_id of the current process.

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

例：

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

結果：

結果	説明
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

構文：

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

Performs reshape of operand tensor to a result tensor.

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

例：

%result = mhlo.reshape %operand : (tensor<2xf32>) -> tensor<1x2xf32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	statically shaped or single bounded dimension tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.return (mhlo::ReturnOp)

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

Informally, this operation serves as a terminator for regions defined by
the StableHLO ops. Non-StableHLO ops, e.g. `func.func`, have their own
terminators, e.g. `func.return`.

Example:

    ```mlir
    %result = "mhlo.reduce"(%input, %init_value) ({
      ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
        %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
        "mhlo.return"(%0) : (tensor<i32>) -> ()
    }) {
      dimensions = dense<1> : tensor<1xi64>
    } : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>
    ```_

Syntax:

```

operation ::= mhlo.return $results attr-dict ( : type($results)^)?

Traits: `AlwaysSpeculatableImplTrait`, `Terminator`

Interfaces: `ConditionallySpeculatable`, `NoMemoryEffect (MemoryEffectOpInterface)`

Effects: `MemoryEffects::Effect{}`

#### Operands:

| Operand | Description |
| :-----: | ----------- |
| `results` | variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values |



### `mhlo.reverse` (mhlo::ReverseOp)

_Reverse operation_

Reverses the order of elements in the `operand` along the specified
`dimensions` and produces a `result` tensor.

See:
<a href="https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse">https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse</a>

Example:
```mlir
%result = mhlo.reverse %operand, dims = [1] : tensor<3x2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.rng (mhlo::RngOp)

Rng operation

Generates random numbers using the rng_distribution algorithm and produces a result tensor of a given shape shape .

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

例：

%result = mhlo.rng %a, %b, %shape, distribution = NORMAL : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

オペランド	説明
a	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
b	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.rng_bit_generator (mhlo::RngBitGeneratorOp)

RngBitGenerator operation

Returns an output filled with uniform random data and an updated output state output_state given an initial state initial_state using the pseudorandom number generator algorithm rng_algorithm .

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

例：

%output_state, %output = mhlo.rng_bit_generator %initial_state, algorithm = THREE_FRY : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

オペランド	説明
initial_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

結果：

結果	説明
output_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.round_nearest_afz (mhlo::RoundOp)

Round operation

構文：

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

Performs element-wise rounding towards the nearest integer, breaking ties away from zero, on the operand tensor and produces a result tensor.

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

構文：

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

Performs element-wise rounding towards the nearest integer, breaking ties towards the even integer, on the operand tensor and produces a result tensor.

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

構文：

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

Performs element-wise reciprocal square root operation on operand tensor and produces a result tensor, implementing the rSqrt operation from the IEEE-754 specification.

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.scatter (mhlo::ScatterOp)

Scatter operation

Produces results tensors which are equal to inputs tensors except that several slices specified by scatter_indices are updated with the values updates using update_computation .

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

例：

%result = "mhlo.scatter"(%input, %scatter_indices, %update) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  scatter_dimension_numbers = #mhlo.scatter<
    update_window_dims = [3, 4],
    inserted_window_dims = [1],
    input_batching_dims = [0],
    scatter_indices_batching_dims = [1],
    scatter_dims_to_operand_dims = [2, 1],
    index_vector_dim = 3>,
  indices_are_sorted = false,
  unique_indices = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>, tensor<2x2x3x2x2xi64>) -> tensor<2x3x4x2xi64>

Traits: RecursiveMemoryEffects , SameVariadicOperandSize

Interfaces: InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
scatter_dimension_numbers	::mlir::mhlo::ScatterDimensionNumbersAttr	Attribute that models the dimension information for scatter
indices_are_sorted	::mlir::BoolAttr	bool attribute
unique_indices	::mlir::BoolAttr	bool attribute

Operands:

オペランド	説明
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
scatter_indices	ranked tensor of integer or index values
updates	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select (mhlo::SelectOp)

Select operation

構文：

operation ::= `mhlo.select` operands attr-dict `:`
              custom<SelectOpType>(type($pred), type($on_true), type($on_false), type($result))

Produces a result tensor where each element is selected from on_true or on_false tensor based on the value of the corresponding element of pred .

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

例：

%result = mhlo.select %pred, %on_true, %on_false : tensor<2x2xi1>, tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
pred	ranked tensor of bool values
on_true	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
on_false	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select_and_scatter (mhlo::SelectAndScatterOp)

SelectAndScatter operation

Scatters the values from the source tensor using scatter based on the outcome of reduce_window of the input tensor using select and produces a result tensor.

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

例：

%result = "mhlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

Traits: RecursiveMemoryEffects

Interfaces: InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
source	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.send (mhlo::SendOp)

Send operation

Sends inputs to a channel channel_id and produces a result token.

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

例：

%result = "mhlo.send"(%operand, %token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (tensor<3x4xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	トークン

結果：

結果	説明
«unnamed»	トークン

mhlo.set_dimension_size (mhlo::SetDimensionSizeOp)

SetDimensionSize 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 XLA's SetDimensionSize: https://www.tensorflow.org/xla/operation_semantics#setdimensionsize

例：

%0 = mhlo.set_dimension_size %arg0, %arg1, dim = 1 : (tensor<4x2xf32>, tensor<i32>) -> tensor<4x2xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
size	tensor of 32-bit signless integer values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.shift_left (mhlo::ShiftLeftOp)

ShiftLeft operation

構文：

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

Performs element-wise left-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

例：

%result = mhlo.shift_left %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

構文：

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

Performs element-wise arithmetic right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

例：

%result = mhlo.shift_right_arithmetic %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

構文：

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

Performs element-wise logical right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

例：

%result = mhlo.shift_right_logical %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

構文：

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

Returns the sign of the operand element-wise and produces a result tensor.

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

例：

%result = mhlo.sign %operand : tensor<7xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sine (mhlo::SineOp)

Sine operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sinh (mhlo::SinhOp)

Sinh operation

構文：

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

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

例：

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

オペランド	説明
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

結果：

結果	説明
result	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.slice (mhlo::SliceOp)

Slice operation

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

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

例：

%result = "mhlo.slice" (%operand) {
  start_indices = dense<[1, 2]> : tensor<2xi64>,
  limit_indices = dense<[3, 4]> : tensor<2xi64>,
  strides = dense<1> : tensor<2xi64>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
start_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
limit_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sort (mhlo::SortOp)

Sort operation

Sorts a variadic number of tensors in inputs together, according to a custom comparator , along the given dimension and produces a variadic number of tensors as results .

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

例：

%result0, %result1 = "mhlo.sort"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>):
    %predicate = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GT>
      } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
  dimension = 0 : i64,
  is_stable = true
} : (tensor<2x3xi32>, tensor<2x3xi32>) -> (tensor<2x3xi32>, tensor<2x3xi32>)

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

オペランド	説明
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sqrt (mhlo::SqrtOp)

Sqrt operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.stochastic_convert (mhlo::StochasticConvertOp)

StochasticConvert operation

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

Informally, this operation performs element-wise conversion of values from a bigger type to a smaller one with stochastic rounding using the random number passed in.

Traits: AlwaysSpeculatableImplTrait , Elementwise

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float values
random	ranked tensor of 2/4/8/16/32/64-bit unsigned integer values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.subtract (mhlo::SubtractOp)

Subtract operation

構文：

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

Performs element-wise subtraction of two tensors lhs and rhs and produces a result tensor.

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

例：

%result = mhlo.subtract %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.tan (mhlo::TanOp)

Tan operation

構文：

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

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

Informally, this operation returns Tan(operand) element-wise.

例：

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.tanh (mhlo::TanhOp)

Tanh operation

構文：

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

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

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

例：

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.topk (mhlo::TopKOp)

TopK operation

構文：

operation ::= `mhlo.topk` `(`$operand `,` `k` `=` $k (`,` `largest` `=` $largest^)? `)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Returns top k values and their indices, along the last dimension of the operand if largest=true or the bottom k values if largest=false .

See: https://www.tensorflow.org/xla/operation_semantics#top-k

例：

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
values	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
indices	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.torch_index_select (mhlo::TorchIndexSelectOp)

TorchIndexSelect 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 PyTorch's index_select, augmented with support for batch dimensions: https://pytorch.org/docs/stable/generated/torch.index_select.html

The batch_dims attribute specifies the number of major batch dimensions (0 or more) that act like a multidimensional loop over both the operand and the index.

例：

%result = "mhlo.torch_index_select"(%operand, %index) {
  dim = 2 : i64,
  batch_dims = 1 : i64
} : (tensor<8x128x3072x64xf32>, tensor<8x16x1024xi32>) -> tensor<8x128x16x1024x64xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
index	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.trace (mhlo::TraceOp)

Trace operation

構文：

operation ::= `mhlo.trace` $operand `,` $tag attr-dict `:` type($operand)

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

It is not used by JAX, PyTorch or TensorFlow, so it looks like we should've classified it as "Private to XLA" and not included it in StableHLO in the first place. With that in mind, its semantics will not be documented here.

例：

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

Attributes:

属性	MLIR Type	説明
tag	::mlir::StringAttr	string attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.transpose (mhlo::TransposeOp)

Transpose operation

Permutes the dimensions of operand tensor using permutation and produces a result tensor.

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

例：

%0 = mhlo.transpose %arg0, dims = [2, 1, 0] : (tensor<1x2x3xi32>) -> tensor<3x2x1xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.triangular_solve (mhlo::TriangularSolveOp)

TriangularSolve operation

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

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

例：

%result = "mhlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

属性	MLIR Type	説明
left_side	::mlir::BoolAttr	bool attribute
lower	::mlir::BoolAttr	bool attribute
unit_diagonal	::mlir::BoolAttr	bool attribute
transpose_a	::mlir::mhlo::TransposeAttr	Transpose options

Operands:

オペランド	説明
a	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values
b	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

結果：

結果	説明
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.tuple (mhlo::TupleOp)

Tuple operation

構文：

operation ::= `mhlo.tuple` $val attr-dict `:` custom<TupleOpType>(type($val), type($result))

Produces a result tuple from values val .

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

例：

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

オペランド

説明

val

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果

説明

result

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

mhlo.uniform_dequantize (mhlo::UniformDequantizeOp)

UniformDequantize operation

構文：

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

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

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

例：

%result = mhlo.uniform_dequantize %operand : (tensor<16x16x!quant.uniform<i8:f32, 34.0:16>>) -> tensor<16x16xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

構文：

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

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

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

例：

%result = mhlo.uniform_quantize %operand : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
operand	ranked tensor of 4/6/8/16/32/64-bit float or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values

結果：

結果	説明
result	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

mhlo.while (mhlo::WhileOp)

While operation

Produces the output from executing body function 0 or more times while the cond function outputs true .

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

例：

%results0, %results1 = "mhlo.while"(%operand0, %operand1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %constant0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0, %arg1) : (tensor<i32>, tensor<i32>) -> ()
}) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface , OpAsmOpInterface

Operands:

オペランド

説明

operand

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

結果：

結果

説明

«unnamed»

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.xla.rng_get_and_update_state (mhlo::XlaRngGetAndUpdateStateOp)

XlaRngGetAndUpdateState operation

構文：

operation ::= `mhlo.xla.rng_get_and_update_state` attr-dict

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

Informally, this operation represents the change of the global random number generator state for rng instructions. The global state is incremented by delta and the old state is returned.

The output is currently defined for a single output type. If this changes in the future to support multiple types, lowering to use of a global memref must ensure that a single memref is still used and updated appropriately.

Interfaces: InferTypeOpInterface

Attributes:

属性	MLIR Type	説明
delta	::mlir::IntegerAttr	64-bit signless integer attribute

結果：

結果	説明
«unnamed»	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

構文：

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

Performs element-wise XOR of two tensors lhs and rhs and produces a result tensor.

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

例：

%result = mhlo.xor %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

オペランド	説明
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

結果：

結果	説明
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

属性

ArgResultAliasAttr

Attribute that models the alias relationship of entry function argument

This attribute captures the alias relationship of an MHLO main function argument to one of the results, denoted by resultIndex . The argTupleIndices and resultTupleIndices are used to index into nested tuples in operand and result respectively. If isMustAlias is true then the operand-result pair must alias.

This is meant to be used as an attribute on a function argument in MHLO. For example, in the following code it expresses that %arg1 may alias 0-th result.

func @main(%arg0: tensor<2xf32>, %arg1: tensor<3xf32> {mhlo.result_alias =
    mhlo.result_alias<result_index = [2], ...>}
  ) -> tensor<2xf32>, tensor<3xf32> {
  // function body ...
}

Parameters:

パラメータ	C++ type	説明
argTupleIndices	::llvm::ArrayRef<int64_t>	寸法
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	寸法
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

構文：

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

Parameters:

パラメータ	C++ type	説明
ハンドル	int64_t
タイプ	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

構文：

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

構文：

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

Parameters:

パラメータ	C++ type	説明
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	寸法
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	寸法
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	寸法

CrossProgramPrefetchAttr

Argument that is prefetched from another program

構文：

#mhlo.cross_program_prefetch<
  int64_t,   # parameter
  ::llvm::ArrayRef<int64_t>,   # indices
  std::optional<int64_t>   # offset
>

This attribute captures an argument that is prefetched from another program. For a given CrossProgramPrefetchAttr , parameter tells us which argument of the main function of the module is prefetched, and indices is a shape index telling us what subshape of that argument is prefetched.

A shape has a subshape iff it is a tuple. In that case, the subshape of the tuple by indices is the shape achieved after indexing by each element of indices in turn. For example, the [1,0] subshape of tuple<tuple<token, token>, tuple<tensor<i32>, token>> is tensor<i32> .

An empty value for indices means the whole shape is prefetched.

例えば、

module attributes { mhlo.cross_program_prefetch = [ #mhlo.cross_program_prefetch< parameter = 0, indices = [0]> ]} {
  func.func @copy(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %0 = "mhlo.copy"(%arg0) {is_cross_program_prefetch}
    return %0 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
  func.func @main(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %1 = "mhlo.async_start"(%arg0) {called_computation=@copy}
    %2 = "mhlo.async_done"(%1) {called_computation=@copy}
    return %2 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
}

The parameter = 0 tells us that the async copy of the 0 th parameter is a cross_program_prefetch , while the index of [0] tells us that the 0 th element of the tuple is prefetched while the other element of the tuple is not.

Parameters:

パラメータ	C++ type	説明
パラメータ	int64_t
インデックス	::llvm::ArrayRef<int64_t>	寸法
オフセット	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

構文：

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

構文：

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

構文：

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

構文：

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

Parameters:

パラメータ	C++ type	説明
lhsPrecisionType	Type
rhsPrecisionType	Type
accumulationType	Type
lhsComponentCount	int64_t
rhsComponentCount	int64_t
numPrimitiveOperations	int64_t
allowImpreciseAccumulation	bool

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

Parameters:

パラメータ	C++ type	説明
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	寸法
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	寸法
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	寸法
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	寸法

FftTypeAttr

XLA fast fourier transform type.

構文：

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

構文：

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

Parameters:

パラメータ	C++ type	説明
offsetDims	::llvm::ArrayRef<int64_t>	寸法
collapsedSliceDims	::llvm::ArrayRef<int64_t>	寸法
operandBatchingDims	::llvm::ArrayRef<int64_t>	寸法
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	寸法
startIndexMap	::llvm::ArrayRef<int64_t>	寸法
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

構文：

#mhlo.output_operand_alias<
  ::llvm::ArrayRef<int64_t>,   # outputTupleIndices
  int64_t,   # operandIndex
  ::llvm::ArrayRef<int64_t>   # operandTupleIndices
>

This attribute captures the alias relationship of the output to one of the operands for a CustomCall op, denoted by operand_index . The output_tuple_indices and operand_tuple_indices are used to index into output and operand types. These indices lists are empty if the corresponding types are not tuple types, and can be arbitrarily long in case of arbitrarily nested tuple types.

See https://www.tensorflow.org/xla/aliasing

Example when used as array with in mhlo.custom-call:

%0 = "mhlo.custom_call"(%arg0, %arg1) {
  // other attributes
  output_operand_alias = [
    #mhlo.output_operand_alias<output_tuple_indices = [0],
                               operand_index = 0,
                               operand_tuple_indices = [1]>
  ]
} : (tuple<tensor<1x1xf32>, tensor<2x3xf32>>, tensor<5x5xf32>) -> tuple<tensor<2x3xf32>>

The output and the 0th operand are both tuples. The aliasing shows the
relationship between the 0th element in output tuple with the 1st element in
the 0th operand. And both of them are of the same type: tensor<2x3xf32>.

Parameters:

パラメータ	C++ type	説明
outputTupleIndices	::llvm::ArrayRef<int64_t>	寸法
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	寸法

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

構文：

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

Parameters:

パラメータ	C++ type	説明
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	寸法
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	寸法

ResultAccuracyAttr

The requested accuracy for unary ops.

Parameters:

パラメータ	C++ type	説明
atol	APFloat
rtol	APFloat
ulps	int64_t
モード	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

構文：

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

構文：

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

構文：

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

Parameters:

パラメータ	C++ type	説明
updateWindowDims	::llvm::ArrayRef<int64_t>	寸法
insertedWindowDims	::llvm::ArrayRef<int64_t>	寸法
inputBatchingDims	::llvm::ArrayRef<int64_t>	寸法
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	寸法
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	寸法
indexVectorDim	int64_t

TransposeAttr

Transpose options

構文：

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

Parameters:

パラメータ	C++ type	説明
価値	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

構文：

#mhlo.type_extensions<
  ::llvm::ArrayRef<int64_t>   # bounds
>

This attribute is used to extend MLIR tensor type with MHLO tensor specific properties. These properties aren't modeled in the MLIR type. This attribute is set in the encoding field of the tensor type.

See HLO_BoundedAttrInterface for documentation for bounds .

Parameters:

パラメータ	C++ type	説明
境界	::llvm::ArrayRef<int64_t>

種類

AsyncBundleType

Opaque collection of other types

構文：

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

Parameters:

パラメータ	C++ type	説明
種類	::llvm::ArrayRef<Type>

Enums

ComparisonDirection

Which comparison operation to perform.

Cases:

シンボル	価値	弦
EQ	0	EQ
北東	1	北東
GE	2	GE
GT	3	GT
ル	4	ル
LT	5	LT

ComparisonType

Which comparison type to use.

Cases:

シンボル	価値	弦
NOTYPE	0	NOTYPE
フロート	1	フロート
TOTALORDER	2	TOTALORDER
SIGNED	3	SIGNED
UNSIGNED	4	UNSIGNED

CustomCallApiVersion

Custom call API version

Cases:

シンボル	価値	弦
API_VERSION_UNSPECIFIED	0	API_VERSION_UNSPECIFIED
API_VERSION_ORIGINAL	1	API_VERSION_ORIGINAL
API_VERSION_STATUS_RETURNING	2	API_VERSION_STATUS_RETURNING
API_VERSION_STATUS_RETURNING_UNIFIED	3	API_VERSION_STATUS_RETURNING_UNIFIED
API_VERSION_TYPED_FFI	4	API_VERSION_TYPED_FFI

CustomCallSchedule

Specifies the desired schedule for the custom-call.

Cases:

シンボル	価値	弦
なし	0	なし
最新	1	最新
EARLIEST	2	EARLIEST

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

Cases:

シンボル	価値	弦
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

Cases:

シンボル	価値	弦
sharding	0	sharding

FftType

XLA fast fourier transform type.

Cases:

シンボル	価値	弦
FFT	0	FFT
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

Cases:

シンボル	価値	弦
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

精度

XLA precision for an operand. Has backend specific meaning.

Cases:

シンボル	価値	弦
デフォルト	0	デフォルト
高い	1	高い
最高	2	最高

ResultAccuracyMode

XLA result accuracy mode.

Cases:

シンボル	価値	弦
デフォルト	0	デフォルト
最高	1	最高
許容範囲	2	許容範囲

RngAlgorithm

XLA PRNG algorithm to be used.

Cases:

シンボル	価値	弦
デフォルト	0	デフォルト
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

Cases:

シンボル	価値	弦
ユニフォーム	1	ユニフォーム
普通	2	普通

転置

Transpose options

Cases:

シンボル	価値	弦
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
転置	2	転置
ADJOINT	3	ADJOINT