StableHLO की खास बातें

StableHLO, मशीन लर्निंग (ML) मॉडल में हाई-लेवल ऑपरेशन (एचएलओ) के लिए सेट किया गया ऑपरेशन है. StableHLO, अलग-अलग एआई फ़्रेमवर्क और एआई कंपाइलर के बीच पोर्टेबिलिटी लेयर के तौर पर काम करता है: StableHLO प्रोग्राम बनाने वाले एआई फ़्रेमवर्क, StableHLO प्रोग्राम का इस्तेमाल करने वाले एआई कंपाइलर के साथ काम करते हैं.

हमारा लक्ष्य, अलग-अलग ML फ़्रेमवर्क (जैसे, TensorFlow, JAX, और PyTorch) और ML कंपाइलर (जैसे, XLA और IREE) के बीच बेहतर इंटरऑपरेबिलिटी बनाकर, ML डेवलपमेंट को आसान और तेज़ बनाना है. इस काम के लिए, इस दस्तावेज़ में StableHLO प्रोग्रामिंग भाषा के बारे में जानकारी दी गई है.

इस स्पेसिफ़िकेशन में तीन मुख्य सेक्शन होते हैं. सबसे पहले, प्रोग्राम सेक्शन में StableHLO प्रोग्राम के स्ट्रक्चर के बारे में बताया गया है. इन प्रोग्राम में StableHLO फ़ंक्शन होते हैं, जिनमें StableHLO ऑपरेशन होते हैं. उस स्ट्रक्चर में, Ops सेक्शन, अलग-अलग ऑपरेशन के सिमेंटिक्स के बारे में बताता है. एक्ज़ीक्यूटिव सेक्शन में, प्रोग्राम में एक साथ लागू किए जाने वाले सभी ऑपरेशन के लिए सिमेंटिक उपलब्ध होते हैं. आखिर में, नोटेशन सेक्शन में, स्पेसिफ़िकेशन में इस्तेमाल किए गए नोटेशन के बारे में बताया गया है.

StableHLO की पिछली रिलीज़ की खास जानकारी देखने के लिए, अपनी पसंद के टैग की गई रिलीज़ पर मौजूद रिपॉज़िटरी खोलें. उदाहरण के लिए, StableHLO v0.19.0 स्पेसिफ़िकेशन. StableHLO के हर छोटे वर्शन में हुए बदलावों को देखने के लिए, VhloDialect.td में वर्शन लॉग देखें.

प्रोग्राम

Program ::= {Func}

StableHLO प्रोग्राम में, StableHLO फ़ंक्शन की कोई भी संख्या हो सकती है. यहां एक प्रोग्राम का उदाहरण दिया गया है, जिसमें फ़ंक्शन @main के तीन इनपुट (%image, %weights, और %bias) और एक आउटपुट है. फ़ंक्शन के मुख्य हिस्से में, छह ऑपरेशन हैं.

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>) -> ()
}

फ़ंक्शन

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

StableHLO फ़ंक्शन (जिन्हें named functions भी कहा जाता है) में एक आइडेंटिफ़ायर, इनपुट/आउटपुट, और एक बॉडी होता है. आने वाले समय में, हम फ़ंक्शन के लिए अतिरिक्त मेटाडेटा लॉन्च करने की योजना बना रहे हैं. इससे HLO (#425, #626, #740, #744) के साथ बेहतर तरीके से काम किया जा सकेगा.

आइडेंटिफ़ायर

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

StableHLO आइडेंटिफ़ायर, कई प्रोग्रामिंग भाषाओं के आइडेंटिफ़ायर से मिलते-जुलते होते हैं. इनकी दो खास बातें होती हैं: 1) सभी आइडेंटिफ़ायर में सिगल हैं, जो अलग-अलग तरह के आइडेंटिफ़ायर में अंतर करते हैं, 2) वैल्यू आइडेंटिफ़ायर, StableHLO प्रोग्राम बनाने की प्रोसेस को आसान बनाने के लिए पूरी तरह से न्यूमेरिक हो सकते हैं.

टाइप

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

StableHLO टाइप को वैल्यू टाइप (जिन्हें फ़र्स्ट-क्लास टाइप भी कहा जाता है) में बांटा जाता है. ये StableHLO वैल्यू दिखाते हैं. साथ ही, नॉन-वैल्यू टाइप, प्रोग्राम के अन्य एलिमेंट के बारे में बताते हैं. StableHLO टाइप, कई प्रोग्रामिंग भाषाओं के टाइप से मिलते-जुलते हैं. इनमें मुख्य खास बात यह है कि StableHLO, डोमेन के हिसाब से काम करता है. इसकी वजह से, कुछ असामान्य नतीजे मिलते हैं. उदाहरण के लिए, स्केलर टाइप, वैल्यू टाइप नहीं होते.

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

टेन्सर के टाइप टेंसर यानी कई डाइमेंशन वाले सरणियों को दिखाते हैं. इनमें एक आकार और एक एलिमेंट टाइप होता है. आकार, डाइमेंशन के साइज़ को दिखाता है. ये साइज़, डाइमेंशन (जिन्हें ऐक्सिस भी कहा जाता है) के बढ़ते क्रम में होते हैं. इन डाइमेंशन की संख्या 0 से R-1 तक होती है. डाइमेंशन R की संख्या को रैंक कहा जाता है. उदाहरण के लिए, tensor<2x3xf32> एक टेंसर टाइप है, जिसका आकार 2x3 और एलिमेंट टाइप f32 है. इसमें दो डाइमेंशन (या दूसरे शब्दों में, दो ऐक्सिस) हैं - 0वां डाइमेंशन और पहला डाइमेंशन - जिनका साइज़ 2 और 3 है. इसकी रैंक दो है.

आकार, कुछ हद तक या पूरी तरह से अनजान (डाइनैमिक) हो सकते हैं. उदाहरण के लिए, tensor<?x2xf64> कुछ हद तक अनजान है और tensor<?x?xf64> पूरी तरह से अनजान है. डाइनैमिक डाइमेंशन के साइज़ को ? का इस्तेमाल करके दिखाया जाता है. आकारों को रैंक नहीं दिया जा सकता.

