ब्रॉडकास्ट ऐप्लिकेशन

इस दस्तावेज़ में, XLA की ब्रॉडकास्टिंग सिमैंटिक के बारे में बताया गया है.

ब्रॉडकास्टिंग क्या है?

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

ब्रॉडकास्टिंग की ज़रूरत तब पड़ सकती है, जब अलग-अलग रैंक वाले मल्टी-डाइमेंशनल ऐरे या अलग-अलग, लेकिन एक जैसे शेप वाले मल्टी-डाइमेंशनल ऐरे के बीच कार्रवाइयां की जाती हैं. जोड़ने की इस कार्रवाई पर विचार करें: X+v. यहां X एक मैट्रिक्स (दो डाइमेंशन वाली सरणी) है और v एक वेक्टर (एक डाइमेंशन वाली सरणी) है. हर एलिमेंट को जोड़ने के लिए, XLA को वेक्टर v को मैट्रिक्स X के डाइमेंशन की संख्या के बराबर "ब्रॉडकास्ट" करना होगा. इसके लिए, v को कुछ बार दोहराना होगा. वेक्टर की लंबाई, मैट्रिक्स के कम से कम एक डाइमेंशन से मेल खानी चाहिए.

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

|1 2 3| + |7 8 9|
|4 5 6|

मैट्रिक्स के डाइमेंशन (2,3) हैं और वेक्टर का डाइमेंशन (3) है. वेक्टर को लाइनों पर दोहराकर ब्रॉडकास्ट किया जाता है, ताकि यह मिल सके:

|1 2 3| + |7 8 9| = |8  10 12|
|4 5 6|   |7 8 9|   |11 13 15|

NumPy में, इसे ब्रॉडकास्टिंग कहा जाता है.

सिद्धांत

XLA भाषा में, नियमों का पालन करना ज़रूरी है. साथ ही, इसमें "जादुई" सुविधाओं का इस्तेमाल नहीं किया जाता. इस तरह की सुविधाओं से, कुछ कैलकुलेशन को तय करना थोड़ा आसान हो सकता है. हालांकि, इससे उपयोगकर्ता के कोड में ज़्यादा अनुमान शामिल हो जाते हैं. इन्हें लंबे समय तक बदलना मुश्किल होगा. ज़रूरत पड़ने पर, क्लाइंट-लेवल के रैपर में अपने-आप काम करने वाली सुविधाओं को जोड़ा जा सकता है.

ब्रॉडकास्टिंग के मामले में, XLA को अलग-अलग रैंक की ऐरे के बीच होने वाले ऑपरेशनों के लिए, ब्रॉडकास्टिंग की खास जानकारी की ज़रूरत होती है. यह NumPy से अलग है. NumPy, जब भी संभव होता है, तब स्पेसिफ़िकेशन का अनुमान लगाता है.

कम डाइमेंशन वाले ऐरे को ज़्यादा डाइमेंशन वाले ऐरे पर ब्रॉडकास्ट करना

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

|1 2 3| + 7 = |8  9  10|
|4 5 6|       |11 12 13|

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

पिछले उदाहरण पर ध्यान दें. (2,3) मैट्रिक्स में स्केलर जोड़ने के बजाय, डाइमेंशन (3) वाले वेक्टर को डाइमेंशन (2,3) वाले मैट्रिक्स में जोड़ें. ब्रॉडकास्टिंग की जानकारी दिए बिना, यह कार्रवाई अमान्य है. मैट्रिक्स-वेक्टर को जोड़ने का सही अनुरोध करने के लिए, ब्रॉडकास्टिंग डाइमेंशन को (1) के तौर पर तय करें. इसका मतलब है कि वेक्टर के डाइमेंशन को मैट्रिक्स के डाइमेंशन 1 से मैच किया जाता है. 2D में, अगर डाइमेंशन 0 पंक्तियों और डाइमेंशन 1 कॉलम को दिखाता है, तो इसका मतलब है कि वेक्टर का हर एलिमेंट, मैट्रिक्स में मौजूद पंक्तियों की संख्या के बराबर साइज़ का कॉलम बन जाता है:

