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

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

नामकरण के बारे में जानकारी: XLA जिस सामान्य डेटा टाइप से डील करता है वह एक N-डाइमेंशनल ऐरे है. इसमें एक ही तरह के एलिमेंट होते हैं. जैसे, 32-बिट फ़्लोट. पूरे दस्तावेज़ में, ऐरे का इस्तेमाल किसी भी डाइमेंशन वाले ऐरे को दिखाने के लिए किया जाता है. आसानी के लिए, खास मामलों के ज़्यादा सटीक और जाने-पहचाने नाम होते हैं. उदाहरण के लिए, वेक्टर एक डाइमेंशन वाला ऐरे होता है और मैट्रिक्स दो डाइमेंशन वाला ऐरे होता है.

शेप और लेआउट और टाइल वाला लेआउट में, Op के स्ट्रक्चर के बारे में ज़्यादा जानें.

ऐब्स

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

हर एलिमेंट का ऐब्सलूट वैल्यू x -> |x|.

Abs(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - abs देखें.

जोड़ें

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

यह फ़ंक्शन, lhs और rhs के हर एलिमेंट को जोड़ता है.

Add(lhs, rhs)

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

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

Add(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - add देखें.

AddDependency

HloInstruction::AddDependency भी देखें.

AddDependency, एचएलओ डंप में दिख सकते हैं. हालांकि, असली उपयोगकर्ताओं को इन्हें मैन्युअल तरीके से बनाने की अनुमति नहीं है.

AfterAll

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

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

AfterAll(tokens)

StableHLO के बारे में जानकारी के लिए, StableHLO - after_all देखें.

AllGather

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

यह फ़ंक्शन, रेप्लिका के बीच कॉनकेटिनेशन करता है.

AllGather(operand, all_gather_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

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

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

AllGather के एपीआई को अंदरूनी तौर पर दो एचएलओ निर्देशों (AllGatherStart और AllGatherDone) में बांटा गया है.

HloInstruction::CreateAllGatherStart भी देखें.

AllGatherStart और AllGatherDone, HLO में प्रिमिटिव के तौर पर काम करते हैं. ये ऑप्स, एचएलओ डंप में दिख सकते हैं. हालांकि, इन्हें उपयोगकर्ताओं को मैन्युअल तरीके से बनाने के लिए नहीं बनाया गया है.

StableHLO के बारे में जानकारी के लिए, StableHLO - all_gather पर जाएं.

AllReduce

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

यह फ़ंक्शन, रेप्लिका में कस्टम कंप्यूटेशन करता है.

AllReduce(operand, computation, replica_groups, channel_id, shape_with_layout, use_global_device_ids)

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

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

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

AllReduce के एपीआई को अंदरूनी तौर पर दो एचएलओ निर्देशों (AllReduceStart और AllReduceDone) में बांटा गया है.

HloInstruction::CreateAllReduceStart भी देखें.

AllReduceStart और AllReduceDone, HLO में प्रिमिटिव के तौर पर काम करते हैं. ये ऑप्स, एचएलओ डंप में दिख सकते हैं. हालांकि, इन्हें उपयोगकर्ताओं को मैन्युअल तरीके से बनाने के लिए नहीं बनाया गया है.

CrossReplicaSum

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

यह फ़ंक्शन, जोड़ के हिसाब से AllReduce करता है.

CrossReplicaSum(operand, replica_groups)

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

AllToAll

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

AllToAll एक सामूहिक ऑपरेशन है. यह सभी कोर से सभी कोर को डेटा भेजता है. इसके दो फ़ेज़ होते हैं:

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

इन कोर को इन तरीकों से कॉन्फ़िगर किया जा सकता है:

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

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

• split_dimension पर मौजूद ऑपरेंड का डाइमेंशन साइज़, split_count से भाग दिया जा सकता है.
• ऑपरेंड का शेप टपल नहीं है.

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

शेप और लेआउट के बारे में ज़्यादा जानने के लिए, xla::shapes देखें..

StableHLO के बारे में जानकारी के लिए, StableHLO - all_to_all देखें.

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 में चार कोर शामिल हैं. हर कोर पर, ऑपरेंड को डाइमेंशन 1 के हिसाब से चार हिस्सों में बांटा जाता है. इसलिए, हर हिस्से का आकार f32[4,4] होता है. चारों हिस्सों को सभी कोर में बांट दिया जाता है. इसके बाद, हर कोर को डाइमेंशन 0 के साथ मिले हुए हिस्सों को कोर 0-4 के क्रम में जोड़ता है. इसलिए, हर कोर पर आउटपुट का आकार f32[16,4] होता है.

AllToAll - दूसरा उदाहरण - StableHLO

ऊपर दिए गए उदाहरण में, AllToAll में दो रेप्लिका हिस्सा ले रहे हैं. हर रेप्लिका पर, ऑपरेंड का आकार f32[2,4] होता है. ऑपरेंड को डाइमेंशन 1 के हिसाब से दो हिस्सों में बांटा गया है. इसलिए, हर हिस्से का आकार f32[2,2] है. इसके बाद, रेप्लिका ग्रुप में उनकी जगह के हिसाब से, दोनों हिस्सों को रेप्लिका के बीच बदला जाता है. हर रेप्लिका, दोनों ऑपरेंड से अपना हिस्सा इकट्ठा करती है और उन्हें डाइमेंशन 0 के साथ जोड़ती है. इस वजह से, हर रेप्लिका पर आउटपुट का आकार f32[4,2] होता है.

RaggedAllToAll

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

RaggedAllToAll, सभी-से-सभी के लिए एक साथ काम करता है. इसमें इनपुट और आउटपुट, रैग्ड टेंसर होते हैं.

RaggedAllToAll(input, input_offsets, send_sizes, output, output_offsets, recv_sizes, replica_groups, channel_id)

रैग्ड टेंसर को तीन टेंसर के सेट से तय किया जाता है:

• data: dataटेंसर, सबसे बाहरी डाइमेंशन के साथ “रैग्ड” होता है. इसके साथ ही, इंडेक्स किए गए हर एलिमेंट का साइज़ अलग-अलग होता है.
• offsets': offsets टेंसर, data टेंसर के सबसे बाहरी डाइमेंशन को इंडेक्स करता है. साथ ही, यह data टेंसर के हर रैग्ड एलिमेंट के शुरुआती ऑफ़सेट को दिखाता है.
• sizes: sizes टेंसर, data टेंसर के हर रैग्ड एलिमेंट के साइज़ को दिखाता है. साइज़ को सब-एलिमेंट की इकाइयों में बताया जाता है. सब-एलिमेंट को ‘data’ टेंसर शेप के प्रत्यय के तौर पर तय किया जाता है. इसे सबसे बाहरी “रैग्ड” डाइमेंशन को हटाकर हासिल किया जाता है.
• offsets और sizes टेंसर का साइज़ एक जैसा होना चाहिए.

अनियमित टेंसर का उदाहरण:

data: [8,3] =
{ {a,b,c},{d,e,f},{g,h,i},{j,k,l},{m,n,o},{p,q,r},{s,t,u},{v,w,x} }

offsets: [3] = {0, 1, 4}

sizes: [3] = {1, 3, 4}

// Index 'data' at 'offsets'[0], 'sizes'[0]' // {a,b,c}

// Index 'data' at 'offsets'[1], 'sizes'[1]' // {d,e,f},{g,h,i},{j,k,l}

// Index 'data' at 'offsets'[2], 'sizes'[2]' // {m,n,o},{p,q,r},{s,t,u},{v,w,x}

output_offsets को इस तरह से शार्ड किया जाना चाहिए कि हर रेप्लिका में, टारगेट रेप्लिका आउटपुट पर्सपेक्टिव में ऑफ़सेट हों.

i-th आउटपुट ऑफ़सेट के लिए, मौजूदा रेप्लिका i-th रेप्लिका को input[input_offsets[i]:input_offsets[i]+input_sizes[i]] अपडेट भेजेगा. इसे i-th रेप्लिका output में output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] में लिखा जाएगा.

उदाहरण के लिए, अगर हमारे पास दो रेप्लिका हैं, तो:

replica 0:
input: [1, 2, 2]
output:[0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 2]
output_offsets: [0, 0]
recv_sizes: [1, 1]

replica 1:
input: [3, 4, 0]
output: [0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 1]
output_offsets: [1, 2]
recv_sizes: [2, 1]

// replica 0's result will be: [1, 3, 0, 0]
// replica 1's result will be: [2, 2, 4, 0]

रैग्ड ऑल-टू-ऑल एचएलओ में ये आर्ग्युमेंट होते हैं:

• input: इनपुट डेटा का रैग्ड टेंसर.
• output: रैग्ड आउटपुट डेटा टेंसर.
• input_offsets: यह इनपुट ऑफ़सेट का रैग्ड टेंसर है.
• send_sizes: रैग्ड सेंड साइज़ टेंसर.
• output_offsets: टारगेट रेप्लिका आउटपुट में रैग्ड ऑफ़सेट का कलेक्शन.
• recv_sizes: ragged recv sizes tensor.

*_offsets और *_sizes टेंसर का आकार एक जैसा होना चाहिए.

*_offsets और *_sizes टेंसर के लिए, दो तरह के आकार इस्तेमाल किए जा सकते हैं:

• [num_devices] जहां रैग्ड-ऑल-टू-ऑल, रेप्लिका ग्रुप में मौजूद हर रिमोट डिवाइस को ज़्यादा से ज़्यादा एक अपडेट भेज सकता है. उदाहरण के लिए:

for (remote_device_id : replica_group) {
     SEND input[input_offsets[remote_device_id]],
     output[output_offsets[remote_device_id]],
     send_sizes[remote_device_id] }

• [num_devices, num_updates] जहां रैग्ड-ऑल-टू-ऑल, रेप्लिका ग्रुप में मौजूद हर रिमोट डिवाइस के लिए, एक ही रिमोट डिवाइस को ज़्यादा से ज़्यादा num_updates अपडेट भेज सकता है. हर अपडेट अलग-अलग ऑफ़सेट पर भेजा जाता है.

उदाहरण के लिए:

for (remote_device_id : replica_group) {
    for (update_idx : num_updates) {
        SEND input[input_offsets[remote_device_id][update_idx]],
        output[output_offsets[remote_device_id][update_idx]]],
        send_sizes[remote_device_id][update_idx] } }

और

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

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

And(lhs, rhs)

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

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

And(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - and देखें.

Async

HloInstruction::CreateAsyncStart, HloInstruction::CreateAsyncUpdate, HloInstruction::CreateAsyncDone भी देखें.

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

Atan2

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

यह फ़ंक्शन, lhs और rhs पर हर एलिमेंट के हिसाब से atan2 ऑपरेशन करता है.

Atan2(lhs, rhs)

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

Atan2 के लिए, अलग-अलग डाइमेंशन में ब्रॉडकास्ट करने की सुविधा वाला एक वैकल्पिक वैरिएंट उपलब्ध है:

Atan2(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - atan2 देखें.

BatchNormGrad

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

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

BatchNormGrad(operand, scale, batch_mean, batch_var, grad_output, epsilon, feature_index)

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

इन तीन ग्रेडिएंट को इन फ़ॉर्मूलों से तय किया जाता है. इसमें 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} \]

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

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

StableHLO के बारे में जानकारी के लिए, StableHLO - batch_norm_grad देखें.

BatchNormInference

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

यह फ़ंक्शन, बैच और स्पेशल डाइमेंशन के हिसाब से किसी ऐरे को नॉर्मलाइज़ करता है.

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

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

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

आउटपुट, n डाइमेंशन वाला एक नॉर्मलाइज़ किया गया ऐरे होता है. इसका आकार, इनपुट operand के आकार जैसा होता है.

StableHLO के बारे में जानकारी के लिए, StableHLO - batch_norm_inference देखें.

BatchNormTraining

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

यह फ़ंक्शन, बैच और स्पेशल डाइमेंशन के हिसाब से किसी ऐरे को नॉर्मलाइज़ करता है.

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

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

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

• यह फ़ीचर डाइमेंशन में मौजूद हर फ़ीचर 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 का टपल होता है:

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

StableHLO के बारे में जानकारी के लिए, StableHLO - batch_norm_training देखें.

Bitcast

HloInstruction::CreateBitcast भी देखें.

Bitcast, एचएलओ डंप में दिख सकते हैं. हालांकि, असली उपयोगकर्ताओं को इन्हें मैन्युअल तरीके से बनाने की अनुमति नहीं है.

BitcastConvertType

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

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

BitcastConvertType(operand, new_element_type)

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

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

StableHLO के बारे में जानकारी के लिए, StableHLO - bitcast_convert देखें.

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

BitcastConvert HLO निर्देश, ऐसे मामले में काम करता है जहां आउटपुट एलिमेंट टाइप 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)

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

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

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

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

StableHLO के बारे में जानकारी के लिए, StableHLO - ब्रॉडकास्ट देखें.

BroadcastInDim

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

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

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

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

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

कॉल करें

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

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

Call(computation, operands...)

operands के आर्ग्युमेंट की संख्या और टाइप, computation के पैरामीटर से मेल खाने चाहिए. operands न होने की अनुमति है.

CompositeCall

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

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

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

इस ऑप को kCall के तौर पर लागू किया जाता है. इसमें is_composite=true एट्रिब्यूट होता है. decomposition फ़ील्ड को computation एट्रिब्यूट से तय किया जाता है. फ़्रंटएंड एट्रिब्यूट, composite. से पहले जोड़े गए बाकी एट्रिब्यूट को सेव करते हैं.

CompositeCall ऑप का उदाहरण:

f32[] call(f32[] %cst), to_apply=%computation, is_composite=true,
frontend_attributes = {
  composite.name="foo.bar",
  composite.attributes={n = 1 : i32, tensor = dense<1> : tensor<i32>},
  composite.version="1"
}

CompositeCall(computation, operands..., name, attributes, version)

ऑपरेशन का decomposition, कॉल किया गया फ़ील्ड नहीं है. इसके बजाय, यह to_apply एट्रिब्यूट के तौर पर दिखता है. यह उस फ़ंक्शन की ओर इशारा करता है जिसमें लोअर-लेवल का इंप्लीमेंटेशन होता है. जैसे, to_apply=%funcname

कंपोज़िट और डीकंपोज़िशन के बारे में ज़्यादा जानकारी, StableHLO स्पेसिफ़िकेशन में देखी जा सकती है.

Cbrt

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

हर एलिमेंट का घनमूल निकालने की कार्रवाई x -> cbrt(x).

Cbrt(operand)

Cbrt फ़ंक्शन में, result_accuracy आर्ग्युमेंट का इस्तेमाल किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Cbrt(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

StableHLO के बारे में जानकारी के लिए, StableHLO - cbrt देखें.

राउंड अप

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

हर एलिमेंट के लिए सीलिंग x -> ⌈x⌉.

Ceil(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - ceil देखें.

Cholesky

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

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

Cholesky(a, lower)

अगर lower true है, तो लोअर-ट्रायंगलर मैट्रिक्स l का हिसाब लगाता है, ताकि $a = l . l^T$. अगर lower false है, तो u अपर-ट्रायंगलर मैट्रिक्स का हिसाब लगाता है, ताकि \(a = u^T . u\).

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

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

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

StableHLO के बारे में जानकारी के लिए, StableHLO - cholesky देखें.

क्लैंप करें

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

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

Clamp(min, operand, max)

ऑपरेंड और कम से कम और ज़्यादा से ज़्यादा वैल्यू दिए जाने पर, अगर ऑपरेंड कम से कम और ज़्यादा से ज़्यादा वैल्यू के बीच की रेंज में है, तो ऑपरेंड दिखाता है. अगर ऑपरेंड इस रेंज से कम है, तो कम से कम वैल्यू दिखाता है. अगर ऑपरेंड इस रेंज से ज़्यादा है, तो ज़्यादा से ज़्यादा वैल्यू दिखाता है. इसका मतलब है कि 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};

StableHLO के बारे में जानकारी के लिए, StableHLO - clamp देखें.

छोटा करें

XlaBuilder::Collapse भी देखें. और tf.reshape ऑपरेशन.

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

Collapse(operand, dimensions)

Collapse, ऑपरेंड के डाइमेंशन के दिए गए सबसेट को एक डाइमेंशन से बदलता है. इनपुट आर्ग्युमेंट, 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} };

Clz

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

हर एलिमेंट के लिए, शुरुआती शून्य की गिनती करता है.

Clz(operand)

CollectiveBroadcast

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

यह सभी रेप्लिका में डेटा ब्रॉडकास्ट करता है. हर ग्रुप में, पहले रेप्लिका आईडी से डेटा को उसी ग्रुप के अन्य आईडी में भेजा जाता है. अगर रेप्लिका आईडी किसी रेप्लिका ग्रुप में नहीं है, तो उस रेप्लिका पर आउटपुट एक ऐसा टेंसर होता है जिसमें shape में 0(s) होते हैं.

CollectiveBroadcast(operand, replica_groups, channel_id)

StableHLO के बारे में जानकारी के लिए, StableHLO - collective_broadcast देखें.

CollectivePermute

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

CollectivePermute एक सामूहिक ऑपरेशन है. यह रेप्लिका के बीच डेटा भेजता और पाता है.

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

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

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

CollectivePermute ऑपरेशन का एपीआई, अंदरूनी तौर पर दो एचएलओ निर्देशों (CollectivePermuteStart और CollectivePermuteDone) में बंट जाता है.

HloInstruction::CreateCollectivePermuteStart भी देखें.

CollectivePermuteStart और CollectivePermuteDone, HLO में प्रिमिटिव के तौर पर काम करते हैं. ये ऑप, एचएलओ डंप में दिख सकते हैं. हालांकि, इन्हें उपयोगकर्ताओं को मैन्युअल तरीके से बनाने के लिए नहीं बनाया गया है.

StableHLO के बारे में जानकारी के लिए, StableHLO - collective_permute देखें.

तुलना करें

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

यह फ़ंक्शन, यहां दी गई चीज़ों के lhs और rhs की तुलना करता है:

Eq

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

यह फ़ंक्शन, lhs और rhs के हर एलिमेंट की तुलना करके यह पता लगाता है कि वे बराबर हैं या नहीं.

\(lhs = rhs\)