आने वाले समय में, हम डाइमेंशन साइज़ और एलिमेंट टाइप के अलावा, टेंसर टाइप को और भी बेहतर बनाने की कोशिश करेंगे. उदाहरण के लिए, लेआउट (#629) और स्पार्सिटी (#1078) को शामिल करने के लिए.

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

एलिमेंट के क्वांटाइज़ किए गए टाइप, स्टोरेज टाइप की इंटेजर वैल्यू दिखाते हैं. ये वैल्यू storage_min से storage_max (इसमें शामिल) की रेंज में होती हैं. ये वैल्यू, एक्सप्रेशन टाइप की फ़्लोटिंग-पॉइंट वैल्यू से मेल खाती हैं. किसी पूर्णांक वैल्यू i के लिए, उससे जुड़ी फ़्लोटिंग-पॉइंट वैल्यू f का हिसाब f = (i - zero_point) * scale के तौर पर लगाया जा सकता है. यहां scale और zero_point को क्वांटाइज़ेशन पैरामीटर कहा जाता है. व्याकरण में storage_min और storage_max वैकल्पिक हैं, लेकिन उनकी डिफ़ॉल्ट वैल्यू क्रमशः min_value(storage_type) और max_value(storage_type) है. क्वांटाइज़ किए गए एलिमेंट टाइप में ये कंस्ट्रेंट होते हैं:

• (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) है, तो size(scales) = 1 है.
• (C11) 0 <= quantization_dimension.

फ़िलहाल, QuantizationScale एक फ़्लोटिंग-पॉइंट कॉन्स्टेंट है. हालांकि, कई लोगों की दिलचस्पी पूर्णांक पर आधारित स्केल में है. इन्हें मल्टीप्लायर और शिफ़्ट के साथ दिखाया जाता है. हम आने वाले समय में, इस पर काम करने की योजना बना रहे हैं (#1404).

QuantizationZeroPoint के सेमेंटेक्स पर फ़िलहाल चर्चा चल रही है. इसमें टाइप, वैल्यू, और यह भी शामिल है कि क्वांटाइज़ किए गए टेंसर टाइप में सिर्फ़ एक या संभावित रूप से कई शून्य पॉइंट हो सकते हैं या नहीं. इस चर्चा के नतीजों के आधार पर, आने वाले समय में शून्य पॉइंट के बारे में जानकारी बदल सकती है (#1405).

QuantizationStorageMin और QuantizationStorageMax के सेमेटिक्स के बारे में भी चर्चा की जा रही है. इससे यह तय किया जा सकेगा कि इन वैल्यू और क्वांटाइज़ किए गए टेंसर की वैल्यू पर कोई पाबंदी लगाई जानी चाहिए या नहीं (#1406).

आखिर में, हम अनजान स्केल और शून्य बिंदुओं को दिखाने के बारे में एक्सप्लोर करने जा रहे हैं. ठीक उसी तरह जैसे हम अनजान डाइमेंशन साइज़ (#1407) को दिखाने के बारे में एक्सप्लोर कर रहे हैं.

क्वांटाइज़्ड टेंसर टाइप, क्वांटाइज़्ड एलिमेंट वाले टेंसर दिखाते हैं. ये टेंसर, सामान्य टेंसर की तरह ही होते हैं. हालांकि, इनके एलिमेंट में सामान्य एलिमेंट टाइप के बजाय, क्वांटाइज़ किए गए एलिमेंट टाइप होते हैं.

क्वांटाइज़ किए गए टेंसर में, क्वांटाइज़ेशन हर टेंसर के लिए हो सकता है. इसका मतलब है कि पूरे टेंसर के लिए एक scale और zero_point हो सकता है. इसके अलावा, क्वांटाइज़ेशन हर ऐक्सिस के लिए भी हो सकता है. इसका मतलब है कि एक खास डाइमेंशन quantization_dimension के हर स्लाइस के लिए एक जोड़ा, कई scales और zero_points हो सकते हैं. ज़्यादा औपचारिक तौर पर, हर ऐक्सिस के लिए क्वांटाइज़ेशन वाले टेंसर t में, quantization_dimension की dim(t, quantization_dimension) स्लाइस होती हैं: t[:, ..., 0, ..., :], t[:, ..., 1, ..., :] वगैरह. iवीं स्लाइस के सभी एलिमेंट, अपने क्वांटाइज़ेशन पैरामीटर के तौर पर scales[i] और zero_points[i] का इस्तेमाल करते हैं. क्वांटाइज़्ड टेंसर टाइप की ये सीमाएं होती हैं:

• हर टेंसर के लिए क्वांटाइज़ेशन के लिए:
  • कोई और पाबंदी नहीं.
• हर अक्ष के लिए क्वांटिज़ेशन के लिए:
  • (C12) quantization_dimension < rank(self).
  • (C13) dim(self, quantization_dimension) = size(scales).

TokenType ::= 'token'

टोकन टाइप, टोकन दिखाते हैं. टोकन, ऐसी वैल्यू होती हैं जिन्हें कुछ ऑपरेशन से जनरेट और इस्तेमाल किया जाता है. टोकन का इस्तेमाल कार्रवाइयों को लागू करने का ऑर्डर देने के लिए किया जाता है. जैसा कि लागू करना सेक्शन में बताया गया है.

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

ट्यूपल टाइप, ट्यूपल यानी अलग-अलग तरह की सूचियों को दिखाते हैं. टपल, एक लेगसी सुविधा है, जो सिर्फ़ एचएलओ (HLO) के साथ काम करने के लिए मौजूद है. एचएलओ में, वैरिएडिक इनपुट और आउटपुट को दिखाने के लिए ट्यूपल का इस्तेमाल किया जाता है. StableHLO में, वैरिएडिक इनपुट और आउटपुट का इस्तेमाल, नेटिव तौर पर किया जा सकता है. StableHLO में ट्यूपल का इस्तेमाल सिर्फ़ HLO ABI को पूरी तरह से दिखाने के लिए किया जाता है. उदाहरण के लिए, किसी खास तरीके से लागू करने पर T, tuple<T>, और tuple<tuple<T>> काफ़ी अलग हो सकते हैं. आने वाले समय में, हम एचएलओ एबीआई में बदलाव करने की योजना बना रहे हैं. इससे हम StableHLO (#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'

एलिमेंट टाइप, टेंसर टाइप के एलिमेंट दिखाते हैं. कई प्रोग्रामिंग भाषाओं के उलट, StableHLO में ये टाइप फ़र्स्ट क्लास नहीं होते. इसका मतलब है कि StableHLO प्रोग्राम, सीधे तौर पर इस तरह की वैल्यू नहीं दिखा सकते. इस वजह से, T टाइप की अदिश वैल्यू को tensor<T> टाइप के 0-डाइमेंशन वाले टेंसर वैल्यू के साथ दिखाना मुहावरेदार होता है.

• बूलियन टाइप, बूलियन वैल्यू true और false दिखाता है.
• इंटिजर टाइप, साइन वाले (si) या बिना साइन वाले (ui) हो सकते हैं. साथ ही, इनमें इस्तेमाल की जा सकने वाली बिट की चौड़ाई (2, 4, 8, 16, 32 या 64) में से कोई एक होनी चाहिए. साइन वाले siN टाइप, -2^(N-1) से लेकर 2^(N-1)-1 तक की इंटिजर वैल्यू दिखाते हैं. वहीं, बिना साइन वाले uiN टाइप, 0 से लेकर 2^N-1 तक की इंटिजर वैल्यू दिखाते हैं.
• फ़्लोटिंग-पॉइंट टाइप इनमें से कोई एक हो सकता है:
  • आईईईई-754 कन्वेंशन के मुताबिक f8E3M4, f8E4M3, और f8E5M2 8-बिट फ़्लोटिंग पॉइंट नंबर.
  • f8E4M3FN और f8E5M2 टाइप, डीप लर्निंग के लिए FP8 फ़ॉर्मैट में बताए गए FP8 फ़ॉर्मैट के E4M3 और E5M2 कोडिंग से जुड़े होते हैं.
  • डीप न्यूरल नेटवर्क के लिए 8-बिट नंबर वाले फ़ॉर्मैट में बताए गए, FP8 फ़ॉर्मैट के E4M3 और E5M2 एन्कोडिंग से जुड़े f8E4M3FNUZ और f8E5M2FNUZ टाइप.
  • f8E4M3B11FNUZ टाइप, FP8 फ़ॉर्मैट के E4M3 एन्कोडिंग से जुड़ा है. इन फ़ॉर्मैट के बारे में हाइब्रिड 8-बिट फ़्लोटिंग पॉइंट (HFP8) ट्रेनिंग और डीप न्यूरल नेटवर्क के लिए अनुमान में बताया गया है.
  • bf16 टाइप, bfloat16 फ़ॉर्मैट से मेल खाता है. इस फ़ॉर्मैट के बारे में BFloat16: Cloud TPUs पर बेहतर परफ़ॉर्मेंस का राज में बताया गया है.
  • f16, f32, और f64 टाइप, IEEE 754 स्टैंडर्ड में बताए गए binary16 ("हफ़्फ़ प्रिसीज़न"), binary32 ("सिंगल प्रिसीज़न"), और binary64 ("डबल प्रिसीज़न") फ़ॉर्मैट के हिसाब से होते हैं.
  • tf32 टाइप, TensorFloat32 फ़ॉर्मैट से जुड़ा होता है और StableHLO में सीमित तौर पर काम करता है.
  • f4E2M1FN, f6E2M3FN, f6E3M2FN, और f8E8M0FNU एमएक्स (माइक्रोस्केलिंग) टाइप, जिनके बारे में ओसीपी माइक्रोस्केलिंग फ़ॉर्मैट स्पेसिफ़िकेशन में बताया गया है.
• कॉम्प्लेक्स टाइप, कॉम्प्लेक्स वैल्यू दिखाते हैं. इनमें एक ही एलिमेंट टाइप के रीयल पार्ट और इमैजरी पार्ट होते हैं. इस्तेमाल किए जा सकने वाले जटिल टाइप में complex<f32> (दोनों पार्ट f32 टाइप के हैं) और complex<f64> (दोनों पार्ट f64 टाइप के हैं) शामिल हैं.

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

फ़ंक्शन टाइप नाम वाले और पहचान छिपाने वाले, दोनों तरह के फ़ंक्शन दिखाते हैं. इनमें इनपुट टाइप (-> की बाईं ओर मौजूद टाइप की सूची) और आउटपुट टाइप (-> की दाईं ओर मौजूद टाइप की सूची) होते हैं. कई प्रोग्रामिंग भाषाओं में, फ़ंक्शन टाइप फ़र्स्ट क्लास होते हैं, लेकिन StableHLO में नहीं.

StringType ::= 'string'

स्ट्रिंग टाइप, बाइट के क्रम को दिखाता है. कई प्रोग्रामिंग भाषाओं के उलट, StableHLO में स्ट्रिंग टाइप फ़र्स्ट क्लास नहीं है. इसका इस्तेमाल सिर्फ़ प्रोग्राम एलिमेंट के लिए स्टैटिक मेटाडेटा तय करने के लिए किया जाता है.

ऑपरेशंस

StableHLO ऑपरेशन (जिन्हें ऑपरेशन भी कहा जाता है), मशीन लर्निंग मॉडल में हाई-लेवल ऑपरेशन के क्लोज़्ड सेट को दिखाते हैं. जैसा कि ऊपर बताया गया है, StableHLO सिंटैक्स काफ़ी हद तक MLIR से प्रेरित है. यह ज़रूरी नहीं है कि यह सबसे बेहतर विकल्प हो, लेकिन यह StableHLO के लक्ष्य के लिए सबसे सही विकल्प है. इस लक्ष्य का मकसद, ML फ़्रेमवर्क और ML कंपाइलर के बीच ज़्यादा इंटरऑपरेबिलिटी बनाना है.

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

StableHLO ऑपरेशन (जिन्हें ops भी कहा जाता है) का एक नाम, इनपुट/आउटपुट, और एक सिग्नेचर होता है. नाम में stablehlo. प्रीफ़िक्स और निमोनिक शामिल है, जो इस्तेमाल किए जा सकने वाले ऑपरेशन में से किसी एक की खास तौर पर पहचान करता है. इस्तेमाल किए जा सकने वाले सभी ऑपरेशन की पूरी सूची देखने के लिए, नीचे देखें.

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

ऑपरेशन, इनपुट का इस्तेमाल करते हैं और आउटपुट जनरेट करते हैं. इनपुट को इन कैटगरी में बांटा जाता है: इनपुट वैल्यू (एक्सीक्यूशन के दौरान कैलकुलेट की जाती हैं), इनपुट फ़ंक्शन (स्टैटिक तौर पर दिए जाते हैं, क्योंकि StableHLO फ़ंक्शन में फ़ंक्शन, फ़र्स्ट-क्लास वैल्यू नहीं होते), और इनपुट एट्रिब्यूट (इन्हें भी स्टैटिक तौर पर दिया जाता है). किसी ऑपरेशन में इस्तेमाल किए जाने वाले इनपुट और आउटपुट का टाइप, उसके मेनिमनिक पर निर्भर करता है. उदाहरण के लिए, addop, दो इनपुट वैल्यू का इस्तेमाल करता है और एक आउटपुट वैल्यू जनरेट करता है. इसकी तुलना में, select_and_scatter ऑपरेटर तीन इनपुट वैल्यू, दो इनपुट फ़ंक्शन, और तीन इनपुट एट्रिब्यूट का इस्तेमाल करता है.

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

इनपुट फ़ंक्शन (जिन्हें बिना नाम वाले फ़ंक्शन भी कहा जाता है) बहुत हद तक नाम वाले फ़ंक्शन से मिलते-जुलते हैं. हालांकि, इनमें ये अंतर होते हैं: 1) इनमें कोई आइडेंटिफ़ायर नहीं होता (इसलिए इनका नाम "बिना नाम वाला" है), 2) इनमें आउटपुट टाइप का एलान नहीं किया जाता (आउटपुट टाइप का पता, फ़ंक्शन में मौजूद return ऑपरेटर से लगाया जाता है).

इनपुट फ़ंक्शन के सिंटैक्स में अभी इस्तेमाल न किया गया हिस्सा शामिल है (ऊपर दिया गया Unused प्रोडक्शन देखें). यह एमएलआईआर के साथ काम करने के लिए मौजूद है. MLIR में, "क्षेत्रों" का एक सामान्य कॉन्सेप्ट है. इनमें जंप ऑपरेशन की मदद से, ऑपरेशन के कई "ब्लॉक" एक साथ जुड़े हो सकते हैं. इन ब्लॉक में ऐसे आईडी होते हैं जो Unused प्रोडक्शन से जुड़े होते हैं, ताकि उन्हें एक-दूसरे से अलग किया जा सके. StableHLO में जंप ऑपरेशन नहीं होते, इसलिए MLIR सिंटैक्स का उससे जुड़ा हिस्सा इस्तेमाल नहीं किया जाता (हालांकि, वह अब भी मौजूद है).

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

इनपुट एट्रिब्यूट का एक नाम और वैल्यू होती है, जो काम करने वाली स्थिर वैल्यू में से एक होती है. प्रोग्राम एलिमेंट के लिए स्टैटिक मेटाडेटा तय करने का मुख्य तरीका यही है. उदाहरण के लिए, concatenate ऑपरेटर, dimension एट्रिब्यूट का इस्तेमाल करके उस डाइमेंशन की जानकारी देता है जिसके साथ इनपुट वैल्यू को जोड़ा जाता है. इसी तरह, slice ऑपरेटर, इनपुट वैल्यू को स्लाइस करने के लिए इस्तेमाल किए जाने वाले सीमाओं की जानकारी देने के लिए, start_indices और limit_indices जैसे कई एट्रिब्यूट का इस्तेमाल करता है.

फ़िलहाल, आम तौर पर इस्तेमाल किए जा रहे StableHLO प्रोग्राम में कभी-कभी ऐसे एट्रिब्यूट होते हैं जिनके बारे में इस दस्तावेज़ में नहीं बताया गया है. आने वाले समय में, हम इन एट्रिब्यूट को StableHLO ऑपसेट में शामिल करने या StableHLO प्रोग्राम में दिखने से रोकने की योजना बना रहे हैं. इस बीच, यहां इन एट्रिब्यूट की सूची दी गई है:

• layout (#629).
• mhlo.frontend_attributes (#628).
• mhlo.sharding (#619).
• output_operand_aliases (#740).
• जगह की जानकारी का मेटाडेटा (#594).

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

ऑपरेशन के सिग्नेचर में, सभी इनपुट वैल्यू के टाइप (-> की बाईं ओर टाइप की सूची) और सभी आउटपुट वैल्यू के टाइप (-> की दाईं ओर टाइप की सूची) शामिल होते हैं. असल में, इनपुट टाइप और आउटपुट टाइप, दोनों ही ज़रूरी नहीं होते. ऐसा इसलिए है, क्योंकि ज़्यादातर StableHLO ऑपरेशन के लिए, इनपुट से आउटपुट टाइप का पता लगाया जा सकता है. इसके बावजूद, MLIR के साथ काम करने के लिए, op signature को StableHLO सिंटैक्स का हिस्सा बनाया गया है.

नीचे एक ऑप का उदाहरण दिया गया है जिसका स्मरणक (स्मरण) select_and_scatter है. इसमें तीन इनपुट वैल्यू (%operand, %source, और %init_value), दो इनपुट फ़ंक्शन, और तीन इनपुट एट्रिब्यूट (window_dimensions, window_strides, और padding) इस्तेमाल किए जाते हैं. ध्यान दें कि ऑपरेशन के सिग्नेचर में सिर्फ़ इनपुट वैल्यू के टाइप शामिल होते हैं, न कि इनलाइन में दिए गए इनपुट फ़ंक्शन और एट्रिब्यूट के टाइप.

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

कॉन्स्टेंट

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

StableHLO कॉन्स्टेंट में एक लिटरल और एक टाइप होता है, जो एक साथ StableHLO वैल्यू दिखाता है. आम तौर पर, टाइप कॉन्सटेंट सिंटैक्स का हिस्सा होता है. हालांकि, जब यह साफ़ तौर पर पता न हो (उदाहरण के लिए, बूलियन कॉन्सटेंट में टाइप i1 होता है, जबकि इंटीजर कॉन्सटेंट में, कई तरह के संभावित टाइप हो सकते हैं).

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

बूलियन कॉन्सटेंट, बूलियन वैल्यू true और false को दिखाते हैं. बूलियन कॉन्सटेंट का टाइप i1 होता है.

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

पूर्णांक कॉन्स्टेंट, दशमलव या हेक्साडेसिमल नोटेशन का इस्तेमाल करने वाली स्ट्रिंग के ज़रिए पूर्णांक वैल्यू दिखाते हैं. बाइनरी या ऑक्टल जैसे अन्य बेस का इस्तेमाल नहीं किया जा सकता. पूर्णांक के लिए, ये पाबंदियां लागू होती हैं:

• (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]

फ़्लोटिंग-पॉइंट कॉन्स्टेंट, स्ट्रिंग के ज़रिए फ़्लोटिंग-पॉइंट वैल्यू दिखाते हैं. इन स्ट्रिंग में दशमलव या वैज्ञानिक नोटेशन का इस्तेमाल किया जाता है. इसके अलावा, हैक्साडेसिमल नोटेशन का इस्तेमाल करके, संबंधित टाइप के फ़्लोटिंग-पॉइंट फ़ॉर्मैट में, बिट की जानकारी सीधे तौर पर दी जा सकती है. फ़्लोटिंग-पॉइंट की वैल्यू के लिए ये पाबंदियां हैं:

• (C1) अगर हेक्साडेसिमल नोटेशन का इस्तेमाल नहीं किया जाता है, तो is_wellformed(float_literal, float_type).
• (C2) अगर हेक्साडेसिमल नोटेशन का इस्तेमाल किया जाता है, तो size(hexadecimal_digits) = num_bits(float_type) / 4.

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

कॉम्प्लेक्स कॉन्स्टेंट, रीयल पार्ट (पहले आता है) और इमेजरी पार्ट (दूसरे नंबर पर आता है) की सूचियों का इस्तेमाल करके कॉम्प्लेक्स वैल्यू दिखाते हैं. उदाहरण के लिए, (1.0, 0.0) : complex<f32> से 1.0 + 0.0i और (0.0, 1.0) : complex<f32> से 0.0 + 1.0i का पता चलता है. इसके बाद, मेमोरी में इन हिस्सों को सेव करने का क्रम तय होता है. कॉम्प्लेक्स कॉन्स्टेंट के लिए ये पाबंदियां लागू होती हैं:

• (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

टेन्सर कॉन्सटेंट, NumPy नोटेशन के ज़रिए बताई गई नेस्ट की गई सूचियों का इस्तेमाल करके टेंसर वैल्यू दिखाता है. उदाहरण के लिए, dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>, इंडेक्स से एलिमेंट तक की इस मैपिंग के साथ टेंसर वैल्यू दिखाता है: {0, 0} => 1, {0, 1} => 2, {0, 2} => 3, {1, 0} => 4, {1, 1} => 5, {1, 2} => 6. इन एलिमेंट को मेमोरी में किस क्रम में सेव किया जाता है, यह लागू करने के तरीके पर निर्भर करता है. टेन्सर कॉन्सटेंट में ये कंस्ट्रेंट होते हैं:

• (C1) has_syntax(tensor_literal, element_type(tensor_type)), जहां:
  • 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)), जहां:
  • 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:]).
  • इसके अलावा, false.

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

क्वांटाइज़ किए गए टेंसर कॉन्स्टेंट, टेंसर कॉन्स्टेंट के जैसे ही नोटेशन का इस्तेमाल करके, क्वांटाइज़ किए गए टेंसर वैल्यू दिखाते हैं. इनमें एलिमेंट को स्टोरेज टाइप के कॉन्स्टेंट के तौर पर दिखाया जाता है. क्वांटाइज़ किए गए टेंसर कॉन्स्टेंट पर ये पाबंदियां लागू होती हैं:

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

स्ट्रिंग लिटरल में, ASCII वर्णों और एस्केप सीक्वेंस का इस्तेमाल करके तय किए गए बाइट होते हैं. ये कोड, कोडिंग के हिसाब से काम नहीं करते. इसलिए, इन बाइट को लागू करने के तरीके के हिसाब से ही इनका मतलब निकाला जा सकता है. स्ट्रिंग लिटरल का टाइप string होता है.

ऑपरेशन

कुल

सिमैंटिक

operand टेंसर पर एलिमेंट के हिसाब से, एब्स ऑपरेशन करता है और result टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:

• साइन वाले पूर्णांकों के लिए: पूर्णांक मॉड्यूल.
• फ़्लोट के लिए: IEEE-754 से abs.
• सम्मिश्र संख्याओं के लिए: जटिल मापांक.
• क्वांटाइज़ किए गए टाइप के लिए: dequantize_op_quantize(abs, operand, type(result)).

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) shape(result) = shape(operand).
• (C2) baseline_element_type(result) को इस तरह परिभाषित किया गया है:
  • अगर is_complex(operand) है, तो complex_element_type(element_type(operand)).
  • अगर ऐसा नहीं है, तो baseline_element_type(operand).

उदाहरण

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

 ज़्यादा उदाहरण

जोड़ें

सिमैंटिक

दो टेंसर lhs और rhs को एलिमेंट के हिसाब से जोड़ता है और इससे एक result टेंसर बनता है. एलिमेंट टाइप के आधार पर, ये काम किए जाते हैं:

• बूलियन के लिए: लॉजिकल OR.
• पूर्णांक के लिए: पूर्णांक जोड़ना.
• फ़्लोट के लिए: IEEE-754 से addition.
• कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स नंबर जोड़ना.
• क्वांटाइज़्ड टाइप के लिए: dequantize_op_quantize(add, lhs, rhs, type(result)).

इनपुट

आउटपुट

कंस्ट्रेंट

• अगर इस संक्रिया में बिना मात्रा वाले टेंसर का इस्तेमाल किया गया है, तो:
  • (C1) type(lhs) = type(rhs) = type(result).
• अगर इस ऑपरेशन में क्वांटाइज़्ड टेंसर का इस्तेमाल किया गया है:
  • (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) है, तो quantization_dimension(lhs) = quantization_dimension(result) है.
  • (C7) अगर is_per_axis_quantized(rhs) है, तो quantization_dimension(rhs) = quantization_dimension(result) है.

उदाहरण

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

 ज़्यादा उदाहरण

after_all

सिमैंटिक्स

यह पक्का करता है कि inputs को बनाने वाले ऑपरेशन, result पर आधारित किसी भी ऑपरेशन से पहले लागू हों. इस ऑपरेशन को लागू करने से कुछ नहीं होता. यह सिर्फ़ result से inputs तक डेटा डिपेंडेंसी सेट अप करने के लिए मौजूद है.

इनपुट

आउटपुट

उदाहरण

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

 ज़्यादा उदाहरण

all_gather

सिमैंटिक

StableHLO प्रोसेस ग्रिड के हर प्रोसेस ग्रुप में, all_gather_dim के साथ हर प्रोसेस के operands टेंसर की वैल्यू को जोड़ता है और results टेंसर बनाता है.

यह ऑपरेशन, StableHLO प्रोसेस ग्रिड को process_groups में बांटता है, जिसे इस तरह परिभाषित किया गया है:

• cross_replica(replica_groups) अगर channel_id <= 0 and use_global_device_ids = false है, तो.
• cross_replica_and_partition(replica_groups) अगर channel_id > 0 and use_global_device_ids = false है, तो.
• flattened_ids(replica_groups) अगर channel_id > 0 and use_global_device_ids = true है, तो.

इसके बाद, हर process_group में:

• process_group में सभी receiver के लिए operands...@receiver = [operand@sender for sender in process_group].
• process_group में सभी के लिए results...@process = concatenate(operands...@process, all_gather_dim) process.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) 0 <= all_gather_dim < rank(operands...).
• (C2) is_unique(replica_groups).
• (C3) size(replica_groups) की परिभाषा इस तरह दी गई है:
  • num_replicas, अगर cross_replica का इस्तेमाल किया गया हो.
  • num_replicas, अगर cross_replica_and_partition का इस्तेमाल किया गया हो.
  • num_processes, अगर flattened_ids का इस्तेमाल किया गया हो.
• (C4) 0 <= replica_groups < size(replica_groups).
• (C5) अगर use_global_device_ids = true है, तो channel_id > 0 है.
• (C6) type(results...) = type(operands...) इनके अलावा:
  • dim(results..., all_gather_dim) = dim(operands..., all_gather_dim) * dim(process_groups, 1).

उदाहरण

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

ज़्यादा उदाहरण

all_reduce

सिमैंटिक्स

StableHLO प्रोसेस ग्रिड में मौजूद प्रोसेस ग्रुप के हर प्रोसेस ग्रुप में, हर प्रोसेस से operands टेंसर की वैल्यू पर रिडक्शन फ़ंक्शन computation लागू करता है और results टेंसर बनाता है.

यह ऑपरेशन, StableHLO प्रोसेस ग्रिड को process_groups में बांटता है, जिसे इस तरह परिभाषित किया गया है:

• cross_replica(replica_groups) अगर channel_id <= 0 and use_global_device_ids = false है, तो.
• cross_replica_and_partition(replica_groups) अगर channel_id > 0 and use_global_device_ids = false है, तो.
• flattened_ids(replica_groups) अगर channel_id > 0 and use_global_device_ids = true है, तो.

इसके बाद, हर process_group में:

• results...@process[result_index] = exec(schedule) कुछ बाइनरी ट्री के लिए schedule जहां:
  • exec(node) = computation(exec(node.left), exec(node.right)).
  • exec(leaf) = leaf.value.
• schedule, लागू करने के तरीके से तय की गई बाइनरी ट्री है, जिसका क्रम से traversal to_destination_type(operands...@process_group...[result_index], type(func_inputs(computation)[0])) है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) is_unique(replica_groups).
• (C2) size(replica_groups) की परिभाषा इस तरह दी गई है:
  • num_replicas, अगर cross_replica का इस्तेमाल किया गया हो.
  • num_replicas, अगर cross_replica_and_partition का इस्तेमाल किया गया हो.
  • num_processes, अगर flattened_ids का इस्तेमाल किया गया हो.
• (C3) 0 <= replica_groups < size(replica_groups).
• (C4) अगर use_global_device_ids = true है, तो channel_id > 0 है.
• (C5) computation का टाइप (tensor<E>, tensor<E>) -> (tensor<E>) है, जहां is_promotable(element_type(operand), E).
• (C6) shape(results...) = shape(operands...).
• (C7) element_type(results...) = E.

उदाहरण

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

 ज़्यादा उदाहरण

all_to_all

सिमैंटिक

StableHLO प्रोसेस ग्रिड में हर प्रोसेस ग्रुप में, split_dimension के साथ operands टेंसर की वैल्यू को अलग-अलग हिस्सों में बांटता है. साथ ही, अलग किए गए हिस्सों को प्रोसेस के बीच में अलग-अलग जगहों पर डालता है. इसके बाद, अलग-अलग जगहों पर डाले गए हिस्सों को concat_dimension के साथ जोड़ता है और results टेंसर बनाता है. यह कार्रवाई StableHLO प्रोसेस ग्रिड को process_groups में बांट देती है. इसकी जानकारी इस तरह से दी गई है:

• अगर channel_id <= 0 है, तो cross_replica(replica_groups).
• अगर channel_id > 0 है, तो cross_partition(replica_groups).

इसके बाद, हर process_group में:

• process_group में सभी sender के लिए split_parts...@sender = split(operands...@sender, split_count, split_dimension) .
• scattered_parts...@receiver = [split_parts...@sender[receiver_index] for sender in process_group] जहां receiver_index = process_group.index(receiver).
• results...@process = concatenate(scattered_parts...@process, concat_dimension).

इनपुट

आउटपुट

कंस्ट्रेंट

• (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) को इस तरह परिभाषित किया गया है:
  • num_replicas, अगर cross_replica का इस्तेमाल किया गया हो.
  • अगर cross_partition का इस्तेमाल किया जाता है, तो num_partitions.
• (C7) 0 <= replica_groups < size(replica_groups).
• (C8) dim(replica_groups, 1) = split_count.
• (C9) type(results...) = type(operands...), अगर split_dimension != concat_dimension:
  • dim(results..., split_dimension) = dim(operands..., split_dimension) / split_count.
  • dim(results..., concat_dimension) = dim(operands..., concat_dimension) * split_count.

उदाहरण

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

 ज़्यादा उदाहरण

और

सिमैंटिक्स

यह दो टेंसर lhs और rhs के एलिमेंट के हिसाब से AND फ़ंक्शन करता है और result टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:

• बूलियन के लिए: लॉजिकल ऐंड.
• पूर्णांकों के लिए: बिटवाइज़ AND.

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

atan2

सिमैंटिक्स

lhs और rhs टेंसर पर, एलिमेंट के हिसाब से atan2 ऑपरेशन करता है और एक result टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:

• फ़्लोट के लिए: IEEE-754 से atan2.
• कॉम्प्लेक्स नंबर के लिए: complex atan2.
• क्वांटाइज़ किए गए टाइप के लिए: dequantize_op_quantize(atan2, lhs, rhs, type(result)).

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

batch_norm_grad

सिमैंटिक

grad_output से batch_norm_training बैकप्रोपगेट करने वाले कई इनपुट के ग्रेडिएंट का हिसाब लगाता है और grad_operand, grad_scale, और grad_offset टेन्सर बनाता है. ज़्यादा औपचारिक तौर पर, इस ऑपरेशन को मौजूदा StableHLO ऑपरेशन के डिकंपोज़िशन के तौर पर दिखाया जा सकता है. इसके लिए, Python सिंटैक्स का इस्तेमाल इस तरह किया जा सकता है:

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

संख्या में दिखाए जा सकने वाले डेटा टाइप के लिए, 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)) करता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) 0 <= feature_index < rank(operand).
• (C2) operand, scale, mean, variance, grad_output, grad_operand, grad_scale, और grad_offset का baseline_element_type एक ही है.
• (C3) operand, grad_output, और grad_operand का आकार एक जैसा है.
• (C4) scale, mean, variance, grad_scale, और grad_offset का आकार एक जैसा है.
• (C5) size(scale) = dim(operand, feature_index).

