'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 berdasarkan 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-ciri: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.add (mhlo::TambahOp)

Tambahkan operasi

Sintaksis:

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

Melakukan penambahan dua tensor lhs dan rhs berdasarkan elemen 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-ciri: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.add_dependency (mhlo::AddDependencyOp)

Operasi Tambahkan Ketergantungan

Sintaksis:

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

Operasi ini bersifat pribadi 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. Saat 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 dijalankan 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 Semua Kumpulkan

Dalam setiap grup proses di kisi proses, gabungkan nilai tensor operan dari setiap proses sepanjang all_gather_dim 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, terapkan computation fungsi reduksi 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>

Sifat: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Antarmuka: InferShapedTypeOpInterface , InferTypeOpInterface

Atribut:

Operan:

Hasil:

mhlo.all_to_all (mhlo::AllToAllOp)

Operasi Semua Ke Semua

Dalam setiap grup proses di kisi proses, pisahkan nilai tensor operand sepanjang split_dimension menjadi beberapa bagian, sebarkan bagian yang terpisah di antara proses, gabungkan bagian yang tersebar di sepanjang concat_dimension dan hasilkan 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>

Sifat: 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 elemen AND 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-ciri: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.async_done (mhlo::AsyncDoneOp)

Operasi AsyncDone

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

Secara informal, operasi ini memblokir hingga akhir komputasi asinkron. Ini mengembalikan hasil akhir dari perhitungan asinkron.

Lihat dokumentasi AsyncStart untuk informasi selengkapnya.

Antarmuka: InferTypeOpInterface

Operan:

Hasil:

mhlo.async_start (mhlo::AsyncStartOp)

Operasi AsyncMulai

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

Secara informal, operasi ini memulai komputasi asinkron.

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

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

Ini mengembalikan semua status yang diperlukan antara operasi asinkron. Setelah penetapan buffer, nilai yang dikembalikan mewakili ruang yang diperlukan untuk menampung input, hasil, dan semua scratchpad yang diperlukan atau diedit oleh operasi asinkron.

Atribut:

Operan:

Hasil:

mhlo.async_update (mhlo::AsyncUpdateOp)

Operasi AsyncUpdate

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

Secara informal, operasi ini memblokir komputasi asinkron hingga hambatan sinkronisasi. Ini mengembalikan bundle setelah mengoperasikannya.

Lihat dokumentasi AsyncStart untuk informasi selengkapnya.

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 berdasarkan 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-ciri: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Operasi BatchNormGrad

Menghitung gradien beberapa input backpropagating BatchNormTrainingOp 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-ciri: AlwaysSpeculatableImplTrait , InferTensorType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Operasi BatchNormInferensi

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>

Sifat: AlwaysSpeculatableImplTrait , InferTensorType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operasi BatchNormTraining

Menghitung mean dan varians di seluruh dimensi batch dan spasial serta menormalkan tensor operand , untuk setiap fitur dalam dimensi feature_index dan menghasilkan tensor output , 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-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 untuk kompiler XLA, sehingga belum memiliki spesifikasi.

Secara informal, operasi ini mengubah bentuk input dengan cara pengaturan fisik elemen tidak berubah.

Operasi ini membutuhkan informasi tata letak untuk memahami "pengaturan fisik elemen", dan dukungan tata letak di MHLO saat ini sedang dalam proses.

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 tenda operand ditafsirkan kembali menggunakan jenis 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 :: siaran)

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 dengan siaran XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Contoh:

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

Ciri -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 -ciri: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Antarmuka: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.case (mhlo :: casedop)

Operasi kasus

Menghasilkan output dari mengeksekusi 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: Efek 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 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 -ciri: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType danaDresultType, Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.ceil (mhlo :: ceilop)

Operasi ceil

Sintaksis:

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

Melakukan langit-langit elemen dari 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 -ciri: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType danaDresultType, Elementwise , SameOperandsAndResultShape

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.cholesky (mhlo :: choleskyop)

Operasi Cholesky

Menghitung dekomposisi cholesky dari batch matriks.

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

Contoh:

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

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

Klem 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 speculatableImpltrait, HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Efek: MemoryEffects::Effect{}

Operan:

Hasil:

mhlo.collective_broadcast (mhlo :: collectiveBroadcastop)

Operasi CollectiveBroadcast

Dalam setiap kelompok proses dalam kisi proses, kirim 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_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 kelompok proses dalam 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 -ciri: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efek: MemoryEffects::Effect{}

Atribut:

Operan:

Hasil:

mhlo.compare (mhlo :: compareop)

Bandingkan operasi

Sintaksis:

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

Melakukan perbandingan 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 -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-bijaksana ke nilai kompleks dari sepasang nilai nyata 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 -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)

Merangkum operasi yang dibuat (terdiri) dari operasi stableHlo lainnya, mengambil inputs dan composite_attributes dan menghasilkan results . Semantik OP diimplementasikan oleh atribut decomposition . OP composite dapat diganti dengan dekomposisi tanpa mengubah semantik program. Dalam kasus di mana inlining dekomposisi tidak memberikan semantik OP yang sama, lebih suka menggunakan custom_call .

Bidang version (default ke 0 ) digunakan untuk menunjukkan ketika 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 gabungan

Menggabungkan sejumlah variad tensor dalam inputs sepanjang dimensi dimension dalam urutan yang sama dengan 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 -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

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

Operands:

Hasil:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

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:

Operands:

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:

Operands:

Hasil:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

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

Operands:

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

Operands:

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:

Operands:

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.

Interfaces: MemoryEffectOpInterface

Atribut:

Operands:

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

Operands:

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:

Operands:

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:

Operands:

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:

Operands:

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:

Operands:

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:

Operands:

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:

Operands:

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:

Operands:

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

Operands:

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

Operands:

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:

Operands:

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

Operands:

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:

Operands:

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.

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Operands:

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

Operands:

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:

Operands:

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

Operands:

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:

Operands:

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:

Operands:

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:

Operands:

Hasil:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Operands:

Hasil:

mhlo.if (mhlo::IfOp)

If operation

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

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

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

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operands:

Hasil:

mhlo.imag (mhlo::ImagOp)

Imag operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Hasil:

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

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

Contoh:

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

Atribut:

Operands:

Hasil:

mhlo.iota (mhlo::IotaOp)

Iota operation

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atribut:

Hasil:

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Hasil:

mhlo.log (mhlo::LogOp)

Log operation

Sintaksis:

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

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

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

Contoh:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Hasil: