'mhlo' Lehçe

Operasyonlar

mhlo.abs (mhlo::AbsOp)

Karın kası ameliyatı

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 result tensörünü üretir.

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.acos (mhlo::AcosOp)

Acos operasyonu

Sözdizimi:

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

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

Örnek:

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

Özellikler: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

İşlenenler:

Sonuçlar:

mhlo.acosh (mhlo::AcoshOp)

Acosh operasyonu

Sözdizimi:

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

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

Örnek:

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

Özellikler: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

İş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 tensör lhs ve rhs eleman bazında toplamını gerçekleştirir ve bir result tensörü üretir.

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.add_dependency (mhlo::AddDependencyOp)

Bağımlılık Ekleme işlemi

Sözdizimi:

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

Bu işlem XLA derleyicisine özeldir, dolayısıyla henüz bir spesifikasyonu yoktur.

Gayriresmi olarak, bu işlem iki işlenen içerir: bir veri işleneni ve bir belirteç. İşlemin çıktısı veri işlenenidir. AfterAll ile kullanıldığında, bu işlem yan etki yaratmayan işlemlerin (belirteç değerleri üretmeyenlerin) sıralanmasını sağlar.

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.after_all (mhlo::AfterAllOp)

AfterAll işlemi

Sözdizimi:

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

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

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

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.all_gather (mhlo::AllGatherOp)

AllGather operasyonu

İşlem ızgarasındaki her işlem grubunda, all_gather_dim boyunca her işlemden gelen işlenen tensörünün değerlerini birleştirir ve bir sonuç tensörü üretir. computation , operands içindeki her işlenen için ayrı ayrı uygulanır ve işlenen başına bir sonuç üretir.

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

İşlem ızgarasındaki her işlem grubunda, her işlemden bir işlenen tensörünün değerlerine bir indirgeme fonksiyonu computation uygulanır ve bir sonuç tensörü üretilir. computation , operands içindeki her işlenen için ayrı ayrı uygulanır ve işlenen başına bir sonuç üretilir.

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

Özellikler: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.all_to_all (mhlo::AllToAllOp)

AllToAll işlemi

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

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

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

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

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.asin (mhlo::AsinOp)

Asin operasyonu

Sözdizimi:

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

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

Örnek:

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

Özellikler: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

İşlenenler:

Sonuçlar:

mhlo.asinh (mhlo::AsinhOp)

Asinh operasyonu

Sözdizimi:

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

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

Örnek:

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

Özellikler: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

İşlenenler:

Sonuçlar:

mhlo.async_done (mhlo::AsyncDoneOp)

AsyncDone işlemi

Bu işlem XLA derleyicisine özeldir, dolayısıyla 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)

AsyncStart işlemi

Bu işlem XLA derleyicisine özeldir, dolayısıyla henüz bir spesifikasyonu yoktur.

Gayri resmi olarak bu işlem, asenkron bir hesaplamayı başlatır.