उदाहरण

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

सिमैंटिक्स

feature_index डाइमेंशन को छोड़कर, सभी डाइमेंशन में operand टेंसर को सामान्य बनाता है और result टेंसर बनाता है. ज़्यादा औपचारिक तौर पर, इस ऑपरेशन को मौजूदा StableHLO ऑपरेशन के डिकंपोज़िशन के तौर पर दिखाया जा सकता है. इसके लिए, Python सिंटैक्स का इस्तेमाल इस तरह किया जा सकता है:

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)

संख्या में दिखाए जा सकने वाले डेटा टाइप के लिए, 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)) करता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) 0 <= feature_index < rank(operand).
• (C2) operand, scale, offset, mean, variance, और result का 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).

उदाहरण

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

सिमैंटिक्स

feature_index डाइमेंशन को छोड़कर, सभी डाइमेंशन के माध्य और वैरियंस कैलकुलेट करता है. साथ ही, output, batch_mean, और batch_var टेंसर बनाने वाले operand टेंसर को नॉर्मलाइज़ करता है. ज़्यादा औपचारिक तौर पर, इस ऑपरेशन को मौजूदा StableHLO ऑपरेशन के डिकंपोज़िशन के तौर पर दिखाया जा सकता है. इसके लिए, Python सिंटैक्स का इस्तेमाल इस तरह किया जा सकता है:

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

