'mhlo' Lehçe

Operasyonlar

mhlo.abs (mhlo::AbsOp)

Karın kasları operasyonu

Sözdizimi:

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

operand tensör üzerinde eleman bazında abs işlemi gerçekleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.add (mhlo::AddOp)

İşlem ekle

Sözdizimi:

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

İki lhs ve rhs tensörünün eleman bazında toplamasını gerçekleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.add_dependency (mhlo::AddDependencyOp)

AddDependency işlemi

Sözdizimi:

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

Bu işlem XLA derleyicisine özel olduğundan henüz bir spesifikasyonu yoktur.

Gayri resmi olarak, bu işlem iki işlenenden oluşur: bir veri işleneni ve bir belirteç. İşlemin çıktısı veri işlenenidir. AfterAll ile birlikte kullanıldığında bu işlem, yan etkisi olmayan işlemlerin (belirteç değerleri üretmeyenler) sıralanmasına olanak sağlar.

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.after_all (mhlo::AfterAllOp)

Tüm işlemlerden sonra

Sözdizimi:

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

inputs üreten işlemlerin, result bağlı işlemlerden önce yürütülmesini sağlar.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.all_gather (mhlo::AllGatherOp)

AllGather işlemi

Süreç ızgarasındaki her süreç grubu içinde, all_gather_dim boyunca her süreçten işlenen tensörünün değerlerini birleştirir ve bir sonuç tensörü üretir. computation , operands her işlenen için ayrı ayrı uygulanır ve işlenen başına bir sonuç üretilir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

Örnek:

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

Özellikler: SameOperandsAndResultElementType

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.all_reduce (mhlo::AllReduceOp)

AllReduce işlemi

Süreç ızgarasındaki her süreç grubu içinde, her süreçteki işlenen tensörünün değerlerine bir indirgeme fonksiyonu computation uygular ve bir sonuç tensörü üretir. computation , operands her işlenen için ayrı ayrı uygulanır ve işlenen başına bir sonuç üretilir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Örnek:

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

Nitelikler: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.all_to_all (mhlo::AllToAllOp)

HepsindenTümüne işlemi

Süreç ızgarasındaki her süreç grubu içinde, operand tensörünün değerlerini split_dimension boyunca parçalara böler, bölünmüş parçaları işlemler arasında dağıtır, dağınık parçaları concat_dimension boyunca birleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.and (mhlo::AndOp)

Ve operasyon

Sözdizimi:

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

lhs ve rhs olmak üzere iki tensörün eleman bazında VE'sini gerçekleştirir ve result tensörünü üretir

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.async_done (mhlo::AsyncDoneOp)

AsyncDone işlemi

Bu işlem XLA derleyicisine özel olduğundan henüz bir spesifikasyonu yoktur.

Gayri resmi olarak bu işlem, eşzamansız bir hesaplamanın sonuna kadar bloke eder. Eşzamansız hesaplamanın nihai sonucunu döndürür.

Daha fazla bilgi için AsyncStart belgelerine bakın.

Arayüzler: InferTypeOpInterface

İşlenenler:

Sonuçlar:

mhlo.async_start (mhlo::AsyncStartOp)

Eşzamansız Başlatma işlemi

Bu işlem XLA derleyicisine özel olduğundan henüz bir spesifikasyonu yoktur.

Gayri resmi olarak, bu işlem eşzamansız bir hesaplamayı başlatır.

