StableHLO Özelliği

StableHLO, makinedeki üst düzey işlemler (HLO) için kullanılan bir işlemdir. öğrenme (ML) modelleridir. StableHLO, farklı öğeler ile videolar arasında taşınabilirlik katmanı görevi görür. Makine öğrenimi çerçeveleri ve makine öğrenimi derleyicileri: StableHLO programları üreten makine öğrenimi çerçeveleri StableHLO programlarını kullanan makine öğrenimi derleyicileriyle uyumludur.

Hedefimiz makine öğrenimi geliştirmeyi basitleştirmek ve hızlandırmak Farklı makine öğrenimi çerçeveleri (ör. TensorFlow, JAX ve PyTorch) ve makine öğrenimi derleyicileri (XLA ve IREE gibi). Bu hedefe doğru belgesinde StableHLO programlama dili için bir spesifikasyon sunulmaktadır.

Bu spesifikasyon üç ana bölüm içermektedir. İlk olarak, Programlar bölümünde StableHLO programlarının yapısı açıklanmaktadır. Bunlar, StableHLO işlemlerinden oluşan StableHLO işlevlerinden oluşur. Bu yapıdaki Ops bölümü ayrı ayrı bağlıdır. Yürütme bölümü, bu işlemlerin bir program içinde birlikte yürütülmesini sağlamaktır. Son olarak, Notasyon bölümünde, bakın.

StableHLO'nun önceki bir sürümünün teknik özelliklerini görüntülemek için şurada depoyu açın: etiketli yayın ekleyin. Örneğin, StableHLO v0.19.0 Spec. StableHLO'nun her alt sürüm yükseltmesinde gerçekleşen değişiklikleri görüntülemek için şuraya bakın: VhloDialect.td adresindeki sürüm günlüğü.

Programlar

Program ::= {Func}

StableHLO programları isteğe bağlı sayıda StableHLO işlevinden oluşur. Aşağıda, 3 girişe sahip @main fonksiyonuna sahip örnek bir program verilmiştir. (%image, %weights ve %bias) ve 1 çıkış. İşlevin gövdesi 6 operasyonu 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 adlandırılır) bir tanımlayıcı, girişler/çıkışlar ve bir gövde. Gelecekte, Daha iyi uyumluluk sağlamak amacıyla işlevler için ek meta veriler sunmak HLO ile (#425, 626, #740, #744) girin.

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ı çoğu programlamada tanımlayıcılara benzer iki özelliği vardır: 1) tüm tanımlayıcıların birlikte Farklı tanımlayıcı türlerini ayırt etme, 2) değer tanımlayıcıları StableHLO programlarının oluşturulmasını basitleştirmek için tamamen sayısal değerler.

Türler

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

StableHLO türleri, değer türleri (diğer adıyla birinci sınıf türleri) içeren, StableHLO değerlerini ve değer olmayan türleri temsil eder. bir şablon görevi görür. StableHLO türleri, ana özelliği StableHLO'nun alana özgü bir yapıya sahip olup bu durum bazı olağan dışı sonuçlara (ör. skaler türler) yol açar değildir).

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