संख्या में दिखाए जा सकने वाले डेटा टाइप के लिए, 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)) करता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) 0 <= feature_index < rank(operand).
• (C2) operand, scale, offset, batch_mean, batch_var, और output में एक ही 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).

उदाहरण

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

सिमैंटिक्स

operand टेंसर पर बिटकास्ट कार्रवाई करता है और result टेंसर बनाता है, जहां पूरे operand टेंसर के बिट, result टेंसर के टाइप का इस्तेमाल करके फिर से समझे जाते हैं.

ज़्यादा औपचारिक तौर पर, E = element_type(operand), E' = element_type(result), और R = rank(operand) के लिए:

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

bits, किसी दी गई वैल्यू को मेमोरी में दिखाता है. इसका व्यवहार, लागू करने के तरीके के हिसाब से तय होता है, क्योंकि टेंसर के सटीक तौर पर दिखाए जाने का तरीका, लागू करने के तरीके के हिसाब से तय होता है. साथ ही, एलिमेंट टाइप के सटीक तौर पर दिखाए जाने का तरीका भी, लागू करने के तरीके के हिसाब से तय होता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) E = is_quantized(operand) ? storage_type(operand) : element_type(operand), E' = is_quantized(result) ? storage_type(result) : element_type(result), और R = rank(operand) के लिए:
  • अगर num_bits(E') = num_bits(E), shape(result) = shape(operand).
  • अगर num_bits(E') < num_bits(E):
  • rank(result) = R + 1.
  • dim(result, i) = dim(operand, i) के लिए सभी 0 <= i < R.
  • dim(result, R) * num_bits(E') = num_bits(E).
  • अगर num_bits(E') > num_bits(E):
  • rank(result) = R - 1.
  • dim(result, i) = dim(operand, i) के लिए सभी 0 <= i < R.
  • dim(operand, R - 1) * num_bits(E) = num_bits(E').
• (C2) अगर is_complex(operand) or is_complex(result) है, तो is_complex(operand) and is_complex(result).

उदाहरण

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

ज़्यादा उदाहरण

broadcast_in_dim

सिमैंटिक्स

operand टेंसर में मौजूद डेटा का डुप्लीकेट बनाकर, किसी इनपुट टेंसर के डाइमेंशन और/या रैंक को बड़ा करता है. साथ ही, result टेंसर बनाता है. ज़्यादा औपचारिक तौर पर, result[result_index] = operand[operand_index] जहां axes(operand) में सभी d के लिए:

• अगर dim(operand, d) = 1 है, तो operand_index[d] = 0.
• operand_index[d] = result_index[broadcast_dimensions[d]] अन्य मामलों में.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) element_type(result) देने वाली कंपनी:
  • अगर !is_per_axis_quantized(operand) है, तो element_type(operand).
  • element_type(operand), हालांकि quantization_dimension(operand), scales(operand), और zero_points(operand), quantization_dimension(result), scales(result), और zero_points(result) से अलग हो सकते हैं.
• (C2) size(broadcast_dimensions) = rank(operand).
• (C3) 0 <= broadcast_dimensions < rank(result).
• (C4) is_unique(broadcast_dimensions).
• (C5) axes(operand) में मौजूद सभी d के लिए:
  • dim(operand, d) = 1 या
  • dim(operand, d) = dim(result, broadcast_dimensions[d]).
• (C6) अगर is_per_axis_quantized(result):
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)].
  • अगर dim(operand, quantization_dimension(operand)) = 1 है, तो scales(result)[i] = scales(operand)[0] and zero_points(result)[i] = zero_points(operand)[0] for i in range(dim(result, quantization_dimension(result))).

उदाहरण

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

 ज़्यादा उदाहरण

केस

सिमैंटिक

index की वैल्यू के आधार पर, branches में से किसी एक फ़ंक्शन को चलाकर आउटपुट जनरेट करता है. ज़्यादा औपचारिक तौर पर, result = selected_branch() जहां:

• अगर 0 <= index < size(branches) है, तो selected_branch = branches[index].
• अगर ऐसा नहीं है, तो selected_branch = branches[-1].

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

सीबीआरटी

सिमैंटिक

operand टेंसर के हर एलिमेंट पर घनमूल का ऑपरेशन करता है और result टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:

• फ़्लोट के लिए: IEEE-754 से rootn(x, 3).
• कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स क्यूब रूट.
• क्वांटाइज़ किए गए डेटा टाइप के लिए: dequantize_op_quantize(cbrt, operand, type(result))

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

ceil

सिमैंटिक्स

operand टेंसर की एलिमेंट के हिसाब से सेल करता है और result टेंसर बनाता है. IEEE-754 के स्पेसिफ़िकेशन के हिसाब से, roundToIntegralTowardPositive ऑपरेशन लागू करता है. क्वांटाइज़्ड टाइप के लिए, dequantize_op_quantize(ceil, operand, type(result)) की मदद से काम करता है.

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

चोलस्की

सिमैंटिक्स

मैट्रिक्स के बैच का चॉल्स्की डिकंपोज़िशन कैलकुलेट करता है.

ज़्यादा औपचारिक तौर पर, index_space(result) में मौजूद सभी i के लिए, result[i0, ..., iR-3, :, :], a[i0, ..., iR-3, :, :] का कोलेस्की डिकंपोज़िशन है. यह एक लोअर-ट्राएंगल (अगर lower true है) या अपर-ट्राएंगल (अगर lower false है) मैट्रिक्स के तौर पर होता है. इसके उलट, सटीक ऊपरी त्रिभुज या सटीक निचले त्रिभुज में मौजूद आउटपुट वैल्यू, लागू करने के तरीके के हिसाब से तय होती हैं.

अगर i मौजूद है, जहां इनपुट मैट्रिक्स हर्मिटियन पॉज़िटिव-डेफ़िनिट मैट्रिक्स नहीं है, तो बिहेवियर की जानकारी नहीं होती है.

संख्या में दिखाए जा सकने वाले डेटा टाइप के लिए, dequantize_op_quantize(lambda operand: cholesky(operand, lower), a, type(result)) करता है.

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

क्लैंप

सिमैंटिक

operand टेंसर के हर एलिमेंट को कम से कम और ज़्यादा से ज़्यादा वैल्यू के बीच जोड़ता है और result टेंसर बनाता है. औपचारिक रूप से, result[result_index] = minimum(maximum(operand[result_index], min_element), max_element), जहां min_element = rank(min) = 0 ? min[] : min[result_index], max_element = rank(max) = 0 ? max[] : max[result_index]. क्वांटिफ़ाइड टाइप के लिए, dequantize_op_quantize(clamp, min, operand, max, type(result)) की तरह काम करता है.

कॉम्प्लेक्स नंबर का क्रम लागू करने में हैरान करने वाला सिमैंटिक शामिल है. इसलिए, भविष्य में हम इस ऑपरेशन के लिए कॉम्प्लेक्स नंबर (#560) का सपोर्ट हटाने की योजना बना रहे हैं.

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

collective_broadcast

सिमैंटिक्स

StableHLO प्रोसेस ग्रिड के हर प्रोसेस ग्रुप में, सोर्स प्रोसेस से टारगेट प्रोसेस में operand टेंसर की वैल्यू भेजें और result टेंसर बनाएं.

यह ऑपरेशन, StableHLO प्रोसेस ग्रिड को process_groups में बांटता है, जिसे इस तरह परिभाषित किया गया है:

• अगर channel_id <= 0 है, तो cross_replica(replica_groups).
• अगर channel_id > 0 है, तो cross_partition(replica_groups).

इसके बाद, result@process को:

• operand@process_groups[i, 0] अगर कोई ऐसा i मौजूद है कि प्रोसेस process_groups[i] में है.
• अगर ऐसा नहीं करना है, तो broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)).

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) is_unique(replica_groups).
• (C2) 0 <= replica_groups < N जहां N को इस तरह परिभाषित किया गया है:
  • अगर cross_replica का इस्तेमाल किया जाता है, तो num_replicas.
  • num_partitions, अगर cross_partition का इस्तेमाल किया गया हो.
