StableHLO Özelliği

StableHLO, makine öğrenimi (ML) modellerindeki üst düzey işlemler (HLO) için bir işlem grubudur. StableHLO, farklı ML çerçeveleri ve ML derleyicileri arasında bir 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 (TensorFlow, JAX ve PyTorch gibi) ile makine öğrenimi derleyicileri (XLA ve IREE gibi) arasında daha fazla birlikte çalışabilirlik sağlayarak makine öğrenimi geliştirme sürecini basitleştirmek ve hızlandırmak. Bu amaçla, bu belgede StableHLO programlama dili için bir spesifikasyon sunulmaktadır.

Bu spesifikasyon üç ana bölümden oluşur. İlk olarak Programlar bölümünde, kendileri StableHLO işlemlerinden oluşan StableHLO işlevlerinden oluşan StableHLO programlarının yapısı açıklanmaktadır. Bu yapıda İşlemler bölümü, ayrı işlemlerin anlamlarını belirtir. Yürütme bölümü, bir programda birlikte yürütülen tüm bu işlemler için anlam sağlar. Son olarak Notasyon bölümünde, spesifikasyon boyunca kullanılan notasyon ele alınmaktadır.

StableHLO'nun önceki bir sürümüne ait spesifikasyonu görüntülemek için ilgili etiketlenmiş sürümde deposu açın. Örneğin, StableHLO v0.19.0 Spesifikasyonu. StableHLO'nun her küçük sürüm yükseltmesinde gerçekleşen 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ş (%image, %weights ve %bias) ve 1 çıkışa sahip bir @main işlevi içeren örnek bir program verilmiştir. İşlevin gövdesinde 6 işlem vardır.

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ı, giriş/çıkış ve bir gövdeye sahiptir. Gelecekte, HLO ile daha iyi uyumluluk elde etmek için işlevler için ek meta veriler sunmayı 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 vardır: 1) tüm tanımlayıcıların farklı tanımlayıcı türlerini ayırt eden eş değerleri vardır, 2) değer tanımlayıcıları StableHLO programlarının oluşturulmasını basitleştirmek için tamamen sayısal olabilir.

Türler

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

StableHLO türleri, StableHLO değerlerini temsil eden değer türleri (birinci sınıf türler olarak da bilinir) ve diğer program öğelerini tanımlayan değer olmayan türler olarak kategorize edilir. StableHLO türleri, birçok programlama dilindeki türlere benzer. Temel özelliği, bazı sıra dışı sonuçlara yol açan StableHLO'nun alana özgü yapısıdır (ör. skaler türler değer türleri değildir).

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

Tenör türleri, tenörleri (yani çok boyutlu dizileri) temsil eder. Bu öğelerin bir şekli ve öğe türü vardır. Şekle, 0 ile R-1 arasında numaralandırılan ve ilgili boyutların (eksenler olarak da bilinir) artan sırasına göre negatif olmayan veya bilinmeyen boyut boyutlarını temsil eder. Boyut sayısı R'e sıralama adı verilir. Örneğin tensor<2x3xf32>, 2x3 şekline ve f32 öğe türüne sahip bir tensör türüdür. 0. boyut ve 1. boyut olmak üzere iki boyutu (veya başka bir deyişle iki ekseni) vardır. Bu boyutların boyutları 2 ve 3'tür. Sıralaması 2.

Şekiller kısmen veya tamamen bilinmeyen (dinamik) olabilir. Örneğin, tensor<?x2xf64> kısmen bilinmiyor, tensor<?x?xf64> tamamen bilinmiyor. Dinamik boyut boyutları, ? kullanılarak gösterilir. Şekillerin sıralaması geri alınamaz.

