ऑपरेशन सिमैंटिक

यहां XlaBuilder इंटरफ़ेस में तय की गई कार्रवाइयों के सिमेंटिक्स के बारे में बताया गया है. आम तौर पर, ये ऑपरेशन xla_data.proto में RPC इंटरफ़ेस में तय की गई कार्रवाइयों से वन-टू-वन मैप करते हैं.

नामकरण के बारे में जानकारी: XLA का सामान्य डेटा टाइप, N-डाइमेंशन वाला अरे होता है जिसमें कुछ एक जैसे एलिमेंट (जैसे कि 32-बिट फ़्लोट) रखते हैं. पूरे दस्तावेज़ में, array का इस्तेमाल आर्बिट्ररी-डाइमेंशन अरे को दिखाने के लिए किया गया है. सुविधा के लिए, खास मामलों में ज़्यादा सटीक और जाने-पहचाने नाम होने चाहिए. उदाहरण के लिए, वेक्टर एक 1-डाइमेंशन और मैट्रिक्स दो-डाइमेंशन वाला अरे होता है.

AfterAll

XlaBuilder::AfterAll भी देखें.

AfterAll अलग-अलग संख्या के टोकन लेता है और एक टोकन बनाता है. टोकन बहुत बुनियादी तरह के होते हैं. इन्हें क्रम से लगाने के लिए, खराब असर डालने वाली कार्रवाइयों के बीच थ्रेड किया जा सकता है. किसी तय ऑपरेशन के बाद, ऑर्डर देने के लिए AfterAll को टोकन के तौर पर इस्तेमाल किया जा सकता है.

AfterAll(operands)

तर्क	टाइप	सिमैंटिक
operands	XlaOp	टोकन की अलग-अलग संख्या

AllGather

XlaBuilder::AllGather भी देखें.

प्रतिरूपों में स्ट्रिंग जोड़ने की प्रक्रिया करता है.

AllGather(operand, all_gather_dim, shard_count, replica_group_ids, channel_id)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	जवाबों को एक साथ जोड़ने के लिए कलेक्शन
all_gather_dim	int64	स्ट्रिंग जोड़ने की प्रोसेस का डाइमेंशन
replica_groups	int64 के वेक्टर का वेक्टर	वे ग्रुप जिनके बीच स्ट्रिंग जोड़ने की प्रोसेस की जाती है.
channel_id	वैकल्पिक int64	क्रॉस-मॉड्यूल कम्यूनिकेशन के लिए वैकल्पिक चैनल आईडी

• replica_groups, उन रेप्लिका ग्रुप की सूची है जिनके बीच स्ट्रिंग जोड़ने की प्रोसेस की जाती है. मौजूदा रेप्लिका के लिए रेप्लिका आईडी को ReplicaId की मदद से फिर से पाया जा सकता है. हर ग्रुप में मौजूद कॉपी का क्रम, नतीजे में उनके इनपुट के क्रम को तय करता है. replica_groups या तो खाली होना चाहिए (इस मामले में, सभी रेप्लिका एक ही ग्रुप से जुड़े होने चाहिए, जो 0 से N - 1 तक के क्रम में होते हैं). इसके अलावा, इसमें उतनी ही संख्या में एलिमेंट होने चाहिए जितने रेप्लिका की संख्या में हैं. उदाहरण के लिए, replica_groups = {0, 2}, {1, 3}, 0 और 2 के साथ-साथ, 1 और 3 के बीच स्ट्रिंग जोड़ने की प्रोसेस करता है.
• shard_count हर कॉपी ग्रुप का साइज़ होता है. हमें इसकी ज़रूरत उन मामलों में होती है जहां replica_groups खाली है.
• channel_id का इस्तेमाल, क्रॉस-मॉड्यूल कम्यूनिकेशन के लिए किया जाता है: सिर्फ़ all-gather एक ही channel_id से होने वाले ऑपरेशन एक-दूसरे से कम्यूनिकेट कर सकते हैं.

आउटपुट आकार, इनपुट का आकार होता है. इसमें all_gather_dim को shard_count गुना बड़ा किया जाता है. उदाहरण के लिए, अगर दो रेप्लिका हैं और ऑपरेंड की दो कॉपी पर वैल्यू [1.0, 2.5] और [3.0, 5.25] है, तो इस ऑपर्च्यूनिटी की आउटपुट वैल्यू जहां all_gather_dim 0 है, दोनों रेप्लिका पर [1.0, 2.5, 3.0, 5.25] होगा.

AllReduce

XlaBuilder::AllReduce भी देखें.

सभी प्रतिरूपों में कस्टम कैलकुलेशन करता है.

AllReduce(operand, computation, replica_group_ids, channel_id)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	रेप्लिकाओं को छोटा करने के लिए, अरे या अरे का वह टपल जो खाली न हो
computation	XlaComputation	रिडक्शन कंप्यूटेशन
replica_groups	int64 के वेक्टर का वेक्टर	वे ग्रुप जिनके बीच कटौती की जाती है
channel_id	वैकल्पिक int64	क्रॉस-मॉड्यूल कम्यूनिकेशन के लिए वैकल्पिक चैनल आईडी

• जब operand, कलेक्शन का एक हिस्सा होता है, तो टपल के हर एलिमेंट पर पूरा रिड्यूस किया जाता है.
• replica_groups उन प्रतिरूप समूहों की सूची है जिनके बीच में कमी की जाती है (मौजूदा प्रतिरूप के लिए रेप्लिका आईडी को ReplicaId का इस्तेमाल करके फिर से पाया जा सकता है). replica_groups खाली होना चाहिए (जिस स्थिति में सभी रेप्लिका एक ही समूह से जुड़ी हों) या उसमें उतनी ही संख्या में एलिमेंट हों जितने प्रतिकृतियां हैं. उदाहरण के लिए, replica_groups = {0, 2}, {1, 3}, 0 और 2 के डुप्लीकेट वर्शन, 1, और 3 के बीच छोटे किए गए एलिमेंट को लागू करता है.
• channel_id का इस्तेमाल, क्रॉस-मॉड्यूल कम्यूनिकेशन के लिए किया जाता है: सिर्फ़ all-reduce एक ही channel_id से होने वाले ऑपरेशन एक-दूसरे से कम्यूनिकेट कर सकते हैं.

आउटपुट का आकार, इनपुट के आकार जैसा ही होता है. उदाहरण के लिए, अगर दो रेप्लिका हैं और ऑपरेंड की वैल्यू [1.0, 2.5] और [3.0, 5.25] है, तो दोनों रेप्लिका पर लागू होने वाले ऑपरेशन और समेशन कंप्यूटेशन की आउटपुट वैल्यू [4.0, 7.75] होगी. अगर इनपुट एक टपल है, तो आउटपुट भी टपल है.

AllReduce के नतीजे का हिसाब लगाने के लिए हर रेप्लिका से एक इनपुट होना ज़रूरी है. इसलिए, अगर एक रेप्लिका, AllReduce नोड को दूसरे की तुलना में ज़्यादा बार एक्ज़ीक्यूट करती है, तो पुरानी कॉपी को हमेशा इंतज़ार करना होगा. जैसा कि सभी रेप्लिका एक ही प्रोग्राम चला रहे हैं, इसलिए ऐसा होने के बहुत ज़्यादा तरीके नहीं हैं. हालांकि, ऐसा तब हो सकता है, जब लूप की स्थिति, इनफ़ीड के डेटा पर निर्भर होती है और जो डेटा लागू होता है उसकी वजह से लूप की एक कॉपी पर दूसरी बार की तुलना में ज़्यादा बार दोहराव हो.

AllToAll

XlaBuilder::AllToAll भी देखें.

AllToAll एक कलेक्टिव ऑपरेशन है, जो सभी कोर से सभी कोर को डेटा भेजता है. इसके दो चरण हैं:

1. स्कैटर फ़ेज़. हर कोर पर, ऑपरेंड को split_dimensions के साथ-साथ split_count ब्लॉक में बांटा जाता है और ब्लॉक सभी कोर में बिखर जाते हैं, जैसे कि ih ब्लॉक को इट कोर में भेजा जाता है.
2. इकट्ठा करने का चरण. हर कोर, मिले हुए ब्लॉक को concat_dimension के साथ जोड़ता है.

हिस्सा लेने वाले कोर को नीचे दिए गए तरीकों से कॉन्फ़िगर किया जा सकता है:

• replica_groups: हर ReplicaGroup में कंप्यूटेशन में शामिल प्रतिरूप आईडी की सूची होती है (मौजूदा प्रतिरूप की प्रतिरूप आईडी ReplicaId का इस्तेमाल करके फिर से हासिल की जा सकती है). AllToAll को सबग्रुप में तय किए गए क्रम में लागू किया जाएगा. उदाहरण के लिए, replica_groups = { {1,2,3}, {4,5,0} } का मतलब है कि AllToAll को {1, 2, 3} के साथ-साथ इकट्ठा करने के चरण में लागू किया जाएगा. साथ ही, मिले हुए ब्लॉक को 1, 2, 3 के क्रम में ही जोड़ा जाएगा. इसके बाद, अन्य AllToAll को 4, 5, 0 की कॉपी में लागू किया जाएगा और स्ट्रिंग जोड़ने के क्रम को 4, 5, 0 पर भी लागू किया जाएगा. अगर replica_groups खाली है, तो सभी रेप्लिका एक ही ग्रुप से जुड़ी होती हैं. यह उनके दिखने के क्रम में जोड़ी जाती हैं.

ज़रूरी शर्तें:

• split_dimension पर ऑपरेंड के डाइमेंशन का साइज़, split_count से विभाजित होता है.
• ऑपरेंड का आकार टपल नहीं होता है.

AllToAll(operand, split_dimension, concat_dimension, split_count, replica_groups)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	n डाइमेंशन वाले इनपुट अरे
split_dimension	int64	[0, n) इंटरवल में एक वैल्यू जो उस डाइमेंशन का नाम रखती है जिसके साथ ऑपरेंड को स्प्लिट किया जाता है
concat_dimension	int64	[0, n) इंटरवल में एक वैल्यू जो उस डाइमेंशन का नाम रखती है जिसके साथ स्प्लिट ब्लॉक जोड़े जाते हैं
split_count	int64	इस ऑपरेशन में शामिल कोर की संख्या. अगर replica_groups खाली है, तो यह जवाबों की संख्या होनी चाहिए. ऐसा न होने पर, यह हर ग्रुप में मौजूद कॉपी की संख्या के बराबर होनी चाहिए.
replica_groups	ReplicaGroup वेक्टर	हर ग्रुप में रेप्लिका आईडी की एक सूची होती है.

नीचे Alltoall का एक उदाहरण दिया गया है.

XlaBuilder b("alltoall");
auto x = Parameter(&b, 0, ShapeUtil::MakeShape(F32, {4, 16}), "x");
AllToAll(x, /*split_dimension=*/1, /*concat_dimension=*/0, /*split_count=*/4);

इस उदाहरण में, Alltoall में चार कोर शामिल हैं. हर कोर पर, ऑपरैंड को डाइमेंशन 0 के साथ चार भागों में बांटा जाता है, ताकि हर हिस्से का आकार f32[4,4] हो. चारों हिस्से, सभी कोर तक फैले हुए हैं. फिर हर कोर, मिले हुए हिस्सों को डाइमेंशन 1 के साथ कोर 0-4 के क्रम में इकट्ठा करता है. इस तरह, हर कोर के आउटपुट का आकार f32[16,4] होता है.

BatchNormGrad

एल्गोरिदम की ज़्यादा जानकारी के लिए, XlaBuilder::BatchNormGrad और ओरिजनल बैच नॉर्मलाइज़ेशन पेपर भी देखें.

बैच मानक के ग्रेडिएंट का हिसाब लगाता है.

BatchNormGrad(operand, scale, mean, variance, grad_output, epsilon, feature_index)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	सामान्य बनाई जाने वाली n डाइमेंशन वाली अरे (x)
scale	XlaOp	1 डाइमेंशन वाला अरे (\(\gamma\))
mean	XlaOp	1 डाइमेंशन वाला अरे (\(\mu\))
variance	XlaOp	1 डाइमेंशन वाला अरे (\(\sigma^2\))
grad_output	XlaOp	BatchNormTraining (\(\nabla y\)) को भेजे गए ग्रेडिएंट
epsilon	float	एप्सिलॉन मान (\(\epsilon\))
feature_index	int64	operand में, सुविधा के डाइमेंशन के हिसाब से इंडेक्स करें

सुविधा डाइमेंशन की हर सुविधा (operand में फ़ीचर डाइमेंशन का इंडेक्स feature_index है) के लिए, कार्रवाई सभी दूसरे डाइमेंशन में operand, offset, और scale के हिसाब से ग्रेडिएंट की गिनती करती है. operand में मौजूद सुविधा डाइमेंशन के लिए, feature_index एक मान्य इंडेक्स होना चाहिए.

तीन ग्रेडिएंट को नीचे दिए गए फ़ॉर्मूला से तय किया जाता है (यह मानते हुए कि 4-डाइमेंशन वाला अरे operand के तौर पर है और सुविधा वाला डाइमेंशन इंडेक्स l, बैच का साइज़ m, और स्पेशल साइज़ w और h है):

\[ \begin{split} c_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sigma^2_l+\epsilon} \right) \\\\ d_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \\\\ \nabla x_{ijkl} &= \frac{\gamma_{l} }{\sqrt{\sigma^2_{l}+\epsilon} } \left( \nabla y_{ijkl} - d_l - c_l (x_{ijkl} - \mu_{l}) \right) \\\\ \nabla \gamma_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sqrt{\sigma^2_{l}+\epsilon} } \right) \\\\\ \nabla \beta_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \end{split} \]

mean और variance इनपुट, बैच और स्पेशल डाइमेंशन में मोमेंट की वैल्यू दिखाते हैं.

आउटपुट टाइप में तीन हैंडल होते हैं:

आउटपुट	टाइप	सिमैंटिक
grad_operand	XlaOp	operand ($\nabla x$) इनपुट के हिसाब से ग्रेडिएंट
grad_scale	XlaOp	scale ($\nabla \gamma$) इनपुट के हिसाब से ग्रेडिएंट
grad_offset	XlaOp	इनपुट offset($\nabla \beta$) के संबंध में ग्रेडिएंट

BatchNormInference

एल्गोरिदम की ज़्यादा जानकारी के लिए, XlaBuilder::BatchNormInference और ओरिजनल बैच नॉर्मलाइज़ेशन पेपर भी देखें.

पूरे बैच और स्पेशल डाइमेंशन में किसी अरे को सामान्य बनाता है.

BatchNormInference(operand, scale, offset, mean, variance, epsilon, feature_index)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	नॉर्मलाइज़ की जाने वाली n आयाम वाली अरे
scale	XlaOp	1 डाइमेंशन वाला अरे
offset	XlaOp	1 डाइमेंशन वाला अरे
mean	XlaOp	1 डाइमेंशन वाला अरे
variance	XlaOp	1 डाइमेंशन वाला अरे
epsilon	float	एप्सिलॉन वैल्यू
feature_index	int64	operand में, सुविधा के डाइमेंशन के हिसाब से इंडेक्स करें

सुविधा डाइमेंशन की हर सुविधा (operand में, फ़ीचर डाइमेंशन का इंडेक्स feature_index है) के लिए, कार्रवाई अन्य सभी डाइमेंशन के माध्य और वैरियंस की गिनती करती है. साथ ही, operand के हर एलिमेंट को सामान्य बनाने के लिए मीन और वैरियंस का इस्तेमाल करती है. operand में सुविधा डाइमेंशन के लिए, feature_index एक मान्य इंडेक्स होना चाहिए.

BatchNormInference, हर बैच के लिए mean और variance की गणना किए बिना BatchNormTraining को कॉल करने के बराबर है. इसके बजाय, यह अनुमानित वैल्यू के तौर पर mean और variance इनपुट का इस्तेमाल करता है. इस ऑपरेटर का मकसद, इंतज़ार के समय को कम करना है, इसलिए इसका नाम BatchNormInference है.

आउटपुट एक n-डाइमेंशन और सामान्य रूप से बनाया गया कलेक्शन है, जिसका आकार operand के इनपुट के जैसा है.

BatchNormTraining

एल्गोरिदम के बारे में ज़्यादा जानकारी के लिए, XlaBuilder::BatchNormTraining और the original batch normalization paper भी देखें.

पूरे बैच और स्पेशल डाइमेंशन में किसी अरे को सामान्य बनाता है.

BatchNormTraining(operand, scale, offset, epsilon, feature_index)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	सामान्य बनाई जाने वाली n डाइमेंशन वाली अरे (x)
scale	XlaOp	1 डाइमेंशन वाला अरे (\(\gamma\))
offset	XlaOp	1 डाइमेंशन वाला अरे (\(\beta\))
epsilon	float	एप्सिलॉन मान (\(\epsilon\))
feature_index	int64	operand में, सुविधा के डाइमेंशन के हिसाब से इंडेक्स करें

सुविधा डाइमेंशन की हर सुविधा (operand में, फ़ीचर डाइमेंशन का इंडेक्स feature_index है) के लिए, कार्रवाई अन्य सभी डाइमेंशन के माध्य और वैरियंस की गिनती करती है. साथ ही, operand के हर एलिमेंट को सामान्य बनाने के लिए मीन और वैरियंस का इस्तेमाल करती है. operand में सुविधा डाइमेंशन के लिए, feature_index एक मान्य इंडेक्स होना चाहिए.

operand \(x\) के हर बैच के लिए, एल्गोरिदम इस तरह का होता है जिसमें m एलिमेंट होते हैं. साथ ही, जिनमें w और h एलिमेंट का साइज़ स्पेशल डाइमेंशन के साइज़ के तौर पर होता है (यह मानते हुए कि operand एक 4 डाइमेंशन वाला अरे है):

• सुविधा डाइमेंशन में हर सुविधा l के लिए, बैच मीन \(\mu_l\) कैलकुलेट करता है: \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• बैच वैरियंस कैलकुलेट करता है \(\sigma^2_l\): $\sigma^2l=\frac{1}{mwh}\sum{i=1}^m\sum{j=1}^w\sum{k=1}^h (x_{ijkl} - \mu_l)^2$

• सामान्य, स्केल और शिफ़्ट को सामान्य बनाता है: \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

ऐपसिलॉन की वैल्यू, आम तौर पर एक छोटी संख्या होती है. वैल्यू को 'शून्य' से अलग-अलग गड़बड़ियों से बचाने के लिए जोड़ा जाता है.

आउटपुट टाइप, तीन XlaOp सेकंड का टपल है:

आउटपुट	टाइप	सिमैंटिक
output	XlaOp	इनपुट के समान आकार वाली n डाइमेंशन वाली अरे operand (y)
batch_mean	XlaOp	1 डाइमेंशन वाला अरे (\(\mu\))
batch_var	XlaOp	1 डाइमेंशन वाला अरे (\(\sigma^2\))

batch_mean और batch_var का हिसाब, बैच और स्पेशल डाइमेंशन में दिया गया है. इसके लिए, ऊपर दिए गए फ़ॉर्मूले का इस्तेमाल किया जाता है.

BitcastConvertType

XlaBuilder::BitcastConvertType भी देखें.

TensorFlow के tf.bitcast की तरह, यह डेटा आकार से टारगेट आकार तक, एलिमेंट के हिसाब से बिटकास्ट कार्रवाई करता है. इनपुट और आउटपुट साइज़ मेल खाने चाहिए: उदाहरण के लिए, s32 एलिमेंट बिटकास्ट रूटीन से f32 एलिमेंट बन जाएंगे और एक s32 एलिमेंट, चार s8 एलिमेंट बन जाएगा. बिटकास्ट को लो-लेवल कास्ट के तौर पर लागू किया जाता है, इसलिए अलग-अलग फ़्लोटिंग-पॉइंट वाली मशीन अलग-अलग नतीजे देती हैं.

BitcastConvertType(operand, new_element_type)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	डिम D के साथ T टाइप की रेंज
new_element_type	PrimitiveType	U लिखें