• (C3) type(result) = type(operand).

उदाहरण

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

सिमैंटिक्स

StableHLO प्रोसेस ग्रिड में मौजूद हर प्रोसेस ग्रुप के अंदर, operand टेंसर की वैल्यू को सोर्स प्रोसेस से टारगेट प्रोसेस में भेजता है और result टेंसर बनाता है.

यह ऑपरेशन, StableHLO प्रोसेस ग्रिड को process_groups में बांटता है, जिसे इस तरह परिभाषित किया गया है:

• अगर channel_id <= 0 है, तो cross_replica(source_target_pairs).
• अगर channel_id > 0 है, तो cross_partition(source_target_pairs).

इसके बाद, result@process को:

• operand@process_groups[i, 0], अगर कोई ऐसा i मौजूद है कि process_groups[i, 1] = process.
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) अन्य मामलों में.

इनपुट

आउटपुट

कंस्ट्रेंट

• (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, जहां N का मतलब इस तरह है:
  • num_replicas, अगर cross_replica का इस्तेमाल किया गया हो.
  • अगर cross_partition का इस्तेमाल किया जाता है, तो num_partitions.
• (C5) type(result) = type(operand).

उदाहरण

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

 ज़्यादा उदाहरण

compare

सिमैंटिक्स

comparison_direction और compare_type के मुताबिक, lhs और rhs टेंसर की एलिमेंट के हिसाब से तुलना करता है और result टेंसर बनाता है.

comparison_direction और compare_type की वैल्यू के लिए ये मतलब तय किए गए हैं:

बूलियन और इंटीजर टाइप के एलिमेंट के लिए:

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

compare_type = FLOAT वाले फ़्लोटिंग-पॉइंट एलिमेंट के लिए, op इन IEEE-754 कार्रवाइयों को लागू करता है:

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

compare_type = TOTALORDER वाले फ़्लोटिंग-पॉइंट एलिमेंट टाइप के लिए, ऑपरेटर, IEEE-754 से totalOrder और compareQuietEqual ऑपरेशन के कॉम्बिनेशन का इस्तेमाल करता है.

जटिल एलिमेंट टाइप के लिए, दिए गए comparison_direction और compare_type का इस्तेमाल करके (real, imag) पेयर की लेक्सिकोग्राफ़िक तुलना की जाती है. कॉम्प्लेक्स नंबर के लिए क्रम तय करने पर, कुछ आश्चर्यजनक सेमेटिक्स शामिल होते हैं. इसलिए, आने वाले समय में हम comparison_direction के GE, GT, LE या LT होने पर, कॉम्प्लेक्स नंबर के लिए सहायता हटाने जा रहे हैं (#560).

संख्या में दिखाए जा सकने वाले डेटा टाइप के लिए, dequantize_compare(lhs, rhs, comparison_direction) करता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) baseline_element_type(lhs) = baseline_element_type(rhs).
• (C2) shape(lhs) = shape(rhs) = shape(result).
• (C3) compare_type की परिभाषा इस तरह दी गई है:
  • अगर is_signed_integer(element_type(lhs)) है, तो SIGNED.
  • अगर is_unsigned_integer(element_type(lhs)) or is_boolean(element_type(lhs)) है, तो UNSIGNED.
  • अगर is_float(element_type(lhs)) है, तो FLOAT या TOTALORDER.
  • अगर is_complex(element_type(lhs)) है, तो FLOAT.

उदाहरण

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

ज़्यादा उदाहरण

जटिल

सिमैंटिक्स

यह फ़ंक्शन, lhs और rhs जैसी रीयल और इमेजरी वैल्यू के पेयर से, कॉम्प्लेक्स वैल्यू में एलिमेंट-वाइज़ कन्वर्ज़न करता है. साथ ही, result टेंसर बनाता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) type(lhs) = type(rhs).
• (C2) shape(result) = shape(lhs).
• (C3) element_type(result) का टाइप complex<E> है, जहां E = element_type(lhs) है.