Gelecekte, tensör türlerini boyut boyutlarının ve öğe türlerinin ötesine genişleterek, örneğin düzenler (#629) ve seyreklik (#1078) eklemeyi 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

Kantitatif öğe türleri, storage_min ile storage_max arasındaki (dahil) aralıkta bir depolama türü tam sayı değerlerini temsil eder. Bu değerler, ifade edilen tür kayan nokta değerlerine karşılık gelir. 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 değerine nicelleştirme parametreleri denir. storage_min ve storage_max dil bilgisinde isteğe bağlıdır ancak sırasıyla min_value(storage_type) ve max_value(storage_type) varsayılan değerlerine sahiptir. Ölçülmüş öğ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 sabit olsa da çarpanlar ve kaydırmalarla temsil edilen tam sayıya dayalı ölçeklere yönelik güçlü bir ilgi var. Bu özelliği yakın gelecekte araştırmayı planlıyoruz (#1404).

Tür, değerler ve kesikli bir tensör türünde yalnızca bir veya birden fazla sıfır noktası bulunup bulunamayacağı da dahil olmak üzere QuantizationZeroPoint'ün semantiği hakkında devam eden bir tartışma var. Bu tartışmanın sonuçlarına göre, sıfır noktayla ilgili spesifikasyon gelecekte değişebilir (#1405).

Devam eden bir diğer tartışma, bu değerlere ve kesikli tenzorların değerlerine herhangi bir kısıtlama uygulanıp uygulanmayacağını belirlemek için QuantizationStorageMin ve QuantizationStorageMax'nin semantiğiyle ilgilidir (#1406).

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

Kantitatifleştirilmiş tenör türleri, kantitatifleştirilmiş öğelere sahip tenörleri temsil eder. Bu tensörler, öğelerinin normal öğe türleri yerine kesikli öğe türlerine sahip olması dışında normal tensörlerle tamamen aynıdır.

Kesirli tensörlerde kesirli sayım tensör başına olabilir. Bu durumda, tensörün tamamı için bir scale ve zero_point bulunur. Kesirli sayım eksen başına da olabilir. Bu durumda, belirli bir boyut quantization_dimension'nin dilimi başına bir çift olmak üzere birden fazla scales ve zero_points bulunur. Daha resmi bir ifadeyle, eksen başına kesme işlemi uygulanmış bir t tensörde quantization_dimension'nin dim(t, quantization_dimension) dilimi vardır: t[:, ..., 0, ..., :], t[:, ..., 1, ..., :] vb. i. dilimdeki tüm öğeler, kesme parametreleri olarak scales[i] ve zero_points[i] kullanır. Ölçülmüş tenör türleri aşağıdaki kısıtlamalara sahiptir:

• Tensör başına kesme için:
  • Ek kısıtlama yoktur.
• Eksen başına kesme 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 üretilen ve tüketilen opak değerleri) 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}]

Tuple türleri, grupları (heterojen listeler) temsil eder. Tuplar, yalnızca HLO ile uyumluluk için mevcut olan eski bir özelliktir. HLO'da, değişken sayıda giriş ve çıkışı temsil etmek için kümeler kullanılır. StableHLO'da değişken girişler ve çıkışlar doğal olarak desteklenir. StableHLO'da tupların 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 StableHLO'dan tuple türlerini kaldırmamıza olanak tanıyabilecek değişiklikler yapmayı planlıyoruz (#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, StableHLO programlarının bu türlerin değerlerini doğrudan temsil edemeyeceği anlamına gelir (sonuç olarak, T türündeki skaler değerleri tensor<T> türündeki 0 boyutlu tenör değerleriyle temsil etmek idiomatiktir).

• Boole türü, true ve false boole değerlerini temsil eder.
• Tam sayı türleri, imzalı (si) veya imzasız (ui) olabilir ve desteklenen bit genişliklerinden birine (2, 4, 8, 16, 32 veya 64) sahip olabilir. İmzalı siN türleri, -2^(N-1) ile 2^(N-1)-1 dahil arasındaki tam sayı değerlerini, imzasız uiN türleri ise 0 ile 2^N-1 dahil arasındaki tam sayı değerlerini temsil eder.
• Kayan nokta türleri aşağıdakilerden biri olabilir:
  • f8E3M4, f8E4M3 ve f8E5M2 8 bitlik kayan nokta numaraları (IEEE-754 kurallarına uygun).
  • Derin Öğrenme için FP8 Biçimleri bölümünde açıklanan FP8 biçiminin sırasıyla E4M3 ve E5M2 kodlamalarına karşılık gelen f8E4M3FN ve f8E5M2 türleri.
  • Derin Sinir Ağları için 8 Bit Sayısal Biçimler bölümünde açıklanan FP8 biçimlerinin E4M3 ve E5M2 kodlamalarına karşılık gelen f8E4M3FNUZ ve f8E5M2FNUZ türleri.
  • Derin Nöral Ağlar için Karma 8 Bitlik Kayan Nokta (HFP8) Eğitimi ve Tahmini bölümünde açıklanan FP8 biçimlerinin E4M3 kodlamasına karşılık gelen f8E4M3B11FNUZ türü.
  • BFloat16: Cloud TPU'larda yüksek performansın sırrı başlıklı makalede açıklanan bfloat16 biçimine karşılık gelen bf16 türü.
  • IEEE 754 standardında açıklanan binary16 ("yarım hassasiyet"), binary32 ("tek hassasiyet") ve binary64 ("çift hassasiyet") biçimlerine karşılık gelen f16, f32 ve f64 türleri.
  • tf32 türü, TensorFloat32 biçimine karşılık gelir ve StableHLO'da sınırlı destek alır.
  • OCP Mikro Ölçeklendirme Biçimleri Spesifikasyonu'nda açıklanan f4E2M1FN, f6E2M3FN, f6E3M2FN ve f8E8M0FNU MX (mikro ölçeklendirme) türleri.
• Karmaşık türler, aynı öğe türünde reel bir bölüme ve sanal bir bölüme sahip 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) türleridir.

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

