StableHLO की खास बातें

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

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

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

StableHLO की पिछली रिलीज़ की खास जानकारी देखने के लिए, टैग की गई रिलीज़ में जाकर, repo खोलें. उदाहरण के लिए, 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 फ़ंक्शन (इन्हें नाम वाले फ़ंक्शन भी कहा जाता है) में एक आइडेंटिफ़ायर, इनपुट/आउटपुट, और बॉडी होती है. हम आने वाले समय में, फ़ंक्शन के लिए अतिरिक्त मेटाडेटा उपलब्ध कराने का प्लान बना रहे हैं, ताकि 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 | BufferType
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 होती है. इसकी रैंक 2 है.

शेप के बारे में कुछ जानकारी हो सकती है या पूरी जानकारी नहीं हो सकती (डाइनैमिक). उदाहरण के लिए, 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 होता है. इसके अलावा, यह पर-ऐक्सिस भी हो सकता है. इसका मतलब है कि इसमें कई scales और zero_points होते हैं. साथ ही, किसी खास डाइमेंशन quantization_dimension के हर स्लाइस के लिए एक जोड़ी होती है. ज़्यादा औपचारिक तौर पर, हर ऐक्सिस के हिसाब से क्वांटाइज़ेशन वाले टेंसर 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}]

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

बफ़र को custom_call से CreateBuffer या Pin का इस्तेमाल करके असाइन किया जा सकता है. साथ ही, custom_call से Unpin का इस्तेमाल करके असाइन किए गए बफ़र को हटाया जा सकता है. सिर्फ़ custom_call ऑप्स, बफ़र में मौजूद कॉन्टेंट को पढ़ और लिख सकते हैं. ज़्यादा जानकारी के लिए, custom_call देखें.

टपल टाइप, टपल को दिखाते हैं. इसका मतलब है कि ये अलग-अलग तरह की सूचियां होती हैं. टपल एक लेगसी सुविधा है. यह सिर्फ़ एचएलओ के साथ काम करने के लिए मौजूद है. एचएलओ में, टपल का इस्तेमाल वैरिएडिक इनपुट और आउटपुट को दिखाने के लिए किया जाता है. StableHLO में, वैरिएडिक इनपुट और आउटपुट को नेटिव तौर पर सपोर्ट किया जाता है.साथ ही, StableHLO में टपल का इस्तेमाल सिर्फ़ HLO ABI को पूरी तरह से दिखाने के लिए किया जाता है. जैसे, T, tuple<T>, और tuple<tuple<T>> किसी खास तरीके से लागू करने के आधार पर अलग-अलग हो सकते हैं. हम आने वाले समय में, HLO ABI में बदलाव करने का प्लान बना रहे हैं. इससे हम 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 तक की पूर्णांक वैल्यू को दिखाते हैं. इसमें ये दोनों वैल्यू भी शामिल हैं.
• फ़्लोटिंग-पॉइंट टाइप इनमें से कोई एक हो सकता है:
  • f8E3M4, f8E4M3, और f8E5M2, IEEE-754 के नियमों के मुताबिक 8-बिट फ़्लोटिंग पॉइंट नंबर होने चाहिए.
  • f8E4M3FN और f8E5M2 टाइप, डीप लर्निंग के लिए FP8 फ़ॉर्मैट में बताए गए FP8 फ़ॉर्मैट की E4M3 और E5M2 एन्कोडिंग के मुताबिक होते हैं.
  • E4M3 और E5M2, f8E4M3FNUZ और f8E5M2FNUZ टाइप के होते हैं. ये डीप न्यूरल नेटवर्क के लिए 8-बिट वाले संख्यात्मक फ़ॉर्मैट में बताए गए FP8 फ़ॉर्मैट की एन्कोडिंग के हिसाब से होते हैं.
  • f8E4M3B11FNUZ टाइप, FP8 फ़ॉर्मैट की E4M3 एन्कोडिंग से मेल खाता है. इसके बारे में डीप न्यूरल नेटवर्क के लिए हाइब्रिड 8-बिट फ़्लोटिंग पॉइंट (HFP8) ट्रेनिंग और अनुमान में बताया गया है.
  • bf16 टाइप, bfloat16 फ़ॉर्मैट से मेल खाता है. इसके बारे में BFloat16: The secret to high performance on Cloud TPUs में बताया गया है.
  • f16, f32, और f64 टाइप, binary16 ("half precision"), binary32 ("single precision"), और binary64 ("double precision") फ़ॉर्मैट के हिसाब से होते हैं. इनके बारे में IEEE 754 स्टैंडर्ड में बताया गया है.
  • tf32 टाइप, TensorFloat32 फ़ॉर्मैट से मेल खाता है. साथ ही, यह StableHLO में सीमित तौर पर काम करता है.
  • f4E2M1FN, f6E2M3FN, f6E3M2FN, और f8E8M0FNU MX (माइक्रोडायमेंशन) टाइप, जिनके बारे में OCP माइक्रोडायमेंशन फ़ॉर्मैट स्पेसिफ़िकेशन में बताया गया है.
