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

İşlenen	Tanım
operand	2/4/8/16/32/64 bit işaretsiz tamsayı veya 4/6/8/16/32/64 bit float veya 32/64 bit float elemanları veya 2/4/8/16/32 bit tekdüze nicemlenmiş işaretli tamsayı veya 2/4/8/16/32 bit tekdüze nicemlenmiş eksen başına işaretli tamsayı veya 2/4/8/16/32 bit tekdüze nicemlenmiş işaretsiz tamsayı veya 2/4/8/16/32 bit tekdüze nicemlenmiş eksen başına işaretsiz tamsayı değerlerinin sıralı tensörü

Sonuçlar:

Sonuç	Tanım
result	2/4/8/16/32/64 bit işaretsiz tam sayı veya 4/6/8/16/32/64 bit kayan noktalı sayı veya 2/4/8/16/32 bit tekdüze nicemlenmiş işaretli tam sayı veya 2/4/8/16/32 bit tekdüze nicemlenmiş eksen başına işaretli tam sayı veya 2/4/8/16/32 bit tekdüze nicemlenmiş işaretsiz tam sayı veya 2/4/8/16/32 bit tekdüze nicemlenmiş eksen başına işaretsiz tam sayı değerlerinin sıralı tensörü

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:

İşlenen	Tanım
operand	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki tensör

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki tensör

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:

İşlenen	Tanım
operand	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki tensör

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki tensör

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:

İşlenen	Tanım
lhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler
rhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

İşlenen	Tanım
operand	4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tam sayı nicemlenmiş değerler veya eksen başına tam sayı nicemlenmiş değerlerin sıralı tensörü veya belirteç veya stablehlo belirteci
token	token veya stablehlo token

Sonuçlar:

Sonuç	Tanım
output	4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tam sayı nicemlenmiş değerler veya eksen başına tam sayı nicemlenmiş değerlerin sıralı tensörü veya belirteç veya stablehlo belirteci

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:

İşlenen	Tanım
inputs	değişkenli belirteç

Sonuçlar:

Sonuç	Tanım
result	jeton

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:

Bağlanmak	MLIR Tipi	Tanım
all_gather_dim	::mlir::IntegerAttr	Değeri negatif olmayan 64 bitlik işaretsiz tamsayı niteliği
replica_groups	::mlir::YoğunIntElementsAttr	64 bitlik işaretsiz tamsayı öğeleri niteliği
channel_handle	::mlir::mhlo::KanalTanıtıcısıAttr	iki 64 bit tam sayı 'handle' ve 'type'
use_global_device_ids	::mlir::BirimAttr	birim niteliği

İşlenenler:

İşlenen	Tanım
operands	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanlarına sahip karmaşık tipteki sıralı tensörün değişken sayısı veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanlarına sahip karmaşık tipteki sıralı tensörün değişken sayısı veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

Bağlanmak	MLIR Tipi	Tanım
replica_groups	::mlir::YoğunIntElementsAttr	64 bitlik işaretsiz tamsayı öğeleri niteliği
channel_handle	::mlir::mhlo::KanalTanıtıcısıAttr	iki 64 bit tam sayı 'handle' ve 'type'
use_global_device_ids	::mlir::BirimAttr	birim niteliği

İşlenenler:

İşlenen	Tanım
operands	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanlarına sahip karmaşık tipteki sıralı tensörün değişken sayısı veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanlarına sahip karmaşık tipteki sıralı tensörün değişken sayısı veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

Bağlanmak	MLIR Tipi	Tanım
split_dimension	::mlir::IntegerAttr	Değeri negatif olmayan 64 bitlik işaretsiz tamsayı niteliği
concat_dimension	::mlir::IntegerAttr	Değeri negatif olmayan 64 bitlik işaretsiz tamsayı niteliği
split_count	::mlir::IntegerAttr	Değeri pozitif olan 64 bitlik işaretsiz tam sayı niteliği
replica_groups	::mlir::YoğunIntElementsAttr	64 bitlik işaretsiz tamsayı öğeleri niteliği
channel_handle	::mlir::mhlo::KanalTanıtıcısıAttr	iki 64 bit tam sayı 'handle' ve 'type'

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanlarına sahip karmaşık tipteki sıralı tensörün değişken sayısı veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanlarına sahip karmaşık tipteki sıralı tensörün değişken sayısı veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

İşlenen	Tanım
lhs	bool veya 2/4/8/16/32/64 bit tam sayı değerlerinin sıralı tensörü
rhs	bool veya 2/4/8/16/32/64 bit tam sayı değerlerinin sıralı tensörü

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

İşlenen	Tanım
operand	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki tensör

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki tensör

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:

İşlenen	Tanım
bundle	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tam sayı veya 32/64-bit float elemanları veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerler veya belirteç veya stablehlo belirteç değerleri ile herhangi bir sıralı tensör kombinasyonuna sahip async_bundle

Sonuçlar:

Sonuç

Tanım

«isimsiz»

4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerler veya belirteç veya stablehlo belirteç veya 4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş değerler veya 4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları veya tensör başına karmaşık türdeki herhangi bir kombinasyonla iç içe geçmiş tuple veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları veya tensör başına karmaşık türdeki memref eksen başına tam sayı nicemlenmiş değerler veya belirteç değerlerinin sıralı tensörü

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:

Bağlanmak	MLIR Tipi	Tanım
called_computation	::mlir::FlatSymbolRefAttr	düz sembol referans niteliği
execution_thread	::mlir::DizeAttr	dize niteliği

İşlenenler:

İşlenen

Tanım

inputs

4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerler veya belirteç veya stablehlo belirteç veya 4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş değerler veya 4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları veya tensör başına karmaşık türdeki herhangi bir kombinasyonla iç içe geçmiş tuple veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit float elemanları veya tensör başına karmaşık türdeki memref eksen başına tam sayı nicemlenmiş değerler veya belirteç değerlerinin sıralı tensörü

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tam sayı veya 32/64-bit float elemanları veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerler veya belirteç veya stablehlo belirteç değerleri ile herhangi bir sıralı tensör kombinasyonuna sahip async_bundle

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:

İşlenen	Tanım
bundle	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tam sayı veya 32/64-bit float elemanları veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerler veya belirteç veya stablehlo belirteç değerleri ile herhangi bir sıralı tensör kombinasyonuna sahip async_bundle

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tam sayı veya 32/64-bit float elemanları veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerler veya belirteç veya stablehlo belirteç değerleri ile herhangi bir sıralı tensör kombinasyonuna sahip async_bundle

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:

İşlenen	Tanım
lhs	32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş değerlerle 4/6/8/16/32/64 bit float veya karmaşık tipte sıralı tensör
rhs	32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş değerlerle 4/6/8/16/32/64 bit float veya karmaşık tipte sıralı tensör

Sonuçlar:

Sonuç	Tanım
result	32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş değerlerle 4/6/8/16/32/64 bit float veya karmaşık tipte sıralı tensör

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:

İşlenen	Tanım
operand	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki tensör

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki tensör

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:

Bağlanmak	MLIR Tipi	Tanım
epsilon	::mlir::FloatAttr	32 bitlik float niteliği
feature_index	::mlir::IntegerAttr	Değeri negatif olmayan 64 bitlik işaretsiz tamsayı niteliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64 bitlik kayan nokta değerlerinin sıralı tensörü
scale	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
mean	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
variance	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
grad_output	4/6/8/16/32/64 bitlik kayan nokta değerlerinin sıralı tensörü

Sonuçlar:

Sonuç	Tanım
grad_operand	4/6/8/16/32/64 bitlik kayan nokta değerlerinin sıralı tensörü
grad_scale	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
grad_offset	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü

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:

Bağlanmak	MLIR Tipi	Tanım
epsilon	::mlir::FloatAttr	32 bitlik float niteliği
feature_index	::mlir::IntegerAttr	Değeri negatif olmayan 64 bitlik işaretsiz tamsayı niteliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64 bitlik kayan nokta değerlerinin sıralı tensörü
scale	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
offset	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
mean	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
variance	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64 bitlik kayan nokta değerlerinin sıralı tensörü

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:

Bağlanmak	MLIR Tipi	Tanım
epsilon	::mlir::FloatAttr	32 bitlik float niteliği
feature_index	::mlir::IntegerAttr	Değeri negatif olmayan 64 bitlik işaretsiz tamsayı niteliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64 bitlik kayan nokta değerlerinin sıralı tensörü
scale	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
offset	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü

Sonuçlar:

Sonuç	Tanım
output	4/6/8/16/32/64 bitlik kayan nokta değerlerinin sıralı tensörü
batch_mean	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü
batch_var	4/6/8/16/32/64 bitlik kayan nokta değerlerinin 1D tensörü

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:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

Bağlanmak	MLIR Tipi	Tanım
broadcast_sizes	::mlir::YoğunIntElementsAttr	64 bitlik işaretsiz tamsayı öğeleri niteliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

Bağlanmak	MLIR Tipi	Tanım
broadcast_dimensions	::mlir::YoğunIntElementsAttr	64 bitlik işaretsiz tamsayı öğeleri niteliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tip veya tensör başına tam sayı nicemlemeli veya eksen başına tam sayı nicemlemeli değerlerin statik şekilli veya tek sınırlı boyutlu tensörü

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:

İşlenen	Tanım
index	32 bitlik işaretsiz tam sayı değerlerinin tensörü

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64 bit float veya bool veya 2/4/8/16/32/64 bit tamsayı veya 32/64 bit float elemanlarına sahip karmaşık tipteki sıralı tensörün değişken sayısı veya tensör başına tamsayı nicemlenmiş değerler veya eksen başına tamsayı nicemlenmiş değerler veya belirteç sıralı tensörü

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:

Bağlanmak	MLIR Tipi	Tanım
result_accuracy	::mlir::mhlo::SonuçDoğruluğuAttr	Tekli işlemler için talep edilen doğruluk.

İşlenenler:

İşlenen	Tanım
operand	32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş değerlerle 4/6/8/16/32/64 bit float veya karmaşık tipte sıralı tensör

Sonuçlar:

Sonuç	Tanım
result	32/64 bit float elemanları veya tensör başına tam sayı nicemlenmiş değerlerle 4/6/8/16/32/64 bit float veya karmaşık tipte sıralı tensör

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:

İşlenen	Tanım
operand	4/6/8/16/32/64 bitlik kayan noktalı veya tensör başına tam sayı nicemlenmiş değerlerin sıralı tensörü

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64 bitlik kayan noktalı veya tensör başına tam sayı nicemlenmiş değerlerin sıralı tensörü

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:

Bağlanmak	MLIR Tipi	Tanım
lower	::mlir::BoolAttr	bool niteliği

İşlenenler:

İşlenen	Tanım
a	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki sıralı tensör

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64 bit float veya 32/64 bit float eleman değerlerine sahip karmaşık tipteki sıralı tensör

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:

İşlenen	Tanım
min	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler
max	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

Bağlanmak	MLIR Tipi	Tanım
replica_groups	::mlir::YoğunIntElementsAttr	64 bitlik işaretsiz tamsayı öğeleri niteliği
channel_handle	::mlir::mhlo::KanalTanıtıcısıAttr	iki 64 bit tam sayı 'handle' ve 'type'

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

Bağlanmak	MLIR Tipi	Tanım
source_target_pairs	::mlir::YoğunIntElementsAttr	64 bitlik işaretsiz tamsayı öğeleri niteliği
channel_handle	::mlir::mhlo::KanalTanıtıcısıAttr	iki 64 bit tam sayı 'handle' ve 'type'

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

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:

Bağlanmak	MLIR Tipi	Tanım
comparison_direction	::mlir::mhlo::ComparisonDirectionAttr	Hangi karşılaştırma işleminin yapılacağı.
compare_type	::mlir::mhlo::ComparisonTypeAttr	Hangi karşılaştırma türünü kullanacağız?

İşlenenler:

İşlenen	Tanım
lhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler
rhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları olan karmaşık tipteki sıralı tensör veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler

Sonuçlar:

Sonuç	Tanım
«isimsiz»	bool değerlerinin sıralı tensörü

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:

İşlenen	Tanım
lhs	32/64 bitlik kayan nokta değerlerinin sıralı tensörü
rhs	32/64 bitlik kayan nokta değerlerinin sıralı tensörü

Sonuçlar:

Sonuç	Tanım
result	32/64 bit kayan nokta eleman değerlerine sahip karmaşık türde sıralı tensör

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.

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

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
name	::mlir::StringAttr	dize özelliği
composite_attributes	::mlir::SözlükAttr	adlandırılmış nitelik değerleri sözlüğü
decomposition	::mlir::FlatSymbolRefAttr	düz sembol referans özelliği
version	::mlir::TamsayıAttr	32 bit işaretsiz tam sayı özelliği

İşlenenler:

İşlenen

Tanım

inputs

4/6/8/16/32/64-bit kayan nokta veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit kayan öğeli karmaşık tipte sıralanmış tensör değişkenleri veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler veya sıralanmış tensörlerin herhangi bir kombinasyonu ile belirteç veya yuvalanmış demet 4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş değerleri veya 4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya karmaşık memref'i olan karmaşık tip 32/64-bit kayan öğelerle veya tensör başına tamsayı nicemlenmiş değerlerle yazın veya eksen başına tamsayı nicemlenmiş değerlerin veya belirteç değerlerinin sıralanmış tensörü

Sonuçlar:

Sonuç

Tanım

«isimsiz»

4/6/8/16/32/64-bit kayan nokta veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit kayan öğeli karmaşık tipte sıralanmış tensör değişkenleri veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerler veya sıralanmış tensörlerin herhangi bir kombinasyonu ile belirteç veya yuvalanmış demet 4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş değerleri veya 4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya karmaşık memref'i olan karmaşık tip 32/64-bit kayan öğelerle veya tensör başına tamsayı nicemlenmiş değerlerle yazın veya eksen başına tamsayı nicemlenmiş değerlerin veya belirteç değerlerinin sıralanmış tensörü

mhlo.concatenate (mhlo::ConcatenateOp)

İşlemi birleştirme

Değişken sayıdaki tensörleri dimension boyutu boyunca inputs verilen bağımsız değişkenlerle aynı sırada birleştirir ve bir result tensörü üretir.

Bakınız: 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>

Nitelikler: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
dimension	::mlir::TamsayıAttr	Değeri negatif olmayan 64 bitlik işaretsiz tamsayı özelliği

İşlenenler:

İşlenen	Tanım
val	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensörün değişkenliği

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

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>

Nitelikler: AlwaysSpeculatableImplTrait , ConstantLike

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
value	::mlir::ElementsAttr	sabit vektör/tensör özelliği

Sonuçlar:

Sonuç	Tanım
output	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte statik şekilli tensör

mhlo.convert (mhlo::ConvertOp)

Dönüştürme işlemi

Sözdizimi:

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

operand tensörde bir öğe türünden diğerine öğe 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#convert

Örnek:

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

Özellikler: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Efektler: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

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)

lhs pencereleri ile rhs dilimleri arasındaki nokta çarpımları hesaplar ve result üretir.

Bakınız: 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>

Nitelikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
window_strides	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
padding	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
lhs_dilation	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
rhs_dilation	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
window_reversal	::mlir::DenseElementsAttr	sabit boole vektörü/tensör özelliği
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Dönüşüm için boyut bilgilerinin yapısı
feature_group_count	::mlir::TamsayıAttr	Değeri pozitif olan 64 bitlik işaretsiz tamsayı özelliği
batch_group_count	::mlir::TamsayıAttr	Değeri pozitif olan 64 bitlik işaretsiz tamsayı özelliği
precision_config	::mlir::ArrayAttr	Hassas Yapılandırma özelliği

İşlenenler:

İşlenen	Tanım
lhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
rhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.copy (mhlo::CopyOp)

Kopyalama işlemi

Sözdizimi:

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

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

Gayri resmi olarak, bu işlem operand bir kopyasıdır. Operasyona eklenen meta verilere bağlı olarak, operasyon yapılmayan bir operasyondan oldukça farklı davranabilir.

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
cross_program_prefetch_index	::mlir::TamsayıAttr	32 bit işaretsiz tam sayı özelliği

İşlenenler:

İşlenen

Tanım

operand