İşlev türleri hem adlandırılmış hem de anonim işlevleri temsil eder. Bunlar giriş türlerine (->'ün sol tarafındaki tür listesi) ve çıkış türlerine (->'ün sağ tarafındaki tür listesi) sahiptir. Birçok programlama dilinde işlev türleri birinci sınıftır ancak StableHLO'da değildir.

StringType ::= 'string'

Dize türü, bayt dizilerini temsil eder. Birçok programlama dilinin aksine, dize türü StableHLO'da 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 bilinir), makine öğrenimi modellerindeki kapalı bir üst düzey işlem grubunu temsil eder. Yukarıda da belirtildiği gibi, StableHLO söz dizimi büyük ölçüde MLIR'den esinlenmiştir. MLIR her zaman en ergonomik alternatif olmasa da StableHLO'nun ML çerçeveleri ile ML derleyicileri arasında daha fazla birlikte çalışabilirlik oluşturma hedefine en uygun seçenektir.

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

StableHLO işlemleri (işlemler olarak da bilinir) bir ada, giriş/çıkışa ve imzaya sahiptir. Ad, stablehlo. ön eki ve desteklenen işlemlerden birini benzersiz şekilde tanımlayan bir hatırlatıcıdan oluşur. Desteklenen tüm işlemlerin kapsamlı bir listesini aşağıda bulabilirsiniz.

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

İşlemler girişler tüketir ve çıktılar oluşturur. 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ığı için statik olarak sağlanır) ve giriş özellikleri (ayrıca statik olarak sağlanır) olarak sınıflandırılır. Bir işlem tarafından tüketilen ve üretilen giriş ve çıkışların türü, o işlemin anımsatıcısına bağlıdır. Örneğin, add op 2 giriş değeri tüketir ve 1 çıkış değeri oluşturur. Buna karşılık, 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 bilinir), adlandırılmış işlevlere çok benzer. Bununla birlikte, aşağıdakiler dışında adlandırılmış işlevlere benzerler: 1) Tanımlayıcıları yoktur (bu nedenle "anonim" adı kullanılır), 2) Çıkış türlerini belirtmezler (Çıkış türleri, işlev içindeki return op'sinden anlaşılır).

Giriş işlevlerinin söz dizimi, şu anda kullanılmayan bir kısmı (yukarıdaki Unused üretimine bakın) içeriyor. Bu parça MLIR ile uyumludur. MLIR'de, atlama işlemleri aracılığıyla birbirine bağlı birden fazla işlem "bloğu" içerebilen daha genel bir "bölge" kavramı vardır. Bu blokların, birbirinden ayırt edilebilmesi için Unused üretimine karşılık gelen kimlikleri vardır. StableHLO'da atlama işlemleri olmadığından MLIR söz dizesinin ilgili kısmı kullanılmaz (ancak yine de mevcuttur).

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

Giriş özelliklerinin bir adı ve desteklenen sabit değerlerinden biri olan bir değeri vardır. 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 için start_indices ve limit_indices gibi birden fazla özellik kullanır.

Şu anda kullanımdaki StableHLO programları bazen bu dokümanda açıklanmayan özellikler içeriyor. Gelecekte bu özellikleri StableHLO işletim sistemine dahil etmeyi veya StableHLO programlarında görünmelerini yasaklamayı planlıyoruz. Bu sırada, 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ür listesi) ve tüm çıkış değerlerinin türlerinden (->'nin sağ tarafındaki tür listesi) oluşur. Giriş türleri ve çıkış türleri genellikle gereksizdir (çünkü çoğu StableHLO işleminde çıkış türleri girişlerden çıkarılabilir). Yine de op türü, MLIR ile uyumluluk için StableHLO söz dizesinin bir parçası olarak bilinçli olarak tasarlanmıştır.

Aşağıda, select_and_scatter kısaltması 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) tüketir. İşlemin imzasının yalnızca giriş değerlerinin türlerini içerdiğini (ancak satır içi olarak sağlanan giriş işlevlerinin ve özelliklerin türlerini içermediğini) unutmayın.

%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 ve bir türe sahiptir. Türü, açık olmadığı durumlar hariç (ör. doğru/yanlış sabitinin türü açıkça i1 iken tam sayı sabitinin birden fazla olası türü olabilir) genellikle sabit söz dizesinin bir parçasıdır.

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

