StableHLO Özelliği

StableHLO, makine öğrenimi (ML) modellerinde üst düzey işlemler (HLO) için bir işlem kümesidir. StableHLO, farklı ML çerçeveleri ve ML derleyicileri arasında taşınabilirlik katmanı olarak çalışır: StableHLO programları üreten ML çerçeveleri, StableHLO programlarını kullanan ML derleyicileriyle uyumludur.

Amacımız, çeşitli makine öğrenimi çerçeveleri (ör. TensorFlow, JAX ve PyTorch) ile makine öğrenimi derleyicileri (ör. XLA ve IREE) arasında daha fazla birlikte çalışabilirlik sağlayarak makine öğrenimi geliştirmeyi basitleştirmek ve hızlandırmaktır. Bu amaçla, bu belgede StableHLO programlama dili için bir spesifikasyon sağlanmaktadır.

Bu spesifikasyon üç ana bölümden oluşur. İlk olarak, Programlar bölümünde, StableHLO işlevlerinden oluşan StableHLO programlarının yapısı açıklanmaktadır. StableHLO işlevleri de StableHLO işlemlerinden oluşur. Bu yapı içinde, Ops bölümünde tek tek işlemlerin semantiği belirtilir. Yürütme bölümü, bir programda birlikte yürütülen tüm bu işlemlerin semantiğini sağlar. Son olarak, Notasyon bölümünde, spesifikasyon genelinde kullanılan notasyon ele alınır.

StableHLO'nun önceki bir sürümündeki spesifikasyonu görüntülemek için ilgilendiğiniz etiketli sürümde depoyu açın. Örneğin, StableHLO v0.19.0 Spec. StableHLO'nun her küçük sürüm artışında meydana gelen değişiklikleri görüntülemek için VhloDialect.td'deki sürüm günlüğüne bakın.

Programlar

Program ::= {Func}

StableHLO programları, rastgele sayıda StableHLO işlevinden oluşur. Aşağıda, 3 girişi (%image, %weights ve %bias) ve 1 çıkışı olan @main işlevini içeren bir örnek program verilmiştir. İşlevin gövdesinde 6 işlem var.

func.func @main(
  %image: tensor<28x28xf32>,
  %weights: tensor<784x10xf32>,
  %bias: tensor<1x10xf32>
) -> tensor<1x10xf32> {
  %0 = "stablehlo.reshape"(%image) : (tensor<28x28xf32>) -> tensor<1x784xf32>
  %1 = "stablehlo.dot"(%0, %weights) : (tensor<1x784xf32>, tensor<784x10xf32>) -> tensor<1x10xf32>
  %2 = "stablehlo.add"(%1, %bias) : (tensor<1x10xf32>, tensor<1x10xf32>) -> tensor<1x10xf32>
  %3 = "stablehlo.constant"() {value = dense<0.0> : tensor<1x10xf32>} : () -> tensor<1x10xf32>
  %4 = "stablehlo.maximum"(%2, %3) : (tensor<1x10xf32>, tensor<1x10xf32>) -> tensor<1x10xf32>
  "func.return"(%4): (tensor<1x10xf32>) -> ()
}

İşlevler

Func        ::= 'func' '.' 'func' FuncId FuncInputs FuncOutputs '{' FuncBody '}'
FuncInputs  ::= '(' [FuncInput {',' FuncInput}] `)`
FuncInput   ::= ValueId ':' ValueType
FuncOutputs ::= ['->' FuncOutput, {',' FuncOutput}]
FuncOutput  ::= ValueType
FuncBody    ::= {Op}

StableHLO işlevleri (adlandırılmış işlevler olarak da bilinir) bir tanımlayıcıya, girişlere/çıkışlara ve gövdeye sahiptir. Gelecekte, HLO ile daha iyi uyumluluk sağlamak için işlevlere ek meta veriler eklemeyi planlıyoruz (#425, #626, #740, #744).

Tanımlayıcılar

FuncId  ::= '@' letter {letter | digit}
ValueId ::= '%' digit {digit}
          | '%' letter {letter | digit}
letter  ::= 'a' | ... | 'z' | 'A' | ... | 'Z' | '_'
digit   ::= '0' | ... | '9'

StableHLO tanımlayıcıları, birçok programlama dilindeki tanımlayıcılara benzer. Ancak iki özelliği farklıdır: 1) Tüm tanımlayıcılar, farklı tanımlayıcı türlerini ayıran işaretlere sahiptir. 2) StableHLO programlarının oluşturulmasını kolaylaştırmak için değer tanımlayıcıları tamamen sayısal olabilir.

Türler

Type         ::= ValueType | NonValueType
ValueType    ::= TensorType | QuantizedTensorType | TokenType | TupleType | BufferType
NonValueType ::= TensorElementType | QuantizedTensorElementType | FunctionType | StringType

StableHLO türleri, StableHLO değerlerini temsil eden değer türleri (birinci sınıf türleri olarak da adlandırılır) ve diğer program öğelerini açıklayan değer dışı türler olarak sınıflandırılır. StableHLO türleri, birçok programlama dilindeki türlere benzer.Ancak StableHLO'nun alana özgü yapısı nedeniyle bazı sıra dışı sonuçlar (ör. skaler türler değer türleri değildir) ortaya çıkar.

TensorType ::= 'tensor' '<' Shape TensorElementType '>'
Shape ::= {DimensionSize 'x'}
DimensionSize ::= digit {digit} | '?'

Tensor türleri, tensörleri (yani çok boyutlu diziler) temsil eder. Bunlar bir şekle ve bir öğe türüne sahiptir. Şekil, karşılık gelen boyutların (eksenler olarak da adlandırılır) artan sırasındaki negatif olmayan veya bilinmeyen boyutları temsil eder. Boyutlar, 0 ile R-1 arasında numaralandırılır. Boyut sayısı R sıra olarak adlandırılır. Örneğin, tensor<2x3xf32>, 2x3 şekline ve f32 öğe türüne sahip bir tensör türüdür. Boyutları 2 ve 3 olan iki boyuta (veya başka bir deyişle iki eksene) sahiptir: 0. boyut ve 1. boyut. Sıralaması 2'dir.

Şekiller kısmen veya tamamen bilinmeyebilir (dinamik). Örneğin, tensor<?x2xf64> kısmen bilinirken tensor<?x?xf64> tamamen bilinmez. Dinamik boyutlar ? kullanılarak gösterilir. Şekillerin derecelendirmesi kaldırılamaz.

