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

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

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

शेप और लेआउट और टाइल वाला लेआउट में, 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 वाले channel_id ऑपरेशन एक-दूसरे से कम्यूनिकेट कर सकते हैं.all-gather
• use_global_device_ids अगर ReplicaGroup कॉन्फ़िगरेशन में मौजूद आईडी, रेप्लिका आईडी के बजाय (replica_id * partition_count + partition_id) के ग्लोबल आईडी को दिखाते हैं, तो यह फ़ंक्शन सही वैल्यू दिखाता है. इससे डिवाइसों को ज़्यादा आसानी से ग्रुप किया जा सकता है. ऐसा तब होता है, जब ऑल-रिड्यूस, क्रॉस-पार्टिशन और क्रॉस-रेप्लिका, दोनों हो.

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

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

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

AllGatherStart, AllGatherDone, HLO में प्रिमिटिव के तौर पर काम करते हैं. ये ऑप्स, 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 वाले 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 टेंसर के हर रैग्ड एलिमेंट के साइज़ को दिखाता है. साइज़ को सब-एलिमेंट की यूनिट में बताया जाता है. सब-एलिमेंट को, ‘डेटा’ टेंसर शेप के सफ़िक्स के तौर पर तय किया जाता है. इसे सबसे बाहरी “रैग्ड” डाइमेंशन को हटाकर हासिल किया जाता है.
• 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]+send_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: ragged input offsets tensor.
• 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 में प्रिमिटिव के तौर पर काम करते हैं. ये ऑप, 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)

फ़ीचर डाइमेंशन (feature_index, operand में फ़ीचर डाइमेंशन का इंडेक्स है) में मौजूद हर फ़ीचर के लिए, यह ऑपरेशन 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)

फ़ंक्शन, फ़ीचर डाइमेंशन (operand में फ़ीचर डाइमेंशन का इंडेक्स feature_index है) की हर फ़ीचर के लिए, अन्य सभी डाइमेंशन के हिसाब से औसत और वैरिएंस का हिसाब लगाता है. साथ ही, 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)

फ़ंक्शन, फ़ीचर डाइमेंशन (operand में फ़ीचर डाइमेंशन का इंडेक्स feature_index है) की हर फ़ीचर के लिए, अन्य सभी डाइमेंशन के हिसाब से औसत और वैरिएंस का हिसाब लगाता है. साथ ही, 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 एचएलओ निर्देश, ऐसे मामले में काम करता है जहां आउटपुट एलिमेंट टाइप 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) का इस्तेमाल यह बताने के लिए किया जाता है कि कंपोज़िट के सिमैंटिक कब बदलते हैं.

इस कार्रवाई को is_composite=true एट्रिब्यूट के साथ kCall के तौर पर लागू किया जाता है. 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 के निचले/ऊपरी त्रिकोण से पढ़ा जाता है. यह 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 के डाइमेंशन का क्रम से लगा हुआ सबसेट होना चाहिए. इसमें डाइमेंशन की संख्या कम से ज़्यादा होनी चाहिए. इसलिए, {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 होते हैं.

CollectiveBroadcast(operand, replica_groups, channel_id)

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

CollectivePermute

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

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

CollectivePermute(operand, source_target_pairs, channel_id)

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

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

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 की तुलना करके, यह पता लगाता है कि कौनसी वैल्यू 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 जैसे कन्वर्ज़न के लिए, सामान्य बनाने वाली int-to-float कन्वर्ज़न रूटीन का इस्तेमाल किया जाएगा. जैसे, round-to-nearest-even.

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) में शून्य जोड़ती है, ताकि स्ट्राइडिंग को ध्यान में न रखने पर, आउटपुट का आकार इनपुट के आकार जैसा ही हो. VALID पैडिंग का मतलब है कि कोई पैडिंग नहीं है.

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)-डाइमेंशनल ऐरे है. इसे इनपुट कहा जाता है. हालांकि, rhs भी एक इनपुट है. न्यूरल नेटवर्क में, ये इनपुट ऐक्टिवेशन होते हैं. 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 होल अपने-आप जुड़ जाते हैं. इससे ऐरे का साइज़ बढ़ जाता है. इन जगहों को no-op वैल्यू से भरा जाता है. कनवोल्यूशन के लिए, इसका मतलब शून्य होता है.

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