Boole sabitleri, true ve false boole değerlerini temsil eder. Boole sabitleri i1 türüne sahiptir.

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

Tam sayı sabitleri, ondalık veya onaltılık gösterim kullanan dizeler aracılığıyla tam sayı 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, temel bitleri ilgili türün kayan nokta biçiminde doğrudan belirtmek için de kullanılabilir. Kayan noktalı sabitler 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 (ilk sırada gelir) ve sanal kısım (ikinci sırada gelir) listelerini kullanarak karmaşık değerleri temsil eder. Örneğin, (1.0, 0.0) : complex<f32>, 1.0 + 0.0i'u, (0.0, 1.0) : complex<f32> ise 0.0 + 1.0i'ı temsil eder. Bu parçaların bellekte depolanma sırası, uygulamaya göre belirlenir. Karmaşık sabitler aşağıdaki kısıtlamalara sahiptir:

• (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österimi ile belirtilen iç içe geçmiş listeleri kullanan tensör değerlerini temsil eder. Örneğin dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>, dizinlerden öğelere yapılan aşağıdaki eşlemeyle 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 bellekte depolanma sırası, uygulamaya göre belirlenir. Tensör 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) '>'

Nicelleştirilmiş tensör sabitleri, tensör sabitleriyle aynı gösterimi kullanan nicelenmiş tensör değerlerini temsil eder ve öğeler, depolama türlerinin sabitleri olarak belirtilir. Ölçülmüş tenö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 sabit değerleri, ASCII karakterleri ve kaçış dizileri kullanılarak belirtilen baytlardan oluşur. Kodlamaya duyarlı değildirler. Bu nedenle, bu baytların yorumlanması uygulamaya göre belirlenir. Dize değişmezleri string türüne sahiptir.

İşlemler

abs

Anlam

operand tensörü üzerinde öğe düzeyinde abs işlemi gerçekleştirir ve result tensörü üretir. Öğe türüne bağlı olarak aşağıdakileri yapar:

• İmzalı tam sayılar için: tamsayı modülü.
• Kayan reklamlar için: IEEE-754'ten abs.
• Karmaşık sayılar için: karmaşık modül.
• Miktarlanmış 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:
  • is_complex(operand) ise complex_element_type(element_type(operand)).
  • Aksi takdirde baseline_element_type(operand) değerini alır.

Örnekler

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

Diğer Örnekler

add

Anlam bilimi

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

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

Girişler

Çıkışlar

Sınırlamalar

• İşlemde kesirli olmayan tenzorlar kullanılıyorsa:
  • (C1) type(lhs) = type(rhs) = type(result).
• İşlemde kesirli tenzorlar 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

inputs değerini üreten işlemlerin, result değerine bağlı tüm 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 vardı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 ızgarasındaki her işlem grubunda, all_gather_dim boyunca her işlemden alınan operands tenzorlarının değerlerini birleştirir ve results tenzorları oluşturur.

İşlem, StableHLO işlem ızgarasını aşağıdaki gibi tanımlanan process_groups olarak böler:

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

Ardından her bir process_group içinde:

• process_group adlı kuruluş biriminde tüm receiver için operands...@receiver = [operand@sender for sender in process_group].
• process_group kapsamındaki 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 ızgarasındaki her işlem grubunda, her işlemdeki operands tenörlerinin değerlerine bir azaltma işlevi computation uygular ve results tenörü oluşturur.

İşlem, StableHLO süreç ızgarasını şu şekilde tanımlanan process_groups şeklinde ayırır:

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

Ardından her bir process_group içinde:

• results...@process[result_index] = exec(schedule) için bazı ikili ağaç schedule şöyledir:
  • exec(node) = computation(exec(node.left), exec(node.right)).
  • exec(leaf) = leaf.value.
• schedule, sıralı traversal'ı to_destination_type(operands...@process_group...[result_index], type(func_inputs(computation)[0])) olan, uygulama tanımlı 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, is_promotable(element_type(operand), E) olduğunda (tensor<E>, tensor<E>) -> (tensor<E>) türüne sahiptir.
• (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 tenzorlarının 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 tenzorları oluşturur. İşlem, StableHLO işlem ızgarasını aşağıdaki gibi tanımlanan process_groups olarak böler:

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

Daha sonra, her process_group içinde:

• process_group adlı kuruluş biriminde tüm sender için split_parts...@sender = split(operands...@sender, split_count, split_dimension)
• scattered_parts...@receiver = [split_parts...@sender[receiver_index] for sender in process_group] burada 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) split_dimension != concat_dimension ise type(results...) = type(operands...) dışında:
  • 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

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

