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

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

ब्रॉडकास्ट करने की सुविधा क्या है?

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

ब्रॉडकास्ट की ज़रूरत, अलग-अलग रैंक वाली मल्टी-डाइमेंशन वाली रेंज के बीच या अलग-अलग, लेकिन काम करने वाले शेप वाले मल्टी-डाइमेंशनल ऐरे के बीच कार्रवाइयों के लिए हो सकती है. X+v के जोड़ के हिसाब से वैल्यू डालें, जहां X एक मैट्रिक्स (रैंक 2 की कैटगरी) और v वेक्टर (रैंक 1 की कलेक्शन) है. एलिमेंट के हिसाब से जोड़ने के लिए, 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 से अलग है, जो मुमकिन होने पर स्पेसिफ़िकेशन की जानकारी देती है.

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

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

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

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

पिछले उदाहरण पर ध्यान दें. किसी (2,3) मैट्रिक्स में स्केलर जोड़ने के बजाय, डाइमेंशन (2,3) के मैट्रिक्स में डाइमेंशन (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 से मैच किया जाता है.

अगर broadcast_dimensions तर्क दिया गया हो, तो इस तरह के ब्रॉडकास्ट का इस्तेमाल XlaBuilder में बाइनरी ऑपरेशन में किया जाता है. उदाहरण के लिए, 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 का मिलान करना गैर-कानूनी है; P और N, दोनों से V का मिलान करना भी गैर-कानूनी है.

डिजनरेट किए गए डाइमेंशन के साथ, मिलती-जुलती रैंक वाले ऐरे ब्रॉडकास्ट करना

एक संबंधित समस्या यह है कि दो ऐसे अरे ब्रॉडकास्ट किए जा रहे हैं जिनमें एक जैसी रैंक है, लेकिन डाइमेंशन साइज़ अलग-अलग हैं. 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 दस्तावेज़ देखें.

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

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

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

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

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

इसके बाद, "डाइमेंशन ब्रॉडकास्टिंग डिजनरेट करें", 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|

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