ऑपरेंड और टारगेट आकार के डाइमेंशन मेल खाने चाहिए. उन आखिरी डाइमेंशन से अलग, जो कन्वर्ज़न से पहले और बाद में पुराने डाइमेंशन के अनुपात से बदलेंगे.

सोर्स और डेस्टिनेशन एलिमेंट के टाइप, टूल में नहीं होने चाहिए.

बिटकास्ट-को अलग-अलग चौड़ाई के प्रिमिटिव टाइप में बदला जा रहा है

BitcastConvert एचएलओ निर्देश उस मामले में इस्तेमाल किया जा सकता है जहां आउटपुट एलिमेंट टाइप T' का साइज़, इनपुट एलिमेंट T के साइज़ के बराबर नहीं होता. सैद्धांतिक तौर पर, पूरा ऑपरेशन बिटकास्ट है और मौजूद बाइट में बदलाव नहीं करता. इसलिए, आउटपुट एलिमेंट का आकार बदलना पड़ता है. B = sizeof(T), B' = sizeof(T') के लिए, दो स्थितियां हो सकती हैं.

सबसे पहले, B > B' होने पर, आउटपुट आकार को साइज़ का सबसे छोटा और सबसे छोटा डाइमेंशन B/B' मिलता है. उदाहरण के लिए:

  f16[10,2]{1,0} %output = f16[10,2]{1,0} bitcast-convert(f32[10]{0} %input)

असरदार स्केलर के लिए भी नियम एक ही रहता है:

  f16[2]{0} %output = f16[2]{0} bitcast-convert(f32[] %input)

इसके अलावा, B' > B के लिए निर्देश के लिए इनपुट आकार का आखिरी लॉजिकल डाइमेंशन, B'/B के बराबर होना ज़रूरी है. साथ ही, कन्वर्ज़न के दौरान यह डाइमेंशन हटा दिया जाता है:

  f32[10]{0} %output = f32[10]{0} bitcast-convert(f16[10,2]{1,0} %input)

ध्यान दें कि अलग-अलग बिट-चौड़ाई के बीच होने वाले कन्वर्ज़न, एलिमेंट के हिसाब से नहीं होते.

ब्रॉडकास्ट करना

XlaBuilder::Broadcast भी देखें.

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

Broadcast(operand, broadcast_sizes)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	डुप्लीकेट किया जाने वाला अरे
broadcast_sizes	ArraySlice<int64>	नए डाइमेंशन के साइज़

नए डाइमेंशन बाईं ओर डाले जाते हैं. उदाहरण के लिए, अगर broadcast_sizes में वैल्यू {a0, ..., aN} हैं और ऑपरेंड की शेप में डाइमेंशन {b0, ..., bM} हैं, तो आउटपुट की शेप में {a0, ..., aN, b0, ..., bM} डाइमेंशन होंगे.

नए डाइमेंशन, ऑपरेंड की कॉपी में इंडेक्स हो जाते हैं, जैसे कि

output[i0, ..., iN, j0, ..., jM] = operand[j0, ..., jM]

उदाहरण के लिए, अगर operand, 2.0f वैल्यू वाला f32 स्केलर है और broadcast_sizes {2, 3} है, तो नतीजे के तौर पर, शेपf32[2, 3] वाली एक कैटगरी होगी. साथ ही, नतीजे में मिलने वाली सभी वैल्यू 2.0f होंगी.

BroadcastInDim

XlaBuilder::BroadcastInDim भी देखें.

अरे में डेटा को डुप्लीकेट करके, उसके साइज़ और रैंक को बड़ा करता है.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	डुप्लीकेट किया जाने वाला अरे
out_dim_size	ArraySlice<int64>	टारगेट शेप के डाइमेंशन के साइज़
broadcast_dimensions	ArraySlice<int64>	लक्ष्य आकार में कौन-सा आयाम ऑपरेंड आकार के प्रत्येक आयाम से संबंधित है

यह ब्रॉडकास्ट की तरह है, लेकिन इसमें कहीं भी डाइमेंशन जोड़ने की सुविधा मिलती है. साथ ही, पहले साइज़ वाले मौजूदा डाइमेंशन को बड़ा किया जा सकता है.

operand को out_dim_size में बताए गए आकार पर ब्रॉडकास्ट किया जाता है. broadcast_dimensions, operand के डाइमेंशन को टारगेट आकार के डाइमेंशन से मैप करता है. इसका मतलब है कि ऑपरेंड के i डाइमेंशन को आउटपुट आकार केbroadcast_dimension[i]वें डाइमेंशन से मैप किया जाता है. operand के डाइमेंशन का साइज़ 1 होना चाहिए या उसका साइज़, आउटपुट शेप में मौजूद डाइमेंशन के बराबर होना चाहिए. बाकी डाइमेंशन में, पहले साइज़ के डाइमेंशन भरे हुए हैं. इसके बाद, डिजनरेट-डाइमेंशन ब्रॉडकास्टिंग इन डिजनरेट डाइमेंशन के साथ ब्रॉडकास्ट करता है, ताकि आउटपुट शेप तक पहुंचा जा सके. ब्रॉडकास्ट करने वाले पेज पर, सिस्टम के मतलब की पूरी जानकारी दी गई है.

कॉल

XlaBuilder::Call भी देखें.

दिए गए तर्कों के साथ गणना शुरू करता है.

Call(computation, args...)

तर्क	टाइप	सिमैंटिक
computation	XlaComputation	आर्बिट्रेरी टाइप के N पैरामीटर के साथ T_0, T_1, ..., T_{N-1} -> S टाइप की कैलकुलेशन
args	N XlaOp सेकंड का क्रम	आर्बिट्रेरी टाइप के N आर्ग्युमेंट

args की arity और टाइप, computation के पैरामीटर से मैच होने चाहिए. इसमें args नहीं हो सकता.

कोलेस्की

XlaBuilder::Cholesky भी देखें.

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

Cholesky(a, lower)

तर्क	टाइप	सिमैंटिक
a	XlaOp	कॉम्प्लेक्स या फ़्लोटिंग-पॉइंट टाइप की रैंक > 2 अरे.
lower	bool	a के ऊपरी या निचले त्रिभुज का उपयोग करना है या नहीं.

अगर lower true है, तो निचले-त्रिकोणीय मैट्रिक्स l की गणना करता है, जैसे कि $a = l . l^T$. अगर lower false है, तो ऊपरी-त्रिकोणीय मैट्रिक्स u की गणना इस तरह करता है \(a = u^T . u\).

lower की वैल्यू के आधार पर, इनपुट डेटा को सिर्फ़ a के निचले/ऊपर वाले ट्राऐंगल से पढ़ा जाता है. दूसरे त्रिभुज के मानों को अनदेखा किया जाता है. आउटपुट डेटा एक ही त्रिभुज में दिखाया जाता है. दूसरे त्रिभुज में दी गई वैल्यू, लागू करने के तरीके से तय होती हैं और कुछ भी हो सकती हैं.

अगर a की रैंक दो से ज़्यादा है, तो a को मैट्रिक्स के बैच के तौर पर माना जाता है. इसमें, बाकी दो छोटे डाइमेंशन को छोड़कर बाकी सभी डाइमेंशन बैच डाइमेंशन होते हैं.

अगर a सिमेट्रिक (हर्मिटियन) पॉज़िटिव नहीं है, तो नतीजे के तौर पर लागू करने के तरीके के बारे में बताया जाता है.

क्लैंप

XlaBuilder::Clamp भी देखें.

किसी ऑपरेंड को कम से कम और ज़्यादा से ज़्यादा वैल्यू के बीच की रेंज में जोड़ता है.

Clamp(min, operand, max)

तर्क	टाइप	सिमैंटिक
min	XlaOp	T टाइप का अरे
operand	XlaOp	T टाइप का अरे
max	XlaOp	T टाइप का अरे

ऑपरेंड और कम से कम और ज़्यादा से ज़्यादा वैल्यू दिए जाने पर, ऑपरेंड कम से कम और ज़्यादा से ज़्यादा के बीच की रेंज में होने पर वह नतीजे के तौर पर दिखाता है. अगर ऑपरेंड इस रेंज से कम है या इससे ज़्यादा है, तो यह सबसे छोटी वैल्यू दिखाता है. यानी, clamp(a, x, b) = min(max(a, x), b).

तीनों कैटगरी एक ही आकार की होनी चाहिए. इसके अलावा, ब्रॉडकास्ट करने के प्रतिबंधित तरीके के तौर पर, min और/या max, T टाइप का स्केलर हो सकते हैं.

min और max स्केलर के साथ उदाहरण:

let operand: s32[3] = {-1, 5, 9};
let min: s32 = 0;
let max: s32 = 6;
==>
Clamp(min, operand, max) = s32[3]{0, 5, 6};

छोटा करें

XlaBuilder::Collapse और tf.reshape कार्रवाई भी देखें.

किसी अरे के डाइमेंशन को एक डाइमेंशन में छोटा करता है.

Collapse(operand, dimensions)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	T टाइप का अरे
dimensions	int64 वेक्टर	क्रम में, T के डाइमेंशन का लगातार सबसेट.

'छोटा करें' विकल्प, ऑपरेंड के डाइमेंशन के दिए गए सबसेट को एक डाइमेंशन से बदल देता है. इनपुट आर्ग्युमेंट, T टाइप का आर्बिट्रेरी अरे और डाइमेंशन इंडेक्स के कंपाइल-टाइम-कॉन्सटेंट वेक्टर हैं. डाइमेंशन इंडेक्स, क्रम में (कम से ज़्यादा डाइमेंशन की संख्या) होने चाहिए और T के डाइमेंशन का लगातार सबसेट होना चाहिए. इसलिए, {0, 1, 2}, {0, 1} या {1, 2} सभी मान्य डाइमेंशन सेट हैं, लेकिन {1, 0} या {0, 2} मान्य नहीं हैं. उन्हें डाइमेंशन क्रम में उसी जगह पर एक नए डाइमेंशन से बदल दिया जाता है जिस क्रम में वे बदली जाती हैं. नया डाइमेंशन साइज़, ओरिजनल डाइमेंशन साइज़ के प्रॉडक्ट के बराबर होता है. dimensions में सबसे कम डाइमेंशन संख्या, लूप नेस्ट में सबसे धीमी डाइमेंशन (सबसे प्रमुख) होती है जो इन डाइमेंशन को छोटा कर देती है. सबसे ज़्यादा डाइमेंशन की संख्या, तेज़ी से बदलती (सबसे छोटी) होती है. अगर सामान्य तौर पर, आइटम को छोटा करने की ज़रूरत है, तो tf.reshape ऑपरेटर देखें.

उदाहरण के लिए, v को 24 एलिमेंट का अरे बनने दें:

let v = f32[4x2x3] { { {10, 11, 12},  {15, 16, 17} },
{ {20, 21, 22},  {25, 26, 27} },
{ {30, 31, 32},  {35, 36, 37} },
{ {40, 41, 42},  {45, 46, 47} } };

// Collapse to a single dimension, leaving one dimension.
let v012 = Collapse(v, {0,1,2});
then v012 == f32[24] {10, 11, 12, 15, 16, 17,
20, 21, 22, 25, 26, 27,
30, 31, 32, 35, 36, 37,
40, 41, 42, 45, 46, 47};

// Collapse the two lower dimensions, leaving two dimensions.
let v01 = Collapse(v, {0,1});
then v01 == f32[4x6] { {10, 11, 12, 15, 16, 17},
{20, 21, 22, 25, 26, 27},
{30, 31, 32, 35, 36, 37},
{40, 41, 42, 45, 46, 47} };

// Collapse the two higher dimensions, leaving two dimensions.
let v12 = Collapse(v, {1,2});
then v12 == f32[8x3] { {10, 11, 12},
{15, 16, 17},
{20, 21, 22},
{25, 26, 27},
{30, 31, 32},
{35, 36, 37},
{40, 41, 42},
{45, 46, 47} };

CollectivePermute

XlaBuilder::CollectivePermute भी देखें.

CollectivePerम्यूट एक साथ मिलने वाली कार्रवाई है, जो डेटा की क्रॉस कॉपी भेजता और पाती है.

CollectivePermute(operand, source_target_pairs)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	n डाइमेंशन वाले इनपुट अरे
source_target_pairs	<int64, int64> वेक्टर	(source_Replica_id, target_Replica_id) जोड़े की सूची. हर जोड़े के लिए, ऑपरेंड को सोर्स रेप्लिका से टारगेट रेप्लिका के लिए भेजा जाता है.

ध्यान दें कि source_target_pair पर ये पाबंदियां लागू होती हैं:

• किसी भी दो जोड़े की टारगेट प्रतिरूप आईडी एक ही नहीं होनी चाहिए और उनकी स्रोत प्रतिरूप आईडी एक ही नहीं होनी चाहिए.
• अगर किसी जोड़ी में रेप्लिका आईडी, टारगेट नहीं है, तो उस रेप्लिका पर आउटपुट एक टेंसर है, जिसमें इनपुट के आकार वाले 0 हैं.

स्ट्रिंग जोड़ें

XlaBuilder::ConcatInDim भी देखें.

स्ट्रिंग जोड़ने की सुविधा की मदद से, कई अरे ऑपर्ड से अरे बनाया जाता है. यह कलेक्शन, हर इनपुट अरे ऑपर्ड की रैंक का ही होता है (जो हर दूसरे ऑपर्ड की रैंक का होना चाहिए). साथ ही, इसमें आर्ग्युमेंट उनके बताए गए क्रम में होते हैं.

Concatenate(operands..., dimension)

तर्क	टाइप	सिमैंटिक
operands	N XlaOp का क्रम	[L0, L1, ...] डाइमेंशन वाली T टाइप की N अरे. इसके लिए, N >= 1 होना ज़रूरी है.
dimension	int64	[0, N) इंटरवल में ऐसी वैल्यू जो operands के बीच जोड़े जाने वाले डाइमेंशन को नाम देती है.

dimension को छोड़कर, सभी डाइमेंशन एक जैसे होने चाहिए. ऐसा इसलिए, क्योंकि XLA में "रग्ड" कलेक्शन काम नहीं करता. यह भी ध्यान रखें कि रैंक-0 की वैल्यू को जोड़ा नहीं जा सकता (क्योंकि किसी डाइमेंशन को नाम देना संभव नहीं है, जिसमें स्ट्रिंग जोड़ने की प्रोसेस होती है).

1-डाइमेंशन वाला उदाहरण:

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
>>> {2, 3, 4, 5, 6, 7}

दो डाइमेंशन का उदाहरण:

let a = {
{1, 2},
{3, 4},
{5, 6},
};
let b = {
{7, 8},
};
Concat({a, b}, 0)
>>> {
{1, 2},
{3, 4},
{5, 6},
{7, 8},
}

डायग्राम:

कंडीशनल

XlaBuilder::Conditional भी देखें.

Conditional(pred, true_operand, true_computation, false_operand, false_computation)

तर्क	टाइप	सिमैंटिक
pred	XlaOp	PRED टाइप का स्केलर
true_operand	XlaOp	आर्ग्युमेंट के टाइप \(T_0\)
true_computation	XlaComputation	XlaComputation के टाइप \(T_0 \to S\)
false_operand	XlaOp	आर्ग्युमेंट के टाइप \(T_1\)
false_computation	XlaComputation	XlaComputation के टाइप \(T_1 \to S\)

अगर pred true है, तो true_computation को लागू करता है. अगर pred false है, तो false_computation को लागू करता है और नतीजा दिखाता है.

true_computation को एक ही तरह का आर्ग्युमेंट \(T_0\) करना चाहिए. साथ ही, इसे true_operand के साथ शुरू किया जाएगा, जो उसी तरह का होना चाहिए. false_computation को एक ही तरह के आर्ग्युमेंट में शामिल किया जाना चाहिए \(T_1\) . साथ ही, इसे false_operand से शुरू किया जाएगा, जो भी एक ही तरह का होना चाहिए. true_computation और false_computation की दिए गई वैल्यू एक ही होनी चाहिए.

ध्यान दें कि pred की वैल्यू के आधार पर, true_computation और false_computation में से सिर्फ़ एक को ही लागू किया जाएगा.

Conditional(branch_index, branch_computations, branch_operands)

तर्क	टाइप	सिमैंटिक
branch_index	XlaOp	S32 टाइप का स्केलर
branch_computations	N XlaComputation का क्रम	\(T_0 \to S , T_1 \to S , ..., T_{N-1} \to S\)टाइप की Xla कंप्यूटेशन
branch_operands	N XlaOp का क्रम	आर्ग्युमेंट के टाइप \(T_0 , T_1 , ..., T_{N-1}\)

branch_computations[branch_index] को लागू करता है और नतीजा दिखाता है. अगर branch_index एक S32 है, जो < 0 या >= N है, तो branch_computations[N-1] को डिफ़ॉल्ट ब्रांच के तौर पर चलाया जाता है.

हर branch_computations[b] को एक ही आर्ग्युमेंट को लिया जाना चाहिए \(T_b\) और इसे branch_operands[b] के साथ शुरू किया जाएगा, जो एक ही तरह का होना चाहिए. हर branch_computations[b] की रिटर्न वैल्यू एक ही होनी चाहिए.

ध्यान दें कि branch_index की वैल्यू के आधार पर, सिर्फ़ एक branch_computations को चलाया जाएगा.

कन्वर्ज़न (कॉन्वोल्यूशन)

XlaBuilder::Conv भी देखें.

ConvertWithGeneralPadding के तौर पर, लेकिन पैडिंग की जानकारी कम शब्दों में दी जाती है. 'SAME' या 'मान्य' फ़ॉर्मैट में ऐसा किया जाता है. एक ही पैडिंग (जगह) इनपुट (lhs) को शून्य से पैड करता है, ताकि खाते में स्ट्रिंग न करते समय, आउटपुट का आकार, इनपुट के आकार जैसा ही हो. मान्य पैडिंग का मतलब है, कोई पैडिंग नहीं.

ConvertWithGeneralP जोड़ने के लिए (कॉन्वोल्यूशन)

XlaBuilder::ConvWithGeneralPadding भी देखें.

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

तर्क	टाइप	सिमैंटिक
lhs	XlaOp	इनपुट की n+2 अरे को रैंक करें
rhs	XlaOp	कर्नेल वेट की n+2 श्रेणी
window_strides	ArraySlice<int64>	कर्नेल स्ट्रेड की n-d अरे
padding	ArraySlice< pair<int64,int64>>	(कम, ज़्यादा) पैडिंग की n-d अरे
lhs_dilation	ArraySlice<int64>	n-d lhs डाइलेशन फ़ैक्टर अरे
rhs_dilation	ArraySlice<int64>	n-d rhs डायलेशन फ़ैक्टर अरे
feature_group_count	int64	सुविधा ग्रुप की संख्या
batch_group_count	int64	बैच ग्रुप की संख्या

मान लें कि जगह के हिसाब से डाइमेंशन की संख्या n है. lhs आर्ग्युमेंट, रैंक n+2 है. यह बेस एरिया की जानकारी देता है. इसे इनपुट कहा जाता है, हालांकि rhs भी एक इनपुट है. न्यूरल नेटवर्क में, ये इनपुट ऐक्टिवेशन होते हैं. n+2 डाइमेंशन इस क्रम में होते हैं:

• batch: इस डाइमेंशन में हर कोऑर्डिनेट एक इंडिपेंडेंट इनपुट दिखाता है, जिसके लिए कॉन्वलूशन किया जाता है.
• z/depth/features: बेस एरिया में हर (y,x) पोज़िशन से एक वेक्टर जुड़ा होता है, जो इस डाइमेंशन में जाता है.
• spatial_dims: यह n के ऐसे स्पेशल डाइमेंशन के बारे में बताता है जो विंडो के मूल क्षेत्र को तय करते हैं.

rhs आर्ग्युमेंट, कॉन्वलूशनल फ़िल्टर/kernel/विंडो के बारे में बताने वाली रैंक n+2 का कलेक्शन है. डाइमेंशन इस क्रम में होते हैं:

• output-z: आउटपुट का z डाइमेंशन.
• input-z: feature_group_count इस डाइमेंशन का साइज़, z डाइमेंशन के साइज़ के बराबर होना चाहिए.
• spatial_dims: यह n के ऐसे स्पेशल डाइमेंशन के बारे में बताता है जो एन-डी विंडो को तय करते हैं. यह विंडो, बेस एरिया में एक जगह से दूसरी जगह जाती है.

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

padding आर्ग्युमेंट, बेस एरिया पर लागू होने वाली शून्य पैडिंग की संख्या तय करता है. पैडिंग (जगह) की संख्या नेगेटिव हो सकती है -- नेगेटिव पैडिंग की कुल वैल्यू, कन्वर्ज़न करने से पहले तय किए गए डाइमेंशन से हटाए जाने वाले एलिमेंट की संख्या दिखाती है. padding[0] डाइमेंशन y के लिए पैडिंग (जगह) तय करता है और padding[1] डाइमेंशन x के लिए पैडिंग (जगह) तय करता है. हर पेयर में, पहले एलिमेंट के तौर पर कम पैडिंग और दूसरे एलिमेंट के तौर पर ज़्यादा पैडिंग होती है. कम पैडिंग (जगह) को निचले इंडेक्स की दिशा में लागू किया जाता है, जबकि ज़्यादा पैडिंग (जगह) को ऊपर के इंडेक्स की दिशा में लागू किया जाता है. उदाहरण के लिए, अगर padding[1] (2,3) है, तो बाईं ओर दो शून्य और दूसरे स्पेशल डाइमेंशन में दाईं ओर तीन शून्य होंगे. पैडिंग (जगह) का इस्तेमाल करना, कॉन्वलूशन करने से पहले इनपुट (lhs) में शून्य वैल्यू डालने के बराबर है.

lhs_dilation और rhs_dilation आर्ग्युमेंट, हर जगह के हिसाब से डाइमेंशन में 1. अगर किसी स्थान-संबंधी डाइमेंशन में फैलाव कारक d है, तो उस डाइमेंशन में हर एंट्री के बीच साफ़ तौर पर d-1 छेद किए जाते हैं, जिससे ऐरे का आकार बढ़ जाता है. इन छेदों में नो-ऑप वैल्यू डाली जाती है. इसका मतलब है कि कॉन्वलूशन का मतलब ज़ीरो होता है.

आरएच के डायलेशन को एट्रस कॉन्वलूशन भी कहा जाता है. ज़्यादा जानकारी के लिए, tf.nn.atrous_conv2d देखें. एलएच के फैलाव को ट्रांसपोज़्ड कन्वोल्यूशन भी कहा जाता है. ज़्यादा जानकारी के लिए, tf.nn.conv2d_transpose देखें.

feature_group_count आर्ग्युमेंट (डिफ़ॉल्ट वैल्यू 1) का इस्तेमाल, ग्रुप किए गए कन्वर्ज़न के लिए किया जा सकता है. feature_group_count, इनपुट और आउटपुट सुविधा डाइमेंशन, दोनों का डिवाइज़र होना चाहिए. अगर feature_group_count, 1 से ज़्यादा है, तो इसका मतलब है कि इनपुट और आउटपुट सुविधा वाले डाइमेंशन और rhs आउटपुट सुविधा वाले डाइमेंशन को कई feature_group_count ग्रुप में बराबर रूप से बांटा गया है. हर ग्रुप में, सुविधाओं का क्रम में आने वाला सब-क्रम शामिल है. rhs का इनपुट सुविधा डाइमेंशन, lhs इनपुट सुविधा के डाइमेंशन को feature_group_count से भाग देने पर मिलने वाली वैल्यू के बराबर होना चाहिए. ऐसा इसलिए, ताकि उसमें पहले से ही इनपुट सुविधाओं के ग्रुप का साइज़ हो. i-th ग्रुप का एक साथ इस्तेमाल करके, कई अलग-अलग कन्वलूशन के लिए feature_group_count का हिसाब लगाया जाता है. इन कन्वर्ज़न से मिलने वाले नतीजों को, आउटपुट सुविधा डाइमेंशन में एक साथ जोड़ा जाता है.

ज़्यादा जानकारी के लिए, feature_group_count आर्ग्युमेंट को इनपुट सुविधा के डाइमेंशन पर सेट किया जाएगा. साथ ही, फ़िल्टर को [filter_height, filter_width, in_channels, channel_multiplier] से [filter_height, filter_width, 1, in_channels * channel_multiplier] में बदल दिया जाएगा. ज़्यादा जानकारी के लिए, tf.nn.depthwise_conv2d देखें.

batch_group_count (डिफ़ॉल्ट वैल्यू 1) आर्ग्युमेंट का इस्तेमाल, बैकप्रोपेगेशन के दौरान ग्रुप किए गए फ़िल्टर के लिए किया जा सकता है. batch_group_count, lhs (इनपुट) बैच डाइमेंशन के साइज़ का डिवाइज़र होना चाहिए. अगर batch_group_count 1 से ज़्यादा है, तो इसका मतलब है कि आउटपुट बैच डाइमेंशन का साइज़ input batch / batch_group_count होना चाहिए. batch_group_count, आउटपुट सुविधा के साइज़ का डिवाइज़र होना चाहिए.

आउटपुट आकार में ये डाइमेंशन इस क्रम में होते हैं:

• batch: इस डाइमेंशन गुणा batch_group_count का साइज़, batch डाइमेंशन के साइज़ के बराबर होना चाहिए.
• z: कर्नेल पर output-z के आकार के बराबर (rhs).
• spatial_dims: कन्वर्ज़न विंडो की हर मान्य प्लेसमेंट के लिए एक वैल्यू.

ऊपर दिया गया चित्र दिखाता है कि batch_group_count फ़ील्ड कैसे काम करता है. असरदार तरीके से, हम हर एलएच बैच को batch_group_count ग्रुप में बांटते हैं और आउटपुट सुविधाओं के लिए भी ऐसा ही करते हैं. इसके बाद, हम इनमें से हर ग्रुप के लिए, पेयर के हिसाब से कॉन्वलूशन करते हैं और आउटपुट सुविधा डाइमेंशन के साथ आउटपुट को जोड़ते हैं. अन्य सभी डाइमेंशन (सुविधा और जगह के बारे में) का ऑपरेशनल सिमैंटिक पहले जैसा ही रहता है.

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

यह बताने के लिए कि कॉन्वलूशन क्या करता है, 2D कन्वलूशन पर विचार करें और आउटपुट में कुछ तय batch, z, y, x कोऑर्डिनेट चुनें. इसके बाद, (y,x), बेस एरिया में विंडो के कोने की पोज़िशन होता है. जैसे, ऊपर बाईं ओर कोने में मौजूद जानकारी, जो इस बात पर निर्भर करती है कि जगह की जानकारी के डाइमेंशन का मतलब क्या है. अब हमारे पास बेस एरिया से ली गई 2d विंडो है, जहां हर 2d पॉइंट 1d वेक्टर से जुड़ा होता है. इसलिए, हमें 3d बॉक्स मिलता है. कॉन्वलूशनल कर्नेल से, क्योंकि हमने आउटपुट कोऑर्डिनेट z को ठीक किया है, इसलिए हमारे पास एक 3d बॉक्स भी है. दोनों बॉक्स के डाइमेंशन एक जैसे होते हैं. इसलिए, हम दो बॉक्स के बीच एलिमेंट के हिसाब से प्रॉडक्ट का योग निकाल सकते हैं (जिस तरह डॉट प्रॉडक्ट की तरह होता है). यह आउटपुट वैल्यू होती है.

ध्यान दें कि अगर output-z 5 है, तो विंडो की हर पोज़िशन, आउटपुट के z डाइमेंशन में आउटपुट में पांच वैल्यू जनरेट करती है. ये वैल्यू, इस बात से अलग हैं कि कॉन्वलूशनल कर्नेल के किस हिस्से का इस्तेमाल किया गया है - हर output-z निर्देशांक के लिए, वैल्यू का एक अलग 3d बॉक्स इस्तेमाल किया जाता है. इसे पांच अलग-अलग कॉन्वलूशन के तौर पर, हर एक के लिए अलग-अलग फ़िल्टर के साथ समझा जा सकता है.

यहां पैडिंग और स्ट्रेडिंग के साथ 2D कॉन्वलूशन के लिए स्यूडो-कोड दिया गया है:

for (b, oz, oy, ox) {  // output coordinates
  value = 0;
  for (iz, ky, kx) {  // kernel coordinates and input z
    iy = oy*stride_y + ky - pad_low_y;
    ix = ox*stride_x + kx - pad_low_x;
    if ((iy, ix) inside the base area considered without padding) {
      value += input(b, iz, iy, ix) * kernel(oz, iz, ky, kx);
    }
  }
  output(b, oz, oy, ox) = value;
}

ConvertElementType

XlaBuilder::ConvertElementType भी देखें.

C++ में, एलिमेंट के हिसाब से static_cast की तरह ही, डेटा के आकार से टारगेट के आकार में, एलिमेंट के हिसाब से कन्वर्ज़न कार्रवाई करता है. डाइमेंशन मेल खाने चाहिए और कन्वर्ज़न, एलिमेंट के हिसाब से है. उदाहरण के लिए, s32-से-f32 कन्वर्ज़न रूटीन के ज़रिए s32 एलिमेंट, f32 एलिमेंट बन जाते हैं.

ConvertElementType(operand, new_element_type)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	डिम D के साथ T टाइप की रेंज
new_element_type	PrimitiveType	U लिखें

ऑपरेंड के डाइमेंशन और टारगेट का आकार मैच होना चाहिए. सोर्स और डेस्टिनेशन एलिमेंट टाइप, टुपल नहीं होने चाहिए.

T=s32 से U=f32 जैसा कन्वर्ज़न, नॉर्मलाइज़ किया गया इन-टू-फ़्लोट कन्वर्ज़न रूटीन करेगा, जैसे कि राउंड-टू-पास-ईवन.

let a: s32[3] = {0, 1, 2};
let b: f32[3] = convert(a, f32);
then b == f32[3]{0.0, 1.0, 2.0}

CrossReplicaSum

योग का कैलकुलेशन करके AllReduce को पूरा करता है.

CustomCall

XlaBuilder::CustomCall भी देखें.

कंप्यूटेशन (कैलकुलेशन) में उपयोगकर्ता के दिए गए फ़ंक्शन को कॉल करें.

CustomCall(target_name, args..., shape)

तर्क	टाइप	सिमैंटिक
target_name	string	फ़ंक्शन का नाम. इस सिंबल के नाम को टारगेट करने के लिए, एक कॉल निर्देश भेजा जाएगा.
args	N XlaOp सेकंड का क्रम	आर्बिट्रेरी टाइप के N आर्ग्युमेंट, जिन्हें फ़ंक्शन में भेजा जाएगा.
shape	Shape	फ़ंक्शन के आउटपुट का आकार

फ़ंक्शन सिग्नेचर एक ही होता है, चाहे arity या आर्ग्युमेंट के टाइप कुछ भी हों:

extern "C" void target_name(void* out, void** in);

उदाहरण के लिए, अगर CustomCall का इस्तेमाल इस तरह से किया जाता है:

let x = f32[2] {1,2};
let y = f32[2x3] { {10, 20, 30}, {40, 50, 60} };

CustomCall("myfunc", {x, y}, f32[3x3])

यहां myfunc को लागू करने का एक उदाहरण दिया गया है:

extern "C" void myfunc(void* out, void** in) {
  float (&x)[2] = *static_cast<float(*)[2]>(in[0]);
  float (&y)[2][3] = *static_cast<float(*)[2][3]>(in[1]);
  EXPECT_EQ(1, x[0]);
  EXPECT_EQ(2, x[1]);
  EXPECT_EQ(10, y[0][0]);
  EXPECT_EQ(20, y[0][1]);
  EXPECT_EQ(30, y[0][2]);
  EXPECT_EQ(40, y[1][0]);
  EXPECT_EQ(50, y[1][1]);
  EXPECT_EQ(60, y[1][2]);
  float (&z)[3][3] = *static_cast<float(*)[3][3]>(out);
  z[0][0] = x[1] + y[1][0];
  // ...
}

उपयोगकर्ता के दिए गए फ़ंक्शन के खराब असर का कोई असर नहीं होना चाहिए. साथ ही, इसे लागू करने का तरीका बेअसर होना चाहिए.

डॉट

XlaBuilder::Dot भी देखें.

Dot(lhs, rhs)

तर्क	टाइप	सिमैंटिक
lhs	XlaOp	T टाइप का अरे
rhs	XlaOp	T टाइप का अरे

इस ऑपरेशन के सटीक सिमैंटिक, ऑपरेंड की रैंक पर निर्भर करते हैं:

इनपुट	आउटपुट	सिमैंटिक
वेक्टर [n] dot वेक्टर [n]	स्केलर	वेक्टर डॉट प्रॉडक्ट
मैट्रिक्स [m x k] dot वेक्टर [k]	वेक्टर [m]	मैट्रिक्स-वेक्टर गुणन
मैट्रिक्स [m x k] dot मैट्रिक्स [k x n]	मैट्रिक्स [m x n]	मैट्रिक्स-मैट्रिक्स गुणन

यह कार्रवाई, lhs के दूसरे डाइमेंशन (या अगर उसकी रैंक 1 है, तो पहले डाइमेंशन) और rhs के पहले डाइमेंशन पर, प्रॉडक्ट का योग करती है. ये "कॉन्ट्रैक्टेड" डाइमेंशन हैं. lhs और rhs के कॉन्ट्रैक्टेड डाइमेंशन का साइज़ एक जैसा होना चाहिए. असल में, इसका इस्तेमाल वेक्टर, वेक्टर/मैट्रिक्स के गुणन या मैट्रिक्स/मैट्रिक्स के गुणन के बीच डॉट प्रॉडक्ट लगाने के लिए किया जा सकता है.

DotGeneral

XlaBuilder::DotGeneral भी देखें.

DotGeneral(lhs, rhs, dimension_numbers)

तर्क	टाइप	सिमैंटिक
lhs	XlaOp	T टाइप का अरे
rhs	XlaOp	T टाइप का अरे
dimension_numbers	DotDimensionNumbers	अनुबंध और बैच डाइमेंशन नंबर

यह Dot की तरह है, लेकिन यह lhs और rhs, दोनों के लिए कॉन्ट्रैक्टिंग और बैच डाइमेंशन नंबर की अनुमति देता है.

DotडाइमेंशनNumbers फ़ील्ड	टाइप	सिमैंटिक
lhs_contracting_dimensions	रिपीटेड int64	lhs कॉन्ट्रैक्टिंग डाइमेंशन नंबर
rhs_contracting_dimensions	रिपीटेड int64	rhs कॉन्ट्रैक्टिंग डाइमेंशन नंबर
lhs_batch_dimensions	रिपीटेड int64	lhs बैच डाइमेंशन नंबर
rhs_batch_dimensions	रिपीटेड int64	rhs बैच डाइमेंशन नंबर

DotGeneral, dimension_numbers में दिए गए डाइमेंशन के आधार पर, प्रॉडक्ट के योग को दिखाता है.

lhs और rhs से असोसिएट किए गए कॉन्ट्रैक्टिंग डाइमेंशन के नंबर एक जैसे होने ज़रूरी नहीं हैं, लेकिन उनके डाइमेंशन साइज़ एक जैसे होने चाहिए.

कॉन्ट्रैक्टेड डाइमेंशन नंबर के साथ उदाहरण:

lhs = { {1.0, 2.0, 3.0},
{4.0, 5.0, 6.0} }

rhs = { {1.0, 1.0, 1.0},
{2.0, 2.0, 2.0} }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(1);
dnums.add_rhs_contracting_dimensions(1);

DotGeneral(lhs, rhs, dnums) -> { {6.0, 12.0},
{15.0, 30.0} }

lhs और rhs से जुड़े हुए बैच डाइमेंशन नंबर, एक जैसे डाइमेंशन साइज़ के होने चाहिए.

बैच डाइमेंशन नंबर (बैच साइज़ 2, 2x2 मैट्रिक्स) वाले उदाहरण:

lhs = { { {1.0, 2.0},
{3.0, 4.0} },
{ {5.0, 6.0},
{7.0, 8.0} } }

rhs = { { {1.0, 0.0},
{0.0, 1.0} },
{ {1.0, 0.0},
{0.0, 1.0} } }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(2);
dnums.add_rhs_contracting_dimensions(1);
dnums.add_lhs_batch_dimensions(0);
dnums.add_rhs_batch_dimensions(0);

DotGeneral(lhs, rhs, dnums) -> { { {1.0, 2.0},
{3.0, 4.0} },
{ {5.0, 6.0},
{7.0, 8.0} } }

इनपुट	आउटपुट	सिमैंटिक
[b0, m, k] dot [b0, k, n]	[b0, मीटर, n]	बैच मतमुल
[b0, b1, m, k] dot [b0, b1, k, n]	[b0, b1, m, n]	बैच मतमुल

इसके बाद, नतीजा मिलने वाला डाइमेंशन नंबर बैच डाइमेंशन से शुरू होता है. इसके बाद, lhs नॉन-कॉन्ट्रैक्टिंग/नॉन-बैच डाइमेंशन से, और आखिर में rhs नॉन-कॉन्ट्रैक्टिंग/नॉन-बैच डाइमेंशन से शुरू होता है.

DynamicSlice

XlaBuilder::DynamicSlice भी देखें.

DynamicSlice, डाइनैमिक start_indices में इनपुट ऐरे से सब-ऐरे को निकालता है. हर डाइमेंशन में स्लाइस का साइज़ size_indices में पास किया जाता है. इससे हर डाइमेंशन में स्लाइस के खास इंटरवल का आखिरी पॉइंट तय होता है: [शुरू, शुरुआत + साइज़). start_indices का आकार रैंक == 1 होना चाहिए, जिसमें डाइमेंशन का साइज़ operand की रैंक के बराबर होना चाहिए.

DynamicSlice(operand, start_indices, size_indices)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	T टाइप की N डाइमेंशन वाली अरे
start_indices	N XlaOp का क्रम	N स्केलर पूर्णांकों की सूची, जिसमें हर डाइमेंशन के लिए स्लाइस के शुरुआती इंडेक्स मौजूद हैं. वैल्यू, शून्य से ज़्यादा या उसके बराबर होनी चाहिए.
size_indices	ArraySlice<int64>	N पूर्णांक की सूची, जिसमें हर डाइमेंशन के लिए स्लाइस का साइज़ है. मॉड्यूलो डाइमेंशन के साइज़ को रैप किए जाने से रोकने के लिए, हर वैल्यू शून्य से ज़्यादा होनी चाहिए. साथ ही, शुरुआत + साइज़, डाइमेंशन के साइज़ से कम या उसके बराबर होना चाहिए.

असरदार स्लाइस इंडेक्स की गिनती करने के लिए, स्लाइस करने से पहले, [1, N) में हर इंडेक्स i के लिए यह ट्रांसफ़ॉर्मेशन लागू किया जाता है:

start_indices[i] = clamp(start_indices[i], 0, operand.dimension_size[i] - size_indices[i])

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

1-डाइमेंशन वाला उदाहरण:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
let s = {2}

DynamicSlice(a, s, {2}) produces:
{2.0, 3.0}

दो डाइमेंशन का उदाहरण:

let b =
{ {0.0,  1.0,  2.0},
{3.0,  4.0,  5.0},
{6.0,  7.0,  8.0},
{9.0, 10.0, 11.0} }
let s = {2, 1}

DynamicSlice(b, s, {2, 2}) produces:
{ { 7.0,  8.0},
{10.0, 11.0} }

DynamicUpdateSlice

XlaBuilder::DynamicUpdateSlice भी देखें.

DynamicUpdateSlice, ऐसा नतीजा जनरेट करता है जो इनपुट ऐरे operand की वैल्यू होती है. इसमें update स्लाइस को start_indices पर ओवरराइट किया जाता है. update का आकार, अपडेट किए गए नतीजे की सब-अरे का आकार तय करता है. start_indices का आकार, रैंक == 1 होना चाहिए. साथ ही, डाइमेंशन का साइज़ operand की रैंक के बराबर होना चाहिए.

DynamicUpdateSlice(operand, update, start_indices)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	T टाइप की N डाइमेंशन वाली अरे
update	XlaOp	T टाइप का N डाइमेंशन वाला अरे, जिसमें स्लाइस को अपडेट किया गया है. अपडेट के आकार का हर डाइमेंशन शून्य से ज़्यादा होना चाहिए. साथ ही, आउट-ऑफ़-बाउंड अपडेट इंडेक्स जनरेट होने से बचने के लिए, हर डाइमेंशन के लिए शुरू और अपडेट का साइज़, ऑपरेंड साइज़ से कम या उसके बराबर होना चाहिए.
start_indices	N XlaOp का क्रम	N स्केलर पूर्णांकों की सूची, जिसमें हर डाइमेंशन के लिए स्लाइस के शुरुआती इंडेक्स मौजूद हैं. वैल्यू, शून्य से ज़्यादा या उसके बराबर होनी चाहिए.

असरदार स्लाइस इंडेक्स की गिनती करने के लिए, स्लाइस करने से पहले, [1, N) में हर इंडेक्स i के लिए यह ट्रांसफ़ॉर्मेशन लागू किया जाता है:

start_indices[i] = clamp(start_indices[i], 0, operand.dimension_size[i] - update.dimension_size[i])

इससे यह पक्का होता है कि अपडेट किया गया स्लाइस, हमेशा ऑपरेंड अरे के हिसाब से इनबाउंड है. अगर स्लाइस, ट्रांसफ़ॉर्मेशन लागू होने से पहले सीमा में है, तो ट्रांसफ़ॉर्मेशन का कोई असर नहीं होगा.

1-डाइमेंशन वाला उदाहरण:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
let u = {5.0, 6.0}
let s = {2}

DynamicUpdateSlice(a, u, s) produces:
{0.0, 1.0, 5.0, 6.0, 4.0}

दो डाइमेंशन का उदाहरण:

let b =
{ {0.0,  1.0,  2.0},
{3.0,  4.0,  5.0},
{6.0,  7.0,  8.0},
{9.0, 10.0, 11.0} }
let u =
{ {12.0,  13.0},
{14.0,  15.0},
{16.0,  17.0} }

let s = {1, 1}

DynamicUpdateSlice(b, u, s) produces:
{ {0.0,  1.0,  2.0},
{3.0, 12.0, 13.0},
{6.0, 14.0, 15.0},
{9.0, 16.0, 17.0} }

एलिमेंट के हिसाब से बाइनरी अंकगणित की संक्रियाएं

XlaBuilder::Add भी देखें.

एलिमेंट के हिसाब से बाइनरी अंकगणितीय संक्रियाओं का एक सेट काम करता है.

Op(lhs, rhs)

जहां Op, Add (जोड़), Sub (सबट्रैक्शन), Mul (गुणा), Div (भाग), Rem (रेमेंडर), Max (ज़्यादा से ज़्यादा), Min (कम से कम), LogicalAnd (लॉजिकल AND) या LogicalOr (लॉजिकल OR) में से एक है.

तर्क	टाइप	सिमैंटिक
lhs	XlaOp	बाईं ओर मौजूद ऑपरेंड: T टाइप का अरे
rhs	XlaOp	दाईं ओर मौजूद ऑपर्ड: T प्रकार का अरे

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

जब Op Rem होता है, तो नतीजे का चिह्न भाजक से लिया जाता है और नतीजे की निरपेक्ष वैल्यू हमेशा भाजक के निरपेक्ष मान से कम होती है.

इंटिजर डिवीज़न ओवरफ़्लो (ज़ीरो से साइन किया गया/बिना हस्ताक्षर वाला डिवीज़न/शून्य से बचा हुआ/-1 के साथ INT_SMIN का साइन किया हुआ डिवीज़न/रि मेंडर) लागू करने से तय की गई वैल्यू जनरेट करता है.

इन ऑपरेशन के लिए, अलग-अलग रैंक पर ब्रॉडकास्ट करने की सुविधा वाला एक अन्य वैरिएंट मौजूद है:

Op(lhs, rhs, broadcast_dimensions)

जहां Op, जैसा कि ऊपर बताया गया है. ऑपरेशन के इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की रेंज के बीच अंकगणितीय संक्रियाओं (जैसे, वेक्टर में मैट्रिक्स जोड़ना) के लिए किया जाना चाहिए.

अतिरिक्त broadcast_dimensions ऑपरेंड, पूर्णांक का एक हिस्सा होता है. इसका इस्तेमाल, निचली रैंक वाले ऑपरेंड की रैंक को ज़्यादा रैंक वाले ऑपरैंड तक बढ़ाने के लिए किया जाता है. broadcast_dimensions कम रैंक वाले आकार के डाइमेंशन को ज़्यादा रैंक वाले आकार के डाइमेंशन से मैप करता है. बड़े किए गए आकार के मैप नहीं किए गए डाइमेंशन, पहले साइज़ वाले डाइमेंशन से भरे हुए होते हैं. डीजनरेट-डाइमेंशन ब्रॉडकास्टिंग इसके बाद, दोनों ऑपरेंड के शेप को बराबर करने के लिए, इन डिजनरेट डाइमेंशन के साथ आकार को ब्रॉडकास्ट करता है. ब्रॉडकास्ट करने वाले पेज पर, इसके बारे में विस्तार से जानकारी दी गई है.

एलिमेंट के हिसाब से तुलना करने की कार्रवाइयां

XlaBuilder::Eq भी देखें.

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

Op(lhs, rhs)

जहां Op, Eq में से कोई एक है (इसके बराबर है), Ne (इसके बराबर नहीं है), Ge (इससे ज़्यादा या इससे ज़्यादा), Gt (इससे ज़्यादा), Le (इससे कम), Lt (इससे कम). EqTotalOrder, NeTotalOrder, GeTotalOrder, GtTotalOrder, LeTotalOrder, GeTotalOrder, GtTotalOrder, LeTotalOrder, और LtTotalOrder . एक जैसे

तर्क	टाइप	सिमैंटिक
lhs	XlaOp	बाईं ओर मौजूद ऑपरेंड: T टाइप का अरे
rhs	XlaOp	दाईं ओर मौजूद ऑपर्ड: T प्रकार का अरे

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

इन ऑपरेशन के लिए, अलग-अलग रैंक पर ब्रॉडकास्ट करने की सुविधा वाला एक अन्य वैरिएंट मौजूद है:

Op(lhs, rhs, broadcast_dimensions)

जहां Op, जैसा कि ऊपर बताया गया है. ऑपरेशन के इस वैरिएंट का इस्तेमाल अलग-अलग रैंक के अरे के बीच तुलना करने के लिए किया जाना चाहिए (जैसे कि वेक्टर में मैट्रिक्स जोड़ना).

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

एलिमेंट के हिसाब से यूनरी फ़ंक्शन

XlaBuilder से, एलिमेंट के हिसाब से एक सिंगल फ़ंक्शन इस्तेमाल किया जा सकता है:

Abs(operand) एलिमेंट के हिसाब से abs x -> |x|.

Ceil(operand) एलिमेंट के हिसाब से सेल x -> ⌈x⌉.

Cos(operand) एलिमेंट के हिसाब से कोसाइन x -> cos(x).

Exp(operand) एलिमेंट के हिसाब से नैचुरल एक्सपोनेन्शियल x -> e^x.

Floor(operand) एलिमेंट के हिसाब से फ़्लोर x -> ⌊x⌋.

Imag(operand) एलिमेंट के हिसाब से, कॉम्प्लेक्स (या असली) आकार का काल्पनिक हिस्सा. x -> imag(x). अगर ऑपरेंड कोई फ़्लोटिंग पॉइंट टाइप है, तो वैल्यू 0 दिखती है.

IsFinite(operand) जांच करता है कि operand का हर एलिमेंट सीमित है या नहीं. जैसे, यह पॉज़िटिव या नेगेटिव अनंत संख्या नहीं है और NaN नहीं है. इनपुट के आकार वाले PRED वैल्यू का अरे दिखाता है. इसमें हर एलिमेंट true होता है, अगर और सिर्फ़ तब, जब संबंधित इनपुट एलिमेंट सीमित हो.

Log(operand) एलिमेंट के हिसाब से नैचुरल लॉगारिद्म x -> ln(x).

LogicalNot(operand) एलिमेंट के हिसाब से लॉजिकल लॉजिकल नहीं x -> !(x) है.

Logistic(operand) एलिमेंट के हिसाब से लॉजिस्टिक फ़ंक्शन का कैलकुलेशन x -> logistic(x).

PopulationCount(operand), operand के हर एलिमेंट में सेट बिट की संख्या का हिसाब लगाता है.

Neg(operand) एलिमेंट के हिसाब से निगेशन x -> -x.

Real(operand) एलिमेंट के हिसाब से, कॉम्प्लेक्स (या रीयल) शेप का असली हिस्सा. x -> real(x). अगर ऑपरेंड कोई फ़्लोटिंग पॉइंट टाइप है, तो वही वैल्यू दिखाता है.

Rsqrt(operand) एलिमेंट के हिसाब से स्क्वेयर रूट की कार्रवाई का व्युत्क्रम x -> 1.0 / sqrt(x).

Sign(operand) एलिमेंट के हिसाब से चिह्न ऑपरेशन x -> sgn(x) जहां

\[\text{sgn}(x) = \begin{cases} -1 & x < 0\\ -0 & x = -0\\ NaN & x = NaN\\ +0 & x = +0\\ 1 & x > 0 \end{cases}\]

operand के एलिमेंट टाइप के तुलना ऑपरेटर का इस्तेमाल करके.

Sqrt(operand) एलिमेंट के हिसाब से स्क्वेयर रूट की कार्रवाई x -> sqrt(x).

Cbrt(operand) एलिमेंट के हिसाब से क्यूबिक रूट की कार्रवाई x -> cbrt(x).

Tanh(operand) एलिमेंट के हिसाब से हाइपरबोलिक टैंजेंट x -> tanh(x).

Round(operand) एलिमेंट के हिसाब से राउंडिंग, शून्य से दूर है.

RoundNearestEven(operand) एलिमेंट के हिसाब से राउंडिंग, सबसे नज़दीकी ईवन से बंधता है.

तर्क	टाइप	सिमैंटिक
operand	XlaOp	फ़ंक्शन का ऑपरेंड

फ़ंक्शन, operand अरे में हर एलिमेंट पर लागू किया जाता है, जिससे एक ही आकार वाली ऐरे बनती है. operand को अदिश (रैंक 0) बनाने की अनुमति है.

एफ़एफ़टी

XLA FFT ऑपरेशन में, रीयल और कॉम्प्लेक्स इनपुट/आउटपुट के लिए, फ़ॉरवर्ड और इनवर्स फ़ोरियर ट्रांसफ़ॉर्म लागू किए जाते हैं. ज़्यादा से ज़्यादा तीन ऐक्सिस पर, कई डाइमेंशन वाले एफ़एफ़टी इस्तेमाल किए जा सकते हैं.

XlaBuilder::Fft भी देखें.

तर्क	टाइप	सिमैंटिक
operand	XlaOp	वह अरे जिसमें हम फूर्ये बदल रहे हैं.
fft_type	FftType	नीचे दी गई टेबल देखें.
fft_length	ArraySlice<int64>	ऐक्सिस की टाइम-डोमेन लंबाई, बदली जा रही है. खास तौर पर, आईआरएफ़एफ़टी के लिए यह ज़रूरी है, ताकि सबसे अंदर वाले ऐक्सिस को सही साइज़ दिया जा सके. इसकी वजह यह है कि RFFT(fft_length=[16]) के आउटपुट का आकार RFFT(fft_length=[17]) के जैसा ही होता है.

FftType	सिमैंटिक
FFT	कॉम्प्लेक्स-टू-कॉम्प्लेक्स एफ़एफ़टी की सुविधा को फ़ॉरवर्ड करें. आकार में कोई बदलाव नहीं हुआ है.
IFFT	इनवर्स कॉम्प्लेक्स-टू-कॉम्प्लेक्स एफ़एफ़टी. आकार में कोई बदलाव नहीं हुआ है.
RFFT	रीयल-टू-कॉम्प्लेक्स एफ़एफ़टी को फ़ॉरवर्ड करें. अगर fft_length[-1] शून्य के अलावा किसी और वैल्यू पर सेट है, तो सबसे अंदर वाले ऐक्सिस का आकार fft_length[-1] // 2 + 1 तक कम कर दिया जाता है. ऐसा करने से, Nyquist फ़्रीक्वेंसी के अलावा, बदले गए सिग्नल के उलटा संयुग्मी हिस्से को हटा दिया जाता है.
IRFFT	इनवर्स रियल-टू-कॉम्प्लेक्स एफ़एफ़टी (उदाहरण के लिए, यह जटिल होता है, लेकिन नतीजे के तौर पर सटीक होता है). अगर fft_length[-1] की वैल्यू शून्य नहीं है, तो सबसे अंदरूनी ऐक्सिस का आकार fft_length[-1] तक बढ़ाया जाता है. यह वैल्यू, नाइक्विस्ट फ़्रीक्वेंसी के अलावा, बदले गए सिग्नल के हिस्से का अनुमान 1 से fft_length[-1] // 2 + 1 एंट्री के रिवर्स कॉन्जुगेट से पता लगाती है.

बहुआयामी एफ़एफ़टी

जब 1 से ज़्यादा fft_length दिए जाते हैं, तो यह सबसे अंदरूनी ऐक्सिस पर एफ़एफ़टी ऑपरेशन के कैस्केड लागू करने के बराबर होता है. ध्यान दें कि रीयल->जटिल और कॉम्प्लेक्स->रीयल केस में, सबसे अंदरूनी ऐक्सिस ट्रांसफ़ॉर्म (असरदार तरीके से) पहले (आरएफ़एफ़टी; आखिरी आईआरएफ़एफ़टी) किया जाता है. इसलिए, सबसे अंदरूनी ऐक्सिस वही है जो साइज़ में बदलाव करता है. फिर अन्य ऐक्सिस में बदलाव जटिल->जटिल होगा.

क्रियान्वयन विवरण

सीपीयू एफ़एफ़टी, Eigen के TensorFFT पर काम करता है. जीपीयू FFT, cuFFT का इस्तेमाल करता है.

इकट्ठा करें

XLA की मदद से, किसी इनपुट अरे के कई स्लाइस (हर स्लाइस, संभावित रूप से अलग रनटाइम ऑफ़सेट पर) को एक साथ इकट्ठा करते हैं.

सामान्य सिमैंटिक

XlaBuilder::Gather भी देखें. ज़्यादा आसान जानकारी के लिए, नीचे दिया गया "सूचना देने वाली जानकारी" सेक्शन देखें.

gather(operand, start_indices, offset_dims, collapsed_slice_dims, slice_sizes, start_index_map)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	वह कलेक्शन जहां से हम इकट्ठा कर रहे हैं.
start_indices	XlaOp	वह कलेक्शन जिसमें हमारे इकट्ठा किए गए स्लाइस के शुरुआती इंडेक्स मौजूद हैं.
index_vector_dim	int64	start_indices में मौजूद डाइमेंशन, जिसमें शुरुआती इंडेक्स "शामिल हैं". ज़्यादा जानकारी के लिए नीचे देखें.
offset_dims	ArraySlice<int64>	आउटपुट आकार में डाइमेंशन का सेट, जो ऑपरेंड से स्लाइस की गई अरे में ऑफ़सेट होता है.
slice_sizes	ArraySlice<int64>	slice_sizes[i], डाइमेंशन i में स्लाइस की सीमाएं है.
collapsed_slice_dims	ArraySlice<int64>	हर स्लाइस में मौजूद डाइमेंशन का सेट, जिसे छोटा किया गया है. इन डाइमेंशन का साइज़ 1 होना चाहिए.
start_index_map	ArraySlice<int64>	ऐसा मैप जिसमें start_indices के इंडेक्स को कानूनी इंडेक्स से मैप करने का तरीका बताया गया है.
indices_are_sorted	bool	क्या इंडेक्स, कॉलर के हिसाब से क्रम में लगाए जाने की गारंटी है.

सुविधा के लिए, हम आउटपुट कलेक्शन में मौजूद डाइमेंशन को offset_dims में नहीं, बल्कि batch_dims के तौर पर लेबल करते हैं.

आउटपुट, batch_dims.size + offset_dims.size रैंक का कलेक्शन है.

operand.rank, offset_dims.size और collapsed_slice_dims.size के योग के बराबर होना चाहिए. साथ ही, slice_sizes.size, operand.rank के बराबर होना चाहिए.

अगर index_vector_dim, start_indices.rank के बराबर है, तो हम अनुमान के हिसाब से start_indices के बाद वाला 1 डाइमेंशन मानते हैं. उदाहरण के लिए, अगर start_indices का आकार [6,7] और index_vector_dim 2 है, तो हम अनुमान के आधार पर start_indices के आकार को [6,7,1] मानते हैं.

i डाइमेंशन के साथ, आउटपुट कलेक्शन के लिए बाउंड की गिनती इस तरह से की जाती है:

1. अगर i, batch_dims में मौजूद है (यानी कि कुछ k के लिए batch_dims[k] के बराबर है) तो हम start_indices.shape में से, संबंधित डाइमेंशन चुनते हैं. अगर k < index_vector_dim है और start_indices.shape.dims[k+1] है, तो index_vector_dim को छोड़कर आगे बढ़ जाते हैं.kstart_indices.shape.dims

2. अगर i, offset_dims में मौजूद है (जैसे कि कुछ k के लिए, offset_dims[k] के बराबर) तो हम collapsed_slice_dims को शामिल करने के बाद, slice_sizes से जुड़ा बाउंड्री चुन लेते हैं. उदाहरण के लिए, हम adjusted_slice_sizes[k] को चुनते हैं, जहां adjusted_slice_sizes, slice_sizes है और इंडेक्स collapsed_slice_dims की सीमाएं हटा दी गई हैं.

आधिकारिक तौर पर, दिए गए आउटपुट इंडेक्स Out से जुड़े ऑपरेंड इंडेक्स In का हिसाब इस तरह लगाया जाता है:

1. मान लें कि batch_dims में k के लिए, G = { Out[k] है. वेक्टर S को इस तरह स्लाइस करने के लिए G का इस्तेमाल करें S[i] = start_indices[मिलाएं(G, i)], जहां मिलाएं(A, b) b को स्थिति index_vector_dim पर A में डाल देता है. ध्यान दें कि G के खाली होने पर भी यह अच्छी तरह से समझा जा सकता है: अगर G खाली है, तो S = start_indices.

2. start_index_map का इस्तेमाल करके S को स्कैटर करके, S का इस्तेमाल करके operand में शुरुआती इंडेक्स Sin बनाएं. ज़्यादा सटीक जानकारी दें:

   1. Sin[start_index_map[k]] = S[k] अगर k < start_index_map.size है.

   2. Sin[_] = 0 अन्य मामलों में.

3. collapsed_slice_dims सेट के हिसाब से, Out में ऑफ़सेट डाइमेंशन में इंडेक्स को बिखेरकर, operand में Oin इंडेक्स बनाएं. ज़्यादा सटीक जानकारी दें:

   1. Oin[remapped_offset_dims(k)] = Out[offset_dims[k]] अगर k < offset_dims.size (remapped_offset_dims के बारे में नीचे बताया गया है).

   2. Oin[_] = 0 अन्य मामलों में.

4. In, Oin + Sin है, जहां +, एलिमेंट के हिसाब से जोड़ है.

remapped_offset_dims एक मोनोटोनिक फ़ंक्शन है, जिसका डोमेन [0, offset_dims.size) और रेंज [0, operand.rank) \ collapsed_slice_dims है. तो अगर, जैसे, offset_dims.size, 4 है, operand.rank 6 है, और collapsed_slice_dims {0, 2} है, तो remapped_offset_dims {0→1, 1→3, 2→4, 3→5} है.

अगर indices_are_sorted को 'सही है' पर सेट किया जाता है, तो XLA यह मान सकता है कि उपयोगकर्ता ने start_indices को बढ़ते हुए start_index_map क्रम में लगाया है. अगर ऐसा नहीं है, तो सिमेंटिक्स लागू किया जाता है.

अनौपचारिक ब्यौरा और उदाहरण

आम तौर पर, आउटपुट कलेक्शन का हर इंडेक्स Out, ऑपरेंड अरे में, एलिमेंट E से मेल खाता है, जिसकी गिनती इस तरह की जाती है:

• हम start_indices से शुरुआती इंडेक्स खोजने के लिए, Out में बैच डाइमेंशन का इस्तेमाल करते हैं.

• हम शुरुआती इंडेक्स (जिसका साइज़ ऑपरेंड.रैंक से कम हो सकता है) को operand में, "फ़ुल" शुरुआती इंडेक्स से मैप करने के लिए start_index_map का इस्तेमाल करते हैं.

• हम पूरे शुरुआती इंडेक्स का इस्तेमाल करके, slice_sizes साइज़ वाले स्लाइस को डाइनैमिक तरीके से बदलते हैं.

• हम collapsed_slice_dims डाइमेंशन को छोटा करके, स्लाइस का आकार बदलते हैं. छोटे किए गए सभी स्लाइस डाइमेंशन की सीमा 1 होनी चाहिए, इसलिए यह नया आकार हमेशा कानूनी होता है.

• हम इस स्लाइस में इंडेक्स करने के लिए, Out में ऑफ़सेट डाइमेंशन का इस्तेमाल करते हैं. इससे, आउटपुट इंडेक्स Out से जुड़े इनपुट एलिमेंट E को पाने में मदद मिलती है.

इसके बाद के सभी उदाहरणों में, index_vector_dim को start_indices.rank - 1 पर सेट किया गया है. index_vector_dim के लिए ज़्यादा दिलचस्प वैल्यू, काम करने के तरीके में आम तौर पर कोई बदलाव नहीं करती हैं. हालांकि, विज़ुअल प्रज़ेंटेशन की वजह से काम करना ज़्यादा मुश्किल हो जाता है.

यह जानने के लिए कि ऊपर दी गई सभी चीज़ें एक साथ कैसे फ़िट होती हैं, आइए एक उदाहरण देखते हैं जिसमें [16,11] कलेक्शन से [8,6] आकार के पांच स्लाइस इकट्ठा किए जाते हैं. [16,11] अरे में स्लाइस की स्थिति को S64[2] आकार के इंडेक्स वेक्टर के रूप में दिखाया जा सकता है. इसलिए, पांच स्थितियों के सेट को S64[5,2] अरे के तौर पर दिखाया जा सकता है.

कलेक्ट करने की कार्रवाई को इंडेक्स ट्रांसफ़ॉर्मेशन के तौर पर दिखाया जा सकता है. इसमें [G,O0,O1] आउटपुट शेप का इंडेक्स होता है. साथ ही, इसे इनपुट ऐरे में किसी एलिमेंट में मैप करने के लिए, इस तरीके का इस्तेमाल किया जाता है:

हम सबसे पहले G का इस्तेमाल करके, इंडेक्स इकट्ठा करें कलेक्शन से (X,Y) वेक्टर चुनते हैं. इंडेक्स [G,O0,O1] के आउटपुट कलेक्शन में मौजूद एलिमेंट, इंडेक्स [X+O0,Y+O1] के इनपुट कलेक्शन का एलिमेंट है.

slice_sizes, [8,6] है, जो O₀ और O₁ की रेंज तय करता है. इसके बाद, यह स्लाइस की सीमाएं तय करता है.

यह इकट्ठा करने की कार्रवाई, बैच डाइमेंशन के तौर पर G के साथ बैच डाइनैमिक स्लाइस के तौर पर काम करती है.

इकट्ठा किए गए इंडेक्स कई डाइमेंशन वाले हो सकते हैं. उदाहरण के लिए, [4,5,2] आकार की "इकट्ठा किए गए इंडेक्स" अरे का इस्तेमाल करके, ऊपर दिए गए उदाहरण का ज़्यादा सामान्य वर्शन, इस तरह के इंडेक्स का अनुवाद करेगा:

फिर से, यह बैच डाइमेंशन के तौर पर, बैच डाइनैमिक स्लाइस G0 और G1 के तौर पर काम करता है. स्लाइस का साइज़ अब भी [8,6] है.

XLA में कलेक्ट करने की कार्रवाई, ऊपर बताए गए अनौपचारिक सिमैंटिक को सामान्य बनाती है. ये सिमेंटिक इन तरीकों से किए जाते हैं:

1. हम यह कॉन्फ़िगर कर सकते हैं कि आउटपुट शेप में कौनसे डाइमेंशन, ऑफ़सेट डाइमेंशन हैं. आखिरी उदाहरण में, वे डाइमेंशन जिनमें O0, O1 शामिल हैं. आउटपुट बैच डाइमेंशन (पिछले उदाहरण में G0, G1 वाले डाइमेंशन), ऐसे आउटपुट डाइमेंशन के तौर पर तय किए जाते हैं जो ऑफ़सेट डाइमेंशन नहीं होते.

2. आउटपुट आकार में साफ़ तौर पर मौजूद आउटपुट ऑफ़सेट डाइमेंशन की संख्या, इनपुट रैंक से कम हो सकती है. इन "वैल्यू मौजूद नहीं है" डाइमेंशन, साफ़ तौर पर collapsed_slice_dims के तौर पर लिस्ट किए गए हैं. इनका स्लाइस साइज़ 1 होना चाहिए. इनमें 1 का स्लाइस साइज़ है, इसलिए उनके लिए सिर्फ़ 0 ही इंडेक्स है और उन्हें हटाने से साफ़ तौर पर जानकारी नहीं मिलती.

3. आखिरी उदाहरण में "इकट्ठा किए गए इंडेक्स" अरे (X, Y) से निकाले गए स्लाइस में, इनपुट ऐरे रैंक की तुलना में कम एलिमेंट हो सकते हैं. साथ ही, साफ़ तौर पर मैप करने से यह तय होता है कि इनपुट की रैंक के लिए इंडेक्स को कैसे बड़ा किया जाना चाहिए.

आखिरी उदाहरण के तौर पर, हम (2) और (3) का इस्तेमाल, tf.gather_nd को लागू करने के लिए करते हैं:

G0 और G1 का इस्तेमाल, इकट्ठा किए गए इंडेक्स के कलेक्शन से शुरुआती इंडेक्स को अलग करने के लिए किया जाता है. हालांकि, शुरुआती इंडेक्स में सिर्फ़ एक एलिमेंट X होता है. इसी तरह, O0 वैल्यू वाला सिर्फ़ एक आउटपुट ऑफ़सेट इंडेक्स है. हालांकि, इनपुट अरे में इंडेक्स के तौर पर इस्तेमाल किए जाने से पहले, इन्हें "मैपिंग इकट्ठा करें" (औपचारिक ब्यौरे में start_index_map) और "ऑफ़सेट मैपिंग" (remapped_offset_dims औपचारिक जानकारी में remapped_offset_dims) के मुताबिक [X,0] और [0,O0] के हिसाब से बड़ा किया जाता है. G_{111,G11 इंडेक्स को मिले हुए इंडेक्स में,G1 किसीG,G1,X000000OOO}GatherIndicestf.gather_nd

इस केस के लिए slice_sizes, [1,11] है. इसका मतलब यह है कि इकट्ठा इंंडेक्स कलेक्शन में मौजूद हर इंडेक्स X में एक पूरी लाइन चुनी जाती है. इस वजह से, इन सभी पंक्तियों को जोड़कर एक लाइन बनाई जाती है.

GetDimensionSize

XlaBuilder::GetDimensionSize भी देखें.

ऑपरेंड के दिए गए डाइमेंशन का साइज़ दिखाता है. ऑपरेंड को अरे के आकार का होना चाहिए.

GetDimensionSize(operand, dimension)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	n डाइमेंशन वाले इनपुट अरे
dimension	int64	[0, n) इंटरवल में ऐसी वैल्यू जो डाइमेंशन की जानकारी देती है

SetDimensionSize

XlaBuilder::SetDimensionSize भी देखें.

XlaOp के डाइमेंशन का डाइनैमिक साइज़ सेट करता है. ऑपरेंड को अरे के आकार का होना चाहिए.

SetDimensionSize(operand, size, dimension)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	n डाइमेंशन वाले इनपुट ऐरे.
size	XlaOp	int32 रनटाइम के डाइनैमिक साइज़ को दिखाता है.
dimension	int64	[0, n) इंटरवल में मौजूद कोई वैल्यू, जो डाइमेंशन की जानकारी देती है.

कंपाइलर के ज़रिए ट्रैक किए जाने वाले डाइनैमिक डाइमेंशन के साथ, ऑपरेंड को पास करें.

डाउनस्ट्रीम कम करने वाले ऑपरेशन से, पेड की गई वैल्यू को अनदेखा कर दिया जाएगा.

let v: f32[10] = f32[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
let five: s32 = 5;
let six: s32 = 6;

// Setting dynamic dimension size doesn't change the upper bound of the static
// shape.
let padded_v_five: f32[10] = set_dimension_size(v, five, /*dimension=*/0);
let padded_v_six: f32[10] = set_dimension_size(v, six, /*dimension=*/0);

// sum == 1 + 2 + 3 + 4 + 5
let sum:f32[] = reduce_sum(padded_v_five);
// product == 1 * 2 * 3 * 4 * 5
let product:f32[] = reduce_product(padded_v_five);

// Changing padding size will yield different result.
// sum == 1 + 2 + 3 + 4 + 5 + 6
let sum:f32[] = reduce_sum(padded_v_six);

GetTupleElement

XlaBuilder::GetTupleElement भी देखें.

कंपाइल-टाइम-कॉन्सटेंट वैल्यू के साथ टपल में इंडेक्स करता है.

वैल्यू, कंपाइल-टाइम-कॉन्सटेंट होनी चाहिए, ताकि आकार का अनुमान यह तय कर सके कि मिलने वाली वैल्यू किस तरह की है.

यह C++ में std::get<int N>(t) के जैसा है. सैद्धान्तिक तौर पर:

let v: f32[10] = f32[10]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
let s: s32 = 5;
let t: (f32[10], s32) = tuple(v, s);
let element_1: s32 = gettupleelement(t, 1);  // Inferred shape matches s32.

tf.tuple भी देखें.

इनफ़ीड

XlaBuilder::Infeed भी देखें.

Infeed(shape)

आर्ग्यूमेंट	टाइप	सिमैंटिक
shape	Shape	इनफ़ीड इंटरफ़ेस से पढ़े गए डेटा का आकार. आकार की लेआउट फ़ील्ड को डिवाइस पर भेजे गए डेटा के लेआउट से मैच कराने के लिए सेट किया जाना चाहिए. ऐसा न होने पर, इसका व्यवहार तय नहीं होता.

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

result1 = while (condition, init = init_value) {
  Infeed(shape)
}

result2 = while (condition, init = result1) {
  Infeed(shape)
}

नेस्ट किए गए टपल आकार काम नहीं करते. खाली टपल के आकार के लिए, इनफ़ीड ऑपरेशन में कोई ऑपरेशन नहीं होता है और डिवाइस के इनफ़ीड से किसी भी डेटा को पढ़े बिना आगे बढ़ जाता है.

आयोटा

XlaBuilder::Iota भी देखें.

Iota(shape, iota_dimension)

यह संभावित रूप से बड़े होस्ट ट्रांसफ़र के बजाय डिवाइस पर एक स्थायी लिटरल बनाता है. यह एक ऐसा कलेक्शन बनाता है जिसमें तय आकार होता है. साथ ही, इसमें वैल्यू को शून्य से शुरू करके, किसी डाइमेंशन के साथ एक वैल्यू को बढ़ाया जाता है. फ़्लोटिंग-पॉइंट टाइप के लिए, बनाया गया अरे ConvertElementType(Iota(...)) के बराबर होता है, जहां Iota इंटिग्रल टाइप और कन्वर्ज़न फ़्लोटिंग-पॉइंट टाइप में होता है.

तर्क	टाइप	सिमैंटिक
shape	Shape	Iota() के बनाए गए कलेक्शन का आकार
iota_dimension	int64	वह डाइमेंशन जिसे साथ-साथ बढ़ाना है.

उदाहरण के लिए, Iota(s32[4, 8], 0) की मदद से प्रॉडक्ट को लौटाया जा सकता है

  [[0, 0, 0, 0, 0, 0, 0, 0 ],
   [1, 1, 1, 1, 1, 1, 1, 1 ],
   [2, 2, 2, 2, 2, 2, 2, 2 ],
   [3, 3, 3, 3, 3, 3, 3, 3 ]]

Iota(s32[4, 8], 1) तक के प्रॉडक्ट लौटाएं

  [[0, 1, 2, 3, 4, 5, 6, 7 ],
   [0, 1, 2, 3, 4, 5, 6, 7 ],
   [0, 1, 2, 3, 4, 5, 6, 7 ],
   [0, 1, 2, 3, 4, 5, 6, 7 ]]

मैप

XlaBuilder::Map भी देखें.

Map(operands..., computation)

तर्क	टाइप	सिमैंटिक
operands	N XlaOp सेकंड का क्रम	T0..T{N-1} टाइप की N कैटगरी
computation	XlaComputation	आर्बिट्रेरी टाइप के T और M टाइप के N पैरामीटर के साथ, T_0, T_1, .., T_{N + M -1} -> S टाइप की कैलकुलेशन
dimensions	int64 कलेक्शन	मैप डाइमेंशन का अरे

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

मैप किया गया फ़ंक्शन, पाबंदी के साथ आर्बिट्रेरी कैलकुलेशन है, जिसमें स्केलर टाइप T के N इनपुट और S टाइप का एक आउटपुट है. आउटपुट में वही डाइमेंशन होते हैं जो ऑपरेंड में होते हैं. हालांकि, एलिमेंट टाइप T को S से बदला जाता है.

उदाहरण के लिए: आउटपुट अरे बनाने के लिए, Map(op1, op2, op3, computation, par1), इनपुट ऐरे में हर (मल्टी-डाइमेंशन) इंडेक्स पर elem_out <- computation(elem1, elem2, elem3, par1) को मैप करता है.

OptimizationBarrier

यह फ़ंक्शन किसी भी ऑप्टिमाइज़ेशन पास को रुकावट के बीच कंप्यूटेशन ले जाने से रोकता है.

यह पक्का करता है कि सभी इनपुट का आकलन, रुकावट के आउटपुट पर निर्भर किसी भी ऑपरेटर से पहले किया जाए.

पैड

XlaBuilder::Pad भी देखें.

Pad(operand, padding_value, padding_config)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	T टाइप का कलेक्शन
padding_value	XlaOp	जोड़ी गई पैडिंग (जगह) भरने के लिए T टाइप का स्केलर
padding_config	PaddingConfig	हर डाइमेंशन के एलिमेंट के दोनों किनारों (कम, ज़्यादा) और एलिमेंट के बीच पैडिंग की रकम

दिए गए operand अरे को अरे के आस-पास पैडिंग (जगह) और दिए गए padding_value के एलिमेंट के बीच बड़ा करता है. padding_config हर डाइमेंशन के लिए, किनारे की पैडिंग और अंदरूनी पैडिंग की संख्या बताता है.

PaddingConfig, PaddingConfigDimension का दोहराया गया फ़ील्ड है, जिसमें हर डाइमेंशन के लिए तीन फ़ील्ड होते हैं: edge_padding_low, edge_padding_high, और interior_padding.

edge_padding_low और edge_padding_high हर डाइमेंशन के लो-एंड (इंडेक्स 0 के बगल में) पर जोड़ी गई पैडिंग की संख्या और सबसे ज़्यादा इंडेक्स के बगल में जोड़ी गई पैडिंग की संख्या बताते हैं. एज पैडिंग की मात्रा नेगेटिव हो सकती है -- नेगेटिव पैडिंग की कुल वैल्यू, तय किए गए डाइमेंशन से हटाए जाने वाले एलिमेंट की संख्या दिखाती है.

interior_padding हर डाइमेंशन में, किसी भी दो एलिमेंट के बीच जोड़ी गई पैडिंग की संख्या तय करता है; यह नेगेटिव नहीं हो सकता. इंटीरियर पैडिंग (जगह) की वैल्यू, एज पैडिंग (जगह) से पहले की होती है. इसलिए, नेगेटिव एज पैडिंग के मामले में, एलिमेंट को इंटरनल पैडिंग से हटा दिया जाता है.

अगर एज पैडिंग (जगह) के सभी जोड़े (0, 0) हैं और अंदरूनी पैडिंग (जगह) की सभी वैल्यू 0 हैं, तो यह कार्रवाई ज़रूरी नहीं है. नीचे की इमेज में दो डाइमेंशन वाले अरे के लिए, अलग-अलग edge_padding और interior_padding वैल्यू के उदाहरण दिए गए हैं.

Recv

XlaBuilder::Recv भी देखें.

Recv(shape, channel_handle)

तर्क	टाइप	सिमैंटिक
shape	Shape	पाने के लिए डेटा का आकार
channel_handle	ChannelHandle	भेजने/recv के हर जोड़े के लिए यूनीक आइडेंटिफ़ायर

उसी चैनल हैंडल को शेयर करने वाले किसी अन्य कंप्यूटेशन में दिए गए Send निर्देश से, दिए गए आकार का डेटा लेता है. मिले डेटा के लिए XlaOp दिखाता है.

Recv ऑपरेशन का क्लाइंट एपीआई, सिंक्रोनस कम्यूनिकेशन दिखाता है. हालांकि, एसिंक्रोनस डेटा ट्रांसफ़र को चालू करने के लिए, निर्देश को अंदरूनी तौर पर दो एचएलओ निर्देशों (Recv और RecvDone) में बांट दिया गया है. HloInstruction::CreateRecv और HloInstruction::CreateRecvDone भी देखें.

Recv(const Shape& shape, int64 channel_id)

एक ही channel_id के साथ, Send निर्देश से डेटा पाने के लिए ज़रूरी संसाधन बांटता है. दिए गए संसाधनों का संदर्भ देता है, जिसका इस्तेमाल नीचे दिए गए RecvDone निर्देश के मुताबिक डेटा ट्रांसफ़र की प्रक्रिया पूरी होने का इंतज़ार करने के लिए करता है. कॉन्टेक्स्ट, {receive buffer (ऐप्लिकेशन), अनुरोध आइडेंटिफ़ायर (U32)} का टपल है और इसका इस्तेमाल सिर्फ़ RecvDone निर्देश की मदद से किया जा सकता है.

RecvDone(HloInstruction context)

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

फैलने से रोकना

XlaBuilder::Reduce भी देखें.

समांतर में एक या उससे ज़्यादा सरणियों पर छोटा करने वाला फ़ंक्शन लागू करता है.

Reduce(operands..., init_values..., computation, dimensions)

तर्क	टाइप	सिमैंटिक
operands	N XlaOp का क्रम	T_0, ..., T_{N-1} टाइप की N कैटगरी.
init_values	N XlaOp का क्रम	T_0, ..., T_{N-1} टाइप के N स्केलर.
computation	XlaComputation	T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}) टाइप की गणना.
dimensions	int64 कलेक्शन	डाइमेंशन की बिना क्रम वाली अरे का इस्तेमाल किया जा सकता है.

जगह:

• N का मान 1 से बड़ा या उसके बराबर होना ज़रूरी है.
• कंप्यूटेशन को "मोटे तौर पर" असोसिएट होना चाहिए (नीचे देखें).
• सभी इनपुट ऐरे के डाइमेंशन एक जैसे होने चाहिए.
• सभी शुरुआती वैल्यू को computation के तहत एक आइडेंटिटी बनानी होगी.
• अगर N = 1, तो Collate(T), T होता है.
• अगर N > 1, तो Collate(T_0, ..., T_{N-1}) T टाइप के N एलिमेंट का एक टपल है.

यह कार्रवाई हर इनपुट ऐरे के एक या उससे ज़्यादा डाइमेंशन को स्केलर में कम कर देती है. दिखाए गए हर कलेक्शन की रैंक rank(operand) - len(dimensions) है. ऑप का आउटपुट Collate(Q_0, ..., Q_N) है, जहां Q_i, T_i टाइप का कलेक्शन है. इनके डाइमेंशन के बारे में नीचे बताया गया है.

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

उदाहरण

रिडक्शन फ़ंक्शन f (यह computation है) के साथ [10, 11, 12, 13] वैल्यू वाली सिंगल 1D कलेक्शन में किसी एक डाइमेंशन को कम करते समय, इसकी गणना इस तरह की जा सकती है

f(10, f(11, f(12, f(init_value, 13)))

लेकिन कई अन्य संभावनाएं भी होती हैं, जैसे

f(init_value, f(f(10, f(init_value, 11)), f(f(init_value, 12), f(init_value, 13))))

नीचे दिया गया हूबहू एक छद्म कोड उदाहरण है. इसमें बताया गया है कि कमी को कैसे लागू किया जा सकता है. इसके लिए, योग का इस्तेमाल 0 की शुरुआती वैल्यू के साथ कम करने की गणना के तौर पर करें.

result_shape <- remove all dims in dimensions from operand_shape

# Iterate over all elements in result_shape. The number of r's here is equal
# to the rank of the result
for r0 in range(result_shape[0]), r1 in range(result_shape[1]), ...:
  # Initialize this result element
  result[r0, r1...] <- 0

  # Iterate over all the reduction dimensions
  for d0 in range(dimensions[0]), d1 in range(dimensions[1]), ...:
    # Increment the result element with the value of the operand's element.
    # The index of the operand's element is constructed from all ri's and di's
    # in the right order (by construction ri's and di's together index over the
    # whole operand shape).
    result[r0, r1...] += operand[ri... di]

यहां 2D अरे (मैट्रिक्स) को कम करने का एक उदाहरण दिया गया है. आकृति की रैंक 2 है, आकार 2 का आयाम 0 है और आकार 3 का आयाम 1 है:

"जोड़ें" फ़ंक्शन की मदद से, डाइमेंशन 0 या 1 को कम करने के नतीजे:

ध्यान दें कि कम करने के दोनों नतीजे 1D अरे हैं. इस डायग्राम में, एक को कॉलम के तौर पर और दूसरे को पंक्ति के तौर पर दिखाया गया है. ऐसा विज़ुअल की सुविधा के लिए किया गया है.

ज़्यादा जटिल उदाहरण के लिए, यहां 3D कलेक्शन दिया गया है. इसकी रैंक 3 है, साइज़ 4 का डाइमेंशन 0 है, साइज़ 2 का डाइमेंशन 1 है, और साइज़ 3 का डाइमेंशन 2 है. आसानी के लिए, 1 से 6 तक की वैल्यू को डाइमेंशन 0 में दोहराया जाता है.

इसी तरह, 2D उदाहरण की तरह, हम सिर्फ़ एक डाइमेंशन को छोटा कर सकते हैं. उदाहरण के लिए, अगर हम डाइमेंशन 0 को कम करते हैं, तो हमें रैंक-2 वाला अरे मिलता है, जिसमें डाइमेंशन 0 की सभी वैल्यू को एक स्केलर में फ़ोल्ड किया गया था:

|  4   8  12 |
| 16  20  24 |

अगर हम डाइमेंशन 2 को कम करते हैं, तो हमें रैंक-2 वाला अरे भी मिलता है, जिसमें डाइमेंशन 2 की सभी वैल्यू एक स्केलर में फ़ोल्ड की गई थीं:

| 6  15 |
| 6  15 |
| 6  15 |
| 6  15 |

ध्यान दें कि आउटपुट में बचे हुए डाइमेंशन के बीच मिलता-जुलता क्रम सुरक्षित रहता है, लेकिन कुछ डाइमेंशन को नई संख्या असाइन की जा सकती है (क्योंकि रैंक में बदलाव होता है).

हम एक से ज़्यादा डाइमेंशन को छोटा भी कर सकते हैं. डाइमेंशन 0 और 1 को कम करने पर, 1D कलेक्शन [20, 28, 36] बनता है.

3D अरे को इसके सभी डाइमेंशन में कम करने से स्केलर 84 बनता है.

वैरिएडिक रिडक्शन

N > 1 होने पर, कम फ़ंक्शन का इस्तेमाल करना थोड़ा मुश्किल होता है, क्योंकि यह सभी इनपुट पर एक साथ लागू होता है. ऑपरेंड, कंप्यूटेशन को इस क्रम में दिए जाते हैं:

• पहले ऑपरेंड के लिए कम की गई वैल्यू चलाई जा रही है
• ...
• N'वें ऑपरेंड के लिए कम की गई वैल्यू चलाई जा रही है
• पहले ऑपरैंड के लिए इनपुट वैल्यू
• ...
• N'वें ऑपरेंड के लिए इनपुट वैल्यू

उदाहरण के लिए, नीचे दिए गए रिडक्शन फ़ंक्शन पर विचार करें, जिसका इस्तेमाल साथ-साथ 1-D कलेक्शन की सबसे बड़ी और तर्कमैक्स वैल्यू का पता लगाने के लिए किया जा सकता है:

f: (Float, Int, Float, Int) -> Float, Int
f(max, argmax, value, index):
  if value >= max:
    return (value, index)
  else:
    return (max, argmax)

1-D इनपुट ऐरे V = Float[N], K = Int[N] और इनिट वैल्यू I_V = Float, I_K = Int के लिए, एक ही इनपुट डाइमेंशन को कम करने का नतीजा f_(N-1), बार-बार होने वाले इन ऐप्लिकेशन के बराबर होता है:

f_0 = f(I_V, I_K, V_0, K_0)
f_1 = f(f_0.first, f_0.second, V_1, K_1)
...
f_(N-1) = f(f_(N-2).first, f_(N-2).second, V_(N-1), K_(N-1))

वैल्यू की कैटगरी और क्रम के हिसाब से इंडेक्स (जैसे कि आईओटा) पर इस कमी को लागू करने से, अरे पर यह फिर से लागू हो जाएगा. साथ ही, यह ऐसा टपल दिखाएगा जिसमें ज़्यादा से ज़्यादा वैल्यू और मैच होने वाले इंडेक्स शामिल होंगे.

ReducePrecision

XlaBuilder::ReducePrecision भी देखें.

फ़्लोटिंग-पॉइंट वैल्यू को कम सटीक फ़ॉर्मैट (जैसे कि IEEE-FP16) में बदलने और वापस ओरिजनल फ़ॉर्मैट में बदलने के असर को मॉडल करता है. कम सटीक फ़ॉर्मैट में, घातांक (एक्सपोनेंट) और मैंटिसा बिट की संख्या को मनमाने तरीके से तय किया जा सकता है. हालांकि, हो सकता है कि सभी बिट साइज़, सभी हार्डवेयर सुविधाओं के लिए काम न करें.

ReducePrecision(operand, mantissa_bits, exponent_bits)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	फ़्लोटिंग-पॉइंट टाइप T की कैटगरी.
exponent_bits	int32	कम सटीक फ़ॉर्मैट में एक्सपोनेंट बिट की संख्या
mantissa_bits	int32	कम सटीक फ़ॉर्मैट में मैंटिसा बिट की संख्या

नतीजा, T टाइप का एक कलेक्शन है. इनपुट वैल्यू को मेंटिसा बिट की दी गई संख्या से, नज़दीक की वैल्यू तक राउंड ऑफ़ किया जाता है. इस वैल्यू को "सम के साथ टाई" सिमेंटिक्स का इस्तेमाल करके दिखाया जाता है. साथ ही, घातांक बिट की संख्या से तय की गई रेंज से ज़्यादा वैल्यू को, पॉज़िटिव या नेगेटिव इनफ़िनिटी में जोड़ दिया जाता है. NaN वैल्यू बनी रहती हैं. हालांकि, इन्हें कैननिकल NaN वैल्यू में बदला जा सकता है.

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

ReduceScatter

XlaBuilder::ReduceScatter भी देखें.

LookScatter एक सामूहिक कार्रवाई है, जो All होती है. इसके बाद, नतीजे को scatter_dimension के साथ-साथ shard_count ब्लॉक में बांटती है और रेप्लिका ग्रुप में मौजूद i की कॉपी को ith शार्ड बताती है.

ReduceScatter(operand, computation, scatter_dim, shard_count, replica_group_ids, channel_id)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	रेप्लिका को छोटा करने के लिए, अरे या अरे का वह टपल जो खाली न हो.
computation	XlaComputation	रिडक्शन कंप्यूटेशन
scatter_dimension	int64	स्कैटर के लिए डाइमेंशन.
shard_count	int64	scatter_dimension को बांटने के लिए ब्लॉक की संख्या
replica_groups	int64 के वेक्टर का वेक्टर	वे ग्रुप जिनके बीच में कमी आती है
channel_id	वैकल्पिक int64	क्रॉस-मॉड्यूल कम्यूनिकेशन के लिए वैकल्पिक चैनल आईडी

• जब operand, कई अरे होता है, तो टपल के हर एलिमेंट पर रिड-स्कैटर लागू किया जाता है.
• replica_groups उन प्रतिरूप समूहों की सूची है जिनके बीच में कमी की जाती है (मौजूदा प्रतिरूप के लिए रेप्लिका आईडी को ReplicaId का इस्तेमाल करके फिर से पाया जा सकता है). हर समूह में प्रतिरूपों का क्रम उस क्रम को तय करता है जिसमें सभी कम करने वाले नतीजे को बिखरता है. replica_groups या तो खाली होना चाहिए (इस मामले में, सभी रेप्लिका एक ही ग्रुप से जुड़े हैं) या उसमें उतनी ही संख्या में एलिमेंट होने चाहिए जितने रेप्लिका की संख्या में हैं. अगर एक से ज़्यादा रेप्लिका ग्रुप मौजूद हैं, तो उन सभी का साइज़ एक ही होना चाहिए. उदाहरण के लिए, replica_groups = {0, 2}, {1, 3}, 0 और 2 रेप्लिका के बीच कम करने वाला फ़ंक्शन लागू करता है. साथ ही, 1 और 3 के बीच छोटा करता है और नतीजे को बिखेरता है.
• shard_count हर कॉपी ग्रुप का साइज़ होता है. हमें इसकी ज़रूरत उन मामलों में होती है जहां replica_groups खाली है. अगर replica_groups खाली नहीं है, तो shard_count हर कॉपी ग्रुप के साइज़ के बराबर होना चाहिए.
• channel_id का इस्तेमाल क्रॉस-मॉड्यूल कम्यूनिकेशन के लिए किया जाता है: सिर्फ़ reduce-scatter ऑपरेशन, एक-दूसरे से कम्यूनिकेट कर सकते हैं और एक ही channel_id का इस्तेमाल कर सकते हैं.

आउटपुट आकार, इनपुट का आकार होता है. इसमें scatter_dimension को shard_count गुना छोटा किया जाता है. उदाहरण के लिए, अगर दो रेप्लिका हैं और ऑपरेंड की वैल्यू [1.0, 2.25] और [3.0, 5.25] है, तो इस ऑपरेशन की आउटपुट वैल्यू जहां scatter_dim है 0 होगी, वहीं पहली रेप्लिका के लिए [4.0] और दूसरी रेप्लिका के लिए [7.5] होगा.

ReduceWindow

XlaBuilder::ReduceWindow भी देखें.

N बहु-आयामी सरणियों के क्रम की हर विंडो में मौजूद सभी एलिमेंट पर रिडक्शन फ़ंक्शन लागू करता है. इससे आउटपुट के रूप में, N बहु-आयामी सरणियों का एक या गुच्छा बनता है. हर आउटपुट अरे में एलिमेंट की संख्या, विंडो की मान्य पोज़िशन की संख्या के बराबर होती है. पूलिंग लेयर को ReduceWindow के तौर पर दिखाया जा सकता है. Reduce की तरह ही, लागू किया गया computation, हमेशा बाईं ओर मौजूद init_values को पास करता है.

ReduceWindow(operands..., init_values..., computation, window_dimensions, window_strides, padding)

तर्क	टाइप	सिमैंटिक
operands	N XlaOps	T_0,..., T_{N-1} टाइप की N बहु-आयामी सरणियों का क्रम, जिसमें हर वह आधार क्षेत्र दिखाती है जिस पर विंडो रखी गई है.
init_values	N XlaOps	कमी के लिए N की शुरुआती वैल्यू, हर N ऑपरेंड के लिए एक. ज़्यादा जानकारी के लिए 'कम करें' देखें.
computation	XlaComputation	सभी इनपुट ऑपरेंड की हर विंडो में मौजूद एलिमेंट पर लागू करने के लिए, T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}) टाइप का रिडक्शन फ़ंक्शन.
window_dimensions	ArraySlice<int64>	विंडो डाइमेंशन वैल्यू के लिए पूर्णांकों का कलेक्शन
window_strides	ArraySlice<int64>	विंडो स्ट्राइड वैल्यू के लिए पूर्णांकों का अरे
base_dilations	ArraySlice<int64>	बेस डाइलेशन वैल्यू के लिए पूर्णांकों का अरे
window_dilations	ArraySlice<int64>	विंडो डाइलेशन वैल्यू के लिए इंटीजर का अरे
padding	Padding	विंडो के लिए पैडिंग टाइप (Padding::kSame) का इस्तेमाल करने पर, स्ट्रेड 1 के होने पर इनपुट के आउटपुट आकार के जैसा ही पैड करने की कोशिश की जाती है. इसके अलावा, पैडिंग::kValid, जो पैडिंग (जगह) का इस्तेमाल नहीं करता है और विंडो के फ़िट न होने पर उसे "बंद कर देता है"