डेप्थवाइज़ कनवोल्यूशन के लिए, 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 डाइमेंशन में 5 वैल्यू जनरेट करती है. इन वैल्यू में यह अंतर होता है कि कनवोल्यूशनल कर्नल का कौन-सा हिस्सा इस्तेमाल किया जाता है. हर 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 इम्यूलेशन उपलब्ध कराया जा सके. जैसे, सिर्फ़ bf16 matmuls के साथ काम करने वाले टीपीयू पर f32 का इम्यूलेशन करना. वैल्यू 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 देखें.

कोश

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 इम्यूलेशन उपलब्ध कराया जा सके. जैसे, सिर्फ़ bf16 matmuls के साथ काम करने वाले टीपीयू पर f32 का इम्यूलेशन करना. वैल्यू 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 इम्यूलेशन उपलब्ध कराया जा सके. जैसे, सिर्फ़ bf16 matmuls के साथ काम करने वाले टीपीयू पर f32 का इम्यूलेशन करना. वैल्यू 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, इनपुट कलेक्शन से dynamic 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 इस्तेमाल किए जा सकते हैं.

Fft(operand, ftt_type, fft_length)

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

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

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

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

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

मंज़िल

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

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

Floor(operand)

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

फ़्यूज़न

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

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

Gather

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 को operand में S की मदद से बिखेरकर, Sin नाम का शुरुआती इंडेक्स बनाएं. ज़्यादा सटीक तौर पर:

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

   2. Sin[_] = 0.

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

   1. Oin[remapped_offset_dims(k)] = Out[offset_dims[k]] if k < offset_dims.size (remapped_offset_dims is defined below).

   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] शेप के 5 स्लाइस इकट्ठा किए गए हैं. [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₁ की रेंज तय होती है. इससे स्लाइस की सीमाएं तय होती हैं.

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

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

यह फिर से बैच डाइमेंशन के तौर पर, बैच डाइनैमिक स्लाइस 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 का इस्तेमाल, सामान्य तौर पर गैदर इंडेक्स कलेक्शन से शुरुआती इंडेक्स को स्लाइस करने के लिए किया जाता है. हालांकि, शुरुआती इंडेक्स में सिर्फ़ एक एलिमेंट, X होता है. इसी तरह, आउटपुट ऑफ़सेट इंडेक्स में सिर्फ़ एक एलिमेंट होता है, जिसकी वैल्यू O0 होती है. हालांकि, इनपुट कलेक्शन में इंडेक्स के तौर पर इस्तेमाल किए जाने से पहले, इन्हें "गैदर इंडेक्स मैपिंग" (औपचारिक ब्यौरे में start_index_map) और "ऑफ़सेट मैपिंग" (औपचारिक ब्यौरे में remapped_offset_dims) के मुताबिक [X,0] और [0,O0] में बदल दिया जाता है. इसके बाद, ये [X,O0] में जुड़ जाते हैं. दूसरे शब्दों में कहें, तो आउटपुट इंडेक्स [G0,G1,O0], इनपुट इंडेक्स [GatherIndices[G0,G_1,0],O0] पर मैप करता है. इससे हमें tf.gather_nd के सिमैंटिक मिलते हैं.

इस मामले में slice_sizes, [1,11] है. इसका मतलब है कि इंडेक्स इकट्ठा करने वाले ऐरे में मौजूद हर इंडेक्स 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 वैल्यू का एक ऐसा कलेक्शन दिखाता है जिसका साइज़ इनपुट के साइज़ के बराबर होता है. इसमें हर एलिमेंट 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(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(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] वाले एक ही 1D ऐरे में एक डाइमेंशन को कम किया जाता है, तो रिडक्शन फ़ंक्शन 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 तक की वैल्यू को दोहराया गया है.

दो डाइमेंशन वाले उदाहरण की तरह ही, हम सिर्फ़ एक डाइमेंशन को कम कर सकते हैं. उदाहरण के लिए, अगर हम डाइमेंशन 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);