|7 8 9| ==> |7 8 9|
            |7 8 9|

ज़्यादा मुश्किल उदाहरण के तौर पर, 3x3 मैट्रिक्स (डाइमेंशन (3,3)) में तीन एलिमेंट वाला वेक्टर (डाइमेंशन (3)) जोड़ने पर विचार करें. इस उदाहरण में, ब्रॉडकास्टिंग दो तरीकों से की जा सकती है:

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

|7 8 9| ==> |7 8 9|
            |7 8 9|
            |7 8 9|

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

 |7| ==> |7 7 7|
 |8|     |8 8 8|
 |9|     |9 9 9|

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

इस तरह के ब्रॉडकास्ट का इस्तेमाल, XlaBuilder में बाइनरी ऑपरेशंस के लिए किया जाता है. ऐसा तब होता है, जब broadcast_dimensions आर्ग्युमेंट दिया गया हो. उदाहरण के लिए, XlaBuilder::Add देखें. XLA के सोर्स कोड में, इस तरह की ब्रॉडकास्टिंग को कभी-कभी "InDim" ब्रॉडकास्टिंग कहा जाता है.

औपचारिक परिभाषा

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

          MxNxPxQ

dim 3:          T
dim 2:        T
dim 1:      T
dim 0:    T

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

TxV मैट्रिक्स को MxNxPxQ ऐरे से मैच करने के लिए, ब्रॉडकास्टिंग डाइमेंशन के एक पेयर का इस्तेमाल किया जाता है:

          MxNxPxQ
dim 2,3:      T V
dim 1,2:    T V
dim 0,3:  T     V
etc...

ब्रॉडकास्टिंग टपल में डाइमेंशन का क्रम वही होना चाहिए जिसमें कम डाइमेंशन वाले ऐरे के डाइमेंशन, ज़्यादा डाइमेंशन वाले ऐरे के डाइमेंशन से मेल खाते हैं. टपल का पहला एलिमेंट यह तय करता है कि ज़्यादा डाइमेंशन वाले ऐरे का कौनसा डाइमेंशन, कम डाइमेंशन वाले ऐरे के डाइमेंशन 0 से मेल खाना चाहिए. टपल में मौजूद दूसरा एलिमेंट यह तय करता है कि ज़्यादा डाइमेंशन वाले ऐरे में मौजूद कौनसे डाइमेंशन को कम डाइमेंशन वाले ऐरे में मौजूद डाइमेंशन 1 से मैच करना है. इसी तरह, अन्य डाइमेंशन के लिए भी यह प्रोसेस दोहराई जाती है. ब्रॉडकास्ट डाइमेंशन का क्रम, बढ़ते क्रम में होना चाहिए. उदाहरण के लिए, पिछले उदाहरण में V को N और T को P से मैच करना गैर-कानूनी है. साथ ही, V को P और N, दोनों से मैच करना भी गैर-कानूनी है.

मिलते-जुलते डाइमेंशन वाली ऐसी ऐरे ब्रॉडकास्ट करना जिनमें डिजनरेट डाइमेंशन मौजूद हैं

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

• ये बराबर हैं या
• इनमें से एक डाइमेंशन 1 है (यह एक "डीजनरेट" डाइमेंशन है)

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

उदाहरण:

1. (2,1) और (2,3) को (2,3) पर ब्रॉडकास्ट किया जाता है.
2. (1,2,5) और (7,2,5) से (7,2,5) पर ब्रॉडकास्ट किया गया.
3. (7,2,5) और (7,1,5) को (7,2,5) पर ब्रॉडकास्ट किया जाता है.
4. (7,2,5) और (7,2,6) एक-दूसरे के साथ काम नहीं करते. इसलिए, इन्हें ब्रॉडकास्ट नहीं किया जा सकता.