4/6/8/16/32/64-bit kayan nokta veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit kayan öğeli karmaşık tipte sıralanmış tensör veya tensör başına tamsayı nicelenmiş veya eksen başına tam sayı nicelenmiş değerler veya 4/6/8/16/32/64-bit sıralanmış tensörün herhangi bir kombinasyonu ile belirteç veya yuvalanmış demet veya bool veya 2/4/8/16/32/64-bit tam sayı veya 32/64-bit kayan öğeli karmaşık tür veya tensör başına tamsayı nicelenmiş değerler veya 4/6/8/16/32/64-bit kayan nokta veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64 bit kayan öğeli veya tensör başına karmaşık tür tamsayı nicemlenmiş değerler veya sıralanmış tensör eksen başına tamsayı nicelenmiş değerlerin veya belirteç değerlerinin

Sonuçlar:

Sonuç

Tanım

result

4/6/8/16/32/64-bit kayan nokta veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit kayan öğeli karmaşık tipte sıralanmış tensör veya tensör başına tamsayı nicelenmiş veya eksen başına tam sayı nicelenmiş değerler veya 4/6/8/16/32/64-bit sıralanmış tensörün herhangi bir kombinasyonu ile belirteç veya yuvalanmış demet veya bool veya 2/4/8/16/32/64-bit tam sayı veya 32/64-bit kayan öğeli karmaşık tür veya tensör başına tamsayı nicelenmiş değerler veya 4/6/8/16/32/64-bit kayan nokta veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64 bit kayan öğeli veya tensör başına karmaşık tür tamsayı nicemlenmiş değerler veya sıralanmış tensör eksen başına tamsayı nicelenmiş değerlerin veya belirteç değerlerinin

mhlo.cosh (mhlo::CoshOp)

Cosh operasyonu

Sözdizimi:

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

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

Örnek:

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

Özellikler: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Arayüzler: InferShapedTypeOpInterface , InferTypeOpInterface

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya 32/64-bit float eleman değerlerine sahip karmaşık tipte tensör

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya 32/64-bit float eleman değerlerine sahip karmaşık tipte tensör

mhlo.cosine (mhlo::CosineOp)

Kosinüs işlemi

Sözdizimi:

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

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

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

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	Tekli işlemler için istenen doğruluk.

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit kayan noktalı veya 32/64 bit kayan öğeli veya tensör başına tamsayı nicemlenmiş değerlere sahip karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit kayan noktalı veya 32/64 bit kayan öğeli veya tensör başına tamsayı nicemlenmiş değerlere sahip karmaşık tipte sıralanmış tensör

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz işlemi

Sözdizimi:

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

operand tensördeki baştaki sıfır bitlerin sayısını öğe bazında sayar ve bir result tensörü üretir.

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

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efektler: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	2/4/8/16/32/64 bit tamsayı değerlerinin sıralanmış tensörü

Sonuçlar:

Sonuç	Tanım
result	2/4/8/16/32/64 bit tamsayı değerlerinin sıralanmış tensörü

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken işlemi

Sözdizimi:

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

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, 0 girişli AfterAllOp ile aynı şeyi yapar: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Örnek:

%output = mhlo.create_token : !mhlo.token

Nitelikler: AlwaysSpeculatableImplTrait

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

Efektler: MemoryEffects::Effect{}

Sonuçlar:

Sonuç	Tanım
output	jeton

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

CrossReplicaSum işlemi

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, channel_id = 0 , use_global_device_ids = false ve computation uygulamalı ekleme ile AllReduceOp ile aynı şeyi yapar: 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>

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
replica_groups	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.custom_call (mhlo::CustomCallOp)

Özel Çağrı işlemi

Sözdizimi:

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

inputs ve called_computations alan ve results üreten, uygulama tanımlı call_target_name işlemini kapsüller.

Bakınız: 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.

Arayüzler: MemoryEffectOpInterface

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
call_target_name	::mlir::StringAttr	dize özelliği
has_side_effect	::mlir::BoolAttr	bool özelliği
backend_config	::mlir::Özellik	dize niteliği veya adlandırılmış nitelik değerleri sözlüğü
api_version	::mlir::mhlo::CustomCallApiVersionAttr	Özel çağrı API sürümü
called_computations	::mlir::ArrayAttr	düz sembol başvuru dizisi özelliği
custom_call_schedule	::mlir::mhlo::CustomCallCallScheduleAttr	Özel çağrı için istenen programı belirtir.
operand_layouts	::mlir::ArrayAttr	Düzen dizisi (indeks türünün 1 boyutlu tensörü) nitelikleri
result_layouts	::mlir::ArrayAttr	Düzen dizisi (indeks türünün 1 boyutlu tensörü) nitelikleri
output_operand_aliases	::mlir::ArrayAttr	CustomCall'ın çıktıları ve işlenenleri için takma ad özelliği

İşlenenler:

İşlenen

Tanım

inputs

4/6/8/16/32/64-bit float veya bool tensör değişkeni veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri veya 4/6/8/16/32/64-bit float veya bool memref'i olan karmaşık tip veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit kayan öğeli karmaşık tür veya tensör başına tamsayı nicelenmiş değerler veya 4/6/8/16/32/64-bit kayan nokta veya bool tensörün herhangi bir kombinasyonu ile belirteç veya iç içe geçmiş tuple veya 2/4/8/16/32/64-bit tam sayı veya 32/64 bit kayan öğeli karmaşık tür veya tensör başına tamsayı nicemlenmiş veya eksen başına tam sayı nicelenmiş değerleri veya 4/6/8/16/32/64 bit kayan nokta veya bool memref'i veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit kayan öğeli karmaşık tip veya tensör başına tam sayı nicelenmiş değerler veya simge değerleri

Sonuçlar:

Sonuç

Tanım

«isimsiz»

4/6/8/16/32/64-bit float veya bool tensör değişkeni veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri veya 4/6/8/16/32/64-bit float veya bool memref'i olan karmaşık tip veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit kayan öğeli karmaşık tür veya tensör başına tamsayı nicelenmiş değerler veya 4/6/8/16/32/64-bit kayan nokta veya bool tensörün herhangi bir kombinasyonu ile belirteç veya iç içe geçmiş tuple veya 2/4/8/16/32/64-bit tam sayı veya 32/64 bit kayan öğeli karmaşık tür veya tensör başına tamsayı nicemlenmiş veya eksen başına tam sayı nicelenmiş değerleri veya 4/6/8/16/32/64 bit kayan nokta veya bool memref'i veya 2/4/8/16/32/64 bit tam sayı veya 32/64 bit kayan öğeli karmaşık tip veya tensör başına tam sayı nicelenmiş değerler veya simge değerleri

mhlo.divide (mhlo::DivOp)

Bölme işlemi

Sözdizimi:

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

Bölen lhs ve bölen rhs tensörlerinin eleman bazında bölünmesini gerçekleştirir ve bir result tensörü üretir.

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

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efektler: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	2/4/8/16/32/64-bit tam sayı veya 4/6/8/16/32/64-bit kayan noktalı veya 32/64 bit kayan öğeli veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerlere sahip karmaşık tipte sıralanmış tensör
rhs	2/4/8/16/32/64-bit tam sayı veya 4/6/8/16/32/64-bit kayan noktalı veya 32/64 bit kayan öğeli veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerlere sahip karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
result	2/4/8/16/32/64-bit tam sayı veya 4/6/8/16/32/64-bit kayan noktalı veya 32/64 bit kayan öğeli veya tensör başına tam sayı nicemlenmiş veya eksen başına tam sayı nicemlenmiş değerlere sahip karmaşık tipte sıralanmış tensör

mhlo.domain (mhlo::DomainOp)

Etki alanı işlemi

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

Gayri resmi olarak bu işlemler, talimatları aynı DomainMetadata özelliğine sahip gruplamak için kullanılır. ShardingMetadata, talimatları aynı cihazda gruplamak için günümüzde ana kullanım durumudur. Alan adı talimatları iki önemli fayda sağlar:

• Etki alanları arasında talimatların yanlışlıkla optimize edilmesini önleyin.
• Etki alanında oluşturulan talimatların meta verilerini otomatik olarak atayın. Etki alanı talimatları olmadan, her HLO optimizasyon geçişinin meta verileri kontrol etmesi ve yayması gerekir; bu da gözden kaçırılması kolay olur ve aynı zamanda derleyiciye karmaşıklık katar. Etki alanı talimatları iki farklı etki alanını bağladığından, her etki alanı talimatı, biri etki alanının işlenen tarafında ve diğeri kullanıcı tarafında olmak üzere iki Etki AlanıMeta Verisi ile ilişkilendirilir.

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
kind	::mlir::mhlo::DomainKindAttr	Bir HLO alanına eklenen bir tür alan meta verisi.
entry_metadata	::mlir::StringAttr	dize özelliği
exit_metadata	::mlir::StringAttr	dize özelliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool sıralanmış tensörü veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit kayan öğeli karmaşık tip veya tensör başına tamsayı nicemlenmiş değerler veya eksen başına tamsayı nicemlenmiş değerlerin veya belirtecin sıralanmış tensörü

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool sıralanmış tensörü veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit kayan öğeli karmaşık tip veya tensör başına tamsayı nicemlenmiş değerler veya eksen başına tamsayı nicemlenmiş değerlerin veya belirtecin sıralanmış tensörü

