StableHLO, मशीन लर्निंग (एमएल) मॉडल में हाई-लेवल ऑपरेशन (एचएलओ) के लिए सेट किया गया ऑपरेशन है. StableHLO अलग-अलग एमएल फ़्रेमवर्क और एमएल कंपाइलर के बीच पोर्टेबिलिटी लेयर के तौर पर काम करता है: StableHLO प्रोग्राम बनाने वाले एमएल फ़्रेमवर्क, StableHLO प्रोग्राम का इस्तेमाल करने वाले एमएल कंपाइलर के साथ काम करते हैं.
हमारा मकसद, ML के अलग-अलग फ़्रेमवर्क (जैसे, TensorFlow, JAX और PyTorch) और ML कंपाइलर (जैसे कि XLA और IREE) के बीच ज़्यादा इंटरऑपरेबिलिटी बनाकर, एमएल के डेवलपमेंट को आसान बनाना और तेज़ करना है. इस दस्तावेज़ में StableHLO प्रोग्रामिंग भाषा की जानकारी दी गई है.
इस स्पेसिफ़िकेशन में तीन मुख्य सेक्शन शामिल हैं. सबसे पहले, प्रोग्राम सेक्शन में StableHLO प्रोग्राम की बनावट के बारे में बताया गया है. इसमें StableHLO फ़ंक्शन मौजूद हैं जिनमें StableHLO ऑपरेशन शामिल हैं. इस संरचना में, Ops सेक्शन हर ऑपरेशन का मतलब बताता है. एक्ज़ीक्यूशन सेक्शन में, प्रोग्राम के अंदर एक साथ लागू किए जाने वाले सभी ऑपरेशन के लिए सिमेंटिक्स उपलब्ध होते हैं. आखिर में, नोटेशन सेक्शन में पूरी जानकारी में इस्तेमाल किए गए नोटेशन के बारे में बताया गया है.
प्रोग्राम
Program ::= {Func}
StableHLO प्रोग्राम में StableHLO की संख्या, मनचाहे तरीके से शामिल होती है.
यहां @main
फ़ंक्शन वाले एक प्रोग्राम का उदाहरण दिया गया है, जिसमें तीन इनपुट
(%image
, %weights
, और %bias
) और एक आउटपुट है. फ़ंक्शन के मुख्य हिस्से में
6 ऑपरेशन होते हैं.
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 फ़ंक्शन (जिन्हें नाम वाले फ़ंक्शन भी कहा जाता है) में एक आइडेंटिफ़ायर, इनपुट/आउटपुट, और एक मुख्य हिस्सा होता है. आने वाले समय में, हम फ़ंक्शन के लिए अतिरिक्त मेटाडेटा शुरू करने की योजना बना रहे हैं, ताकि एचएलओ (#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
डाइमेंशन की संख्या को rank कहा जाता है. उदाहरण के लिए, tensor<2x3xf32>
एक टेंसर टाइप है, जिसका साइज़ 2x3
और एलिमेंट टाइप f32
है. इसमें दो डाइमेंशन (या
दूसरे शब्दों में, दो ऐक्सिस) होते हैं - पहला डाइमेंशन और पहला डाइमेंशन - जिसका साइज़ 2 और 3 है. इसकी रैंक 2 है.
यह उन स्टैटिक आकार के साथ काम करने के बारे में बताता है जहां डाइमेंशन के साइज़, स्टैटिक रूप से तय होते हैं. आने वाले समय में, हम ऐसे डाइनैमिक शेप के लिए भी सहायता उपलब्ध कराने की योजना बना रहे हैं, जिनमें डाइमेंशन के साइज़ के बारे में कुछ हद तक या पूरी तरह जानकारी नहीं होती (#8). इसके अलावा, हम डाइमेंशन साइज़ और एलिमेंट टाइप के अलावा, अन्य तरह के टेंसर टाइप एक्सप्लोर करने की योजना बना रहे हैं. जैसे, लेआउट (#629) और स्पैरिटी (#1078) को शामिल करना.
QuantizedTensorType ::= 'tensor' '<' Shape QuantizedTensorElementType '>'
QuantizedTensorElementType ::= '!quant.uniform' '<'
QuantizationStorageType
['<' QuantizationStorageMin ':' QuantizationStorageMax '>']
':' QuantizationExpressedType
[':' QuantizationDimension]
',' QuantizationParameters '>'
QuantizationStorageType ::= IntegerType
QuantizationStorageMin ::= IntegerConstant
QuantizationStorageMax ::= IntegerConstant
QuantizationExpressedType ::= FloatType
QuantizationDimension ::= IntegerConstant
QuantizationParameters ::= QuantizationParameter
| '{' QuantizationParameter {',' QuantizationParameter} '}'
QuantizationParameter ::= QuantizationScale ':' QuantizationZeroPoint
QuantizationScale ::= FloatConstant
QuantizationZeroPoint ::= IntegerConstant
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
storage_type |
पूर्णांक का टाइप | (C1-C4), (C9) |
storage_min |
पूर्णांक कॉन्सटेंट | (C2), (C4), (C8) |
storage_max |
पूर्णांक कॉन्सटेंट | (C3), (C4), (C8) |
expressed_type |
फ़्लोटिंग-पॉइंट टाइप | (C1), (C5) |
quantization_dimension |
वैकल्पिक पूर्णांक कॉन्सटेंट | (C11-C13) |
scales |
फ़्लोटिंग-पॉइंट कॉन्सटेंट की अलग-अलग संख्या | (C5-C7), (C10), (C11), (C13) |
zero_points |
इंटीजर कॉन्सटेंट की अलग-अलग संख्या | (C8-C10) |
संख्या के हिसाब से बनाए गए एलिमेंट, 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)
num_bits(storage_type) < num_bits(expressed_type)
. - (C2)
type(storage_min) = storage_type
. - (C3)
type(storage_max) = storage_type
. - (C4)
min_value(storage_type) <= storage_min < storage_max <= max_value(storage_type)
. - (C5)
type(scales...) = expressed_type
. - (C6)
0 < scales
. - (C7)
is_finite(scales...)
. - (C8)
storage_min <= zero_points <= storage_max
. - (C9)
type(zero_points...) = storage_type
. - (C10)
size(scales) = size(zero_points)
. - (C11) अगर
is_empty(quantization_dimension)
है, तोsize(scales) = 1
. - (C12)
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)
.
- (C12)
TokenType ::= 'token'
टोकन टाइप टोकन को दिखाते हैं. जैसे, कुछ कार्रवाइयों से बनाई गई और इस्तेमाल की गई ओपेक वैल्यू. टोकन का इस्तेमाल, एक्ज़ीक्यूशन सेक्शन में बताए गए तरीके से, कार्रवाइयों पर एक्ज़ीक्यूट करने का ऑर्डर लागू करने के लिए किया जाता है.
TupleType ::= 'tuple' '<' TupleElementTypes '>'
TupleElementTypes ::= [ValueType {',' ValueType}]
टपल टाइप, टपल को दिखाते हैं. उदाहरण के लिए, विषमांगी सूचियां. टपल एक लेगसी सुविधा है, जो सिर्फ़ एचएलओ के साथ काम करने के लिए उपलब्ध है. एचएलओ में, ट्यूपल का इस्तेमाल बदलाव वाले इनपुट और आउटपुट को दिखाने के लिए किया जाता है. StableHLO में, वैरिएडिक इनपुट और आउटपुट मूल रूप से काम करते हैं. StableHLO में, ट्यूपल का सिर्फ़ इस्तेमाल
HLO एबीआई को बेहतर तरीके से दिखाने के लिए किया जाता है, जहां T
, tuple<T>
, और
tuple<tuple<T>>
जैसे किसी खास लागू करने के हिसाब से काफ़ी अलग-अलग हो सकता है. आने वाले समय में, हम एचएलओ एबीआई में बदलाव करने की योजना बना रहे हैं. इससे हमें StableHLO से टपल टाइप हटाने की अनुमति मिल सकती है (#598).
TensorElementType ::= BooleanType | IntegerType | FloatType | ComplexType
BooleanType ::= 'i1'
IntegerType ::= SignedIntegerType | UnsignedIntegerType
SignedIntegerType ::= 'si4' | 'si8' | 'si16' | 'si32' | 'si64'
UnsignedIntegerType ::= 'ui4' | 'ui8' | 'ui16' | 'ui32' | 'ui64'
FloatType ::= 'f8E4M3FN' | 'f8E5M2' | 'f8E4M3FNUZ' | 'f8E5M2FNUZ'
| 'f8E4M3B11FNUZ' | 'bf16' | 'f16' | 'f32' | 'f64'
ComplexType ::= 'complex' '<' ComplexElementType '>'
ComplexElementType ::= 'f32' | 'f64'
एलिमेंट टाइप, टेंसर टाइप के एलिमेंट दिखाते हैं. कई प्रोग्रामिंग भाषाओं के उलट, ये टाइप StableHLO की
पहली कैटगरी नहीं हैं. इसका मतलब है कि
StableHLO प्रोग्राम, सीधे तौर पर इस तरह की वैल्यू को नहीं दिखा सकते. इसी वजह से,
T
टाइप के अदिश वैल्यू को tensor<T>
टाइप के 0-डाइमेंशन वाले टेंसर
वैल्यू से दिखाना मुहावरे है.
- बूलियन टाइप, बूलियन वैल्यू
true
औरfalse
दिखाता है. - इंटीज़र टाइप साइन किए गए (
si
) या साइन नहीं किए गए (ui
) हो सकते हैं और इनमें से एक बिट विड्थ (4
,8
,16
,32
या64
) हो सकती है. साइन किए गएsiN
टाइप-2^(N-1)
से2^(N-1)-1
तक के पूर्णांक वैल्यू दिखाते हैं और साइन नहीं किए गएuiN
टाइप,0
से2^N-1
तक के पूर्णांकों की वैल्यू दिखाते हैं. - फ़्लोट-पॉइंट टाइप इनमें से कोई एक हो सकता है:
f8E4M3FN
औरf8E5M2
टाइप, डीप लर्निंग के लिए FP8 फ़ॉर्मैट में बताए गए FP8 फ़ॉर्मैट केE4M3
औरE5M2
एन्कोडिंग के हिसाब से हैं.- FP8 फ़ॉर्मैट के
E4M3
औरE5M2
एन्कोडिंग से जुड़ेf8E4M3FNUZ
औरf8E5M2FNUZ
टाइप डीप न्यूरल नेटवर्क के लिए 8-बिट वाले न्यूमेरिक फ़ॉर्मैट में बताए गए हैं. E4M3
के FP8 फ़ॉर्मैट के हिसाब सेf8E4M3B11FNUZ
टाइप. हाइब्रिड 8-बिट फ़्लोटिंग पॉइंट (HFP8) ट्रेनिंग और डीप न्यूरल नेटवर्क के अनुमान में इसके बारे में बताया गया है.- BFloat16: Cloud TPU पर बेहतर परफ़ॉर्मेंस का सीक्रेट फ़ॉर्मैट में बताए गए
bfloat16
फ़ॉर्मैट से जुड़ाbf16
टाइप. f16
,f32
, औरf64
टाइप इनके मुताबिक होते हैं:binary16
("हाफ़ प्रिसिज़न"),binary32
("सिंगल प्रिसिज़न"), औरbinary64
("डबल सटीक") फ़ॉर्मैट, IEEE 754 स्टैंडर्ड में बताए गए हैं.
- जटिल टाइप ऐसी जटिल वैल्यू दिखाते हैं जिनमें असल हिस्सा होता है और एक ही एलिमेंट टाइप का काल्पनिक हिस्सा होता है. काम करने वाले कॉम्प्लेक्स टाइप,
complex<f32>
(दोनों हिस्सेf32
टाइप के हैं) औरcomplex<f64>
(दोनों हिस्सेf64
टाइप के हैं) हैं.
FunctionType ::= '(' InputTypes ')' '->' '(' OutputTypes ')'
InputTypes ::= [ValueType {',' ValueType}]
OutputTypes ::= [ValueType {',' ValueType}]
फ़ंक्शन टाइप नाम वाले और पहचान छिपाने वाले, दोनों फ़ंक्शन को दिखाते हैं. इनमें इनपुट टाइप (->
की बाईं ओर मौजूद टाइप की सूची) और आउटपुट टाइप (->
की दाईं ओर मौजूद टाइप की सूची) होते हैं. कई प्रोग्रामिंग भाषाओं में, फ़ंक्शन टाइप फ़र्स्ट क्लास होते हैं, लेकिन StableHLO में नहीं.
StringType ::= 'string'
स्ट्रिंग का टाइप, बाइट के क्रम को दिखाता है. कई प्रोग्रामिंग भाषाओं के उलट, StableHLO में स्ट्रिंग का टाइप पहली क्लास नहीं है. इसका इस्तेमाल सिर्फ़ प्रोग्राम एलिमेंट के लिए स्टैटिक मेटाडेटा की जानकारी देने के लिए किया जाता है.
ऑपरेशंस
StableHLO ऑपरेशन (जिन्हें ऑपरेशन भी कहा जाता है) मशीन लर्निंग मॉडल में हाई-लेवल ऑपरेशन के बंद सेट को दिखाते हैं. जैसा कि ऊपर बताया गया है, StableHLO सिंटैक्स काफ़ी हद तक MLIR से प्रेरित है. यह ज़रूरी नहीं है कि यह सबसे बेहतर विकल्प हो. हालांकि, एमएल फ़्रेमवर्क और एमएल कंपाइलर के बीच ज़्यादा इंटरऑपरेबिलिटी बनाने के StableHLO के लक्ष्य के लिए, यह साफ़ तौर पर सबसे सही विकल्प है.
Op ::= [OpOutputs] OpName OpInputs ':' OpSignature
OpName ::= '"' 'stablehlo' '.' OpMnemonic '"'
OpMnemonic ::= 'abs' | 'add' | ...
StableHLO कार्रवाइयों (इन्हें ops भी कहा जाता है) का एक नाम, इनपुट/आउटपुट, और एक सिग्नेचर होता है. नाम में stablehlo.
प्रीफ़िक्स और एक मेनेमोनिक शामिल है, जो काम करने वाले ऑपरेशन में से किसी एक की खास तौर पर पहचान करता है. काम करने वाले सभी ऑपरेशन की
पूरी सूची यहां देखें.
फ़िलहाल, StableHLO प्रोग्राम में कभी-कभी ऐसी कार्रवाइयां की जाती हैं जिनके बारे में इस दस्तावेज़ में नहीं बताया गया है. आने वाले समय में, हम या तो इन ऑपरेशन को StableHLO ऑपसेट में शामिल कर लेंगे या फिर उन्हें StableHLO प्रोग्राम में दिखाने पर पाबंदी लगा देंगे. तब तक, यहां इन कार्रवाइयों की सूची दी गई है:
builtin.module
,func.func
,func.call
, औरfunc.return
(#425).chlo
कार्रवाइयां (#602).- StableHLO कार्रवाइयों की "एचएलओ में नहीं" कैटगरी - शुरुआत में, ये StableHLO ऑपरेशन का हिस्सा थे, लेकिन बाद में इन्हें सही से फ़िट नहीं किया गया:
broadcast
,create_token
,cross-replica-sum
,dot
,einsum
,torch_index_select
,unary_einsum
(#3). - StableHLO कार्रवाइयों की "डायनेमिज़्म" कैटगरी - इन्हें MHLO से बूटस्ट्रैप
किया गया था, लेकिन हमने अभी तक उनका अनुमान नहीं लगाया है:
compute_reshape_shape
,cstr_reshapable
,dynamic_broadcast_in_dim
,dynamic_conv
,dynamic_gather
,dynamic_iota
,dynamic_pad
,dynamic_reshape
,real_dynamic_slice
,set_dimension_size
(#8). - आकार का हिसाब लगाना, जिसमें
arith
,shape
, औरtensor
कार्रवाइयां (#8) शामिल हैं.
OpInputs ::= OpInputValues OpInputFuncs OpInputAttrs
OpInputValues ::= '(' [OpInputValue {',' OpInputValue}] ')'
OpInputValue ::= ValueId
OpInputFuncs ::= ['(' OpInputFunc {',' OpInputFunc} ')']
OpInputAttrs ::= ['{' OpInputAttr {',' OpInputAttr} '}']
OpOutputs ::= [OpOutput {',' OpOutput} '=']
OpOutput ::= ValueId
ऑपरेशन, इनपुट का इस्तेमाल करते हैं और आउटपुट जनरेट करते हैं. इनपुट को, इनपुट फ़ंक्शन (एक्ज़ीक्यूशन के दौरान हिसाब लगाया गया), इनपुट फ़ंक्शन (स्टैटिक तरीके से, क्योंकि StableHLO फ़ंक्शन में कोई फ़र्स्ट-क्लास वैल्यू नहीं होती) और इनपुट एट्रिब्यूट (स्टैटिक तरीके से भी दिए जाते हैं) में बांटा जाता है. किसी ऑपरेटर की ओर से इस्तेमाल और बनाए गए इनपुट
और आउटपुट किस तरह के इनपुट और आउटपुट के तौर पर बनते हैं, यह उसके मिनेमोनिक पर निर्भर करता है. उदाहरण के लिए, add
ऑपरेशन दो इनपुट वैल्यू का इस्तेमाल करता है और एक आउटपुट वैल्यू जनरेट करता है. इसके मुकाबले, select_and_scatter
ऑपरेटर तीन इनपुट वैल्यू, दो इनपुट फ़ंक्शन, और तीन इनपुट एट्रिब्यूट का इस्तेमाल करता है.
OpInputFunc ::= '{' Unused FuncInputs ':' FuncBody '}'
Unused ::= '^' digit {digit}
| '^' letter {letter | digit}
इनपुट फ़ंक्शन (जिन्हें अनाम फ़ंक्शन भी कहा जाता है) नाम वाले फ़ंक्शन से बहुत हद तक मिलते-जुलते होते हैं, लेकिन: 1) उनमें कोई आइडेंटिफ़ायर नहीं होता (इसलिए, "पहचान नहीं की गई है"), 2) वे आउटपुट टाइप का एलान नहीं करते (आउटपुट टाइप, फ़ंक्शन के अंदर return
op से लागू किए जाते हैं).
इनपुट फ़ंक्शन के सिंटैक्स में फ़िलहाल इस्तेमाल न किया गया एक हिस्सा शामिल है (ऊपर दिया गया Unused
प्रोडक्शन देखें), जो MLIR के साथ काम करने के लिए इस्तेमाल किया गया है. एमएलआईआर में,
"इलाकों" का एक सामान्य सिद्धांत है. इसमें जंप ऑपरेटर के ज़रिए एक साथ कई "ब्लॉक" जोड़े जा सकते हैं. इन ब्लॉक में Unused
प्रोडक्शन से जुड़े आईडी होते हैं, ताकि उन्हें एक-दूसरे से अलग किया जा सके.
StableHLO में जंप ऑपरेटर नहीं है, इसलिए MLIR सिंटैक्स के लिए इस्तेमाल किए गए हिस्से का इस्तेमाल नहीं किया गया है (लेकिन यह अब भी वहां मौजूद है).
OpInputAttr ::= OpInputAttrName '=' OpInputAttrValue
OpInputAttrName ::= letter {letter | digit}
OpInputAttrValue ::= Constant
इनपुट एट्रिब्यूट में एक नाम और वैल्यू होती है, जो इस्तेमाल किए जा सकने वाले
कॉन्सटेंट में से एक है. प्रोग्राम एलिमेंट के लिए स्टैटिक मेटाडेटा तय करने के ये मुख्य तरीके हैं. उदाहरण के लिए, concatenate
ऑपरेटर dimension
एट्रिब्यूट का इस्तेमाल करके, उस डाइमेंशन की जानकारी देता है जिसके साथ इसके इनपुट वैल्यू को जोड़ा जाता है. इसी तरह,
slice
op, इनपुट वैल्यू को स्लाइस करने के लिए इस्तेमाल होने वाली सीमाओं के बारे में बताने के लिए, 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 हस्ताक्षर को 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
है.
ऑपरेशंस टीम
abs
सिमैंटिक
यह operand
टेंसर पर, एलिमेंट के हिसाब से ऐब्स ऑपरेशन करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- साइन किए गए पूर्णांक के लिए: पूर्णांक मॉड्यूल.
- फ़्लोट के लिए: IEEE-754 से
abs
. - कॉम्प्लेक्स नंबर (समिश्र संख्याओं) के लिए: कॉम्प्लेक्स मॉड्यूलस.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(abs, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
साइन किए गए इंटीजर, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया हुआ टेंसर | (सी1-सी2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
साइन किए गए इंटीजर या फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का क्वानंटाइज़ किया गया टेंसर | (सी1-सी2) |
कंस्ट्रेंट
- (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))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
(I2) | rhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(lhs) = baseline_type(rhs) = baseline_type(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
के लिए डेटा डिपेंडेंसी बनाने के लिए मौजूद है.
इनपुट
लेबल | नाम | टाइप |
---|---|---|
(I1) | inputs |
token की वैरिएडिक संख्या |
आउटपुट
नाम | टाइप |
---|---|
result |
token |
उदाहरण
// %input0: !stablehlo.token
// %input1: !stablehlo.token
%result = "stablehlo.after_all"(%input0, %input1) : (!stablehlo.token, !stablehlo.token) -> !stablehlo.token
all_gather
सिमैंटिक
StableHLO प्रोसेस ग्रिड में मौजूद हर प्रोसेस ग्रुप में, all_gather_dim
के साथ-साथ हर प्रोसेस से operand
टेंसर की वैल्यू जोड़ता है और result
टेंसर बनाता है.
यह कार्रवाई, 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
में मौजूदprocess
सभी के लिएresult@process = concatenate(operands@process, all_gather_dim)
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C6) |
(I2) | all_gather_dim |
si64 टाइप का कॉन्सटेंट |
(C1), (C6) |
(I3) | replica_groups |
si64 टाइप का 2-डाइमेंशन टेंसर कॉन्सटेंट |
(सी2-सी4) |
(I4) | channel_id |
si64 टाइप का कॉन्सटेंट |
(सी5) |
(I5) | use_global_device_ids |
i1 टाइप का कॉन्सटेंट |
(सी5) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी6) |
कंस्ट्रेंट
- (C1)
0 <= all_gather_dim < rank(operand)
. - (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(result) = type(operand)
को छोड़कर:dim(result, all_gather_dim) = dim(operand, all_gather_dim) * dim(process_groups, 1)
.
उदाहरण
// num_replicas: 2
// num_partitions: 1
// %operand@(0, 0): [[1, 2], [3, 4]]
// %operand@(1, 0): [[5, 6], [7, 8]]
%result = "stablehlo.all_gather"(%operand) {
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<2x4xi64>
// %result@(0, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
// %result@(1, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
all_reduce
सिमैंटिक
StableHLO प्रोसेस ग्रिड में मौजूद हर प्रोसेस ग्रुप में, हर प्रोसेस से operand
टेंसर की वैल्यू पर रिडक्शन computation
लागू करता है और result
टेंसर बनाता है.
यह कार्रवाई, 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
के अंदर:
- कुछ बाइनरी ट्री के लिए
result@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]))
है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C5), (C6) |
(I2) | replica_groups |
si64 टाइप के 1-डाइमेंशन वाले टेंसर कॉन्सटेंट का वैरैडिक नंबर |
(सी1-सी3) |
(I3) | channel_id |
si64 टाइप का कॉन्सटेंट |
(सी4) |
(I4) | use_global_device_ids |
i1 टाइप का कॉन्सटेंट |
(सी4) |
(I5) | computation |
फ़ंक्शन | (सी5) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C6-C7) |
कंस्ट्रेंट
- (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(result) = shape(operand)
. - (C7)
element_type(result) = E
.
उदाहरण
// num_replicas: 2
// num_partitions: 1
// %operand@(0, 0): [1, 2, 3, 4]
// %operand@(1, 0): [5, 6, 7, 8]
%result = "stablehlo.all_reduce"(%operand) ({
^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_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor<i64>) -> tensor<i64>
// %result@(0, 0): [6, 8, 10, 12]
// %result@(1, 0): [6, 8, 10, 12]
all_to_all
सिमैंटिक
StableHLO प्रोसेस ग्रिड में मौजूद हर प्रोसेस ग्रुप में, operand
टेंसर की वैल्यू को split_dimension
के साथ-साथ हिस्सों में बांटता है, प्रोसेस के बीच में स्प्लिट किए गए हिस्सों को बांटता है, concat_dimension
की मदद से, बिखरे हुए हिस्सों को बांटता है, और result
टेंसर बनाता है.
यह कार्रवाई, 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(operand@sender, split_count, split_dimension)
.scattered_parts@receiver = [split_parts@sender[receiver_index] for sender in process_group]
, जहांreceiver_index = process_group.index(receiver)
.result@process = concatenate(scattered_parts@process, concat_dimension)
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1-C3), (C9) |
(I2) | split_dimension |
si64 टाइप का कॉन्सटेंट |
(C1), (C2), (C9) |
(I3) | concat_dimension |
si64 टाइप का कॉन्सटेंट |
(C3), (C9) |
(I4) | split_count |
si64 टाइप का कॉन्सटेंट |
(C2), (C4), (C8), (C9) |
(I5) | replica_groups |
si64 टाइप का 2-डाइमेंशन टेंसर कॉन्सटेंट |
(सी5-सी8) |
(I6) | channel_id |
si64 टाइप का कॉन्सटेंट |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी9) |
कंस्ट्रेंट
- (C1)
0 <= split_dimension < rank(operand)
. - (C2)
dim(operand, split_dimension) % split_count = 0
. - (C3)
0 <= concat_dimension < rank(operand)
. - (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(result) = type(operand)
, इसे छोड़कर:dim(result, split_dimension) = dim(operand, split_dimension) / split_count
.dim(result, concat_dimension) = dim(operand, concat_dimension) * split_count
.
उदाहरण
// num_replicas: 2
// num_partitions: 1
// %operand@(0, 0): [[1, 2, 3, 4],
// [5, 6, 7, 8]]
// %operand@(1, 0): [[9, 10, 11, 12],
// [13, 14, 15, 16]]
%result = "stablehlo.all_to_all"(%operand) {
split_dimension = 1 : i64,
concat_dimension = 0 : i64,
split_count = 2 : i64,
replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<2x4xi64>) -> tensor<4x2xi64>
// %result@(0, 0): [[1, 2],
// [5, 6],
// [9, 10],
// [13, 14]]
// %result@(1, 0): [[3, 4],
// [7, 8],
// [11, 12],
// [15, 16]]
और
सिमैंटिक
दो टेंसर lhs
और rhs
से, एलिमेंट के हिसाब से AND काम करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- बूलियन के लिए: लॉजिकल AND.
- पूर्णांक के लिए: बिट के अनुसार AND.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
बूलियन या पूर्णांक टाइप का टेंसर | (सी1) |
(I2) | rhs |
बूलियन या पूर्णांक टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
बूलियन या पूर्णांक टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (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
. - सम्मिश्र संख्याओं के लिए: जटिल atan2.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(atan2, lhs, rhs, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
(I2) | rhs |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (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
टेंसर बनाता है. औपचारिक तौर पर, इस कार्रवाई को 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))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (C1-C3), (C5) |
(I2) | scale |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (C2), (C4), (C5) |
(I3) | mean |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (C2), (C4) |
(I4) | variance |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (C2), (C4) |
(I5) | grad_output |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (C2), (C3) |
(I6) | epsilon |
f32 टाइप का कॉन्सटेंट |
|
(I7) | feature_index |
si64 टाइप का कॉन्सटेंट |
(C1), (C5) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
grad_operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (C2), (C3) |
grad_scale |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (C2), (C4) |
grad_offset |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (C2), (C4) |
कंस्ट्रेंट
- (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
टेंसर बनाता है. औपचारिक तौर पर, इस कार्रवाई को Python सिंटैक्स का इस्तेमाल करके मौजूदा StableHLO ऑपरेशन में अपघटन के तौर पर
इस तरह से दिखाया जा सकता है:
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))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1-सी7) |
(I2) | scale |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (C2), (C3) |
(I3) | offset |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (C2), (C4) |
(I4) | mean |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (सी5) |
(I5) | variance |
फ़्लोटिंग-पॉइंट या पर-टेंसर मात्रा के हिसाब से 1-डाइमेंशन वाला टेंसर | (C2), (C6) |
(I6) | epsilon |
f32 टाइप का कॉन्सटेंट |
|
(I7) | feature_index |
si64 टाइप का कॉन्सटेंट |
(C1), (C3-C6) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (C2), (C7) |
कंस्ट्रेंट
- (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
टेंस को सामान्य बनाया जाता है. औपचारिक तौर पर, इस कार्रवाई को 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))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
(I2) | scale |
फ़्लोटिंग-पॉइंट या पर-टेंसर का मापा गया 1-डाइमेंशन टेंसर | (C2), (C3) |
(I3) | offset |
फ़्लोटिंग-पॉइंट या पर-टेंसर का मापा गया 1-डाइमेंशन टेंसर | (C2), (C4) |
(I4) | epsilon |
f32 टाइप का कॉन्सटेंट |
(C1), (C3-C6) |
(I5) | feature_index |
si64 टाइप का कॉन्सटेंट |
(C1), (C3-C6) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
output |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी7) |
batch_mean |
फ़्लोटिंग-पॉइंट या पर-टेंसर का मापा गया 1-डाइमेंशन टेंसर | (C2), (C5) |
batch_var |
फ़्लोटिंग-पॉइंट या पर-टेंसर का मापा गया 1-डाइमेंशन टेंसर | (C2), (C6) |
कंस्ट्रेंट
- (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
टेंसर बनाता है. यहां result
टेंसर के टाइप
का इस्तेमाल करके, पूरे operand
टेंसर के बिट का दोबारा मतलब निकाला जाता है.
औपचारिक तौर पर, 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
, किसी दी गई वैल्यू को मेमोरी में दिखाता है. इसके काम करने का तरीका तय होता है, क्योंकि टेंसर को सटीक रूप से लागू करने के बारे में बताया जाता है. साथ ही, एलिमेंट के टाइप को सटीक रूप से लागू करने के बारे में भी बताया जाता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या क्वानटिाइज़्ड टेंसर | (सी1-सी2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या क्वानटिाइज़्ड टेंसर | (सी1-सी2) |
कंस्ट्रेंट
- (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
टेंसर बनाता है. औपचारिक तौर पर,
axes(operand)
में मौजूद सभी d
के लिए
result[result_index] = operand[operand_index]
:
- अगर
dim(operand, d) = 1
है, तोoperand_index[d] = 0
. - अगर ऐसा नहीं है, तो
operand_index[d] = result_index[broadcast_dimensions[d]]
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या क्वानटिाइज़्ड टेंसर | (C1-C2), (C5-C6) |
(I2) | broadcast_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(सी2-सी6) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या क्वानटिाइज़्ड टेंसर | (C1), (C3), (C5-C6) |
कंस्ट्रेंट
- (C1)
element_type(result)
को यह सुविधा देता है:element_type(operand)
, अगर!is_per_axis_quantized(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]
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | index |
si32 टाइप का 0-डाइमेंशन वाला टेंसर |
|
(I2) | branches |
फ़ंक्शन की वैरिएडिक संख्या | (सी1-सी4) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या, मात्रा वाले टेंसर या टोकन | (सी4) |
कंस्ट्रेंट
- (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))
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (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]
सील
सिमैंटिक
यह operand
टेंसर की, एलिमेंट के हिसाब से सेल करता है और result
टेंसर बनाता है.
IEEE-754 के स्पेसिफ़िकेशन के मुताबिक roundToIntegralTowardPositive
कार्रवाई को लागू करता है. संख्या वाले टाइप के लिए, यह वैल्यू
dequantize_op_quantize(ceil, operand, type(result))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
कंस्ट्रेंट
- (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))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | a |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1-सी3) |
(I2) | lower |
i1 टाइप का 0-डाइमेंशन वाला टेंसर कॉन्सटेंट |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (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) के लिए, कॉम्प्लेक्स नंबर का इस्तेमाल हटाने की योजना बना रहे हैं.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | min |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C3) |
(I2) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1-सी4) |
(I3) | max |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C2), (C3) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी4) |
कंस्ट्रेंट
- (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(0, element_type(result)), [], type(result))
नहीं तो.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर | (सी3) |
(I2) | replica_groups |
si64 टाइप के 1-डाइमेंशन वाले टेंसर कॉन्सटेंट का वैरैडिक नंबर |
(C1), (C2) |
(I3) | channel_id |
si64 टाइप का कॉन्सटेंट |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर | (सी3) |
कंस्ट्रेंट
- (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
में बांटती है, जिसके बारे में इस तरह से बताया गया है:
- अगर
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))
नहीं तो.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी5) |
(I2) | source_target_pairs |
si64 टाइप का 2-डाइमेंशन टेंसर कॉन्सटेंट |
(सी1-सी4) |
(I3) | channel_id |
si64 टाइप का कॉन्सटेंट |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
कंस्ट्रेंट
- (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
के साथ फ़्लोटिंग-पॉइंट एलिमेंट टाइप के लिए, op यह IEEE-754 कार्रवाइयां लागू करता है:
EQ
:compareQuietEqual
.NE
:compareQuietNotEqual
.GE
:compareQuietGreaterEqual
.GT
:compareQuietGreater
.LE
:compareQuietLessEqual
.LT
:compareQuietLess
.
compare_type = TOTALORDER
के साथ फ़्लोटिंग-पॉइंट एलिमेंट टाइप के लिए, ऑपरेटर, आईईई-754 से totalOrder
और compareQuietEqual
के कॉम्बिनेशन का इस्तेमाल करता है. ऐसा लगता है कि इस सुविधा का इस्तेमाल नहीं किया गया है. इसलिए, आने वाले समय में हम इसे हटाने की योजना बना रहे हैं (#584).
जटिल एलिमेंट टाइप के लिए, (real, imag)
पेयर की लेक्सिकोग्राफ़िक तुलना, दिए गए comparison_direction
और compare_type
का इस्तेमाल करके की जाती है.
कॉम्प्लेक्स नंबर का क्रम लागू करने में हैरान करने वाले सिमेंटिक शब्द शामिल होते हैं.
इसलिए, आने वाले समय में हम कॉम्प्लेक्स नंबर के लिए ऐसी सहायता हटाने की योजना बना रहे हैं
जब comparison_direction
GE
, GT
, LE
या LT
हो
(#560).
संख्या वाले टाइप के लिए, dequantize_compare(lhs, rhs,
comparison_direction)
परफ़ॉर्म करता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1-सी3) |
(I2) | rhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1-सी2) |
(I3) | comparison_direction |
EQ , NE , GE , GT , LE , और LT की सूची |
|
(I4) | compare_type |
FLOAT , TOTALORDER , SIGNED , और UNSIGNED की Enum |
(सी3) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
बूलियन टाइप का टेंसर | (सी2) |
कंस्ट्रेंट
- (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
. FLOAT
याTOTALORDER
अगरis_float(element_type(lhs))
हो.- अगर
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
टेंसर बनाता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
f32 या f64 टाइप का टेंसर |
(सी1-सी3) |
(I2) | rhs |
f32 या f64 टाइप का टेंसर |
(सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
कॉम्प्लेक्स टाइप का टेंसर | (C2), (C3) |
कंस्ट्रेंट
- (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)]
concatenate
सिमैंटिक
inputs
को dimension
डाइमेंशन के साथ उसी क्रम में लगाता है जिस क्रम में दिए गए तर्क करते हैं और result
टेंसर बनाता है. औपचारिक तौर पर,
result[i0, ..., id, ..., iR-1] = inputs[k][i0, ..., kd, ..., iR-1]
, जहां:
id = d0 + ... + dk-1 + kd
.d
,dimension
के बराबर है औरd0
, ...inputs
केd
वें डाइमेंशन साइज़ हैं.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | inputs |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (सी1-सी6) |
(I2) | dimension |
si64 टाइप का कॉन्सटेंट |
(C2), (C4), (C6) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी5-सी6) |
कंस्ट्रेंट
- (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
टेंसर बनाता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | value |
कॉन्सटेंट | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
output |
टेंसर या क्वानटिाइज़्ड टेंसर | (सी1) |
कंस्ट्रेंट
- (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
में बदल दिया जाता है. नीचे देखें कि यह
जटिल टाइप के लिए कैसे काम करता है.
इंटीजर-टू-इंटीजर, इंटीजर-टू-फ़्लोटिंग-पॉइंट या फ़्लोटिंग-पॉइंट-टू-फ़्लोटिंग-पॉइंट वाले कन्वर्ज़न के लिए, अगर सोर्स वैल्यू को डेस्टिनेशन टाइप में सटीक रूप से दिखाया जा सकता है, तो नतीजे की वैल्यू वही होगी. ऐसा न होने पर, व्यवहार TBD (#180) है.
floating-point-to-integer वाले कन्वर्ज़न के लिए, फ़्रैक्शनल वाले हिस्से को काटा जाता है. अगर डेस्टिनेशन टाइप में छोटी की गई वैल्यू को नहीं दिखाया जा सकता, तो व्यवहार TBD (#180) है.
complex-से-जटिल कन्वर्ज़न वाले कन्वर्ज़न, असल और काल्पनिक हिस्सों को बदलने के लिए फ़्लोटिंग-पॉइंट-टू-फ़्लोटिंग-पॉइंट कन्वर्ज़न के ही तरीके का पालन करते हैं.
complex-to-any-other-type और any-other-type-to-complex कन्वर्ज़न के लिए, सोर्स काल्पनिक वैल्यू को अनदेखा कर दिया जाता है या डेस्टिनेशन काल्पनिक वैल्यू शून्य कर दी जाती है. असल हिस्से का कन्वर्ज़न, फ़्लोट-पॉइंट कन्वर्ज़न के बाद होता है.
आम तौर पर, इस कार्रवाई में डिक्वांटाइज़ेशन (क्वांटाइज़्ड टेंसर से रेगुलर टेंसर में कन्वर्ज़न), क्वांटाइज़ेशन (सामान्य टेंसर से मात्रा वाले टेंसर में कन्वर्ज़न), और रिकंटिाइज़ेशन (क्वांटाइज़्ड टेंसर में कन्वर्ज़न) को शामिल किया जा सकता है. हालांकि, फ़िलहाल हमारे पास इसके लिए काम करने का खास तरीका है - पहले इस्तेमाल के उदाहरण के लिए uniform_dequantize
और सेकंड और तीसरे उदाहरण के लिए uniform_quantize
. आने वाले समय में, इन दोनों ऑपरेशन को convert
(#1576) में मर्ज किया जा सकता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर | (सी1) |
कंस्ट्रेंट
- (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))
की वैल्यू देता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C10-C11), (C14) (C25), (C27-C30) |
(I2) | rhs |
टेंसर या क्वानटिाइज़्ड टेंसर | (C1), (C14-C16), (C25), (C27-C32) |
(I3) | window_strides |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2-C3), (C25) |
(I4) | padding |
si64 टाइप का 2-डाइमेंशन टेंसर कॉन्सटेंट |
(C4), (C25) |
(I5) | lhs_dilation |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C5-C6), (C25) |
(I6) | rhs_dilation |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C7-C8), (C25) |
(I7) | window_reversal |
i1 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(सी9) |
(I8) | input_batch_dimension |
si64 टाइप का कॉन्सटेंट |
(C10), (C13), (C25) |
(I9) | input_feature_dimension |
si64 टाइप का कॉन्सटेंट |
(C11), (C13-C14) |
(I10) | input_spatial_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C12), (C13), (C25) |
(I11) | kernel_input_feature_dimension |
si64 टाइप का कॉन्सटेंट |
(C14), (C18) |
(I12) | kernel_output_feature_dimension |
si64 टाइप का कॉन्सटेंट |
(C15-C16), (C18), (C25), (C32) |
(I13) | kernel_spatial_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C17-C18), (C25) |
(I14) | output_batch_dimension |
si64 टाइप का कॉन्सटेंट |
(C20), (C25) |
(I15) | output_feature_dimension |
si64 टाइप का कॉन्सटेंट |
(C20), (C25), (C33) |
(I16) | output_spatial_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C19-C20), (C25) |
(I17) | feature_group_count |
si64 टाइप का कॉन्सटेंट |
(C11), (C14), (C16), (C21), (C23) |
(I18) | batch_group_count |
si64 टाइप का कॉन्सटेंट |
(C10), (C15), (C22), (C23), (C25) |
(I19) | precision_config |
DEFAULT , HIGH , और HIGHEST के एनम की अलग-अलग संख्या |
(C24) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या क्वानटिाइज़्ड टेंसर | (C25-C28), (C30-C31), (C33) |
कंस्ट्रेंट
- (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)
.
- (C27)
- अगर इस कार्रवाई में क्वांटाइज़्ड टेंसर का इस्तेमाल किया जाता है, तो:
- (C28)
is_quantized_tensor(lhs) and is_quantized_tensor(rhs) and is_quantized_tensor(result)
. - (C29)
storage_type(lhs) = storage_type(rhs)
. - (C30)
expressed_type(lhs) = expressed_type(rhs) = expressed_type(result)
. - (C31) अगर
is_per_tensor_quantized(rhs)
है, तोis_per_tensor_quantized(result)
. - (C32) अगर
is_per_axis_quantized(rhs)
है, तोquantization_dimension(rhs) = kernel_output_feature_dimension
. - (C33) अगर
is_per_axis_quantized(result)
है, तोquantization_dimension(result) = output_feature_dimension
.
- (C28)
उदाहरण
// %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 = dense<4> : tensor<2xi64>,
padding = dense<0> : tensor<2x2xi64>,
lhs_dilation = dense<2> : tensor<2xi64>,
rhs_dilation = dense<1> : tensor<2xi64>,
window_reversal = dense<false> : tensor<2xi1>,
// 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]>,
feature_group_count = 1 : i64,
batch_group_count = 1 : i64,
precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>) -> tensor<1x2x2x1xi32>
// %result: [[
// [[10], [26]],
// [[46], [62]]
// ]]
कोटिज्या
सिमैंटिक
operand
टेंसर पर, एलिमेंट के हिसाब से कोसाइन ऑपरेशन करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
cos
. - सम्मिश्र संख्याओं के लिए: सम्मिश्र कोसाइन.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(cosine, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (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
टेंसर बनाता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
पूर्णांक टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (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) को एक साथ एक ही जगह पर लाने की योजना बना रहे हैं.
इनपुट
लेबल | नाम | टाइप |
---|---|---|
(I1) | inputs |
वैल्यू की अलग-अलग संख्या |
(I2) | call_target_name |
string टाइप का कॉन्सटेंट |
(I3) | has_side_effect |
i1 टाइप का कॉन्सटेंट |
(I4) | backend_config |
string टाइप का कॉन्सटेंट |
(I5) | api_version |
si32 टाइप का कॉन्सटेंट |
(I6) | called_computations |
string टाइप के कॉन्सटेंट की अलग-अलग संख्या |
आउटपुट
नाम | टाइप |
---|---|
results |
वैल्यू की अलग-अलग संख्या |
उदाहरण
%results = "stablehlo.custom_call"(%input0) {
call_target_name = "foo",
has_side_effect = false,
backend_config = "bar",
api_version = 1 : i32,
called_computations = [@foo]
} : (tensor<f64>) -> tensor<f64>
विभाजन
सिमैंटिक
भाज्य lhs
और भाजक rhs
टेंस को एलिमेंट के हिसाब से भाग देता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- पूर्णांकों के लिए: पूर्णांक का विभाजन, जो खारिज किए गए किसी भी हिस्से के भाग के साथ बीजगणितीय भागफल बनाता है.
- फ़्लोट के लिए: IEEE-754 से
division
. - सम्मिश्र संख्याओं के लिए: सम्मिश्र विभाजन.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(divide, lhs, rhs, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया गया टेंसर | (सी1) |
(I2) | rhs |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (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))
की वैल्यू देता है.
यह सिर्फ़ पर-टेंसर क्वांटाइज़ेशन के लिए सिमैंटिक के बारे में बताता है. हर ऐक्सिस पर संख्या बढ़ाने का काम चल रहा है (#1574). साथ ही, आने वाले समय में, हम हाइब्रिड क्वांटाइज़ेशन (#1575) के लिए सहायता जोड़ने पर विचार कर सकते हैं.
precision_config
, ऐक्सेलरेटर बैकएंड पर कंप्यूटेशन की स्पीड और
सटीक होने के बीच संतुलन को कंट्रोल करता है. यह इनमें से कोई एक हो सकता है (इस समय, Enum वैल्यू के सिमेंटिक के बारे में कुछ नहीं बताया गया है, लेकिन हम #755 में इसे ठीक करने की योजना बना रहे हैं):
DEFAULT
: सबसे तेज़ कैलकुलेशन, लेकिन ओरिजनल नंबर का कम से कम सटीक अनुमान.HIGH
: ज़्यादा धीमी कैलकुलेशन, लेकिन ओरिजनल नंबर का ज़्यादा सटीक अनुमान.HIGHEST
: सबसे धीमी गिनती, लेकिन मूल संख्या का सबसे सटीक अनुमान.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C5-C6), (C9-C10), (C12-C16) |
(I2) | rhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C7-C10), (C12) |
(I3) | lhs_batching_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C1), (C3), (C5), (C9), (C12) |
(I4) | rhs_batching_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C1), (C4), (C7), (C9) |
(I5) | lhs_contracting_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C3), (C6), (C10) |
(I6) | rhs_contracting_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C4), (C8), (C10) |
(I7) | precision_config |
DEFAULT , HIGH , और HIGHEST के एनम की अलग-अलग संख्या |
(C11) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C12), (C14), (C16) |
कंस्ट्रेंट
- (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)
.
- (C13)
- अगर इस कार्रवाई में क्वांटाइज़्ड टेंसर का इस्तेमाल किया जाता है, तो:
- (C14)
is_quantized(lhs) and is_quantized(rhs) and is_quantized(result)
. - (C15)
storage_type(lhs) = storage_type(rhs)
. - (C16)
expressed_type(lhs) = expressed_type(rhs) = expressed_type(result)
. - (C17)
zero_points(rhs) = 0
.
- (C14)
उदाहरण
// %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>]
} : (tensor<2x2x2xi64>, tensor<2x2x2xi64>) -> tensor<2x2x2xi64>
// %result: [
// [[1, 2],
// [3, 4]],
// [[5, 6],
// [7, 8]]
// ]
dynamic_slice
सिमैंटिक
डाइनैमिक रूप से कंप्यूट किए गए शुरुआती इंडेक्स का इस्तेमाल करके, operand
से स्लाइस निकालता है और result
टेंसर बनाता है. start_indices
में हर डाइमेंशन के लिए स्लाइस के शुरुआती इंडेक्स होते हैं, हालांकि इसमें बदलाव हो सकता है. साथ ही, slice_sizes
में हर डाइमेंशन के स्लाइस के साइज़ होते हैं. औपचारिक तौर पर,
result[result_index] = operand[operand_index]
यहां:
adjusted_start_indices = clamp(0, start_indices, shape(operand) - slice_sizes)
.operand_index = adjusted_start_indices + result_index
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C2), (C4) |
(I2) | start_indices |
पूर्णांक टाइप के 0-डाइमेंशन वाले टेंसर की वैरैडिक संख्या | (C2), (C3) |
(I3) | slice_sizes |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C4), (C5) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C5) |
कंस्ट्रेंट
- (C1)
element_type(operand) = element_type(result)
. - (C2)
size(start_indices) = size(slice_sizes) = rank(operand)
. - (C3)
same(type(start_indices...))
. - (C4)
0 <= slice_sizes <= shape(operand)
. - (C5)
shape(result) = slice_sizes
.
उदाहरण
// %operand: [
// [0, 0, 1, 1],
// [0, 0, 1, 1],
// [0, 0, 0, 0],
// [0, 0, 0, 0]
// ]
// %start_indices0: -1
// %start_indices1: 3
%result = "stablehlo.dynamic_slice"(%operand, %start_indices0, %start_indices1) {
slice_sizes = dense<[2, 2]> : tensor<2xi64>
} : (tensor<4x4xi32>, tensor<i64>, tensor<i64>) -> tensor<2x2xi32>
// %result: [
// [1, 1],
// [1, 1]
// ]
dynamic_update_slice
सिमैंटिक
इससे result
टेंसर बनता है, जो operand
टेंसर के बराबर होता है. हालांकि, इसमें अंतर सिर्फ़ यह है कि start_indices
से शुरू होने वाली स्लाइस को, update
की वैल्यू के हिसाब से अपडेट किया जाता है.
औपचारिक तौर पर, result[result_index]
को इस तरह परिभाषित किया गया है:
update[update_index]
अगर0 <= update_index < shape(update)
है, तो:adjusted_start_indices = clamp(0, start_indices, shape(operand) - shape(update))
.update_index = result_index - adjusted_start_indices
.
- अगर ऐसा नहीं है, तो
operand[result_index]
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1-C4), (C6) |
(I2) | update |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C2), (C3), (C6) |
(I3) | start_indices |
पूर्णांक टाइप के 0-डाइमेंशन वाले टेंसर की वैरैडिक संख्या | (C4), (C5) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
type(operand) = type(result)
. - (C2)
element_type(update) = element_type(operand)
. - (C3)
rank(update) = rank(operand)
. - (C4)
size(start_indices) = rank(operand)
. - (C5)
same(type(start_indices...))
. - (C6)
0 <= shape(update) <= shape(operand)
.
उदाहरण
// %operand: [
// [1, 1, 0, 0],
// [1, 1, 0, 0],
// [1, 1, 1, 1],
// [1, 1, 1, 1]
// ]
// %update: [
// [1, 1],
// [1, 1]
// ]
// %start_indices0: -1
// %start_indices1: 3
%result = "stablehlo.dynamic_update_slice"(%operand, %update, %start_indices0, %start_indices1)
: (tensor<4x4xi32>, tensor<2x2xi32>, tensor<i64>, tensor<i64>) -> tensor<4x4xi32>
// %result: [
// [1, 1, 1, 1],
// [1, 1, 1, 1],
// [1, 1, 1, 1],
// [1, 1, 1, 1]
// ]
घातांकी
सिमैंटिक
operand
टेंसर पर, एलिमेंट के हिसाब से एक्स्पोनेंशियल कार्रवाई करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
exp
. - सम्मिश्र संख्याओं के लिए: जटिल घातांक.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(exponential, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [[0.0, 1.0], [2.0, 3.0]]
%result = "stablehlo.exponential"(%operand) : (tensor<2x2xf64>) -> tensor<2x2xf64>
// %result: [[1.0, 2.7182818284590451], [7.3890560989306504, 20.085536923187668]]
exponential_minus_one
सिमैंटिक
operand
टेंसर पर, एलिमेंट के हिसाब से एक्सपोनेन्शियल माइनस एक ऑपरेशन करता है और
result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
expm1
. - कॉम्प्लेक्स नंबर (समिश्र संख्याओं) के लिए: कॉम्प्लेक्स एक्सपोनेन्शियल माइनस एक.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(exponential_minus_one, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [0.0, 1.0]
%result = "stablehlo.exponential_minus_one"(%operand) : (tensor<2xf64>) -> tensor<2xf64>
// %result: [0.0, 1.71828187]
एफ़एफ़टी
सिमैंटिक
रीयल और कॉम्प्लेक्स इनपुट/आउटपुट के लिए, फ़ॉरवर्ड और इनवर्स फूरियर ट्रांसफ़ॉर्म करता है.
fft_type
इनमें से एक है:
FFT
: कॉम्प्लेक्स-टू-कॉम्प्लेक्स एफ़एफ़टी को फ़ॉरवर्ड करें.IFFT
: इनवर्स कॉम्प्लेक्स-टू-कॉम्प्लेक्स एफ़एफ़टी.RFFT
: रीयल-टू-कॉम्प्लेक्स एफ़एफ़टी को फ़ॉरवर्ड करें.IRFFT
: इनवर्स रियल-टू-कॉम्प्लेक्स एफ़एफ़टी (इसका मतलब है कि यह मुश्किल शब्दों में होता है, लेकिन असल रिटर्न रीयल होता है).
आधिकारिक तौर पर, अगर fft
, इनपुट के तौर पर कॉम्प्लेक्स टाइप के एक डाइमेंशन वाले टेंसर लेता है, तो आउटपुट के तौर पर एक जैसे 1-डाइमेंशन वाले टेंसर बनाता है और डिस्क्रीट फूरिये कन्वर्ज़न की गणना करता है:
fft_type = FFT
के लिए, result
को एल कंप्यूटेशन की सीरीज़ का फ़ाइनल नतीजा माना जाता है. इसमें L = size(fft_length)
शामिल है. उदाहरण के लिए, L = 3
के लिए:
result1[i0, ..., :] = fft(operand[i0, ..., :])
.result2[i0, ..., :, iR-1] = fft(result1[i0, ..., :, iR-1])
.result[i0, ..., :, iR-2, iR-1] = fft(result2[i0, ..., :, iR-2, iR-1])
.
इसके अलावा, ifft
फ़ंक्शन दिया गया है, जिसमें एक ही तरह का सिग्नेचर है और यह fft
के व्युत्क्रम की गणना करता है:
fft_type = IFFT
के लिए, result
को fft_type = FFT
के लिए कंप्यूटेशन के उलटा तय किया जाता है. उदाहरण के लिए, L = 3
के लिए:
result1[i0, ..., :, iR-2, iR-1] = ifft(operand[i0, ..., :, iR-2, iR-1])
.result2[i0, ..., :, iR-1] = ifft(result1[i0, ..., :, iR-1])
.result[i0, ..., :] = ifft(result2[i0, ..., :])
.
इसके अलावा, फ़्लोटिंग-पॉइंट टाइप के 1 डाइमेंशन वाले टेंसर लेने वाला फ़ंक्शन rfft
, एक ही फ़्लोटिंग-पॉइंट सिमैंटिक वाले कॉम्प्लेक्स टाइप के एक डाइमेंशन वाले टेंसर बनाता है. यह इस तरह काम करता है:
rfft(real_operand) = truncated_result
कहांcomplex_operand... = (real_operand..., 0.0)
.complex_result = fft(complex_operand)
.truncated_result = complex_result[:(rank(complex_result) / 2 + 1)]
.
(जब रीयल ऑपरेंड के लिए डिस्क्रीट फूरिये ट्रांसफ़ॉर्म का हिसाब लगाया जाता है, तो नतीजे के पहले N/2 + 1
एलिमेंट साफ़ तौर पर बाकी के नतीजे के बारे में बताते हैं. इसलिए, ग़ैर-ज़रूरी एलिमेंट की गिनती करने से बचने के लिए, rfft
के नतीजे में काट-छांट की जाती है).
fft_type = RFFT
के लिए, result
को एल कंप्यूटेशन की सीरीज़ का फ़ाइनल नतीजा माना जाता है. इसमें L = size(fft_length)
शामिल है. उदाहरण के लिए, L = 3
के लिए:
result1[i0, ..., :] = rfft(operand[i0, ..., :])
.result2[i0, ..., :, iR-1] = fft(result1[i0, ..., :, iR-1])
.result[i0, ..., :, iR-2, iR-1] = fft(result2[i0, ..., :, iR-2, iR-1])
.
आखिर में, irfft
फ़ंक्शन दिया गया है, जिसमें एक ही तरह का सिग्नेचर है और यह rfft
के व्युत्क्रम की गणना करता है:
fft_type = IRFFT
के लिए, result
को fft_type = RFFT
के लिए कंप्यूटेशन के उलटा तय किया जाता है. उदाहरण के लिए, L = 3
के लिए:
result1[i0, ..., :, iR-2, iR-1] = ifft(operand[i0, ..., :, iR-2, iR-1])
.result2[i0, ..., :, iR-1] = ifft(result1[i0, ..., :, iR-1])
.result[i0, ..., :] = irfft(result2[i0, ..., :])
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप का टेंसर | (C1), (C2), (C4), (C5) |
(I2) | fft_type |
FFT , IFFT , RFFT , और IRFFT की Enum |
(C2), (C5) |
(I3) | fft_length |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C1), (C3), (C4) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप का टेंसर | (C2), (C4), (C5) |
कंस्ट्रेंट
- (C1)
size(fft_length) <= rank(operand)
. - (C2) अलग-अलग तरह के
operand
औरresult
एलिमेंट के बीच संबंध अलग-अलग होता है:- अगर
fft_type = FFT
,element_type(operand)
, औरelement_type(result)
का कॉम्प्लेक्स टाइप एक ही है. - अगर
fft_type = IFFT
,element_type(operand)
, औरelement_type(result)
का कॉम्प्लेक्स टाइप एक ही है. - अगर
fft_type = RFFT
है, तोelement_type(operand)
एक फ़्लोटिंग-पॉइंट टाइप है औरelement_type(result)
एक ही फ़्लोटिंग-पॉइंट वाले सिमैंटिक का कॉम्प्लेक्स टाइप है. - अगर
fft_type = IRFFT
है, तोelement_type(operand)
एक कॉम्प्लेक्स टाइप है औरelement_type(result)
एक ही फ़्लोटिंग-पॉइंट वाले सिमैंटिक का फ़्लोटिंग-पॉइंट टाइप है.
- अगर
- (C3)
1 <= size(fft_length) <= 3
. - (C4) अगर
operand
औरresult
में से, फ़्लोटिंग-पॉइंट टाइप का टेंसरreal
है, तोshape(real)[-size(fft_length):] = fft_length
होगा. - (C5)
shape(result) = shape(operand)
, हालांकि:- अगर
fft_type = RFFT
,dim(result, -1) = dim(operand, -1) = 0 ? 0 : dim(operand, -1) / 2 + 1
. - अगर
fft_type = IRFFT
,dim(operand, -1) = dim(result, -1) = 0 ? 0 : dim(result, -1) / 2 + 1
.
- अगर
उदाहरण
// %operand: [(1.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)]
%result = "stablehlo.fft"(%operand) {
fft_type = #stablehlo<fft_type FFT>,
fft_length = dense<4> : tensor<1xi64>
} : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>
// %result: [(1.0, 0.0), (1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]
फ़्लोर ऑपरेटर डालें
सिमैंटिक
एलिमेंट के हिसाब से operand
टेंसर के फ़्लोर से नतीजे देता है और result
टेंसर बनाता है.
IEEE-754 के स्पेसिफ़िकेशन के मुताबिक roundToIntegralTowardNegative
कार्रवाई को लागू करता है. संख्या वाले टाइप के लिए, यह वैल्यू
dequantize_op_quantize(floor, operand, type(result))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [-0.8166, -0.2530, 0.2530, 0.8166, 2.0]
%result = "stablehlo.floor"(%operand) : (tensor<5xf32>) -> tensor<5xf32>
// %result: [-1.0, -1.0, 0.0, 0.0, 2.0]
इकट्ठा करना
सिमैंटिक
start_indices
में बताए गए ऑफ़सेट से operand
टेंसर से स्लाइस इकट्ठा करता है और result
टेंसर बनाता है.
यह डायग्राम दिखाता है कि result
में मौजूद एलिमेंट, कैसे operand
में मौजूद एलिमेंट को कंक्रीट के उदाहरण का इस्तेमाल करके मैप करते हैं. इस डायग्राम में, result
इंडेक्स के कुछ उदाहरण दिए गए हैं. साथ ही, यह जानकारी दी गई है कि वे किस operand
इंडेक्स से जुड़े हैं.
औपचारिक तौर पर, result[result_index] = operand[operand_index]
जहां:
batch_dims = [d for d in axes(result) and d not in offset_dims]
.batch_index = result_index[batch_dims...]
.start_index
का मतलब है:start_indices[bi0, ..., :, ..., biN]
में, जहांbatch_index
मेंbi
अलग-अलग एलिमेंट होते हैं और:
कोindex_vector_dim
इंडेक्स में डाला जाता है. ऐसा तब होता है, जबindex_vector_dim
<rank(start_indices)
हो.- अगर ऐसा नहीं है, तो
[start_indices[batch_index]]
.
axes(operand)
में मौजूदd_operand
के लिए,full_start_index[d_operand] = clamp(start_index[d_start], 0, dim(operand, d_operand) - slice_sizes[d_operand])
अगरd_operand = start_index_map[d_start]
हो.- अगर ऐसा नहीं है, तो
full_start_index[d_operand] = 0
.
offset_index = result_index[offset_dims...]
.full_offset_index = [oi0, ..., 0, ..., oiN]
, जहांoffset_index
मेंoi
अलग-अलग एलिमेंट होते हैं और0
कोcollapsed_slice_dims
के इंडेक्स में शामिल किया जाता है.operand_index = full_start_index + full_offset_index
.
अगर indices_are_sorted
, true
है, तो लागू करने के तरीके में यह माना जा सकता है कि
start_indices
को start_index_map
के हिसाब से क्रम में लगाया गया है. ऐसा न होने पर,
व्यवहार के बारे में जानकारी नहीं दी जाती. औपचारिक तौर पर, indices(result)
के सभी i1 < i2
के लिए,
full_start_index(i1) <= full_start_index(i2)
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C7), (C10-C12), (C14) |
(I2) | start_indices |
पूर्णांक टाइप का टेंसर | (C2), (C3), (C13) |
(I3) | offset_dims |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C1), (C4-C5), (C13) |
(I4) | collapsed_slice_dims |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C1), (C6-C8), (C13) |
(I5) | start_index_map |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C3), (C9), (C10) |
(I6) | index_vector_dim |
si64 टाइप का कॉन्सटेंट |
(C2), (C3), (C13) |
(I7) | slice_sizes |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C8), (C11-C13) |
(I8) | indices_are_sorted |
i1 टाइप का कॉन्सटेंट |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C5), (C13-C14) |
कंस्ट्रेंट
- (C1)
rank(operand) = size(offset_dims) + size(collapsed_slice_dims)
. - (C2)
0 <= index_vector_dim <= rank(start_indices)
. - (C3)
size(start_index_map) = index_vector_dim < rank(start_indices) ? dim(start_indices, index_vector_dim) : 1
. - (C4)
is_unique(offset_dims) and is_sorted(offset_dims)
. - (C5)
0 <= offset_dims < rank(result)
. - (C6)
is_unique(collapsed_slice_dims) and is_sorted(collapsed_slice_dims)
. - (C7)
0 <= collapsed_slice_dims < rank(operand)
. - (C8)
slice_sizes[collapsed_slice_dims...] <= 1
. - (C9)
is_unique(start_index_map)
. - (C10)
0 <= start_index_map < rank(operand)
. - (C11)
size(slice_sizes) = rank(operand)
. - (C12)
0 <= slice_sizes <= shape(operand)
. - (C13)
shape(result) = combine(batch_dim_sizes, offset_dim_sizes)
जहां:batch_dim_sizes = shape(start_indices)
के अलावा, इसमेंindex_vector_dim
से जुड़ाstart_indices
डाइमेंशन साइज़ शामिल नहीं है.offset_dim_sizes = shape(slice_sizes)
, सिर्फ़slice_sizes
में,collapsed_slice_dims
से जुड़े डाइमेंशन साइज़ शामिल नहीं किए गए हैं.combine
,batch_dim_sizes
कोbatch_dims
के हिसाब से ऐक्सिस पर औरoffset_dim_sizes
कोoffset_dims
से जुड़े ऐक्सिस पर रखता है.
- (C14)
element_type(operand) = element_type(result)
.
उदाहरण
// %operand: [
// [[1, 2], [3, 4], [5, 6], [7, 8]],
// [[9, 10],[11, 12], [13, 14], [15, 16]],
// [[17, 18], [19, 20], [21, 22], [23, 24]]
// ]
// %start_indices: [
// [[0, 0], [1, 0], [2, 1]],
// [[0, 1], [1, 1], [0, 2]]
// ]
%result = "stablehlo.gather"(%operand, %start_indices) {
dimension_numbers = #stablehlo.gather<
offset_dims = [2, 3],
collapsed_slice_dims = [0],
start_index_map = [1, 0],
index_vector_dim = 2>,
slice_sizes = dense<[1, 2, 2]> : tensor<3xi64>,
indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>) -> tensor<2x3x2x2xi32>
// %result: [
// [
// [[1, 2], [3, 4]],
// [[3, 4], [5, 6]],
// [[13, 14], [15, 16]]
// ],
// [
// [[9, 10], [11, 12]],
// [[11, 12], [13, 14]],
// [[17, 18], [19, 20]]
// ]
// ]
get_dimension_size
सिमैंटिक
operand
के दिए गए dimension
के साइज़ की वैल्यू जनरेट करता है. औपचारिक तौर पर,
result = dim(operand, dimension)
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर | (सी1) |
(I2) | dimension |
si64 टाइप का कॉन्सटेंट |
(सी1) |
आउटपुट
नाम | टाइप |
---|---|
result |
si32 टाइप का 0-डाइमेंशन वाला टेंसर |
कंस्ट्रेंट
- (C1)
0 <= dimension < rank(operand)
.
उदाहरण
// %operand: [[1, 2, 3], [4, 5, 6]]
%result = "stablehlo.get_dimension_size"(%operand) {
dimension = 1 : i64
} : (tensor<2x3xi64>) -> tensor<i32>
// %result: 3
get_tuple_element
सिमैंटिक
operand
टपल की index
पोज़िशन पर एलिमेंट एक्सट्रैक्ट करता है और
result
बनाता है. औपचारिक तौर पर, result = operand[index]
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
tuple | (C1), (C2) |
(I2) | index |
si32 टाइप का कॉन्सटेंट |
(C1), (C2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
कोई भी समर्थित प्रकार | (सी2) |
कंस्ट्रेंट
- (C1)
0 <= index < size(operand)
. - (C2)
type(result) = tuple_element_types(operand)[index]
.
उदाहरण
// %operand: ([1.0, 2.0], (3))
%result = "stablehlo.get_tuple_element"(%operand) {
index = 0 : i32
} : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>
// %result: [1.0, 2.0]
if
सिमैंटिक
pred
की वैल्यू के आधार पर, true_branch
या
false_branch
से सिर्फ़ एक फ़ंक्शन को एक्ज़ीक्यूट करने पर आउटपुट देता है. औपचारिक तौर पर, result =
pred ? true_branch() : false_branch()
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | pred |
i1 टाइप का 0-डाइमेंशन वाला टेंसर |
|
(I2) | true_branch |
फ़ंक्शन | (सी1-सी3) |
(I3) | false_branch |
फ़ंक्शन | (C1), (C2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या, मात्रा वाले टेंसर या टोकन | (सी3) |
कंस्ट्रेंट
- (C1)
input_types(true_branch) = input_types(false_branch) = []
. - (C2)
output_types(true_branch) = output_types(false_branch)
. - (C3)
type(results...) = output_types(true_branch)
.
उदाहरण
// %result_true_branch: 10
// %result_false_branch: 11
// %pred: true
%result = "stablehlo.if"(%pred) ({
"stablehlo.return"(%result_true_branch) : (tensor<i32>) -> ()
}, {
"stablehlo.return"(%result_false_branch) : (tensor<i32>) -> ()
}) : (tensor<i1>) -> tensor<i32>
// %result: 10
इमेज
सिमैंटिक
operand
से, एलिमेंट के हिसाब से काल्पनिक हिस्सा निकालता है और result
टेंसर बनाता है. औपचारिक तौर पर, हर एलिमेंट x
के लिए:
imag(x) = is_complex(x) ? imaginary_part(x) :
constant(0, element_type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप का टेंसर | (C1), (C2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट टाइप का टेंसर | (C1), (C2) |
कंस्ट्रेंट
- (C1)
shape(result) = shape(operand)
. - (C2)
element_type(result)
इस तरह परिभाषित किया गया है:- अगर
is_complex(operand)
है, तोcomplex_element_type(element_type(operand))
. - अगर ऐसा नहीं है, तो
element_type(operand)
.
- अगर
उदाहरण
// %operand: [(1.0, 2.0), (3.0, 4.0)]
%result = "stablehlo.imag"(%operand) : (tensor<2xcomplex<f32>>) -> tensor<2xf32>
// %result: [2.0, 4.0]
इनफ़ीड
सिमैंटिक
फ़ीड में मौजूद डेटा को पढ़ता है और results
जनरेट करता है.
infeed_config
के सिमैंटिक लागू करने से तय होते हैं.
results
में पेलोड की वैल्यू पहले और बाद में आने वाला टोकन होता है. आने वाले समय में, हम पेलोड और टोकन को दो अलग-अलग आउटपुट में बांटने की योजना बना रहे हैं, ताकि बेहतर तरीके से काम किया जा सके (#670).
इनपुट
लेबल | नाम | टाइप |
---|---|---|
(I1) | token |
token |
(I2) | infeed_config |
string टाइप का कॉन्सटेंट |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या, मात्रा वाले टेंसर या टोकन | (सी1-सी3) |
कंस्ट्रेंट
- (C1)
0 < size(results)
. - (C2)
is_empty(result[:-1])
याis_tensor(type(results[:-1]))
. - (C3)
is_token(type(results[-1]))
.
उदाहरण
// %token: !stablehlo.token
// infeed_queue[0]: [[1, 2], [3, 4]]
// infeed_queue[1]: [[5, 6], [7, 8]]
%results0:2 = "stablehlo.infeed"(%token) {
infeed_config = ""
} : (!stablehlo.token) -> (tensor<2x2xi64>, !stablehlo.token)
// results0#0: [[1, 2], [3, 4]]
%results1:2 = "stablehlo.infeed"(%token) {
infeed_config = ""
} : (!stablehlo.token) -> (tensor<2x2xi64>, !stablehlo.token)
// results1#0: [[5, 6], [7, 8]]
आयोटा
सिमैंटिक
iota_dimension
डाइमेंशन के साथ शून्य से शुरू होने वाले बढ़ते क्रम में, output
टेंसर में वैल्यू भरता है. औपचारिक तौर पर,
output[result_index] = constant(is_quantized(output) ?
quantize(result_index[iota_dimension], element_type(output)) :
result_index[iota_dimension], element_type(output))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | iota_dimension |
si64 |
(सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
output |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
0 <= iota_dimension < rank(output)
.
उदाहरण
%output = "stablehlo.iota"() {
iota_dimension = 0 : i64
} : () -> tensor<4x5xi32>
// %output: [
// [0, 0, 0, 0, 0],
// [1, 1, 1, 1, 1],
// [2, 2, 2, 2, 2],
// [3, 3, 3, 3, 3]
// ]
%output = "stablehlo.iota"() {
iota_dimension = 1 : i64
} : () -> tensor<4x5xi32>
// %output: [
// [0, 1, 2, 3, 4],
// [0, 1, 2, 3, 4],
// [0, 1, 2, 3, 4],
// [0, 1, 2, 3, 4]
// ]
is_finite
सिमैंटिक
एलिमेंट के हिसाब से जांच करता है कि क्या x
में वैल्यू सीमित है (जैसे, न तो
+Inf, -Inf, और न ही NaN) और y
टेंसर देता है. IEEE-754 स्पेसिफ़िकेशन के मुताबिक isFinite
ऑपरेशन लागू करता है. संख्या वाले टाइप के लिए, नतीजा हमेशा
true
होता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | x |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
y |
बूलियन टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
shape(x) = shape(y)
.
उदाहरण
// Logical values: -Inf, +Inf, NaN, ...
// %x: [0xFFF0000000000000, 0x7FF0000000000000, 0x7FF8000000000000, -10.0, -0.0, 0.0, 10.0]
%y = "stablehlo.is_finite"(%x) : (tensor<7xf64) -> tensor<7xi1>
// %y: [false, false, false, true, true, true, true]
log
सिमैंटिक
यह operand
टेंसर पर, एलिमेंट के हिसाब से लॉगारिद्म (लघुगणक) की कार्रवाई करता है और
result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
log
. - कॉम्प्लेक्स नंबर (समिश्र संख्याओं) के लिए: कॉम्प्लेक्स लॉगारिद्म.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(log, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [[1.0, 2.0], [3.0, 4.0]]
%result = "stablehlo.log"(%operand) : (tensor<2x2xf64>) -> tensor<2x2xf64>
// %result: [[0.0, 0.69314718055994529], [1.0986122886681098, 1.3862943611198906]]
log_plus_one
सिमैंटिक
operand
टेंसर पर, एलिमेंट के हिसाब से लॉगारिद्म और एक कार्रवाई करता है. साथ ही, result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
logp1
. - कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स लॉगारिद्म और वन.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(log_plus_one, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [0.0, -0.999, 7.0, 6.38905621, 15.0]
%result = "stablehlo.log_plus_one"(%operand) : (tensor<5xf64>) -> tensor<5xf64>
// %result: [0.0, -6.90776825, 2.07944155, 2.0, 2.77258873]
लॉजिस्टिक
सिमैंटिक
यह operand
टेंसर पर एलिमेंट के हिसाब से लॉजिस्टिक ऑपरेशन करता है और
result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
division(1, addition(1, exp(-x)))
. - कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स लॉजिस्टिक.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(logistic, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [[0.0, 1.0], [2.0, 3.0]]
%result = "stablehlo.logistic"(%operand) : (tensor<2x2xf64>) -> tensor<2x2xf64>
// %result: [[0.5, 0.73105858], [0.88079708, 0.95257413]]
मैप
सिमैंटिक
dimensions
के किनारे, मैप फ़ंक्शन computation
को inputs
पर लागू करता है और result
टेंसर बनाता है.
औपचारिक तौर पर, result[result_index] = computation(inputs...[result_index])
.
ध्यान दें कि फ़िलहाल, dimensions
का इस्तेमाल नहीं किया गया है और ऐसा हो सकता है कि आने वाले समय में इसे हटा दिया जाए (#487).
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | inputs |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (सी1-सी4) |
(I2) | dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(सी3) |
(I3) | computation |
फ़ंक्शन | (सी4) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C4) |
कंस्ट्रेंट
- (C1)
shape(inputs...) = shape(result)
. - (C2)
0 < size(inputs) = N
. - (C3)
dimensions = range(rank(inputs[0]))
. - (C4)
computation
का टाइप(tensor<E0>, ..., tensor<EN-1>) -> tensor<E'>
है, जिसमेंEi = element_type(inputs[i])
औरE' = element_type(result)
शामिल हैं.
उदाहरण
// %input0: [[0, 1], [2, 3]]
// %input1: [[4, 5], [6, 7]]
%result = "stablehlo.map"(%input0, %input1) ({
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%0 = stablehlo.multiply %arg0, %arg1 : tensor<i64>
stablehlo.return %0 : tensor<i64>
}) {
dimensions = dense<[0, 1]> : tensor<2xi64>
} : (tensor<2x2xi64>, tensor<2x2xi64>) -> tensor<2x2xi64>
// %result: [[0, 5], [12, 21]]
ज़्यादा से ज़्यादा
सिमैंटिक
यह टेंसर lhs
और rhs
पर, एलिमेंट के हिसाब से ज़्यादा से ज़्यादा कार्रवाई करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- बूलियन के लिए: लॉजिकल OR.
- पूर्णांकों के लिए: ज़्यादा से ज़्यादा पूर्णांक.
- फ़्लोट के लिए: IEEE-754 से
maximum
. - कॉम्प्लेक्स नंबर के लिए:
(real, imaginary)
पेयर के लिए ज़्यादा से ज़्यादा लेक्सिकोग्राफ़िक. कॉम्प्लेक्स नंबर का क्रम लागू करने में हैरान करने वाले सिमैंटिक शामिल होते हैं. इसलिए, आने वाले समय में हम इस ऑपरेशन (#560) के लिए, कॉम्प्लेक्स नंबर का इस्तेमाल हटाने की योजना बना रहे हैं. - संख्या वाले टाइप के लिए:
dequantize_op_quantize(maximum, lhs, rhs, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
(I2) | rhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(lhs) = baseline_type(rhs) = baseline_type(result)
.
उदाहरण
// %lhs: [[1, 2], [7, 8]]
// %rhs: [[5, 6], [3, 4]]
%result = "stablehlo.maximum"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[5, 6], [7, 8]]
कम से कम
सिमैंटिक
यह टेंसर lhs
और rhs
पर, एलिमेंट के हिसाब से कम से कम कार्रवाई करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- बूलियन के लिए: लॉजिकल AND.
- पूर्णांकों के लिए: कम से कम पूर्णांक.
- फ़्लोट के लिए: IEEE-754 से
minimum
. - कॉम्प्लेक्स नंबर के लिए:
(real, imaginary)
पेयर के लिए कम से कम लेक्सिकोग्राफ़िक होना चाहिए. कॉम्प्लेक्स नंबर का क्रम लागू करने में हैरान करने वाले सिमैंटिक शामिल होते हैं. इसलिए, आने वाले समय में हम इस ऑपरेशन (#560) के लिए, कॉम्प्लेक्स नंबर का इस्तेमाल हटाने की योजना बना रहे हैं. - संख्या वाले टाइप के लिए:
dequantize_op_quantize(minimum, lhs, rhs, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
(I2) | rhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(lhs) = baseline_type(rhs) = baseline_type(result)
.
उदाहरण
// %lhs: [[1, 2], [7, 8]]
// %rhs: [[5, 6], [3, 4]]
%result = "stablehlo.minimum"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[1, 2], [3, 4]]
गुणा करें
सिमैंटिक
एलिमेंट के हिसाब से, दो टेंसर lhs
और rhs
का गुणनफल करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- बूलियन के लिए: लॉजिकल AND.
- पूर्णांकों के लिए: पूर्णांक का गुणा करना.
- फ़्लोट के लिए: IEEE-754 से
multiplication
. - सम्मिश्र संख्याओं के लिए: जटिल गुणन.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(multiply, lhs, rhs, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
(I2) | rhs |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.multiply"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[5, 12], [21, 32]]
ऋण का चिह्न
सिमैंटिक
एलिमेंट के हिसाब से operand
टेंसर निगेशन करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- साइन किए गए पूर्णांक के लिए: पूर्णांक निगेशन.
- साइन नहीं किए गए पूर्णांक के लिए: बिटकास्ट करके साइन किए गए पूर्णांक पर, पूर्णांक निगेशन, बिटकास्ट करके साइन नहीं किए गए पूर्णांक पर वापस जाएं.
- फ़्लोट के लिए: IEEE-754 से
negate
. - कॉम्प्लेक्स नंबर के लिए: कॉम्प्लेक्स निगेशन.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(negate, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// Negation operation with integer Tensors
// %operand: [0, -2]
%result = "stablehlo.negate"(%operand) : (tensor<2xi32>) -> tensor<2xi32>
// %result: [0, 2]
// Negation operation with with complex tensors
// %operand: (2.5, 0.0)
%result = "stablehlo.negate"(%operand) : (tensor<1xcomplex<f32>>) -> tensor<1xcomplex<f32>>
// %result: [-2.5, -0.0]
नहीं
सिमैंटिक
टेंसर operand
के बजाय, एलिमेंट के हिसाब से result
टेंसर बनाता है.
एलिमेंट टाइप के आधार पर, ये काम करता है:
- बूलियन के लिए: लॉजिकल NOT.
- पूर्णांकों के लिए: बिट के मुताबिक NOT.
तर्क
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
operand |
बूलियन या पूर्णांक टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
बूलियन या पूर्णांक टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
type(operand) = type(result)
.
उदाहरण
// Bitwise operation with with integer tensors
// %operand: [[1, 2], [3, 4]]
%result = "stablehlo.not"(%operand) : (tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[-2, -3], [-4, -5]]
// Bitwise operation with with boolean tensors
// %operand: [true, false]
%result = "stablehlo.not"(%operand) : (tensor<2xi1>) -> tensor<2xi1>
// %result: [false, true]
optimization_barrier
सिमैंटिक
यह पक्का करता है कि operand
बनाने वाले ऑपरेशन, result
पर निर्भर किसी भी ऑपरेशन से पहले एक्ज़िक्यूट होते हैं. साथ ही, कंपाइलर ट्रांसफ़ॉर्मेशन को बैरियर पर मूव करने से रोकते हैं. इसके अलावा, यह कार्रवाई एक आइडेंटिटी है, जैसे कि result = operand
.
तर्क
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
operand |
टेंसर की अलग-अलग संख्या, पर-टेनर मात्रा के हिसाब से संख्या में पाए गए टेंसर या टोकन | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर की अलग-अलग संख्या, पर-टेनर मात्रा के हिसाब से संख्या में पाए गए टेंसर या टोकन | (सी1) |
कंस्ट्रेंट
- (C1)
type(operand...) = type(result...)
.
उदाहरण
// %operand0: 0.0
// %operand1: 1.0
%result0, %result1 = "stablehlo.optimization_barrier"(%operand0, %operand1) : (tensor<f32>, tensor<f32>) -> (tensor<f32>, tensor<f32>)
// %result0: 0.0
// %result1: 1.0
या
सिमैंटिक
दो टेंसर lhs
और rhs
पर, एलिमेंट के हिसाब से OR result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- बूलियन के लिए: लॉजिकल OR.
- पूर्णांक के लिए: बिट के मुताबिक OR.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
पूर्णांक या बूलियन टाइप का टेंसर | (सी1) |
(I2) | rhs |
पूर्णांक या बूलियन टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक या बूलियन टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
type(lhs) = type(rhs) = type(result)
.
उदाहरण
// Bitwise operation with with integer tensors
// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.or"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[5, 6], [7, 12]]
// Logical operation with with boolean tensors
// %lhs: [[false, false], [true, true]]
// %rhs: [[false, true], [false, true]]
%result = "stablehlo.or"(%lhs, %rhs) : (tensor<2x2xi1>, tensor<2x2xi1>) -> tensor<2x2xi1>
// %result: [[false, true], [true, true]]
आउटफ़ीड
सिमैंटिक
आउटफ़ीड में inputs
को लिखता है और result
टोकन बनाता है.
outfeed_config
के सिमैंटिक लागू करने से तय होते हैं.
इनपुट
लेबल | नाम | टाइप |
---|---|---|
(I1) | inputs |
टेंसर या क्वांटाइज़्ड टेंसर की अलग-अलग संख्या |
(I2) | token |
token |
(I3) | outfeed_config |
string टाइप का कॉन्सटेंट |
आउटपुट
नाम | टाइप |
---|---|
result |
token |
उदाहरण
%result = "stablehlo.outfeed"(%inputs0, %token) {
outfeed_config = ""
} : (tensor<2x2x2xi64>, !stablehlo.token) -> !stablehlo.token
पैड
सिमैंटिक
दिए गए padding_value
की मदद से, operand
को टेंसर के चारों ओर और साथ ही टेंसर के एलिमेंट के बीच में रखकर, operand
को बड़ा करता है.
edge_padding_low
और edge_padding_high
, हर डाइमेंशन के लो-एंड (इंडेक्स 0 के बगल में) और हाई-एंड (सबसे बड़े इंडेक्स के बगल में) में जोड़ी गई पैडिंग की संख्या बताते हैं. पैडिंग की संख्या नेगेटिव हो सकती है. यहां नेगेटिव पैडिंग की कुल वैल्यू, तय किए गए डाइमेंशन से हटाए जाने वाले एलिमेंट की संख्या बताती है.
interior_padding
, हर डाइमेंशन में किसी भी दो एलिमेंट के बीच जोड़ी गई पैडिंग की संख्या बताता है, जो शायद नेगेटिव न हो. इंटीरियर पैडिंग,
एज पैडिंग से पहले होती है, जैसे कि नेगेटिव एज पैडिंग, इंटीरियर-पैडेड ऑपरेंड के एलिमेंट को हटा देगी.
औपचारिक तौर पर, result[result_index]
को इस तरह परिभाषित किया गया है:
operand[operand_index]
अगरresult_index = edge_padding_low + operand_index * (interior_padding + 1)
.- अगर ऐसा नहीं है, तो
padding_value
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C2), (C4) |
(I2) | padding_value |
0-डाइमेंशन वाले टेंसर या पर-टेन्सर का क्वानटिफ़ाई किया गया टेंसर | (सी1) |
(I3) | edge_padding_low |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C1), (C4) |
(I4) | edge_padding_high |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C1), (C4) |
(I5) | interior_padding |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(सी2-सी4) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी3-सी6) |
कंस्ट्रेंट
- (C1)
element_type(operand) = element_type(padding_value) = element_type(result)
. - (C2)
size(edge_padding_low) = size(edge_padding_high) = size(interior_padding) = rank(operand)
. - (C3)
0 <= interior_padding
. - (C4)
shape(result) = shape(operand) + edge_padding_low + max(shape(operand) - 1, 0) * interior_padding + edge_padding_high
.
उदाहरण
// %operand: [
// [1, 2, 3],
// [4, 5, 6]
// ]
// %padding_value: 0
%result = "stablehlo.pad"(%operand, %padding_value) {
edge_padding_low = dense<[0, 1]> : tensor<2xi64>,
edge_padding_high = dense<[2, 1]> : tensor<2xi64>,
interior_padding = dense<[1, 2]> : tensor<2xi64>
} : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>
// %result: [
// [0, 1, 0, 0, 2, 0, 0, 3, 0],
// [0, 0, 0, 0, 0, 0, 0, 0, 0],
// [0, 4, 0, 0, 5, 0, 0, 6, 0],
// [0, 0, 0, 0, 0, 0, 0, 0, 0],
// [0, 0, 0, 0, 0, 0, 0, 0, 0]
// ]
partition_id
सिमैंटिक
मौजूदा प्रोसेस का partition_id
बनता है.
आउटपुट
नाम | टाइप |
---|---|
result |
ui32 टाइप का 0-डाइमेंशन वाला टेंसर |
उदाहरण
%result = "stablehlo.partition_id"() : () -> tensor<ui32>
पॉपसींट
सिमैंटिक
operand
टेंसर में सेट किए गए बिट की संख्या की एलिमेंट के हिसाब से गिनती करता है और result
टेंसर बनाता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
पूर्णांक टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
type(operand) = type(result)
.
उदाहरण
// %operand: [0, 1, 2, 127]
%result = "stablehlo.popcnt"(%operand) : (tensor<4xi64>) -> tensor<4xi64>
// %result: [0, 1, 1, 7]
शारीरिक गतिविधि से बनी पावर का डेटा
सिमैंटिक
यह फ़ंक्शन, lhs
टेंसर को rhs
टेंसर के हिसाब से एक्सपोनेन्शियल (तत्व के हिसाब से) करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- पूर्णांकों के लिए: पूर्णांक घातांक.
- फ़्लोट के लिए: IEEE-754 से
pow
. - सम्मिश्र संख्याओं के लिए: सम्मिश्र घातांक.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(power, lhs, rhs, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
(I2) | rhs |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %lhs: [-2.0, -0.0, -36.0, 5.0, 3.0, 10000.0]
// %rhs: [2.0, 2.0, 1.1, 2.0, -1.0, 10.0]
%result = "stablehlo.power"(%lhs, %rhs) : (tensor<6xf64>, tensor<6xf64>) -> tensor<6xf64>
// %result: [4.0, 0.0, -nan, 25.0, 0.333333343, inf]
वास्तविक
सिमैंटिक
operand
से, एलिमेंट के हिसाब से असली हिस्सा निकालता है और result
टेंसर बनाता है. औपचारिक तौर पर, हर एलिमेंट x
के लिए:
real(x) = is_complex(x) ? real_part(x) : x
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप का टेंसर | (C1), (C2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट टाइप का टेंसर | (C1), (C2) |
कंस्ट्रेंट
- (C1)
shape(result) = shape(operand)
. - (C2)
element_type(result)
इस तरह परिभाषित किया गया है:- अगर
is_complex(operand)
है, तोcomplex_element_type(element_type(operand))
. - अगर ऐसा नहीं है, तो
element_type(operand)
.
- अगर
उदाहरण
// %operand: [(1.0, 2.0), (3.0, 4.0)]
%result = "stablehlo.real"(%operand) : (tensor<2xcomplex<f32>>) -> tensor<2xf32>
// %result: [1.0, 3.0]
Recv
सिमैंटिक
यह channel_id
के साथ किसी चैनल से डेटा लेता है और results
बनाता है.
अगर is_host_transfer
true
है, तो कार्रवाई, होस्ट से डेटा ट्रांसफ़र करती है. ऐसा न होने पर, यह दूसरे डिवाइस से डेटा ट्रांसफ़र करता है. इसका मतलब है कि यह लागू करने के तरीके से तय होता है. यह फ़्लैग, channel_type
में दी गई जानकारी का डुप्लीकेट है. इसलिए, आने वाले समय में हम इनमें से सिर्फ़ एक जानकारी (#666) को रखने की योजना बना रहे हैं.
results
में पेलोड की वैल्यू पहले और बाद में आने वाला टोकन होता है. आने वाले समय में, हम पेलोड और टोकन को दो अलग-अलग आउटपुट में बांटने की योजना बना रहे हैं, ताकि बेहतर तरीके से काम किया जा सके (#670).
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | token |
token |
(सी4) |
(I2) | channel_id |
si64 टाइप का कॉन्सटेंट |
|
(I3) | channel_type |
DEVICE_TO_DEVICE और HOST_TO_DEVICE की Enum |
(सी1) |
(I4) | is_host_transfer |
i1 टाइप का कॉन्सटेंट |
(सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या, मात्रा वाले टेंसर या टोकन | (सी2-सी4) |
कंस्ट्रेंट
- (C1)
channel_type
को इस तरह से परिभाषित किया गया है:HOST_TO_DEVICE
अगरis_host_transfer = true
,- अगर ऐसा नहीं है, तो
DEVICE_TO_DEVICE
.
- (C2)
0 < size(results)
. - (C3)
is_empty(result[:-1])
याis_tensor(type(results[:-1]))
. - (C4)
is_token(type(results[-1]))
.
उदाहरण
%results0, %results1 = "stablehlo.recv"(%token) {
channel_handle = #stablehlo.channel_handle<handle = 1, type = 3>,
is_host_transfer = true
} : (!stablehlo.token) -> (tensor<2x2xi64>, !stablehlo.token)
कम करें
सिमैंटिक
dimensions
के साथ-साथ inputs
और init_values
पर रिडक्शन फ़ंक्शन body
लागू करता है और results
टेंसर बनाता है.
कमी का क्रम, लागू करने के क्रम से तय होता है. इसका मतलब है कि body
और
init_values
को एक मोनोइड बनाना चाहिए, ताकि यह पक्का किया जा सके कि ऑपरेशन सभी इनपुट के लिए एक जैसे नतीजे दे. हालांकि, यह स्थिति
बहुत कम उत्सर्जन के दायरे में नहीं आती है. उदाहरण के लिए, body
के लिए फ़्लोटिंग-पॉइंट जोड़ना और init_values
के लिए शून्य, असल में मोनोइड नहीं बनाता है, क्योंकि फ़्लोटिंग-पॉइंट जोड़ संबंध नहीं होता है.
औपचारिक तौर पर, results...[j0, ..., jR-1] = reduce(input_slices_converted)
जहां:
input_slices = inputs...[j0, ..., :, ..., jR-1]
, जहांdimensions
पर:
डाले जाते हैं.input_slices_converted = to_destination_type(input_slices..., type(func_inputs(body)[:len(func_inputs(body))//2])...)
.init_values_converted = to_destination_type(init_values..., type(func_inputs(body)[len(func_inputs(body))//2:])...)
.- कुछ बाइनरी ट्री के लिए
reduce(input_slices_converted) = exec(schedule)
schedule
, जहां:exec(node) = body(exec(node.left), exec(node.right))
.exec(leaf) = leaf.value
.
schedule
एक लागू लागू किया गया पूरा बाइनरी ट्री है. इसका इन-ऑर्डर ट्रैवर्सल, लागू किए जाने वाले तरीके से तय होता है.index_space(input_slices_converted)
में सभीindex
के लिए,input_slices_converted...[index]
की वैल्यू,index
के बढ़ते हुए लेक्सिकोग्राफ़िक क्रम में हैं.- इसे लागू करने की तय की गई स्थितियों पर,
init_values_converted
की तय की गई संख्या के साथ बांटा गया हो.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | inputs |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (C1-C4), (C6), (C7) |
(I2) | init_values |
0-डाइमेंशन वाले टेंसर या पर-टेन्सर के मात्रा वाले टेंसर की वैरैडिक संख्या | (C2), (C3) |
(I3) | dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C4), (C5), (C7) |
(I4) | body |
फ़ंक्शन | (सी6) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (C3), (C7), (C8) |
कंस्ट्रेंट
- (C1)
same(shape(inputs...))
. - (C2)
element_type(inputs...) = element_type(init_values...)
. - (C3)
0 < size(inputs) = size(init_values) = size(results) = N
. - (C4)
0 <= dimensions < rank(inputs[0])
. - (C5)
is_unique(dimensions)
. - (C6)
body
का टाइप(tensor<E0>, ..., tensor<EN-1>, tensor<E0>, ...,
tensor<EN-1>) -> (tensor<E0>, ..., tensor<EN-1>)
है, जहांis_promotable(element_type(inputs[i]), Ei)
है. - (C7)
shape(results...) = shape(inputs...)
, लेकिनdimensions
से जुड़ेinputs...
के डाइमेंशन साइज़ शामिल नहीं किए गए हैं. [0,N)
में सभीi
के लिए (C8)element_type(results[i]) = Ei
.
उदाहरण
// %input = [[0, 1, 2, 3, 4, 5]]
// %init_value = 0
%result = "stablehlo.reduce"(%input, %init_value) ({
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
"stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
dimensions = dense<1> : tensor<1xi64>
} : (tensor<1x6xi64>, tensor<i64>) -> tensor<1xi64>
// %result = [15]
reduce_precision
सिमैंटिक
एलिमेंट के हिसाब से operand
को किसी दूसरे फ़्लोटिंग-पॉइंट टाइप में बदलता है, जो exponent_bits
और mantissa_bits
का इस्तेमाल करता है. साथ ही, वापस मूल फ़्लोटिंग-पॉइंट टाइप में बदलता है और output
टेंसर बनाता है.
औपचारिक तौर पर:
- मूल वैल्यू के मैंटिसा बिट को अपडेट किया जाता है, ताकि
roundToIntegralTiesToEven
सिमैंटिक का इस्तेमाल करके, मूल वैल्यू कोmantissa_bits
की मदद से सबसे करीबी वैल्यू में पूरा किया जा सके. - इसके बाद, अगर
mantissa_bits
, ओरिजनल वैल्यू के मैंटिसा बिट की संख्या से कम है, तो मैंटिसा बिट को छोटा करकेmantissa_bits
कर दिया जाता है. - इसके बाद, अगर इंटरमीडिएट नतीजे के घातांक बिट,
exponent_bits
से मिली रेंज में फ़िट नहीं होते हैं, तो इंटरमीडिएट नतीजा, मूल चिह्न का इस्तेमाल करके अनंत संख्या में ओवरफ़्लो हो जाता है. इसके अलावा, मूल चिह्न का इस्तेमाल करके अंडरफ़्लो करके शून्य पर सेट हो जाता है. - संख्या वाले टाइप के लिए,
dequantize_op_quantize( lambda operand: reduce_precision(operand, exponent_bits, mantissa_bits), operand, type(result))
की वैल्यू देता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
(I2) | exponent_bits |
si32 टाइप का कॉन्सटेंट |
(सी2) |
(I3) | mantissa_bits |
si32 टाइप का कॉन्सटेंट |
(सी3) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
output |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(output)
. - (C2)
1 <= exponent_bits
. - (C3)
0 <= mantissa_bits
.
उदाहरण
// Logical values: +Inf, NaN, +Denormal, 0.0, 65519.0, 65520.0
// %operand: [0x7FF0000000000000, 0x7FFFFFFFFFFFFFFF, 0x0000000000000001, 0.0, 65519.0, 65520.0]
%output = "stablehlo.reduce_precision"(%operand) {
exponent_bits = 5 : i32,
mantissa_bits = 10 : i32
} : (tensor<6xf64>) -> tensor<6xf64>
// Logical values: +Inf, NaN, 0.0, 0.0, 65504.0, +Inf
// %output: [0x7FF0000000000000, 0x7FFFFFFFFFFFFFFF, 0.0, 0.0, 65504.0, 0x7FF0000000000000]
reduce_scatter
सिमैंटिक
StableHLO प्रोसेस ग्रिड में मौजूद हर प्रोसेस ग्रुप में, रिडक्शन करता है. इसके लिए, हर प्रोसेस के operand
टेंसर की वैल्यू पर computations
का इस्तेमाल करके, रिडक्शन के नतीजे को scatter_dimension
के साथ-साथ कई हिस्सों में बांट दिया जाता है. साथ ही, result
बनाने के लिए प्रोसेस के बीच में बंटे हुए हिस्सों को बांट देता है.
यह कार्रवाई, 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
के अंदर:
reduced_value = all_reduce(operand, replica_groups, channel_id, use_global_device_ids, computation)
.parts@sender = split(reduced_value@sender, dim(process_groups, 1), scatter_dimension)
.process_group
में मौजूद सभीsender
के लिएresult@receiver = parts@sender[receiver_index]
, जहांreceiver_index = process_group.index(receiver)
है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C2), (C7), (C8) |
(I2) | scatter_dimension |
si64 टाइप का कॉन्सटेंट |
(C1), (C2), (C8) |
(I3) | replica_groups |
si64 टाइप का 2-डाइमेंशन टेंसर कॉन्सटेंट |
(सी3-सी5) |
(I4) | channel_id |
si64 टाइप का कॉन्सटेंट |
(सी6) |
(I5) | use_global_device_ids |
i1 टाइप का कॉन्सटेंट |
(सी6) |
(I6) | computation |
फ़ंक्शन | (सी7) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C8-C9) |
कंस्ट्रेंट
- (C1)
dim(operand, scatter_dimension) % dim(process_groups, 1) = 0
. - (C2)
0 <= scatter_dimension < rank(operand)
. - (C3)
is_unique(replica_groups)
. - (C4)
size(replica_groups)
को इस तरह से परिभाषित किया गया है:- अगर
cross_replica
का इस्तेमाल किया गया है, तोnum_replicas
. - अगर
cross_replica_and_partition
का इस्तेमाल किया गया है, तोnum_replicas
. - अगर
flattened_ids
का इस्तेमाल किया गया है, तोnum_processes
.
- अगर
- (C5)
0 <= replica_groups < size(replica_groups)
. - (C6) अगर
use_global_device_ids = true
है, तोchannel_id > 0
. - (C7)
computation
का टाइप(tensor<E>, tensor<E>) -> (tensor<E>)
है, जहांis_promotable(element_type(operand), E)
है. - (C8)
shape(result) = shape(operand)
, इसे छोड़कर:dim(result, scatter_dimension) = dim(operand, scatter_dimension) / dim(process_groups, 1)
.
- (C9)
element_type(result) = E
.
उदाहरण
// num_replicas: 2
// num_partitions: 1
// %operand@(0, 0): [[1, 2, 3, 4],
// [5, 6, 7, 8]]
// %operand@(1, 0): [[9, 10, 11, 12],
// [13, 14, 15, 16]]
%result = "stablehlo.reduce_scatter"(%operand) ({
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
"stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
scatter_dimension = 1 : i64,
replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor<2x4xi64>) -> tensor<2x2xi64>
//
// %result@(0, 0): [[10, 12],
// [18, 20]]
// %result@(1, 0): [[14, 16],
// [22, 24]]
reduce_window
सिमैंटिक
inputs
और init_values
की विंडो पर कम करने वाला फ़ंक्शन body
लागू करता है और results
बनाता है.
यह डायग्राम दिखाता है कि कंक्रीट के उदाहरण का इस्तेमाल करके, inputs...
से results...
में एलिमेंट की गिनती कैसे की जाती है.
औपचारिक तौर पर,
results...[result_index] = reduce(windows, init_values, axes(inputs...), body)
(कम करें देखें) जहां:
padded_inputs = pad(inputs..., init_values..., padding[:, 0], padding[:, 1], base_dilations - 1)
.window_start = result_index * window_strides
.window_end = window_start + (window_dimensions - 1) * window_dilations + 1
.windows = slice(padded_inputs..., window_start, window_end, window_dilations)
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | inputs |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (C1-C4), (C6), (C8), (C10), (C12), (C13), (C15) |
(I2) | init_values |
0-डाइमेंशन वाले टेंसर या पर-टेन्सर के मात्रा वाले टेंसर की वैरैडिक संख्या | (C1), (C13) |
(I3) | window_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C4), (C5), (C15) |
(I4) | window_strides |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C6), (C7), (C15) |
(I5) | base_dilations |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C8), (C9), (C15) |
(I6) | window_dilations |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C10), (C11), (C15) |
(I7) | padding |
si64 टाइप का 2-डाइमेंशन टेंसर कॉन्सटेंट |
(C12), (C15) |
(I8) | body |
फ़ंक्शन | (C13) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (C1), (C14-C16) |
कंस्ट्रेंट
- (C1)
0 < size(inputs) = size(init_values) = size(results) = N
. - (C2)
same(shape(inputs...))
. - (C3)
element_type(inputs...) = element_type(init_values...)
. - (C4)
size(window_dimensions) = rank(inputs[0])
. - (C5)
0 < window_dimensions
. - (C6)
size(window_strides) = rank(inputs[0])
. - (C7)
0 < window_strides
. - (C8)
size(base_dilations) = rank(inputs[0])
. - (C9)
0 < base_dilations
. - (C10)
size(window_dilations) = rank(inputs[0])
. - (C11)
0 < window_dilations
. - (C12)
shape(padding) = [rank(inputs[0]), 2]
. - (C13)
body
का टाइप(tensor<E0>, ..., tensor<EN-1>, tensor<E0>, ...,
tensor<EN-1>) -> (tensor<E0>, ..., tensor<EN-1>)
है, जहांis_promotable(element_type(inputs[i]), Ei)
है. - (C14)
same(shape(results...))
. - (C15)
shape(results[0]) = num_windows
जहां:dilated_input_shape = shape(inputs[0]) = 0 ? 0 : (shape(inputs[0]) - 1) * base_dilations + 1
.padded_input_shape = padding[:, 0] + dilated_input_shape + padding[:, 1]
.dilated_window_shape = (window_dimensions - 1) * window_dilations + 1
.is_empty_window = padded_input_shape = 0 || dilated_window_shape > padded_input_shape
.num_windows = is_empty_window ? 0 : floor((padded_input_shape - dilated_window_shape) / window_strides) + 1
.
[0,N)
में सभीi
के लिए (C16)element_type(results[i]) = Ei
.
उदाहरण
// %input = [[1, 2], [3, 4], [5, 6]]
// %init_value = 0
%result = "stablehlo.reduce_window"(%input, %init_value) ({
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
"stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
window_dimensions = dense<[2, 1]> : tensor<2xi64>,
window_strides = dense<[4, 1]> : tensor<2xi64>,
base_dilations = dense<[2, 1]> : tensor<2xi64>,
window_dilations = dense<[3, 1]> : tensor<2xi64>,
padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi64>, tensor<i64>) -> tensor<2x2xi64>
// %result = [[0, 0], [3, 4]]
शेष
सिमैंटिक
भाज्य lhs
और भाजक rhs
टेंसर का शेष भाग एलिमेंट के हिसाब से करता है और result
टेंसर बनाता है.
औपचारिक रूप से, नतीजे का चिह्न भाजक से लिया जाता है और नतीजे की निरपेक्ष वैल्यू हमेशा भाजक के निरपेक्ष मान से कम होती है.
बाकी बचे पैसों का हिसाब lhs - d * rhs
के तौर पर लगाया जाता है, जहां d
से पता चलता है:
- पूर्णांकों के लिए:
stablehlo.divide(lhs, rhs)
. - फ़्लोट के लिए: राउंडिंग एट्रिब्यूट के साथ IEEE-754 से
division(lhs, rhs)
.roundTowardZero
. - कॉम्प्लेक्स नंबर के लिए: TBD (#997).
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(remainder, lhs, rhs, type(result))
.
फ़्लोटिंग-पॉइंट एलिमेंट टाइप के लिए, यह कार्रवाई IEEE-754 की खास जानकारी में बताए गए remainder
ऑपरेशन से मेल नहीं खाती. इसमें d
, सम से बंधने वाली lhs/rhs
की सटीक वैल्यू के आस-पास की इंटिग्रल वैल्यू है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया गया टेंसर | (सी1) |
(I2) | rhs |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %lhs: [17, -17, 17, -17]
// %rhs: [3, 3, -3, -3]
%result = "stablehlo.remainder"(%lhs, %rhs) : (tensor<4xi64>, tensor<4xi64>) -> tensor<4xi64>
// %result: [2, -2, 2, -2]
replica_id
सिमैंटिक
मौजूदा प्रोसेस का replica_id
बनता है.
आउटपुट
नाम | टाइप |
---|---|
result |
ui32 टाइप का 0-डाइमेंशन वाला टेंसर |
उदाहरण
%result = "stablehlo.replica_id"() : () -> tensor<ui32>
आकार बदलें
सिमैंटिक
operand
टेंसर का आकार बदलकर result
टेंसर बनाता है. सैद्धान्तिक तौर पर,
एक ही कैननिकल वर्शन बनाए रखना, लेकिन आकार में बदलाव
करने का मतलब है. उदाहरण के लिए, tensor<2x3xf32>
से tensor<3x2xf32>
या tensor<6xf32>
.
औपचारिक तौर पर, result[result_index] = operand[operand_index]
में जहां
result_index
और operand_index
, index_space(result)
और index_space(operand)
के लेक्सिकोग्राफ़िक क्रम में एक ही हैं.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या क्वानटिाइज़्ड टेंसर | (सी1-सी3) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या क्वानटिाइज़्ड टेंसर | (सी1-सी3) |
कंस्ट्रेंट
- (C1)
element_type(result)
को यह सुविधा देता है:element_type(operand)
, अगर!is_per_axis_quantized(operand)
है.element_type(operand)
में अंतर हो सकता है. हालांकि, अगर ऐसा नहीं है, तोquantization_dimension(operand)
औरquantization_dimension(result)
में अंतर हो सकता है.
- (C2)
size(operand) = size(result)
. - (C3) अगर
is_per_axis_quantized(operand)
:reduce(dims(operand, [0, 1, ..., quantization_dimension(operand) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y) = reduce(dims(result, [0, 1, ..., quantization_dimension(result) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y)
.dim(operand, quantization_dimension(operand)) = dim(result, quantization_dimension(result))
.reduce(dims(operand, [quantization_dimension(operand) + 1, ..., rank(operand) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y) = reduce(dims(result, [quantization_dimension(result) + 1, ..., rank(result) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y)
.
उदाहरण
// %operand: [[1, 2, 3], [4, 5, 6]]]
%result = "stablehlo.reshape"(%operand) : (tensor<2x3xi32>) -> tensor<3x2xi32>
// %result: [[1, 2], [3, 4], [5, 6]]
reverse
सिमैंटिक
operand
में, तय किए गए dimensions
के साथ एलिमेंट के क्रम को उलटा करता है और result
टेंसर बनाता है. औपचारिक तौर पर,
result[result_index] = operand[operand_index]
यहां:
- अगर
dimensions
मेंd
है, तोoperand_index[d] = dim(result, d) - result_index[d] - 1
. - अगर ऐसा नहीं है, तो
operand_index[d] = result_index[d]
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C3) |
(I2) | dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C3) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C3) |
कंस्ट्रेंट
- (C1)
type(operand) = type(result)
. - (C2)
is_unique(dimensions)
. - (C3)
0 <= dimensions < rank(result)
.
उदाहरण
// %operand = [[1, 2], [3, 4], [5, 6]]
%result = "stablehlo.reverse"(%operand) {
dimensions = dense<1> : tensor<1xi64>
} : (tensor<3x2xi32>) -> tensor<3x2xi32>
// %result: [[2, 1], [4, 3], [6, 5]]
आरएनजी
सिमैंटिक
rng_distribution
एल्गोरिदम का इस्तेमाल करके, रैंडम नंबर जनरेट करता है और दिए गए आकार shape
का result
टेंसर बनाता है.
अगर rng_distribution = UNIFORM
है, तो [a, b)
इंटरवल पर एक जैसा डिस्ट्रिब्यूशन के बाद, रैंडम नंबर जनरेट होते हैं. अगर a >= b
हो,
तो व्यवहार के बारे में नहीं बताया जाता.
अगर rng_distribution = NORMAL
है, तो मीन = a
और स्टैंडर्ड डेविएशन = b
के साथ सामान्य डिस्ट्रिब्यूशन के बाद, रैंडम नंबर जनरेट होते हैं.
अगर b < 0
हो, तो व्यवहार तय नहीं होता.
रैंडम नंबरों को जनरेट करने का तरीका लागू करने से तय होता है. उदाहरण के लिए, वे सारणिक पर सेट हो सकते हैं और नहीं भी. साथ ही, यह भी हो सकता है कि वे छिपी हुई स्थिति का इस्तेमाल करें या न करें.
कई हिस्सेदारों के साथ बातचीत करने के दौरान इस ऑपर्च्यूनिटी को काफ़ी हद तक रोक दिया गया इसलिए, आने वाले समय में हम इसे हटाने की योजना बना रहे हैं (#597).
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | a |
पूर्णांक, बूलियन या फ़्लोटिंग-पॉइंट टाइप का 0-डाइमेंशन टेंसर | (C1), (C2) |
(I2) | b |
पूर्णांक, बूलियन या फ़्लोटिंग-पॉइंट टाइप का 0-डाइमेंशन टेंसर | (C1), (C2) |
(I3) | shape |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(सी3) |
(I4) | rng_distribution |
UNIFORM और NORMAL की Enum |
(सी2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक, बूलियन या फ़्लोटिंग-पॉइंट टाइप का टेंसर | (सी1-सी3) |
कंस्ट्रेंट
- (C1)
element_type(a) = element_type(b) = element_type(result)
. - (C2) अगर
rng_distribution = NORMAL
है, तोis_float(a)
. - (C3)
shape(result) = shape
.
उदाहरण
// %a = 0
// %b = 2
// %shape = [3, 3]
%result = "stablehlo.rng"(%a, %b, %shape) {
rng_distribution = #stablehlo<rng_distribution UNIFORM>
} : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>
// %result: [
// [1, 0, 1],
// [1, 1, 1],
// [0, 0, 0]
// ]
rng_bit_generator
सिमैंटिक
यूनिफ़ॉर्म रैंडम बिट और अपडेट किए गए आउटपुट स्टेटस से भरा output
दिखाता है.
यह स्यूडोरैंडम नंबर जनरेटर एल्गोरिदम का इस्तेमाल करके, rng_algorithm
शुरुआती स्थिति initial_state
देता है.output_state
इस बात की गारंटी नहीं दी जाती है कि आउटपुट, initial_state
का डिटर्मिनिस्टिक फ़ंक्शन है. हालांकि, इसकी कोई गारंटी नहीं है कि यह
लागू करने के तरीके के बीच तय होगा.
rng_algorithm
इनमें से एक है:
DEFAULT
: लागू करने वाला एल्गोरिदम.THREE_FRY
: Thryfry एल्गोरिदम का लागू करने वाला वैरिएंट.*PHILOX
: Philox एल्गोरिदम का वह वैरिएंट जिसे लागू किया गया है.*
* देखें: सैलमन और अन्य एससी 2011. पैरलल रैंडम नंबर: 1, 2, 3 जितना आसान.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | rng_algorithm |
DEFAULT , THREE_FRY , और PHILOX की Enum |
(सी2) |
(I2) | initial_state |
ui64 टाइप का 1-डाइमेंशन टेंसर |
(C1), (C2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
output_state |
ui64 टाइप का 1-डाइमेंशन टेंसर |
(सी1) |
output |
पूर्णांक या फ़्लोटिंग-पॉइंट टाइप का टेंसर |
कंस्ट्रेंट
- (C1)
type(initial_state) = type(output_state)
. - (C2)
size(initial_state)
इस तरह परिभाषित किया गया है:- लागू करने से तय होता है, अगर
rng_algorithm = DEFAULT
. - अगर
rng_algorithm = THREE_FRY
है, तो2
. 2
या3
अगरrng_algorithm = PHILOX
हो.
- लागू करने से तय होता है, अगर
उदाहरण
// %initial_state: [1, 2]
%output_state, %output = "stablehlo.rng_bit_generator"(%initial_state) {
rng_algorithm = #stablehlo<rng_algorithm THREE_FRY>
} : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)
// %output_state: [1, 6]
// %output: [
// [9236835810183407956, 16087790271692313299],
// [18212823393184779219, 2658481902456610144]
// ]
round_nearest_afz
सिमैंटिक
एलिमेंट के हिसाब से, सबसे करीबी पूर्णांक की ओर राउंडिंग करता है. इससे टाई को operand
टेंसर पर, शून्य से दूर तोड़ता है और result
टेंसर बनाता है. IEEE-754 निर्देशों
के मुताबिक roundToIntegralTiesToAway
कार्रवाई लागू करता है. संख्या वाले टाइप के लिए, यह
dequantize_op_quantize(round_nearest_afz, operand, type(result))
की वैल्यू देता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand = [-2.5, 0.4, 0.5, 0.6, 2.5]
%result = "stablehlo.round_nearest_afz"(%operand) : (tensor<5xf64>) -> tensor<5xf64>
// %result: [-3.0, 0.0, 1.0, 1.0, 3.0]
round_nearest_even
सिमैंटिक
एलिमेंट के हिसाब से, सबसे करीबी पूर्णांक की ओर राउंडिंग करता है और operand
टेंसर पर, सम पूर्णांक से टाई करता है और result
टेंसर बनाता है. IEEE-754 के स्पेसिफ़िकेशन के मुताबिक roundToIntegralTiesToEven
कार्रवाई को लागू करता है. संख्या वाले टाइप के लिए, यह वैल्यू
dequantize_op_quantize(round_nearest_even, operand, type(result))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट टाइप या पर-टेन्सर का इस्तेमाल किया गया टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand = [-2.5, 0.4, 0.5, 0.6, 2.5]
%result = "stablehlo.round_nearest_even"(%operand) : (tensor<5xf64>) -> tensor<5xf64>
// %result: [-2.0, 0.0, 0.0, 1.0, 2.0]
आरएसक्यूर्ट
सिमैंटिक
operand
टेंसर पर, एलिमेंट के हिसाब से रेसिप्रोकल स्क्वेयर रूट ऑपरेशन करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
rSqrt
. - सम्मिश्र संख्याओं के लिए: जटिल व्युत्क्रम वर्गमूल.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(rsqrt, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [[1.0, 4.0], [9.0, 25.0]]
%result = "stablehlo.rsqrt"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[1.0, 0.5], [0.33333343, 0.2]]
scatter
सिमैंटिक
inputs
टेंसर के बराबर results
टेंसर बनाता है. हालांकि, scatter_indices
में बताए गए कई स्लाइस, update_computation
का इस्तेमाल करके updates
वैल्यू के साथ अपडेट होते हैं.
यह डायग्राम दिखाता है कि updates...
में मौजूद एलिमेंट, कैसे results...
में मौजूद एलिमेंट को कंक्रीट के उदाहरण का इस्तेमाल करके मैप करते हैं. इस डायग्राम में, updates...
इंडेक्स के कुछ उदाहरण दिए गए हैं. साथ ही, यह जानकारी दी गई है कि results...
के किन इंडेक्स के बारे में जानकारी दी गई है.
आधिकारिक तौर पर, index_space(updates[0])
में मौजूद सभी update_index
के लिए:
update_scatter_dims = [d for d in axes(updates[0]) and d not in update_window_dims]
.update_scatter_index = update_index[update_scatter_dims...]
.start_index
का मतलब है:scatter_indices[si0, ..., :, ..., siN]
, जहांupdate_scatter_index
मेंsi
अलग-अलग एलिमेंट होते हैं और:
कोindex_vector_dim
इंडेक्स में डाला जाता है. ऐसा तब होता है, जबindex_vector_dim
<rank(scatter_indices)
हो.- अगर ऐसा नहीं है, तो
[scatter_indices[update_scatter_index]]
.
axes(inputs[0])
में मौजूदd_input
के लिए,full_start_index[d_input] = start_index[d_start]
अगरd_input = scatter_dims_to_operand_dims[d_start]
.- अगर ऐसा नहीं है, तो
full_start_index[d_input] = 0
.
update_window_index = update_index[update_window_dims...]
.full_window_index = [wi0, ..., 0, ..., wiN]
, जहांupdate_window_index
मेंwi
अलग-अलग एलिमेंट होते हैं और0
कोinserted_window_dims
के इंडेक्स में शामिल किया जाता है.result_index = full_start_index + full_window_index
.
इसे देखते हुए, results = exec(schedule, inputs)
, जहां:
schedule
,index_space(updates[0])
का लागू किया गया क्रम है.exec([update_index, ...], results) = exec([...], updated_results)
में:- अगर
result_index
,shape(results...)
की सीमा में है updates_converted = to_destination_type( updates...[update_index], type(func_inputs(update_computation) [len(func_inputs(update_computation))//2:])... )
updated_values = update_computation(results...[result_index], updates_converted)
updated_results
,results
की एक कॉपी है, जिसकीresults...[result_index]
कोupdated_values...
पर सेट किया गया है.- या फिर
updated_results = results
.
- अगर
exec([], results) = results
.
अगर indices_are_sorted
, true
है, तो लागू करने के तरीके में यह माना जा सकता है कि
scatter_indices
को scatter_dims_to_operand_dims
के हिसाब से क्रम में लगाया गया है. ऐसा न होने पर, व्यवहार के बारे में जानकारी नहीं दी जाएगी. औपचारिक तौर पर, indices(result)
के सभी i1 < i2
के लिए, full_start_index(i1)
<= full_start_index(i2)
.
अगर unique_indices
, true
है, तो लागू करने के तरीके यह मान सकता है कि
सभी result_index
इंडेक्स अलग-अलग हैं. अगर unique_indices
,
true
है, लेकिन बिखरे हुए इंडेक्स यूनीक नहीं हैं, तो व्यवहार तय नहीं होता.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | inputs |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (C1), (C2), (C4-C6), (C10), (C13), (C15-C16) |
(I2) | scatter_indices |
पूर्णांक टाइप का टेंसर | (C4), (C11), (C14) |
(I3) | updates |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (C3-C6), (C8) |
(I4) | update_window_dims |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C4), (C7), (C8) |
(I5) | inserted_window_dims |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C4), (C9), (C10) |
(I6) | scatter_dims_to_operand_dims |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C11-C13) |
(I7) | index_vector_dim |
si64 टाइप का कॉन्सटेंट |
(C4), (C11), (C14) |
(I8) | indices_are_sorted |
i1 टाइप का कॉन्सटेंट |
|
(I9) | unique_indices |
i1 टाइप का कॉन्सटेंट |
|
(I10) | update_computation |
फ़ंक्शन | (C15) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (C15-C17) |
कंस्ट्रेंट
- (C1)
same(shape(inputs...))
. - (C2)
rank(inputs[0]) = size(update_window_dims) + size(inserted_window_dims)
. - (C3)
same(shape(updates...))
. - (C4)
shape(updates[0]) = combine(update_scatter_dim_sizes, update_window_dim_sizes)
जहां:update_scatter_dim_sizes = shape(scatter_indices)
, लेकिन इसमेंindex_vector_dim
से जुड़ाscatter_indices
डाइमेंशन साइज़ शामिल नहीं है.update_window_dim_sizes <= shape(inputs[0])
, सिर्फ़inputs[0]
में,inserted_window_dims
से जुड़े डाइमेंशन साइज़ को शामिल नहीं किया गया है.combine
,update_scatter_dim_sizes
कोupdate_scatter_dims
से जुड़े ऐक्सिस पर औरupdate_window_dim_sizes
कोupdate_window_dims
से जुड़े ऐक्सिस पर रखता है.
- (C5)
0 < size(inputs) = size(updates) = N
. - (C6)
element_type(updates...) = element_type(inputs...)
. - (C7)
is_unique(update_window_dims) and is_sorted(update_window_dims)
. - (C8)
0 <= update_window_dims < rank(updates[0])
. - (C9)
is_unique(inserted_window_dims) and is_sorted(update_window_dims)
. - (C10)
0 <= inserted_window_dims < rank(inputs[0])
. - (C11)
size(scatter_dims_to_operand_dims) = index_vector_dim < rank(scatter_indices) ? dim(scatter_indices, index_vector_dim) : 1
. - (C12)
is_unique(scatter_dims_to_operand_dims)
. - (C13)
0 <= scatter_dims_to_operand_dims < rank(inputs[0])
. - (C14)
0 <= index_vector_dim <= rank(scatter_indices)
. - (C15)
update_computation
का टाइप(tensor<E0>, ..., tensor<EN-1>, tensor<E0>, ..., tensor<EN-1>) -> (tensor<E0>, ..., tensor<EN-1>)
है, जहांis_promotable(element_type(inputs[i]), Ei)
है. - (C16)
shape(inputs...) = shape(results...)
. [0,N)
में सभीi
के लिए (C17)element_type(results[i]) = Ei
.
उदाहरण
// %input: [
// [[1, 2], [3, 4], [5, 6], [7, 8]],
// [[9, 10], [11, 12], [13, 14], [15, 16]],
// [[17, 18], [19, 20], [21, 22], [23, 24]]
// ]
// %scatter_indices: [[[0, 2], [1, 0], [2, 1]], [[0, 1], [1, 0], [0, 9]]]
// %update: [
// [[[1, 1], [1, 1]], [[1, 1], [1, 1]], [[1, 1], [1, 1]]],
// [[[1, 1], [1, 1]], [[1, 1], [1, 1]], [[1, 1], [1, 1]]]
// ]
%result = "stablehlo.scatter"(%input, %scatter_indices, %update) ({
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
"stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
scatter_dimension_numbers = #stablehlo.scatter<
update_window_dims = [2, 3],
inserted_window_dims = [0],
scatter_dims_to_operand_dims = [1, 0],
index_vector_dim = 2>,
indices_are_sorted = false,
unique_indices = false
} : (tensor<3x4x2xi64>, tensor<2x3x2xi64>, tensor<2x3x2x2xi64>) -> tensor<3x4x2xi64>
// %result: [
// [[1, 2], [5, 6], [7, 8], [7, 8]],
// [[10, 11], [12, 13], [14, 15], [16, 17]],
// [[18, 19], [20, 21], [21, 22], [23, 24]]
// ]
चुनें
सिमैंटिक
इससे result
टेंसर बनता है, जहां हर एलिमेंट को on_true
या
on_false
टैंसर से चुना जाता है. ऐसा pred
के एलिमेंट की वैल्यू के आधार पर किया जाता है.
औपचारिक तौर पर, result[result_index] = pred_element ? on_true[result_index] :
on_false[result_index]
, जहां pred_element = rank(pred) = 0 ? pred[] :
pred[result_index]
. संख्या वाले टाइप के लिए, यह वैल्यू
dequantize_select_quantize(pred, on_true, on_false, type(result))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | pred |
i1 टाइप का टेंसर |
(सी1) |
(I2) | on_true |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी1-सी2) |
(I3) | on_false |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (सी2) |
कंस्ट्रेंट
- (C1)
rank(pred) = 0 or shape(pred) = shape(on_true)
. - (C2)
baseline_type(on_true) = baseline_type(on_false) = baseline_type(result)
.
उदाहरण
// %pred: [[false, true], [true, false]]
// %on_true: [[1, 2], [3, 4]]
// %on_false: [[5, 6], [7, 8]]
%result = "stablehlo.select"(%pred, %on_true, %on_false) : (tensor<2x2xi1>, tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[5, 2], [3, 8]]
select_and_scatter
सिमैंटिक
select
का इस्तेमाल करके, input
टेंसर के reduce_window
से मिले नतीजे के आधार पर, scatter
का इस्तेमाल करके source
टेंसर की वैल्यू को अलग-अलग करता है और result
टेंसर बनाता है.
इस डायग्राम में दिखाया गया है कि कंक्रीट के उदाहरण का इस्तेमाल करके, result
में मौजूद एलिमेंट की गिनती कैसे की जाती है,
operand
और source
से.
औपचारिक तौर पर:
इन इनपुट के साथ
selected_values = reduce_window_without_init(...)
:- `इनपुट = [ऑपरेंड].
window_dimensions
,window_strides
, औरpadding
को इसी तरह इस्तेमाल किया जा रहा है.base_dilations = windows_dilations = 1
.body
को इस तरह परिभाषित किया गया है:
def body(arg0: tensor<E>, arg1: tensor<E>) -> tensor<E>: return select(arg0, arg1) ? arg0 : arg1;
जहां
E = element_type(operand)
औरreduce_window_without_init
,reduce_window
की तरह ही काम करते हैं. हालांकि, इसमें शामिल वैल्यूreduce
(कम करें देखें) केschedule
में, init वैल्यू शामिल नहीं होती हैं. फ़िलहाल, यह नहीं बताया गया है कि अगर मिलती-जुलती विंडो में कोई वैल्यू (#731) नहीं है, तो क्या होगा.result[result_index] = reduce([source_values], [init_value], [0], scatter)
जहां:source_values = [source[source_index] for source_index in source_indices]
.selected_index(source_index) = operand_index
, अगरselected_values[source_index]
मेंoperand_index
सेoperand
एलिमेंट है.source_indices = [source_index for source_index in indices(source) if selected_index(source_index) = result_index]
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1-C4), (C6), (C8-C11) |
(I2) | source |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C2) |
(I3) | init_value |
0-डाइमेंशन वाले टेंसर या पर-टेन्सर का क्वानटिफ़ाई किया गया टेंसर | (सी3) |
(I4) | window_dimensions |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C4), (C5) |
(I5) | window_strides |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C6), (C7) |
(I6) | padding |
si64 टाइप का 2-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C8) |
(I7) | select |
फ़ंक्शन | (सी9) |
(I8) | scatter |
फ़ंक्शन | (सी10) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C11-C12) |
कंस्ट्रेंट
- (C1)
element_type(operand) = element_type(source)
. - (C2)
shape(source) = num_windows
जहां:padded_operand_shape = padding[:, 0] + shape(operand) + padding[:, 1]
.is_empty_window = padded_operand_shape = 0 || window_dimensions > padded_operand_shape
.num_windows = is_empty_window ? 0 : floor((padded_operand_shape - window_dimensions) / window_strides) + 1
.
- (C3)
element_type(init_value) = element_type(operand)
. - (C4)
size(window_dimensions) = rank(operand)
. - (C5)
0 < window_dimensions
. - (C6)
size(window_strides) = rank(operand)
. - (C7)
0 < window_strides
. - (C8)
shape(padding) = [rank(operand), 2]
. - (C9)
select
का टाइप(tensor<E>, tensor<E>) -> tensor<i1>
है, जहांE = element_type(operand)
है. - (C10)
scatter
का टाइप(tensor<E>, tensor<E>) -> tensor<E>
है, जहांis_promotable(element_type(operand), E)
है. - (C11)
shape(operand) = shape(result)
. - (C12)
element_type(result) = E
.
उदाहरण
// %operand: [[1, 5], [2, 5], [3, 6], [4, 4]]
// %source: [[5, 6], [7, 8]]
// %init_value: 0
%result = "stablehlo.select_and_scatter"(%operand, %source, %init_value) ({
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%0 = "stablehlo.compare"(%arg0, %arg1) {
comparison_direction = #stablehlo<comparison_direction GE>
} : (tensor<i64>, tensor<i64>) -> tensor<i1>
"stablehlo.return"(%0) : (tensor<i1>) -> ()
}, {
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
"stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
window_dimensions = dense<[3, 1]> : tensor<2xi64>,
window_strides = dense<[2, 1]> : tensor<2xi64>,
padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi64>, tensor<2x2xi64>, tensor<i64>) -> tensor<4x2xi64>
// %result: [[0, 0], [0, 0], [5, 14], [7, 0]]
भेजें
सिमैंटिक
channel_id
चैनल पर inputs
भेजता है और result
टोकन बनाता है.
अगर is_host_transfer
true
है, तो कार्रवाई, डेटा को होस्ट को ट्रांसफ़र कर देती है. ऐसा न होने पर, यह डेटा को दूसरे डिवाइस पर ट्रांसफ़र कर देता है. इसका मतलब है कि यह लागू करने के तरीके से तय होता है. यह फ़्लैग, channel_type
में दी गई जानकारी का डुप्लीकेट है. इसलिए, आने वाले समय में हम इनमें से सिर्फ़ एक जानकारी (#666) को रखने की योजना बना रहे हैं.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | inputs |
टेंसर या क्वांटाइज़्ड टेंसर की अलग-अलग संख्या | |
(I2) | token |
token |
|
(I3) | channel_id |
si64 टाइप का कॉन्सटेंट |
|
(I4) | channel_type |
DEVICE_TO_DEVICE और DEVICE_TO_HOST की Enum |
(सी1) |
(I5) | is_host_transfer |
i1 टाइप का कॉन्सटेंट |
(सी1) |
आउटपुट
नाम | टाइप |
---|---|
result |
token |
कंस्ट्रेंट
- (C1)
channel_type
को इस तरह से परिभाषित किया गया है:DEVICE_TO_HOST
अगरis_host_transfer = true
,- अगर ऐसा नहीं है, तो
DEVICE_TO_DEVICE
.
उदाहरण
%result = "stablehlo.send"(%operand, %token) {
channel_handle = #stablehlo.channel_handle<handle = 1, type = 2>,
is_host_transfer = true
} : (tensor<2x2xi64>, !stablehlo.token) -> !stablehlo.token
shift_left
सिमैंटिक
lhs
टेंसर पर, एलिमेंट के हिसाब से लेफ़्ट-शिफ़्ट कार्रवाई करता है. इसके लिए, बिट की rhs
संख्या का इस्तेमाल किया जाता है और result
टेंसर बनता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
पूर्णांक टाइप का टेंसर | (सी1) |
(I2) | rhs |
पूर्णांक टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
type(lhs) = type(rhs) = type(result)
.
उदाहरण
// %lhs: [-1, 0, 1]
// %rhs: [1, 2, 3]
%result = "stablehlo.shift_left"(%lhs, %rhs): (tensor<3xi64>, tensor<3xi64>) -> tensor<3xi64>
// %result: [-2, 0, 8]
shift_right_arithmetic
सिमैंटिक
lhs
टेंसर पर, एलिमेंट के हिसाब से अंकगणितीय राइट-शिफ़्ट ऑपरेशन करता है. इसके लिए,
rhs
बिट का इस्तेमाल किया जाता है और result
टेंसर बनता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
पूर्णांक टाइप का टेंसर | (सी1) |
(I2) | rhs |
पूर्णांक टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
type(lhs) = type(rhs) = type(result)
.
उदाहरण
// %lhs: [-1, 0, 8]
// %rhs: [1, 2, 3]
%result = "stablehlo.shift_right_arithmetic"(%lhs, %rhs): (tensor<3xi64>, tensor<3xi64>) -> tensor<3xi64>
// %result: [-1, 0, 1]
shift_right_logical
सिमैंटिक
lhs
टेंसर पर, एलिमेंट के हिसाब से लॉजिकल राइट-शिफ़्ट कार्रवाई करता है. इसके लिए, rhs
बिट का इस्तेमाल किया जाता है और result
टेंसर जनरेट होता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
पूर्णांक टाइप का टेंसर | (सी1) |
(I2) | rhs |
पूर्णांक टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
type(lhs) = type(rhs) = type(result)
.
उदाहरण
// %lhs: [-1, 0, 8]
// %rhs: [1, 2, 3]
%result = "stablehlo.shift_right_logical"(%lhs, %rhs): (tensor<3xi64>, tensor<3xi64>) -> tensor<3xi64>
// %result: [9223372036854775807, 0, 1]
हस्ताक्षर
सिमैंटिक
operand
एलिमेंट के हिसाब से चिह्न दिखाता है और result
टेंसर बनाता है.
औपचारिक तौर पर हर एलिमेंट x
के लिए, Python सिंटैक्स का इस्तेमाल करके सिमैंटिक इस तरह से समझाया जा सकता है:
def sign(x):
if is_integer(x):
if compare(x, 0, LT, SIGNED): return -1
if compare(x, 0, EQ, SIGNED): return 0
return 1
elif is_float(x):
if is_nan(x): return NaN
if compare(x, -0.0, EQ, FLOAT): return -0.0
if compare(x, +0.0, EQ, FLOAT): return +0.0
if compare(x, 0.0, LT, FLOAT): return -1.0
return 1.0
elif is_complex(x):
if is_nan(real(x)) or is_nan(imag(x)): return (NaN, NaN)
if compare(x, (0.0, 0.0), EQ, FLOAT): return (0.0, 0.0)
return divide(x, convert(abs(x), type(x)))
संख्या वाले टाइप के लिए, यह वैल्यू
dequantize_op_quantize(sign, operand, type(result))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
साइन किए गए इंटीजर, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया हुआ टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
साइन किए गए इंटीजर, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर का क्वानंटाइज़ किया हुआ टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// Logical values: +NaN, -1.0, -0.0, +0.0, 1.0
// operand: [0x7FFFFFFFFFFFFFFF, -1.0, -0.0, 0.0, 1.0]
%result = "stablehlo.sign"(%operand) : (tensor<5xf64>) -> tensor<5xf64>
// Logical values: +NaN, -1.0, -0.0, +0.0, 1.0
// %result: [0x7FFFFFFFFFFFFFFF, -1.0, -0.0, 0.0, 1.0]
ज्या
सिमैंटिक
operand
टेंसर पर, एलिमेंट के हिसाब से साइन ऑपरेशन करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
sin
. - सम्मिश्र संख्याओं के लिए: सम्मिश्र साइन.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(sine, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [
// [0.0, 1.57079632], // [0, pi/2]
// [3.14159265, 4.71238898] // [pi, 3pi/2]
// ]
%result = "stablehlo.sine"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[0.0, 1.0], [0.0, -1.0]]
स्लाइस
सिमैंटिक
स्टैटिक तरीके से कंप्यूट किए गए शुरुआती इंडेक्स का इस्तेमाल करके, operand
से स्लाइस निकालता है और result
टेंसर बनाता है. start_indices
में हर डाइमेंशन के स्लाइस के शुरुआती इंडेक्स होते हैं. limit_indices
में हर डाइमेंशन के स्लाइस के लिए, आखिरी इंडेक्स (खास) शामिल होता है. साथ ही, strides
में हर डाइमेंशन के लिए स्ट्राइड शामिल होते हैं.
औपचारिक तौर पर, result[result_index] = operand[operand_index]
जहां
operand_index = start_indices + result_index * strides
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1-C3), (C5) |
(I2) | start_indices |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C3), (C5) |
(I3) | limit_indices |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C3), (C5) |
(I4) | strides |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(C2), (C4) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या पर-टेंसर मात्रा में मापा गया टेंसर | (C1), (C5) |
कंस्ट्रेंट
- (C1)
element_type(operand) = element_type(result)
. - (C2)
size(start_indices) = size(limit_indices) = size(strides) = rank(operand)
. - (C3)
0 <= start_indices <= limit_indices <= shape(operand)
. - (C4)
0 < strides
. - (C5)
shape(result) = ceil((limit_indices - start_indices) / strides)
.
उदाहरण
// %operand: [
// [0, 0, 0, 0],
// [0, 0, 1, 1],
// [0, 0, 1, 1]
// ]
%result = "stablehlo.slice"(%operand) {
start_indices = dense<[1, 2]> : tensor<2xi64>,
limit_indices = dense<[3, 4]> : tensor<2xi64>,
strides = dense<1> : tensor<2xi64>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>
// % result: [
// [1, 1],
// [1, 1]
// ]
क्रम से लगाएं
सिमैंटिक
comparator
के हिसाब से, dimension
डाइमेंशन के साथ inputs
के 1-डाइमेंशन स्लाइस को एक साथ क्रम में लगाता है और results
बनाता है.
दूसरी कार्रवाइयों में मिलते-जुलते इनपुट के उलट, dimension
नीचे दिए गए सिमैंटिक के साथ नेगेटिव वैल्यू इस्तेमाल करने की अनुमति देता है. आने वाले समय में, एक जैसा अनुभव देने की
वजह से इसे अस्वीकार किया जा सकता है
(#1377).
अगर is_stable
सही है, तो क्रम एक जैसा रहता है. इसका मतलब है कि उन एलिमेंट का क्रम पहले के हिसाब से बना रहता है जिन्हें कम्पैरेटर के बराबर माना जाता है. अगर एक इनपुट हो, तो दो एलिमेंट e1
और e2
को तुलना करने वाला तब ही माना जाता है, जब comparator(e1, e2) = comparator(e2, e1) = false
हो. यह कई इनपुट को सामान्य कैसे बनाता है, इसके लिए नीचे दिया गया औपचारिक तरीका देखें.
आधिकारिक तौर पर, index_space(results[0])
में मौजूद सभी result_index
के लिए:
adjusted_dimension = dimension >= 0 ? dimension : rank(inputs[0]) + dimension
.result_slice = [ri0, ..., :, ..., riR-1]
में,riN
result_index
में अलग-अलग एलिमेंट होते हैं और:
कोadjusted_dimension
में डाला जाता है.inputs_together = (inputs[0]..., ..., inputs[N-1]...)
.results_together[result_slice] = sort(inputs_together[result_slice], comparator_together)
.- जहां
sort
, 1-डाइमेंशन स्लाइस को घटते क्रम में सॉर्ट करता है. इससे यह उम्मीद की जाती है किcomparator_together
true
तब दिखता है, जब बाईं ओर का तर्क, दाएं हाथ के दूसरे आर्ग्युमेंट से कम हो. def comparator_together(lhs_together, rhs_together): args = [] for (lhs_el, rhs_el) in zip(lhs_together, rhs_together): args.append(lhs_el) args.append(rhs_el) return comparator(*args)
(results[0]..., ..., results[N-1]...) = results_together
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | inputs |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (सी1-सी5) |
(I2) | dimension |
si64 टाइप का कॉन्सटेंट |
(सी4) |
(I3) | is_stable |
i1 टाइप का कॉन्सटेंट |
|
(I4) | comparator |
फ़ंक्शन | (सी5) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या या पर-टेंसर के मात्रा वाले टेंसर | (C2), (C3) |
कंस्ट्रेंट
- (C1)
0 < size(inputs)
. - (C2)
type(inputs...) = type(results...)
. - (C3)
same(shape(inputs...) + shape(results...))
. - (C4)
-R <= dimension < R
, जहांR = rank(inputs[0])
. - (C5)
comparator
का टाइप(tensor<E1>, tensor<E1>, ..., tensor<EN-1>, tensor<EN-1>) -> tensor<i1>
है, जिसमेंEi = element_type(inputs[i])
है.
उदाहरण
// %input0 = [[1, 2, 3], [3, 2, 1]]
// %input1 = [[3, 2, 1], [1, 2, 3]]
%result0, %result1 = "stablehlo.sort"(%input0, %input1) ({
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>, %arg2: tensor<i64>, %arg3: tensor<i64>):
%predicate = "stablehlo.compare"(%arg0, %arg1) {
comparison_direction = #stablehlo<comparison_direction GT>
} : (tensor<i64>, tensor<i64>) -> tensor<i1>
"stablehlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
dimension = 0 : i64,
is_stable = true
} : (tensor<2x3xi64>, tensor<2x3xi64>) -> (tensor<2x3xi64>, tensor<2x3xi64>)
// %result0 = [[3, 2, 3], [1, 2, 1]]
// %result1 = [[1, 2, 1], [3, 2, 3]]
sqrt
सिमैंटिक
एलिमेंट के हिसाब से स्क्वेयर रूट, operand
टेंसर पर कार्रवाई करता है और
result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
squareRoot
. - सम्मिश्र संख्याओं के लिए: सम्मिश्र वर्गमूल.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(sqrt, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [[0.0, 1.0], [4.0, 9.0]]
%result = "stablehlo.sqrt"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[0.0, 1.0], [2.0, 3.0]]
घटाएं
सिमैंटिक
यह एलिमेंट के हिसाब से, दो टेंसर lhs
और rhs
को घटाता है और इससे result
टेंसर बनता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- पूर्णांकों के लिए: पूर्णांक घटाना.
- फ़्लोट के लिए: IEEE-754 से
subtraction
. - सम्मिश्र संख्याओं के लिए: जटिल घटाव.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(subtract, lhs, rhs, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
(I2) | rhs |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
पूर्णांक, फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेन्सर से क्वान्टाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(lhs) = baseline_type(rhs) = baseline_type(result)
.
उदाहरण
// %lhs: [[6, 8], [10, 12]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.subtract"(%lhs, %rhs) : (tensor<2x2xf32>, tensor<2x2xf32>) -> (tensor<2x2xf32>)
// %result: [[1, 2], [3, 4]]
टैन
सिमैंटिक
operand
टेंसर पर, एलिमेंट के हिसाब से हाइपरबोलिक टेंजेंट ऑपरेशन करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- फ़्लोट के लिए: IEEE-754 से
tanh
. - कॉम्प्लेक्स नंबर (समिश्र संख्याओं) के लिए: कॉम्प्लेक्स हाइपरबोलिक टैंजेंट.
- संख्या वाले टाइप के लिए:
dequantize_op_quantize(tanh, operand, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_type(operand) = baseline_type(result)
.
उदाहरण
// %operand: [-1.0, 0.0, 1.0]
%result = "stablehlo.tanh"(%operand) : (tensor<3xf32>) -> tensor<3xf32>
// %result: [-0.76159416, 0.0, 0.76159416]
ट्रांसपोज़ करें
सिमैंटिक
permutation
का इस्तेमाल करके, operand
टेंसर के डाइमेंशन की अनुमति देता है और result
टेंसर बनाता है. औपचारिक तौर पर, result[result_index] = operand[operand_index]
जहां result_index[d] = operand_index[permutation[d]]
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर या क्वानटिाइज़्ड टेंसर | (सी1-सी4) |
(I2) | permutation |
si64 टाइप का 1-डाइमेंशन टेंसर कॉन्सटेंट |
(सी2-सी4) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
टेंसर या क्वानटिाइज़्ड टेंसर | (C1), (C3-C4) |
कंस्ट्रेंट
- (C1)
element_type(result)
को यह सुविधा देता है:element_type(operand)
, अगर!is_per_axis_quantized(operand)
है.element_type(operand)
में अंतर हो सकता है. हालांकि, अगर ऐसा नहीं है, तोquantization_dimension(operand)
औरquantization_dimension(result)
में अंतर हो सकता है.
- (C2)
permutation
,range(rank(operand))
का क्रमचय है. - (C3)
shape(result) = dim(operand, permutation...)
. - (C4) अगर
is_per_axis_quantized(result)
है, तोquantization_dimension(operand) = permutation(quantization_dimension(result))
.
उदाहरण
// %operand: [
// [[1,2], [3,4], [5,6]],
// [[7,8], [9,10], [11,12]]
// ]
%result = "stablehlo.transpose"(%operand) {
permutation = dense<[2, 1, 0]> : tensor<3xi64>
} : (tensor<2x3x2xi32>) -> tensor<2x3x2xi32>
// %result: [
// [[1,7], [3,9], [5,11]],
// [[2,8], [4,10], [6,12]]
// ]
triangular_solve
सिमैंटिक
निचले और ऊपरी त्रिकोणीय गुणांकों वाले रैखिक समीकरणों के बैच को हल करता है.
औपचारिक तौर पर, अगर a
और b
दिए गए हैं, तो op(a[i0, ..., iR-3, :, :]) * x = b[i0, ..., iR-3, :, :]
के लिए result[i0, ..., iR-3, :, :]
एक समाधान है, जब left_side
, true
या x * op(a[i0, ..., iR-3, :, :]) = b[i0, ..., iR-3, :, :]
होता है, जब left_side
false
होता है, तो x
वैरिएबल का समाधान होता है. यहां op(a)
का पता transpose_a
से लगाया जाता है. यह इनमें से कोई एक हो सकता है:
NO_TRANSPOSE
:a
का इस्तेमाल करके कार्रवाई करें.TRANSPOSE
:a
के ट्रांसपोज़ पर कार्रवाई करें.ADJOINT
:a
के संयुग्मी अंतरण पर कार्रवाई करें.
अगर lower
true
है या a
का ऊपरी त्रिभुज है, तो इनपुट डेटा को सिर्फ़ a
के निचले त्रिभुज से ही पढ़ा जा सकता है. आउटपुट डेटा उसी त्रिभुज में दिखाया जाता है;
दूसरे त्रिभुज में दी गई वैल्यू, लागू की गई वैल्यू से तय होती हैं.
अगर unit_diagonal
सही है, तो लागू करने वाले टूल यह मान सकता है कि a
के विकर्ण
एलिमेंट 1 के बराबर हैं. ऐसा न होने पर, व्यवहार के बारे में जानकारी नहीं दी जाती.
संख्या वाले टाइप के लिए, यह वैल्यू
dequantize_op_quantize(lambda x, y: triangular_solve(x, y, left_side, lower,
unit_diagonal, transpose_a), a, b, type(result))
के हिसाब से होती है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | a |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1-सी3) |
(I2) | b |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1-सी4) |
(I3) | left_side |
i1 टाइप का कॉन्सटेंट |
(सी3) |
(I4) | lower |
i1 टाइप का कॉन्सटेंट |
|
(I5) | unit_diagonal |
i1 टाइप का कॉन्सटेंट |
|
(I6) | transpose_a |
NO_TRANSPOSE , TRANSPOSE , और ADJOINT की Enum |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट या कॉम्प्लेक्स टाइप या पर-टेंसर क्वानटिाइज़्ड टेंसर का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
baseline_element_type(a) = baseline_element_type(b)
. - (C2)
2 <= rank(a) = rank(b) = R
. - (C3)
shape(a)
औरshape(b)
के बीच का संबंध इस तरह परिभाषित किया गया है:shape(a)[:-3] = shape(b)[:-3]
.dim(a, -2) = dim(a, -1) = dim(b, left_side ? -2 : -1)
.
- (C4)
baseline_type(b) = baseline_type(result)
.
उदाहरण
// %a = [
// [1.0, 0.0, 0.0],
// [2.0, 4.0, 0.0],
// [3.0, 5.0, 6.0]
// ]
// %b = [
// [2.0, 0.0, 0.0],
// [4.0, 8.0, 0.0],
// [6.0, 10.0, 12.0]
// ]
%result = "stablehlo.triangular_solve"(%a, %b) {
left_side = true,
lower = true,
unit_diagonal = false,
transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>
// %result: [
// [2.0, 0.0, 0.0],
// [0.0, 2.0, 0.0],
// [0.0, 0.0, 2.0]
// ]
tuple
सिमैंटिक
val
वैल्यू से result
टपल जनरेट करता है.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | val |
वैल्यू की अलग-अलग संख्या | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
tuple | (सी1) |
कंस्ट्रेंट
- (C1)
result
का टाइपtuple<E0, ..., EN-1>
है, जहांEi = type(val[i])
है.
उदाहरण
// %val0: [1.0, 2.0]
// %val1: (3)
%result = "stablehlo.tuple"(%val0, %val1) : (tensor<2xf32>, tuple<tensor<i32>>) -> tuple<tensor<2xf32>, tuple<tensor<i32>>>
// %result: ([1.0, 2.0], (3))
uniform_dequantize
सिमैंटिक
यह operand
टाइप के हिसाब से तय किए गए वॉल्यूम वाले टेंसर operand
के एलिमेंट के हिसाब से, एलिमेंट के हिसाब से फ़्लोटिंग-पॉइंट टेंसर result
में बदलाव करता है.
औपचारिक तौर पर, result = dequantize(operand)
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
क्वांटाइज़्ड टेंसर | (C1), (C2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
फ़्लोटिंग-पॉइंट टाइप का टेंसर | (C1), (C2) |
कंस्ट्रेंट
- (C1)
shape(operand) = shape(result)
. - (C2)
element_type(result) = expressed_type(operand)
.
उदाहरण
// %operand: [10, 10]
%result = "stablehlo.uniform_dequantize"(%operand) : (tensor<2x!quant.uniform<i8:f32:0, {0.1:-30,0.5:-20}>>) -> tensor<2xf32>
// %result: [4.0, 15.0]
uniform_quantize
सिमैंटिक
यह फ़ंक्शन result
टाइप में तय किए गए क्वांटाइज़ेशन पैरामीटर के मुताबिक, एलिमेंट के हिसाब से फ़्लोटिंग-पॉइंट टेंसर या क्वांटाइज़्ड टेंसर में, operand
को क्वांटाइज़्ड टेंसर result
में बदलता है.
औपचारिक तौर पर,
- अगर
is_float(operand)
:result = quantize(operand, type(result))
.
- अगर
is_quantized(operand)
:float_result = dequantize(operand)
.result = quantize(float_result, type(result))
.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
फ़्लोटिंग-पॉइंट या वॉल्यूम वाले टाइप का टेंसर | (C1), (C2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
क्वांटाइज़्ड टेंसर | (C1), (C2) |
कंस्ट्रेंट
- (C1)
shape(operand) = shape(result)
. - (C2)
expressed_type(result) = is_float(operand) ? element_type(operand) : expressed_type(operand)
.
उदाहरण
// %operand: [4.0, 15.0]
%result = "stablehlo.uniform_quantize"(%operand) : (tensor<2xf32>) -> tensor<2x!quant.uniform<i8:f32:0, {0.1:-30,0.5:-20}>>
// %result: [10, 10]
// %operand: [10, 10]
%result = "stablehlo.uniform_quantize"(%operand) : (tensor<2x!quant.uniform<i8:f32:0, {0.1:-30,0.5:-20}>>) -> tensor<2x!quant.uniform<i8:f32:0, {0.1:-20,0.2:-30}>>
// %result: [20, 45]
समय
सिमैंटिक
body
फ़ंक्शन को 0 या उससे ज़्यादा बार एक्ज़ीक्यूट करने पर आउटपुट देता है, जबकि
cond
फ़ंक्शन true
आउटपुट देता है. औपचारिक तौर पर, Python सिंटैक्स का इस्तेमाल करके सिमैंटिक को इस तरह से दिखाया जा सकता है:
internal_state = operand
while cond(*internal_state):
internal_state = body(*internal_state)
results = internal_state
इनफ़ाइनाइट लूप का व्यवहार TBD है (#383).
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | operand |
टेंसर की अलग-अलग संख्या, मात्रा वाले टेंसर या टोकन | (सी1-सी3) |
(I2) | cond |
फ़ंक्शन | (सी1) |
(I3) | body |
फ़ंक्शन | (सी2) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
results |
टेंसर की अलग-अलग संख्या, मात्रा वाले टेंसर या टोकन | (सी3) |
कंस्ट्रेंट
- (C1)
cond
का टाइप(T0, ..., TN-1) -> tensor<i1>
है, जहांTi = type(operand[i])
है. - (C2)
body
का टाइप(T0, ..., TN-1) -> (T0, ..., TN-1)
है, जहांTi = type(operand[i])
है. - (C3)
type(results...) = type(operand...)
.
उदाहरण
// %init_i: 1
// %init_sum: 0
// %one: 1
// %ten: 10
%results0, %results1 = "stablehlo.while"(%init_i, %init_sum) ({
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%cond = "stablehlo.compare"(%arg0, %ten) {
comparison_direction = #stablehlo<comparison_direction LT>
} : (tensor<i64>, tensor<i64>) -> tensor<i1>
stablehlo.return %cond : tensor<i1>
}, {
^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
%new_sum = stablehlo.add %arg1, %one : tensor<i64>
%new_i = stablehlo.add %arg0, %one : tensor<i64>
stablehlo.return %new_i, %new_sum : tensor<i64>, tensor<i64>
}) : (tensor<i64>, tensor<i64>) -> (tensor<i64>, tensor<i64>)
// %results0: 10
// %results1: 10
एक्सओआर
सिमैंटिक
एलिमेंट के हिसाब से, दो टेंसर lhs
और rhs
का XOR परफ़ॉर्म करता है और result
टेंसर बनाता है. एलिमेंट टाइप के आधार पर, ये काम करता है:
- बूलियन के लिए: लॉजिकल XOR.
- पूर्णांक के लिए: बिट के अनुसार XOR.
इनपुट
लेबल | नाम | टाइप | कंस्ट्रेंट |
---|---|---|---|
(I1) | lhs |
बूलियन या पूर्णांक टाइप का टेंसर | (सी1) |
(I2) | rhs |
बूलियन या पूर्णांक टाइप का टेंसर | (सी1) |
आउटपुट
नाम | टाइप | कंस्ट्रेंट |
---|---|---|
result |
बूलियन या पूर्णांक टाइप का टेंसर | (सी1) |
कंस्ट्रेंट
- (C1)
type(lhs) = type(rhs) = type(result)
.
उदाहरण
// Bitwise operation with with integer tensors
// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.xor"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[4, 4], [4, 12]]
// Logical operation with with boolean tensors
// %lhs: [[false, false], [true, true]]
// %rhs: [[false, true], [false, true]]
%result = "stablehlo.xor"(%lhs, %rhs) : (tensor<2x2xi1>, tensor<2x2xi1>) -> tensor<2x2xi1>
// %result: [[false, true], [true, false]]
प्लान लागू करना
क्रम में एक्ज़ीक्यूशन
StableHLO प्रोग्राम को चलाने के लिए, main
फ़ंक्शन में इनपुट वैल्यू और आउटपुट वैल्यू की गणना की जाती है. किसी फ़ंक्शन के आउटपुट वैल्यू का पता लगाने के लिए,
इससे जुड़े return
ऑपरेटर में रूट किए गए ऑपरेशन के ग्राफ़ को लागू किया जाता है.
एक्ज़ीक्यूशन ऑर्डर, लागू करने के लिए तब तक तय किया जाता है, जब तक कि यह डेटाफ़्लो के साथ अलाइन हो जाता है. इसका मतलब है कि अगर ऑप को उनके इस्तेमाल से पहले लागू किया जाता है. StableHLO में, साइड पर असर डालने वाले सभी ऑपरेशन एक टोकन का इस्तेमाल करते हैं और एक टोकन जनरेट करते हैं (after_all
के ज़रिए कई टोकन को एक टोकन में मल्टीप्लेक्स किया जा सकता है). इसलिए,
साइड इफ़ेक्ट को लागू करने का क्रम भी डेटाफ़्लो के साथ अलाइन होता है. ऊपर दिए गए उदाहरण कार्यक्रम के लागू होने के संभावित आदेश %0
→ %1
→ %2
→ %3
→ %4
→ return
या %3
→ %0
→
%1
→ %2
→ %4
→ return
हैं.
औपचारिक तौर पर, StableHLO प्रोसेस:
1) StableHLO प्रोग्राम, 2) ऑपरेशन स्टेटस (अभी तक एक्ज़ीक्यूट नहीं किया गया है,
पहले से लागू किया जा चुका है), और 3) इंटरमीडिएट वैल्यू का कॉम्बिनेशन होता है, जिन पर प्रोसेस काम कर रही है.
यह प्रोसेस, main
फ़ंक्शन के लिए इनपुट वैल्यू से शुरू होती है. कार्रवाई की स्थितियों और इंटरमीडिएट वैल्यू को अपडेट करने वाले ऑपरेशन के ग्राफ़ से, यह प्रोसेस आगे बढ़ती है. इसके बाद, यह आउटपुट वैल्यू के साथ खत्म होती है. अब अतिरिक्त औपचारिकता TBD है
(#484).
पैरलल एक्ज़ीक्यूशन
StableHLO प्रोग्राम को साथ-साथ, num_partitions
तक num_replicas
की 2D प्रोसेस ग्रिड में व्यवस्थित किया जा सकता है. दोनों का टाइप ui32
है.
StableHLO प्रोसेस ग्रिड में, StableHLO प्रोसेस में से num_replicas * num_partitions
एक साथ प्रोसेस हो रही हैं. हर प्रोसेस में एक यूनीक
process_id = (replica_id, partition_id)
होता है, जहां
replica_ids = range(num_replicas)
में
replica_id
और partition_ids = range(num_partitions)
में
partition_id
, दोनों का
टाइप ui32
है.
प्रोसेस ग्रिड का साइज़, हर प्रोग्राम के लिए स्टैटिक रूप से जाना जाता है. आने वाले समय में, हम इसे StableHLO प्रोग्राम #650 का हिस्सा बनाने की योजना बना रहे हैं. साथ ही, प्रोसेस ग्रिड में हर प्रोसेस के लिए जगह की जानकारी स्थिर रूप से मौजूद होती है. हर प्रोसेस को replica_id
और partition_id
ऑपरेशन के ज़रिए, प्रोसेस ग्रिड में अपनी पोज़िशन ऐक्सेस करने की अनुमति होती है.
प्रोसेस ग्रिड में, सभी प्रोग्राम एक जैसे हो सकते हैं ("सिंगल प्रोग्राम, कई डेटा" स्टाइल में), सभी अलग-अलग हो सकते हैं ("एक से ज़्यादा प्रोग्राम, एक से ज़्यादा डेटा" स्टाइल में) या इनके बीच में कुछ हो सकता है. आने वाले समय में, हम पैरलल StableHLO प्रोग्राम तय करने के अन्य मुहावरों के लिए सहायता शुरू करने की योजना बना रहे हैं, जिसमें GSPMD (#619) भी शामिल है.
प्रोसेस ग्रिड में, प्रोसेस एक-दूसरे से काफ़ी अलग होती हैं - उनकी कार्रवाई की अलग-अलग स्थितियां होती हैं, अलग-अलग इनपुट/इंटरमीडिएट/आउटपुट वैल्यू होती हैं और ज़्यादातर ऑपरेशन, प्रोसेस के बीच अलग-अलग किए जाते हैं. हालांकि, नीचे बताए गए कुछ सामूहिक ऑपरेशन अलग-अलग होते हैं.
यह देखते हुए कि ज़्यादातर ऑपरेशन को चलाने में एक ही प्रोसेस की वैल्यू का इस्तेमाल किया जाता है, आम तौर पर इन वैल्यू को उनके नामों से रेफ़र करना साफ़ तौर पर नहीं बताया जाता.
हालांकि, कलेक्टिव ऑपरेशन के सिमैंटिक की जानकारी देते समय, यह काफ़ी नहीं होता. साथ ही, इससे किसी खास प्रोसेस में वैल्यू name
के बारे में बताने के लिए नोटेशन name@process_id
का इस्तेमाल किया जाता है. (इस नज़रिए से, अमान्य name
को name@(replica_id(), partition_id())
के लिए शॉर्टहैंड के तौर पर देखा जा सकता है).
सभी प्रोसेस में एक्ज़ीक्यूशन का क्रम, लागू करने के तरीके से तय होता है. हालांकि, पॉइंट-टू-पॉइंट कम्यूनिकेशन और सामूहिक ऑपरेशन से की जाने वाली प्रोसेस को सिंक नहीं किया जाता, जैसा कि नीचे बताया गया है.
अलग-अलग लोगों के बीच बातचीत की सुविधा
StableHLO प्रोसेस, StableHLO चैनल की मदद से
एक-दूसरे से बातचीत कर सकती हैं. चैनल को si64
टाइप के पॉज़िटिव आईडी से दिखाया जाता है. अलग-अलग ऑपरेशन की मदद से, चैनलों को वैल्यू भेजी जा सकती हैं और
उन्हें चैनलों से लिया जा सकता है.
आगे से तरीका बताना है कि ये चैनल आईडी कहां से आ रहे हैं, प्रोसेस प्रोग्राम को कैसे उनके बारे में जानकारी मिलती है और उनके लिए किस तरह का सिंक्रनाइज़ेशन शुरू किया जाता है. यह अभी तय नहीं है (#484).
स्ट्रीमिंग कम्यूनिकेशन
हर StableHLO प्रोसेस में दो स्ट्रीमिंग इंटरफ़ेस का ऐक्सेस होता है:
- फ़ीड में, जिससे पढ़ा जा सकता है.
- आउटफ़ीड, जिसमें लिखा जा सकता है.
प्रोसेस के बीच संपर्क करने के लिए इस्तेमाल होने वाले चैनलों के उलट, इनफ़ीड और आउटफ़ीड के दोनों सिरों पर प्रोसेस होती हैं. हालांकि, इनफ़ीड और आउटफ़ीड के लिए, प्रोसेस को लागू करने की प्रोसेस तय होती है.
अतिरिक्त औपचारिकता, जैसे कि स्ट्रीमिंग कम्यूनिकेशन, प्रोग्राम को लागू करने के क्रम पर किस तरह असर डालता है और इसके ज़रिए किस तरह का सिंक किया गया है, इसे टीबीडी (#484) कहा जाता है.
कलेक्टिव ऑपरेशन
StableHLO में छह सामूहिक ऑपरेशन हैं: all_gather
, all_reduce
,
all_to_all
, collective_broadcast
, collective_permute
, और
reduce_scatter
. ये सभी ऑपरेशन, StableHLO प्रोसेस ग्रिड में मौजूद प्रोसेस को StableHLO प्रोसेस ग्रुप में बांट देते हैं और हर प्रोसेस ग्रुप के अंदर जॉइंट कंप्यूटेशन करते हैं. ये प्रोसेस दूसरे प्रोसेस ग्रुप से अलग होते हैं.
हर प्रोसेस ग्रुप में, सामूहिक ऑपरेशन सिंक करने की प्रक्रिया में रुकावट डाल सकते हैं. अतिरिक्त औपचारिकता, जैसे यह बताना कि आखिर यह सिंक्रोनाइज़ेशन कब होता है, प्रोसेस किस तरह इस रुकावट तक पहुंचती हैं और नहीं करने पर क्या होता है, TBD है (#484).
अगर प्रोसेस ग्रुप में क्रॉस-पार्टिशन कम्यूनिकेशन शामिल है, यानी कि प्रोसेस ग्रुप में ऐसी प्रोसेस हैं जिनके पार्टीशन आईडी अलग-अलग हैं, तो कलेक्टिव ऑप के लिए एक चैनल की ज़रूरत होगी. साथ ही, कलेक्टिव ऑपरेटर को si64
टाइप का एक पॉज़िटिव channel_id
देना होगा. क्रॉस-रेप्लिका कम्यूनिकेशन के लिए चैनलों की ज़रूरत नहीं होती.
सामूहिक ऑपरेशन के ज़रिए किए गए कंप्यूटेशन, अलग-अलग ऑपरेशन के लिए खास होते हैं. साथ ही, इसके बारे में ऊपर दिए गए अलग-अलग ऑपरेशन सेक्शन में बताया गया है. हालांकि, प्रोसेस ग्रिड को प्रोसेस ग्रुप में बांटने की रणनीतियां, इन ऑपरेशन के बीच शेयर की जाती हैं और इस सेक्शन में इनके बारे में बताया गया है. औपचारिक रूप से, StableHLO नीचे दी गई चार रणनीतियों का इस्तेमाल करता है.
cross_replica
प्रोसेस के हर ग्रुप में, सिर्फ़ क्रॉस-रेप्लिका कम्यूनिकेशन होते हैं. यह रणनीति, replica_groups
- प्रतिरूप आईडी की सूचियों की सूची - का इस्तेमाल करती है और partition_ids
तक replica_groups
के कार्टीज़न प्रॉडक्ट की गणना करती है. replica_groups
में यूनीक एलिमेंट होने चाहिए और ये सभी replica_ids
को कवर करना चाहिए. औपचारिक तौर पर, Python सिंटैक्स का इस्तेमाल
करके:
def cross_replica(replica_groups: List[List[ReplicaId]]) -> List[List[ProcessId]]:
for replica_group in replica_groups:
for partition_id in partition_ids:
process_group = []
for replica_id in replica_group:
process_group.append((replica_id, partition_id))
yield process_group
उदाहरण के लिए, replica_groups = [[0, 1], [2, 3]]
और num_partitions = 2
के लिए
cross_replica
,
[[(0, 0), (1, 0)], [(0, 1), (1, 1)], [(2, 0), (3, 0)], [(2, 1), (3, 1)]]
जनरेट करेगा.
cross_partition
प्रोसेस करने वाले हर ग्रुप में, सिर्फ़ क्रॉस-पार्टिशन कम्यूनिकेशन होते हैं. यह रणनीति partition_groups
का इस्तेमाल करती है - जो विभाजन आईडी की सूची की सूची होती है - और replica_ids
के ज़रिए partition_groups
के कार्टेशियन प्रॉडक्ट की गणना करती है.
partition_groups
में यूनीक एलिमेंट होने चाहिए और ये सभी partition_ids
को कवर करने चाहिए.
औपचारिक तौर पर, Python सिंटैक्स का इस्तेमाल करके:
def cross_partition(partition_groups: List[List[PartitionId]]) -> List[List[ProcessId]]:
for partition_group in partition_groups:
for replica_id in replica_ids:
process_group = []
for partition_id in partition_group:
process_group.append((replica_id, partition_id))
yield process_group
उदाहरण के लिए, partition_groups = [[0, 1]]
और num_replicas = 4
के लिए
cross_partition
,
[[(0, 0), (0, 1)], [(1, 0), (1, 1)], [(2, 0), (2, 1)], [(3, 0), (3, 1)]]
जनरेट करेगा.
cross_replica_and_partition
क्रॉस-रेप्लिका और क्रॉस-पार्टिशन कम्यूनिकेशन, दोनों प्रोसेस हर ग्रुप में हो सकते हैं. यह रणनीति replica_groups
- रेप्लिका आईडी की सूची - और हर replica_group
के कार्टेशियन प्रॉडक्ट की गणना partition_ids
तक करती है. replica_groups
में यूनीक एलिमेंट होने चाहिए और ये सभी
replica_ids
को कवर करने चाहिए. औपचारिक तौर पर, Python सिंटैक्स का इस्तेमाल करके:
def cross_replica_and_partition(replica_groups: List[List[ReplicaId]]) -> List[List[ProcessId]]:
for replica_group in replica_groups:
process_group = []
for partition_id in partition_ids:
for replica_id in replica_group:
process_group.append((replica_id, partition_id))
yield process_group
उदाहरण के लिए, replica_groups = [[0, 1], [2, 3]]
और num_partitions = 2
के लिए
cross_replica_and_partition
,
[[(0, 0), (1, 0), (0, 1), (1, 1)], [(2, 0), (3, 0), (2, 1), (3, 1)]]
जनरेट करेगा.
flattened_ids
यह रणनीति flattened_id_groups
- replica_id * num_partitions + partition_id
के रूप में "फ़्लैट की गई" प्रोसेस आईडी की सूचियों की सूची
लेती है और उन्हें
प्रोसेस आईडी में बदल देती है. flattened_id_groups
में यूनीक एलिमेंट होने चाहिए
और इनमें सभी process_ids
शामिल होने चाहिए. औपचारिक तौर पर, Python सिंटैक्स का इस्तेमाल करके:
def flattened_ids(flattened_id_groups: List[List[ui32]]) -> List[List[ProcessId]]:
for flattened_id_group in flattened_id_groups:
process_group = []
for flattened_id in flattened_id_group:
replica_id = flattened_id // num_partitions
partition_id = flattened_id % num_partitions
process_group.append((replica_id, partition_id))
yield process_group
उदाहरण के लिए, flattened_id_groups = [[0, 1, 2, 3], [4, 5, 6, 7]]
,
num_replicas = 4
, और num_partitions = 2
के लिए flattened_ids
,
[[(0, 0), (0, 1), (1, 0), (1, 1)], [(2, 0), (2, 1), (3, 0), (3, 1)]]
जनरेट करेगा.
सटीक जानकारी
फ़िलहाल, StableHLO संख्या के सटीक होने की गारंटी नहीं देता, लेकिन आने वाले समय में इसमें बदलाव हो सकता है (#1156).
गड़बड़ियां
StableHLO प्रोग्राम की पुष्टि, अलग-अलग ऑपरेशन के लिए कई तरह की पाबंदियों के ज़रिए की जाती है, जो रन टाइम से पहले कई तरह की गड़बड़ियों को कंट्रोल करते हैं. हालांकि, गड़बड़ी की स्थितियां अब भी हो सकती हैं, जैसे कि इंटीजर ओवरफ़्लो, आउट-ऑफ़-बाउंड ऐक्सेस वगैरह. जब तक साफ़ तौर पर समस्या को दूर न किया जाए, तब तक इन सभी गड़बड़ियों की वजह से, लागू करने से जुड़ी तय कार्रवाई होती है, लेकिन आने वाले समय में यह बदल सकती है (#1157).
इस नियम के अपवाद के तौर पर, StableHLO प्रोग्राम में फ़्लोटिंग-पॉइंट अपवाद
का व्यवहार अच्छी तरह से तय किया गया है. जिन ऑपरेशन के लिए आईईईई-754 स्टैंडर्ड (अमान्य ऑपरेशन, डिवीज़न-बाय-ज़ीरो, ओवरफ़्लो, अंडरफ़्लो या पूरी तरह से लागू न होने वाले अपवाद) के तहत अपवाद तय किए जाते हैं वे डिफ़ॉल्ट नतीजे देते हैं (जैसा कि स्टैंडर्ड में बताया गया है) और इनसे जुड़े स्टेटस फ़्लैग को ऊपर किए बिना, एक्ज़ीक्यूट करना जारी रखा जाता है. यह स्टैंडर्ड के raiseNoFlag
अपवाद को हैंडल करने की तरह ही होता है. गैर-मानक संक्रियाओं (जैसे कि जटिल अंकगणित और कुछ ट्रांसेंडेंटल फ़ंक्शन) के अपवादों के बारे में बताया गया है.
नोटेशन
सिंटैक्स की जानकारी देने के लिए, इस दस्तावेज़ में EBNF सिंटैक्स (ISO/IEC 14977:1996,
Wikipedia) के बदले हुए ISO फ़्लेवर का इस्तेमाल किया गया है,
जिसमें दो बदलाव किए गए हैं: 1) नियमों को =
के बजाय ::=
का इस्तेमाल करके तय किया गया है,
2) स्ट्रिंग जोड़ने की प्रोसेस को ,
के बजाय, जूसटैपोज़िशन का इस्तेमाल करके दिखाया जाता है.
सिमेंटिक्स (जैसे कि "टाइप", "कॉन्स्टेंट", और "ऑप" सेक्शन में) की जानकारी देने के लिए, हम Python सिंटैक्स पर आधारित फ़ॉर्मूले इस्तेमाल कर रहे हैं. साथ ही, अरे ऑपरेशन को संक्षेप में बताने के लिए, जैसा कि नीचे बताया गया है. यह कोड के छोटे स्निपेट के साथ अच्छा काम करता है. हालांकि, ऐसे मामलों में जब कोड के बड़े स्निपेट की ज़रूरत होती है, तो हम vanilla Python सिंटैक्स का इस्तेमाल करते हैं. इसे हमेशा साफ़ तौर पर उपलब्ध कराया जाता है.
फ़ॉर्मूला
जानें कि dot_general
स्पेसिफ़िकेशन में दिए गए उदाहरण से, फ़ॉर्मूला कैसे काम करते हैं. इस कार्रवाई की एक शर्त इस तरह से है:
dim(lhs, lhs_batching_dimensions...) = dim(rhs, rhs_batching_dimensions...)
.
इस फ़ॉर्मूला में इस्तेमाल किए गए नाम दो सोर्स से लिए जाते हैं: 1) ग्लोबल फ़ंक्शन,
यानी dim
, 2) इससे जुड़े प्रोग्राम एलिमेंट की मेंबर डेफ़िनिशन यानी कि
lhs
, lhs_batching_dimensions
, rhs
, और rhs_batching_dimensions
इनपुट.
जो dot_general
के "इनपुट" सेक्शन में बताए गए हैं.
जैसा कि ऊपर बताया गया है, इस फ़ॉर्मूला का सिंटैक्स Python पर आधारित है. इसमें कम शब्दों में लिखे गए कुछ एक्सटेंशन इस्तेमाल किए गए हैं. फ़ॉर्मूला को समझने के लिए, आइए इसे वैनिला Python सिंटैक्स में बदलते हैं.
A) इन फ़ॉर्मूलों में, हम बराबरी दिखाने के लिए =
का इस्तेमाल कर रहे हैं. इसलिए, Python सिंटैक्स पाने के लिए सबसे पहले, =
को ==
से बदला जाएगा. इसका तरीका नीचे बताया गया है:
dim(lhs, lhs_batching_dimensions...) == dim(rhs, rhs_batching_dimensions...)
.
B) साथ ही, ये फ़ॉर्मूले एलिप्सिस (...
) के साथ भी काम करते हैं, जो स्केलर एक्सप्रेशन को टेंसर एक्सप्रेशन में बदल देते हैं. संक्षेप में, f(xs...)
का शाब्दिक अर्थ है कि "टेंसर xs
में हर अदिश x
के लिए, एक अदिश f(x)
की गणना करें और फिर इन सभी अदिश नतीजों को एक टेंसर परिणाम के रूप में एक साथ लौटाता है". वनीला Python सिंटैक्स में,
हमारा उदाहरण फ़ॉर्मूला यह है:
[dim(lhs, dim1) for dim1 in lhs_batching_dimensions] ==
[dim(rhs, dim2) for dim2 in rhs_batching_dimensions]
.
एलिप्सिस की वजह से, अक्सर अलग-अलग स्केलर के लेवल पर काम करने से बचा जा सकता है. हालांकि, कुछ मामलों में, कम लेवल वाले सेमी-इन्फ़ॉर्मल सिंटैक्स का इस्तेमाल, gather
स्पेसिफ़िकेशन के start_indices[bi0, ..., :, ..., biN]
फ़ॉर्मूला की तरह ही किया जा सकता है. कम शब्दों में सटीक जानकारी देने के लिए, हम उम्मीद करते हैं कि इस तरह के सिंटैक्स का अनुवाद वनीला Python में करने के लिए कोई औपचारिकता नहीं दी जाएगी. हालांकि, यह उम्मीद की जाती है कि अलग-अलग मामलों के हिसाब से इसे अब भी आसानी से समझा जा सकेगा.
अगर कुछ खास फ़ॉर्मूला धुंधले दिखते हैं, तो कृपया हमें बताएं. हम उन्हें बेहतर बनाने की कोशिश करेंगे.
साथ ही, आपने ध्यान दिया कि फ़ॉर्मूला सभी तरह की सूचियों को बड़ा करने के लिए एलिप्सिस का इस्तेमाल करते हैं. इनमें टेंसर, टेंसर की सूचियां (जैसे, अलग-अलग टेंसर की सूची वगैरह) शामिल हो सकते हैं. यह ऐसा क्षेत्र है जहां हम सटीक औपचारिकता नहीं देते (उदाहरण के लिए, सूचियां, StableHLO 'स्टेबिलिटी टाइप सिस्टम' का हिस्सा भी नहीं होती हैं), और समझने लायक होती हैं.
C) हम जो आख़िरी अहम नोटेशन इस्तेमाल करते हैं वह इंप्लिसिट ब्रॉडकास्टिंग है. हालांकि, StableHLO ऑप्टसेट को बिना किसी वाक्य के ब्रॉडकास्ट करने की सुविधा नहीं मिलती, लेकिन फ़ॉर्मूले को कम शब्दों में लिखने की सुविधा मिलती है. कम शब्दों में कहें, तो अगर स्केलर का इस्तेमाल उस संदर्भ में किया जाता है जहां टेंसर की उम्मीद की जाती है, तो स्केलर को सही आकार में ब्रॉडकास्ट किया जाता है.
dot_general
उदाहरण को जारी रखने के लिए, यहां एक और कंस्ट्रेंट दिया गया है:
0 <= lhs_batching_dimensions < rank(lhs)
. dot_general
के ब्यौरे के मुताबिक, lhs_batching_dimensions
एक टेंसर है. हालांकि, 0
और rank(lhs)
दोनों स्केलर हैं. इंप्लिसिट ब्रॉडकास्टिंग लागू करने के बाद, फ़ॉर्मूला [0, ..., 0] <= lhs_batching_dimensions < [rank(lhs), ..., rank(lhs)]
हो जाएगा.
जब किसी खास dot_general
ऑपरेशन पर लागू किया जाता है, तो यह फ़ॉर्मूला बूलियन के टेंसर का आकलन करेगा. जब फ़ॉर्मूले का इस्तेमाल कंस्ट्रेंट के तौर पर किया जाता है, तो
कंस्ट्रेंट होल्ड तब होता है, जब फ़ॉर्मूला, true
या ऐसे टेंसर का आकलन करता है जिसमें सिर्फ़ true
एलिमेंट होते हैं.
नाम
फ़ॉर्मूला में, लेक्सिकल स्कोप में ये चीज़ें शामिल होती हैं: 1) ग्लोबल फ़ंक्शन, 2) सदस्य की परिभाषाएं,
3) स्थानीय परिभाषाएं. ग्लोबल फ़ंक्शन की सूची यहां दी गई है. एलिमेंट परिभाषाओं की सूची उस प्रोग्राम एलिमेंट पर निर्भर करती है जिस पर नोटेशन लागू होता है:
- सदस्य की परिभाषाओं में, "इनपुट" और "आउटपुट" सेक्शन में पेश किए गए नाम शामिल होते हैं.
- बाकी सभी चीज़ों के लिए, सदस्य परिभाषाओं में प्रोग्राम एलिमेंट के स्ट्रक्चर वाले हिस्से शामिल होते हैं, जिनका नाम उनसे जुड़े ईबीएनएफ़ नॉन-टर्मिनल के नाम पर रखा जाता है. ज़्यादातर, इन स्ट्रक्चर वाले हिस्सों के नाम, नॉन-टर्मिनल के नामों को स्नेक केस में बदलकर (जैसे कि
IntegerLiteral
=>integer_literal
) हासिल किए जाते हैं. हालांकि, कभी-कभी इस प्रोसेस में नाम छोटे कर दिए जाते हैं (जैसे किQuantizationStorageType
=>storage_type
). ऐसे मामलों में, नामों को - इसके अलावा, सदस्य की परिभाषाओं में, संबंधित प्रोग्राम एलिमेंट को रेफ़र करने के लिए,
self
को हमेशा शामिल किया जाता है.
वैल्यू
फ़ॉर्मूलों का आकलन होने पर, वे इस तरह की वैल्यू के साथ काम करते हैं:
1) Value
(असल वैल्यू, जैसे कि dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
; उन्हें हमेशा पता होता है कि उनका टाइप किस तरह का है),
2) Placeholder
(आने वाले समय की वैल्यू, जैसे कि lhs
, rhs
या result
; उनके असल वैल्यू का अभी तक पता नहीं है, सिर्फ़ उनके टाइप के बारे में पता है),
3) Type
("टाइप" सेक्शन में बताए गए टाइप),
4) "फ़ंक्शन" सेक्शन में Function
फ़ंक्शन.
संदर्भ के आधार पर, हो सकता है कि नाम अलग-अलग वैल्यू का हवाला दे रहे हों. खास तौर पर, ऑपरेशन के लिए "सेमैंटिक" सेक्शन (और दूसरे प्रोग्राम एलिमेंट के लिए मिलते-जुलते) रनटाइम लॉजिक के बारे में बताता है, इसलिए सभी इनपुट Value
के तौर पर उपलब्ध होते हैं.
वहीं दूसरी ओर, ऑपरेशन (और उसके बराबर) के लिए "कंस्ट्रेंट" सेक्शन, "कंपाइल-टाइम" लॉजिक के बारे में बताता है.इसका मतलब है कि आम तौर पर, रनटाइम से पहले एक कन्वर्ज़न लागू होता है. इसलिए, Value
के तौर पर सिर्फ़ कॉन्सटैंट इनपुट उपलब्ध होते हैं और अन्य इनपुट सिर्फ़ Placeholder
के तौर पर उपलब्ध होते हैं.
नाम | "सेमैंटिक" में | "सीमाएं" में |
---|---|---|
ग्लोबल फ़ंक्शन | Function |
Function |
कॉन्सटैंट इनपुट | Value |
Value |
नॉन-कॉन्सटेंट इनपुट | Value |
Placeholder |
आउटपुट | Value |
Placeholder |
स्थानीय परिभाषाएं | परिभाषा पर निर्भर करता है | परिभाषा पर निर्भर करता है |
आइए, एक transpose
कार्रवाई के उदाहरण पर विचार करें:
%result = "stablehlo.transpose"(%operand) {
permutation = dense<[2, 1, 0]> : tensor<3xi64>
} : (tensor<2x3x2xi32>) -> tensor<2x3x2xi32>
इस ऑपरेशन के लिए, permutation
एक कॉन्सटेंट है. इसलिए, यह सिमैंटिक और कंस्ट्रेंट, दोनों में Value
के तौर पर उपलब्ध है. वहीं, सिमैंटिक में operand
और result
, Value
के तौर पर उपलब्ध हैं, लेकिन कंस्ट्रेंट के मामले में सिर्फ़ Placeholder
के तौर पर उपलब्ध हैं.
फ़ंक्शन
टाइप का निर्माण
ऐसा कोई फ़ंक्शन नहीं है जिसका इस्तेमाल टाइप बनाने के लिए किया जा सके. इसके बजाय, हम सीधे टाइप सिंटैक्स का इस्तेमाल करते हैं, क्योंकि यह आम तौर पर छोटा होता है. उदाहरण के लिए, function_type(
[tensor_type([], E), tensor_type([], E)], [tensor_type([], E)])
के बजाय (tensor<E>, tensor<E>) -> (tensor<E>)
.
टाइप पर फ़ंक्शन
element_type
की जानकारी, टेंसर टाइप और कैलकुलेटर वाले टेंसर के हिसाब से तय की जाती है. यह वैल्यू, इससे जुड़ेTensorType
याQuantizedTensorType
केTensorElementType
याQuantizedTensorElementType
हिस्से के आधार पर तय की जाती है.
def element_type(x: Value | Placeholder | Type):
if type(x) == TensorType:
return tensor_element_type(x)
if type(x) == QuantizedTensorType:
return quantized_tensor_element_type(x)
if type(x) is not Type:
return element_type(type(x))
is_per_axis_quantized(x: Value | Placeholder | Type) -> Value
,is_quantized(x) and quantization_dimension(x) is not None
का शॉर्टकट है.is_per_tensor_quantized(x: Value | Placeholder | Type) -> Value
,is_quantized(x) and quantization_dimension(x) is None
का शॉर्टकट है.is_promotable(x: Type, y: Type) -> bool
यह जांचता है कि टाइपx
कोy
टाइप करने के लिए प्रमोट किया जा सकता है या नहीं. जबx
औरy
QuantizedTensorElementType
हो, तो प्रमोशन सिर्फ़storage_type
पर लागू होता है. फ़िलहाल, प्रमोशन के इस खास वर्शन का इस्तेमाल सीमित करने की गणना के संदर्भ में किया जाता है (ज़्यादा जानकारी के लिए आरएफ़सी देखें).
def is_promotable(x: Type, y: Type) -> Value:
is_same_type = (is_bool(x) and is_bool(y)) or
(is_integer(x) and is_integer(y)) or (is_float(x) and is_float(y)) or
(is_complex(x) and is_complex(y)) or
(is_quantized(x) and is_quantized(y) and expressed_type(x) = expressed_type(y))
if is_same_type == False:
return False
if is_integer(x) or is_float(x):
return bitwidth(x) <= bitwidth(y)
if is_complex(x):
return bitwidth(element_type(x)) <= bitwidth(element_type(y))
if is_quantized(x):
return bitwidth(storage_type(x)) <= bitwidth(storage_type(y))
return false
is_quantized(x: Value | Placeholder | Type) -> Value
,is_quantized_tensor_element_type(x)
का शॉर्टकट है.is_type_name(x: Value | Placeholder | Type) -> Value
. यह सुविधा सभी तरह के लोगों के लिए उपलब्ध है. जैसे, अगरx
FloatType
है, तोis_float(x)
true
दिखाता है. अगरx
कोई वैल्यू या प्लेसहोल्डर है, तो यह फ़ंक्शनis_type_name(type(x))
के लिए शॉर्टकट है.max_value(x: Type) -> Value
,TensorElementType
की ज़्यादा से ज़्यादा वैल्यू दिखाता है. अगरx
,TensorElementType
नहीं है, तोNone
दिखाता है.min_value(x: Type) -> Value
,TensorElementType
की कम से कम संभावित वैल्यू दिखाता है. अगरx
,TensorElementType
नहीं है, तोNone
दिखाता है.member_name(x: Value | Placeholder | Type) -> Any
. यह सुविधा सभी तरह की सदस्यता की सभी परिभाषाएंmember_name
के लिए उपलब्ध हैं. उदाहरण के लिए,tensor_element_type(x)
इससे जुड़ेTensorType
काTensorElementType
वाला हिस्सा दिखाता है. अगरx
कोई वैल्यू या प्लेसहोल्डर है, तो यह फ़ंक्शनmember_name(type(x))
के लिए शॉर्टकट है. अगरx
ऐसा टाइप नहीं है जिसमें सही सदस्य या ऐसी वैल्यू या प्लेसहोल्डर मौजूद हो, तोNone
दिखाता है.
वैल्यू तैयार करना
operation_name(*xs: Value | Type) -> Value
. सभी कार्रवाइयों के लिए उपलब्ध है. उदाहरण के लिए,add(lhs, rhs)
दो टेंसर वैल्यूlhs
औरrhs
लेता है और इन इनपुट की मदद से,add
ऑपरेशन का आकलन करने का आउटपुट दिखाता है.broadcast_in_dim
जैसे कुछ ऑपरेशन के लिए, उनके आउटपुट "लोड-असर" होते हैं. इसका मतलब है कि किसी कार्रवाई का आकलन करने के लिए, इसकी ज़रूरत होती है. इस मामले में, फ़ंक्शन इन टाइप को आर्ग्युमेंट के तौर पर लेता है.
वैल्यू पर फ़ंक्शन
Python के सभी ऑपरेटर और फ़ंक्शन उपलब्ध हैं. उदाहरण के लिए, Python में मौजूद सदस्यता और स्लाइसिंग, दोनों नोटेशन को टेंसर, क्वांटाइज़्ड टेंसर, और ट्यूपल में इंडेक्स करने के लिए उपलब्ध है.
to_destination_type(x: Value, destination_type: Type) -> Value
को टेंसर पर सेट किया जाता है औरtype(x)
औरdestination_type
के आधार पर,x
की बदली गई वैल्यू इस तरह मिलती है:
def to_destination_type(x: Value, destination_type: Type) -> Value:
if type(x) == destination_type:
return x
if is_quantized(destination_type):
if is_quantized(type(x)):
return quantize(x, destination_type)
assert is_float(type(x))
return quantize(x, destination_type)
if is_quantized(type(x)):
assert destination_type = expressed_type(type(x))
return dequantize(type(x))
return convert(x, destination_type)
convert
, uniform_quantize
, और
uniform_dequantize
कार्रवाइयों (#1576) को मर्ज करने पर, शुरुआती चर्चा चल रही है.
मर्ज करने के बाद, हमें ऊपर दिए गए फ़ंक्शन की ज़रूरत नहीं होती और हम उसके बजाय convert
के लिए, कार्रवाई के नाम का इस्तेमाल कर सकते हैं.
is_nan(x: Value) -> Value
को टेंसर पर सेट किया जाता है और अगरx
के सभी एलिमेंटNaN
याfalse
होते हैं, तोtrue
दिखाता है. अगरx
टेंसर नहीं है, तोNone
दिखाता है.अगर
x
के एलिमेंट को उनके इंडेक्स के बढ़ते क्रम में याfalse
के हिसाब से बढ़ते क्रम में लगाया जाए, तोis_sorted(x: Value) -> Value
का मतलब टेंसर पर होता है और यहtrue
दिखाता है. अगरx
, टेंसर नहीं है, तोNone
दिखाता है.is_unique(x: Value) -> Value
को टेंसर पर सेट किया जाता है. साथ ही, अगरx
में डुप्लीकेट एलिमेंट नहीं होता याfalse
मौजूद नहीं होता, तो यहtrue
दिखाता है. अगरx
टेंसर नहीं है, तोNone
दिखाता है.member_name(x: Value) -> Any
सभी वैल्यू में से,member_name
मेंबर की सभी परिभाषाओं के लिए तय किया जाता है. उदाहरण के लिए,real_part(x)
, इससे जुड़ेComplexConstant
काRealPart
हिस्सा दिखाता है. अगरx
ऐसी वैल्यू नहीं है जिसका सदस्य सही है, तोNone
दिखाता है.same(x: Value) -> Value
को टेंसर पर सेट किया जाता है. अगरx
के सभी एलिमेंट एक-दूसरे के बराबर हैं याfalse
है, तो नतीजे के तौर परtrue
दिखता है. अगर टेंसर में कोई एलिमेंट नहीं है, तो उसे "सभी एक-दूसरे के बराबर" के तौर पर गिना जाता है. इसका मतलब है कि फ़ंक्शनtrue
दिखाता है. अगरx
कोई टेंसर नहीं है, तोNone
दिखाता है.split(x: Value, num_results: Value, axis: Value) -> Value
को टेंसर पर सेट किया जाता है और यह ऐक्सिसaxis
के साथx
केnum_results
स्लाइस दिखाता है. अगरx
, टेंसर याdim(x, axis) % num_results != 0
नहीं है, तोNone
दिखाता है.
आकार की गणना
axes(x: Value | Placeholder | Type) -> Value
,range(rank(x))
का शॉर्टकट है.dim(x: Value | Placeholder | Type, axis: Value) -> Value
,shape(x)[axis]
का शॉर्टकट है.dims(x: Value | Placeholder | Type, axes: List) -> List
,list(map(lambda axis: dim(x, axis), axes))
का शॉर्टकट है.index_space(x: Value | Placeholder | Type) -> Value
के बारे में टेंसर पर बताया गया है और यह बढ़ते हुए क्रम में लगाए गएTensorType
के लिएsize(x)
इंडेक्स दिखाता है. जैसे,[0, ..., 0]
,[0, ..., 1]
, ...,shape(x) - 1
. अगरx
, टेंसर टाइप नहीं है, तो कैलकुलेटेड टेंसर टाइप या इनमें से किसी एक टाइप की वैल्यू या प्लेसहोल्डरNone
है.rank(x: Value | Placeholder | Type) -> Value
,size(shape(x))
का शॉर्टकट है.shape(x: Value | Placeholder | Type) -> Value
के बारे मेंmember_name
के ज़रिए "फ़ंक्शन टाइप" सेक्शन में बताया गया है.size(x: Value | Placeholder | Type) -> Value
,reduce(lambda x, y: x * y, shape(x))
का शॉर्टकट है.
क्वांटाइज़ेशन से जुड़ी गणनाएं
def baseline_element_type(x: Value | Placeholder | Type) -> Type
,element_type(baseline_type(x))
का शॉर्टकट है.baseline_type
के बारे में, टेंसर टाइप और संख्या वाले टेंसर टाइप के आधार पर इस्तेमाल किया जाता है.साथ ही, यह उन्हें "बेसलाइन" में बदल देता है. इसका मतलब है कि एक समान आकार वाला टाइप है, लेकिन एलिमेंट टाइप के क्वांटाइज़ेशन पैरामीटर, डिफ़ॉल्ट वैल्यू पर रीसेट हो जाते हैं. इसका इस्तेमाल टेंसर और क्वांटाइज़ किए गए टेंसर, दोनों टाइप की एक समान तरीके से तुलना करने के लिए आसान ट्रिक के तौर पर किया जाता है. इसकी अक्सर ज़रूरत पड़ती है. संख्या वाले टाइप के लिए, यह क्वांटाइज़ेशन पैरामीटर को अनदेखा किए बिना, टाइप की तुलना करने की सुविधा चालू करता है. जैसे,shape
,storage_type
,expressed_type
,storage_min
,storage_max
, औरquantization_dimension
(हर ऐक्सिस के लिए संख्या के हिसाब से आकलन किए गए टाइप के लिए) सभी मैच होने चाहिए. हालांकि,scales
औरzero points
में अंतर हो सकता है.
def baseline_type(x: Value | Placeholder | Type) -> Type:
if type(x) == TensorType:
return x
if type(x) == QuantizedTensorType:
element_type = quantized_tensor_element_type(x)
baseline_element_type = QuantizedTensorElementType(
storage_type = storage_type(element_type),
storage_min = storage_min(element_type),
storage_max = storage_max(element_type),
expressed_type = expressed_type(element_type),
quantization_dimension = quantization_dimension(element_type),
scales = [constant(1.0, expressed_type(element_type))] * dim(x, quantization_dimension(element_type)),
zero_points = [constant(0, storage_type(element_type))] * dim(x, quantization_dimension(element_type)))
return QuantizedTensorType(shape(x), baseline_element_type)
if type(x) is not Type:
return baseline_element_type(type(x))
dequantize
को क्वांटाइज़्ड टेंसर टाइप के हिसाब से तय किया जाता है. यह उन्हें फ़्लोटिंग-पॉइंट टेंसर में बदल देता है. इसके लिए संख्या वाले एलिमेंट को बदला जाता है. ये एलिमेंट, स्टोरेज टाइप की इंटीजर वैल्यू को, बताए गए टाइप की फ़्लोटिंग-पॉइंट वैल्यू में बदलते हैं. इसके लिए, क्वांटाइज़ किए गए एलिमेंट से जुड़े ज़ीरो पॉइंट और स्केल का इस्तेमाल किया जाता है.
def compute_zero_points(quantized_type, result_type):
if is_per_tensor_quantized(quantized_type):
return broadcast_in_dim(constant(zero_point(quantized_type), storage_type(quantized_type)), [], result_type)
if is_per_axis_quantized(quantized_type):
for i in index_space(result_type):
d = quantization_dimension(quantized_type)
zero_points[i] = zero_points(quantized_type)[i[d]]
return zero_points
def compute_scales(quantized_type, result_type):
if is_per_tensor_quantized(quantized_type):
return broadcast_in_dim(constant(scale(quantized_type), expressed_type(quantized_type)), [],
type(result_type))
if is_per_axis_quantized(quantized_type):
for i in index_space(result_type):
d = quantization_dimension(quantized_type)
scales[i] = scales(quantized_type)[i[d]]
return scales
def dequantize(x: Value) -> Value:
assert is_quantized(x)
x_storage = bitcast_convert(x, storage_type(x))
x_storage_sub = x_storage - compute_zero_points(type(x), type(x_storage))
x_expressed_sub = convert(x_storage_sub, expressed_type(x))
return x_expressed_sub * compute_scales(type(x), type(x_expressed_sub))
quantize
को फ़्लोटिंग-पॉइंट टेंसर टाइप पर तय किया जाता है और यह उन्हें क्वांटाइज़ किए गए टेंसर टाइप में बदल देता है. ऐसा करने के लिए, बताए गए टाइप के फ़्लोटिंग-पॉइंट वैल्यू को स्टोरेज टाइप से जुड़ी पूर्णांक वैल्यू में बदला जाता है. इसके लिए, क्वांटाइज़ किए गए एलिमेंट से जुड़े ज़ीरो पॉइंट और स्केल का इस्तेमाल किया जाता है.
def quantize(x: Value, type: Type) -> Value:
assert is_float(x) and is_quantized(type)
x_expressed_rounded = round_nearest_even(x / compute_scales(type, type(x)))
x_storage_rounded = convert(x_expressed_rounded, storage_type(type))
x_storage_add = x_storage_rounded + compute_zero_points(type, type(x_storage_rounded))
x_storage = clamp(storage_min(type), x_storage_add, storage_max(type))
return bitcast_convert(x_storage, type)
dequantize_op_quantize
का इस्तेमाल, क्वांटाइज़ किए गए टेंसर पर एलिमेंट के हिसाब से कैलकुलेशन करने के लिए किया जाता है. यह आकलन किए गए एलिमेंट को मापता है. इसका मतलब यह है कि संख्या वाले एलिमेंट को उनके बताए गए टाइप में बदल दिया जाता है, फिर कोई कार्रवाई की जाती है. इसके बाद, संख्या को कैलकुलेट किया जाता है. इसका मतलब है कि नतीजों को वापस उनके स्टोरेज टाइप में बदल दिया जाता है. फ़िलहाल, यह फ़ंक्शन सिर्फ़ पर-टेंसर क्वांटाइज़ेशन के लिए काम करता है. हर ऐक्सिस पर संख्या बढ़ाने का काम जारी है (#1574).
def dequantize_op_quantize(op, *inputs_and_output_type):
inputs = inputs_and_output_type[:-1]
output_type = inputs_and_output_type[-1]
float_inputs = map(dequantize, inputs)
float_result = op(*float_inputs)
return quantize(float_result, output_type)
def dequantize_batch_norm_grad_or_training_quantize(op, *inputs_and_output_types):
inputs = inputs_and_output_type[:-3]
float_inputs = map(dequantize, inputs)
float_results = op(*float_inputs)
return map(quantize, float_results, inputs_and_output_type[-3:])
def dequantize_compare(lhs, rhs, comparison_direction):
float_lhs = dequantize(lhs)
float_rhs = dequantize(rhs)
return compare(float_lhs, float_rhs, comparison_direction, FLOAT)
def dequantize_select_quantize(pred, on_true, on_false, output_type):
float_on_true = dequantize(on_true)
float_on_false = dequantize(on_false)
float_result = select(pred, float_on_true, float_on_false)
return quantize(float_result, output_type)
ग्रिड कंप्यूटेशन
cross_partition(replica_groups: Value) -> Value
. ऊपर दिया गया "cross_replica" सेक्शन देखें.cross_replica(replica_groups: Value) -> Value
. ऊपर दिया गया "cross_replica" सेक्शन देखें.cross_replica_and_partition(replica_groups: Value) -> Value
. ऊपर दिया गया "cross_replica_and_partition" सेक्शन देखें.flattened_ids(replica_groups: Value) -> Value
. ऊपर दिया गया "फ़्लैटेन्ड_id" सेक्शन देखें.