जगह:

• N का मान 1 से बड़ा या उसके बराबर होना ज़रूरी है.
• सभी इनपुट ऐरे के डाइमेंशन एक जैसे होने चाहिए.
• अगर N = 1, तो Collate(T), T होता है.
• अगर N > 1, तो Collate(T_0, ..., T_{N-1}) (T0,...T{N-1}) टाइप के N एलिमेंट का एक टपल है.

नीचे दिए गए कोड और इमेज में, ReduceWindow को इस्तेमाल करने का उदाहरण दिया गया है. इनपुट, साइज़ [4x6] का मैट्रिक्स है. साथ ही, window_dimensions और window_stride_dimensions दोनों [2x3] हैं.

// Create a computation for the reduction (maximum).
XlaComputation max;
{
  XlaBuilder builder(client_, "max");
  auto y = builder.Parameter(0, ShapeUtil::MakeShape(F32, {}), "y");
  auto x = builder.Parameter(1, ShapeUtil::MakeShape(F32, {}), "x");
  builder.Max(y, x);
  max = builder.Build().value();
}

// Create a ReduceWindow computation with the max reduction computation.
XlaBuilder builder(client_, "reduce_window_2x3");
auto shape = ShapeUtil::MakeShape(F32, {4, 6});
auto input = builder.Parameter(0, shape, "input");
builder.ReduceWindow(
    input,
    /*init_val=*/builder.ConstantLiteral(LiteralUtil::MinValue(F32)),
    *max,
    /*window_dimensions=*/{2, 3},
    /*window_stride_dimensions=*/{2, 3},
    Padding::kValid);