mhlo.dot (mhlo::DotOp)

Nokta işlemi

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 Noktası ile aynı şeyi yapar: https://www.tensorflow.org/xla/operation_semantics#dot

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
precision_config	::mlir::ArrayAttr	Hassas Yapılandırma özelliği

İşlenenler:

İşlenen	Tanım
lhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
rhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.dot_general (mhlo::DotGeneralOp)

NoktaGenel operasyon

lhs dilimleri ile rhs dilimleri arasındaki nokta çarpımları hesaplar ve bir result tensörü üretir.

Bakınız: 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>

Nitelikler: AlwaysSpeculatableImplTrait

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	Nokta için boyut bilgisini modelleyen öznitelik.
precision_config	::mlir::ArrayAttr	Hassas Yapılandırma özelliği
algorithm	::mlir::mhlo::DotAlgorithmAttr	Nokta hesaplamak için kullanılacak algoritma kısıtlamalarını modelleyen öznitelik.

İşlenenler:

İşlenen	Tanım
lhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
rhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim işlemi

Bu işlem işlevsel olarak yayın_in_dim işlemiyle aynıdır, ancak sonuç şekli output_dimensions aracılığıyla dinamik olarak belirtilir.

Ayrıca boyutların genişleme davranışı hakkındaki statik bilgiyi ifade etmek için isteğe bağlı öznitelikleri de kabul eder. Belirtilmediği takdirde tüm boyutların genişleyebileceği varsayılır. Genişlediği bilinen boyut kümeleri ve genişlemediği bilinen boyut kümeleri ayrık olmalı ve işlenenin boyutlarının bir alt kümesi olmalıdır.

Bakınız: 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>

Nitelikler: AlwaysSpeculatableImplTrait

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
broadcast_dimensions	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
known_expanding_dimensions	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
output_dimensions	1 boyutlu indeks tensörü veya 2/4/8/16/32/64 bit tamsayı değerleri

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv işlemi

Bu işlem devam eden bir çalışma olduğundan henüz spesifikasyona dahil edilmemiştir: https://github.com/openxla/stablehlo/issues/8

Gayri resmi olarak bu işlem, padding d_padding aracılığıyla dinamik olarak belirtilmesi dışında ConvolutionOp ile aynı şeyi yapar: 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>

Nitelikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
window_strides	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
padding	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
lhs_dilation	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
rhs_dilation	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği
window_reversal	::mlir::DenseElementsAttr	sabit boole vektörü/tensör özelliği
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Dönüşüm için boyut bilgilerinin yapısı
feature_group_count	::mlir::TamsayıAttr	Değeri pozitif olan 64 bitlik işaretsiz tamsayı özelliği
batch_group_count	::mlir::TamsayıAttr	Değeri pozitif olan 64 bitlik işaretsiz tamsayı özelliği
precision_config	::mlir::ArrayAttr	Hassas Yapılandırma özelliği

İşlenenler:

İşlenen	Tanım
lhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
rhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
d_padding	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather işlemi

Bu işlem devam eden bir çalışma olduğundan henüz spesifikasyona dahil edilmemiştir: https://github.com/openxla/stablehlo/issues/8

Gayri resmi olarak bu işlem, slice_sizes dinamik olarak belirtilmesi dışında GatherOp ile aynı şeyi yapar: 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>

Nitelikler: AlwaysSpeculatableImplTrait , InferTensorType

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Toplama için boyut bilgilerini modelleyen öznitelik
indices_are_sorted	::mlir::BoolAttr	bool özelliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
start_indices	2/4/8/16/32/64 bit tamsayı değerlerinin sıralanmış tensörü
slice_sizes	2/4/8/16/32/64 bit tamsayı değerlerinin statik olarak şekillendirilmiş 1 boyutlu tamsayı tensörü

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DinamikIota işlemi

Bu işlem işlevsel olarak iota op ile aynıdır, ancak sonuç şekli output_shape aracılığıyla dinamik olarak belirtilir.

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

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
iota_dimension	::mlir::TamsayıAttr	Değeri negatif olmayan 64 bitlik işaretsiz tamsayı özelliği

İşlenenler:

İşlenen	Tanım
output_shape	1 boyutlu indeks tensörü veya 2/4/8/16/32/64 bit tamsayı değerleri

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad işlemi

Sözdizimi:

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

operand Dinamik Olarak Doldurur, alt uç/üst uç/iç kısımda eklenen dolgu miktarı giriş tensörlerinden geçirilir.

Nitelikler: AlwaysSpeculatableImplTrait

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

Efektler: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
padding_value	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
edge_padding_low	1 boyutlu indeks tensörü veya 2/4/8/16/32/64 bit tamsayı değerleri
edge_padding_high	1 boyutlu indeks tensörü veya 2/4/8/16/32/64 bit tamsayı değerleri
interior_padding	1 boyutlu indeks tensörü veya 2/4/8/16/32/64 bit tamsayı değerleri

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DinamikYeniden Şekillendirme işlemi

Sözdizimi:

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

Bu işlem işlevsel olarak yeniden şekillendirme işlemiyle aynıdır, ancak sonucun şekli output_shape aracılığıyla dinamik olarak belirtilir.

Bakınız: 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>

Nitelikler: AlwaysSpeculatableImplTrait

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

Efektler: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool tensörü veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tip
output_shape	1 boyutlu indeks tensörü veya 2/4/8/16/32/64 bit tamsayı değerleri

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool tensörü veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tip

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice işlemi

Dinamik olarak hesaplanan başlangıç ​​indekslerini kullanarak operand bir dilim çıkarır ve bir result tensörü üretir.

Bakınız: 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>

Nitelikler: AlwaysSpeculatableImplTrait , InferTensorType

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
slice_sizes	::mlir::DenseIntElementsAttr	64 bit işaretsiz tam sayı öğeleri özelliği

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
start_indices	2/4/8/16/32/64 bit tam sayı değerlerinin 0D tensörünün değişkenliği

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice işlemi

Sözdizimi:

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

start_indices başlayan dilimin update içindeki değerlerle güncellenmesi dışında operand tensörüne eşit olan bir result tensörü üretir.

Bakınız: 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>

Nitelikler: AlwaysSpeculatableImplTrait , InferTensorType

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

Efektler: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
update	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
start_indices	2/4/8/16/32/64 bit tam sayı değerlerinin 0D tensörünün değişkenliği

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.einsum (mhlo::EinsumOp)

Einsum işlemi

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, TF'nin einsum'uyla aynı şeyi yapar: 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>

Nitelikler: AlwaysSpeculatableImplTrait

Arayüzler: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
einsum_config	::mlir::StringAttr	dize özelliği

İşlenenler:

İşlenen	Tanım
lhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör
rhs	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
«isimsiz»	4/6/8/16/32/64-bit float veya bool veya 2/4/8/16/32/64-bit tamsayı veya 32/64-bit float elemanları veya tensör başına tamsayı nicemlenmiş veya eksen başına tamsayı nicemlenmiş değerleri olan karmaşık tipte sıralanmış tensör

mhlo.erf (mhlo::ErfOp)

Erf operasyonu

Sözdizimi:

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

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

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efektler: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit kayan değer değerlerinin sıralanmış tensörü

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit kayan değer değerlerinin sıralanmış tensörü

mhlo.exponential (mhlo::ExpOp)

Exp işlemi

Sözdizimi:

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

operand tensörü üzerinde öğe bazında üstel işlem gerçekleştirir ve bir result tensörü üretir.

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

Örnek:

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

Nitelikler: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efektler: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Türü	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	Tekli işlemler için istenen doğruluk.

İşlenenler:

İşlenen	Tanım
operand	4/6/8/16/32/64-bit kayan noktalı veya 32/64 bit kayan öğeli veya tensör başına tamsayı nicemlenmiş değerlere sahip karmaşık tipte sıralanmış tensör