उदाहरण

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

 ज़्यादा उदाहरण

मिश्रित

सिमैंटिक

यह StableHLO के अन्य ऑपरेशन से बना ऑपरेशन होता है. इसमें inputs और composite_attributes को लेकर results बनाया जाता है. ऑपरेशन के सिमेंटिक्स को decomposition एट्रिब्यूट से लागू किया जाता है. प्रोग्राम के सेमेंटेटिक्स में बदलाव किए बिना, composite ऑपरेशन को उसके डिकंपोज़िशन से बदला जा सकता है. जिन मामलों में डेकंपोज़िशन को इनलाइन करने से, ऑपरेटर के लिए एक ही सेमेंटेटिक्स नहीं मिलता, उनमें custom_call का इस्तेमाल करें.

version फ़ील्ड (डिफ़ॉल्ट रूप से 0 पर सेट होता है) का इस्तेमाल, किसी कंपोजिट के सेमैंटिक में बदलाव होने पर जानकारी देने के लिए किया जाता है.

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

जोड़ें

सिमैंटिक्स

inputs को dimension डाइमेंशन के साथ उसी क्रम में जोड़ता है जिस क्रम में दिया गया है. साथ ही, यह result टेंसर बनाता है. ज़्यादा औपचारिक तौर पर, result[i0, ..., id, ..., iR-1] = inputs[k][i0, ..., kd, ..., iR-1], जहां:

1. id = d0 + ... + dk-1 + kd.
2. d, dimension के बराबर है. साथ ही, d0, ... inputs के dवें डाइमेंशन के साइज़ हैं.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) same(element_type(inputs...)).
• (C2) dim(inputs..., dimension) को छोड़कर, 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]), सिवाय:
  • dim(result, dimension) = dim(inputs[0], dimension) + ....