किसी डाइमेंशन में 1 का स्टेप करने से यह पता चलता है कि डाइमेंशन में किसी विंडो की जगह उसके पास वाली विंडो से 1 एलिमेंट दूर है. यह बताने के लिए कि कोई विंडो एक-दूसरे को ओवरलैप नहीं करती है, window_stride_dimensions, window_DIMENSIONs के बराबर होना चाहिए. नीचे दिए गए चित्र में दो अलग-अलग स्ट्रेड मानों का इस्तेमाल दिखाया गया है. इनपुट के हर डाइमेंशन पर पैडिंग (जगह) लागू की जाती है. साथ ही, कैलकुलेशन एक जैसी होती हैं, जैसे कि इनपुट, पैडिंग के बाद मौजूद डाइमेंशन के साथ मिला था.

सामान्य पैडिंग (जगह) के उदाहरण के लिए, 3 डाइमेंशन के साथ कम से कम विंडो (शुरुआती वैल्यू MAX_FLOAT है) की कंप्यूटिंग कम से कम करें. साथ ही, इनपुट कलेक्शन [10000, 1000, 100, 10, 1] पर 2 को घुमाएं. kValid को पैडिंग की सुविधा से, कम से कम दो मान्य विंडो: [10000, 1000, 100] और [100, 10, 1] की वैल्यू का हिसाब लगाया जाता है. इससे, आउटपुट [100, 1] मिलता है. kSame सबसे पहले अरे को पैडिंग करता है, ताकि कम विंडो के बाद की आकृति, स्ट्राइड एक के लिए इनपुट के इनपुट के समान ही हो. इसके लिए, दोनों तरफ़ शुरुआती एलिमेंट जोड़ें और [MAX_VALUE, 10000, 1000, 100, 10, 1, MAX_VALUE] पाएं. पेडेड अरे पर रिड-विंडो चलाने की सुविधा, तीन विंडो [MAX_VALUE, 10000, 1000], [1000, 100, 10], [10, 1, MAX_VALUE], और यील्ड [1000, 10, 1] पर काम करती है.