Sonuçlar:

Sonuç	Tanım
result	4/6/8/16/32/64-bit kayan noktalı veya 32/64 bit kayan öğeli veya tensör başına tamsayı nicemlenmiş değerlere sahip karmaşık tipte sıralanmış tensör

mhlo.exponential_minus_one (mhlo::Expm1Op)

Deney1 işlemi

Sözdizimi:

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

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

Bakınız: 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{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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

Nitelikler:

Bağlanmak	MLIR Type	Tanım
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

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:

Bağlanmak	MLIR Type	Tanım
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

İşlenenler:

İşlenen	Tanım
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

Sonuçlar:

Sonuç

Tanım

results

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

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

Nitelikler:

Bağlanmak	MLIR Type	Tanım
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
slice_sizes	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
indices_are_sorted	::mlir::BoolAttr	bool attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	ranked tensor of 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

Nitelikler:

Bağlanmak	MLIR Type	Tanım
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	tensor of 32-bit signless integer values

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

Nitelikler:

Bağlanmak	MLIR Type	Tanım
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

İşlenenler:

İşlenen

Tanım

operand

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

Sonuçlar:

Sonuç

Tanım

«unnamed»

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

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

İşlenenler:

İşlenen	Tanım
pred	ranked tensor of bool values

Sonuçlar:

Sonuç	Tanım
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

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

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float values

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)

Nitelikler:

Bağlanmak	MLIR Type	Tanım
infeed_config	::mlir::StringAttr	string attribute
layout	::mlir::ArrayAttr	array attribute

İşlenenler:

İşlenen	Tanım
token	jeton

Sonuçlar:

Sonuç

Tanım

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

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

Nitelikler:

Bağlanmak	MLIR Type	Tanım
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Sonuçlar:

Sonuç	Tanım
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

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

İşlenenler:

İşlenen	Tanım
x	ranked tensor of 4/6/8/16/32/64-bit float values

Sonuçlar:

Sonuç	Tanım
y	ranked tensor of bool values

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

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.log_plus_one (mhlo::Log1pOp)

Log1p operation

Sözdizimi:

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

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

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

Örnek:

%result = mhlo.log_plus_one %operand : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.logistic (mhlo::LogisticOp)

Logistic operation

Sözdizimi:

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

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

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.map (mhlo::MapOp)

Map operation

Applies a map function computation to inputs along the dimensions and produces a result tensor.

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

Örnek:

%result = "mhlo.map"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.multiply %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  dimensions = dense<[0, 1]> : tensor<2xi64>
} : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.maximum (mhlo::MaxOp)

Max operation

Sözdizimi:

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

Performs element-wise max operation on tensors lhs and rhs and produces a result tensor.

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum (mhlo::MinOp)

Min operation

Sözdizimi:

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

Performs element-wise min operation on tensors lhs and rhs and produces a result tensor.

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum_broadcast_shapes (mhlo::MinimumBroadcastShapesOp)

Minimizes the rank of two or more shapes to be broadcasted

Sözdizimi:

operation ::= `mhlo.minimum_broadcast_shapes` $shapes attr-dict `:` type($shapes) `->` type($results)

Given two or more 1D tensors representing shapes, returns one 1D tensor for each operand, where operand i corresponds to output i .

The returned tensors have the property that they specify a shape which is a reshape of the corresponding input shape, and the broadcasted output shape (using shape::BroadcastOp) of the returned shapes is a reshape of the broadcasted output shape of the input shapes. Among all possibilities with this property, the one is chosen which minimizes the rank of each returned shape.

The general idea of this op is that it can be used for ops which have a broadcasting semantic to operate on shapes with a possibly smaller rank while preserving equivalence of the computed values. After computing the result of the op using reshaped operands, the result can be reshaped to the result that would have been originally computed.

Here is an example with two input shapes:

mhlo.minimum_broadcast_shapes [1, 2, 3, 1, 2, 1],
                                 [1, 1, 1, 2, 3] -> [6, 2, 1], [2, 3]

The broadcasted output shape of the operands is [1, 2, 3, 1, 2, 3], the broadcasted output shape of the outputs is [6, 2, 3]. These two shapes are reshapes of each other, and also each output is a reshape of the corresponding input.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
shapes	variadic of 1D tensor of index values

Sonuçlar:

Sonuç	Tanım
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

Sözdizimi:

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

Performs element-wise product of two tensors lhs and rhs and produces a result tensor.

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

Örnek:

%result = mhlo.multiply %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.negate (mhlo::NegOp)

Neg operation

Sözdizimi:

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

Performs element-wise negation of operand tensor and produces a result tensor.

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

Örnek:

%result = mhlo.negate %operand : tensor<2x3xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.not (mhlo::NotOp)

Not operation

Sözdizimi:

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

Performs element-wise NOT of tensor operand of type integer and produces a result tensor.

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

Örnek:

%result = mhlo.not %operand : tensor<5x3x1xi1>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

Sözdizimi:

operation ::= `mhlo.optimization_barrier` attr-dict ($operand^ `:` custom<PairwiseOpType>(type($operand), type($result))):(`(` `)`)?

Ensures that the operations that produce the operand are executed before any operations that depend on the result and prevents compiler transformations from moving operations across the barrier. Other than that, the operation is an identity, ie result = operand .

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

Örnek:

%result0, %result1 = mhlo.optimization_barrier %operand0, %operand1 : tensor<f32>, tensor<f32>

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

Sonuçlar:

Sonuç	Tanım
result	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.or (mhlo::OrOp)

Or operation

Sözdizimi:

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

Performs element-wise OR of two tensors lhs and rhs and produces a result tensor.

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

Örnek:

%result = mhlo.or %lhs, %rhs : tensor<2xi1>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.outfeed (mhlo::OutfeedOp)

Outfeed operation

Writes inputs to the outfeed and produces a result token.

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

Örnek:

%result = "mhlo.outfeed"(%input0, %token) {
  outfeed_config = ""
} : (tensor<3x3x3xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
outfeed_config	::mlir::StringAttr	string attribute

İşlenenler:

İşlenen	Tanım
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	jeton

Sonuçlar:

Sonuç	Tanım
«unnamed»	jeton

mhlo.pad (mhlo::PadOp)

Pad operation

Expands operand by padding around the tensor as well as between the elements of the tensor with the given padding_value .

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

Örnek:

%0 = mhlo.pad %arg0, %arg1, low = [0, 1], high = [2, 1], interior = [1, 2]
  : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
edge_padding_low	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
edge_padding_high	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
interior_padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
padding_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.partition_id (mhlo::PartitionIdOp)

PartitionId operation

Sözdizimi:

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

Produces partition_id of the current process.

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

Örnek:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

Sözdizimi:

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

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

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

Örnek:

%result = mhlo.popcnt %operand : tensor<4xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

Sözdizimi:

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

Performs element-wise exponentiation of lhs tensor by rhs tensor and produces a result tensor.

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

Örnek:

%result = mhlo.power %lhs, %rhs : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.ragged_dot (mhlo::RaggedDotOp)

Ragged matrix multiplication over a single ragged dimension

This operation takes three tensor args---lhs, rhs, and group_sizes---and a "ragged_dot_dimension_numbers" attribute. Like dot_general, the lhs and rhs are allowed arbitrary batch and contracting dimensions. Additionally, the lhs is required to have one ragged dimension, and the rhs may have at most one group dimension. The op has three modes, depending on the kind of the lhs ragged dimension.

In mode 1, the shape-signature is [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] . Here the ragged dimension is an lhs non-contracting dimension ( m ). The dimensions b and k represent batch and contracting dimensions respectively. The rhs is required to have a group dimension ( g ).

In mode 2, the shape-signature is [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] . Here the ragged dimension is an lhs/rhs contracting dimension ( k ).

In mode 3, the shape-signature is [b,m,k], [b,k,n], [g] -> [b,m,n] . Here the ragged dimension is an lhs/rhs batch dimension ( b ).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
ragged_dot_dimension_numbers	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
group_sizes	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.real (mhlo::RealOp)

Gerçek operasyon

Sözdizimi:

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

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

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

Sözdizimi:

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

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 SliceOp except that start_indices , limit_indices and strides are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

Örnek:

%result = mhlo.real_dynamic_slice %operand,
            %start_indices, %limit_indices, %strides
       : (tensor<256x?xf32>, tensor<2xindex>, tensor<2xindex>, tensor<2xindex>) -> tensor<256x?xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
limit_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
strides	1D tensor of index or 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.recv (mhlo::RecvOp)

Recv operation

Receives data from a channel with channel_id and produces results .

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

Örnek:

%results:2 = "mhlo.recv"(%token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (!mhlo.token) -> (tensor<3x4xi32>, !mhlo.token)

Nitelikler:

Bağlanmak	MLIR Type	Tanım
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
token	jeton

Sonuçlar:

Sonuç

Tanım

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

mhlo.reduce (mhlo::ReduceOp)

Reduce operation

Applies a reduction function body to inputs and init_values along the dimensions and produces a result tensor.

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

Örnek:

%result = "mhlo.reduce"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  dimensions = dense<1> : tensor<1xi64>
} : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_precision (mhlo::ReducePrecisionOp)

ReducePrecision operation

Sözdizimi:

operation ::= `mhlo.reduce_precision` $operand `,` `format` `=` custom<ExponentMantissa>($exponent_bits, $mantissa_bits)
              attr-dict `:` custom<SameOperandsAndResultType>(type($operand), type($output))

Performs element-wise conversion of operand to another floating-point type that uses exponent_bits and mantissa_bits and back to the original floating-point type and produces an output tensor.

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

Örnek:

%output = mhlo.reduce_precision %operand, format = e5m2 : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
exponent_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is positive
mantissa_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Sonuçlar:

Sonuç	Tanım
output	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.reduce_scatter (mhlo::ReduceScatterOp)

ReduceScatter operation

Within each process group in the process grid, performs reduction, using computations , over the values of the operand tensor from each process, splits the reduction result along scatter_dimension into parts, and scatters the split parts between the processes to produce the result .

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

Örnek:

%result = "mhlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
  %0 = mhlo.add %arg0, %arg1 : tensor<f32>
  mhlo.return %0 : tensor<f32>
}) {
  scatter_dimension = 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<2x4xf32>) -> tensor<2x2xf32>

Nitelikler:

Bağlanmak	MLIR Type	Tanım
scatter_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
replica_groups	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
use_global_device_ids	::mlir::UnitAttr	unit attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_window (mhlo::ReduceWindowOp)

ReduceWindow operation

Applies a reduction function body to windows of inputs and init_values and produces results .

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

Örnek:

%result = "mhlo.reduce_window"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  window_dimensions = dense<[2, 1]> : tensor<2xi64>,
  window_strides = dense<[4, 1]> : tensor<2xi64>,
  base_dilations = dense<[2, 1]> : tensor<2xi64>,
  window_dilations = dense<[3, 1]> : tensor<2xi64>,
  padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi32>, tensor<i32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
base_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.remainder (mhlo::RemOp)

Rem operation

Sözdizimi:

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

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

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

Örnek:

%result = mhlo.remainder %lhs, %rhs : tensor<4xi64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.replica_id (mhlo::ReplicaIdOp)

ReplicaId operation

Sözdizimi:

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

Produces replica_id of the current process.

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

Örnek:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

Sözdizimi:

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

Performs reshape of operand tensor to a result tensor.

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

Örnek:

%result = mhlo.reshape %operand : (tensor<2xf32>) -> tensor<1x2xf32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	statically shaped or single bounded dimension tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.return (mhlo::ReturnOp)

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

Informally, this operation serves as a terminator for regions defined by
the StableHLO ops. Non-StableHLO ops, e.g. `func.func`, have their own
terminators, e.g. `func.return`.

Example:

    ```mlir
    %result = "mhlo.reduce"(%input, %init_value) ({
      ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
        %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
        "mhlo.return"(%0) : (tensor<i32>) -> ()
    }) {
      dimensions = dense<1> : tensor<1xi64>
    } : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>
    ```_

Syntax:

```

operation ::= mhlo.return $results attr-dict ( : type($results)^)?

Traits: `AlwaysSpeculatableImplTrait`, `Terminator`

Interfaces: `ConditionallySpeculatable`, `NoMemoryEffect (MemoryEffectOpInterface)`

Effects: `MemoryEffects::Effect{}`

#### Operands:

| Operand | Description |
| :-----: | ----------- |
| `results` | variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values |



### `mhlo.reverse` (mhlo::ReverseOp)

_Reverse operation_

Reverses the order of elements in the `operand` along the specified
`dimensions` and produces a `result` tensor.

See:
<a href="https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse">https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse</a>

Example:
```mlir
%result = mhlo.reverse %operand, dims = [1] : tensor<3x2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.rng (mhlo::RngOp)

Rng operation

Generates random numbers using the rng_distribution algorithm and produces a result tensor of a given shape shape .

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

Örnek:

%result = mhlo.rng %a, %b, %shape, distribution = NORMAL : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

İşlenenler:

İşlenen	Tanım
a	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
b	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.rng_bit_generator (mhlo::RngBitGeneratorOp)

RngBitGenerator operation

Returns an output filled with uniform random data and an updated output state output_state given an initial state initial_state using the pseudorandom number generator algorithm rng_algorithm .

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

Örnek:

%output_state, %output = mhlo.rng_bit_generator %initial_state, algorithm = THREE_FRY : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

İşlenenler:

İşlenen	Tanım
initial_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

Sonuçlar:

Sonuç	Tanım
output_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.round_nearest_afz (mhlo::RoundOp)

Round operation

Sözdizimi:

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

Performs element-wise rounding towards the nearest integer, breaking ties away from zero, on the operand tensor and produces a result tensor.

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

Sözdizimi:

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

Performs element-wise rounding towards the nearest integer, breaking ties towards the even integer, on the operand tensor and produces a result tensor.

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

Sözdizimi:

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

Performs element-wise reciprocal square root operation on operand tensor and produces a result tensor, implementing the rSqrt operation from the IEEE-754 specification.

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.scatter (mhlo::ScatterOp)

Scatter operation

Produces results tensors which are equal to inputs tensors except that several slices specified by scatter_indices are updated with the values updates using update_computation .

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

Örnek:

%result = "mhlo.scatter"(%input, %scatter_indices, %update) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  scatter_dimension_numbers = #mhlo.scatter<
    update_window_dims = [3, 4],
    inserted_window_dims = [1],
    input_batching_dims = [0],
    scatter_indices_batching_dims = [1],
    scatter_dims_to_operand_dims = [2, 1],
    index_vector_dim = 3>,
  indices_are_sorted = false,
  unique_indices = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>, tensor<2x2x3x2x2xi64>) -> tensor<2x3x4x2xi64>

Traits: RecursiveMemoryEffects , SameVariadicOperandSize

Interfaces: InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
scatter_dimension_numbers	::mlir::mhlo::ScatterDimensionNumbersAttr	Attribute that models the dimension information for scatter
indices_are_sorted	::mlir::BoolAttr	bool attribute
unique_indices	::mlir::BoolAttr	bool attribute

İşlenenler:

İşlenen	Tanım
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
scatter_indices	ranked tensor of integer or index values
updates	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select (mhlo::SelectOp)

İşlemi seçin

Sözdizimi:

operation ::= `mhlo.select` operands attr-dict `:`
              custom<SelectOpType>(type($pred), type($on_true), type($on_false), type($result))

Produces a result tensor where each element is selected from on_true or on_false tensor based on the value of the corresponding element of pred .

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

Örnek:

%result = mhlo.select %pred, %on_true, %on_false : tensor<2x2xi1>, tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
pred	ranked tensor of bool values
on_true	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
on_false	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select_and_scatter (mhlo::SelectAndScatterOp)

SelectAndScatter operation

Scatters the values from the source tensor using scatter based on the outcome of reduce_window of the input tensor using select and produces a result tensor.

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

Örnek:

%result = "mhlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

Traits: RecursiveMemoryEffects

Interfaces: InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
source	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.send (mhlo::SendOp)

Send operation

Sends inputs to a channel channel_id and produces a result token.

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

Örnek:

%result = "mhlo.send"(%operand, %token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (tensor<3x4xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	jeton

Sonuçlar:

Sonuç	Tanım
«unnamed»	jeton

mhlo.set_dimension_size (mhlo::SetDimensionSizeOp)

SetDimensionSize 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 XLA's SetDimensionSize: https://www.tensorflow.org/xla/operation_semantics#setdimensionsize

Örnek:

%0 = mhlo.set_dimension_size %arg0, %arg1, dim = 1 : (tensor<4x2xf32>, tensor<i32>) -> tensor<4x2xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
size	tensor of 32-bit signless integer values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.shift_left (mhlo::ShiftLeftOp)

ShiftLeft operation

Sözdizimi:

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

Performs element-wise left-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Örnek:

%result = mhlo.shift_left %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

Sözdizimi:

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

Performs element-wise arithmetic right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Örnek:

%result = mhlo.shift_right_arithmetic %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

Sözdizimi:

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

Performs element-wise logical right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Örnek:

%result = mhlo.shift_right_logical %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

Sözdizimi:

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

Returns the sign of the operand element-wise and produces a result tensor.

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

Örnek:

%result = mhlo.sign %operand : tensor<7xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sine (mhlo::SineOp)

Sine operation

Sözdizimi:

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

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

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sinh (mhlo::SinhOp)

Sinh operation

Sözdizimi:

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

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

Örnek:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

İşlenenler:

İşlenen	Tanım
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Sonuçlar:

Sonuç	Tanım
result	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.slice (mhlo::SliceOp)

Slice operation

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

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

Örnek:

%result = "mhlo.slice" (%operand) {
  start_indices = dense<[1, 2]> : tensor<2xi64>,
  limit_indices = dense<[3, 4]> : tensor<2xi64>,
  strides = dense<1> : tensor<2xi64>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
start_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
limit_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sort (mhlo::SortOp)

Sort operation

Sorts a variadic number of tensors in inputs together, according to a custom comparator , along the given dimension and produces a variadic number of tensors as results .

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

Örnek:

%result0, %result1 = "mhlo.sort"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>):
    %predicate = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GT>
      } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
  dimension = 0 : i64,
  is_stable = true
} : (tensor<2x3xi32>, tensor<2x3xi32>) -> (tensor<2x3xi32>, tensor<2x3xi32>)

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

İşlenenler:

İşlenen	Tanım
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sqrt (mhlo::SqrtOp)

Sqrt operation

Sözdizimi:

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

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

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.stochastic_convert (mhlo::StochasticConvertOp)

StochasticConvert operation

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

Informally, this operation performs element-wise conversion of values from a bigger type to a smaller one with stochastic rounding using the random number passed in.

Traits: AlwaysSpeculatableImplTrait , Elementwise

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float values
random	ranked tensor of 2/4/8/16/32/64-bit unsigned integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.subtract (mhlo::SubtractOp)

Subtract operation

Sözdizimi:

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

Performs element-wise subtraction of two tensors lhs and rhs and produces a result tensor.

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

Örnek:

%result = mhlo.subtract %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.tan (mhlo::TanOp)

Tan operation

Sözdizimi:

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

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

Informally, this operation returns Tan(operand) element-wise.

Örnek:

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.tanh (mhlo::TanhOp)

Tanh operation

Sözdizimi:

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

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

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

Örnek:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.topk (mhlo::TopKOp)

TopK operation

Sözdizimi:

operation ::= `mhlo.topk` `(`$operand `,` `k` `=` $k (`,` `largest` `=` $largest^)? `)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Returns top k values and their indices, along the last dimension of the operand if largest=true or the bottom k values if largest=false .

See: https://www.tensorflow.org/xla/operation_semantics#top-k

Örnek:

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
values	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
indices	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.torch_index_select (mhlo::TorchIndexSelectOp)

TorchIndexSelect 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 PyTorch's index_select, augmented with support for batch dimensions: https://pytorch.org/docs/stable/generated/torch.index_select.html

The batch_dims attribute specifies the number of major batch dimensions (0 or more) that act like a multidimensional loop over both the operand and the index.

Örnek:

%result = "mhlo.torch_index_select"(%operand, %index) {
  dim = 2 : i64,
  batch_dims = 1 : i64
} : (tensor<8x128x3072x64xf32>, tensor<8x16x1024xi32>) -> tensor<8x128x16x1024x64xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
index	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.trace (mhlo::TraceOp)

Trace operation

Sözdizimi:

operation ::= `mhlo.trace` $operand `,` $tag attr-dict `:` type($operand)

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

It is not used by JAX, PyTorch or TensorFlow, so it looks like we should've classified it as "Private to XLA" and not included it in StableHLO in the first place. With that in mind, its semantics will not be documented here.

Örnek:

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

Nitelikler:

Bağlanmak	MLIR Type	Tanım
tag	::mlir::StringAttr	string attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.transpose (mhlo::TransposeOp)

Transpose operation

Permutes the dimensions of operand tensor using permutation and produces a result tensor.

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

Örnek:

%0 = mhlo.transpose %arg0, dims = [2, 1, 0] : (tensor<1x2x3xi32>) -> tensor<3x2x1xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.triangular_solve (mhlo::TriangularSolveOp)

TriangularSolve operation

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

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

Örnek:

%result = "mhlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Nitelikler:

Bağlanmak	MLIR Type	Tanım
left_side	::mlir::BoolAttr	bool attribute
lower	::mlir::BoolAttr	bool attribute
unit_diagonal	::mlir::BoolAttr	bool attribute
transpose_a	::mlir::mhlo::TransposeAttr	Transpose options

İşlenenler:

İşlenen	Tanım
a	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values
b	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Sonuçlar:

Sonuç	Tanım
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.tuple (mhlo::TupleOp)

Tuple operation

Sözdizimi:

operation ::= `mhlo.tuple` $val attr-dict `:` custom<TupleOpType>(type($val), type($result))

Produces a result tuple from values val .

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

Örnek:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen

Tanım

val

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç

Tanım

result

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

mhlo.uniform_dequantize (mhlo::UniformDequantizeOp)

UniformDequantize operation

Sözdizimi:

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

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

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

Örnek:

%result = mhlo.uniform_dequantize %operand : (tensor<16x16x!quant.uniform<i8:f32, 34.0:16>>) -> tensor<16x16xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

Sözdizimi:

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

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

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

Örnek:

%result = mhlo.uniform_quantize %operand : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
operand	ranked tensor of 4/6/8/16/32/64-bit float or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

mhlo.while (mhlo::WhileOp)

While operation

Produces the output from executing body function 0 or more times while the cond function outputs true .

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

Örnek:

%results0, %results1 = "mhlo.while"(%operand0, %operand1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %constant0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0, %arg1) : (tensor<i32>, tensor<i32>) -> ()
}) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface , OpAsmOpInterface

İşlenenler:

İşlenen

Tanım

operand

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

Sonuçlar:

Sonuç

Tanım

«unnamed»

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.xla.rng_get_and_update_state (mhlo::XlaRngGetAndUpdateStateOp)

XlaRngGetAndUpdateState operation

Sözdizimi:

operation ::= `mhlo.xla.rng_get_and_update_state` attr-dict

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

Informally, this operation represents the change of the global random number generator state for rng instructions. The global state is incremented by delta and the old state is returned.

The output is currently defined for a single output type. If this changes in the future to support multiple types, lowering to use of a global memref must ensure that a single memref is still used and updated appropriately.

Interfaces: InferTypeOpInterface

Nitelikler:

Bağlanmak	MLIR Type	Tanım
delta	::mlir::IntegerAttr	64-bit signless integer attribute

Sonuçlar:

Sonuç	Tanım
«unnamed»	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

Sözdizimi:

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

Performs element-wise XOR of two tensors lhs and rhs and produces a result tensor.

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

Örnek:

%result = mhlo.xor %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

İşlenenler:

İşlenen	Tanım
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Sonuçlar:

Sonuç	Tanım
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Nitelikler

ArgResultAliasAttr

Attribute that models the alias relationship of entry function argument

This attribute captures the alias relationship of an MHLO main function argument to one of the results, denoted by resultIndex . The argTupleIndices and resultTupleIndices are used to index into nested tuples in operand and result respectively. If isMustAlias is true then the operand-result pair must alias.

This is meant to be used as an attribute on a function argument in MHLO. For example, in the following code it expresses that %arg1 may alias 0-th result.

func @main(%arg0: tensor<2xf32>, %arg1: tensor<3xf32> {mhlo.result_alias =
    mhlo.result_alias<result_index = [2], ...>}
  ) -> tensor<2xf32>, tensor<3xf32> {
  // function body ...
}

Parametreler:

Parametre	C++ type	Tanım
argTupleIndices	::llvm::ArrayRef<int64_t>	Boyut
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	Boyut
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

Sözdizimi:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

Parametreler:

Parametre	C++ type	Tanım
halletmek	int64_t
tip	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

Sözdizimi:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

Sözdizimi:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

Parametreler:

Parametre	C++ type	Tanım
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	Boyut
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	Boyut
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	Boyut

CrossProgramPrefetchAttr

Argument that is prefetched from another program

Sözdizimi:

#mhlo.cross_program_prefetch<
  int64_t,   # parameter
  ::llvm::ArrayRef<int64_t>,   # indices
  std::optional<int64_t>   # offset
>

This attribute captures an argument that is prefetched from another program. For a given CrossProgramPrefetchAttr , parameter tells us which argument of the main function of the module is prefetched, and indices is a shape index telling us what subshape of that argument is prefetched.

A shape has a subshape iff it is a tuple. In that case, the subshape of the tuple by indices is the shape achieved after indexing by each element of indices in turn. For example, the [1,0] subshape of tuple<tuple<token, token>, tuple<tensor<i32>, token>> is tensor<i32> .

An empty value for indices means the whole shape is prefetched.

Örneğin,

module attributes { mhlo.cross_program_prefetch = [ #mhlo.cross_program_prefetch< parameter = 0, indices = [0]> ]} {
  func.func @copy(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %0 = "mhlo.copy"(%arg0) {is_cross_program_prefetch}
    return %0 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
  func.func @main(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %1 = "mhlo.async_start"(%arg0) {called_computation=@copy}
    %2 = "mhlo.async_done"(%1) {called_computation=@copy}
    return %2 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
}

The parameter = 0 tells us that the async copy of the 0 th parameter is a cross_program_prefetch , while the index of [0] tells us that the 0 th element of the tuple is prefetched while the other element of the tuple is not.

Parametreler:

Parametre	C++ type	Tanım
parametre	int64_t
endeksler	::llvm::ArrayRef<int64_t>	Boyut
telafi etmek	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

Sözdizimi:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

Sözdizimi:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

Sözdizimi:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

Sözdizimi:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

Parametreler:

Parametre	C++ type	Tanım
lhsPrecisionType	Type
rhsPrecisionType	Type
accumulationType	Type
lhsComponentCount	int64_t
rhsComponentCount	int64_t
numPrimitiveOperations	int64_t
allowImpreciseAccumulation	bool

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

Parametreler:

Parametre	C++ type	Tanım
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Boyut
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Boyut
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	Boyut
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	Boyut

FftTypeAttr

XLA fast fourier transform type.

Sözdizimi:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

Sözdizimi:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

Parametreler:

Parametre	C++ type	Tanım
offsetDims	::llvm::ArrayRef<int64_t>	Boyut
collapsedSliceDims	::llvm::ArrayRef<int64_t>	Boyut
operandBatchingDims	::llvm::ArrayRef<int64_t>	Boyut
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Boyut
startIndexMap	::llvm::ArrayRef<int64_t>	Boyut
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

Sözdizimi:

#mhlo.output_operand_alias<
  ::llvm::ArrayRef<int64_t>,   # outputTupleIndices
  int64_t,   # operandIndex
  ::llvm::ArrayRef<int64_t>   # operandTupleIndices
>

This attribute captures the alias relationship of the output to one of the operands for a CustomCall op, denoted by operand_index . The output_tuple_indices and operand_tuple_indices are used to index into output and operand types. These indices lists are empty if the corresponding types are not tuple types, and can be arbitrarily long in case of arbitrarily nested tuple types.

See https://www.tensorflow.org/xla/aliasing

Example when used as array with in mhlo.custom-call:

%0 = "mhlo.custom_call"(%arg0, %arg1) {
  // other attributes
  output_operand_alias = [
    #mhlo.output_operand_alias<output_tuple_indices = [0],
                               operand_index = 0,
                               operand_tuple_indices = [1]>
  ]
} : (tuple<tensor<1x1xf32>, tensor<2x3xf32>>, tensor<5x5xf32>) -> tuple<tensor<2x3xf32>>

The output and the 0th operand are both tuples. The aliasing shows the
relationship between the 0th element in output tuple with the 1st element in
the 0th operand. And both of them are of the same type: tensor<2x3xf32>.

Parametreler:

Parametre	C++ type	Tanım
outputTupleIndices	::llvm::ArrayRef<int64_t>	Boyut
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	Boyut

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

Sözdizimi:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

Parametreler:

Parametre	C++ type	Tanım
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	Boyut
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	Boyut

ResultAccuracyAttr

The requested accuracy for unary ops.

Parametreler:

Parametre	C++ type	Tanım
atol	APFloat
rtol	APFloat
ulps	int64_t
mod	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

Sözdizimi:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

Sözdizimi:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

Sözdizimi:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

Parametreler:

Parametre	C++ type	Tanım
updateWindowDims	::llvm::ArrayRef<int64_t>	Boyut
insertedWindowDims	::llvm::ArrayRef<int64_t>	Boyut
inputBatchingDims	::llvm::ArrayRef<int64_t>	Boyut
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Boyut
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	Boyut
indexVectorDim	int64_t

TransposeAttr

Transpose options

Sözdizimi:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

Parametreler:

Parametre	C++ type	Tanım
değer	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

Sözdizimi:

#mhlo.type_extensions<
  ::llvm::ArrayRef<int64_t>   # bounds
>

This attribute is used to extend MLIR tensor type with MHLO tensor specific properties. These properties aren't modeled in the MLIR type. This attribute is set in the encoding field of the tensor type.

See HLO_BoundedAttrInterface for documentation for bounds .

Parametreler:

Parametre	C++ type	Tanım
sınırlar	::llvm::ArrayRef<int64_t>

Türler

AsyncBundleType

Opaque collection of other types

Sözdizimi:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

Parametreler:

Parametre	C++ type	Tanım
türleri	::llvm::ArrayRef<Type>

Numaralandırmalar

ComparisonDirection

Which comparison operation to perform.

Davalar:

Sembol	Değer	Sicim
EQ	0	EQ
NE	1	NE
Genel Müdür	2	Genel Müdür
GT	3	GT
LE	4	LE
LT	5	LT

ComparisonType

Which comparison type to use.

Davalar:

Sembol	Değer	Sicim
NOTYPE	0	NOTYPE
BATMADAN YÜZMEK	1	BATMADAN YÜZMEK
TOTALORDER	2	TOTALORDER
İMZALANDI	3	İMZALANDI
UNSIGNED	4	UNSIGNED

CustomCallApiVersion

Custom call API version

Davalar:

Sembol	Değer	Sicim
API_VERSION_UNSPECIFIED	0	API_VERSION_UNSPECIFIED
API_VERSION_ORIGINAL	1	API_VERSION_ORIGINAL
API_VERSION_STATUS_RETURNING	2	API_VERSION_STATUS_RETURNING
API_VERSION_STATUS_RETURNING_UNIFIED	3	API_VERSION_STATUS_RETURNING_UNIFIED
API_VERSION_TYPED_FFI	4	API_VERSION_TYPED_FFI

CustomCallSchedule

Specifies the desired schedule for the custom-call.

Davalar:

Sembol	Değer	Sicim
HİÇBİRİ	0	HİÇBİRİ
EN SONUNCU	1	EN SONUNCU
EN ERKEN	2	EN ERKEN

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

Davalar:

Sembol	Değer	Sicim
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

Davalar:

Sembol	Değer	Sicim
parçalama	0	parçalama

FftType

XLA fast fourier transform type.

Davalar:

Sembol	Değer	Sicim
FFT	0	FFT
Eğer öyleyse	1	Eğer öyleyse
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

Davalar:

Sembol	Değer	Sicim
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

Kesinlik

XLA precision for an operand. Has backend specific meaning.

Davalar:

Sembol	Değer	Sicim
VARSAYILAN	0	VARSAYILAN
YÜKSEK	1	YÜKSEK
EN YÜKSEK	2	EN YÜKSEK

ResultAccuracyMode

XLA result accuracy mode.

Davalar:

Sembol	Değer	Sicim
VARSAYILAN	0	VARSAYILAN
EN YÜKSEK	1	EN YÜKSEK
TOLERANS	2	TOLERANS

RngAlgorithm

XLA PRNG algorithm to be used.

Davalar:

Sembol	Değer	Sicim
VARSAYILAN	0	VARSAYILAN
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

Davalar:

Sembol	Değer	Sicim
ÜNİFORMA	1	ÜNİFORMA
NORMAL	2	NORMAL

Transpoze

Transpose options

Davalar:

Sembol	Değer	Sicim
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
TRANSPOZE	2	TRANSPOZE
ADJOINT	3	ADJOINT