• Boolelar için: mantıksal VE.
• Tam sayılar için: bit tabanlı 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 bir result tensörü oluşturur. Öğe türüne bağlı olarak aşağıdakileri yapar:

• Kayan reklamlar için: IEEE-754'ten atan2.
• Karmaşık sayılar için: karmaşık atan2.
• Kesirli 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

grad_output'dan geri yayılan batch_norm_training girişlerinin gradyanlarını hesaplar ve grad_operand, grad_scale ve grad_offset tensörlerini oluşturur. Daha resmi bir ifadeyle bu işlem, Python söz dizimi kullanılarak mevcut StableHLO işlemlerine aşağıdaki şekilde ayrılarak 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

Miktarı ölçülmüş türlerde, 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)) 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 değerine sahiptir.
• (C3) operand, grad_output ve grad_operand aynı şekle sahiptir.
• (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

operand tensörünü feature_index boyutu hariç tüm boyutlarda normalize eder ve bir result tensörü oluşturur. Daha resmi bir ifadeyle bu işlem, Python söz dizimini kullanarak mevcut StableHLO işlemlerinin bir ayrışımı olarak şu şekilde 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)

Miktarı belirlenmiş 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 değerine 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 tenzorunu normalleştirerek output, batch_mean ve batch_var tenzorlarını oluşturur. Daha resmi bir ifadeyle, bu işlem aşağıdaki gibi 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