कम करने वाले फ़ंक्शन का आकलन करने का क्रम, मनमुताबिक होता है और हो सकता है कि यह तय न हो. इसलिए, छोटा करने वाला फ़ंक्शन फिर से जोड़ने के लिए बहुत ज़्यादा संवेदनशील नहीं होना चाहिए. ज़्यादा जानकारी के लिए, Reduce के संदर्भ में असोसिएशन के बारे में हुई चर्चा देखें.

ReplicaId

XlaBuilder::ReplicaId भी देखें.

प्रतिरूप का यूनीक आईडी (U32 अदिश) देता है.

ReplicaId()

हर रेप्लिका का यूनीक आईडी, [0, N) इंटरवल में बिना हस्ताक्षर वाला एक पूर्णांक होता है. यहां N, डुप्लीकेट कॉपी की संख्या होती है. सभी रेप्लिका एक ही प्रोग्राम को चला रहे हैं, इसलिए प्रोग्राम में ReplicaId() कॉल हर रेप्लिका पर अलग वैल्यू दिखाएगा.

आकार बदलें

XlaBuilder::Reshape और Collapse कार्रवाई भी देखें.

किसी अरे के डाइमेंशन को नए कॉन्फ़िगरेशन में बदलता है.

Reshape(operand, new_sizes) Reshape(operand, dimensions, new_sizes)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	T टाइप का अरे
dimensions	int64 वेक्टर	डाइमेंशन को छोटा करने का क्रम
new_sizes	int64 वेक्टर	नए डाइमेंशन के साइज़ का वेक्टर