Gelecekte, tensör türlerini boyut boyutları ve öğe türlerinin ötesine taşıyarak düzenler (#629) ve seyrekliği (#1078) de içerecek şekilde genişletmeyi planlıyoruz.

QuantizedTensorType ::= 'tensor' '<' Shape QuantizedTensorElementType '>'
QuantizedTensorElementType ::= '!quant.uniform' '<'
                  QuantizationStorageType
                  ['<' QuantizationStorageMin ':' QuantizationStorageMax '>']
                  ':' QuantizationExpressedType
                  [':' QuantizationDimension]
                  ',' QuantizationParameters '>'
QuantizationStorageType ::= IntegerType
QuantizationStorageMin ::= IntegerLiteral
QuantizationStorageMax ::= IntegerLiteral
QuantizationExpressedType ::= FloatType
QuantizationDimension ::= IntegerLiteral
QuantizationParameters ::= QuantizationParameter
                         | '{' QuantizationParameter {',' QuantizationParameter} '}'
QuantizationParameter ::= QuantizationScale [':' QuantizationZeroPoint]
QuantizationScale ::= FloatLiteral
QuantizationZeroPoint ::= IntegerLiteral

Kuantize edilmiş öğe türleri, depolama türünün storage_min ile storage_max (dahil) arasındaki aralıkta bulunan ve ifade edilmiş türün kayan nokta değerlerine karşılık gelen tam sayı değerlerini temsil eder. Belirli bir tam sayı değeri i için, karşılık gelen kayan nokta değeri f, f = (i - zero_point) * scale olarak hesaplanabilir. Burada scale ve zero_point, nicelendirme parametreleri olarak adlandırılır. storage_min ve storage_max, dilbilgisinde isteğe bağlıdır ancak sırasıyla min_value(storage_type) ve max_value(storage_type) varsayılan değerlerine sahiptir. Kuantize edilmiş öğe türleri aşağıdaki kısıtlamalara sahiptir:

• (C1) type(storage_min) = storage_type.
• (C2) type(storage_max) = storage_type.
• (C3) min_value(storage_type) <= storage_min < storage_max <= max_value(storage_type).
• (C4) type(scales...) = expressed_type.
• (C5) 0 < scales.
• (C6) is_finite(scales...).
• (C7) storage_min <= zero_points <= storage_max.
• (C8) type(zero_points...) = storage_type.
• (C9) size(scales) = size(zero_points).
• (C10) is_empty(quantization_dimension) ise size(scales) = 1.
• (C11) 0 <= quantization_dimension.

Şu anda QuantizationScale kayan noktalı bir sabittir ancak çarpanlar ve kaydırmalarla gösterilen tam sayı tabanlı ölçeklere büyük ilgi duyulmaktadır. Bu konuyu yakın gelecekte ele almayı planlıyoruz (#1404).

QuantizationZeroPoint semantiğiyle ilgili devam eden bir tartışma var. Bu tartışma, türü, değerleri ve nicelenmiş tensör türünde yalnızca bir veya birden fazla sıfır noktası olup olamayacağını içeriyor. Bu tartışmanın sonuçlarına göre, sıfır puanla ilgili spesifikasyon gelecekte değişebilir (#1405).

Devam eden bir diğer tartışma ise bu değerlere ve nicelenmiş tensörlerin değerlerine herhangi bir kısıtlama getirilip getirilmeyeceğini belirlemek için QuantizationStorageMin ve QuantizationStorageMax semantiğini içeriyor (#1406).

Son olarak, bilinmeyen boyutları temsil etmeyi planladığımız gibi (#1407), bilinmeyen ölçekleri ve sıfır noktalarını temsil etmeyi de planlıyoruz.

Kuantize edilmiş tensör türleri, kuantize edilmiş öğeler içeren tensörleri temsil eder. Bu tensörler, öğelerinin normal öğe türleri yerine nicelenmiş öğe türlerine sahip olması dışında normal tensörlerle tamamen aynıdır.

Kuantize edilmiş tensörlerde kuantizasyon tensör başına olabilir. Bu durumda, tensörün tamamı için bir scale ve zero_point bulunur. Kuantizasyon eksen başına da olabilir. Bu durumda, belirli bir boyutun quantization_dimension her dilimi için bir çift olmak üzere birden fazla scales ve zero_points bulunur. Daha resmi bir ifadeyle, eksen başına nicemleme içeren bir tensörde t, quantization_dimension'nin dim(t, quantization_dimension) dilimi vardır: t[:, ..., 0, ..., :], t[:, ..., 1, ..., :] vb. i. dilimdeki tüm öğeler, nicemleme parametreleri olarak scales[i] ve zero_points[i] kullanır. Kuantize edilmiş tensör türleri aşağıdaki kısıtlamalara sahiptir:

• Tensör başına nicemleme için:
  • Ek kısıtlama yoktur.
• Eksen başına nicemleme için:
  • (C12) quantization_dimension < rank(self).
  • (C13) dim(self, quantization_dimension) = size(scales).

TokenType ::= 'token'

Jeton türleri, jetonları (yani bazı işlemler tarafından oluşturulan ve kullanılan opak değerler) temsil eder. Jetonlar, Yürütme bölümünde açıklandığı gibi işlemlere yürütme sırası uygulamak için kullanılır.

TupleType ::= 'tuple' '<' TupleElementTypes '>'
TupleElementTypes ::= [ValueType {',' ValueType}]

Arabellek türleri, arabellekleri temsil eder. Örneğin, XLA'da arabellekler, tutarlı depolama alanına sahip çok boyutlu dizilerdir. Tensor türlerine benzer şekilde, arabellek türlerinin de şekli ve öğe türü vardır. Şekil, 0 ile R-1 arasında numaralandırılmış, karşılık gelen boyutların (eksenler olarak da adlandırılır) artan sırasındaki negatif olmayan veya bilinmeyen boyutları temsil eder. Boyut sayısı R sıra olarak adlandırılır. Örneğin, memref<2x3xf32>, şekli 2x3 ve öğe türü f32 olan bir arabellek türüdür. Boyutları 2 ve 3 olan iki boyutu (veya başka bir deyişle iki ekseni) vardır: 0. boyut ve 1. boyut. Sıralaması 2'dir.

Arabellekler, custom_call ile CreateBuffer veya Pin kullanılarak ayrılabilir ve custom_call ile Unpin kullanılarak serbest bırakılabilir. Yalnızca custom_call işlemleri arabelleklerdeki içeriği okuyabilir ve yazabilir. Daha fazla ayrıntı için custom_call sayfasına bakın.

Demet türleri, demetleri (yani heterojen listeleri) temsil eder. Demetler, yalnızca HLO ile uyumluluk için kullanılan eski bir özelliktir. HLO'da, değişken sayıda giriş ve çıkışı temsil etmek için demetler kullanılır. StableHLO'da değişken sayıda giriş ve çıkış yerel olarak desteklenir.StableHLO'da demetlerin tek kullanımı, HLO ABI'yi kapsamlı bir şekilde temsil etmektir. Örneğin, T, tuple<T> ve tuple<tuple<T>> belirli bir uygulamaya bağlı olarak önemli ölçüde farklı olabilir. Gelecekte, HLO ABI'de değişiklikler yapmayı planlıyoruz. Bu değişiklikler, StableHLO'dan demet türlerini kaldırmamıza olanak tanıyabilir (#598).

TensorElementType ::= BooleanType | IntegerType | FloatType | ComplexType
BooleanType ::= 'i1'
IntegerType ::= SignedIntegerType | UnsignedIntegerType
SignedIntegerType ::= 'si2' | 'si4' | 'si8' | 'si16' | 'si32' | 'si64'
UnsignedIntegerType ::= 'ui2' | 'ui4' | 'ui8' | 'ui16' | 'ui32' | 'ui64'
FloatType ::= 'f4E2M1FN' | 'f6E2M3FN' | 'f6E3M2FN' | 'f8E3M4' | 'f8E4M3'
            | 'f8E4M3FN' | 'f8E4M3FNUZ' | 'f8E4M3B11FNUZ' | 'f8E5M2'
            | 'f8E5M2FNUZ' | 'f8E8M0FNU' | 'bf16' | 'f16' | 'f32' | 'f64'
TensorFloat32 ::= 'tf32'
ComplexType ::= 'complex' '<' ComplexElementType '>'
ComplexElementType ::= 'f32' | 'f64'

Öğe türleri, tensör türlerinin öğelerini temsil eder. Birçok programlama dilinin aksine, bu türler StableHLO'da birinci sınıf değildir. Bu nedenle, StableHLO programları bu türlerin değerlerini doğrudan temsil edemez (sonuç olarak, T türündeki skaler değerleri tensor<T> türündeki 0 boyutlu tensör değerleriyle temsil etmek yaygın bir uygulamadır).

• Boole türü, Boole değerleri true ve false'ü temsil eder.
• Tam sayı türleri işaretli (si) veya işaretsiz (ui) olabilir ve desteklenen bit genişliklerinden birine (2, 4, 8, 16, 32 veya 64) sahip olabilir. İşaretli siN türleri, -2^(N-1) ile 2^(N-1)-1 arasındaki tam sayı değerlerini (bu değerler dahil) temsil eder. İşaretsiz uiN türleri ise 0 ile 2^N-1 arasındaki tam sayı değerlerini (bu değerler dahil) temsil eder.
• Kayan nokta türleri aşağıdakilerden biri olabilir:
  • f8E3M4, f8E4M3 ve f8E5M2, IEEE-754 kurallarına uygun 8 bitlik kayan nokta sayılarıdır.
  • f8E4M3FN ve f8E5M2 türleri, FP8 Formats for Deep Learning (Derin Öğrenme için FP8 Biçimleri) başlıklı makalede açıklanan FP8 biçiminin sırasıyla E4M3 ve E5M2 kodlamalarına karşılık gelir.
  • f8E4M3FNUZ ve f8E5M2FNUZ türleri, 8-bit Numerical Formats for Deep Neural Networks (Derin Sinir Ağları İçin 8 Bit Sayısal Biçimler) başlıklı makalede açıklanan FP8 biçimlerinin E4M3 ve E5M2 kodlamalarına karşılık gelir.
  • f8E4M3B11FNUZ türü, E4M3 kodlamasına karşılık gelir. FP8 biçimlerinin kodlaması, Derin Sinir Ağları İçin Hibrit 8 Bit Kayan Noktalı (HFP8) Eğitim ve Çıkarım başlıklı makalede açıklanmıştır.
  • bf16, BFloat16: The secret to high performance on Cloud TPUs (BFloat16: Cloud TPU'larda yüksek performansın sırrı) başlıklı makalede açıklanan bfloat16 biçimine karşılık gelen tür.
  • f16, f32 ve f64 türleri sırasıyla binary16 ("yarım duyarlıklı"), binary32 ("tek duyarlıklı") ve binary64 ("çift duyarlıklı") biçimlerine karşılık gelir. Bu biçimler IEEE 754 standardında açıklanmıştır.
  • tf32 türü, TensorFloat32 biçimine karşılık gelir ve StableHLO'da sınırlı destek sunar.
  • OCP Microscaling Formats Specification'da açıklanan f4E2M1FN, f6E2M3FN, f6E3M2FN ve f8E8M0FNU MX (mikro ölçeklendirme) türleri.
• Karmaşık türler, aynı öğe türüne ait bir reel kısım ve bir sanal kısım içeren karmaşık değerleri temsil eder. Desteklenen karmaşık türler complex<f32> (her iki bölüm de f32 türündedir) ve complex<f64> (her iki bölüm de f64 türündedir).

FunctionType ::= '(' InputTypes ')' '->' '(' OutputTypes ')'
InputTypes ::= [ValueType {',' ValueType}]
OutputTypes ::= [ValueType {',' ValueType}]

İşlev türleri, hem adlandırılmış hem de anonim işlevleri temsil eder. Giriş türleri (-> simgesinin sol tarafındaki türlerin listesi) ve çıkış türleri (-> simgesinin sağ tarafındaki türlerin listesi) vardır. Birçok programlama dilinde işlev türleri birinci sınıf olsa da StableHLO'da birinci sınıf değildir.

StringType ::= 'string'

Dize türü, bayt dizilerini temsil eder. Birçok programlama dilinin aksine, StableHLO'da dize türü birinci sınıf değildir ve yalnızca program öğeleri için statik meta verileri belirtmek amacıyla kullanılır.

İşlemler

StableHLO işlemleri (işlemler olarak da adlandırılır) makine öğrenimi modellerindeki üst düzey işlemlerin kapalı bir kümesini temsil eder. Yukarıda bahsedildiği gibi, StableHLO söz dizimi büyük ölçüde MLIR'den esinlenmiştir. Bu, en ergonomik alternatif olmasa da StableHLO'nun makine öğrenimi çerçeveleri ve makine öğrenimi derleyicileri arasında daha fazla birlikte çalışabilirlik oluşturma hedefi için muhtemelen en uygun seçenektir.

Op            ::= [OpOutputs] OpName OpInputs ':' OpSignature
OpName        ::= '"' 'stablehlo' '.' OpMnemonic '"'
OpMnemonic    ::= 'abs' | 'add' | ...

StableHLO işlemleri (işlemler olarak da adlandırılır) bir ada, girişlere/çıkışlara ve imzaya sahiptir. Ad, stablehlo. önekinden ve desteklenen işlemlerden birini benzersiz şekilde tanımlayan bir anımsatıcıdan oluşur. Desteklenen tüm işlemlerin kapsamlı listesi için aşağıya bakın.

OpInputs        ::= OpInputValues OpInputFuncs OpInputAttrs
OpInputValues   ::= '(' [OpInputValue {',' OpInputValue}] ')'
OpInputValue    ::= ValueId
OpInputFuncs    ::= ['(' OpInputFunc {',' OpInputFunc} ')']
OpInputAttrs    ::= ['{' OpInputAttr {',' OpInputAttr} '}']
OpOutputs       ::= [OpOutput {',' OpOutput} '=']
OpOutput        ::= ValueId

İşlemler girdileri tüketir ve çıktılar üretir. Girişler; giriş değerleri (yürütme sırasında hesaplanır), giriş işlevleri (StableHLO'da işlevler birinci sınıf değerler olmadığından statik olarak sağlanır) ve giriş özellikleri (ayrıca statik olarak sağlanır) şeklinde sınıflandırılır. Bir işlemin kullandığı ve ürettiği giriş ve çıkış türü, işlemin anımsatıcı koduna bağlıdır. Örneğin, add işlemi 2 giriş değeri kullanır ve 1 çıkış değeri üretir. Buna kıyasla, select_and_scatter işlemi 3 giriş değeri, 2 giriş işlevi ve 3 giriş özelliği kullanır.

OpInputFunc ::= '{' Unused FuncInputs ':' FuncBody '}'
Unused      ::= '^' digit {digit}
              | '^' letter {letter | digit}

Giriş işlevleri (anonim işlevler olarak da adlandırılır) adlandırılmış işlevlere çok benzer. Ancak: 1) Tanımlayıcıları yoktur (bu nedenle "anonim" olarak adlandırılırlar). 2) Çıkış türlerini bildirmezler (çıkış türleri, işlevdeki return işleminden çıkarılır).

Giriş işlevlerinin söz diziminde, MLIR ile uyumluluk için şu anda kullanılmayan bir bölüm bulunur (yukarıdaki Unused üretim bölümüne bakın). MLIR'de, atlama işlemleriyle birbirine bağlanmış birden fazla işlem "bloğu" içerebilen daha genel bir "bölgeler" kavramı vardır. Bu blokların, Unused üretimle eşleşen kimlikleri vardır. Böylece bloklar birbirinden ayırt edilebilir. StableHLO'da atlama işlemleri olmadığından MLIR söz diziminin ilgili kısmı kullanılmaz (ancak yine de oradadır).

OpInputAttr      ::= OpInputAttrName '=' OpInputAttrValue
OpInputAttrName  ::= letter {letter | digit}
OpInputAttrValue ::= Constant

Giriş özelliklerinin adı ve desteklenen sabitlerden biri olan değeri vardır. Bunlar, program öğeleri için statik meta verileri belirtmenin birincil yoludur. Örneğin, concatenate işlemi, giriş değerlerinin birleştirildiği boyutu belirtmek için dimension özelliğini kullanır. Benzer şekilde, slice işlemi, giriş değerini dilimlemek için kullanılan sınırları belirtmek üzere start_indices ve limit_indices gibi birden fazla özellik kullanır.

Şu anda, gerçek hayattaki StableHLO programları bazen bu belgede açıklanmayan özellikler içerir. Gelecekte bu özellikleri StableHLO işlem kümesine dahil etmeyi veya StableHLO programlarında görünmelerini yasaklamayı planlıyoruz. Bu süre zarfında, bu özelliklerin listesini aşağıda bulabilirsiniz:

• layout (#629).
• mhlo.frontend_attributes (#628).
• mhlo.sharding (#619).
• output_operand_aliases (#740).
• Konum meta verileri (#594).

OpSignature ::= '(' [ValueType {',' ValueType}] ')' '->' '(' [ValueType {',' ValueType}] ')'

İşlem imzası, tüm giriş değerlerinin türlerinden (->'nin sol tarafındaki türlerin listesi) ve tüm çıkış değerlerinin türlerinden (->'nin sağ tarafındaki türlerin listesi) oluşur. Giriş türleri kesinlikle gereksizdir ve çıkış türleri de neredeyse her zaman gereksizdir (çünkü çoğu StableHLO işlemi için çıkış türleri girişlerden çıkarılabilir). Bununla birlikte, op signature, MLIR ile uyumluluk için StableHLO söz diziminin bir parçasıdır.

Aşağıda, anımsatıcısı select_and_scatter olan bir örnek işlem verilmiştir. 3 giriş değeri (%operand, %source ve %init_value), 2 giriş işlevi ve 3 giriş özelliği (window_dimensions, window_strides ve padding) kullanır. İşlemin imzasının yalnızca giriş değerlerinin türlerini (ancak satır içi olarak sağlanan giriş işlevlerinin ve özelliklerinin türlerini değil) içerdiğine dikkat edin.

%result = "stablehlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "stablehlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "stablehlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "stablehlo.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>

Sabitler

Constant ::= BooleanConstant
           | IntegerConstant
           | FloatConstant
           | ComplexConstant
           | TensorConstant
           | QuantizedTensorConstant
           | StringConstant
           | EnumConstant

StableHLO sabitleri, birlikte bir StableHLO değerini temsil eden bir değişmez değere ve türe sahiptir. Genellikle tür, sabit söz diziminin bir parçasıdır.Ancak türün net olduğu durumlarda (ör. bir boolean sabiti net bir şekilde i1 türündedir, ancak bir tam sayı sabiti birden fazla olası türe sahip olabilir) bu durum geçerli değildir.

BooleanConstant ::= BooleanLiteral
BooleanLiteral  ::= 'true' | 'false'

Boole sabitleri, true ve false Boole değerlerini temsil eder. Boole sabitlerinin türü i1'dır.

IntegerConstant   ::= IntegerLiteral ':' IntegerType
IntegerLiteral    ::= ['-' | '+'] DecimalDigits
                    | ['-' | '+'] '0x' HexadecimalDigits
DecimalDigits     ::= decimalDigit {decimalDigit}
HexadecimalDigits ::= hexadecimalDigit {hexadecimalDigit}
decimalDigit      ::= '0' | ... | '9'
hexadecimalDigit  ::= decimalDigit | 'a' | ... | 'f' | 'A' | ... | 'F'

Tamsayı sabitleri, ondalık veya onaltılık gösterim kullanan dizeler aracılığıyla tamsayı değerlerini temsil eder. Diğer tabanlar (ör. ikili veya sekizlik) desteklenmez. Tam sayı sabitleri aşağıdaki kısıtlamalara sahiptir:

• (C1) is_wellformed(integer_literal, integer_type).

FloatConstant  ::= FloatLiteral ':' FloatType
FloatLiteral   ::= SignPart IntegerPart FractionalPart ScientificPart
                 | '0x' [HexadecimalDigits]
SignPart       ::= ['-' | '+']
IntegerPart    ::= DecimalDigits
FractionalPart ::= ['.' [DecimalDigits]]
ScientificPart ::= [('e' | 'E') ['-' | '+'] DecimalDigits]

Kayan nokta sabitleri, ondalık veya bilimsel gösterim kullanan dizeler aracılığıyla kayan nokta değerlerini temsil eder. Ayrıca, onaltılık gösterim, ilgili türün kayan nokta biçimindeki temel bitleri doğrudan belirtmek için kullanılabilir. Kayan nokta sabitleri aşağıdaki kısıtlamalara sahiptir:

• (C1) Onaltılık olmayan gösterim kullanılıyorsa, is_wellformed(float_literal, float_type).
• (C2) Onaltılık gösterim kullanılıyorsa, size(hexadecimal_digits) = num_bits(float_type) / 4.

ComplexConstant ::= ComplexLiteral ':' ComplexType
ComplexLiteral  ::= '(' RealPart ',' ImaginaryPart ')'
RealPart        ::= FloatLiteral
ImaginaryPart   ::= FloatLiteral

Karmaşık sabitler, gerçek kısım (önce gelir) ve sanal kısım (ikinci gelir) listelerini kullanarak karmaşık değerleri temsil eder. Örneğin, (1.0, 0.0) : complex<f32>, 1.0 + 0.0i'yi, (0.0, 1.0) : complex<f32> ise 0.0 + 1.0i'ü temsil eder. Bu parçaların bellekte depolanma sırası uygulamaya bağlıdır. Karmaşık sabitler aşağıdaki kısıtlamalara tabidir:

• (C1) is_wellformed(real_part, complex_element_type(complex_type)).
• (C2) is_wellformed(imaginary_part, complex_element_type(complex_type)).

TensorConstant ::= TensorLiteral ':' TensorType
TensorLiteral  ::= 'dense' '<' (DenseLiteral | ElementLiteral) '>'
DenseLiteral   ::= DenseDimension | DenseElements
DenseDimension ::= '[' [DenseLiteral {',' DenseLiteral}] ']'
DenseElements  ::= [ElementLiteral {',' ElementLiteral}]
ElementLiteral ::= BooleanLiteral | IntegerLiteral | FloatLiteral | ComplexLiteral

Tensor sabitleri, NumPy gösterimiyle belirtilen iç içe geçmiş listeler kullanılarak tensör değerlerini temsil eder. Örneğin, dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>, dizinlerden öğelere aşağıdaki eşlemeyi içeren bir tensör değerini temsil eder: {0, 0} => 1, {0, 1} => 2, {0, 2} => 3, {1, 0} => 4, {1, 1} => 5, {1, 2} => 6. Bu öğelerin daha sonra bellekte depolanma sırası uygulamaya bağlıdır. Tensor sabitleri aşağıdaki kısıtlamalara sahiptir:

• (C1) has_syntax(tensor_literal, element_type(tensor_type)), burada:
  • has_syntax(element_literal: Syntax, element_type: Type) = is_wellformed(element_literal, type).
  • has_syntax(tensor_literal: List, element_type: Type) = has_syntax(tensor_literal..., element_type).
• (C2) has_shape(tensor_literal, shape(tensor_type)), burada:
  • has_shape(element_literal: Syntax, []) = true.
  • has_shape(tensor_literal: List, shape: List) = size(tensor_literal) = shape[0] and has_shape(tensor_literal..., shape[1:]).
  • Aksi takdirde false.

QuantizedTensorConstant ::= QuantizedTensorLiteral ':' QuantizedTensorType
QuantizedTensorLiteral  ::= 'dense' '<' (DenseLiteral | ElementLiteral) '>'

Kuantize edilmiş tensör sabitleri, tensör sabitleriyle aynı gösterimi kullanarak kuantize edilmiş tensör değerlerini temsil eder. Öğeler, depolama türlerinin sabitleri olarak belirtilir. Kuantize edilmiş tensör sabitleri aşağıdaki kısıtlamalara sahiptir:

• (C1) has_syntax(quantized_tensor_literal, storage_type(quantized_tensor_type)).
• (C2) has_shape(quantized_tensor_literal, shape(quantized_tensor_type)).

StringConstant  ::= StringLiteral
StringLiteral   ::= '"' {stringCharacter | escapeSequence} '"'
stringCharacter ::= all ASCII characters except '\00', '\01', ... '\1f' and '"'
escapeSequence  ::= '\' ('"' | '\' | 'n' | 't' | (hexadecimalDigit hexadecimalDigit))

Dize değişmezleri, ASCII karakterleri ve kaçış dizileri kullanılarak belirtilen baytlardan oluşur. Kodlamadan bağımsız oldukları için bu baytların yorumlanması uygulamaya göre tanımlanır. Dize değişmezleri string türündedir.

İşlemler

abs

Anlam Bilimi

operand tensöründe öğe bazında mutlak değer işlemi gerçekleştirir ve result tensörünü üretir. Öğe türüne bağlı olarak aşağıdakileri yapar:

• İşaretli tam sayılar için: tam sayı modülü.
• Kayan nokta sayıları için: IEEE-754'ten abs.
• Karmaşık sayılar için: karmaşık modül.
• Kuantize edilmiş türler için: dequantize_op_quantize(abs, operand, type(result)).

Girişler

Çıkışlar

Sınırlamalar

• (C1) shape(result) = shape(operand).
• (C2) baseline_element_type(result) şu şekilde tanımlanır:
  • complex_element_type(element_type(operand)) ise is_complex(operand).
  • Aksi takdirde baseline_element_type(operand).

Örnekler

// %operand: [-2, 0, 2]
%result = "stablehlo.abs"(%operand) : (tensor<3xi32>) -> tensor<3xi32>
// %result: [2, 0, 2]

 Diğer örnekler

add

Anlam Bilimi

lhs ve rhs tensörlerinin öğe bazında toplama işlemini gerçekleştirir ve result tensörünü oluşturur. Öğe türüne bağlı olarak aşağıdakileri yapar:

• Boole değerleri için: mantıksal VEYA.
• Tam sayılar için: tam sayı toplama.
• Kayan nokta sayıları için: IEEE-754'ten addition.
• Karmaşık sayılar için: karmaşık toplama.
• Kuantize edilmiş türler için: dequantize_op_quantize(add, lhs, rhs, type(result)).

Girişler

Çıkışlar

Sınırlamalar

• İşlemde nicelendirilmemiş tensörler kullanılıyorsa:
  • (C1) type(lhs) = type(rhs) = type(result).
• İşlemde nicel tensorlar kullanılıyorsa:
  • (C2) is_quantized(lhs) and is_quantized(rhs) and is_quantized(result).
  • (C3) storage_type(lhs) = storage_type(rhs) = storage_type(result).
  • (C4) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result).
  • (C5) (is_per_axis_quantized(lhs) or is_per_axis_quantized(rhs)) = is_per_axis_quantized(result).
  • (C6) is_per_axis_quantized(lhs) ise quantization_dimension(lhs) = quantization_dimension(result).
  • (C7) is_per_axis_quantized(rhs) ise quantization_dimension(rhs) = quantization_dimension(result).

Örnekler

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.add"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[6, 8], [10, 12]]

 Diğer örnekler

after_all

Anlam Bilimi

inputs üreten işlemlerin, result öğesine bağlı olan işlemlerden önce yürütülmesini sağlar. Bu işlemin yürütülmesi hiçbir şey yapmaz, yalnızca result ile inputs arasında veri bağımlılıkları oluşturmak için kullanılır.

Girişler

Çıkışlar

Örnekler

// %input0: !stablehlo.token
// %input1: !stablehlo.token
%result = "stablehlo.after_all"(%input0, %input1) : (!stablehlo.token, !stablehlo.token) -> !stablehlo.token

 Diğer örnekler

all_gather

Anlam Bilimi

StableHLO işlem tablosundaki her işlem grubunda, her işlemden gelen operands tensörlerinin değerlerini all_gather_dim boyunca birleştirir ve results tensörleri oluşturur.

İşlem, StableHLO işlem ızgarasını process_groups olarak böler. Bu değer aşağıdaki şekilde tanımlanır:

• cross_replica(replica_groups) if channel_id <= 0 and use_global_device_ids = false.
• cross_replica_and_partition(replica_groups) if channel_id > 0 and use_global_device_ids = false.
• flattened_ids(replica_groups) if channel_id > 0 and use_global_device_ids = true.

Ardından, her bir process_group içinde:

• process_group içindeki tüm receiver için operands...@receiver = [operand@sender for sender in process_group].
• process_group içindeki tüm process için results...@process = concatenate(operands...@process, all_gather_dim).

Girişler

Çıkışlar

Sınırlamalar

• (C1) 0 <= all_gather_dim < rank(operands...).
• (C2) is_unique(replica_groups).
• (C3) size(replica_groups) şu şekilde tanımlanır:
  • cross_replica kullanılıyorsa num_replicas
  • cross_replica_and_partition kullanılıyorsa num_replicas
  • flattened_ids kullanılıyorsa num_processes
• (C4) 0 <= replica_groups < size(replica_groups).
• (C5) use_global_device_ids = true ise channel_id > 0.
• (C6) type(results...) = type(operands...) hariç:
  • dim(results..., all_gather_dim) = dim(operands..., all_gather_dim) * dim(process_groups, 1).

Örnekler

// num_replicas: 2
// num_partitions: 1
// %operand0@(0, 0): [[1, 2], [3, 4]]
// %operand0@(1, 0): [[5, 6], [7, 8]]
// %operand1@(0, 0): [[11, 12], [13, 14]]
// %operand1@(1, 0): [[15, 16], [17, 18]]
%result:2 = "stablehlo.all_gather"(%operand0, %operand1) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<2x2xi64>, tensor<2x2xi64>) -> (tensor<2x4xi64>, tensor<2x4xi64>)
// %result0@(0, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
// %result0@(1, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
// %result1@(0, 0): [[11, 12, 15, 16], [13, 14, 17, 18]]
// %result1@(1, 0): [[11, 12, 15, 16], [13, 14, 17, 18]]

 Diğer örnekler

all_reduce

Anlam Bilimi

StableHLO işlem tablosundaki her işlem grubunda, her işlemden gelen operands tensörlerinin değerlerine bir indirgeme işlevi computation uygular ve results tensörleri üretir.

İşlem, StableHLO işlem ızgarasını process_groups olarak böler. Bu değer aşağıdaki şekilde tanımlanır:

• cross_replica(replica_groups) if channel_id <= 0 and use_global_device_ids = false.
• cross_replica_and_partition(replica_groups) if channel_id > 0 and use_global_device_ids = false.
• flattened_ids(replica_groups) if channel_id > 0 and use_global_device_ids = true.

Ardından, her bir process_group içinde:

• results...@process[result_index] = exec(schedule) bazı ikili ağaçlar için schedule. Burada:
  • exec(node) = computation(exec(node.left), exec(node.right)).
  • exec(leaf) = leaf.value.
• schedule, sıralı geçişi to_destination_type(operands...@process_group...[result_index], type(func_inputs(computation)[0])) olan, uygulamaya göre tanımlanmış bir ikili ağaçtır.

Girişler

Çıkışlar

Sınırlamalar

• (C1) is_unique(replica_groups).
• (C2) size(replica_groups) şu şekilde tanımlanır:
  • cross_replica kullanılıyorsa num_replicas
  • cross_replica_and_partition kullanılıyorsa num_replicas
  • flattened_ids kullanılıyorsa num_processes
• (C3) 0 <= replica_groups < size(replica_groups).
• (C4) use_global_device_ids = true ise channel_id > 0.
• (C5) computation, (tensor<E>, tensor<E>) -> (tensor<E>) türünde. Burada is_promotable(element_type(operand), E).
• (C6) shape(results...) = shape(operands...).
• (C7) element_type(results...) = E.

Örnekler

// num_replicas: 2
// num_partitions: 1
// %operand0@(0, 0): [1, 2, 3, 4]
// %operand0@(1, 0): [5, 6, 7, 8]
// %operand1@(0, 0): [9, 10, 11, 12]
// %operand1@(1, 0): [13, 14, 15, 16]
%result:2 = "stablehlo.all_reduce"(%operand0, %operand0) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
    "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xi64>, tensor<4xi64>) -> (tensor<4xi64>, tensor<4xi64>)
// %result0@(0, 0): [6, 8, 10, 12]
// %result0@(1, 0): [6, 8, 10, 12]
// %result1@(0, 0): [22, 24, 26, 28]
// %result1@(1, 0): [22, 24, 26, 28]

 Diğer örnekler

all_to_all

Anlam Bilimi

StableHLO işlem ızgarasındaki her işlem grubunda, operands tensörlerinin değerlerini split_dimension boyunca parçalara ayırır, ayrılan parçaları işlemler arasında dağıtır, dağıtılan parçaları concat_dimension boyunca birleştirir ve results tensörleri oluşturur. İşlem, StableHLO işlem ızgarasını process_groups olarak böler. Bu değer aşağıdaki şekilde tanımlanır:

• cross_replica(replica_groups) ise channel_id <= 0.
• cross_partition(replica_groups) ise channel_id > 0.

Ardından, her bir process_group içinde:

• split_parts...@sender = split(operands...@sender, split_count, split_dimension) process_group içindeki tüm sender için.
• scattered_parts...@receiver = [split_parts...@sender[receiver_index] for sender in process_group] where receiver_index = process_group.index(receiver).
• results...@process = concatenate(scattered_parts...@process, concat_dimension).

Girişler

Çıkışlar

Sınırlamalar

• (C1) 0 <= split_dimension < rank(operands...).
• (C2) dim(operands..., split_dimension) % split_count = 0.
• (C3) 0 <= concat_dimension < rank(operands...).
• (C4) 0 < split_count.
• (C5) is_unique(replica_groups).
• (C6) size(replica_groups) şu şekilde tanımlanır:
  • cross_replica kullanılıyorsa num_replicas
  • cross_partition kullanılıyorsa num_partitions
• (C7) 0 <= replica_groups < size(replica_groups).
• (C8) dim(replica_groups, 1) = split_count.
• (C9) type(results...) = type(operands...), split_dimension != concat_dimension koşulu hariç:
  • dim(results..., split_dimension) = dim(operands..., split_dimension) / split_count.
  • dim(results..., concat_dimension) = dim(operands..., concat_dimension) * split_count.

Örnekler

// num_replicas: 2
// num_partitions: 1
// %operand1@(0, 0): [[1, 2, 3, 4],
//                    [5, 6, 7, 8]]
// %operand1@(1, 0): [[9, 10, 11, 12],
//                    [13, 14, 15, 16]]
// %operand2@(0, 0): [[17, 18, 19, 20],
//                    [21, 22, 23, 24]]
// %operand2@(1, 0): [[25, 26, 27, 28],
//                    [29, 30, 31, 32]]
%result:2 = "stablehlo.all_to_all"(%operand1, %operand2) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
} : (tensor<2x4xi64>, tensor<2x4xi64>) -> (tensor<4x2xi64>, tensor<4x2xi64>)
// %result#0@(0, 0): [[1, 2], [5, 6], [9, 10], [13, 14]]
// %result#0@(1, 0): [[3, 4], [7, 8], [11, 12], [15, 16]]
// %result#1@(0, 0): [[17, 18], [21, 22], [25, 26], [29, 30]]
// %result#1@(1, 0): [[19, 20], [23, 24], [27, 28], [31, 32]]

 Diğer örnekler

ve

Anlam bilimi

lhs ve rhs tensörlerinin öğe bazında VE işlemini gerçekleştirir ve result tensörü oluşturur. Öğe türüne bağlı olarak aşağıdakileri yapar:

• Boole değerleri için: mantıksal VE.
• Tam sayılar için: bit düzeyinde VE.

Girişler

Çıkışlar

Sınırlamalar

• (C1) type(lhs) = type(rhs) = type(result).

Örnekler

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.and"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[1, 2], [3, 0]]

 Diğer örnekler

atan2

Anlam Bilimi

lhs ve rhs tensöründe öğe bazında atan2 işlemi gerçekleştirir ve result tensörü oluşturur. Öğe türüne bağlı olarak aşağıdakileri yapar:

• Kayan nokta sayıları için: IEEE-754'ten atan2.
• Karmaşık sayılar için: complex atan2.
• Kuantize edilmiş türler için: dequantize_op_quantize(atan2, lhs, rhs, type(result)).

Girişler

Çıkışlar

Sınırlamalar

• (C1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result).

Örnekler

// %lhs: [0.0, 1.0, -1.0]
// %rhs: [0.0, 0.0, 0.0]
%result = "stablehlo.atan2"(%lhs, %rhs) : (tensor<3xf64>, tensor<3xf64>) -> tensor<3xf64>
// %result: [0.0, 1.57079637, -1.57079637] // [0.0, pi/2, -pi/2]

 Diğer örnekler

batch_norm_grad

Anlam Bilimi

batch_norm_training'nın grad_output'den geri yayılım yapan çeşitli girişlerinin gradyanlarını hesaplar ve grad_operand, grad_scale ve grad_offset tensörlerini üretir. Daha resmi bir şekilde ifade etmek gerekirse bu işlem, Python söz dizimi kullanılarak mevcut StableHLO işlemlerine ayrıştırma olarak ifade edilebilir:

def compute_sum(operand, feature_index):
  (sum,) = reduce(
      inputs=[operand],
      init_values=[constant(0, element_type(operand))],
      dimensions=[i for i in range(rank(operand)) if i != feature_index],
      body=lambda x, y: add(x, y))
  return sum

def compute_mean(operand, feature_index):
  sum = compute_sum(operand, feature_index)
  divisor = constant(size(operand) / dim(operand, feature_index),
                     element_type(operand))
  divisor_bcast = broadcast_in_dim(divisor, [], type(sum))
  return divide(sum, divisor_bcast)

def batch_norm_grad(operand, scale, mean, variance, grad_output, epsilon, feature_index):
  # Broadcast inputs to type(operand)
  scale_bcast = broadcast_in_dim(scale, [feature_index], type(operand))
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  variance_bcast = broadcast_in_dim(variance, [feature_index], type(operand))
  epsilon_bcast = broadcast_in_dim(constant(epsilon, element_type(operand)), [],
                                   type(operand))

  # Perform normalization using the provided `mean` and `variance`
  # Intermediate values will be useful for computing gradients
  centered_operand = subtract(operand, mean_bcast)
  stddev = sqrt(add(variance_bcast, epsilon_bcast))
  normalized_operand = divide(centered_operand, stddev)

  # Use the implementation from batchnorm_expander.cc in XLA
  # Temporary variables have exactly the same names as in the C++ code
  elements_per_feature = broadcast_in_dim(
      constant(divide(size(operand), dim(operand, feature_index)),
               element_type(grad_output)),
      [], type(operand))
  i1 = multiply(grad_output, elements_per_feature)
  i2 = broadcast_in_dim(
      compute_sum(grad_output, feature_index), [feature_index], type(operand))
  i3 = broadcast_in_dim(
      compute_sum(multiply(grad_output, centered_operand), feature_index),
      [feature_index], type(operand))
  i4 = multiply(i3, centered_operand)
  i5 = divide(i4, add(variance_bcast, epsilon_bcast))
  i6 = subtract(subtract(i1, i2), i5)

  grad_operand =
      multiply(divide(divide(scale_bcast, stddev), elements_per_feature), i6)
  grad_scale =
      compute_sum(multiply(grad_output, normalized_operand), feature_index)
  grad_offset = compute_sum(grad_output, feature_index)

  return grad_operand, grad_scale, grad_offset

Kuantize edilmiş türler için dequantize_batch_norm_grad_or_training_quantize(lambda operand, scale, mean, variance, grad_output: batch_norm_grad(operand, scale, mean, variance, grad_output, epsilon, feature_index), operand, scale, mean, variance, grad_output, type(grad_operand), type(grad_scale), type(feature_index)) işlemini gerçekleştirir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) 0 <= feature_index < rank(operand).
• (C2) operand, scale, mean, variance, grad_output, grad_operand, grad_scale ve grad_offset aynı baseline_element_type'a sahiptir.
• (C3) operand, grad_output ve grad_operand aynı şekle sahip.
• (C4) scale, mean, variance, grad_scale ve grad_offset aynı şekle sahiptir.
• (C5) size(scale) = dim(operand, feature_index).

Örnekler

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %mean: [2.0, 3.0]
// %variance: [1.0, 1.0]
// %grad_output: [
//                [[0.1, 0.1], [0.1, 0.1]],
//                [[0.1, 0.1], [0.1, 0.1]]
//               ]
%grad_operand, %grad_scale, %grad_offset =
"stablehlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>,
     tensor<2x2x2xf64>) -> (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>)
// %grad_operand: [
//                 [[0.0, 0.0], [0.0, 0.0]],
//                 [[0.0, 0.0], [0.0, 0.0]]
//                ]
// %grad_scale:  [0.0, 0.0]
// %grad_offset: [0.4, 0.4]

batch_norm_inference

Anlam Bilimi

operand tensörünü, feature_index boyutu hariç tüm boyutlarda normalleştirir ve result tensörü üretir. Daha resmi bir şekilde, bu işlem Python söz dizimi kullanılarak mevcut StableHLO işlemlerine ayrıştırma olarak ifade edilebilir:

def batch_norm_inference(operand, scale, offset, mean, variance, epsilon, feature_index):
  # Broadcast inputs to shape(operand)
  scale_bcast = broadcast_in_dim(scale, [feature_index], type(operand))
  offset_bcast = broadcast_in_dim(offset, [feature_index], type(operand))
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  variance_bcast = broadcast_in_dim(variance, [feature_index], type(operand))
  epsilon_bcast = broadcast_in_dim(constant(epsilon, element_type(operand)), [],
                                   type(operand))

  # Perform normalization using the provided `mean` and `variance` instead of
  # computing them like `batch_norm_training` does.
  centered_operand = subtract(operand, mean_bcast)
  stddev = sqrt(add(variance_bcast, epsilon_bcast))
  normalized_operand = divide(centered_operand, stddev)
  return add(multiply(scale_bcast, normalized_operand), offset_bcast)

Kuantize edilmiş türler için dequantize_op_quantize(lambda operand, scale, offset, mean, variance: batch_norm_inference(operand, scale, offset, mean, variance, epsilon, feature_index), operand, scale, offset, mean, variance, type(result)) işlemini gerçekleştirir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) 0 <= feature_index < rank(operand).
• (C2) operand, scale, offset, mean, variance ve result aynı baseline_element_type'ye sahiptir.
• (C3) size(scale) = dim(operand, feature_index).
• (C4) size(offset) = dim(operand, feature_index).
• (C5) size(mean) = dim(operand, feature_index).
• (C6) size(variance) = dim(operand, feature_index).
• (C7) baseline_type(operand) = baseline_type(result).

Örnekler

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %offset: [1.0, 1.0]
// %mean: [2.0, 3.0]
// %variance: [1.0, 1.0]
%result = "stablehlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>) -> tensor<2x2x2xf64>
// %result: [
//           [[0.0, 0.0], [2.0, 2.0]],
//           [[2.0, 2.0], [0.0, 0.0]]
//          ]

batch_norm_training

Anlam Bilimi

feature_index boyutu hariç tüm boyutlarda ortalama ve varyansı hesaplar ve operand tensörünü normalleştirerek output, batch_mean ve batch_var tensörlerini oluşturur. Daha resmi bir şekilde ifade etmek gerekirse bu işlem, Python söz dizimi kullanılarak mevcut StableHLO işlemlerine ayrıştırma olarak ifade edilebilir:

def compute_mean(operand, feature_index):
  (sum,) = reduce(
      inputs=[operand],
      init_values=[constant(0, element_type(operand))],
      dimensions=[i for i in range(rank(operand)) if i != feature_index],
      body=lambda x, y: add(x, y))
  divisor = constant(size(operand) / dim(operand, feature_index),
                     element_type(operand))
  divisor_bcast = broadcast_in_dim(divisor, [], type(sum))
  return divide(sum, divisor_bcast)

def compute_variance(operand, feature_index):
  mean = compute_mean(operand, feature_index)
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  centered_operand = subtract(operand, mean_bcast)
  return compute_mean(mul(centered_operand, centered_operand), feature_index)

def batch_norm_training(operand, scale, offset, epsilon, feature_index):
  mean = compute_mean(operand, feature_index)
  variance = compute_variance(operand, feature_index)
  return batch_norm_inference(operand, scale, offset, mean, variance, epsilon,
                              feature_index),
         mean, variance

Kuantize edilmiş türler için dequantize_batch_norm_grad_or_training_quantize(lambda operand, scale, offset: batch_norm_training(operand, scale, offset, epsilon, feature_index), operand, scale, offset, type(output), type(batch_mean), type(batch_var)) işlemini gerçekleştirir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) 0 <= feature_index < rank(operand).
• (C2) operand, scale, offset, batch_mean, batch_var ve output aynı baseline_element_type'ye sahip.
• (C3) size(scale) = dim(operand, feature_index).
• (C4) size(offset) = dim(operand, feature_index).
• (C5) size(batch_mean) = dim(operand, feature_index).
• (C6) size(batch_var) = dim(operand, feature_index).
• (C7) baseline_type(output) = baseline_type(operand).

Örnekler

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %offset: [1.0, 1.0]
%output, %batch_mean, %batch_var = "stablehlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>) ->
    (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>)
// %output: [
//           [[0.0, 0.0], [2.0, 2.0]],
//           [[2.0, 2.0], [0.0, 0.0]]
//          ]
// %batch_mean: [2.0, 3.0]
// %batch_var: [1.0, 1.0]

bitcast_convert

Anlam bilimi

operand tensöründe bit yayınlama işlemi gerçekleştirir ve result tensörü oluşturur. Bu tensörde, operand tensörünün tamamındaki bitler result tensörünün türü kullanılarak yeniden yorumlanır.

Daha resmi bir ifadeyle, E = element_type(operand), E' = element_type(result) ve R = rank(operand) verildiğinde:

• num_bits(E') < num_bits(E) ise: bits(result[i0, ..., iR-1, :]) = bits(operand[i0, ..., iR-1]).
• num_bits(E') > num_bits(E) ise: bits(result[i0, ..., iR-2]) = bits(operand[i0, ..., iR-2, :]).
• num_bits(E') = num_bits(E) ise: bits(result[i0, ..., iR-1]) = bits(operand[i0, ..., iR-1]).

bits, belirli bir değerin bellek içi gösterimini döndürür ve tensörlerin tam gösterimi uygulamaya bağlı olduğundan ve öğe türlerinin tam gösterimi de uygulamaya bağlı olduğundan davranışı uygulamaya bağlıdır.

Girişler

Çıkışlar

Sınırlamalar

• (C1) E = is_quantized(operand) ? storage_type(operand) : element_type(operand), E' = is_quantized(result) ? storage_type(result) : element_type(result) ve R = rank(operand) değerleri verildiğinde:
  • num_bits(E') = num_bits(E) ise shape(result) = shape(operand).
  • Eğer num_bits(E') < num_bits(E):
  • rank(result) = R + 1.
  • dim(result, i) = dim(operand, i) tüm 0 <= i < R için.
  • dim(result, R) * num_bits(E') = num_bits(E).
  • Eğer num_bits(E') > num_bits(E):
  • rank(result) = R - 1.
  • dim(result, i) = dim(operand, i) tüm 0 <= i < R için.
  • dim(operand, R - 1) * num_bits(E) = num_bits(E').
• (C2) is_complex(operand) or is_complex(result) ise is_complex(operand) and is_complex(result).

Örnekler

// %operand: 0x0123456789ABCDEF
%result = "stablehlo.bitcast_convert"(%operand) : (tensor<f64>) -> tensor<4xf16>
// %result: [0xCDEF, 0x89AB, 0x4567, 0x0123] // little-endian representation

 Diğer örnekler

broadcast_in_dim

Anlam bilimi

operand tensöründeki verileri kopyalayarak giriş tensörünün boyutlarını ve/veya sıralamasını genişletir ve result tensörü oluşturur. Daha resmi bir ifadeyle, axes(operand) içindeki tüm d için result[result_index] = operand[operand_index]:

• operand_index[d] = 0 ise dim(operand, d) = 1.
• Aksi takdirde operand_index[d] = result_index[broadcast_dimensions[d]].

Girişler

Çıkışlar

Sınırlamalar

• (C1) element_type(result) tarafından verilir:
  • !is_per_axis_quantized(operand) ise element_type(operand).
  • element_type(operand) hariç olmak üzere quantization_dimension(operand), scales(operand) ve zero_points(operand), quantization_dimension(result), scales(result) ve zero_points(result)'den farklı olabilir. Aksi takdirde, sırasıyla.
• (C2) size(broadcast_dimensions) = rank(operand).
• (C3) 0 <= broadcast_dimensions < rank(result).
• (C4) is_unique(broadcast_dimensions).
• (C5) axes(operand) içindeki tüm d için:
  • dim(operand, d) = 1 veya
  • dim(operand, d) = dim(result, broadcast_dimensions[d]).
• (C6) is_per_axis_quantized(result) ise:
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)].
  • dim(operand, quantization_dimension(operand)) = 1 ise scales(result)[i] = scales(operand)[0] and zero_points(result)[i] = zero_points(operand)[0] for i in range(dim(result, quantization_dimension(result))).

Örnekler

// %operand: [
//            [1, 2, 3]
//           ]
%result = "stablehlo.broadcast_in_dim"(%operand) {
  broadcast_dimensions = array<i64: 2, 1>
} : (tensor<1x3xi32>) -> tensor<2x3x2xi32>
// %result: [
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ],
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ]
//          ]

 Diğer örnekler

kılıf

Anlam Bilimi

branches içindeki işlevlerden tam olarak birini index değerine bağlı olarak çalıştırıp çıkışı üretir. Daha resmi bir şekilde ifade etmek gerekirse, result = selected_branch() burada:

• selected_branch = branches[index] ise 0 <= index < size(branches).
• Aksi takdirde selected_branch = branches[-1].

Girişler

Çıkışlar

Sınırlamalar

• (C1) 0 < size(branches).
• (C2) input_types(branches...) = [].
• (C3) same(output_types(branches...)).
• (C4) type(results...) = output_types(branches[0]).

Örnekler

// %index: -1
// %result_branch0: [0, 0]
// %result_branch1: [1, 1]
%result0, %result1 = "stablehlo.case"(%index) ({
  "stablehlo.return"(%result_branch0, %result_branch0) : (tensor<2xi64>, tensor<2xi64>) -> ()
}, {
  "stablehlo.return"(%result_branch1, %result_branch1) : (tensor<2xi64>, tensor<2xi64>) -> ()
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)
// %result0: [1, 1]
// %result1: [1, 1]

 Diğer örnekler

cbrt

Anlam Bilimi

operand tensöründe öğe bazında küp kökü işlemi gerçekleştirir ve result tensörü oluşturur. Öğe türüne bağlı olarak aşağıdakileri yapar:

• Kayan nokta sayıları için: IEEE-754'ten rootn(x, 3).
• Karmaşık sayılar için: karmaşık küpkök.
• Kuantize edilmiş türler için: dequantize_op_quantize(cbrt, operand, type(result))

Girişler

Çıkışlar

Sınırlamalar

• (C1) baseline_type(operand) = baseline_type(result).

Örnekler

// %operand: [0.0, 1.0, 8.0, 27.0]
%result = "stablehlo.cbrt"(%operand) : (tensor<4xf64>) -> tensor<4xf64>
// %result: [0.0, 1.0, 2.0, 3.0]

 Diğer örnekler

ceil

Anlam Bilimi

operand tensörünün öğe bazında tavanını alır ve result tensörü oluşturur. IEEE-754 spesifikasyonundaki roundToIntegralTowardPositive işlemini uygular. Kuantize edilmiş türler için dequantize_op_quantize(ceil, operand, type(result)) işlemini gerçekleştirir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) baseline_type(operand) = baseline_type(result).

Örnekler

// %operand: [-0.8166, -0.2530, 0.2530, 0.8166, 2.0]
%result = "stablehlo.ceil"(%operand) : (tensor<5xf32>) -> tensor<5xf32>
// %result: [-0.0, -0.0, 1.0, 1.0, 2.0]

 Diğer örnekler

cholesky

Anlam bilimi

Bir grup matrisin Cholesky ayrıştırmasını hesaplar.

Daha resmi bir ifadeyle, index_space(result) içindeki tüm i için, result[i0, ..., iR-3, :, :], a[i0, ..., iR-3, :, :]'ün Cholesky ayrışımıdır ve alt üçgen (lower, true ise) veya üst üçgen (lower, false ise) matris biçimindedir. Karşı üçgendeki çıkış değerleri (sırasıyla kesin üst üçgen veya kesin alt üçgen) uygulamaya göre tanımlanır.

Giriş matrisinin Hermitian pozitif tanımlı matris olmadığı i varsa davranış tanımlanmamıştır.

Kuantize edilmiş türler için dequantize_op_quantize(lambda operand: cholesky(operand, lower), a, type(result)) işlemini gerçekleştirir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) baseline_type(a) = baseline_type(result).
• (C2) 2 <= rank(a).
• (C3) dim(a, -2) = dim(a, -1).

Örnekler

// %a: [
//      [1.0, 2.0, 3.0],
//      [2.0, 20.0, 26.0],
//      [3.0, 26.0, 70.0]
//     ]
%result = "stablehlo.cholesky"(%a) {
  lower = true
} : (tensor<3x3xf32>) -> tensor<3x3xf64>
// %result: [
//           [1.0, 0.0, 0.0],
//           [2.0, 4.0, 0.0],
//           [3.0, 5.0, 6.0]
//          ]

sıkıştırma

Anlam Bilimi

operand tensörünün her öğesini minimum ve maksimum değer arasında sıkıştırır ve result tensörü oluşturur. Daha resmi bir ifadeyle, result[result_index] = minimum(maximum(operand[result_index], min_element), max_element), burada min_element = rank(min) = 0 ? min[] : min[result_index], max_element = rank(max) = 0 ? max[] : max[result_index]. Kuantize edilmiş türler için dequantize_op_quantize(clamp, min, operand, max, type(result)) işlemi yapılır.

Karmaşık sayılara sıralama uygulamak şaşırtıcı bir anlambilim içerir. Bu nedenle, gelecekte bu işlem için karmaşık sayı desteğini kaldırmayı planlıyoruz (#560).

Girişler

Çıkışlar

Sınırlamalar

• (C1) rank(min) = 0 or shape(min) = shape(operand).
• (C2) rank(max) = 0 or shape(max) = shape(operand).
• (C3) baseline_element_type(min) = baseline_element_type(operand) = baseline_element_type(max).
• (C4) baseline_type(operand) = baseline_type(result).

Örnekler

// %min: [5, 10, 15]
// %operand: [3, 13, 23]
// %max: [10, 15, 20]
%result = "stablehlo.clamp"(%min, %operand, %max) : (tensor<3xi32>, tensor<3xi32>, tensor<3xi32>) -> tensor<3xi32>
// %result: [5, 13, 20]

 Diğer örnekler

collective_broadcast

Anlam bilimi

StableHLO işlem tablosundaki her işlem grubunda, kaynak işlemden hedef işlemlere operand tensörünün değerini gönderin ve result tensörü oluşturun.

İşlem, StableHLO işlem ızgarasını process_groups olarak böler. Bu değer aşağıdaki şekilde tanımlanır:

• cross_replica(replica_groups) ise channel_id <= 0.
• cross_partition(replica_groups) ise channel_id > 0.

Daha sonra result@process şu şekilde verilir:

• operand@process_groups[i, 0] varsa süreç i içinde yer alır.process_groups[i]
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) aksi takdirde.

Girişler

Çıkışlar

Sınırlamalar

• (C1) is_unique(replica_groups).
• (C2) 0 <= replica_groups < N burada N şu şekilde tanımlanır:
  • cross_replica kullanılıyorsa num_replicas
  • cross_partition kullanılıyorsa num_partitions
• (C3) type(result) = type(operand).

Örnekler

// num_replicas: 4
// num_partitions: 1
// %operand@(0, 0): [[1, 2]]
// %operand@(1, 0): [[3, 4]]
// %operand@(2, 0): [[5, 6]]
// %operand@(3, 0): [[7, 8]]
%result = "stablehlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[2, 1]]> : tensor<1x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor1x2xi64>) -> tensor<1x2xi64>
// %result@(0, 0): [[0, 0]]
// %result@(1, 0): [[5, 6]]
// %result@(2, 0): [[5, 6]]
// %result@(3, 0): [[0, 0]]

collective_permute

Anlam bilimi

StableHLO işlem ızgarasındaki her işlem grubunda, kaynak işlemden hedef işleme operand tensörünün değerini gönderir ve result tensörü oluşturur.

İşlem, StableHLO işlem ızgarasını process_groups olarak böler. Bu değer aşağıdaki şekilde tanımlanır:

• cross_replica(source_target_pairs) ise channel_id <= 0.
• cross_partition(source_target_pairs) ise channel_id > 0.

Daha sonra result@process şu şekilde verilir:

• operand@process_groups[i, 0], process_groups[i, 1] = process olacak şekilde bir i varsa.
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) aksi takdirde.

Girişler

Çıkışlar

Sınırlamalar

• (C1) dim(source_target_pairs, 1) = 2.
• (C2) is_unique(source_target_pairs[:, 0]).
• (C3) is_unique(source_target_pairs[:, 1]).
• (C4) 0 <= source_target_pairs < N, burada N şu şekilde tanımlanır:
  • cross_replica kullanılıyorsa num_replicas
  • cross_partition kullanılıyorsa num_partitions
• (C5) type(result) = type(operand).

Örnekler

// num_replicas: 3
// num_partitions: 1
// %operand@(0, 0): [[1, 2], [3, 4]]
// %operand@(1, 0): [[5, 6], [7, 8]]
// %operand@(2, 0): [[9, 10], [11, 12]]
%result = "stablehlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor<2x2xi64>) -> tensor<2x2xi64>
//
// %result@(0, 0): [[0, 0], [0, 0]]
// %result@(1, 0): [[1, 2], [3, 4]]
// %result@(2, 0): [[5, 6], [7, 8]]

 Diğer örnekler

karşılaştır

Anlam Bilimi

lhs ve rhs tensörlerini comparison_direction ve compare_type'ye göre öğe bazında karşılaştırır ve result tensörü oluşturur.

comparison_direction ve compare_type değerleri aşağıdaki anlamsal özelliklere sahiptir:

Boole ve tam sayı öğe türleri için:

• EQ: lhs = rhs.
• NE: lhs != rhs.
• GE: lhs >= rhs.
• GT: lhs > rhs.
• LE: lhs <= rhs.
• LT: lhs < rhs.

compare_type = FLOAT ile kayan nokta öğesi türleri için işlem, aşağıdaki IEEE-754 işlemlerini uygular:

• EQ: compareQuietEqual.
• NE: compareQuietNotEqual.
• GE: compareQuietGreaterEqual.
• GT: compareQuietGreater.
• LE: compareQuietLessEqual.
• LT: compareQuietLess.

compare_type = TOTALORDER ile kayan noktalı öğe türleri için işlem, IEEE-754'teki totalOrder ve compareQuietEqual işlemlerinin kombinasyonunu kullanır.

Karmaşık öğe türlerinde, sağlanan comparison_direction ve compare_type kullanılarak (real, imag) çiftlerinin sözlük sırasına göre karşılaştırması yapılır. Karmaşık sayılara sıralama uygulamak şaşırtıcı bir semantiğe yol açar. Bu nedenle, gelecekte comparison_direction değeri GE, GT, LE veya LT olduğunda karmaşık sayı desteğini kaldırmayı planlıyoruz (#560).

Kuantize edilmiş türler için dequantize_compare(lhs, rhs, comparison_direction) işlemini gerçekleştirir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) baseline_element_type(lhs) = baseline_element_type(rhs).
• (C2) shape(lhs) = shape(rhs) = shape(result).
• (C3) compare_type şu şekilde tanımlanır:
  • SIGNED ise is_signed_integer(element_type(lhs)).
  • UNSIGNED ise is_unsigned_integer(element_type(lhs)) or is_boolean(element_type(lhs)).
  • FLOAT veya TOTALORDER ise is_float(element_type(lhs)).
  • FLOAT ise is_complex(element_type(lhs)).

Örnekler

// %lhs: [1.0, 3.0]
// %rhs: [1.1, 2.9]
%result = "stablehlo.compare"(%lhs, %rhs) {
  comparison_direction = #stablehlo<comparison_direction LT>,
  compare_type = #stablehlo<comparison_type FLOAT>
} : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>
// %result: [true, false]

 Diğer örnekler

karmaşık

Anlam Bilimi

Gerçek ve hayali değerler çifti olan lhs ve rhs değerlerinden karmaşık bir değere öğe bazında dönüştürme işlemi gerçekleştirir ve result tensörünü oluşturur.

Girişler

Çıkışlar

Sınırlamalar

• (C1) type(lhs) = type(rhs).
• (C2) shape(result) = shape(lhs).
• (C3) element_type(result), E = element_type(lhs) olduğu durumlarda complex<E> türündedir.

Örnekler

// %lhs: [1.0, 3.0]
// %rhs: [2.0, 4.0]
%result = "stablehlo.complex"(%lhs, %rhs) : (tensor<2xf64>, tensor<2xf64>) -> tensor<2xcomplex<f64>>
// %result: [(1.0, 2.0), (3.0, 4.0)]

 Diğer örnekler

birleşik

Anlam bilimi

Diğer StableHLO işlemlerinden oluşan bir işlemi kapsar. inputs ve composite_attributes değerlerini alır ve results değerini üretir. İşlemin anlamı, decomposition özelliğiyle uygulanır. composite işlemi, program semantiğini değiştirmeden ayrıştırılmış haliyle değiştirilebilir. Ayrıştırmanın satır içine yerleştirilmesi aynı işlem semantiğini sağlamadığı durumlarda custom_call kullanmayı tercih edin.

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

Girişler

Çıkışlar

Sınırlamalar

• (C1) is_namespaced_op_name(name)
• (C2) is_defined_in_parent_scope(decomposition)
• (C3) types(inputs...) == input_types(decomposition)
• (C4) types(results...) == output_types(decomposition)

Örnekler

%results = "stablehlo.composite"(%input0, %input1) {
  name = "my_namespace.my_op",
  composite_attributes = {
    my_attribute = "my_value"
  },
  decomposition = @my_op,
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

 Diğer örnekler

birleştir

Anlam Bilimi

Verilen bağımsız değişkenlerle aynı sırada inputs boyutunda dimension boyutunu birleştirir ve result tensörü oluşturur. Daha resmi bir şekilde ifade etmek gerekirse, result[i0, ..., id, ..., iR-1] = inputs[k][i0, ..., kd, ..., iR-1], burada:

1. id = d0 + ... + dk-1 + kd.
2. d, dimension değerine eşittir ve d0, ... inputs öğesinin d. boyutunun boyutlarıdır.

Girişler

Çıkışlar

Sınırlamalar

• (C1) same(element_type(inputs...)).
• (C2) same(shape(inputs...)) hariç dim(inputs..., dimension).
• (C3) 0 < size(inputs).
• (C4) 0 <= dimension < rank(inputs[0]).
• (C5) element_type(result) = element_type(inputs[0]).
• (C6) shape(result) = shape(inputs[0]) şu durumlar hariç:
  • dim(result, dimension) = dim(inputs[0], dimension) + ....

Örnekler

// %input0: [[1, 2], [3, 4], [5, 6]]
// %input1: [[7, 8]]
%result = "stablehlo.concatenate"(%input0, %input1) {
  dimension = 0 : i64
} : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>
// %result: [[1, 2], [3, 4], [5, 6], [7, 8]]

 Diğer örnekler

sabit

Anlam Bilimi

Sabit bir value değerinden output tensörü oluşturur.

Girişler

Çıkışlar

Sınırlamalar

• (C1) type(value) = type(output).

Örnekler

%output = "stablehlo.constant"() {
  value = dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>
} : () -> tensor<2x2xf32>
// %output: [[0.0, 1.0], [2.0, 3.0]]

 Diğer örnekler

Dönüşüm gerçekleştirme

Anlam Bilimi

operand tensöründe bir öğe türünden diğerine öğe bazında dönüştürme işlemi gerçekleştirir ve result tensörü oluşturur.

boolean-to-any-supported-type (Boolean'dan desteklenen herhangi bir türe) dönüşümlerinde false değeri sıfıra, true değeri ise bire dönüştürülür. any-supported-type-to-boolean dönüşümlerinde sıfır değeri false, sıfır olmayan değerler ise true olarak dönüştürülür. Karmaşık türlerde bu işlemin nasıl çalıştığını öğrenmek için aşağıya bakın.

Tam sayıdan tam sayıya, tam sayıdan kayan noktalı sayıya veya kayan noktalı sayıdan kayan noktalı sayıya dönüşümlerde kaynak değer hedef türde tam olarak gösterilebiliyorsa sonuç değeri bu tam gösterimdir. Aksi takdirde davranış henüz belli değil (#180).

floating-point-to-integer dönüştürme işlemlerinde kesirli kısım kesilir. Kısaltılmış değer hedef türde gösterilemiyorsa davranış belirlenir (TBD) (#180).

Karmaşıktan karmaşığa dönüşüm, gerçek ve sanal kısımları dönüştürmek için kayan noktalıdan kayan noktalıya dönüşümlerle aynı davranışı izler.

Karmaşıktan diğer tüm türlere ve diğer tüm türlerden karmaşığa dönüşümlerde kaynak hayali değer yok sayılır veya hedef hayali değer sıfırlanır. Gerçek bölümün dönüştürülmesi, kayan nokta dönüştürmelerini izler.

Bu işlem, prensip olarak nicelikten arındırma (nicelikli tensörlerden normal tensörlere dönüştürme), niceliklendirme (normal tensörlerden nicelikli tensörlere dönüştürme) ve yeniden niceliklendirme (nicelikli tensörler arasında dönüştürme) işlemlerini ifade edebilir. Ancak şu anda bu işlemler için özel işlemlerimiz var: uniform_dequantize ilk kullanım alanı için, uniform_quantize ise ikinci ve üçüncü kullanım alanları için. Gelecekte bu iki işlem convert (#1576) içinde birleştirilebilir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) shape(operand) = shape(result).

Örnekler

// %operand: [-1, 0, 1]
%result = "stablehlo.convert"(%operand) : (tensor<3xi64>) -> tensor<3xcomplex<f64>>
// %result: [(-1.0, 0.0), (0.0, 0.0), (1.0, 0.0)]

 Diğer örnekler

konvolüsyon

Anlam Bilimi

lhs pencereleri ile rhs dilimleri arasındaki iç çarpımları hesaplar ve result üretir. Aşağıdaki şemada, result içindeki öğelerin lhs ve rhs değerlerinden nasıl hesaplandığı somut bir örnekle gösterilmektedir.

Daha resmi bir şekilde, lhs zaman aralıklarını ifade edebilmek için girişlerin lhs cinsinden aşağıdaki gibi yeniden çerçevelendiğini düşünün:

• lhs_window_dimensions = lhs_shape(dim(lhs, input_batch_dimension), dim(rhs, kernel_spatial_dimensions), dim(lhs, input_feature_dimension)).
• lhs_window_strides = lhs_shape(1, window_strides, 1).
• lhs_padding = lhs_shape([0, 0], padding, [0, 0]).
• lhs_base_dilations = lhs_shape(1, lhs_dilation, 1).
• lhs_window_dilations = lhs_shape(1, rhs_dilation, 1).

Bu yeniden çerçeveleme işleminde aşağıdaki yardımcı işlevler kullanılır:

• lhs_shape(n, hw, c) = permute([n] + hw + [c], [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension]).
• result_shape(n1, hw, c1) = permute([n1] + hw + [c1], [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension]).
• permute([j0, j1, ..., jR-1], permutation) = [i0, i1, ..., iR-1] / j[d] = i[permutation[d]].

feature_group_count = 1 ve batch_group_count = 1 ise index_space(dim(result, output_spatial_dimensions...)) içindeki tüm output_spatial_index için result[result_shape(:, output_spatial_index, :)] = dot_product olur. Burada:

• padding_value = constant(0, element_type(lhs)).
• padded_lhs = pad(lhs, padding_value, lhs_padding[:, 0], lhs_padding[:, 1], lhs_base_dilations - 1).
• lhs_window_start = lhs_shape(0, output_spatial_index, 0) * lhs_window_strides.
• lhs_window = slice(padded_lhs, lhs_window_start, lhs_window_start + lhs_window_dimensions, lhs_window_dilations).
• reversed_lhs_window = reverse(lhs_window, [input_spatial_dimensions[dim] for dim in range(size(window_reversal)) if window_reversal[dim] = true]). Bu özellik kullanılmıyor gibi görünüyor. Bu nedenle, gelecekte bu özelliği kaldırmayı planlıyoruz (#1181).
• dot_product = dot_general(reversed_lhs_window, rhs, lhs_batching_dimensions=[], lhs_contracting_dimensions=input_spatial_dimensions + [input_feature_dimension], rhs_batching_dimensions=[], rhs_contracting_dimensions=kernel_spatial_dimensions + [kernel_input_feature_dimension]).

Eğer feature_group_count > 1:

• lhses = split(lhs, feature_group_count, input_feature_dimension).
• rhses = split(rhs, feature_group_count, kernel_output_feature_dimension).
• results... = convolution(lhses..., rhses..., ..., feature_group_count=1, ...).
• result = concatenate(results, output_feature_dimension).

Eğer batch_group_count > 1:

• lhses = split(lhs, batch_group_count, input_batch_dimension).
• rhses = split(rhs, batch_group_count, kernel_output_feature_dimension).
• results... = convolution(lhses..., rhses..., ..., batch_group_count=1, ...).
• result = concatenate(results, output_feature_dimension).

Kuantize edilmiş türler için dequantize_op_quantize( lambda lhs, rhs: convolution(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, window_reversal, input_batch_dimension, input_feature_dimension, input_spatial_dimensions, kernel_input_feature_dimension, kernel_output_feature_dimension, kernel_spatial_dimensions, output_batch_dimension, output_feature_dimension, output_spatial_dimensions, feature_group_count, batch_group_count, precision_config), lhs, rhs, type(result)) işlemini gerçekleştirir.

Karma nicelenmiş türler için hybrid_dequantize_then_op( lambda lhs, rhs: convolution(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, window_reversal, input_batch_dimension, input_feature_dimension, input_spatial_dimensions, kernel_input_feature_dimension, kernel_output_feature_dimension, kernel_spatial_dimensions, output_batch_dimension, output_feature_dimension, output_spatial_dimensions, feature_group_count, batch_group_count, precision_config), lhs, rhs) işlemini gerçekleştirir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) N = rank(lhs) = rank(rhs).
• (C2) size(window_strides) = N - 2.
• (C3) 0 < window_strides.
• (C4) shape(padding) = [N - 2, 2].
• (C5) size(lhs_dilation) = N - 2.
• (C6) 0 < lhs_dilation.
• (C7) size(rhs_dilation) = N - 2.
• (C8) 0 < rhs_dilation.
• (C9) size(window_reversal) = N - 2.
• (C10) dim(lhs, input_batch_dimension) % batch_group_count = 0.
• (C11) dim(lhs, input_feature_dimension) % feature_group_count = 0.
• (C12) size(input_spatial_dimensions) = N - 2.
• (C13) input_dimensions = [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension] verildi:
  • is_unique(input_dimensions).
  • 0 <= input_dimensions < N.
• (C14) dim(rhs, kernel_input_feature_dimension) = dim(lhs, input_feature_dimension) / feature_group_count.
• (C15) dim(rhs, kernel_output_feature_dimension) % batch_group_count = 0.
• (C16) dim(rhs, kernel_output_feature_dimension) % feature_group_count = 0.
• (C17) size(kernel_spatial_dimensions) = N - 2.
• (C18) kernel_dimensions = kernel_spatial_dimensions + [kernel_input_feature_dimension] + [kernel_output_feature_dimension] verildi:
  • is_unique(kernel_dimensions).
  • 0 <= kernel_dimensions < N.
• (C19) size(output_spatial_dimensions) = N - 2.
• (C20) Verilen output_dimensions = [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension]:
  • is_unique(output_dimensions).
  • 0 <= output_dimensions < N.
• (C21) 0 < feature_group_count.
• (C22) 0 < batch_group_count.
• (C23) feature_group_count = 1 or batch_group_count = 1.
• (C24) size(precision_config) = 2.
• (C25) dim(result, result_dim) şu şekilde tanımlanır:
  • dim(lhs, input_batch_dimension) / batch_group_count ise result_dim = output_batch_dimension.
  • dim(rhs, kernel_output_feature_dimension) ise result_dim = output_feature_dimension.
  • Aksi takdirde num_windows, şu durumlarda:
  • output_spatial_dimensions[spatial_dim] = result_dim.
  • lhs_dim = input_spatial_dimensions[spatial_dim].
  • rhs_dim = kernel_spatial_dimensions[spatial_dim].
  • dilated_input_shape[lhs_dim] = dim(lhs, lhs_dim) = 0 ? 0 : (dim(lhs, lhs_dim) - 1) * lhs_dilation[spatial_dim] + 1.
  • padded_input_shape[lhs_dim] = padding[spatial_dim, 0] + dilated_input_shape[lhs_dim] + padding[spatial_dim, 1].
  • dilated_window_shape[lhs_dim] = dim(rhs, rhs_dim) = 0 ? 0 : (dim(rhs, rhs_dim) - 1) * rhs_dilation[spatial_dim] + 1.
  • is_empty_window[lhs_dim] = padded_input_shape[lhs_dim] = 0 || dilated_window_shape[lhs_dim] > padded_input_shape[lhs_dim].
  • num_windows = is_empty_window[lhs_dim] ? 0 : floor((padded_input_shape[lhs_dim] - dilated_window_shape[lhs_dim]) / window_strides[spatial_dim]) + 1.
• (C26) rank(result) = N.
• İşlemde nicelendirilmemiş tensörler kullanılıyorsa:
  • (C27) element_type(lhs) = element_type(rhs) = element_type(result).
• İşlemde nicel tensorlar kullanılıyorsa:
  • (C28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs).
  • (C29) is_per_axis_quantized(rhs) ise quantization_dimension(rhs) = kernel_output_feature_dimension.
  • (C30) is_per_axis_quantized(result) ise quantization_dimension(result) = output_feature_dimension.
  • Eğer is_quantized(lhs):
  • (C31) storage_type(lhs) = storage_type(rhs).
  • (C32) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result).
  • (C33) Eğer is_per_tensor_quantized(rhs) ise is_per_tensor_quantized(result).
  • Eğer !is_quantized(lhs):
  • (C34) element_type(lhs) = expressed_type(rhs) = element_type(result).

Örnekler

// %lhs: [[
//        [
//          [1], [2], [5], [6]
//        ],
//        [
//          [3], [4], [7], [8]
//        ],
//        [
//          [10], [11], [14], [15]
//        ],
//        [
//          [12], [13], [16], [17]
//        ]
//      ]]
//
// %rhs: [
//        [[[1]], [[1]], [[1]]],
//        [[[1]], [[1]], [[1]]],
//        [[[1]], [[1]], [[1]]]
//       ]
%result = "stablehlo.convolution"(%lhs, %rhs) {
  window_strides = array<i64: 4, 4>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = array<i64: 2, 2>,
  rhs_dilation = array<i64: 1, 1>,
  window_reversal = array<i1: false, false>,
  // In the StableHLO dialect, dimension numbers are encoded via:
  // `[<input dimensions>]x[<kernel dimensions>]->[output dimensions]`.
  // "b" is batch dimension, "f" is feature dimension,
  // "i" is input feature dimension, "o" is output feature dimension,
  // "0/1/etc" are spatial dimensions.
  dimension_numbers = #stablehlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  batch_group_count = 1 : i64,
  feature_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi64>, tensor<3x3x1x1xi64>) -> tensor<1x2x2x1xi64>
// %result: [[
//            [[10], [26]],
//            [[46], [62]]
//          ]]

 Diğer örnekler

kosinüs

Anlam bilimi

operand tensöründe öğe bazında kosinüs işlemi gerçekleştirir ve result tensörü oluşturur. Öğe türüne bağlı olarak aşağıdakileri yapar:

• Kayan nokta sayıları için: IEEE-754'ten cos.
• Karmaşık sayılar için: karmaşık kosinüs.
• Kuantize edilmiş türler için: dequantize_op_quantize(cosine, operand, type(result)).

Girişler

Çıkışlar

Sınırlamalar

• (C1) baseline_type(operand) = baseline_type(result).

Örnekler

// %operand: [
//            [0.0, 1.57079632],       // [0, pi/2]
//            [3.14159265, 4.71238898] // [pi, 3pi/2]
//           ]
%result = "stablehlo.cosine"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[1.0, 0.0], [-1.0, 0.0]]

 Diğer örnekler

count_leading_zeros

Anlam bilimi

operand tensordaki baştaki sıfır bitlerinin sayısını öğe bazında hesaplar ve result tensörü oluşturur.

Girişler

Çıkışlar

Sınırlamalar

• (C1) type(operand) = type(result).

Örnekler

// %operand: [[0, 1], [128, -1]]
%result = "stablehlo.count_leading_zeros"(%operand) : (tensor<2x2xi64>) -> tensor<2x2xi64>
// %result: [[64, 63], [56, 0]]

 Diğer örnekler

custom_call

Anlam bilimi

call_target_name ile tanımlanan, inputs ve called_computations alan ve results üreten bir işlemi kapsar. has_side_effect, backend_config ve api_version, ek uygulama tanımlı meta veriler sağlamak için kullanılabilir.

Şu anda bu işlem, XLA derleyicisindeki benzer işlemin organik gelişimini yansıtan, oldukça düzensiz bir meta veri koleksiyonu içeriyor. Gelecekte bu meta verileri birleştirmeyi planlıyoruz (#741).

Girişler

Çıkışlar

(XLA GPU Desteği) Özel custom_call hedefleri

buffer türleriyle ilgili üç özel call_target_name vardır: CreateBuffer başlatılmamış bir buffer oluşturur, Pin başlatılmış bir buffer oluşturur ve Unpin bir buffer'nin yerini kaldırıp buffer'nin içeriğini döndürür.

%uninitialized_buffer = "stablehlo.custom_call"() {
  call_target_name = "CreateBuffer",
  api_version = 4 : i32,
} : () -> memref<4xf64>

%initialized_buffer = "stablehlo.custom_call"(%init_value) {
  call_target_name = "Pin",
  api_version = 4 : i32,
} : (tensor<4xf64>) -> memref<4xf64>

%dealloc_buffer = "stablehlo.custom_call"(%initialized_buffer) {
  call_target_name = "Unpin",
  api_version = 4 : i32,
} : (memref<4xf64>) -> tensor<4xf64>

Takma ad

Bazı custom_call işlemleri, çıkışlarda bir bölümün ve işlenenlerde bir bölümün aynı belleği paylaşmasını gerektirebilir. Bu durum, output_operand_aliases ile ifade edilebilir. Bir takma ad çifti gösterimi, çıkış kısmını temsil eden çıkış demeti dizinlerinin bir listesinden ve işlenen kısmını temsil eden işlenen demeti dizinlerinin bir listesiyle birlikte bir operand_index'ten oluşur. İlgili tür bir tuple türü değilse çıkış veya işlenen demeti dizinlerinin listesi boştur ve rastgele iç içe yerleştirilmiş bir demet türü için rastgele uzun olabilir. Bu, XLA takma ad gösterimine benzer.

Bir takma ad çiftindeki çıkış kısmı ve giriş kısmı aynı türde olmalıdır. CreateBuffer, Pin ve Unpin'a yapılan çağrı olmayan özel çağrı işlemleri için buffer işleneni en fazla bir takma ad çiftinde görünebilir ve buffer çıkışı bir takma ad çiftinde görünmelidir.

Örnekler

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

%updated_buffer = "stablehlo.custom_call"(%buffer) {
  call_target_name = "Update",
  api_version = 4 : i32,
  output_operand_aliases = [
    #stablehlo.output_operand_alias<output_tuple_indices = [],
      operand_index = 0,
      operand_tuple_indices = []>]
} : (memref<4xf64>) -> memref<4xf64>

bölü

Anlam bilimi

Bölünen lhs ve bölen rhs tensörlerinin öğe bazında bölünmesini gerçekleştirir ve result tensörü oluşturur. Öğe türüne bağlı olarak aşağıdakileri yapar:

• Tam sayılar için: Kesir kısmı atılarak cebirsel bölümü üreten tam sayı bölme.
• Kayan nokta sayıları için: IEEE-754'ten division.
• Karmaşık sayılar için: karmaşık bölme.
• Kuantize edilmiş türler için:
  • dequantize_op_quantize(divide, lhs, rhs, type(result)).

Girişler

Çıkışlar

Sınırlamalar

• (C1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result).

Örnekler

// %lhs: [17.1, -17.1, 17.1, -17.1]
// %rhs: [3.0, 3.0, -3.0, -3.0]
%result = "stablehlo.divide"(%lhs, %rhs) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
// %result: [5.66666651, -5.66666651, -5.66666651, 5.66666651]

 Diğer örnekler

dot_general

Anlam Bilimi

lhs dilimleri ile rhs dilimleri arasındaki iç çarpımları hesaplar ve result tensörü oluşturur.

Daha resmi bir ifadeyle result[result_index] = dot_product, burada:

• lhs_result_dimensions = [d for d in axes(lhs) and d not in lhs_batching_dimensions and d not in lhs_contracting_dimensions].
• rhs_result_dimensions = [d for d in axes(rhs) and d not in rhs_batching_dimensions and d not in rhs_contracting_dimensions].
• result_batching_index + result_lhs_index + result_rhs_index = result_index burada size(result_batching_index) = size(lhs_batching_dimensions), size(result_lhs_index) = size(lhs_result_dimensions) ve size(result_rhs_index) = size(rhs_result_dimensions).
• transposed_lhs = transpose(lhs, lhs_batching_dimensions + lhs_result_dimensions + lhs_contracting_dimensions).
• transposed_lhs_slice = slice(transposed_lhs, result_batching_index + result_lhs_index + [:, ..., :]).
• reshaped_lhs_slice = reshape(transposed_lhs_slice, dims(lhs, lhs_contracting_dimensions)).
• transposed_rhs = transpose(rhs, rhs_batching_dimensions + rhs_result_dimensions + rhs_contracting_dimensions).
• transposed_rhs_slice = slice(transposed_rhs, result_batching_index + result_rhs_index + [:, ..., :]).
• reshaped_rhs_slice = reshape(transposed_rhs_slice, dims(rhs, rhs_contracting_dimensions)).
• dot_product = reduce( inputs=[multiply(reshaped_lhs_slice, reshaped_rhs_slice)], init_values=[constant(0, element_type(result))], dimensions=range(size(lhs_contracting_dimensions)), body=lambda x, y: add(x, y)).

Kuantize edilmiş türler için dequantize_op_quantize( lambda lhs, rhs: dot_general(lhs, rhs, lhs_batching_dimensions, rhs_batching_dimensions, lhs_contracting_dimensions, rhs_contracting_dimensions, precision_config), lhs, rhs, type(result)) işlemini gerçekleştirir.

Karma nicelenmiş türler için hybrid_dequantize_then_op( lambda lhs, rhs: dot_general(lhs, rhs, lhs_batching_dimensions, rhs_batching_dimensions, lhs_contracting_dimensions, rhs_contracting_dimensions, precision_config), lhs, rhs) işlemini gerçekleştirir.

precision_config, hız ile doğruluk arasındaki dengeyi kontrol eder. Bu, aşağıdakilerden biri olabilir (Şu anda bu enum değerlerinin semantiği yeterince belirtilmemiştir ancak #755 numaralı sorunda bu konuyu ele almayı planlıyoruz):

• DEFAULT: En hızlı hesaplama ancak orijinal sayıya en az doğru yaklaşım.
• HIGH: Daha yavaş hesaplama ancak orijinal sayıya daha doğru yaklaşım.
• HIGHEST: En yavaş hesaplama ancak orijinal sayıya en yakın tahmin.

DotAlgorithm, nokta işlemini uygulamak için kullanılan algoritmanın temel özelliklerini tanımlar. Bu özellikler, hassasiyeti de tanımlar. Algoritma özelliği alanları ayarlanırsa precision_config, DEFAULT olmalıdır. DotAlgorithms Varsayılan parametreler uygulamaya göre tanımlandığından varsayılan bir değere sahip değildir. Bu nedenle, tüm nokta algoritması alanları, boş bir nokta algoritması belirtmek için None olarak ayarlanabilir. Bu durumda, precision_config değeri kullanılır.

DotAlgorithm alanları şunlardır:

• lhs_precision_type ve rhs_precision_type, işlemin sol ve sağ tarafının yuvarlandığı duyarlılıklar. Kesinlik türleri, girişlerin ve çıkışın depolama türlerinden bağımsızdır.
• accumulation_type Birikim için kullanılan hassasiyet.
• lhs_component_count, rhs_component_count ve num_primitive_operations sol tarafı ve/veya sağ tarafı birden fazla bileşene ayıran ve bu değerler üzerinde birden fazla "ilkel" nokta işlemi yapan bir algoritma uyguladığımızda geçerlidir. Bu genellikle daha yüksek bir hassasiyeti taklit etmek için yapılır (ör. Yüksek Hassasiyetli Hesaplamalar İçin bfloat16 Yapay Zeka Veri Türünden Yararlanma: bf16_6x tf32_3x vb.). Ayrıştırma içermeyen algoritmalar için bu değerler 1 olarak ayarlanmalıdır.
• allow_imprecise_accumulation, bazı adımlarda (ör. CUBLASLT_MATMUL_DESC_FAST_ACCUM) daha düşük hassasiyette birikime izin verilip verilmeyeceğini belirtmek için kullanılır.

Örnek DotAlgorithm özellikleri:

// Inputs are casted to tf32, and then accumulated in f32:
{lhs_precision_type = tf32,
 rhs_precision_type = tf32,
 accumulation_type = f32,
 lhs_component_count = 1,
 rhs_component_count = 1,
 num_primitive_operations = 1,
 allow_imprecise_accumulation = false}


// bf16_6x: each input is decomposed to 3 bf16 components, then 6 dot operations are done on those components, and the result is accumulated in f32.
{lhs_precision_type = bf16,
 rhs_precision_type = bf16,
 accumulation_type = f32,
 lhs_component_count = 3,
 rhs_component_count = 3,
 num_primitive_operations = 6,
 allow_imprecise_accumulation = false}


// Inputs are (casted to) f8e5m2, and we accumulate in f32, but for some steps we may accumulate in lower precision.
{lhs_precision_type = f8e5m2,
 rhs_precision_type = f8e5m2,
 accumulation_type = f32,
 lhs_component_count = 1,
 rhs_component_count = 1,
 num_primitive_operations = 1,
 allow_imprecise_accumulation = true}

Hangi kombinasyonların destekleneceğine uygulamalar karar verir. Genel olarak, StableHLO tüketicisi tarafından her hızlandırıcı türünde her algoritmanın destekleneceği garanti edilmez. Belirli bir algoritma desteklenmiyorsa alternatif bir algoritma kullanılmak yerine hata verilmelidir. StableHLO doğrulaması, herhangi bir donanımda desteklendiği bilinmeyen algoritmaları engelleyerek en iyi çaba doğrulaması sağlar.

Desteklenen bazı algoritma değerleri için xla_data.proto > Algorithm bölümüne bakın. 2483 numaralı destek kaydı, arka uç tarafından desteklenen algoritmalarla ilgili merkezi bir doküman oluşturma planını içerir.

Girişler

Çıkışlar

Sınırlamalar

• (C1) size(lhs_batching_dimensions) = size(rhs_batching_dimensions).
• (C2) size(lhs_contracting_dimensions) = size(rhs_contracting_dimensions).
• (C3) is_unique(lhs_batching_dimensions + lhs_contracting_dimensions).
• (C4) is_unique(rhs_batching_dimensions + rhs_contracting_dimensions).
• (C5) 0 <= lhs_batching_dimensions < rank(lhs).
• (C6) 0 <= lhs_contracting_dimensions < rank(lhs).
• (C7) 0 <= rhs_batching_dimensions < rank(rhs).
• (C8) 0 <= rhs_contracting_dimensions < rank(rhs).
• (C9) dim(lhs, lhs_batching_dimensions...) = dim(rhs, rhs_batching_dimensions...).
• (C10) dim(lhs, lhs_contracting_dimensions...) = dim(rhs, rhs_contracting_dimensions...).
• (C11) size(precision_config) = 2.
• (C12) shape(result) = dim(lhs, lhs_batching_dimensions) + dim(lhs, lhs_result_dimensions) + dim(rhs, rhs_result_dimensions).
• İşlemde nicelendirilmemiş tensörler kullanılıyorsa:
  • (C13) element_type(lhs) = element_type(rhs).
• İşlemde nicel tensorlar kullanılıyorsa:
  • (C14) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs).
  • (C15) zero_points(rhs) = 0.
  • (C16) is_per_axis_quantized(rhs) ise quantization_dimension(rhs), rhs_contracting_dimensions içinde değil.
  • Eğer is_quantized(lhs):
  • (C17) storage_type(lhs) = storage_type(rhs).
  • (C18) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result).
  • (C19) Eğer is_per_tensor_quantized(rhs) ise is_per_tensor_quantized(result).
  • Eğer !is_quantized(lhs):
  • (C20) element_type(lhs) = expressed_type(rhs) = element_type(result).
• !is_empty_algorithm(lhs_precision_type, rhs_precision_type, accumulation_type, lhs_component_count, rhs_component_count, num_primitive_operations allow_imprecise_accumulation) ise:
  • (C21) precision_config... = DEFAULT.
  • (C22) 0 < lhs_component_count.
  • (C23) 0 < rhs_component_count.
  • (C24) 0 < num_primitive_operations.

Örnekler

// %lhs: [
//        [[1, 2],
//         [3, 4]],
//        [[5, 6],
//         [7, 8]]
//       ]
// %rhs: [
//        [[1, 0],
//         [0, 1]],
//        [[1, 0],
//         [0, 1]]
//       ]
%result = "stablehlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #stablehlo.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>],
  algorithm = #stablehlo.dot_algorithm<
    lhs_precision_type = tf32,
    rhs_precision_type = tf32,
    accumulation_type = f32,
    lhs_component_count = 1,
    rhs_component_count = 1,
    num_primitive_operations = 1,
    allow_imprecise_accumulation = false
  >
} : (tensor<2x2x2xi64>, tensor<2x2x2xi64>) -> tensor<2x2x2xi64>
// %result: [
//           [[1, 2],
//            [3, 4]],
//           [[5, 6],
//            [7, 8]]
//          ]

 Diğer örnekler

dynamic_broadcast_in_dim

Anlam bilimi

Bu işlem, işlevsel olarak broadcast_in_dim işlemine eşdeğerdir ancak sonuç şekli output_dimensions aracılığıyla dinamik olarak belirtilir.

İşlem, boyutların genişleme davranışı hakkında statik bilgileri ifade etmek için isteğe bağlı özellikler known_expanding_dimensions, known_nonexpanding_dimensions de kabul eder. Belirtilmezse tüm boyutların genişleyebileceği varsayılır.

Girişler

Çıkışlar

Sınırlamalar

• (C1) element_type(result) tarafından verilir:
  • !is_per_axis_quantized(operand) ise element_type(operand).
  • element_type(operand) hariç olmak üzere quantization_dimension(operand), scales(operand) ve zero_points(operand), quantization_dimension(result), scales(result) ve zero_points(result)'den farklı olabilir. Aksi takdirde, sırasıyla.
• (C2) size(broadcast_dimensions) = rank(operand).
• (C3) 0 <= broadcast_dimensions < rank(result).
• (C4) is_unique(broadcast_dimensions).
• (C5) axes(operand) içindeki tüm d için:
  • dim(operand, d) = 1 veya
  • dim(operand, d) = dim(result, broadcast_dimensions[d]).
• (C6) is_per_axis_quantized(result) ise:
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)].
  • dim(operand, quantization_dimension(operand)) = 1 ise scales(result)[i] = scales(operand)[0] and zero_points(result)[i] = zero_points(operand)[0] for i in range(dim(result, quantization_dimension(result))).
• (C7) size(output_dimensions) = rank(result).
• (C8) is_unique(known_expanding_dimensions + known_nonexpanding_dimensions).
• (C9) 0 <= known_expanding_dimensions < rank(operand).
• (C10) 0 <= known_nonexpanding_dimensions < rank(operand).

Örnekler

// %operand: [
//            [1, 2, 3]
//           ]
%operand = stablehlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = stablehlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "stablehlo.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>
// %result: [
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ],
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ]
//          ]

 Diğer örnekler

dynamic_conv

Anlam bilimi

Bu işlem, işlevsel olarak convolution op ile aynıdır ancak dolgu, padding aracılığıyla dinamik olarak belirtilir.

Girişler