Miktarı ölçülmüş türlerde, 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)) 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 değerine sahiptir.
• (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 bir bit yayınlama işlemi gerçekleştirir ve operand tenörünün tümünün bitlerinin result tenörünün türü kullanılarak yeniden yorumlandığı bir result tensörü oluşturur.

Daha resmi bir ifadeyle, E = element_type(operand), E' = element_type(result) ve R = rank(operand) için:

• 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 bellekteki temsilini döndürür. Tensörlerin tam temsilinin uygulama tanımlı olması ve öğe türlerinin tam temsilinin de uygulama tanımlı olması nedeniyle bu davranışı uygulama tanımlı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) çerçevesinde:
  • num_bits(E') = num_bits(E) ise shape(result) = shape(operand).
  • num_bits(E') < num_bits(E) ise:
  • rank(result) = R + 1.
  • dim(result, i) = dim(operand, i) için 0 <= i < R.
  • dim(result, R) * num_bits(E') = num_bits(E).
  • num_bits(E') > num_bits(E) ise:
  • rank(result) = R - 1.
  • dim(result, i) = dim(operand, i) için 0 <= i < R.
  • 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

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

• dim(operand, d) = 1 ise operand_index[d] = 0.
• Aksi takdirde operand_index[d] = result_index[broadcast_dimensions[d]] değerini alır.

Girişler

Çıkışlar

Sınırlamalar

• (C1) element_type(result) şu şekilde hesaplanır:
  • !is_per_axis_quantized(operand) ise element_type(operand).
  • element_type(operand), ancak quantization_dimension(operand), scales(operand) ve zero_points(operand) sırasıyla quantization_dimension(result), scales(result) ve zero_points(result)'den farklı olabilir.
• (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

index değerine bağlı olarak branches içinden tam olarak bir işlevin yürütülmesiyle elde edilen çıktıyı oluşturur. Daha resmi bir ifadeyle, result = selected_branch() burada:

• 0 <= index < size(branches) ise selected_branch = branches[index].
• Aksi takdirde selected_branch = branches[-1] değerini alır.

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ü üzerinde öğe tabanlı kübik kök işlemi gerçekleştirir ve result tensörü üretir. Öğe türüne bağlı olarak aşağıdakileri yapar:

• Kayan noktalı sayılar için: IEEE-754'ten rootn(x, 3).
• Karmaşık sayılar için: karmaşık küp kökü.
• Kesirli 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 tenzorunun öğe bazında üst sınırını gerçekleştirir ve bir result tenzoru oluşturur. IEEE-754 spesifikasyonundaki roundToIntegralTowardPositive işlemini uygular. Miktarı belirlenmiş 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

Bir dizi matrisin Cholesky ayrışması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 alt üçgen (lower true ise) veya üst üçgen (lower false ise) matris biçiminde Cholesky ayrışımıdır. Karşıt üçgendeki çıkış değerleri (ör. katı üst üçgen veya buna karşılık gelen katı alt üçgen) uygulama tanımlıdır.

Girdi matrisinin Hermitian pozitif tanımlı bir matrisi olmadığı i varsa davranış tanımsızdır.

Miktarı ölçülmüş türlerde, dequantize_op_quantize(lambda operand: cholesky(operand, lower), a, type(result)) 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]
//          ]

kelepçe

Anlam bilimi

operand tenzorunun her bir öğesini minimum ve maksimum değer arasında sıkıştırır ve bir result tenzoru 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]. Nicel türlerde dequantize_op_quantize(clamp, min, operand, max, type(result)) olarak performans gösterir.

Karmaşık sayılara sıralama uygulamak şaşırtıcı anlamlar içerir. Bu nedenle, gelecekte bu işlem için karmaşık sayılar 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 ızgarasındaki her işlem grubunda, operand tenzorunun değerini kaynak işlemden hedef işlemlere gönderin ve bir result tenzoru oluşturun.

İşlem, StableHLO işlem ızgarasını aşağıdaki gibi tanımlanan process_groups olarak böler:

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

Ardından result@process şu şekilde hesaplanır:

• operand@process_groups[i, 0], işlem process_groups[i] içinde olduğunda 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) 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, operand tensörü değeri kaynak işlemden hedef işleme gönderilir ve bir result tensörü üretir.

İşlem, StableHLO işlem ızgarasını aşağıdaki gibi tanımlanan process_groups olarak böler:

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

Ardından result@process şu şekilde hesaplanır:

• operand@process_groups[i, 0] (process_groups[i, 1] = process gibi 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 tenörlerinin comparison_direction ve compare_type'e göre öğe bazında karşılaştırmasını yapar ve bir result tenörü oluşturur.

comparison_direction ve compare_type değerleri şu anlamlara 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 içeren kayan nokta öğe türleri için op, aşağıdaki IEEE-754 işlemlerini uygular:

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

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

Karmaşık öğe türleri için, sağlanan comparison_direction ve compare_type kullanılarak (real, imag) çiftlerinin alfabetik karşılaştırması yapılır. Karmaşık sayılara sıralama uygulamak şaşırtıcı anlamlar içerir. Bu nedenle, gelecekte comparison_direction GE, GT, LE veya LT olduğunda karmaşık sayı desteğini kaldırmayı planlıyoruz (#560).

Kesirli 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:
  • is_signed_integer(element_type(lhs)) ise SIGNED.
  • is_unsigned_integer(element_type(lhs)) or is_boolean(element_type(lhs)) ise UNSIGNED.
  • is_float(element_type(lhs)) ise FLOAT veya TOTALORDER.
  • is_complex(element_type(lhs)) ise FLOAT.

Ö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

Gerçek ve sanal değerlerden (lhs ve rhs) oluşan iki değerden karmaşık bir değere öğe düzeyinde dönüştürme gerçekleştirir ve bir result tensörü üretir.

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ğunda complex<E> türünde.

Ö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

inputs ve composite_attributes'yi alıp results üreterek diğer StableHLO işlemlerinden oluşan bir işlemi kapsar. Op'nin semantikleri decomposition özelliği tarafından uygulanır. composite işlemi, program semantiklerini değiştirmeden ayrıştırmasıyla değiştirilebilir. Ayrıştırmanın satır içi olarak yerleştirilmesinin aynı işlem semantiğini sağlamadığı durumlarda custom_call kullanmayı tercih edin.

version alanı (varsayılan olarak 0 değerine ayarlanır), bileşenin anlamının 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ştirmek

Anlam

inputs öğesini, belirtilen bağımsız değişkenlerle aynı sırada dimension boyutu boyunca birleştirir ve bir result tensörü oluşturur. Daha resmi bir ifadeyle, result[i0, ..., id, ..., iR-1] = inputs[k][i0, ..., kd, ..., iR-1], burada:

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

Girişler

Çıkışlar

Sınırlamalar

• (C1) same(element_type(inputs...)).
• (C2) dim(inputs..., dimension) hariç same(shape(inputs...)).
• (C3) 0 < size(inputs).
• (C4) 0 <= dimension < rank(inputs[0]).
• (C5) element_type(result) = element_type(inputs[0]).
• (C6) Aşağıdakiler hariç shape(result) = shape(inputs[0]):
  • 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

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

operand tenzorunda bir öğe türünden diğerine öğe bazında dönüşüm gerçekleştirir ve bir result tenzoru oluşturur.

boolean-to-any-supported-type dönüşümleri için false değeri sıfıra ve true değeri bire dönüştürülür. any-supported-type-to-boolean dönüşümleri için sıfır değeri false değerine, sıfır olmayan değerler ise true değerine dönüştürülür. Bunun karmaşık türler için nasıl çalıştığını aşağıda görebilirsiniz.

Tam sayı ile tam sayı, tam sayı ile kayan nokta veya kayan nokta ile kayan nokta dönüşümleri söz konusu olduğunda, kaynak değer hedef türünde tam olarak temsil edilebiliyorsa sonuç değeri bu tam temsildir. Aksi takdirde davranış henüz belirlenmemiştir (#180).

floating-point-to-integer dönüşümleri içeren dönüşümlerde kesirli kısım kısaltılır. Kısaltılmış değer hedef türünde temsil edilemiyorsa davranış TBD olur (#180).

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

Karmaşıktan başka bir türe ve başka bir türden karmaşığa dönüşümlerde sırasıyla kaynak karmaşık değer yok sayılır veya hedef karmaşık değer sıfırlanır. Gerçek kısmın dönüştürülmesi, kayan nokta dönüşümlerini izler.

Bu işlem, prensipte kesirli sayılaştırmayı (kesirli sayılaştırılmış tenzorlardan normal tenzorlara dönüşüm), kesirli sayılaştırmayı (normal tenzorlardan kesirli sayılaştırılmış tenzorlara dönüşüm) ve yeniden kesirli sayılaştırmayı (kesirli sayılaştırılmış tenzorlar arasında dönüşüm) ifade edebilir ancak şu anda bunun için özel işlemlerimiz var: ilk kullanım alanı için uniform_dequantize ve ikinci ve üçüncü kullanım alanları için uniform_quantize. Gelecekte bu iki işlem convert ile birleştirilebilir (#1576).

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 değerini döndürür. Aşağıdaki şemada, result öğelerinin lhs ve rhs'den nasıl hesaplandığı somut bir örnekle gösterilmektedir.

Daha resmi bir ifadeyle, lhs pencerelerini ifade edebilmek için girişlerin lhs açısından aşağıdaki şekilde 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] burada 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:

• 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 özelliğin kullanılmadığı anlaşılıyor. Bu nedenle, ileride 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]).

feature_group_count > 1 ise:

• 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).

batch_group_count > 1 ise:

• 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).

Miktarı belirlenmiş 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 kesirli 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] ile ilgili:
  • 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] ile ilgili:
  • is_unique(kernel_dimensions).
  • 0 <= kernel_dimensions < N.