उदाहरण

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

 ज़्यादा उदाहरण

कॉन्सटेंट

सिमैंटिक

कॉन्स्टेंट value से, output टेंसर बनाता है.

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

ग्राहक में बदलने वाले

सिमैंटिक

operand टेंसर पर, एलिमेंट के हिसाब से एक एलिमेंट टाइप से दूसरे एलिमेंट टाइप में बदलाव करता है और result टेंसर बनाता है.

बुलियन-टू-ऐनी-सपोर्टेड-टाइप कन्वर्ज़न के लिए, वैल्यू false को शून्य में बदल दिया जाता है और वैल्यू true को एक में बदल दिया जाता है. any-supported-type-to-boolean कन्वर्ज़न के लिए, शून्य वैल्यू को false में बदला जाता है और शून्य से बड़ी वैल्यू को true में बदला जाता है. जटिल टाइप के लिए, यह सुविधा कैसे काम करती है, यह जानने के लिए नीचे देखें.

पूर्णांक से पूर्णांक, पूर्णांक से फ़्लोटिंग-पॉइंट या फ़्लोटिंग-पॉइंट से फ़्लोटिंग-पॉइंट वाले कन्वर्ज़न के लिए, अगर सोर्स वैल्यू को डेस्टिनेशन टाइप में पूरी तरह से दिखाया जा सकता है, तो नतीजा वैल्यू उसी तरह दिखती है. इसके अलावा, इसकी सुविधा कैसे काम करेगी, यह तय नहीं किया गया है (#180).

फ़्लोटिंग-पॉइंट से पूर्णांक में बदलने वाले कन्वर्ज़न के लिए, भिन्नात्मक भाग को छोटा कर दिया जाता है. अगर छोटी की गई वैल्यू को डेस्टिनेशन टाइप में नहीं दिखाया जा सकता, तो व्यवहार अभी तय नहीं है (#180).

कॉम्प्लेक्स-टू-कॉम्प्लेक्स कन्वर्ज़न, रीयल और इमेजरी पार्ट को बदलने के लिए, फ़्लोटिंग-पॉइंट-टू-फ़्लोटिंग-पॉइंट कन्वर्ज़न के जैसे ही काम करते हैं.

कॉम्प्लेक्स से किसी अन्य टाइप और किसी अन्य टाइप से कॉम्प्लेक्स कन्वर्ज़न के लिए, सोर्स की काल्पनिक वैल्यू को अनदेखा किया जाता है या डेस्टिनेशन की काल्पनिक वैल्यू को शून्य कर दिया जाता है. रीयल पार्ट के कन्वर्ज़न के लिए, फ़्लोटिंग-पॉइंट कन्वर्ज़न का इस्तेमाल किया जाता है.

सिद्धांत रूप से, इस ऑपरेशन से डेक्वांटाइज़ेशन (क्विंटाइज़ किए गए टेंसर को सामान्य टेंसर में बदलना), क्विंटाइज़ेशन (सामान्य टेंसर को क्विंटाइज़ किए गए टेंसर में बदलना), और फिर से क्विंटाइज़ेशन (क्विंटाइज़ किए गए टेंसर के बीच बदलाव) किया जा सकता है. हालांकि, फ़िलहाल हमारे पास इसके लिए खास ऑपरेशन हैं - पहले इस्तेमाल के उदाहरण के लिए uniform_dequantize और दूसरे और तीसरे इस्तेमाल के उदाहरणों के लिए uniform_quantize. आने वाले समय में, इन दोनों ऑपरेशन को convert (#1576) में मर्ज किया जा सकता है.

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

कॉन्वोल्यूशन

सिमैंटिक्स

lhs की विंडो और rhs के स्लाइस के बीच डॉट प्रॉडक्ट का हिसाब लगाता है और result बनाता है. नीचे दिए गए डायग्राम में, उदाहरण के ज़रिए दिखाया गया है कि result में मौजूद एलिमेंट का हिसाब, lhs और rhs से कैसे लगाया जाता है.

lhs की विंडो दिखाने के लिए, इनपुट को lhs के हिसाब से फिर से फ़्रेम करें:

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

रीफ़्रेमिंग के लिए, इन हेल्पर फ़ंक्शन का इस्तेमाल किया जाता है:

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

अगर feature_group_count = 1 और batch_group_count = 1 है, तो index_space(dim(result, output_spatial_dimensions...)) में सभी output_spatial_index के लिए, 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]). ऐसा लगता है कि इस सुविधा का इस्तेमाल नहीं किया जा रहा है. इसलिए, हम आने वाले समय में इसे हटाने वाले हैं (#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:

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

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

क्वांटाइज़्ड टाइप के लिए, 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)) फ़ंक्शन इस्तेमाल करता है.

हाइब्रिड क्वांटाइज़ किए गए टाइप के लिए, 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) करता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (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]:
  • 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] को दिया गया:
  • 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]:
  • 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) को इस तरह परिभाषित किया गया है:
  • अगर result_dim = output_batch_dimension है, तो dim(lhs, input_batch_dimension) / batch_group_count.
  • अगर result_dim = output_feature_dimension है, तो dim(rhs, kernel_output_feature_dimension).
  • 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.
• अगर ऑपरेशन में बिना क्वांटाइज़ किए गए टेंसर का इस्तेमाल किया जाता है, तो:
  • (C27) element_type(lhs) = element_type(rhs) = element_type(result).
• अगर इस ऑपरेशन में क्वांटाइज़्ड टेंसर का इस्तेमाल किया गया है:
  • (C28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs).
  • (C29) अगर is_per_axis_quantized(rhs), तो quantization_dimension(rhs) = kernel_output_feature_dimension.
  • (C30) अगर is_per_axis_quantized(result) है, तो quantization_dimension(result) = output_feature_dimension.
  • अगर 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) है, तो is_per_tensor_quantized(result).
  • अगर !is_quantized(lhs):
  • (C34) element_type(lhs) = expressed_type(rhs) = element_type(result).

उदाहरण

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

 ज़्यादा उदाहरण

कोज्या

सिमैंटिक्स

operand टेंसर पर एलिमेंट के हिसाब से कोसाइन करता है और result टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम किए जाते हैं:

• फ़्लोट के लिए: IEEE-754 से cos.
• कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स कोसाइन.
• क्वांटाइज़ किए गए टाइप के लिए: dequantize_op_quantize(cosine, operand, type(result)).

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

ज़्यादा उदाहरण

count_leading_zeros

सिमैंटिक्स

operand टेन्सर में, शुरुआत में मौजूद शून्य बिट की संख्या को एलिमेंट के हिसाब से गिनता है और result टेन्सर बनाता है.

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

 ज़्यादा उदाहरण

custom_call

सिमैंटिक्स

लागू करने के तरीके से तय किए गए ऑपरेशन call_target_name को एन्कैप्सुलेट करता है, जो inputs और called_computations लेता है और results बनाता है. has_side_effect, backend_config, और api_version का इस्तेमाल, लागू करने के तरीके से जुड़ा अतिरिक्त मेटाडेटा देने के लिए किया जा सकता है.

फ़िलहाल, इस कार्रवाई में मेटाडेटा का एक व्यवस्थित कलेक्शन मौजूद है. यह XA कंपाइलर में इसके वर्शन के अपने-आप हुए विकास को दिखाता है. आने वाले समय में, हम इस मेटाडेटा को एक जैसा बनाने जा रहे हैं (#741).

इनपुट

आउटपुट

उदाहरण

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

विभाजन

सिमैंटिक

भाज्य lhs और भाजक rhs टेंसर का एलिमेंट के हिसाब से भाग करता है और result टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:

• पूर्णांकों के लिए: पूर्णांक का भागफल, जो बीजगणितीय भागफल बनाता है और दशमलव के बाद वाले हिस्से को हटा देता है.
• फ़्लोट के लिए: IEEE-754 से division.
• सम्मिश्र संख्याओं के लिए: जटिल विभाजन.
• क्वांटाइज़ किए गए डेटा टाइप के लिए:
  • dequantize_op_quantize(divide, lhs, rhs, type(result)).

इनपुट

आउटपुट

कंस्ट्रेंट

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

उदाहरण

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

ज़्यादा उदाहरण

dot_general

सिमैंटिक्स

lhs और rhs के स्लाइस के बीच डॉट प्रॉडक्ट का हिसाब लगाता है और एक result टेंसर बनाता है.

ज़्यादा औपचारिक तौर पर, result[result_index] = dot_product, जहां:

• 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 जहां size(result_batching_index) = size(lhs_batching_dimensions), size(result_lhs_index) = size(lhs_result_dimensions) और 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)).

क्वांटाइज़्ड टाइप के लिए, 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)) फ़ंक्शन इस्तेमाल करता है.

हाइब्रिड क्वांटाइज़ किए गए टाइप के लिए, 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) करता है.