सैद्धान्तिक तौर पर, फिर से आकार सबसे पहले किसी अरे को डेटा वैल्यू के एक-विमीय वेक्टर में फ़्लैट करता है और फिर इस वेक्टर को नए आकार में बदल देता है. इनपुट आर्ग्युमेंट, T टाइप का आर्बिट्रेरी अरे है. यह डाइमेंशन इंडेक्स का कंपाइल-टाइम-कॉन्सटेंट वेक्टर है, और नतीजे के लिए, डाइमेंशन साइज़ का कंपाइल-टाइम-कॉन्सटेंट वेक्टर है. अगर dimension वेक्टर की वैल्यू दी गई है, तो यह T के सभी डाइमेंशन का क्रमचय होनी चाहिए. अगर वैल्यू नहीं दी गई है, तो डिफ़ॉल्ट वैल्यू {0, ..., rank - 1} होनी चाहिए. dimensions में डाइमेंशन का क्रम, लूप नेस्ट में सबसे धीरे दिखने वाले डाइमेंशन (सबसे मुख्य) से लेकर सबसे तेज़ बदलने वाले डाइमेंशन (सबसे छोटा) तक होता है. यह डाइमेंशन, इनपुट ऐरे को एक डाइमेंशन में छोटा कर देता है. new_sizes वेक्टर, आउटपुट कलेक्शन का साइज़ तय करता है. new_sizes के इंडेक्स 0 की वैल्यू, डाइमेंशन 0 का साइज़, इंडेक्स 1 की वैल्यू, डाइमेंशन 1 का साइज़ वगैरह होती है. new_size डाइमेंशन का प्रॉडक्ट, ऑपरेंड के डाइमेंशन साइज़ के प्रॉडक्ट के बराबर होना चाहिए. new_sizes से तय किए गए कई डाइमेंशन वाले कलेक्शन में छोटे किए गए अरे को बेहतर करते समय, new_sizes में डाइमेंशन को सबसे धीमी ट्रांज़िशन (सबसे ज़्यादा ज़रूरी) और सबसे तेज़ी से बदलने वाले (सबसे कम) से क्रम में लगाया जाता है.