• कॉम्प्लेक्स टाइप, कॉम्प्लेक्स वैल्यू को दिखाते हैं. इनमें एक वास्तविक हिस्सा और एक काल्पनिक हिस्सा होता है. ये दोनों हिस्से एक ही एलिमेंट टाइप के होते हैं. complex<f32> (दोनों हिस्से f32 टाइप के हैं) और complex<f64> (दोनों हिस्से f64 टाइप के हैं) जैसे कॉम्प्लेक्स टाइप इस्तेमाल किए जा सकते हैं.

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

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

StringType ::= 'string'

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

कार्रवाइयां

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

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

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

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

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

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

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

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

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

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

फ़िलहाल, StableHLO प्रोग्राम में कभी-कभी ऐसे एट्रिब्यूट शामिल होते हैं जिनके बारे में इस दस्तावेज़ में नहीं बताया गया है. आने वाले समय में, हम इन एट्रिब्यूट को StableHLO opset में शामिल करने या उन्हें 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 होता है.

Ops

एबीएस

सिमैंटिक

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

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

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) shape(result) = shape(operand).
• (C2) baseline_element_type(result) को इस तरह परिभाषित किया गया है:
  • complex_element_type(element_type(operand)) अगर is_complex(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.
• पूर्णांकों के लिए: पूर्णांक जोड़ना.
• फ़्लोट के लिए: addition, IEEE-754 से.
• कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स जोड़ना.
• क्वांटाइज़ किए गए टाइप के लिए: 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) if channel_id <= 0 and use_global_device_ids = false.
• cross_replica_and_partition(replica_groups) if channel_id > 0 and use_global_device_ids = false.
• flattened_ids(replica_groups) if channel_id > 0 and use_global_device_ids = true.

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

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

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) 0 <= all_gather_dim < rank(operands...).
• (C2) is_unique(replica_groups).
• (C3) size(replica_groups) को इस तरह से परिभाषित किया गया है:
  • cross_replica का इस्तेमाल करने पर num_replicas.
  • cross_replica_and_partition का इस्तेमाल करने पर num_replicas.
  • flattened_ids का इस्तेमाल करने पर num_processes.
• (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) if channel_id <= 0 and use_global_device_ids = false.
• cross_replica_and_partition(replica_groups) if channel_id > 0 and use_global_device_ids = false.
• flattened_ids(replica_groups) if channel_id > 0 and use_global_device_ids = true.

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

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

इनपुट

आउटपुट

कंस्ट्रेंट

• (C1) is_unique(replica_groups).
• (C2) size(replica_groups) को इस तरह परिभाषित किया गया है:
  • cross_replica का इस्तेमाल करने पर num_replicas.
  • cross_replica_and_partition का इस्तेमाल करने पर num_replicas.
  • flattened_ids का इस्तेमाल करने पर num_processes.
• (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 प्रोसेस ग्रिड में मौजूद हर प्रोसेस ग्रुप में, operands टेंसर की वैल्यू को split_dimension के हिसाब से हिस्सों में बांटता है. इसके बाद, इन हिस्सों को प्रोसेस के बीच स्कैटर करता है. इसके बाद, स्कैटर किए गए हिस्सों को concat_dimension के हिसाब से जोड़ता है और results टेंसर बनाता है. यह ऑपरेशन, StableHLO प्रोसेस ग्रिड को process_groups में बांटता है. इसे इस तरह से तय किया जाता है:

• cross_replica(replica_groups) अगर channel_id <= 0.
• cross_partition(replica_groups) अगर channel_id > 0.

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

• split_parts...@sender = split(operands...@sender, split_count, split_dimension) process_group में मौजूद सभी sender के लिए.
• 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) को इस तरह से परिभाषित किया गया है:
  • cross_replica का इस्तेमाल करने पर num_replicas.
  • 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 टेंसर बनाता है. यह एलिमेंट टाइप के हिसाब से, ये काम करता है:

• फ़्लोट के लिए: atan2, IEEE-754 से.
• कॉम्प्लेक्स नंबर के लिए: 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

सिमैंटिक

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

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 डाइमेंशन को छोड़कर, सभी डाइमेंशन के लिए माध्य और वैरिएंस का हिसाब लगाता है. साथ ही, operand टेंसर को सामान्य करता है. इससे output, batch_mean, और batch_var टेंसर जनरेट होते हैं. ज़्यादा औपचारिक तौर पर, इस ऑपरेशन को Python सिंटैक्स का इस्तेमाल करके, मौजूदा StableHLO ऑपरेशन में इस तरह से बांटा जा सकता है:

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.
  • सभी 0 <= i < R के लिए dim(result, i) = dim(operand, i).
  • dim(result, R) * num_bits(E') = num_bits(E).
  • अगर num_bits(E') > num_bits(E):
  • rank(result) = R - 1.
  • सभी 0 <= i < R के लिए dim(result, i) = dim(operand, i).
  • 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 के लिए:

• operand_index[d] = 0 अगर dim(operand, d) = 1.
• अन्य मामलों में 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() जहां:

• selected_branch = branches[index] अगर 0 <= index < size(branches).
• अन्य मामलों में 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]

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

cbrt

सिमैंटिक

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

• फ़्लोट के लिए: rootn(x, 3), IEEE-754 से.
• कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स क्यूब रूट.
• क्वांटाइज़ किए गए टाइप के लिए: 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]

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

cholesky

सिमैंटिक

यह फ़ंक्शन, मैट्रिक्स के एक बैच के चोलेस्की डिकंपोज़िशन का हिसाब लगाता है.

ज़्यादा औपचारिक तौर पर, 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 में बांटता है. इसे इस तरह से तय किया जाता है:

• cross_replica(replica_groups) अगर channel_id <= 0.
• cross_partition(replica_groups) अगर channel_id > 0.

इसके बाद, 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.
  • cross_partition का इस्तेमाल करने पर num_partitions.
• (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 में बांटता है. इसे इस तरह से तय किया जाता है:

• cross_replica(source_target_pairs) अगर channel_id <= 0.
• cross_partition(source_target_pairs) अगर channel_id > 0.

इसके बाद, 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 को इस तरह से तय किया गया है:
  • cross_replica का इस्तेमाल करने पर num_replicas.
  • 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]]

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

तुलना करें

सिमैंटिक

यह फ़ंक्शन, 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 वाले फ़्लोटिंग-पॉइंट एलिमेंट टाइप के लिए, यह ऑप IEEE-754 के इन ऑपरेशनों को लागू करता है:

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

compare_type = TOTALORDER वाले फ़्लोटिंग-पॉइंट एलिमेंट टाइप के लिए, op, 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 को इस तरह से परिभाषित किया गया है:
  • SIGNED अगर is_signed_integer(element_type(lhs)).
  • UNSIGNED अगर is_unsigned_integer(element_type(lhs)) or is_boolean(element_type(lhs)).
  • अगर is_float(element_type(lhs)) है, तो FLOAT या TOTALORDER.
  • FLOAT अगर is_complex(element_type(lhs)).

उदाहरण

// %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) same(shape(inputs...)) को छोड़कर, dim(inputs..., dimension).
• (C3) 0 < size(inputs).
• (C4) 0 <= dimension < rank(inputs[0]).
• (C5) element_type(result) = element_type(inputs[0]).
• (C6) shape(result) = shape(inputs[0]) इन मामलों को छोड़कर:
  • 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 टेंसर बनाता है.

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

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

floating-point-to-integer कन्वर्ज़न के लिए, फ़्रैक्शनल पार्ट को छोटा कर दिया जाता है. अगर काटी गई वैल्यू को डेस्टिनेशन टाइप में नहीं दिखाया जा सकता, तो इसका तरीका टीबीडी (#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 बनाता है. इस डायग्राम में, एक उदाहरण की मदद से दिखाया गया है कि lhs और rhs से result में मौजूद एलिमेंट की गिनती कैसे की जाती है.

ज़्यादा औपचारिक तौर पर, 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) को इस तरह परिभाषित किया गया है:
  • dim(lhs, input_batch_dimension) / batch_group_count अगर result_dim = output_batch_dimension.
  • dim(rhs, kernel_output_feature_dimension) अगर result_dim = 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 टेंसर बनाता है. यह एलिमेंट टाइप के हिसाब से, ये काम करता है:

• फ़्लोट के लिए: cos, IEEE-754 से.
• कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स कोसाइन.
• क्वांटाइज़ किए गए टाइप के लिए: 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 का इस्तेमाल, लागू करने से जुड़े अतिरिक्त मेटाडेटा को उपलब्ध कराने के लिए किया जा सकता है.

फ़िलहाल, इस ऑपरेशन में मेटाडेटा का एक काफ़ी अव्यवस्थित कलेक्शन शामिल है. यह XLA कंपाइलर में, इसके काउंटरपार्ट ऑपरेशन के ऑर्गैनिक इवोल्यूशन को दिखाता है. आने वाले समय में, हम इस मेटाडेटा को एक साथ लाने का प्लान कर रहे हैं (#741).

इनपुट

आउटपुट

(XLA GPU Support) Special custom_call targets

buffer टाइप से जुड़े तीन खास call_target_name होते हैं: CreateBuffer एक अनइनिशियलाइज़्ड buffer बनाता है, Pin एक इनिशियलाइज़्ड buffer बनाता है, और Unpin एक buffer को डीऐलोकेट करता है और buffer का कॉन्टेंट दिखाता है.

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

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

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

उपनाम

कुछ custom_call ऑप्स को आउटपुट और ऑपरेंड में एक हिस्सा चाहिए, ताकि वे एक ही मेमोरी को शेयर कर सकें. इसे output_operand_aliases के ज़रिए दिखाया जा सकता है. एलियास पेयर के प्रज़ेंटेशन में, आउटपुट टपल इंडेक्स की एक सूची होती है. यह सूची, आउटपुट वाले हिस्से को दिखाती है. साथ ही, इसमें ऑपरेंड इंडेक्स के साथ-साथ ऑपरेंड टपल इंडेक्स की एक सूची होती है. यह सूची, ऑपरेंड वाले हिस्से को दिखाती है. अगर संबंधित टाइप tuple टाइप नहीं है, तो आउटपुट या ऑपरेंड टपल इंडेक्स की सूची खाली होती है. साथ ही, नेस्ट किए गए किसी भी टपल टाइप के लिए, यह सूची कितनी भी लंबी हो सकती है. यह XLA के एलियास के तौर पर दिखाए जाने जैसा ही है.

एलियास पेयर के आउटपुट और इनपुट का टाइप एक जैसा होना चाहिए. कस्टम कॉल ऑपरेशंस के लिए, CreateBuffer, Pin, और Unpin को कॉल नहीं किया जाता है. साथ ही, buffer ऑपरैंड, ज़्यादा से ज़्यादा एक एलियास पेयर में दिख सकता है. इसके अलावा, buffer आउटपुट, एक एलियास पेयर में दिखना चाहिए.

उदाहरण

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

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

विभाजन

सिमैंटिक

यह फ़ंक्शन, डिविडेंड lhs और डिवाइज़र rhs टेंसर के हर एलिमेंट को अलग-अलग भाग देता है. साथ ही, result टेंसर बनाता है. यह एलिमेंट टाइप के हिसाब से, ये काम करता है:

• पूर्णांकों के लिए: पूर्णांक भागफल, जो बीजीय भागफल बनाता है. इसमें दशमलव के बाद वाले हिस्से को हटा दिया जाता है.
• फ़्लोट के लिए: division, IEEE-754 से.
• कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स डिवीज़न.
• क्वांटाइज़ किए गए टाइप के लिए:
  • 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, ऐक्सलरेटर बैकएंड पर कंप्यूटेशन के लिए, स्पीड और सटीक नतीजे के बीच ट्रेडऑफ़ को कंट्रोल करता है. यह इनमें से कोई एक हो सकता है (फ़िलहाल, इन enum वैल्यू के सिमैंटिक के बारे में पूरी जानकारी नहीं दी गई है. हालांकि, हम #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

सिमैंटिक

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

इनपुट