precision_config, ऐक्सेलरेटर बैकएंड पर, कैलकुलेशन के लिए, स्पीड और सटीक होने के बीच के समझौते को कंट्रोल करता है. यह इनमें से कोई एक हो सकता है (फ़िलहाल, इन वैल्यू के बारे में ज़्यादा जानकारी नहीं दी गई है. हालांकि, हम #755 में इस समस्या को ठीक करने की कोशिश कर रहे हैं):

• DEFAULT: सबसे तेज़ तरीके से हिसाब लगाया जाता है. हालांकि, मूल संख्या के मुकाबले यह अनुमानित संख्या कम सटीक होती है.
• HIGH: कैलकुलेशन में ज़्यादा समय लगता है, लेकिन मूल संख्या के करीब का अनुमान ज़्यादा सटीक होता है.
• HIGHEST: यह सबसे धीमा तरीका है. हालांकि, इससे मूल संख्या का सबसे सटीक अनुमान लगाया जा सकता है.

DotAlgorithm, बिंदु वाले ऑपरेशन को लागू करने के लिए इस्तेमाल किए गए एल्गोरिदम की मुख्य प्रॉपर्टी तय करता है. इससे सटीक जानकारी भी मिलती है. अगर एल्गोरिदम एट्रिब्यूट के फ़ील्ड सेट हैं, तो precision_config को DEFAULT पर सेट करना होगा. DotAlgorithms के लिए कोई डिफ़ॉल्ट वैल्यू नहीं होती, क्योंकि डिफ़ॉल्ट पैरामीटर लागू करने के लिए तय किए जाते हैं. इसलिए, खाली बिंदु एल्गोरिदम की जानकारी देने के लिए, सभी बिंदु एल्गोरिदम फ़ील्ड को None पर सेट किया जा सकता है. इसके बजाय, precision_config वैल्यू का इस्तेमाल किया जाएगा.

DotAlgorithm फ़ील्ड में ये शामिल हैं:

• lhs_precision_type और rhs_precision_type, वे सटीक हैं जिनसे ऑपरेशन की बाईं और दाईं ओर का सटीक वैल्यू के टाइप, इनपुट और आउटपुट के स्टोरेज टाइप से अलग होते हैं.
• accumulation_type इकट्ठा करने के लिए इस्तेमाल की गई सटीक वैल्यू.
• lhs_component_count, rhs_component_count, और num_primitive_operations का इस्तेमाल तब किया जाता है, जब हम ऐसा एल्गोरिदम इस्तेमाल कर रहे हों जो बाईं ओर और/या दाईं ओर मौजूद वैल्यू को कई कॉम्पोनेंट में बांटता है और उन वैल्यू पर कई "प्राइमटिव" डॉट ऑपरेशन करता है.आम तौर पर, ऐसा ज़्यादा सटीक नतीजे पाने के लिए किया जाता है. उदाहरण के लिए, ज़्यादा सटीक गणना के लिए, bfloat16 आर्टिफ़िशियल इंटेलिजेंस डेटाटाइप का इस्तेमाल करना: bf16_6x tf32_3x वगैरह. जिन एल्गोरिदम में डेटा को अलग-अलग हिस्सों में नहीं बांटा जाता है उनके लिए, इन वैल्यू को 1 पर सेट किया जाना चाहिए.
• allow_imprecise_accumulation, ताकि यह बताया जा सके कि कुछ चरणों (जैसे, CUBLASLT_MATMUL_DESC_FAST_ACCUM) के लिए कम सटीक जानकारी के इकट्ठा करने की अनुमति है या नहीं.

DotAlgorithm एट्रिब्यूट के उदाहरण:

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

यह तय करना लागू करने वाले लोगों का काम है कि कौनसे कॉम्बिनेशन काम करते हैं. आम तौर पर, यह गारंटी नहीं है कि StableHLO का इस्तेमाल करने वाला उपभोक्ता, हर एल्गोरिद्म को हर तरह के ऐक्सेलरेटर पर इस्तेमाल कर सकता है. अगर कोई एल्गोरिदम काम नहीं करता है, तो किसी अन्य विकल्प का इस्तेमाल करने के बजाय, गड़बड़ी का मैसेज दिखाया जाना चाहिए. StableHLO की पुष्टि करने की सुविधा, पूरी कोशिश करके पुष्टि करेगी. इससे, ऐसे एल्गोरिदम को रोका जा सकेगा जो किसी हार्डवेयर पर काम नहीं करते.

एल्गोरिदम की इस्तेमाल की जा सकने वाली कुछ वैल्यू के बारे में जानने के लिए, xla_data.proto > Algorithm पर जाएं. टिकट #2483 एक ऐसा प्लान कैप्चर करता है जो बैकएंड के साथ काम करने वाले एल्गोरिदम पर एक ही जगह पर एक दस्तावेज़ बनाने के लिए ज़रूरी होता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (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).
• अगर ऑपरेशन में बिना क्वांटाइज़ किए गए टेंसर का इस्तेमाल किया जाता है, तो:
  • (C13) element_type(lhs) = element_type(rhs).
• अगर ऑपरेशन में क्वांटाइज़ किए गए टेंसर का इस्तेमाल किया जाता है, तो:
  • (C14) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs).
  • (C15) zero_points(rhs) = 0.
  • (C16) अगर is_per_axis_quantized(rhs) है, तो quantization_dimension(rhs) rhs_contracting_dimensions में नहीं है.
  • अगर 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) है, तो is_per_tensor_quantized(result).
  • अगर !is_quantized(lhs):
  • (C20) element_type(lhs) = expressed_type(rhs) = element_type(result).
• अगर !is_empty_algorithm(lhs_precision_type, rhs_precision_type, accumulation_type, lhs_component_count, rhs_component_count, num_primitive_operations allow_imprecise_accumulation):
  • (C21) precision_config... = DEFAULT.
  • (C22) 0 < lhs_component_count.
  • (C23) 0 < rhs_component_count.
  • (C24) 0 < num_primitive_operations.

उदाहरण

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

 ज़्यादा उदाहरण

dynamic_broadcast_in_dim

सिमैंटिक

यह ऑपरेशन, broadcast_in_dim ऑपरेशन के काम करने के तरीके से मिलता-जुलता है. हालांकि, नतीजे का शेप output_dimensions की मदद से डाइनैमिक तौर पर तय किया जाता है.

इस ऑपरेशन में वैकल्पिक एट्रिब्यूट known_expanding_dimensions, known_nonexpanding_dimensions भी स्वीकार किए जाते हैं. इनकी मदद से, डाइमेंशन के बढ़ते व्यवहार के बारे में स्टैटिक जानकारी दी जाती है. अगर जानकारी नहीं दी गई है, तो माना गया है कि सभी डाइमेंशन बड़े हो सकते हैं.

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) element_type(result) देने वाली कंपनी:
  • अगर !is_per_axis_quantized(operand) है, तो element_type(operand).
  • element_type(operand), हालांकि quantization_dimension(operand), scales(operand), और zero_points(operand), quantization_dimension(result), scales(result), और zero_points(result) से अलग हो सकते हैं.
• (C2) size(broadcast_dimensions) = rank(operand).
• (C3) 0 <= broadcast_dimensions < rank(result).
• (C4) is_unique(broadcast_dimensions).
• (C5) axes(operand) में मौजूद सभी d के लिए:
  • dim(operand, d) = 1 या
  • dim(operand, d) = dim(result, broadcast_dimensions[d]).
• (C6) अगर is_per_axis_quantized(result):
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)].
  • अगर dim(operand, quantization_dimension(operand)) = 1 है, तो 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).

उदाहरण

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

ज़्यादा उदाहरण

dynamic_conv

सिमैंटिक्स

यह ऑपरेशन, कंवोल्यूशन ऑपरेशन के काम करने के तरीके से मिलता-जुलता है. हालांकि, पैडिंग को padding के ज़रिए डाइनैमिक तौर पर तय किया जाता है.

इनपुट

आउटपुट

कंस्ट्रेंट

• (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]:
  • 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] को दिया गया:
  • 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]:
  • 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) को इस तरह परिभाषित किया गया है:
  • अगर result_dim = output_batch_dimension है, तो dim(lhs, input_batch_dimension) / batch_group_count.
  • अगर result_dim = output_feature_dimension है, तो dim(rhs, kernel_output_feature_dimension).
  • 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.
• अगर ऑपरेशन में बिना क्वांटाइज़ किए गए टेंसर का इस्तेमाल किया जाता है, तो:
  • (C27) element_type(lhs) = element_type(rhs) = element_type(result).
• अगर इस ऑपरेशन में क्वांटाइज़्ड टेंसर का इस्तेमाल किया गया है:
  • (C28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs).
  • (C29) अगर is_per_axis_quantized(rhs), तो quantization_dimension(rhs) = kernel_output_feature_dimension.
  • (C30) अगर is_per_axis_quantized(result) है, तो quantization_dimension(result) = output_feature_dimension.
  • अगर 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) है, तो is_per_tensor_quantized(result).
  • अगर !is_quantized(lhs):
  • (C34) element_type(lhs) = expressed_type(rhs) = element_type(result).

उदाहरण

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