• (C19) size(output_spatial_dimensions) = N - 2
• (C20) output_dimensions = [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension] verildiğinde:
  • 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:
  • result_dim = output_batch_dimension ise dim(lhs, input_batch_dimension) / batch_group_count.
  • result_dim = output_feature_dimension ise dim(rhs, kernel_output_feature_dimension).
  • num_windows aksi takdirde:
  • 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 miktarlandırılmamış tensörler kullanılıyorsa:
  • (C27) element_type(lhs) = element_type(rhs) = element_type(result).
• İşlemde kesirli tenzorlar 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) 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ü üzerinde element düzeyinde kosinüs işlemi gerçekleştirir ve result tensörü üretir. Öğe türüne bağlı olarak aşağıdakiler gerçekleşir:

• Kayan noktalı sayılar için: IEEE-754'ten cos.
• Karmaşık sayılar için: karmaşık kosinüs.
• Kesirli 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 tenzorundaki baştaki sıfır bitlerinin sayısını öğe bazında sayar ve bir result tenzoru 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

inputs ve called_computations değerini alıp results değerini döndüren uygulama tanımlı bir işlem call_target_name'ü kapsar. has_side_effect, backend_config ve api_version, uygulama tanımlı ek meta veriler sağlamak için kullanılabilir.

Şu anda bu işlem, XLA derleyicideki eşdeğer işleminin 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

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

bölü

Anlam bilimi

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

• Tam sayılar için: kesirli parçalar çıkarılarak cebirsel bölümü oluşturan tam sayı bölme.
• Kayan noktalı sayılar için: IEEE-754'ten division.
• Karmaşık sayılar için: karmaşık bölme.
• Kesirli 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 dilimlerinin rhs dilimleriyle iç çarpımlarını hesaplar ve bir result tensörü oluşturur.

Daha resmi olarak, 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)).