Eq(lhs, rhs)

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

Eq के लिए, ब्रॉडकास्टिंग की सुविधा के साथ एक वैकल्पिक वैरिएंट उपलब्ध है:

Eq(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

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

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

EqTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO के बारे में जानकारी के लिए, StableHLO - तुलना करें देखें.

Ne

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

यह फ़ंक्शन, lhs और rhs के हर एलिमेंट की तुलना करके यह पता लगाता है कि वे बराबर नहीं हैं.

\(lhs != rhs\)

Ne(lhs, rhs)

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

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

Ne(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

Ne के लिए, फ़्लोटिंग पॉइंट नंबर से ज़्यादा के कुल ऑर्डर को सपोर्ट किया जाता है. इसके लिए, यह तरीका अपनाया जाता है:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

NeTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO के बारे में जानकारी के लिए, StableHLO - तुलना करें देखें.

Ge

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

यह फ़ंक्शन, lhs और rhs की तुलना करके, यह पता लगाता है कि कौनसी वैल्यू greater-or-equal-than.

\(lhs >= rhs\)

Ge(lhs, rhs)

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

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

Ge(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

Gt के लिए, फ़्लोटिंग पॉइंट नंबर से ज़्यादा के कुल ऑर्डर की सुविधा उपलब्ध है. इसके लिए, यह ज़रूरी है कि:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

GtTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO के बारे में जानकारी के लिए, StableHLO - तुलना करें देखें.

Gt

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

यह फ़ंक्शन, lhs और rhs की हर वैल्यू की तुलना करके यह पता लगाता है कि कौनसी वैल्यू बड़ी है.

\(lhs > rhs\)

Gt(lhs, rhs)

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

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

Gt(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - तुलना करें देखें.

ले

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

यह फ़ंक्शन, lhs और rhs की हर वैल्यू की तुलना करके यह पता लगाता है कि lhs की वैल्यू, rhs की वैल्यू से less-or-equal-than.

\(lhs <= rhs\)

Le(lhs, rhs)

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

Le के लिए, अलग-अलग डाइमेंशन में ब्रॉडकास्ट करने की सुविधा वाला एक वैकल्पिक वैरिएंट उपलब्ध है:

Le(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

Le के लिए, फ़्लोटिंग पॉइंट नंबर के हिसाब से कुल ऑर्डर की सुविधा उपलब्ध है. इसके लिए, यह तरीका अपनाएं:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LeTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO के बारे में जानकारी के लिए, StableHLO - तुलना करें देखें.

Lt

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

यह फ़ंक्शन, lhs और rhs की तुलना करके, यह पता लगाता है कि कौनसी वैल्यू छोटी है.

\(lhs < rhs\)

Lt(lhs, rhs)

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

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

Lt(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

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

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LtTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO के बारे में जानकारी के लिए, StableHLO - तुलना करें देखें.

पेचीदा लेवल

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

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

Complex(lhs, rhs)

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

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

Complex(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - complex देखें.

ConcatInDim (Concatenate)

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

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

Concatenate(operands..., dimension)

dimension को छोड़कर, सभी डाइमेंशन एक जैसे होने चाहिए. ऐसा इसलिए है, क्योंकि XLA "रैग्ड" ऐरे के साथ काम नहीं करता. यह भी ध्यान दें कि शून्य डाइमेंशन वाली वैल्यू को एक साथ नहीं जोड़ा जा सकता. ऐसा इसलिए, क्योंकि उस डाइमेंशन का नाम नहीं दिया जा सकता जिसके हिसाब से वैल्यू को एक साथ जोड़ा जाता है.

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

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
//Output:  {2, 3, 4, 5, 6, 7}

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

let a = { {1, 2},
         {3, 4},
         {5, 6} };

let b = { {7, 8} };

Concat({a, b}, 0)

//Output:  { {1, 2},
//          {3, 4},
//          {5, 6},
//          {7, 8} }

डायग्राम:

StableHLO के बारे में जानकारी के लिए, StableHLO - concatenate देखें.

कंडीशनल

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

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

अगर predicate true है, तो true_computation को लागू करता है. अगर predicate false है, तो false_computation को लागू करता है. इसके बाद, नतीजा दिखाता है.

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

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

Conditional(branch_index, branch_computations, branch_operands)

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 को लागू किया जाएगा.

StableHLO के बारे में जानकारी के लिए, StableHLO - if देखें.

स्थिर

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

यह फ़ंक्शन, किसी कॉन्स्टेंट literal से output बनाता है.

Constant(literal)

StableHLO के बारे में जानकारी के लिए, StableHLO - constant देखें.

ConvertElementType

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

C++ में मौजूद एलिमेंट-वाइज़ static_cast की तरह ही, ConvertElementType भी डेटा शेप से टारगेट शेप में एलिमेंट-वाइज़ कन्वर्ज़न ऑपरेशन करता है. डाइमेंशन मेल खाने चाहिए.साथ ही, कन्वर्ज़न एलिमेंट के हिसाब से होना चाहिए. उदाहरण के लिए, s32 एलिमेंट, s32-से-f32 कन्वर्ज़न रूटीन के ज़रिए f32 एलिमेंट बन जाते हैं.

ConvertElementType(operand, new_element_type)

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

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}

StableHLO के बारे में जानकारी के लिए, StableHLO - convert देखें.

Conv (कॉन्वोल्यूशन)

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

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

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

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

Conv(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

Conv के लिए, कंट्रोल के ज़्यादा लेवल उपलब्ध हैं:

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

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

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

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

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

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

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

lhs_dilation और rhs_dilation आर्ग्युमेंट, हर स्पेस डाइमेंशन में एलएचएस और आरएचएस पर लागू होने वाले डाइलेशन फ़ैक्टर के बारे में बताते हैं. अगर किसी स्पेशल डाइमेंशन में डाइलटेशन फ़ैक्टर 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-वें ग्रुप का इस्तेमाल, कई अलग-अलग कनवोल्यूशन के लिए 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: कर्नल (rhs) पर मौजूद output-z के साइज़ के बराबर.
• spatial_dims: कनवोल्यूशनल विंडो के हर मान्य प्लेसमेंट के लिए एक वैल्यू.

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

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

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

ध्यान दें कि अगर 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;
}

precision_config का इस्तेमाल, सटीक कॉन्फ़िगरेशन के बारे में बताने के लिए किया जाता है. लेवल से यह तय होता है कि हार्डवेयर को ज़्यादा मशीन कोड जनरेट करने की कोशिश करनी चाहिए या नहीं.इससे ज़रूरत पड़ने पर, ज़्यादा सटीक dtype इम्यूलेशन उपलब्ध कराया जा सकता है. जैसे, ऐसे टीपीयू पर f32 का इम्यूलेशन करना जो सिर्फ़ bf16 matmuls के साथ काम करता है. वैल्यू DEFAULT, HIGH, HIGHEST हो सकती हैं. MXU सेक्शन में ज़्यादा जानकारी.

preferred_element_type एक स्केलर एलिमेंट है. इसका इस्तेमाल, ज़्यादा/कम सटीक आउटपुट टाइप को इकट्ठा करने के लिए किया जाता है. preferred_element_type, दी गई कार्रवाई के लिए संचय टाइप का सुझाव देता है. हालांकि, इसकी कोई गारंटी नहीं है. इससे कुछ हार्डवेयर बैकएंड, किसी दूसरे टाइप में इकट्ठा हो जाते हैं और पसंदीदा आउटपुट टाइप में बदल जाते हैं.

StableHLO के बारे में जानकारी के लिए, StableHLO - कनवोल्यूशन देखें.

ConvWithGeneralPadding

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

ConvWithGeneralPadding(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

यह Conv के जैसा ही है, जिसमें पैडिंग कॉन्फ़िगरेशन साफ़ तौर पर बताया गया है.

ConvWithGeneralDimensions

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

ConvWithGeneralDimensions(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

यह Conv जैसा ही है. इसमें डाइमेंशन नंबर साफ़ तौर पर दिए गए हैं.

ConvGeneral

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

ConvGeneral(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

Conv के जैसा ही है. इसमें डाइमेंशन नंबर और पैडिंग कॉन्फ़िगरेशन साफ़ तौर पर बताया गया है

ConvGeneralDilated

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

ConvGeneralDilated(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type, window_reversal)

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

कॉपी करें

HloInstruction::CreateCopyStart भी देखें.

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

Cos

यह भी देखेंXlaBuilder::Cos.

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

Cos(operand)

Cos में, result_accuracy आर्ग्युमेंट का इस्तेमाल भी किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Cos(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

StableHLO के बारे में जानकारी के लिए, StableHLO - cosine देखें.

Cosh

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

हर एलिमेंट के लिए हाइपरबोलिक कोसाइन x -> cosh(x).

Cosh(operand)

Cosh फ़ंक्शन में, result_accuracy आर्ग्युमेंट का इस्तेमाल भी किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Cosh(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

CustomCall

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

कैलकुलेशन के दौरान, उपयोगकर्ता के दिए गए फ़ंक्शन को कॉल करें.

CustomCall के बारे में दस्तावेज़, डेवलपर की जानकारी - XLA Custom Calls में दिया गया है

StableHLO के बारे में जानकारी के लिए, StableHLO - custom_call देखें.

डिवीजन

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

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

Div(lhs, rhs)

पूर्णांक को भाग देने पर ओवरफ़्लो (शून्य से भाग देने पर या INT_SMIN को -1 से भाग देने पर, साइंड/अनसाइंड डिविज़न/रीमाइंडर) होने पर, लागू करने के लिए तय की गई वैल्यू मिलती है.

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

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

Div(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - divide देखें.

डोमेन

HloInstruction::CreateDomain भी देखें.

Domain, एचएलओ डंप में दिख सकता है. हालांकि, इसे असली उपयोगकर्ताओं को मैन्युअल तरीके से नहीं बनाना चाहिए.

डॉट

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

Dot(lhs, rhs, precision_config, preferred_element_type)

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

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

precision_config का इस्तेमाल, सटीक कॉन्फ़िगरेशन के बारे में बताने के लिए किया जाता है. लेवल से यह तय होता है कि हार्डवेयर को ज़्यादा मशीन कोड जनरेट करने की कोशिश करनी चाहिए या नहीं.इससे ज़रूरत पड़ने पर, ज़्यादा सटीक dtype इम्यूलेशन उपलब्ध कराया जा सकता है. जैसे, ऐसे टीपीयू पर f32 का इम्यूलेशन करना जो सिर्फ़ bf16 matmuls के साथ काम करता है. वैल्यू DEFAULT, HIGH, HIGHEST हो सकती हैं. MXU सेक्शन में ज़्यादा जानकारी.

preferred_element_type एक स्केलर एलिमेंट है. इसका इस्तेमाल, ज़्यादा/कम सटीक आउटपुट टाइप को इकट्ठा करने के लिए किया जाता है. preferred_element_type, दी गई कार्रवाई के लिए संचय टाइप का सुझाव देता है. हालांकि, इसकी कोई गारंटी नहीं है. इससे कुछ हार्डवेयर बैकएंड, किसी दूसरे टाइप में इकट्ठा हो जाते हैं और पसंदीदा आउटपुट टाइप में बदल जाते हैं.

StableHLO के बारे में जानकारी के लिए, StableHLO - dot देखें.

DotGeneral

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

DotGeneral(lhs, rhs, dimension_numbers, precision_config, preferred_element_type)

यह Dot के जैसा ही है. हालांकि, इसमें lhs और 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} } }

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

precision_config का इस्तेमाल, सटीक कॉन्फ़िगरेशन के बारे में बताने के लिए किया जाता है. लेवल से यह तय होता है कि हार्डवेयर को ज़्यादा मशीन कोड जनरेट करने की कोशिश करनी चाहिए या नहीं.इससे ज़रूरत पड़ने पर, ज़्यादा सटीक dtype इम्यूलेशन उपलब्ध कराया जा सकता है. जैसे, ऐसे टीपीयू पर f32 का इम्यूलेशन करना जो सिर्फ़ bf16 matmuls के साथ काम करता है. वैल्यू DEFAULT, HIGH, HIGHEST हो सकती हैं. ज़्यादा जानकारी MXU सेक्शन में देखी जा सकती है.

preferred_element_type एक स्केलर एलिमेंट है. इसका इस्तेमाल, ज़्यादा/कम सटीक आउटपुट टाइप को इकट्ठा करने के लिए किया जाता है. preferred_element_type, दी गई कार्रवाई के लिए संचय टाइप का सुझाव देता है. हालांकि, इसकी कोई गारंटी नहीं है. इससे कुछ हार्डवेयर बैकएंड, किसी दूसरे टाइप में इकट्ठा हो जाते हैं और पसंदीदा आउटपुट टाइप में बदल जाते हैं.

StableHLO के बारे में जानकारी के लिए, StableHLO - dot_general देखें.

ScaledDot

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

ScaledDot(lhs, lhs_scale, rhs, rhs_scale, dimension_number, precision_config,preferred_element_type)

यह DotGeneral के जैसा ही है.

यह 'lhs', 'lhs_scale', 'rhs', और 'rhs_scale' ऑपरेंड के साथ एक स्केल्ड डॉट ऑप बनाता है. इसमें 'dimension_numbers' में दिए गए कॉन्ट्रैक्टिंग और बैच डाइमेंशन शामिल होते हैं.

RaggedDot

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

RaggedDot कंप्यूटेशन के बारे में ज़्यादा जानने के लिए, StableHLO - chlo.ragged_dot पर जाएं

DynamicReshape

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

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

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

StableHLO के बारे में जानकारी के लिए, StableHLO - dynamic_reshape देखें.

DynamicSlice

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

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

DynamicSlice(operand, start_indices, slice_sizes)

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

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

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

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

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

DynamicSlice(a, s, {2});
// Result: {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});
//Result:
// { { 7.0,  8.0},
//   {10.0, 11.0} }

StableHLO के बारे में जानकारी के लिए, StableHLO - dynamic_slice देखें.

DynamicUpdateSlice

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

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

DynamicUpdateSlice(operand, update, start_indices)

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

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

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

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

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)
// Result: {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)
// Result:
// { {0.0,  1.0,  2.0},
//   {3.0, 12.0, 13.0},
//   {6.0, 14.0, 15.0},
//   {9.0, 16.0, 17.0} }

StableHLO के बारे में जानकारी के लिए, StableHLO - dynamic_update_slice देखें.

Erf

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

हर एलिमेंट के लिए एरर फ़ंक्शन x -> erf(x), जहां:

\(\text{erf}(x) = \frac{2}{\sqrt{\pi} }\int_0^x e^{-t^2} \, dt\).

Erf(operand)

Erf फ़ंक्शन में, result_accuracy आर्ग्युमेंट का इस्तेमाल भी किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Erf(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

आखिरी तारीख

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

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

Exp(operand)

Exp में, result_accuracy आर्ग्युमेंट का इस्तेमाल भी किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Exp(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

StableHLO के बारे में जानकारी के लिए, StableHLO - exponential देखें.

Expm1

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

हर एलिमेंट के लिए, नैचुरल एक्सपोनेंशियल माइनस वन x -> e^x - 1.

Expm1(operand)

Expm1 फ़ंक्शन में, result_accuracy आर्ग्युमेंट का इस्तेमाल किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Expm1(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

StableHLO के बारे में जानकारी के लिए, StableHLO - exponential_minus_one देखें.

Fft

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

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

Fft(operand, ftt_type, fft_length)

StableHLO के बारे में जानकारी के लिए, StableHLO - fft देखें.

मल्टीडाइमेंशनल एफ़एफ़टी

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

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

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

मंज़िल

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

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

Floor(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - फ़्लोर देखें.

फ़्यूज़न

HloInstruction::CreateFusion भी देखें.

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

इकट्ठा करना

XLA का gather ऑपरेशन, इनपुट ऐरे के कई स्लाइस को एक साथ जोड़ता है. हर स्लाइस, रनटाइम के अलग-अलग ऑफ़सेट पर होता है.

StableHLO के बारे में जानकारी के लिए, StableHLO - gather देखें.

जनरल सिमैंटिक्स

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

gather(operand, start_indices, dimension_numbers, slice_sizes, indices_are_sorted)

सुविधा के लिए, हम आउटपुट ऐरे में मौजूद डाइमेंशन को 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 में से उससे जुड़े डाइमेंशन बाउंड चुनते हैं. ऐसा करते समय, index_vector_dim को छोड़ दिया जाता है. इसका मतलब है कि अगर k < index_vector_dim है, तो start_indices.shape.dims[k] चुनें. इसके अलावा, start_indices.shape.dims[k+1] चुनें.

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. मान लें कि G = { Out[k] for k in batch_dims }. G का इस्तेमाल करके, वेक्टर S को इस तरह से स्लाइस करें कि S[i] = start_indices[Combine(G, i)] हो. यहां Combine(A, b) का मतलब है कि b को A में index_vector_dim पोज़िशन पर डाला गया है. ध्यान दें कि G की वैल्यू खाली होने पर भी, इसे अच्छी तरह से तय किया जाता है: अगर G की वैल्यू खाली है, तो S = start_indices.

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

   1. Sin[start_index_map[k]] = S[k] if k < start_index_map.size.

   2. Sin[_] = 0.

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

   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 से मेल खाता है. इसकी गणना इस तरह की जाती है:

• हम Out में मौजूद बैच डाइमेंशन का इस्तेमाल करके, start_indices से शुरुआती इंडेक्स ढूंढते हैं.

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

• हम पूरे शुरुआती इंडेक्स का इस्तेमाल करके, 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] ऐरे के तौर पर दिखाया जा सकता है.

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

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

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

यह gather ऑपरेशन, G को बैच डाइमेंशन के तौर पर इस्तेमाल करने वाले बैच डाइनैमिक स्लाइस की तरह काम करता है.

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

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

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

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

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

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

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

G0 और G1 का इस्तेमाल, सामान्य तौर पर gather इंडेक्स ऐरे से शुरुआती इंडेक्स को स्लाइस करने के लिए किया जाता है. हालांकि, शुरुआती इंडेक्स में सिर्फ़ एक एलिमेंट, X होता है. इसी तरह, वैल्यू O0 के साथ सिर्फ़ एक आउटपुट ऑफ़सेट इंडेक्स है. हालांकि, इनपुट ऐरे में इंडेक्स के तौर पर इस्तेमाल किए जाने से पहले, इन्हें "Gather Index Mapping" (start_index_map in the formal description) और "Offset Mapping" (remapped_offset_dims in the formal description) के मुताबिक [X,0] और [0,O0] में बदल दिया जाता है. इसके बाद, ये [X,O0] में जुड़ जाते हैं. दूसरे शब्दों में कहें, तो आउटपुट इंडेक्स [G0,G1,O0] को इनपुट इंडेक्स [GatherIndices[G0,G1,0],O0] पर मैप किया जाता है. इससे हमें tf.gather_nd के सिमैंटिक मिलते हैं.

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

GetDimensionSize

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

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

GetDimensionSize(operand, dimension)

StableHLO के बारे में जानकारी के लिए, StableHLO - get_dimension_size देखें.

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 भी देखें.

GetTupleElement(tuple_data, index)

StableHLO के बारे में जानकारी के लिए, StableHLO - get_tuple_element देखें.

Imag

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

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

Imag(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - imag देखें.

इनफ़ीड

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

Infeed(shape, config)

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

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

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

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

StableHLO के बारे में जानकारी के लिए, StableHLO - infeed देखें.

आयोटा

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

Iota(shape, iota_dimension)

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

उदाहरण के लिए, 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 ]]

StableHLO के बारे में जानकारी के लिए, StableHLO - iota देखें.

IsFinite

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

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

IsFinite(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - is_finite देखें.

लॉग

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

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

Log(operand)

लॉग में, result_accuracy आर्ग्युमेंट का इस्तेमाल भी किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Log(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

StableHLO के बारे में जानकारी के लिए, StableHLO - log देखें.

Log1p

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

हर एलिमेंट के लिए, नैचुरल लॉगारिद्म को x -> ln(1+x) से शिफ्ट किया गया है.

Log1p(operand)

Log1p फ़ंक्शन में, result_accuracy आर्ग्युमेंट का इस्तेमाल भी किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Log1p(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

StableHLO के बारे में जानकारी के लिए, StableHLO - log_plus_one देखें.

लॉजिस्टिक

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

हर एलिमेंट के लिए लॉजिस्टिक फ़ंक्शन की गणना x -> logistic(x).

Logistic(operand)

लॉजिस्टिक फ़ंक्शन में, result_accuracy आर्ग्युमेंट का इस्तेमाल भी किया जा सकता है. हालांकि, यह ज़रूरी नहीं है:

Logistic(operand, result_accuracy)

result_accuracy के बारे में ज़्यादा जानकारी के लिए, नतीजों की सटीकता देखें.

StableHLO के बारे में जानकारी के लिए, StableHLO - लॉजिस्टिक्स देखें.

मैप

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

Map(operands..., computation, dimensions)

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

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

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

StableHLO के बारे में जानकारी के लिए, StableHLO - map देखें.

ज़्यादा से ज़्यादा

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

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

Max(lhs, rhs)

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

Max के लिए, अलग-अलग डाइमेंशन में ब्रॉडकास्ट करने की सुविधा के साथ एक वैकल्पिक वैरिएंट उपलब्ध है:

Max(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - maximum देखें.

कम से कम

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

यह lhs और rhs पर, एलिमेंट के हिसाब से min ऑपरेशन करता है.

Min(lhs, rhs)

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

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

Min(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - minimum देखें.

Mul

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

यह lhs और rhs के हर एलिमेंट का प्रॉडक्ट दिखाता है.

Mul(lhs, rhs)

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

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

Mul(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - multiply देखें.

Neg

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

हर एलिमेंट के हिसाब से नेगेशन x -> -x.

Neg(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - negate देखें

नहीं

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

हर एलिमेंट के लिए लॉजिकल नॉट x -> !(x).

Not(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - not देखें.

OptimizationBarrier

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

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

OptimizationBarrier(operand)

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

StableHLO के बारे में जानकारी के लिए, StableHLO - optimization_barrier देखें.

या

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

यह फ़ंक्शन, lhs और rhs के हर एलिमेंट के लिए OR ऑपरेशन करता है .

Or(lhs, rhs)

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

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

Or(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - or देखें.

आउटफ़ीड

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

यह फ़ंक्शन, आउटफ़ीड में इनपुट लिखता है.

Outfeed(operand, shape_with_layout, outfeed_config)

shape_with_layout से, हमें उस लेआउट के बारे में पता चलता है जिसे हमें आउटपुट के तौर पर दिखाना है.

StableHLO के बारे में जानकारी के लिए, StableHLO - outfeed देखें.

पैड

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

Pad(operand, padding_value, padding_config)

यह फ़ंक्शन, दी गई 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 वैल्यू के उदाहरण दिखाए गए हैं.

StableHLO के बारे में जानकारी के लिए, StableHLO - pad देखें.

पैरामीटर

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

Parameter, कैलकुलेशन के लिए आर्ग्युमेंट के तौर पर दिए गए इनपुट को दिखाता है.

PartitionID

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

इससे मौजूदा प्रोसेस का partition_id जनरेट होता है.

PartitionID(shape)

PartitionID, एचएलओ डंप में दिख सकता है. हालांकि, इसे असली उपयोगकर्ताओं को मैन्युअल तरीके से बनाने के लिए नहीं बनाया गया है.

StableHLO के बारे में जानकारी के लिए, StableHLO - partition_id देखें.

PopulationCount

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

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

PopulationCount(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - popcnt देखें.

Pow

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

यह फ़ंक्शन, lhs के हर एलिमेंट को rhs के हर एलिमेंट से गुणा करता है.

Pow(lhs, rhs)

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

Pow के लिए, अलग-अलग डाइमेंशन में ब्रॉडकास्ट करने की सुविधा के साथ एक वैकल्पिक वैरिएंट उपलब्ध है:

Pow(lhs,rhs, broadcast_dimensions)

इस वैरिएंट का इस्तेमाल, अलग-अलग रैंक की ऐरे के बीच अंकगणितीय कार्रवाइयों के लिए किया जाना चाहिए. जैसे, किसी मैट्रिक्स में वेक्टर जोड़ना.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - power पर जाएं.

रियल

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

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

Real(operand)

StableHLO के बारे में जानकारी के लिए, StableHLO - real देखें.

Recv

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

Recv, RecvWithTokens, और RecvToHost, HLO में कम्यूनिकेशन प्रिमिटिव के तौर पर काम करते हैं. ये ऑप आम तौर पर, एचएलओ डंप में लो-लेवल इनपुट/आउटपुट या क्रॉस-डिवाइस ट्रांसफ़र के हिस्से के तौर पर दिखते हैं. हालांकि, इन्हें असली उपयोगकर्ताओं को मैन्युअल तरीके से बनाने के लिए नहीं बनाया गया है.

Recv(shape, handle)

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

StableHLO के बारे में जानकारी के लिए, StableHLO - recv देखें.

RecvDone

HloInstruction::CreateRecv और HloInstruction::CreateRecvDone भी देखें.

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

Recv(const Shape& shape, int64 channel_id)

यह कुकी, एक ही channel_id वाले Send निर्देश से डेटा पाने के लिए ज़रूरी संसाधन उपलब्ध कराती है. यह फ़ंक्शन, असाइन किए गए संसाधनों के लिए कॉन्टेक्स्ट दिखाता है. इसका इस्तेमाल, RecvDone निर्देश के ज़रिए डेटा ट्रांसफ़र पूरा होने का इंतज़ार करने के लिए किया जाता है. कॉन्टेक्स्ट, {receive buffer (shape), request identifier (U32)} का टपल होता है. इसका इस्तेमाल सिर्फ़ RecvDone निर्देश के लिए किया जा सकता है.

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

Reduce

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

यह फ़ंक्शन, एक या उससे ज़्यादा अरे पर एक साथ रिडक्शन फ़ंक्शन लागू करता है.

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

कहां:

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

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

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

StableHLO के बारे में जानकारी के लिए, StableHLO - reduce देखें.

उदाहरण

जब [10, 11, 12, 13] वैल्यू वाले एक डाइमेंशन के ऐरे को f (यह computation है) रिडक्शन फ़ंक्शन के साथ कम किया जाता है, तो उसे इस तरह से कैलकुलेट किया जा सकता है

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 number of dimensions 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 कलेक्शन (मैट्रिक्स) को कम करने का एक उदाहरण दिया गया है. शेप में दो डाइमेंशन हैं. डाइमेंशन 0 का साइज़ 2 है और डाइमेंशन 1 का साइज़ 3 है:

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

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

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

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

|  4   8  12 |
| 16  20  24 |

डाइमेंशन 2 को कम करने पर, हमें दो डाइमेंशन वाली एक ऐसी सरणी मिलती है जिसमें डाइमेंशन 2 की सभी वैल्यू को एक अदिश में शामिल किया गया है:

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

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

हम एक साथ कई डाइमेंशन भी कम कर सकते हैं. डाइमेंशन 0 और 1 को कम करने पर, 1D ऐरे [20, 28, 36] मिलता है.

सभी डाइमेंशन में 3D ऐरे को कम करने पर, स्केलर 84 मिलता है.

Variadic Reduce

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

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

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

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

एक डाइमेंशन वाले इनपुट ऐरे 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))

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

ReducePrecision

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

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

ReducePrecision(operand, exponent_bits, mantissa_bits)

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

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

StableHLO के बारे में जानकारी के लिए, StableHLO - reduce_precision देखें.

ReduceScatter

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

ReduceScatter एक सामूहिक ऑपरेशन है. यह AllReduce ऑपरेशन को असरदार तरीके से पूरा करता है. इसके बाद, नतीजे को shard_count ब्लॉक में बांटकर स्कैटर करता है. रेप्लिका ग्रुप में मौजूद scatter_dimension और रेप्लिका i को ith शार्ड मिलता है.

ReduceScatter(operand, computation, scatter_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• जब 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 का इस्तेमाल क्रॉस-मॉड्यूल कम्यूनिकेशन के लिए किया जाता है: सिर्फ़ एक ही channel_id वाले reduce-scatter ऑपरेशन एक-दूसरे से कम्यूनिकेट कर सकते हैं.
• layout लेआउट के बारे में ज़्यादा जानकारी के लिए, xla::shapes देखें.
• use_global_device_ids, उपयोगकर्ता की ओर से तय किया गया फ़्लैग है. जब false(डिफ़ॉल्ट) replica_groups में मौजूद संख्याएं ReplicaId होती हैं, तब true replica_groups, (ReplicaID*partition_count + partition_id) के ग्लोबल आईडी को दिखाती हैं. उदाहरण के लिए:
  • इसमें दो रेप्लिका और चार पार्टीशन हैं,
  • replica_groups={ {0,1,4,5},{2,3,6,7} } and use_global_device_ids=true
  • group[0] = (0,0), (0,1), (1,0), (1,1)
  • group[1] = (0,2), (0,3), (1,2), (1,3)
  • यहां हर पेयर (replica_id, partition_id) है.

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

StableHLO के बारे में जानकारी के लिए, StableHLO - reduce_scatter पर जाएं.

ReduceScatter - Example 1 - StableHLO

ऊपर दिए गए उदाहरण में, ReduceScatter में दो रेप्लिका हिस्सा ले रहे हैं. हर रेप्लिका पर, ऑपरेंड का आकार f32[2,4] होता है. सभी रेप्लिका में, सभी को कम करने (जोड़ने) की कार्रवाई की जाती है. इससे हर रेप्लिका पर, f32[2,4] शेप की कम की गई वैल्यू मिलती है. इसके बाद, कम की गई इस वैल्यू को डाइमेंशन 1 के हिसाब से दो हिस्सों में बांट दिया जाता है. इसलिए, हर हिस्से का आकार f32[2,2] होता है. प्रोसेस ग्रुप में मौजूद हर रेप्लिका को, ग्रुप में उसकी पोज़िशन के हिसाब से डेटा मिलता है. इस वजह से, हर रेप्लिका पर आउटपुट का आकार f32[2,2] होता है.

ReduceWindow

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

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

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

कहां:

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

StableHLO के बारे में जानकारी के लिए, StableHLO - reduce_window देखें.

ReduceWindow - Example 1

इनपुट, [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);