'mhlo' Dialek

Operasi

mhlo.abs (mhlo::AbsOp)

Operasi ABS

Sintaksis:

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

Melakukan operasi absans elemen demi elemen pada tensor operand dan menghasilkan tensor result .

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

Contoh:

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

Sifat: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.acos (mhlo::AcosOp)

Operasi Acos

Sintaksis:

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

Melakukan operasi acos elemen demi elemen pada tensor operand dan menghasilkan tensor result .

Contoh:

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

Ciri-ciri: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Operan:

Hasil:

mhlo.acosh (mhlo::AcoshOp)

Operasi Acosh

Sintaksis:

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

Melakukan operasi acosh elemen demi elemen pada tensor operand dan menghasilkan tensor result .

Contoh:

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

Ciri-ciri: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Operan:

Hasil:

mhlo.add (mhlo::AddOp)

Tambahkan operasi

Sintaksis:

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

Melakukan penjumlahan elemen demi elemen dari dua tensor lhs dan rhs dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

Contoh:

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

Sifat: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.add_dependency (mhlo::AddDependencyOp)

Operasi AddDependency

Sintaksis:

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

Operasi ini bersifat eksklusif untuk kompiler XLA, sehingga belum memiliki spesifikasi.

Secara informal, operasi ini memiliki dua operan: operan data dan token. Output dari operasi ini adalah operan data. Ketika digunakan dengan AfterAll, operasi ini memungkinkan pengurutan operasi yang tidak menimbulkan efek samping (operasi yang tidak menghasilkan nilai token).

Contoh:

%1 = mhlo.add_dependency %arg0, %0 : (tensor<3x4xf32>, !mhlo.token) -> tensor<3x4xf32>

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.after_all (mhlo::AfterAllOp)

Setelah semua operasi

Sintaksis:

operation ::= `mhlo.after_all` $inputs attr-dict
              `:` custom<VariadicSameOperandsAndResultType>(ref($inputs), type($inputs), type($result))

Memastikan bahwa operasi yang menghasilkan inputs dieksekusi sebelum operasi apa pun yang bergantung pada result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Contoh:

%result = mhlo.after_all %input0, %input1 : !mhlo.token

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.all_gather (mhlo::AllGatherOp)

Operasi AllGather

Di dalam setiap grup proses dalam grid proses, nilai tensor operan dari setiap proses di sepanjang all_gather_dim digabungkan dan menghasilkan tensor hasil. computation diterapkan secara terpisah untuk setiap operan dalam operands , menghasilkan satu hasil per operan.

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

Contoh:

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

Sifat: SameOperandsAndResultElementType

Atribut:

Operan:

Hasil:

mhlo.all_reduce (mhlo::AllReduceOp)

Operasi AllReduce

Dalam setiap grup proses di grid proses, fungsi reduksi computation pada nilai tensor operan dari setiap proses dan menghasilkan tensor hasil. computation diterapkan secara terpisah untuk setiap operan dalam operands , menghasilkan satu hasil per operan.

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Contoh:

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

Traits: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Atribut:

Operan:

Hasil:

mhlo.all_to_all (mhlo::AllToAllOp)

Operasi AllToAll

Di dalam setiap grup proses dalam grid proses, nilai tensor operand dibagi sepanjang split_dimension menjadi beberapa bagian, bagian-bagian yang terbagi tersebut disebar di antara proses-proses, bagian-bagian yang tersebar tersebut digabungkan sepanjang concat_dimension , dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.and (mhlo::AndOp)

Dan operasi

Sintaksis:

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

Melakukan operasi AND elemen demi elemen pada dua tensor lhs dan rhs dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

Contoh:

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

Sifat: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.asin (mhlo::AsinOp)

Operasi asin

Sintaksis:

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

Melakukan operasi asin elemen demi elemen pada tensor operand dan menghasilkan tensor result .

Contoh:

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

Ciri-ciri: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Operan:

Hasil:

mhlo.asinh (mhlo::AsinhOp)

Operasi Asinh

Sintaksis:

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

Melakukan operasi asinh elemen demi elemen pada tensor operand dan menghasilkan tensor result .

Contoh:

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

Ciri-ciri: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Operan:

Hasil:

mhlo.async_done (mhlo::AsyncDoneOp)

Operasi AsyncDone

Operasi ini bersifat eksklusif untuk kompiler XLA, sehingga belum memiliki spesifikasi.

Secara informal, operasi ini akan memblokir hingga akhir komputasi asinkron. Operasi ini mengembalikan hasil akhir dari komputasi asinkron tersebut.

Lihat dokumentasi AsyncStart untuk informasi lebih lanjut.

Antarmuka: InferTypeOpInterface

Operan:

Hasil:

mhlo.async_start (mhlo::AsyncStartOp)

Operasi AsyncStart

Operasi ini bersifat eksklusif untuk kompiler XLA, sehingga belum memiliki spesifikasi.

Secara informal, operasi ini memulai komputasi asinkron.

Ini digunakan ketika terdapat fungsi yang berisi penantian asinkron (seperti DMA) dan komputasi pada thread. Misalnya, sebuah fungsi mungkin terdiri dari komputasi, DMA, komputasi lain, DMA kedua, dan komputasi terakhir. Ini akan direpresentasikan sebagai async_start diikuti oleh async_update dan async_done. async_start akan melakukan komputasi pertama pada thread dan kemudian memulai DMA. async_update akan menunggu DMA selesai jika belum selesai, kemudian mengeksekusi komputasi kedua dalam fungsi, dan memulai DMA kedua. Terakhir, async_done akan menunggu DMA terakhir ini, dan kemudian menjalankan komputasi terakhir yang perlu dijalankan pada thread dan mengembalikan hasil dari komputasi terakhir tersebut.

operands diteruskan langsung ke komputasi. called_computation adalah fungsi yang akan dijalankan secara asinkron. execution_thread adalah nama thread tempat komputasi akan dijalankan. Thread utama disebut "main". Semua thread memiliki nama.

Ini mengembalikan semua status yang dibutuhkan di antara operasi asinkron. Setelah penugasan buffer, nilai yang dikembalikan mewakili ruang yang dibutuhkan untuk menampung input, hasil, dan setiap catatan sementara yang dibutuhkan atau diedit oleh operasi asinkron.

Atribut:

Operan:

Hasil:

mhlo.async_update (mhlo::AsyncUpdateOp)

Operasi AsyncUpdate

Operasi ini bersifat eksklusif untuk kompiler XLA, sehingga belum memiliki spesifikasi.

Secara informal, operasi ini memblokir komputasi asinkron hingga penghalang sinkronisasi. Ini mengembalikan bundle setelah melakukan operasi padanya.

Lihat dokumentasi AsyncStart untuk informasi lebih lanjut.

Antarmuka: InferTypeOpInterface

Operan:

Hasil:

mhlo.atan2 (mhlo::Atan2Op)

Operasi Atan2

Sintaksis:

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

Melakukan operasi atan2 elemen demi elemen pada tensor lhs dan rhs dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.atanh (mhlo::AtanhOp)

Operasi Atanh

Sintaksis:

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

Melakukan operasi atanh elemen demi elemen pada tensor operand dan menghasilkan tensor result .

Contoh:

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

Ciri-ciri: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Operan:

Hasil:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Operasi BatchNormGrad

Menghitung gradien dari beberapa input BatchNormTrainingOp yang melakukan backpropagasi dari grad_output , dan menghasilkan tensor grad_operand , grad_scale dan grad_offset .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

Contoh:

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

Sifat: AlwaysSpeculatableImplTrait , InferTensorType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Operasi BatchNormInference

Menormalisasi tensor operand di semua dimensi kecuali dimensi feature_index dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

Contoh:

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

Sifat: AlwaysSpeculatableImplTrait , InferTensorType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operasi Pelatihan Norma Batch

Menghitung rata-rata dan varians di seluruh dimensi batch dan spasial serta menormalisasi tensor operand , untuk setiap fitur dalam dimensi feature_index dan menghasilkan output tensor batch_mean dan batch_var .

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

Contoh:

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

Sifat: AlwaysSpeculatableImplTrait , InferTensorType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.bitcast (mhlo::BitcastOp)

Operasi Bitcast

Sintaksis:

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

Operasi ini bersifat eksklusif untuk kompiler XLA, sehingga belum memiliki spesifikasi.

Secara informal, operasi ini mengubah bentuk input sedemikian rupa sehingga susunan fisik elemen tetap tidak berubah.

Operasi ini membutuhkan informasi tata letak untuk memahami "susunan fisik elemen", dan dukungan tata letak di MHLO saat ini masih dalam pengembangan.

Contoh:

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Operasi BitcastConvert

Sintaksis:

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

Melakukan operasi bitcast pada tensor operand dan menghasilkan tensor result di mana bit-bit dari seluruh tensor operand diinterpretasikan ulang menggunakan tipe tensor result tersebut.

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

Contoh:

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.broadcast (mhlo::BroadcastOp)

Operasi siaran

Operasi ini sedang dalam proses penghapusan dari StableHLO, sehingga tidak termasuk dalam spesifikasi: https://github.com/openxla/stablehlo/issues/3

Secara informal, operasi ini melakukan hal yang sama seperti Broadcast pada XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Operasi BroadcastInDim

Memperluas dimensi dan/atau rank tensor input dengan menduplikasi data dalam tensor operand dan menghasilkan tensor result .

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Antarmuka: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.case (mhlo::CaseOp)

Operasi kasus

Menghasilkan output dari eksekusi tepat satu function dari branches yang bergantung pada nilai index .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

Contoh:

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

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Antarmuka: InferTypeOpInterface

Operan:

Hasil:

mhlo.cbrt (mhlo::CbrtOp)

Operasi CBRT

Sintaksis:

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

Melakukan operasi akar kubik elemen demi elemen pada tensor operand dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.ceil (mhlo::CeilOp)