Tensör türleri, tensörleri, yani çok boyutlu dizileri temsil eder. Bir şekil ve öğe türü (burada şekil, negatif olmayan veya bilinmeyen boyut boyutları, 0 ile R-1 arasında numaralandırılan boyutlar (bunlar eksen olarak da adlandırılır). İlgili içeriği oluşturmak için kullanılan R boyut sayısına sıralama denir. Örneğin, tensor<2x3xf32> 2x3 şekline ve f32 öğe türüne sahip bir tensör türü. İki boyutu vardır. (veya başka bir deyişle, iki eksen) - 0. boyut ve 1. boyut; diğer bir deyişle 2 ve 3'tür. Sıralaması 2.

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

Gelecekte, Google Analytics 4'teki tensör türlerini boyutları ve öğe türlerini (örneğin, yerleşimleri dahil etmek için) (#629) ve yetersizlik (#1078).

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

Nitelikli öğe türleri, depolama türünün tam sayı değerlerini şuna karşılık gelen storage_min - storage_max (dahil) aralığı ifade edilmiş bir türün kayan nokta değerleri. Belirli bir tam sayı değeri i için karşılık gelen kayan nokta değeri f şu şekilde hesaplanabilir: f = (i - zero_point) * scale, burada scale ve zero_point olarak adlandırılır nicelleştirme parametreleri. storage_min ve storage_max isteğe bağlıdır dilbilgisinde mevcut ancak varsayılan değerleri min_value(storage_type) ve Sırasıyla max_value(storage_type). Nicelleştirilmiş öğe türleri aşağıdaki sınırlamalara tabidir:

• (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 bir kayan nokta sabitidir, ancak çarpanları ve değerleri ile temsil edilen tamsayı tabanlı ölçeklere güçlü ilgi olur. Bu konuyu yakın gelecekte araştırmayı planlıyoruz (#1404).

QuantizationZeroPoint kelimesinin anlamı konusunda devam eden bir tartışma var. ve yalnızca bir veya daha fazla nicelleştirilmiş bir tensör türünde potansiyel olarak birden çok sıfır noktasıdır. Referans olarak Bu tartışmanın sonuçlarına göre, sıfır puan civarındaki spesifikasyonlar değişebilir. ileride bahsedeceğim (#1405).

Devam eden bir diğer tartışma da QuantizationStorageMin anlamıyla ilgili. ve kısıtlanması gerekip gerekmediğini belirlemek için QuantizationStorageMax bu değerlere ve nicelenmiş tensörlerin değerlerine (#1406).

Son olarak, bilinmeyen ölçekleri ve sıfır ölçeğini temsil ederek hesaplamayı planlıyoruz. araştırmalarımızda olduğu gibi, bilinmeyen noktaları temsil etmeyi planladığımız gibi boyut boyutlarını (#1407) tıklayın.

Nicelleştirilmiş tensör türleri, miktarlandırılmış öğelere sahip tensörleri temsil eder. Bu tensörler, elemanları dışında normal tensörlerle tamamen aynıdır. yerine miktarlandırılmış öğe türlerine sahip olmalıdır.

Miktarlandırılmış tensörlerde miktar tansör başına olabilir. Diğer bir deyişle, tensörün tamamı için bir scale ve zero_point olabilir veya eksen başına olabilir. yani, birden fazla scales ve zero_points (her bir öğe dilimi başına bir çift) belirli bir quantization_dimension boyutunu seçin. Daha resmi olarak, bir tensörde t eksen başına nicelemeyle, dim(t, quantization_dimension) dilim quantization_dimension tarihindekiler: t[:, ..., 0, ..., :], t[:, ..., 1, ..., :], vb. i. dilimdeki tüm öğeler, scales[i] ve zero_points[i] öğelerini ve niceleme parametrelerinden biridir. Nicel tensör türleri aşağıdaki gibidir sınırlamalar:

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

TokenType ::= 'token'

Jeton türleri jetonları, yani üretilen ve tüketilen opak değerleri temsil eder. neden olur. Jetonlar, işlemlere yürütme sırası uygulamak için kullanılır Yürütme bölümünde gösterildiği gibi.

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

Tuple türleri, grupları (heterojen listeler) temsil eder. Tuples bir miradır Bu özellik yalnızca HLO ile uyumluluk için kullanılabilir. HLO'da, delikler giriş ve çıkışları temsil etmek için kullanılır. StableHLO'da değişken girdiler ve çıkışlar yerel olarak desteklenir ve StableHLO'da tuple'ların tek kullanımı HLO ABI'ı (ör. T, tuple<T> ve tuple<tuple<T>>, belirli bir kullanım alanına bağlı olarak önemli ölçüde farklılık gösterebilir. hakkında bilgi edindiniz. Gelecekte HLO ABI'de değişiklikler yapmayı planlıyoruz. Bu işlem, StableHLO'dan öğe türlerini kaldırmamıza olanak tanır. (#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 ::= 'f8E4M3FN' | 'f8E5M2' | 'f8E4M3FNUZ' | 'f8E5M2FNUZ'
            | 'f8E4M3B11FNUZ' | 'bf16' | 'f16' | 'f32' | 'f64'
TensorFloat32 ::= 'tf32'
ComplexType ::= 'complex' '<' ComplexElementType '>'
ComplexElementType ::= 'f32' | 'f64'

Öğe türleri, tensör türlerinin öğelerini temsil eder. Birçok programın aksine bu türler StableHLO'da birinci sınıf değildir. Bunun anlamı, StableHLO programları bu tür değerleri doğrudan temsil edemez (sonuç olarak 0 boyutlu tensörle T türünde skaler değerleri göstermek deyimseldir (tensor<T> türündeki değerler) seçin.

• 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 biri (2, 4, 8, 16, 32 veya 64). İmzalı siN türleri, -2^(N-1) ile 2^(N-1)-1 arasındaki tam sayı değerlerini temsil eder dahil ve imzasız uiN türleri, 0 - 0 arasındaki tam sayı değerlerini temsil eder 2^N-1 dahil.
• Kayan nokta türleri aşağıdakilerden biri olabilir:
  • f8E4M3FN ve f8E5M2 sırasıyla FP8 biçiminin E4M3 ve E5M2 kodlamaları: Derin Öğrenme için FP8 Biçimleri.
  • E4M3 ve E5M2 özelliklerine karşılık gelen f8E4M3FNUZ ve f8E5M2FNUZ türleri şu sayfada açıklandığı üzere FP8 biçimlerinin kodlamaları: Derin Sinir Ağları için 8 Bit Sayısal Biçimler.
  • FP8 biçimlerinin E4M3 kodlamasına karşılık gelen f8E4M3B11FNUZ türü şurada açıklandığı: Derin Sinir Ağları için Karma 8 Bit Kayan Nokta (HFP8) Eğitimi ve Çıkarım.
  • Şu sayfada açıklanan bfloat16 biçimine karşılık gelen bf16 türü: Bfloat16: Cloud TPU'larda yüksek performansın sırrı
  • Sırasıyla f16, f32 ve f64 türleri binary16 ("yarı hassasiyet"), binary32 ("tek hassasiyet") ve binary64 ("çift hassasiyet") biçimleri aşağıda açıklanmıştır: IEEE 754 standardı.
  • tf32 türü, TensorKaydırma32 biçimine karşılık gelir ve StableHLO'da sınırlı destek sunulur.
• Karmaşık türler, gerçek bir bölümü olan karmaşık değerleri temsil eder ve aynı öğe türünün sanal bir kısmını içerir. Desteklenen kompleks türler, complex<f32> (her iki bölüm de f32 türündedir) ve complex<f64> şeklindedir (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. Bunlar giriş türleri (-> öğesinin sol tarafındaki türler listesi) ve çıkış türleri (-> öğesinin sağındaki türler listesi). Birçok programlamada dil, işlev türleri birinci sınıftır ancak StableHLO'da yoktur.

StringType ::= 'string'

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

İşlemler

StableHLO işlemleri (operasyon olarak da adlandırılır) kapalı bir kümeyi temsil eder üst düzey operasyonlar. Yukarıda açıklandığı gibi, StableHLO söz dizimi, büyük ölçüde MLIR’den esinlenilerek geliştirilmiştir. Ancak bu, ergonomik bir alternatif ancak muhtemelen StableHLO'nun makine öğrenimi çerçeveleri ile makine öğrenimi derleyicileri arasında daha fazla birlikte çalışabilirlik sağlar.

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

StableHLO işlemlerinin (işlem olarak da adlandırılır) bir adı vardır. giriş/çıkış ve bir imzadır. Ad, stablehlo. ön ekinden ve Desteklenen işlemlerden birini benzersiz şekilde tanımlayan bir hatırlatıcı. Aşağıdaki bilgilere göz atın desteklenen tüm operasyonların kapsamlı bir listesini içerir.

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

İşlemler girişleri tüketir ve çıkışlar üretir. Girişler şu kategorilere ayrılır: giriş değerleri (yürütme sırasında hesaplanır), giriş işlevleri (sağlanan statiktir, çünkü StableHLO'da işlevler birinci sınıf değerler değildir) ve giriş özellikleri (statik olarak da sağlanır). Giriş ve çıkış türü işlem gücüne bağlıdır. Örneğin, add op, 2 giriş değeri tüketir ve 1 çıkış değeri üretir. Buna kıyasla, select_and_scatter işlemi 3 giriş değeri, 2 giriş işlevi tüketir ve 3 giriş özelliği.

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 benzerdir. Tek fark: 1) bir tanımlayıcıları yoktur (dolayısıyla "anonim" olması gerekir, 2) çıkış türlerini bildirmezler (çıktı türleri işlevin içindeki return işleminden türetilir).

Giriş işlevlerinin söz dizimi, kullanılmayan bir bölümü içeriyor (bkz. Unused üretimi) gerekir. MLIR'de, "bölgeler" daha genel bir kavramdır birden fazla "engelleme" olabilen atlama operasyonlarıyla birbirine bağlanmış operasyonlar. Bu blokların, ilgili bloklara karşılık gelen birbirlerinden ayırt edilebilmeleri için Unused üretime atanır. StableHLO'da atlama işlemleri yoktur. Bu nedenle, MLIR söz diziminin karşılık gelen kısmı (ancak hâlâ oradadır).

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

Giriş özelliklerinin bir adı ve desteklenen bir değeri vardır sabitler. Bunlar, program için statik meta verileri belirtmenin birincil yoludur öğeler. Örneğin, concatenate operasyonu şunun için dimension özelliğini kullanır: giriş değerlerinin birleştirileceği boyutu belirtin. Aynı şekilde, slice işlemi, start_indices ve limit_indices gibi birden çok özellik kullanıyor. ifadesini girin.

Şu anda, doğadaki StableHLO programları bazen Bunlar bu dokümanda açıklanmamıştır. Gelecekte, ya bu özellikleri StableHLO işletim sistemine alır veya bunları StableHLO programlarında görünüyor. Bu arada sırada bu müzakerelerin özellikler:

• 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ğeri türlerinden ( -> işaretinin sol tarafındaki) ve tüm çıkış değerlerinin türlerini (liste, türleri -> öğesinin sağ tarafında gösterilir). Özetle, giriş türleri ve çıkış türleri de neredeyse her zaman gereksizdir (çünkü en fazla StableHLO işlemi için, çıkış türleri girişlerden çıkarılabilir. Yine de operasyon imza, kasıtlı olarak MLIR ile uyumluluk için StableHLO söz diziminin bir parçasıdır.

Aşağıda, anımsatıcı select_and_scatter olan bir örnek işlem verilmiştir. 3 veri tüketir giriş değerleri (%operand, %source ve %init_value), 2 giriş işlevi ve 3 giriş özelliği (window_dimensions, window_strides ve padding). Operatörün imzasının yalnızca giriş değeri türlerini içerdiğini unutmayın (satır içi sağlanan giriş işlevlerinin ve özniteliklerinin türleri değil).

%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 bir değişmez değere ve birlikte şu değeri temsil eden bir türe sahiptir: StableHLO değerine sahip. Genellikle, tür sabit söz diziminin bir parçasıdır, belirsiz olduğunda (ör. bir boole sabiti açık bir şekilde i1 türündeyse, Buna karşın, tam sayı sabitinin birden fazla olası türü olabilir).

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

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

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. Diğer tabanlar, ör. ikili veya sekizlik desteklenmez. Tam sayı sabitlerinin kısıtlamaları aşağıdaki gibidir:

• (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, kayan nokta değerlerini Ondalık veya bilimsel gösterim kullanabilirsiniz. Buna ek olarak, onaltılı gösterim temel bitleri kayan nokta biçiminde doğrudan belirtmek için kullanılır seçin. Kayan nokta sabitleri aşağıdaki kısıtlamalara sahiptir:

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

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

Karmaşık sabitler, gerçek bölümün listelerini kullanarak karmaşık değerleri temsil eder (önce gelir) ve hayali bir bölüm (ikinci sırada gelir) yer alır. Örneğin, (1.0, 0.0) : complex<f32>, 1.0 + 0.0i değerini ve (0.0, 1.0) : complex<f32>, 0.0 + 1.0i değerini temsil eder. Bu öğelerin daha sonra uygulama tarafından tanımlanmış şekilde saklanır. Karmaşık sabitler aşağıdaki sınırlamalara 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. Örneğin, dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> dizinlerden öğelere aşağıdaki eşlemeyle birlikte 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ı tanımlanmıştır. Tensor sabitleri için aşağıdaki kısıtlamalar bulunur:

• (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, aynı tensör sabitleri olarak gösterim; elemanlar kendi sabit değerleri olarak belirtilir depolama alanı türü. Nicel 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 sabit değerleri, ASCII karakterleri kullanılarak belirtilen baytlardan oluşur. kaçış dizileridir. Kodlamadan bağımsız oldukları için bu kodların yorumlanması bayt, uygulama tanımlıdır. Dize değişmez değerleri string türündedir.

İşlemler

abs

Anlam

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

• İşaretli tam sayılar için: tam sayı 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).

Örnekler

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

Diğer Örnekler

add

Anlam

İki tensoru (lhs ve rhs) eleman olarak ekler ve bir üretir result tensörü. Öğe türüne bağlı olarak aşağıdakiler gerçekleşir:

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

Girişler

Çıkışlar

Sınırlamalar

• İşlemde miktarlandırılmamış tensörler kullanılıyorsa:
  • (C1) type(lhs) = type(rhs) = type(result).
• İşlemde nicel tensörler 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 öğesini üreten işlemlerin herhangi bir tarihten önce yürütülmesini sağlar ve result türüne bağlı olan işlemler. Bu işlemi gerçekleştirmek hiçbir şey yapmaz, yalnızca result ile inputs arasındaki veri bağımlılıklarını oluşturmak için kullanılabilir.

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

StableHLO süreç ızgarasındaki her işlem grubu içinde, değerleri birleştirir. all_gather_dim boyunca her süreçten operands tensöründen results tensörü.

İşlem, StableHLO süreç ızgarasını process_groups olarak ayırır. şu şekilde tanımlanır:

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

Daha sonra, her process_group içinde:

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

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

StableHLO süreç ızgarasındaki her süreç grubuna bir azaltma uygular her işlemdeki operands tensörlerinin değerlerine computation işlevi ve results tensör üretir.

İşlem, StableHLO süreç ızgarasını process_groups olarak ayırır. şu şekilde tanımlanır:

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

Daha sonra, her process_group içinde:

• Bazı ikili ağaçlar için results...@process[result_index] = exec(schedule) schedule burada:
  • exec(node) = computation(exec(node.left), exec(node.right)).
  • exec(leaf) = leaf.value.
• schedule, sırasıyla geçiş to_destination_type(operands...@process_group...[result_index], type(func_inputs(computation)[0])).

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

StableHLO süreç ızgarasındaki her süreç grubu içinde, split_dimension boyunca uzanan operands tensörleri parçalara ayırarak bölünmeyi dağıtır parçaları, sürekli olarak dağılmış parçaları birleştirerek concat_dimension ve results tensör üretir. İşlem, StableHLO süreç ızgarasını process_groups olarak ayırır. şu şekilde tanımlanır:

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

Daha sonra, her 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] 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) type(results...) = type(operands...), şu durumlar dışında: split_dimension != concat_dimension:
  • 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

lhs ve rhs olmak üzere iki tensör için öğe düzeyinde VE işlemini gerçekleştirir ve bir result üretir tensördür. Öğe türüne bağlı olarak aşağıdakiler gerçekleşir:

• 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

lhs ve rhs tensörü üzerinde öğe tabanlı atan2 işlemi gerçekleştirir ve result tensörü. Öğe türüne bağlı olarak aşağıdakiler gerçekleşir:

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

Geri çoğaltan çeşitli batch_norm_training girişlerinin gradyanlarını hesaplar grad_output üretir ve grad_operand, grad_scale ve grad_offset üretir tensörler. Daha resmi ifade etmek gerekirse bu işlem, aşağıdaki gibi Python söz dizimini kullanan mevcut StableHLO işlemlerini içerir:

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ı kullanılan 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))

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 sahip.
• (C3) operand, grad_output ve grad_operand aynı şekle sahip.
• (C4) scale, mean, variance, grad_scale ve grad_offset sahip anlamına gelir.
• (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ü şu boyut hariç tüm boyutlarda normalleştirir: feature_index boyutunu belirler ve bir result tensörü oluşturur. Daha resmi ifade etmek gerekirse işlem, mevcut StableHLO işlemlerine ayrışma olarak ifade edilebilir aşağıdaki gibi bir Python söz dizimi kullanarak:

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ı kullanılan türlerde, 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))

Girişler

Çıkışlar

Sınırlamalar

• (C1) 0 <= feature_index < rank(operand).
• (C2) operand, scale, offset, mean, variance ve result sahip aynı baseline_element_type.
• (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

feature_index hariç tüm boyutlardaki ortalamayı ve varyansı hesaplar boyut ve output, batch_mean üreten operand tensörü normalleştirir ve batch_var tensör. Daha resmi ifade etmek gerekirse bu işlem mevcut StableHLO işlemlerine ayrıştırmak için Python sözdizimini şöyle olur:

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ı kullanılan 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))

Girişler

Çıkışlar

Sınırlamalar

• (C1) 0 <= feature_index < rank(operand).
• (C2) operand, scale, offset, batch_mean, batch_var ve output var aynı baseline_element_type.
• (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

operand tensörü üzerinde bir bitcast işlemi gerçekleştirir ve result tensörü üretir Bu örnekte, operand tensörünün tamamının bitleri result tensör türü.

Daha resmî bir şekilde ifade etmek gerekirse E = element_type(operand), E' = element_type(result), ve R = rank(operand):

• 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 ve davranışının bellekteki gösterimini döndürür uygulama tanımlıdır çünkü tensörlerin tam gösterimi öğe türlerinin tam gösterimi şöyledir: tanımlanabilir.

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) dikkate alınarak:
  • num_bits(E') = num_bits(E) ise shape(result) = shape(operand).
  • Eğer num_bits(E') < num_bits(E):
  • rank(result) = R + 1.
  • Tüm 0 <= i < R için dim(result, i) = dim(operand, i).
  • dim(result, R) * num_bits(E') = num_bits(E).
  • Eğer num_bits(E') > num_bits(E):
  • rank(result) = R - 1.
  • Tüm 0 <= i < R için dim(result, i) = dim(operand, i).
  • 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

Verileri çoğaltarak bir giriş tensörünün boyutlarını ve/veya sıralamasını genişletir operand tensöründe çalışır ve bir result tensörü üretir. Daha resmi ifade etmek gerekirse result[result_index] = operand[operand_index] burada tüm d için axes(operand):

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

Girişler

Çıkışlar

Sınırlamalar

• (C1) element_type(result) değerini sağlayan:
  • !is_per_axis_quantized(operand) ise element_type(operand).
  • element_type(operand) (bu quantization_dimension(operand) hariç) scales(operand) ve zero_points(operand) şundan farklı olabilir: quantization_dimension(result), scales(result) ve zero_points(result) resp., aksi takdirde.
• (C2) size(broadcast_dimensions) = rank(operand).
• (C3) 0 <= broadcast_dimensions < rank(result).
• (C4) is_unique(broadcast_dimensions)
• (C5) axes(operand) bünyesindeki 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

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

• 0 <= index < size(branches) ise selected_branch = branches[index].
• 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

operand tensörü üzerinde öğe tabanlı kübik kök işlemi gerçekleştirir ve result tensörü. Öğe türüne bağlı olarak aşağıdakiler gerçekleşir:

• Kayan reklamlar için: IEEE-754'ten rootn(x, 3).
• Karmaşık sayılar için: karmaşık küpik kök.
• Miktarı ölçülmüş 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

Element tabanlı operand tensörü gerçekleştirir ve bir result tensörü üretir. IEEE-754'teki roundToIntegralTowardPositive işlemini uygular bakın. Miktarı kullanılan türlerde, dequantize_op_quantize(ceil, operand, type(result))

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 resmî bir şekilde ifade etmek gerekirse index_space(result) bölgesindeki tüm i için result[i0, ..., iR-3, :, :], aşağıdaki değerin bir Cholesky ayrışmasıdır a[i0, ..., iR-3, :, :], alt üçgenden biri biçiminde (lower true ise) veya üst üçgen (lower false ise) matrisi. Karşıt üçgende gösterilen çıkış değerleri (ör. katı üst üçgen veya katı alt üçgenler ise uygulama tanımlıdır.

Girdi matrisinin Hermitian pozitif tanımlı olmadığı i varsa söz konusu olduğunda, davranış tanımsızdır.

Miktarı kullanılan türlerde, dequantize_op_quantize(lambda operand: cholesky(operand, lower), a, type(result))

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]
//          ]

kenetleme

Anlam

operand tensörünün her öğesini minimum ile maksimum arasında sabitler değerini döndürür ve bir result tensörü üretir. Daha resmi dilde: 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]. Miktarı kullanılan türlerde dequantize_op_quantize(clamp, min, operand, max, type(result)) gerçekleştiriyor.

Karmaşık sayılarda sıralama yaratmak, şaşırtıcı anlamlar ya da Bu nedenle gelecekte karmaşık sayılar için desteği 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

StableHLO süreç tablosundaki her süreç grubunda, operand tensörü kaynak süreçten hedef süreçlere aktarır ve result tensörü.

İşlem, StableHLO süreç ızgarasını process_groups olarak ayırır. şu şekilde tanımlanır:

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

Daha sonra, result@process sağlayan:

• Sürecin geçerli olması için gereken i varsa operand@process_groups[i, 0] process_groups[i] içinde.
• 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

StableHLO süreç ızgarasındaki her işlem grubu içinde, operand tensörü kaynak süreçten hedef sürece çıkar ve result tensörü.

İşlem, StableHLO süreç ızgarasını process_groups olarak ayırır. şu şekilde tanımlanır:

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

Daha sonra, result@process sağlayan:

• operand@process_groups[i, 0] gibi bir i varsa process_groups[i, 1] = process.
• 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

Şuna göre lhs ve rhs tensörlerinin öğe bazında karşılaştırmasını yapar: comparison_direction ve compare_type ile aynı ve bir result tensörü üretir.

comparison_direction ve compare_type değerleri şuna sahiptir: anlambilim:

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.

op, compare_type = FLOAT içeren kayan nokta öğe türlerinde aşağıdaki IEEE-754 işlemleri için geçerlidir:

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

compare_type = TOTALORDER içeren kayan nokta öğe türlerinde op şuna ait totalOrder ve compareQuietEqual işlemlerinin birleşimini kullanır: IEEE-754.

Karmaşık öğe türleri için (real, imag) çiftlerinin sözlüksel karşılaştırması sağlanan comparison_direction ve compare_type kullanılarak gerçekleştirildi. Karmaşık sayılarda sıralama yaratmak, şaşırtıcı anlamlar ya da Bu nedenle gelecekte karmaşık sayılar için desteği kaldırmayı planlıyoruz. comparison_direction GE, GT, LE veya LT olduğunda (#560).

Miktarı ölçülmüş türler için. dequantize_compare(lhs, rhs, comparison_direction) gerçekleştiriyor.

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 eşleştirilmiş değer çiftinden karmaşık bir değere element tabanlı dönüşüm gerçekleştirir. lhs ve rhs ile sanal değerler arasında bir olarak belirleyip 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), complex<E> türünde olup burada E = element_type(lhs).

Ö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

Diğer StableHLO işlemlerinden oluşan (oluşturulan) bir işlemi içerir. inputs ve composite_attributes alıp results üretiyoruz. İlgili içeriği oluşturmak için kullanılan işlemin anlamı, decomposition özelliği tarafından uygulanır. İlgili içeriği oluşturmak için kullanılan composite işlemi, program değiştirilmeden ayrıştırılmasıyla değiştirilebilir anlambilim. Ayrıştırmayı satır içine almak aynı işlem semantiği, custom_call kullanmayı tercih edin.

version alanı (varsayılan olarak 0 değerine ayarlanır), bir bileşenin anlamsal değişikliği vardı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 değerini, verilen sırada dimension boyutu boyunca birleştirir bağımsız değişkenlerini kullanır ve bir result tensörü üretir. Daha resmi 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şit, d0, ... ise d. boyut boyutudur / inputs.

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) shape(result) = shape(inputs[0]) 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

Sabit bir value değerinden bir output tensörü üretir.

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

Şu durumda bir öğe türünden diğerine öğe tabanlı dönüşüm gerçekleştirir: operand tensörü ve result tensörü üretir.

boolean-to-any-supported-type dönüşümleri için false değeri sıfıra dönüştürülür ve true değeri bire dönüştürülür. Örneğin, any-supported-type-to-boolean dönüşümlerini içeren bir dönüşüm yoksa sıfır değeri şuna dönüştürülür: false ve sıfır olmayan değerler true biçimine dönüştürülür. Bunun nasıl yapılacağını karmaşık türler için geçerlidir.

Tamsayıdan tam sayıya, tamsayıdan kayan noktaya geçiş içeren dönüşümler için veya floating-point-to-floating-point (kayan-nokta-kayan-nokta) hedef türünde temsil edildiğinde, sonuç değeri, söz konusu temsil eder. Aksi takdirde, davranış henüz belli değil (#180).

floating-point-to-integer dönüşüm 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'dir (#180).

Karmaşıktan karmaşa içeren dönüşümlerde aynı davranışı izler. floating-point-to-floating-point dönüşümler, gerçek ve hayali parçalar içerir.

complex-to-any-other-type ve any-other-type-to-complex dönüşümleri için kaynak sanal değeri yok sayılır veya hedef sanal değeri sıfırdır. Gerçek parçanın dönüştürülmesinde, kayan nokta dönüşümleridir.

Prensipte, bu işlem, ayrışmayı (deneyim, nicelenmiş tensörlerden normal tensörlere), nicelleştirme (normalden tensörlerden miktarlandırılmış tensörlere ve yeniden niceleme (nicelleştirilmiş tensörler), ancak şu anda bunun için özel operasyonlarımız var. İlk kullanım alanı için uniform_dequantize veuniform_quantize kullanım alanlarından bahsedeceğiz. Gelecekte bu iki operasyon birleştirilebilir convert (#1576) olarak değiştirin.

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

lhs pencereleri ile rhs dilimleri arasındaki nokta ürünlerini hesaplar ve şunları üretir: result. Aşağıdaki şemada, result içindeki öğelerin Somut bir örnek kullanarak lhs ve rhs.

Daha resmî bir şekilde, girişlerin lhs açısından aşağıdaki şekilde yeniden kavranmasını sağlayabilirsiniz. lhs pencerelerini ifade edebilmek için:

• 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 aşağıdaki yardımcı işlevleri kullanı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 herkes için index_space(dim(result, output_spatial_dimensions...)) konumunda output_spatial_index, result[result_shape(:, output_spatial_index, :)] = dot_product 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ılmadığından ileride uygulamayı kaldırmayı planlıyoruz. bu (#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)

Miktarı ölçülmüş türlerde, 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)) gerçekleştirir.

Karma miktarlandırılmış türlerde 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) performans gösterir.

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] ile ilgili:
  • 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).
  • Aksi takdirde, şu koşullarda num_windows:
  • 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 nicel tensörler kullanılıyorsa:
  • (C28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs)
  • (C29) is_per_axis_quantized(rhs) ise ardından 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

operand tensörü üzerinde element düzeyinde kosinüs işlemi gerçekleştirir ve bir result tensörü. Öğe türüne bağlı olarak aşağıdakiler gerçekleşir:

• Kayan reklamlar için: IEEE-754'ten cos.
• Karmaşık sayılar için: karmaşık kosinüs.
• Miktarlanmış 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

operand hücresinin başındaki sıfır bit sayısını öğe bazında sayar ve bir result tensörü üretir.

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

Aşağıdaki işlemler için gereken uygulama tanımlı call_target_name işlemini içerir: inputs ve called_computations ile results üretir. has_side_effect, backend_config ve api_version, ek bilgi sağlamak için kullanılabilir. meta verilerdir.

Şu anda bu işlem oldukça dağınık bir meta verileridir. Meta veriler XLA derleyicisi olur. 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

lhs bölünme ve bölünen rhs tensörlerini element düzeyinde böler ve bir result tensörü üretir. Öğe türüne bağlı olarak aşağıdakiler gerçekleşir:

• Tam sayılar için: herhangi bir sayıdaki cebirsel bölümü oluşturan tam sayı bölme kısmen silindi.
• Kayan reklamlar için: IEEE-754'ten division.
• Karmaşık sayılar için: karmaşık bölme.
• Ölçülen 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

lhs dilimleri ile rhs dilimleri arasındaki nokta ürünlerini hesaplar ve result tensörü.

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ı ölçülmüş türlerde, 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)) gerçekleştirir.

Karma miktarlandırılmış türlerde 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) performans gösterir.

precision_config, veriler için hız ile doğruluk arasındaki dengeyi kontrol eder hesaplamalarına yardımcı olur. Bu, aşağıdakilerden biri olabilir ( bu sıralama değerlerinin anlamı eksik olsa da, bu konuyu ele almayı #755):

• DEFAULT: En hızlı hesaplama, ancak orijinal sayı.
• HIGH: Hesaplama daha yavaştır ancak orijinal sayı.
• HIGHEST: En yavaş hesaplama, ancak hedefe en doğru tahmin orijinal sayı.

DotAlgorithm, aşağıdakileri uygulamak için kullanılan algoritmanın ana özelliklerini tanımlar: nokta işlemidir. Bu işlem, hassasiyeti de tanımlar. Algoritma alanları ayarlanırsa precision_config, DEFAULT olmalıdır. DotAlgorithms. varsayılan parametreler uygulandığından, varsayılan bir değere sahip değildir tanımlanmıştır. Bu nedenle, tüm nokta algoritması alanları None olarak ayarlanabilir boş nokta algoritması bulunur. Bunun yerine, precision_config değeri kullanılır.

DotAlgorithm alanları şunları içerir:

• lhs_precision_type ve rhs_precision_type, LHS ve LHS ile İşlemin sağ tarafı yuvarlanır. Hassasiyet türleri giriş ve çıkışların depolama türleri.
• accumulation_type, toplama için kullanılan hassasiyet.
• lhs_component_count, rhs_component_count ve num_primitive_operations ve/veya RHS'yi ayıran bir algoritma yaptığımızda uygulanır. birden fazla bileşene sahip ve birden çok "temel" öğe bu satırlarda genellikle daha yüksek bir hassasiyet emülasyonu yapmak için (ör. Daha Yüksek Hassasiyetli Hesaplamalar İçin bfloat16 Yapay Zeka Veri Türünden Yararlanma: bf16_6x tf32_3x vb.) Ayrıştırılması olmayan algoritmalar için bu değerler 1 olarak ayarlanmalıdır.
• Toplama işleminin daha düşük kesinlikte olup olmadığını belirtmek için allow_imprecise_accumulation bazı adımlarda izin verilir (ör. CUBLASLT_MATMUL_DESC_FAST_ACCUM).

Ö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. İçinde her algoritmanın tek bir algoritmada desteklendiği garanti edilmez. hızlandırıcı türünü ayarlayın. Belirli bir algoritma geri dönmek yerine bir hata alternatifidir. StableHLO doğrulaması mümkün olan en iyi doğrulamayı sağlar. herhangi bir donanımda desteklenmediği bilinen algoritmaları önleme amaçlıdır.

Bkz. xla_data.proto > Algorithm . 2483 numaralı bilet, bir olası satış yaratma planını algoritmalarla ilgili merkezi bir belge hazırladık.

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 yer almıyor.
  • Eğer is_quantized(lhs):
  • (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).
  • Eğer !is_quantized(lhs):
  • (C20) element_type(lhs) = expressed_type(rhs) = element_type(result).
• Eğer !is_empty_algorithm(lhs_precision_type, rhs_precision_type, accumulation_type, lhs_component_count, rhs_component_count, num_primitive_operations allow_imprecise_accumulation):
  • (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

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

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

Girişler

Çıkışlar

Sınırlamalar

• (C1) element_type(result) değerini sağlayan:
  • !is_per_axis_quantized(operand) ise element_type(operand).
  • element_type(operand) (bu quantization_dimension(operand) hariç) scales(operand) ve zero_points(operand) şundan farklı olabilir: quantization_dimension(result), scales(result) ve zero_points(result) resp., aksi takdirde.
• (C2) size(broadcast_dimensions) = rank(operand).
• (C3) 0 <= broadcast_dimensions < rank(result).
• (C4) is_unique(broadcast_dimensions)
• (C5) axes(operand) bünyesindeki 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_non_expanding_dimensions)
• (C9) 0 <= known_expanding_dimensions < rank(operand).
• (C10) 0 <= known_non_expanding_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_non_expanding_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

Bu işlem işlevsel olarak konvolüsyon 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] ile ilgili:
  • 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).
  • Aksi takdirde, şu koşullarda num_windows:
  • 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 nicel tensörler kullanılıyorsa:
  • (C28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs)
  • (C29) is_per_axis_quantized(rhs) ise ardından 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]]
//          ]]