Miktarı belirlenmiş 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 kesirli 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ızlandırıcı arka uçlarındaki hesaplamalar için hız ile doğruluk arasındaki dengeyi kontrol eder. Bu, aşağıdakilerden biri olabilir (şu anda bu enum değerlerinin semantikleri yeterince belirtilmemiştir ancak bu sorunu #755 ile çözmeyi planlıyoruz):

• DEFAULT: En hızlı hesaplamadır, ancak orijinal sayıya en az doğru tahmindir.
• HIGH: Daha yavaş hesaplama, ancak orijinal sayıya daha yakın bir yaklaşım.
• HIGHEST: En yavaş hesaplama yöntemidir ancak orijinal sayıya en yakın yaklaşık değerdir.

DotAlgorithm, nokta işlemini uygulamak için kullanılan ve hassasiyeti de tanımlayan algoritmanın ana özelliklerini tanımlar. Algoritma özellik alanları ayarlanmışsa precision_config, DEFAULT olmalıdır. DotAlgorithms öğesinin varsayılan bir değeri yoktur. Çünkü varsayılan parametreler uygulama tarafından tanımlanmıştır. Dolayısıyla tüm nokta algoritması alanları, boş bir nokta algoritması belirtmek için None olarak ayarlanabilir. Bu algoritma, bunun yerine precision_config değerini kullanır.

DotAlgorithm alanları şunları içerir:

• lhs_precision_type ve rhs_precision_type, işlemin sol ve sağ tarafının yuvarlandığı hassasiyettir. Hassasiyet türleri, giriş ve çıkışın depolama türlerinden bağımsızdır.
• accumulation_type Toplama 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 uygularken geçerlidir. Bu işlemler genellikle daha yüksek bir hassasiyeti taklit etmek için yapılır (ör. Daha 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.
• Bazı adımlarda (ör. CUBLASLT_MATMUL_DESC_FAST_ACCUM) daha düşük hassasiyette veri toplamaya izin verilip verilmediğini belirtmek için allow_imprecise_accumulation kullanın.

Ö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 desteklendiğine karar vermek uygulamalara bağlıdır. Genel olarak, StableHLO tüketicisi tarafından her algoritmanın her hızlandırıcı türünde desteklendiği garanti edilmez. Belirli bir algoritma desteklenmiyorsa alternatife geçmek yerine bir hata oluşturulmalıdır. StableHLO doğrulaması, herhangi bir donanımda desteklenmediği bilinen algoritmaların kullanılmasını önleyerek en iyi doğrulama yöntemini sunar.

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 algoritmalar hakkında 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 miktarlandırılmamış tensörler kullanılıyorsa:
  • (C13) element_type(lhs) = element_type(rhs)
• İşlemde nicel tensörler 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ğildir.
  • is_quantized(lhs) ise:
  • (C17) storage_type(lhs) = storage_type(rhs).
  • (C18) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result).
  • (C19) is_per_tensor_quantized(rhs) ise is_per_tensor_quantized(result).
  • !is_quantized(lhs) ise:
  • (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, broadcast_in_dim çalışma biçimiyle işlevsel olarak aynıdır ancak sonuç şekli output_dimensions aracılığıyla dinamik olarak belirtilir.

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

Girişler

Çıkışlar

Sınırlamalar

• (C1) element_type(result) şu şekilde hesaplanır:
  • !is_per_axis_quantized(operand) ise element_type(operand).
  • element_type(operand), ancak quantization_dimension(operand), scales(operand) ve zero_points(operand) sırasıyla quantization_dimension(result), scales(result) ve zero_points(result)'den farklı olabilir.
• (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 toplama işleviyle aynıdır ancak dolgu, padding aracılığıyla dinamik olarak belirtilir.

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] ile ilgili:
  • 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] ile ilgili:
  • is_unique(kernel_dimensions).
  • 0 <= kernel_dimensions < N.
• (C19) size(output_spatial_dimensions) = N - 2
• (C20) output_dimensions = [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension] verildiğinde:
  • 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:
  • result_dim = output_batch_dimension ise dim(lhs, input_batch_dimension) / batch_group_count.
  • result_dim = output_feature_dimension ise dim(rhs, kernel_output_feature_dimension).
  • num_windows aksi takdirde:
  • 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 miktarlandırılmamış tensörler kullanılıyorsa:
  • (C27) element_type(lhs) = element_type(rhs) = element_type(result).
• İşlemde kesirli tenzorlar 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) 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]]]
//        ]
// %padding: [[1, 1],
//            [1, 1]]
%result = "stablehlo.dynamic_conv"(%lhs, %rhs, %padding) {
  window_strides = array<i64: 4, 4>,
  lhs_dilation = array<i64: 2, 2>,
  rhs_dilation = array<i64: 1, 1>,
  window_reversal = array<i1: false, false>,
  dimension_numbers = #stablehlo.conv<raw
    input_batch_dimension = 0,
    input_feature_dimension = 3,
    input_spatial_dimensions = [0, 1],
    kernel_input_feature_dimension = 2,
    kernel_output_feature_dimension = 3,
    kernel_spatial_dimensions = [0, 1],
    output_batch_dimension = 0,
    output_feature_dimension = 3,
    output_spatial_dimensions = [1, 2]
  >,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi64>, tensor<3x3x1x1xi64>, tensor<2x2xi64>) -> tensor<1x2x2x1xi64>
// %result: [[
//            [[1], [5]],
//            [[10], [14]]
//          ]]