Bu, hem eşzamansız beklemeler (DMA'lar gibi) hem de iş parçacığı üzerinde hesaplama içeren işlevler olduğunda kullanılır. Örneğin, bir işlev bir hesaplama, bir DMA, başka bir hesaplama, ikinci bir DMA ve son bir hesaplamadan oluşabilir. Bu, bir async_start, ardından bir async_update ve bir async_done ile temsil edilir. async_start, ilk hesaplamayı iş parçacığı üzerinde yapar ve ardından DMA'yı başlatır. async_update, DMA henüz tamamlanmadıysa 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ı bekler ve ardından iş parçacığı üzerinde çalıştırılması gereken son hesaplamayı çalıştırır ve bu son hesaplamanın sonucunu döndürür.

operands doğrudan hesaplamaya aktarılır. called_computation , eşzamansız olarak çalıştırılacak fonksiyondur. execution_thread çalıştırılacağı iş parçacığının adıdır. Ana iş parçacığına "main" adı verilir. Tüm iş parçacıklarının adları vardır.

Bu, eşzamansız işlemler arasında ihtiyaç duyulan tüm durumu döndürür. Arabellek atamasından sonra, döndürülen değerler, eşzamansız işlem tarafından ihtiyaç duyulan veya düzenlenen girdileri, sonuçları ve tüm 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 özeldir, dolayısıyla henüz bir spesifikasyonu yoktur.

Gayriresmi olarak, bu işlem bir senkronizasyon bariyerine ulaşana kadar asenkron bir hesaplamayı engeller. Bu işlem, üzerinde işlem yaptıktan sonra bundle değerini 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şlemi gerçekleştirir ve bir result tensörü üretir.

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

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.atanh (mhlo::AtanhOp)

Atanh operasyonu

Sözdizimi:

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

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

Örnek:

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

Özellikler: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

İşlenenler:

Sonuçlar:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

BatchNormGrad işlemi

BatchNormTrainingOp'un çeşitli girdilerinin grad_output geri yayılımını hesaplar ve grad_operand , grad_scale ve grad_offset tensörlerini üretir.

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

Özellikler: AlwaysSpeculatableImplTrait , InferTensorType

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

BatchNormInference işlemi

operand tensörünü feature_index boyutu hariç tüm boyutlarda normalleştirir ve bir result tensörü üretir.

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

Özellikler: AlwaysSpeculatableImplTrait , InferTensorType

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

BatchNormTraining işlemi

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

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

Özellikler: AlwaysSpeculatableImplTrait , InferTensorType

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.bitcast (mhlo::BitcastOp)

Bitcast işlemi

Sözdizimi:

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

Bu işlem XLA derleyicisine özeldir, dolayısıyla henüz bir spesifikasyonu yoktur.

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

Bu işlemin "elemanların fiziksel düzenlemesini" anlamlandırabilmesi için düzen bilgisine ihtiyacı vardır ve MHLO'daki düzen desteği şu anda geliştirme aşamasındadır.

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

BitcastConvert işlemi

Sözdizimi:

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

operand tensör üzerinde bir bit dönüştürme işlemi gerçekleştirir ve operand tensörünün tüm bitlerinin, result tensörünün türü kullanılarak yeniden yorumlandığı bir result tensörü üretir.

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

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.broadcast (mhlo::BroadcastOp)

Yayın operasyonu

Bu işlem StableHLO'dan çıkmak üzere olduğundan, spesifikasyona dahil edilmemiştir: 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 , InferTensorType , SameOperandsAndResultElementType

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

BroadcastInDim işlemi

operand tensöründeki verileri kopyalayarak giriş tensörünün boyutlarını ve/veya derecesini genişletir ve bir result tensörü üretir.

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.case (mhlo::CaseOp)

Vaka operasyonu

index değerine bağlı olarak branches yalnızca bir function çalıştırılmasıyla çıktı üretir.

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

TCMB operasyonu

Sözdizimi:

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

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

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

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.ceil (mhlo::CeilOp)

Tavan operasyonu

Sözdizimi:

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

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

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

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.cholesky (mhlo::CholeskyOp)

Cholesky operasyonu

Bir dizi matrisin Cholesky ayrıştırılmasını hesaplar.

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

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İş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ün her bir elemanını minimum ve maksimum değer arasında sıkıştırır ve bir result tensörü üretir.

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Toplu Yayın operasyonu

İşlem ızgarasındaki her işlem grubunda, operand tensörünün değerini kaynak işlemden hedef işleme gönder ve bir result tensörü üret.

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

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

TopluPermute işlemi

İşlem ızgarasındaki her işlem grubu içerisinde, operand tensörünün değerini kaynak işlemden hedef işleme gönderir ve bir result tensörü üretir.

Bkz: 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 , CompatibleOperandsAndResultType

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.compare (mhlo::CompareOp)

İşlemi karşılaştır

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.

Bkz: 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 , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.complex (mhlo::ComplexOp)

Karmaşık operasyon

Sözdizimi:

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

Gerçek ve sanal değer çiftlerinden ( lhs ve rhs ) karmaşık bir değere eleman bazında dönüşüm gerçekleştirir ve bir result tensörü üretir.

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

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.composite (mhlo::CompositeOp)

Bileşik işlem

Sözdizimi:

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

Diğer StableHLO işlemlerinden oluşan (bileşen) bir işlemi kapsüller, inputs ve composite_attributes alır ve results üretir. İşlemin semantiği, decomposition özniteliği tarafından uygulanır. composite işlem, program semantiğini değiştirmeden ayrıştırmasıyla değiştirilebilir. Ayrıştırmanın satır içi olarak uygulanmasının aynı işlem semantiğini sağlamadığı durumlarda, custom_call kullanmayı tercih edin.

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

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

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

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

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , ConstantLike

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

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)

Etkiler: MemoryEffects::Effect{}

İşlenenler:

Sonuçlar:

mhlo.convolution (mhlo::ConvolutionOp)

Evrişim işlemi

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>

Özellikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

Sonuçlar:

mhlo.cosh (mhlo::CoshOp)

Cosh operation

Sözdizimi:

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

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

Örnek:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

İşlenenler:

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

Özellikler: AlwaysSpeculatableImplTrait

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

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

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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>

Özellikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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>

Özellikler: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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>

Özellikler: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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>

Özellikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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>

Özellikler: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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.

Özellikler: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

İşlenenler:

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>

Özellikler: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

İşlenenler:

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>

Özellikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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.

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Etkiler: MemoryEffects::Effect{}

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

İşlenenler:

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.

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)

Etkiler: MemoryEffects::Effect{}

Nitelikler:

İşlenenler:

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)