Operasi langit-langit

Sintaksis:

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

Melakukan operasi ceil per elemen pada tensor operand dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.cholesky (mhlo::CholeskyOp)

Operasi Cholesky

Menghitung dekomposisi Cholesky dari sekumpulan matriks.

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.clamp (mhlo::ClampOp)

Pengoperasian penjepit

Sintaksis:

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

Membatasi setiap elemen tensor operand antara nilai minimum dan maksimum dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Operasi Siaran Kolektif

Di dalam setiap grup proses pada grid proses, kirim nilai tensor operand dari proses sumber ke proses target dan hasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

Contoh:

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

Ciri-ciri: CompatibleOperandsAndResultType

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Atribut:

Operan:

Hasil:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Operasi CollectivePermute

Di dalam setiap grup proses dalam grid proses, mengirimkan nilai tensor operand dari proses sumber ke proses target dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

Contoh:

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

Sifat: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.compare (mhlo::BandingkanOp)

Bandingkan operasi

Sintaksis:

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

Melakukan perbandingan elemen demi elemen pada tensor lhs dan rhs sesuai dengan comparison_direction dan compare_type , dan menghasilkan tensor result .

Lihat: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.complex (mhlo::ComplexOp)

Operasi yang kompleks

Sintaksis:

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

Melakukan konversi elemen demi elemen ke nilai kompleks dari sepasang nilai riil dan imajiner, lhs dan rhs , dan menghasilkan tensor result .

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.composite (mhlo::CompositeOp)

Operasi komposit

Sintaksis:

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

Mengkapsulasi sebuah operasi yang terdiri dari (tersusun) operasi StableHLO lainnya, menerima inputs dan composite_attributes , serta menghasilkan results . Semantik operasi diimplementasikan oleh atribut decomposition . Operasi composite dapat digantikan dengan dekomposisinya tanpa mengubah semantik program. Dalam kasus di mana penyisipan dekomposisi tidak memberikan semantik operasi yang sama, lebih baik gunakan custom_call .

Kolom version (nilai defaultnya adalah 0 ) digunakan untuk menunjukkan kapan semantik suatu komposit berubah.

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

Contoh:

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

Antarmuka: SymbolUserOpInterface

Atribut:

Operan:

Hasil:

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.constant (mhlo::ConstantOp)

Operasi konstan

Produces an output tensor from a constant value .

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Hasil:

mhlo.convert (mhlo::ConvertOp)

Convert operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.convolution (mhlo::ConvolutionOp)

Operasi konvolusi

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.copy (mhlo::CopyOp)

Copy operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.cosh (mhlo::CoshOp)

Cosh operation

Sintaksis:

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

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

Contoh:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operan:

Hasil:

mhlo.cosine (mhlo::CosineOp)

Operasi kosinus

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

Sintaksis:

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

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

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

Contoh:

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Hasil:

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

CrossReplicaSum operation

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

Sintaksis:

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

Encapsulates an implementation-defined operation call_target_name that takes inputs and called_computations and produces results .

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

Contoh:

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

Antarmuka: MemoryEffectOpInterface

Atribut:

Operan:

Hasil:

mhlo.divide (mhlo::DivOp)

Div operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.domain (mhlo::DomainOp)

Domain operation

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

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

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.dot (mhlo::DotOp)

Dot operation

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

Informally, this operation does the same thing as XLA's Dot: https://www.tensorflow.org/xla/operation_semantics#dot

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

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

It also accepts optional attributes to express static knowledge about the expanding behavior of dimensions. If not specified, all dimensions are assumed to be possibly expanding. The sets of dimensions that are known to be expanding and the set of dimensions that are known to be non-expanding must be disjoint and they must be a subset of the operand's dimensions.

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv operation

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

Informally, this operation does the same thing as ConvolutionOp except that padding is specified dynamically via d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather operation

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

Informally, this operation does the same thing as GatherOp except that slice_sizes are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Contoh:

%result = "mhlo.dynamic_gather"(%operand, %start_indices, %slice_sizes) {
  dimension_numbers = #mhlo.gather<
    offset_dims = [2, 3],
    collapsed_slice_dims = [0],
    start_index_map = [0, 2],
    index_vector_dim = 2>,
  indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>, tensor<3xi64>) -> tensor<2x3x2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

Sintaksis:

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

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.einsum (mhlo::EinsumOp)

Einsum operation

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.erf (mhlo::ErfOp)

Erf operation

Sintaksis:

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.exponential (mhlo::ExpOp)

Exp operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

Sintaksis:

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

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

Contoh:

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

Atribut:

Operan:

Hasil:

mhlo.floor (mhlo::FloorOp)

Floor operation

Sintaksis:

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operan:

Hasil:

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.

Atribut:

Operan:

Hasil:

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

Contoh:

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

Atribut:

Operan:

Hasil:

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

Contoh:

%result = mhlo.get_dimension_size %operand, dim = 1 : (tensor<2x3xf32>) -> tensor<i32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Sintaksis:

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