'mhlo' Dialek

Operasi

mhlo.abs (mhlo::AbsOp)

Operasi perut

Sintaksis:

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

Melakukan operasi abs 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>

Ciri: 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 per 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 per 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 penambahan 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>

Ciri: 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 pribadi bagi kompiler XLA, jadi belum memiliki spesifikasi.

Secara informal, operasi ini memiliki dua operan: operan data dan token. Keluaran dari operasi ini adalah operan data. Ketika digunakan dengan AfterAll, operasi ini memungkinkan pengurutan operasi tanpa 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)

Operasi AfterAll

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

Dalam setiap grup proses di kisi proses, menggabungkan nilai tensor operan dari setiap proses di sepanjang all_gather_dim dan menghasilkan tensor hasil. computation diterapkan secara terpisah untuk setiap operan di 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 kisi proses, terapkan computation fungsi reduksi ke nilai tensor operan dari setiap proses dan hasilkan 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>

Ciri-ciri: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Atribut:

Operan:

Hasil:

mhlo.all_to_all (mhlo::AllToAllOp)

Operasi AllToAll

Dalam setiap grup proses di kisi proses, membagi nilai tensor operand sepanjang split_dimension menjadi beberapa bagian, menyebarkan bagian yang terbagi di antara proses, menggabungkan bagian yang tersebar 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>

Ciri: 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 AND elemen-bijaksana dari 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>

Ciri: 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 pribadi bagi kompiler XLA, jadi belum memiliki spesifikasi.

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

Lihat dokumentasi untuk AsyncStart untuk informasi lebih lanjut.

Antarmuka: InferTypeOpInterface

Operan:

Hasil:

mhlo.async_start (mhlo::AsyncStartOp)

Operasi AsyncStart

Operasi ini bersifat pribadi bagi kompiler XLA, jadi belum memiliki spesifikasi.

Secara informal, operasi ini memulai komputasi asinkron.

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

operands diteruskan langsung ke komputasi. Fungsi called_computation adalah fungsi yang akan dijalankan secara asinkron. execution_thread adalah nama utas tempat utas tersebut akan dijalankan. Utas utama disebut "main". Semua utas memiliki nama.

Ini mengembalikan semua status yang dibutuhkan di antara operasi asinkron. Setelah buffer ditetapkan, nilai yang dikembalikan mewakili ruang yang dibutuhkan untuk menyimpan input, hasil, dan scratchpad apa pun yang dibutuhkan atau diedit oleh operasi asinkron.

Atribut:

Operan:

Hasil:

mhlo.async_update (mhlo::AsyncUpdateOp)

Operasi AsyncUpdate

Operasi ini bersifat pribadi bagi kompiler XLA, jadi belum memiliki spesifikasi.

Secara informal, operasi ini memblokir komputasi asinkron hingga mencapai batas sinkronisasi. Ini mengembalikan bundle setelah beroperasi di atasnya.

Lihat dokumentasi untuk 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>

Ciri: 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 beberapa masukan BatchNormTrainingOp yang dipropagasi balik 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>)

Ciri: AlwaysSpeculatableImplTrait , InferTensorType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Operasi BatchNormInference

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

Ciri: AlwaysSpeculatableImplTrait , InferTensorType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operasi BatchNormTraining

Menghitung rata-rata dan varians di seluruh dimensi batch dan spasial dan menormalkan 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>)

Ciri: 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 pribadi bagi kompiler XLA, jadi belum memiliki spesifikasi.

Secara informal, operasi ini mengubah bentuk masukan dengan cara tidak mengubah susunan fisik elemen.

Operasi ini memerlukan informasi tata letak untuk memahami "penataan fisik elemen", dan dukungan tata letak di MHLO saat ini masih dalam tahap pengerjaan.

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 dari seluruh tensor operand ditafsirkan ulang menggunakan tipe tensor result .

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 perjalanan keluar dari StableHLO, jadi tidak termasuk dalam spesifikasi: https://github.com/openxla/stablehlo/issues/3

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

Contoh:

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

Ciri: 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 peringkat 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>

Ciri: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Antarmuka: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.case (mhlo::CaseOp)

Operasi kasus

Menghasilkan keluaran dari pelaksanaan tepat satu function dari branches tergantung 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>)

Ciri-ciri: 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 per 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>

Ciri: 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 pemotongan elemen demi 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>

Ciri: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.cholesky (mhlo::CholeskyOp)

Operasi koleski

Menghitung dekomposisi Cholesky pada sekumpulan matriks.

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

Contoh:

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

Ciri: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.clamp (mhlo::ClampOp)

Operasi penjepit

Sintaksis:

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

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

Ciri-ciri: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Operasi Siaran Kolektif

Dalam setiap grup proses di kisi proses, kirimkan 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

Dalam setiap grup proses di kisi 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>

Ciri: 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 dari tensor lhs dan rhs menurut 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>

Ciri: 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 pasangan 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>>

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

Mengenkapsulasi operasi yang terdiri dari operasi StableHLO lainnya, mengambil inputs dan composite_attributes , serta menghasilkan results . Semantik operasi (OP) diimplementasikan oleh atribut decomposition . Operasi composite dapat digantikan dengan dekomposisinya tanpa mengubah semantik program. Jika penyisipan dekomposisi tidak menghasilkan semantik operasi yang sama, sebaiknya gunakan custom_call .

Bidang version (defaultnya 0 ) digunakan untuk menunjukkan kapan semantik 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)

Operasi penggabungan

Menggabungkan sejumlah variadis tensor dalam inputs sepanjang dimensi dimension dalam urutan yang sama seperti argumen yang diberikan dan menghasilkan tensor result .

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

Ciri: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.constant (mhlo::ConstantOp)

Constant operation

Produces an output tensor from a constant value .

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Antarmuka: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

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

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

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

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

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

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efek: 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.

Ciri-ciri: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

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

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

Ciri-ciri: AlwaysSpeculatableImplTrait

Antarmuka: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

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

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

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.floor (mhlo::FloorOp)

Operasi lantai

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)

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

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

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