एक खास स्थिति में, इनपुट के तौर पर इस्तेमाल की गई हर ऐरे में अलग-अलग इंडेक्स पर डीजनरेट डाइमेंशन होता है. इस स्थिति में भी, ब्रॉडकास्टिंग की सुविधा काम करती है. इस मामले में, नतीजा एक "आउटर ऑपरेशन" है: (2,1) और (1,3) को (2,3) पर ब्रॉडकास्ट किया जाता है. ज़्यादा उदाहरणों के लिए, ब्रॉडकास्टिंग के बारे में NumPy का दस्तावेज़ पढ़ें.

ब्रॉडकास्ट कंपोज़िशन

कम डाइमेंशन वाले ऐरे को ज़्यादा डाइमेंशन वाले ऐरे में ब्रॉडकास्ट करना और डिजनरेट डाइमेंशन का इस्तेमाल करके ब्रॉडकास्ट करना, दोनों को एक ही बाइनरी ऑपरेशन में किया जा सकता है. उदाहरण के लिए, वैल्यू (0) के ब्रॉडकास्ट डाइमेंशन का इस्तेमाल करके, साइज़ 4 वाले वेक्टर और साइज़ 1x2 वाले मैट्रिक्स को एक साथ जोड़ा जा सकता है:

|1 2 3 4| + [5 6]    // [5 6] is a 1x2 matrix, not a vector.

सबसे पहले, ब्रॉडकास्ट डाइमेंशन का इस्तेमाल करके, वेक्टर को ज़्यादा से ज़्यादा दो डाइमेंशन (मैट्रिक्स) तक ब्रॉडकास्ट किया जाता है. ब्रॉडकास्ट डाइमेंशन में मौजूद एक वैल्यू (0) से पता चलता है कि वेक्टर का डाइमेंशन ज़ीरो, मैट्रिक्स के डाइमेंशन ज़ीरो से मेल खाता है. इससे 4xM साइज़ का मैट्रिक्स बनता है. यहां M की वैल्यू, 1x2 ऐरे में मौजूद डाइमेंशन के साइज़ से मेल खाने के लिए चुनी जाती है. इसलिए, 4x2 मैट्रिक्स बनाया जाता है:

|1 1| + [5 6]
|2 2|
|3 3|
|4 4|

इसके बाद, "degenerate dimension broadcasting" 1x2 मैट्रिक्स के डाइमेंशन ज़ीरो को ब्रॉडकास्ट करता है, ताकि यह दाईं ओर के डाइमेंशन के साइज़ से मेल खा सके:

|1 1| + |5 6|     |6  7|
|2 2| + |5 6|  =  |7  8|
|3 3| + |5 6|     |8  9|
|4 4| + |5 6|     |9 10|

एक और मुश्किल उदाहरण यह है कि (1, 2) के ब्रॉडकास्ट डाइमेंशन का इस्तेमाल करके, 1x2 साइज़ की मैट्रिक्स को 4x3x1 साइज़ के ऐरे में जोड़ा गया है. सबसे पहले, ब्रॉडकास्ट डाइमेंशन का इस्तेमाल करके, 1x2 मैट्रिक्स को तीन डाइमेंशन तक ब्रॉडकास्ट किया जाता है. इससे Mx1x2 इंटरमीडिएट ऐरे बनता है. इसमें डाइमेंशन का साइज़ M, बड़े ऑपरेंड (4x3x1 ऐरे) के साइज़ से तय होता है. इससे 4x1x2 इंटरमीडिएट ऐरे बनता है. M, डाइमेंशन 0 (सबसे बायां डाइमेंशन) पर है, क्योंकि डाइमेंशन 1 और 2 को ओरिजनल 1x2 मैट्रिक्स के डाइमेंशन पर मैप किया गया है. ऐसा इसलिए, क्योंकि ब्रॉडकास्ट डाइमेंशन (1, 2) हैं. इस इंटरमीडिएट ऐरे को 4x3x1 मैट्रिक्स में जोड़ा जा सकता है. इसके लिए, डिजनरेट डाइमेंशन की ब्रॉडकास्टिंग का इस्तेमाल किया जाता है, ताकि 4x3x2 ऐरे का नतीजा मिल सके.