उदाहरण के लिए, v को 24 एलिमेंट का अरे बनने दें:

let v = f32[4x2x3] { { {10, 11, 12}, {15, 16, 17} },
                    { {20, 21, 22}, {25, 26, 27} },
                    { {30, 31, 32}, {35, 36, 37} },
                    { {40, 41, 42}, {45, 46, 47} } };

In-order collapse:
let v012_24 = Reshape(v, {0,1,2}, {24});
then v012_24 == f32[24] {10, 11, 12, 15, 16, 17, 20, 21, 22, 25, 26, 27,
                         30, 31, 32, 35, 36, 37, 40, 41, 42, 45, 46, 47};

let v012_83 = Reshape(v, {0,1,2}, {8,3});
then v012_83 == f32[8x3] { {10, 11, 12}, {15, 16, 17},
                          {20, 21, 22}, {25, 26, 27},
                          {30, 31, 32}, {35, 36, 37},
                          {40, 41, 42}, {45, 46, 47} };

Out-of-order collapse:
let v021_24 = Reshape(v, {1,2,0}, {24});
then v012_24 == f32[24]  {10, 20, 30, 40, 11, 21, 31, 41, 12, 22, 32, 42,
                          15, 25, 35, 45, 16, 26, 36, 46, 17, 27, 37, 47};

let v021_83 = Reshape(v, {1,2,0}, {8,3});
then v021_83 == f32[8x3] { {10, 20, 30}, {40, 11, 21},
                          {31, 41, 12}, {22, 32, 42},
                          {15, 25, 35}, {45, 16, 26},
                          {36, 46, 17}, {27, 37, 47} };


let v021_262 = Reshape(v, {1,2,0}, {2,6,2});
then v021_262 == f32[2x6x2] { { {10, 20}, {30, 40},
                              {11, 21}, {31, 41},
                              {12, 22}, {32, 42} },
                             { {15, 25}, {35, 45},
                              {16, 26}, {36, 46},
                              {17, 27}, {37, 47} } };

खास मामले में, रीशेप किसी एक एलिमेंट वाली अरे को अदिश और अदिश में बदल सकता है. उदाहरण के लिए,

Reshape(f32[1x1] { {5} }, {0,1}, {}) == 5;
Reshape(5, {}, {1,1}) == f32[1x1] { {5} };

रेवेन्यू (रिवर्स)

XlaBuilder::Rev भी देखें.

Rev(operand, dimensions)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	T टाइप का अरे
dimensions	ArraySlice<int64>	रिवर्स करने के लिए डाइमेंशन

तय किए गए dimensions के साथ, operand कलेक्शन में एलिमेंट के क्रम को उलटा करता है. इससे उसी आकार का आउटपुट अरे जनरेट होता है. मल्टीडाइमेंशन वाले इंडेक्स में, ऑपरेंड अरे का हर एलिमेंट, उस इंडेक्स में आउटपुट कलेक्शन में सेव होता है जिसमें बदलाव किया गया है. हर डाइमेंशन में इंडेक्स को रिवर्स करके, कई डाइमेंशन वाला इंडेक्स बदल जाता है. इसका मतलब है कि अगर N का कोई डाइमेंशन, रिवर्स डाइमेंशन में शामिल है, तो उसका इंडेक्स i, N - 1 - i में बदल जाता है.

Rev ऑपरेशन का एक इस्तेमाल न्यूरल नेटवर्क में ग्रेडिएंट कंप्यूटेशन के दौरान दो विंडो डाइमेंशन के साथ कॉन्वलूशन वेट अरे को रिवर्स करना है.

RngNormal

XlaBuilder::RngNormal भी देखें.

सामान्य डिस्ट्रिब्यूशन के बाद जनरेट हुई रैंडम संख्याओं से किसी दिए गए आकार का आउटपुट बनाता है. \(N(\mu, \sigma)\) पैरामीटर \(\mu\) और \(\sigma\), और आउटपुट आकार में फ़्लोटिंग पॉइंट एलिमेंटल टाइप होना चाहिए. इसके अलावा, पैरामीटर का स्केलर वैल्यू तय होना चाहिए.

RngNormal(mu, sigma, shape)

तर्क	टाइप	सिमैंटिक
mu	XlaOp	T प्रकार का स्केलर, जनरेट की गई संख्याओं का माध्य तय करता है
sigma	XlaOp	T का स्केलर, जो जनरेट किए गए एलिमेंट का स्टैंडर्ड डीविएशन तय करता है
shape	Shape	T टाइप के आउटपुट का आकार

RngUniform

XlaBuilder::RngUniform भी देखें.

इंटरवल \([a,b)\)के दौरान एक जैसे डिस्ट्रिब्यूशन के बाद जनरेट हुई रैंडम संख्याओं से किसी दिए गए आकार का आउटपुट बनाता है. पैरामीटर और आउटपुट एलिमेंट टाइप, बूलियन टाइप, इंटिग्रल या फ़्लोटिंग पॉइंट टाइप होने चाहिए. साथ ही, हर टाइप का टाइप एक जैसा होना चाहिए. फ़िलहाल, सीपीयू और जीपीयू बैकएंड में, सिर्फ़ F64, F32, F16, BF16, S64, U64, S32, और U32 को इस्तेमाल किया जा सकता है. इसके अलावा, पैरामीटर की वैल्यू को स्केलर होना चाहिए. अगर \(b <= a\) नतीजे को लागू करने के तरीके के बारे में बताया गया है.

RngUniform(a, b, shape)

तर्क	टाइप	सिमैंटिक
a	XlaOp	T का स्केलर, इंटरवल की निचली सीमा तय करता है
b	XlaOp	T का स्केलर, इंटरवल की ऊपरी सीमा तय करता है
shape	Shape	T टाइप के आउटपुट का आकार

RngBitGenerator

तय किए गए एल्गोरिदम (या बैकएंड डिफ़ॉल्ट) का इस्तेमाल करके, दिए गए आकार के साथ एक जैसे रैंडम बिट से आउटपुट जनरेट करता है. साथ ही, अपडेट की गई स्थिति (शुरुआती स्थिति की तरह ही आकार के साथ) और जनरेट किया गया रैंडम डेटा दिखाता है.

शुरुआती स्थिति, किसी भी नंबर के मौजूदा जनरेशन की शुरुआती स्थिति होती है. यह और ज़रूरी आकार और मान्य वैल्यू, इस्तेमाल किए गए एल्गोरिदम पर निर्भर करती हैं.

इस बात की गारंटी है कि आउटपुट शुरुआती स्थिति का डिटर्मिनिस्टिक फ़ंक्शन होगा. हालांकि, बैकएंड और कंपाइलर वर्शन के बीच यह तय करने की कोई गारंटी नहीं है.

RngBitGenerator(algorithm, key, shape)

तर्क	टाइप	सिमैंटिक
algorithm	RandomAlgorithm	PRNG एल्गोरिदम का इस्तेमाल करना होगा.
initial_state	XlaOp	PRNG एल्गोरिदम के लिए शुरुआती स्थिति.
shape	Shape	जनरेट किए गए डेटा के लिए आउटपुट आकार.

algorithm के लिए उपलब्ध मान:

• rng_default: बैकएंड की खास शर्तों के साथ खास एल्गोरिदम का बैकएंड.

• rng_three_fry: थ्रीFry काउंटर-आधारित PRNG एल्गोरिदम. initial_state का आकार, आर्बिट्रेरी वैल्यू वाला u64[2] है. सैलमन और अन्य एससी, 2011. पैरलल रैंडम नंबर: 1, 2, 3 जितने आसान होते हैं.

• rng_philox: साथ-साथ रैंडम नंबर जनरेट करने के लिए Philox एल्गोरिदम. initial_state का आकार, आर्बिट्रेरी वैल्यू वाला u64[3] है. सैलमन और अन्य एससी, 2011. पैरलल रैंडम नंबर: 1, 2, 3 जितने आसान होते हैं.

स्कैटर

XLA स्कैटर ऑपरेशन, नतीजों का एक क्रम जनरेट करता है, जो इनपुट ऐरे operands की वैल्यू होते हैं. इसमें, scatter_indices के बताए गए इंडेक्स पर, कई स्लाइस होते हैं. इन्हें update_computation का इस्तेमाल करके, updates में वैल्यू के क्रम के साथ अपडेट किया जाता है.

XlaBuilder::Scatter भी देखें.

scatter(operands..., scatter_indices, updates..., update_computation, index_vector_dim, update_window_dims, inserted_window_dims, scatter_dims_to_operand_dims)

तर्क	टाइप	सिमैंटिक
operands	N XlaOp का क्रम	T_0, ..., T_N टाइप की N कैटगरी, जिनमें मौजूद होना है.
scatter_indices	XlaOp	वह कलेक्शन जिसमें उन स्लाइस के शुरुआती इंडेक्स हैं जिन्हें फैलाया जाना चाहिए.
updates	N XlaOp का क्रम	T_0, ..., T_N टाइप की N कैटगरी. updates[i] में ऐसी वैल्यू मौजूद हैं जिनका इस्तेमाल operands[i] को स्कैटर करने के लिए किया जाना चाहिए.
update_computation	XlaComputation	इनपुट अरे में मौजूदा वैल्यू और स्कैटर के दौरान अपडेट को जोड़ने के लिए इस्तेमाल किया जाने वाला कंप्यूटेशन. यह कैलकुलेशन T_0, ..., T_N, T_0, ..., T_N -> Collate(T_0, ..., T_N) टाइप की होनी चाहिए.
index_vector_dim	int64	scatter_indices में मौजूद डाइमेंशन, जिसमें शुरुआती इंडेक्स शामिल हैं.
update_window_dims	ArraySlice<int64>	updates आकार में डाइमेंशन का सेट, जो विंडो डाइमेंशन होता है.
inserted_window_dims	ArraySlice<int64>	विंडो डाइमेंशन का सेट, जिसे updates आकार में शामिल किया जाना चाहिए.
scatter_dims_to_operand_dims	ArraySlice<int64>	डाइमेंशन, स्कैटर इंडेक्स से ऑपरेंड इंडेक्स स्पेस तक ले जाते हैं. इस अरे को i को scatter_dims_to_operand_dims[i] में मैप करने के तौर पर समझा जाता है . यह वन-टू-वन और कुल होना चाहिए.
indices_are_sorted	bool	क्या इंडेक्स, कॉलर के हिसाब से क्रम में लगाए जाने की गारंटी है.
unique_indices	bool	क्या कॉलर के लिए इंडेक्स के यूनीक होने की गारंटी है.

जगह:

• N का मान 1 से बड़ा या उसके बराबर होना ज़रूरी है.
• operands[0], ..., operands[N-1] सभी के डाइमेंशन एक जैसे होने चाहिए.
• updates[0], ..., updates[N-1] सभी के डाइमेंशन एक जैसे होने चाहिए.
• अगर N = 1, तो Collate(T), T होता है.
• अगर N > 1, तो Collate(T_0, ..., T_N) T टाइप के N एलिमेंट का एक टपल है.

अगर index_vector_dim, scatter_indices.rank के बराबर है, तो हम अनुमान के तौर पर, scatter_indices को पीछे वाले 1 डाइमेंशन का हिस्सा मानते हैं.

हम update_scatter_dims प्रकार के ArraySlice<int64> को updates के आकार में डाइमेंशन के सेट के तौर पर बताते हैं. यह संख्या update_window_dims में नहीं होती. यह बढ़ते क्रम में होती है.

स्कैटर के आर्ग्युमेंट को इन कंस्ट्रेंट के हिसाब से होना चाहिए:

• हर updates कलेक्शन की रैंक update_window_dims.size + scatter_indices.rank - 1 होनी चाहिए.

• हर updates कलेक्शन में i डाइमेंशन की सीमाएं, इनके मुताबिक होनी चाहिए:

  • अगर i, update_window_dims में मौजूद है (यानी कुछ k के लिए, update_window_dims[k] के बराबर है), तो inserted_window_dims में शामिल होने के बाद, updates में i डाइमेंशन की सीमा, operand से जुड़ी सीमा से ज़्यादा नहीं होनी चाहिए. जैसे, adjusted_window_bounds[k], जहां adjusted_window_bounds में operand की सीमाएं शामिल होंगी, लेकिन इंडेक्स की सीमाओं से inserted_window_dims हटा दिए गए होंगे.
  • अगर update_scatter_dims में i मौजूद है (जैसे, कुछ k के लिए update_scatter_dims[k] के बराबर), तो updates में i डाइमेंशन की सीमा, इससे जुड़ी scatter_indices की सीमा के बराबर होनी चाहिए. इससे index_vector_dim को छोड़कर, scatter_indices.shape.dims[k] में, अगर k < index_vector_dim हो और scatter_indices.shape.dims[k+1] हो, तो यह बाउंड होगा.

• update_window_dims बढ़ते क्रम में होना चाहिए, इनमें कोई दोहराया गया डाइमेंशन नंबर नहीं होना चाहिए, और यह [0, updates.rank) की रेंज में होना चाहिए.

• inserted_window_dims बढ़ते क्रम में होना चाहिए, इनमें कोई दोहराया गया डाइमेंशन नंबर नहीं होना चाहिए, और यह [0, operand.rank) की रेंज में होना चाहिए.

• operand.rank, update_window_dims.size और inserted_window_dims.size के योग के बराबर होना चाहिए.

• scatter_dims_to_operand_dims.size, scatter_indices.shape.dims[index_vector_dim] के बराबर होनी चाहिए और इसकी वैल्यू [0, operand.rank) की रेंज में होनी चाहिए.

हर updates कलेक्शन में दिए गए इंडेक्स U के लिए, operands कलेक्शन में इससे जुड़े इंडेक्स I को इस तरह से कैलकुलेट किया जाता है:

1. मान लें कि update_scatter_dims में k के लिए, G = { U[k] } है. scatter_indices कलेक्शन में इंडेक्स वेक्टर S खोजने के लिए G का इस्तेमाल करें, जैसे कि S[i] = scatter_indices[मिलाएं(G, i)] जहां कंबाइन करें(A, b) b को index_vector_dim में लगा देता है.
2. scatter_dims_to_operand_dims मैप का इस्तेमाल करके S स्कैटर करके, S का इस्तेमाल करके operand में Sin इंडेक्स बनाएं. आधिकारिक तौर पर:
   1. Sin[scatter_dims_to_operand_dims[k]] = S[k] अगर k < scatter_dims_to_operand_dims.size.
   2. Sin[_] = 0 अन्य मामलों में.
3. inserted_window_dims के हिसाब से, U में update_window_dims पर इंडेक्स फैलाकर, हर operands कलेक्शन में Win इंडेक्स बनाएं. आधिकारिक तौर पर:
   1. Win[window_dims_to_operand_dims(k)] = U[k] अगर k update_window_dims में है, जहां window_dims_to_operand_dims, [0, update_window_dims.size) और रेंज [0, operand.rank) \ inserted_window_dims के साथ मोनोटॉनिक फ़ंक्शन है. उदाहरण के लिए, अगर update_window_dims.size, 4 है, operand.rank 6 है, और inserted_window_dims {0, 2} है, तो window_dims_to_operand_dims {0→1, 1→3, 2→4, 3→5} है.
   2. Win[_] = 0 अन्य मामलों में.
4. I, Win + Sin है, जहां +, एलिमेंट के हिसाब से जोड़ है.

कम शब्दों में, स्कैटर की कार्रवाई को इस तरह परिभाषित किया जा सकता है.

• output को operands के साथ शुरू करें. उदाहरण के लिए, सभी इंडेक्स J के लिए, operands[J] कलेक्शन में मौजूद सभी इंडेक्स O के लिए:
  output[J][O] = operands[J][O]
• updates[J] के कलेक्शन में हर इंडेक्स U और operand[J] कैटगरी के उससे जुड़े इंडेक्स O के लिए, अगर O, output के लिए मान्य इंडेक्स है:
  (output[0][O], ..., output[N-1][O]) =update_computation(output[0][O], ..., ,output[N-1][O],updates[0][U], ...,updates[N-1][U])

अपडेट लागू करने का क्रम तय नहीं होता. इसलिए, जब updates में एक से ज़्यादा इंडेक्स, operands में एक ही इंडेक्स को रेफ़र करते हैं, तो output में उसकी वैल्यू तय नहीं होगी.

ध्यान दें कि update_computation में दिया गया पहला पैरामीटर हमेशा output कलेक्शन की मौजूदा वैल्यू होगी और दूसरा पैरामीटर हमेशा updates कलेक्शन की वैल्यू होगी. यह खास तौर पर उन मामलों के लिए ज़रूरी है, जब update_computation कम्यूटेटिव नहीं होता.

अगर indices_are_sorted को 'सही है' पर सेट किया जाता है, तो XLA यह मान सकता है कि उपयोगकर्ता ने start_indices को बढ़ते हुए start_index_map क्रम में लगाया है. अगर ऐसा नहीं है, तो सिमेंटिक्स लागू किया जाता है.

अगर unique_indices को 'सही है' पर सेट किया जाता है, तो XLA यह मान सकता है कि बिके हुए सभी एलिमेंट यूनीक हैं. इसलिए, XLA गैर-परमाणु संक्रियाओं का इस्तेमाल कर सकता है. अगर unique_indices सही पर सेट है और जो इंडेक्स बिके हुए हैं वे यूनीक नहीं हैं, तो सिमैंटिक लागू करना तय किया जाता है.

अनौपचारिक तौर पर, स्कैटर ऑप को इकट्ठा ऑप के इनवर्स के तौर पर देखा जा सकता है. इसका मतलब है कि स्कैटर ऑप, इनपुट में उन एलिमेंट को अपडेट करता है जिन्हें उससे जुड़े इकट्ठा ऑपर्च्यूनिटी से निकाला जाता है.

ज़्यादा जानकारी और उदाहरणों के लिए, Gather में "इनफ़ॉर्मल ब्यौरा" सेक्शन देखें.

चुनें

XlaBuilder::Select भी देखें.

प्रेडिकेट अरे की वैल्यू के आधार पर, दो इनपुट अरे के एलिमेंट से आउटपुट अरे बनाता है.

Select(pred, on_true, on_false)

तर्क	टाइप	सिमैंटिक
pred	XlaOp	PRED टाइप का अरे
on_true	XlaOp	T टाइप का अरे
on_false	XlaOp	T टाइप का अरे

on_true और on_false कलेक्शन का आकार एक ही होना चाहिए. यह आउटपुट कलेक्शन का आकार भी है. pred अरे की डाइमेंशन, PRED एलिमेंट टाइप वाली on_true और on_false की डाइमेंशन के बराबर होना चाहिए.

pred के हर एलिमेंट P के लिए, आउटपुट ऐरे का संबंधित एलिमेंट on_true से तब लिया जाता है, जब P की वैल्यू true होती है. साथ ही, अगर P की वैल्यू false है, तो on_false से लिया जाता है. pred, ब्रॉडकास्ट करने के प्रतिबंधित तरीके के तौर पर, PRED टाइप का स्केलर हो सकता है. इस मामले में, अगर pred true है, तो आउटपुट कलेक्शन को on_true से और अगर pred false है, तो on_false से लिया जाता है.

नॉन-स्केलर pred के साथ उदाहरण:

let pred: PRED[4] = {true, false, false, true};
let v1: s32[4] = {1, 2, 3, 4};
let v2: s32[4] = {100, 200, 300, 400};
==>
Select(pred, v1, v2) = s32[4]{1, 200, 300, 4};

स्केलर pred के साथ उदाहरण:

let pred: PRED = true;
let v1: s32[4] = {1, 2, 3, 4};
let v2: s32[4] = {100, 200, 300, 400};
==>
Select(pred, v1, v2) = s32[4]{1, 2, 3, 4};

टपल के बीच में से किसी एक को ही चुना जा सकता है. इस काम के लिए टपल को स्केलर प्रकार माना जाता है. अगर on_true और on_false ऐसे टूल हैं (जिनका आकार एक ही होना चाहिए!), तो pred, PRED टाइप का स्केलर होना चाहिए.

SelectAndScatter

XlaBuilder::SelectAndScatter भी देखें.

इस कार्रवाई को एक कंपोज़िट ऑपरेशन के तौर पर माना जा सकता है. यह सबसे पहले हर विंडो से कोई एलिमेंट चुनने के लिए, operand कलेक्शन पर ReduceWindow की गणना करता है. इसके बाद, चुने गए एलिमेंट के इंडेक्स पर source अरे को स्कैटर कर देता है. इससे आउटपुट कलेक्शन, ऑपरेंड अरे के आकार से मिलता-जुलता होता है. बाइनरी select फ़ंक्शन का इस्तेमाल, हर विंडो पर किसी एलिमेंट को लागू करके उससे जुड़े एलिमेंट को चुनने के लिए किया जाता है. साथ ही, इसे उस प्रॉपर्टी के साथ कॉल किया जाता है जिसमें पहले पैरामीटर के इंडेक्स वेक्टर की जानकारी, दूसरे पैरामीटर के इंडेक्स वेक्टर से कम होती है. अगर पहला पैरामीटर चुना जाता है, तो select फ़ंक्शन true दिखाता है और दूसरा पैरामीटर चुनने पर false दिखाता है. साथ ही, फ़ंक्शन में ट्रांज़िटिविटी होनी चाहिए (जैसे, अगर select(a, b) और select(b, c) true हैं, तो select(a, c) भी true है), ताकि चुना गया एलिमेंट किसी विंडो के लिए पार किए गए एलिमेंट के क्रम पर निर्भर न हो.

scatter फ़ंक्शन, आउटपुट कलेक्शन में चुने गए हर इंडेक्स पर लागू किया जाता है. इसमें दो स्केलर पैरामीटर होते हैं:

1. आउटपुट कलेक्शन में चुने गए इंडेक्स पर मौजूदा वैल्यू
2. source से ली गई स्कैटर वैल्यू, जो चुने गए इंडेक्स पर लागू होती है

यह दो पैरामीटर को मिलाता है और एक स्केलर वैल्यू दिखाता है. इसका इस्तेमाल, आउटपुट कलेक्शन में चुने गए इंडेक्स की वैल्यू को अपडेट करने के लिए किया जाता है. शुरुआत में, आउटपुट कलेक्शन के सभी इंडेक्स, init_value पर सेट होते हैं.

आउटपुट अरे का आकार, operand अरे जैसा ही होता है. साथ ही, source कलेक्शन का आकार, operand अरे पर ReduceWindow ऑपरेशन लागू करने से मिलने वाले नतीजे जैसा ही होना चाहिए. SelectAndScatter का इस्तेमाल, न्यूरल नेटवर्क में पूलिंग लेयर के लिए ग्रेडिएंट वैल्यू का बैकप्रॉपैगेट करने के लिए किया जा सकता है.

SelectAndScatter(operand, select, window_dimensions, window_strides, padding, source, init_value, scatter)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	टाइप T का अरे, जिस पर विंडो स्लाइड होती हैं
select	XlaComputation	हर विंडो में सभी एलिमेंट पर लागू करने के लिए, T, T -> PRED टाइप की बाइनरी कंप्यूटेशन की जाती है. अगर पहला पैरामीटर चुना जाता है, तो true दिखाता है. वहीं, दूसरा पैरामीटर चुनने पर false दिखाता है
window_dimensions	ArraySlice<int64>	विंडो डाइमेंशन वैल्यू के लिए पूर्णांकों का कलेक्शन
window_strides	ArraySlice<int64>	विंडो स्ट्राइड वैल्यू के लिए पूर्णांकों का अरे
padding	Padding	विंडो के लिए पैडिंग टाइप (Padding::kSame या Padding::kValid)
source	XlaOp	टाइप T की अरे, जिसमें स्कैटर की वैल्यू हैं
init_value	XlaOp	आउटपुट कलेक्शन की शुरुआती वैल्यू के लिए टाइप T का स्केलर वैल्यू
scatter	XlaComputation	हर स्कैटर सोर्स एलिमेंट को उसके डेस्टिनेशन एलिमेंट के साथ लागू करने के लिए, T, T -> T टाइप की बाइनरी कंप्यूटेशन

नीचे दिए गए डायग्राम में, SelectAndScatter का इस्तेमाल करने के उदाहरण दिए गए हैं. इसमें, select फ़ंक्शन, इसके पैरामीटर में सबसे बड़ी वैल्यू की गणना करता है. ध्यान दें कि जब विंडो ओवरलैप होती हैं, तो जैसा कि नीचे दिए गए चित्र (2) में दिखाया गया है, operand कलेक्शन के इंडेक्स को अलग-अलग विंडो में कई बार चुना जा सकता है. इस इमेज में, वैल्यू 9 के एलिमेंट को टॉप विंडो (नीले और लाल) दोनों से चुना गया है और बाइनरी जोड़ने के लिए scatter फ़ंक्शन, वैल्यू 8 (2 + 6) का आउटपुट एलिमेंट देता है.

scatter फ़ंक्शन का आकलन करने का क्रम मनमुताबिक होता है और हो सकता है कि यह तय न हो. इसलिए, scatter फ़ंक्शन को फिर से जोड़ने के लिए बहुत ज़्यादा संवेदनशील नहीं होना चाहिए. ज़्यादा जानकारी के लिए, Reduce के संदर्भ में असोसिएशन के बारे में हुई चर्चा देखें.

भेजें

XlaBuilder::Send भी देखें.

Send(operand, channel_handle)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	भेजा जाने वाला डेटा (T प्रकार की श्रेणी)
channel_handle	ChannelHandle	भेजने/recv के हर जोड़े के लिए यूनीक आइडेंटिफ़ायर

दिए गए ऑपरेंड डेटा को किसी अन्य कंप्यूटेशन से Recv निर्देश को भेजता है, जो उसी चैनल हैंडल को शेयर करता है. कोई डेटा नहीं दिखाता है.

Recv ऑपरेशन की तरह ही, Send ऑपरेशन का Client API, सिंक्रोनस कम्यूनिकेशन दिखाता है. साथ ही, इसे अंदरूनी तौर पर दो एचएलओ निर्देशों (Send और SendDone) में बांटा जाता है, ताकि एसिंक्रोनस डेटा ट्रांसफ़र चालू किया जा सके. HloInstruction::CreateSend और HloInstruction::CreateSendDone भी देखें.

Send(HloInstruction operand, int64 channel_id)

एक ही चैनल आईडी वाले Recv निर्देश से असाइन किए गए संसाधनों को ऑपरेंड का एसिंक्रोनस ट्रांसफ़र शुरू करता है. यह फ़ंक्शन, कॉन्टेक्स्ट दिखाता है. इसका इस्तेमाल, डेटा ट्रांसफ़र पूरा होने का इंतज़ार करने के लिए, नीचे दिए गए SendDone निर्देश की मदद से किया जाता है. कॉन्टेक्स्ट, {operand (आकार), अनुरोध पहचानकर्ता (U32)} का एक टपल है और इसका इस्तेमाल सिर्फ़ SendDone निर्देश की मदद से किया जा सकता है.

SendDone(HloInstruction context)

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

चैनल के निर्देशों को शेड्यूल करना

हर चैनल के लिए चार निर्देशों (Recv, RecvDone, Send, SendDone) को लागू करने का क्रम इस तरह है.

• Recv, Send से पहले है
• Send, RecvDone से पहले है
• Recv, RecvDone से पहले है
• Send, SendDone से पहले है

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

स्लाइस

XlaBuilder::Slice भी देखें.

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

Slice(operand, start_indices, limit_indices, strides)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	T टाइप की N डाइमेंशन वाली अरे
start_indices	ArraySlice<int64>	N पूर्णांक की सूची, जिसमें हर डाइमेंशन के लिए स्लाइस के शुरुआती इंडेक्स मौजूद हैं. वैल्यू, शून्य से ज़्यादा या उसके बराबर होनी चाहिए.
limit_indices	ArraySlice<int64>	हर डाइमेंशन के स्लाइस के लिए, आखिरी इंडेक्स (खास) वाले N पूर्णांक की सूची. हर वैल्यू, डाइमेंशन के लिए तय की गई start_indices वैल्यू से ज़्यादा या उसके बराबर होनी चाहिए. साथ ही, यह डाइमेंशन के साइज़ से कम या उसके बराबर होनी चाहिए.
strides	ArraySlice<int64>	N पूर्णांक की सूची, जो स्लाइस के इनपुट स्ट्राइड को तय करता है. स्लाइस, d डाइमेंशन में हर strides[d] एलिमेंट चुनता है.

1-डाइमेंशन वाला उदाहरण:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
Slice(a, {2}, {4}) produces:
  {2.0, 3.0}

दो डाइमेंशन का उदाहरण:

let b =
 { {0.0,  1.0,  2.0},
   {3.0,  4.0,  5.0},
   {6.0,  7.0,  8.0},
   {9.0, 10.0, 11.0} }

Slice(b, {2, 1}, {4, 3}) produces:
  { { 7.0,  8.0},
    {10.0, 11.0} }

क्रम से लगाएं

XlaBuilder::Sort भी देखें.

Sort(operands, comparator, dimension, is_stable)

तर्क	टाइप	सिमैंटिक
operands	ArraySlice<XlaOp>	क्रम से लगाने के लिए ऑपरेंड.
comparator	XlaComputation	इस्तेमाल की जाने वाली कंप्रेटर कंप्यूटेशन.
dimension	int64	वह डाइमेंशन जिसके हिसाब से क्रम में लगाना है.
is_stable	bool	स्टेबल क्रम में लगाने की सुविधा का इस्तेमाल किया जाना चाहिए या नहीं.

अगर सिर्फ़ एक ऑपरैंड दिया गया हो, तो:

• अगर ऑपरेंड कोई रैंक-1 टेंसर (ऐरे) है, तो नतीजा, क्रम से लगाया गया अरे होता है. अगर आपको अरे को बढ़ते क्रम में लगाना है, तो कॉम्पैरेटर को तुलना से कम परफ़ॉर्मेंस करनी चाहिए. औपचारिक तौर पर, अरे को क्रम से लगाने के बाद, यह i < j वाले सभी इंडेक्स पोज़िशन, i, j के लिए उन सभी के लिए रहता है जो comparator(value[i], value[j]) = comparator(value[j], value[i]) = false या comparator(value[i], value[j]) = true में से किसी एक में हो सकते हैं.

• अगर ऑपरेंड की रैंक ऊंची है, तो ऑपरेंड को दिए गए डाइमेंशन के हिसाब से क्रम में लगाया जाता है. उदाहरण के लिए, रैंक-2 के टेंसर (मैट्रिक्स) के लिए, 0 की डाइमेंशन वैल्यू हर कॉलम को अलग-अलग क्रम में लगाती है. साथ ही, 1 डाइमेंशन वैल्यू हर लाइन को अलग-अलग क्रम में लगाती है. अगर कोई डाइमेंशन नंबर नहीं दिया जाता है, तो आखिरी डाइमेंशन को डिफ़ॉल्ट रूप से चुना जाता है. क्रम से लगाए गए किसी डाइमेंशन के लिए, क्रम से लगाने का वही क्रम लागू होता है जो रैंक-1 के मामले में लागू होता है.

अगर n > 1 ऑपरैंड दिए गए हैं:

• सभी n ऑपरेंड एक जैसे डाइमेंशन वाले टेंसर होने चाहिए. टेंसर के एलिमेंट टाइप अलग-अलग हो सकते हैं.

• सभी ऑपरेंड को एक-एक करके क्रम से लगाया जाता है, अलग-अलग नहीं. सैद्धांतिक तौर पर, ऑपरेंड को टुपल की तरह माना जाता है. जब यह जांच की जाती है कि इंडेक्स स्थितियों i और j पर हर ऑपरेंड के एलिमेंट को बदलने की ज़रूरत है या नहीं, तो तुलना करने वाले को 2 * n स्केलर पैरामीटर के साथ कॉल किया जाता है, जहां पैरामीटर 2 * k, k-th ऑपरेंड से i स्थिति पर मान से मेल खाता है और पैरामीटर 2 * k + 1, k-th ऑपरेंड की स्थिति j पर मान से मेल खाता है. आम तौर पर, तुलना करने वाला प्रोग्राम 2 * k और 2 * k + 1 पैरामीटर की तुलना एक-दूसरे से करता है. साथ ही, अन्य पैरामीटर पेयर का इस्तेमाल टाई ब्रेकर के तौर पर किया जा सकता है.

• नतीजा एक टपल है जिसमें ऑपरेंड को क्रम से लगाया जाता है. दिए गए डाइमेंशन के साथ, जैसा कि ऊपर बताया गया है. टपल का i-th ऑपरेंड, क्रम के i-th ऑपरेंड से जुड़ा होता है.

उदाहरण के लिए, अगर तीन ऑपरेंड operand0 = [3, 1], operand1 = [42, 50], operand2 = [-3.0, 1.1] हैं और तुलना करने वाला, सिर्फ़ operand0 की वैल्यू की तुलना इससे कम से करता है, तो क्रम का आउटपुट टूल ([1, 3], [50, 42], [1.1, -3.0]) होगा.

अगर is_stable को 'सही है' पर सेट किया जाता है, तो इस बात की गारंटी दी जाती है कि क्रम में कोई बदलाव नहीं होगा. इसका मतलब है कि अगर ऐसे एलिमेंट हैं जिन्हें तुलना करने वाले के हिसाब से बराबर माना जाता है, तो वैल्यू के मिलते-जुलते क्रम को सुरक्षित रखा जाता है. दो एलिमेंट e1 और e2 अगर और सिर्फ़ comparator(e1, e2) = comparator(e2, e1) = false हों, तो बराबर होते हैं. डिफ़ॉल्ट रूप से, is_stable 'गलत' पर सेट होता है.

ट्रांसपोज़ करें

tf.reshape कार्रवाई भी देखें.

Transpose(operand)

तर्क	टाइप	सिमैंटिक
operand	XlaOp	ट्रांसपोज़ करने के लिए ऑपरेंड.
permutation	ArraySlice<int64>	डाइमेंशन को अनुमति देने का तरीका.

दिए गए क्रमचय के साथ ऑपरेंड डाइमेंशन की अनुमति देता है, इसलिए ∀ i . 0 ≤ i < rank ⇒ input_dimensions[permutation[i]] = output_dimensions[i].

यह इसके जैसा ही है Reशेप(ऑपरैंड, क्रमचय, परम्युट(परम्यूटेशन, ऑपरेंड.आकार.डाइमेंशन)) जैसा ही होता है.

TriangularSolve

XlaBuilder::TriangularSolve भी देखें.

आगे या पीछे के प्रतिस्थापन की मदद से निचले या ऊपरी त्रिकोणीय गुणांक (मैट्रिक्स) वाले रैखिक समीकरणों को हल करता है. लीडिंग डाइमेंशन के साथ ब्रॉडकास्ट करते हुए, यह रूटीन a और b वैरिएबल के लिए x के लिए, किसी एक मैट्रिक्स सिस्टम op(a) * x = b या x * op(a) = b को हल करता है, जहां op(a), op(a) = a या op(a) = Transpose(a) या op(a) = Conj(Transpose(a)) है.

TriangularSolve(a, b, left_side, lower, unit_diagonal, transpose_a)

तर्क	टाइप	सिमैंटिक
a	XlaOp	[..., M, M] आकृति वाले कॉम्प्लेक्स या फ़्लोटिंग-पॉइंट टाइप की रैंक > 2.
b	XlaOp	a रैंक > 2 अरे है, जिसका आकार [..., M, K] सही है. अगर left_side सही है, तो [..., K, M] ऐसा नहीं होगा.
left_side	bool	यह बताता है कि op(a) * x = b (true) या x * op(a) = b (false) फ़ॉर्म के सिस्टम को हल करना है या नहीं.
lower	bool	a के ऊपरी या निचले त्रिभुज का उपयोग करना है या नहीं.
unit_diagonal	bool	अगर true, तो a के डायगनल एलिमेंट को 1 माना जाता है और इसे ऐक्सेस नहीं किया जा सकता.
transpose_a	Transpose	a को वैसे ही इस्तेमाल करना है, उसे ट्रांसपोज़ करना है या उसका कॉन्जुगेट ट्रांसपोज़ लेना है.

lower की वैल्यू के आधार पर, इनपुट डेटा को सिर्फ़ a के निचले/ऊपर वाले ट्राऐंगल से पढ़ा जाता है. दूसरे त्रिभुज के मानों को अनदेखा किया जाता है. आउटपुट डेटा एक ही त्रिभुज में दिखाया जाता है. दूसरे त्रिभुज में दी गई वैल्यू, लागू करने के तरीके से तय होती हैं और कुछ भी हो सकती हैं.

अगर a और b की रैंक दो से ज़्यादा है, तो उन्हें मैट्रिक्स के बैच के तौर पर माना जाता है. यहां बाकी दो छोटे डाइमेंशन, बैच डाइमेंशन होते हैं. a और b के डाइमेंशन एक जैसे होने चाहिए.

टपल

XlaBuilder::Tuple भी देखें.

एक टपल जिसमें डेटा हैंडल की अलग-अलग संख्या होती है. हर हैंडल का अपना आकार होता है.

यह C++ में std::tuple के जैसा है. सैद्धान्तिक तौर पर:

let v: f32[10] = f32[10]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
let s: s32 = 5;
let t: (f32[10], s32) = tuple(v, s);

GetTupleElement कार्रवाई की मदद से, टपल को अलग किया जा सकता है (ऐक्सेस किया जा सकता है).

हालांकि

XlaBuilder::While भी देखें.

While(condition, body, init)

तर्क	टाइप	सिमैंटिक
condition	XlaComputation	T -> PRED टाइप का XlaComputation, जो लूप खत्म होने की स्थिति के बारे में बताता है.
body	XlaComputation	T -> T टाइप का XlaComputation, जो लूप की बॉडी के बारे में बताता है.
init	T	condition और body के पैरामीटर के लिए शुरुआती वैल्यू.

body को क्रम से तब तक एक्ज़ीक्यूट करता है, जब तक condition काम नहीं करता. यह नीचे दिए गए अंतर और पाबंदियों को छोड़कर, कई दूसरी भाषाओं में लूप में चलने वाले सामान्य तरीके से मिलता-जुलता है.

• While नोड, T टाइप की वैल्यू दिखाता है, जो body के आखिरी बार लागू होने का नतीजा है.
• T टाइप का आकार स्टैटिक तरीके से तय किया जाता है और सभी बार में एक जैसा होना चाहिए.

कंप्यूटेशन के T पैरामीटर, पहले इटरेशन में init वैल्यू से शुरू होते हैं. साथ ही, बाद के हर इटरेशन में, body से नए नतीजे में अपने-आप अपडेट हो जाते हैं.

While नोड का एक मुख्य इस्तेमाल यह है कि न्यूरल नेटवर्क में ट्रेनिंग को बार-बार लागू किया जाए. सिंप्लिफ़ाइड स्युडोकोड को नीचे एक ग्राफ़ के साथ दिखाया गया है, जो कंप्यूटेशन को दिखाता है. यह कोड while_test.cc में देखा जा सकता है. इस उदाहरण में T का टाइप, Tuple है. इसमें, इटरेशन की संख्या के लिए int32 और अक्युमिलेटर के लिए vector[10] शामिल है. लूप में 1,000 बार बदलने के लिए, एक्क्यूमुलेटर में एक कॉन्सटेंट वेक्टर जोड़ता रहता है.

// Pseudocode for the computation.
init = {0, zero_vector[10]} // Tuple of int32 and float[10].
result = init;
while (result(0) < 1000) {
  iteration = result(0) + 1;
  new_vector = result(1) + constant_vector[10];
  result = {iteration, new_vector};
}