Bu, hem eşzamansız beklemeleri (DMA'lar gibi) hem de iş parçacığı üzerinde hesaplamayı içeren işlevler olduğunda kullanılır. Örneğin, bir fonksiyon bir hesaplama, bir DMA, başka bir hesaplama, ikinci bir DMA ve son bir hesaplamadan oluşabilir. Bu, bir async_start ve ardından async_update ve bir async_done olarak temsil edilir. async_start iş parçacığı üzerinde ilk hesaplamayı yapar ve ardından DMA'yı başlatır. async_update, henüz yapılmadıysa DMA'nın tamamlanmasını bekler, ardından işlevdeki ikinci hesaplamayı yürütür ve ikinci DMA'yı başlatır. Son olarak, async_done bu son DMA'yı bekleyecek ve ardından iş parçacığı üzerinde çalıştırılması gereken son hesaplamayı çalıştıracak ve bu son hesaplamanın sonucunu döndürecektir.

operands doğrudan hesaplamaya iletilir called_computation eşzamansız olarak çalıştırılacak olan işlevdir execution_thread içinde çalıştırılacağı iş parçacığının adıdır. Ana iş parçacığına "ana" denir. Tüm konuların isimleri vardır.

Bu, eşzamansız işlemler arasında gereken tüm durumu döndürür. Arabellek atamasından sonra dönüş değerleri, girişi, sonuçları ve eşzamansız işlem tarafından ihtiyaç duyulan veya düzenlenen not defterlerini tutmak için gereken alanı temsil eder.

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.async_update (mhlo::AsyncUpdateOp)

AsyncUpdate işlemi

Bu işlem XLA derleyicisine özel olduğundan henüz bir spesifikasyonu yoktur.

Gayri resmi olarak bu işlem, bir senkronizasyon engeline kadar eşzamansız bir hesaplamayı engeller. Bu, üzerinde çalıştıktan sonra bundle döndürür.

Daha fazla bilgi için AsyncStart belgelerine bakın.

Arayüzler: InferTypeOpInterface

İşlenenler:

Sonuçlar:

mhlo.atan2 (mhlo::Atan2Op)

Atan2 operasyonu

Sözdizimi:

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

lhs ve rhs tensörü üzerinde eleman bazında atan2 işlemini gerçekleştirir ve result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

BatchNormGrad işlemi

grad_output geriye yayılan BatchNormTrainingOp'un çeşitli girişlerinin gradyanlarını hesaplar ve grad_operand , grad_scale ve grad_offset tensörlerini üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , InferTensorType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

BatchNormInference işlemi

operand tensörünü feature_index boyutu dışındaki tüm boyutlarda normalleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , InferTensorType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

BatchNormEğitim işlemi

Toplu iş ve uzamsal boyutlar arasında ortalama ve varyansı hesaplar ve feature_index boyutundaki her özellik için operand tensörünü normalleştirir ve output , batch_mean ve batch_var tensörlerini üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , InferTensorType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.bitcast (mhlo :: bitcastop)

Bitcast Operasyonu

Sözdizimi:

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

Bu işlem XLA derleyicisi için özeldir, bu nedenle henüz bir spesifikasyon yoktur.

Gayri resmi olarak, bu işlem, elemanların fiziksel düzenlemesinin değişmediği şekilde girişin şeklini değiştirir.

Bu işlemin "elementlerin fiziksel düzenlemesi" ni anlamak için düzen bilgilerine ihtiyacı vardır ve MHLO'da düzen desteği şu anda devam etmekte olan bir çalışma.

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.bitcast_convert (mhlo :: bitcastconvertop)

BitcastConvert İşlemi

Sözdizimi:

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

operand tensörde bir Bitcast işlemi gerçekleştirir ve tüm operand tensörün bitlerinin result tensörünün türü kullanılarak yeniden yorumlandığı bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait

Arabirimler: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.broadcast (MHLO :: Broadcastop)

Yayın işlemi

Bu işlem StableHlo'dan çıkıyor, bu nedenle spesifikasyona dahil değil: https://github.com/openxla/stablehlo/issues/3

Gayri resmi olarak, bu işlem XLA'nın yayını ile aynı şeyi yapar: https://www.tensorflow.org/xla/operation_semantics#broadcast

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait SpeculatableImptrait, InferTensorType , SameOperandsAndResultElementType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Özellikler:

İşlenenler:

Sonuçlar:

mhlo.broadcast_in_dim (MHLO :: BroadcastInimop)

BroadcastInim İşlemi

operand tensördeki verileri çoğaltarak bir giriş tensörünün boyutlarını ve/veya sıralamasını genişletir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Özellikler:

İşlenenler:

Sonuçlar:

mhlo.case (mhlo :: caseop)

Vaka işlemi

index değerine bağlı olarak branches tam olarak bir function yürütmekten çıktıyı üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

Örnek:

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

Özellikler: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Arayüzler: InferTypeOpInterface

İşlenenler:

Sonuçlar:

mhlo.cbrt (MHLO :: CBRTOP)

CBRT işlemi

Sözdizimi:

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

operand tensörde eleman bazında kübik kök işlemi gerçekleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait SpeculatableImptrait, CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.ceil (MHLO :: Ceilop)

Tavan

Sözdizimi:

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

Element bazında operand tensör tavanı gerçekleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceilil

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait SpeculatableImptrait, CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.cholesky (MHLO :: Choleskyop)

Cholesky Operasyonu

Bir grup matrisin cholesky ayrışmasını hesaplar.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait SpeculatableImptrait, InferTensorType , SameOperandsAndResultElementType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Özellikler:

İşlenenler:

Sonuçlar:

mhlo.clamp (MHLO :: Clampop)

Kelepçe işlemi

Sözdizimi:

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

operand tensörün her öğesini minimum ve maksimum değer arasında sıkıştırır ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.collective_broadcast (MHLO :: CollectiveBroadcastop)

Kolektifbroad yayın işlemi

Proses ızgarasındaki her işlem grubunda, operand tensörün değerini kaynak işlemden hedef işlemlere gönderin ve bir result tensörü üretin.

Bkz. Https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

Örnek:

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

Özellikler: CompatibleOperandsAndResultType

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

Özellikler:

İşlenenler:

Sonuçlar:

mhlo.collective_permute (MHLO :: CollectivePermuteop)

Kolektifermute işlemi

Proses ızgarasındaki her işlem grubunda, operand tensörünün kaynak işleminden hedef sürece gönderir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait SpeculatableImptrait, CompatibleOperandsAndResultType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Özellikler:

İşlenenler:

Sonuçlar:

mhlo.compare (mhlo :: compareop)

İşlemi karşılaştırın

Sözdizimi:

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

comparison_direction ve compare_type göre lhs ve rhs tensörlerinin eleman bazında karşılaştırmasını gerçekleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait SpeculatableImptrait, Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Özellikler:

İşlenenler:

Sonuçlar:

mhlo.complex (mhlo :: complexop)

Karmaşık çalışma

Sözdizimi:

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

Bir çift gerçek ve hayali değer olan lhs ve rhs karmaşık bir değere eleman bazında dönüşüm gerçekleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait SpeculatableImptrait, Elementwise , SameOperandsAndResultShape , SameOperandsElementType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.composite (mhlo :: compositeop)

Kompozit işlem

Sözdizimi:

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

Diğer stabilhlo operasyonlarının oluşturulduğu (bestelenen), inputs ve composite_attributes alarak ve results üreten bir işlemi kapsar. OP'nin semantiği decomposition özelliği tarafından uygulanır. composite OP, program semantiğini değiştirmeden ayrışmasıyla değiştirilebilir. Ayrışmanın birleştirilmesinin aynı OP anlambilimini sağlamadığı durumlarda, custom_call kullanmayı tercih edin.

version alanı (varsayılan 0 kadar), bir kompozitin semantiğinin değiştiğini belirtmek için kullanılır.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#composite

Örnek:

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

Arayüzler: SymbolUserOpInterface

Özellikler:

İşlenenler:

Sonuçlar:

mhlo.concatenate (MHLO :: Concatesateop)

Birleştirme işlemi

dimension boyutu boyunca inputs değişken sayıda tensörü verilen argümanlarla aynı sırayla birleştirir ve bir result tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#concatesate

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait SpeculatableImptrait, SameOperandsAndResultElementType

Arayüzler: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Özellikler:

İşlenenler:

Sonuçlar:

mhlo.constant (MHLO :: Constantop)

Sürekli çalışma

Sabit bir value bir output tensörü üretir.

Bakınız: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Sonuçlar:

mhlo.convert (mhlo::ConvertOp)

Convert operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

mhlo.copy (mhlo::CopyOp)

Copy operation

Sözdizimi:

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.

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

Sözdizimi:

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

Örnek:

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

Sözdizimi:

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

Örnek:

%results = "mhlo.custom_call"(%input0) {
  call_target_name = "foo",
  has_side_effect = false,
  backend_config = "bar",
  api_version = 1 : i32,
  called_computations = [@foo]
} : (tensor<f32>) -> tensor<f32>

A custom call invokes code external to XLA. The `inputs` are passed to the
external code, and the external code is expected to produce a result of the
given type. The exact mechanism is backend-specific. For example, in the CPU
backend, a call instruction is emitted which targets a symbol with the name
`call_target_name`.

If XLA runtime is enabled for a backend, then custom calls use the runtime
custom call calling convention to call into the external functions. This
calling convention defines an ABI for encoding arguments, attributes and
results.

Depending on the API version there are two ways to pass extra bits of static
information to the external function:

1. For `API_VERSION_TYPED_FFI` custom calls `backend_config` must be a
   dictionary attribute, that will be encoded according to the custom call
   calling convention and passed to the external function as the attributes
   argument. External code is expected to use declarative bindings (see
   `xla/runtime/custom_call.h`) to decode them at run time. These custom
   calls are only supported if XLA uses XLA runtime.

2. For previous API versions it is the user responsibility to encode extra
   bits of static information as a string `backend_config` attribute, and
   decode it at run time.

Interfaces: MemoryEffectOpInterface

Attributes:

Operands:

Sonuçlar:

mhlo.divide (mhlo::DivOp)

Div operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

mhlo.domain (mhlo::DomainOp)

Domain operation

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

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

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

Sözdizimi:

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:

Sonuçlar:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

Sözdizimi:

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

Örnek:

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

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

Sözdizimi:

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

Örnek:

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

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

mhlo.erf (mhlo::ErfOp)

Erf operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

mhlo.exponential (mhlo::ExpOp)

Exp operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

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

Örnek:

%result = mhlo.fft %operand, type = FFT, length = [4] : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

mhlo.floor (mhlo::FloorOp)

Floor operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

mhlo.fusion (mhlo::FusionOp)

Fusion operation

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

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

Attributes:

Operands:

Sonuçlar:

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

Örnek:

%result = "mhlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [3, 4],
    collapsed_slice_dims = [1],
    operand_batching_dims = [0],
    start_indices_batching_dims = [1],
    start_index_map = [2, 1],
    index_vector_dim = 3>,
  slice_sizes = dense<[0, 2, 2]> : tensor<3xi64>,
  indices_are_sorted = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>) -> tensor<2x2x3x2x2xi64>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Sonuçlar:

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:

Sonuçlar:

mhlo.imag (mhlo::ImagOp)

Imag operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

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

Örnek:

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

Attributes:

Operands:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Sonuçlar:

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar:

mhlo.log (mhlo::LogOp)

Log operation

Sözdizimi:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Sonuçlar: