आकार और लेआउट

XLA Shape Proto (xla_data.proto) से, N-डाइमेंशन वाले अरे (कलेक्शन) की रैंक, साइज़, और डेटा टाइप के बारे में कम शब्दों में बताया जाता है.

शब्दावली, नोटेशन, और कन्वेंशन

• किसी कलेक्शन की रैंक, डाइमेंशन की संख्या के बराबर होती है. अरे की सही रैंक, उन डाइमेंशन की संख्या होती है जिनका साइज़ एक से ज़्यादा होता है.

• N डाइमेंशन के अरे के लिए, डाइमेंशन को 0 से N-1 तक की संख्या दी जाती है. डाइमेंशन की संख्या, सुविधा के हिसाब से आर्बिट्रेरी लेबल हैं. इन डाइमेंशन संख्याओं का क्रम यह नहीं बताता कि आकार के लेआउट में कोई खास छोटा/खास क्रम है. लेआउट, Layout प्रोटो से तय किया जाता है.

• पारंपरिक तरीके के मुताबिक, डाइमेंशन को उनकी संख्या के बढ़ते क्रम में सूची में रखा जाता है. उदाहरण के लिए, [A x B x C] साइज़ वाली 3 डाइमेंशन वाली अरे के लिए, डाइमेंशन 0 का साइज़ A, डाइमेंशन 1 का साइज़ B, और डाइमेंशन 2 में साइज़ C होता है.

  XLA की कुछ सुविधाएं, Python जैसे नेगेटिव इंडेक्स के साथ भी काम करती हैं: डाइमेंशन -1 आखिरी डाइमेंशन है (N डाइमेंशन अरे के लिए, N-1 के बराबर). उदाहरण के लिए, ऊपर बताई गई 3-डाइमेंशन वाली कैटगरी के लिए, डाइमेंशन -1 का साइज़ C और डाइमेंशन -2 का साइज़ B होता है. इसी तरह और भी बहुत कुछ होता है.

• दो, तीन, और चार डाइमेंशन वाले सरणियों में अक्सर डाइमेंशन से जुड़े खास अक्षर होते हैं. उदाहरण के लिए, 2D कलेक्शन के लिए:

  • डाइमेंशन 0: y
  • डाइमेंशन 1: x

  3D कलेक्शन के लिए:

  • डाइमेंशन 0: z
  • डाइमेंशन 1: y
  • डाइमेंशन 2: x

  4D कलेक्शन के लिए:

  • डाइमेंशन 0: p
  • डाइमेंशन 1: z
  • डाइमेंशन 2: y
  • डाइमेंशन 3: x

• XLA API में मौजूद फ़ंक्शन, जो डाइमेंशन लेते हैं वे डाइमेंशन नंबर के बढ़ते क्रम में ऐसा करते हैं. यह डाइमेंशन को initializer_list के तौर पर पास करते समय इस्तेमाल किए गए क्रम से मेल खाता है; उदाहरण के लिए,

  ShapeUtil::MakeShape(F32, {A, B, C, D})

  एक ऐसा आकार बनाएगा जिसके डाइमेंशन साइज़ का अरे, [A, B, C, D] क्रम में शामिल होगा.

लेआउट

Layout प्रोटो से पता चलता है कि मेमोरी में कोई अरे कैसे दिखाया जाता है. Layout प्रोटो में ये फ़ील्ड शामिल होते हैं:

message Layout {
  repeated int64 minor_to_major = 1;
  repeated int64 padded_dimensions = 2;
  optional PaddingValue padding_value = 3;
}

माइनर-टू-मेजर डाइमेंशन के हिसाब से क्रम

सिर्फ़ minor_to_major फ़ील्ड ज़रूरी है. यह फ़ील्ड, आकार में डाइमेंशन के नाबालिग-से-मुख्य क्रम को बताता है. minor_to_major में मौजूद वैल्यू, अरे के डाइमेंशन का क्रम (N डाइमेंशन वाली अरे के लिए 0 से N-1 तक) हैं. इसमें पहली वैल्यू, सबसे ज़्यादा मेजर डाइमेंशन तक की सबसे छोटी वैल्यू तक की हो सकती है. सबसे छोटा डाइमेंशन, वह डाइमेंशन होता है जो लीनियर मेमोरी में मौजूद कलेक्शन के एलिमेंट से गुजरते समय सबसे तेज़ी से बदलता है.

उदाहरण के लिए, [2 x 3] साइज़ का नीचे दिया गया 2D कलेक्शन देखें:

a b c
d e f

यहां डाइमेंशन 0, साइज़ 2 और डाइमेंशन 1 में साइज़ 3 है. अगर लेआउट में minor_to_major फ़ील्ड [0, 1] है, तो डाइमेंशन 0 सबसे छोटा डाइमेंशन और 1 सबसे अहम डाइमेंशन है. यह लीनियर मेमोरी में नीचे दिए गए लेआउट के मुताबिक होता है:

a d b e c f

0 से N-1 तक का यह माइनर-टू-मेजर डाइमेंशन का क्रम, कॉलम-मेजर (रैंक 2 पर) के जैसा है. डाइमेंशन के एक जैसे क्रम को मानते हुए, दूसरे तरीके से हम इस लेआउट को कोड में देख सकते हैं: "दिम 0 माइनर है".

वहीं दूसरी ओर, अगर लेआउट में minor_to_major फ़ील्ड [1, 0] है, तो लीनियर मेमोरी का लेआउट यह होगा:

a b c d e f

N डाइमेंशन वाली कलेक्शन के लिए, माइनर-टू-मेजर डाइमेंशन का क्रम, N-1 से लेकर 0 तक होता है. यह क्रम, रो-मेजर (रैंक 2 पर मौजूद) के जैसा होता है. अगर यह मान लिया जाए कि डाइमेंशन एक-दूसरे से जुड़े हुए हैं, तो "डिम 0 मेजर" है. इस कोड में इस लेआउट को दूसरे तरीके से समझा जा सकता है.

डिफ़ॉल्ट माइनर-टू-मेजर ऑर्डर

नए बनाए गए आकारों के लिए डिफ़ॉल्ट लेआउट "डाइमेंशन का क्रम मेजर-टू-माइनर है" (रैंक 2 पर मौजूद लाइन-मेजर से मिलता-जुलता है).

पैडिंग (जगह)

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

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

a d 0 b e 0 c f 0 0 0 0 0 0 0

यह नीचे दिए गए कलेक्शन के लेआउट के बराबर है, जिसका डाइमेंशन माइनर-टू-मुख्य डाइमेंशन के क्रम में एक जैसा है:

a b c 0 0
d e f 0 0
0 0 0 0 0

अरे में इंडेक्स करना

index_util.h क्लास में IndexUtil, कई डाइमेंशन वाले इंडेक्स और लीनियर इंडेक्स को आपस में बदलने के लिए सुविधाएं देता है. इन इंडेक्स को आकार और लेआउट के आधार पर तय किया जाता है. कई डाइमेंशन वाले इंडेक्स में, हर डाइमेंशन के लिए एक int64 इंडेक्स शामिल होता है. लीनियर इंडेक्स, सिंगल int64 वैल्यू होती है. यह वैल्यू, अरे को बरकरार रखने वाले बफ़र में इंडेक्स होती है. आकृतियों और लेआउट को बनाना और उनमें बदलाव करना आसान बनाने वाली उपयोगिताओं के लिए, shape_util.h और layout_util.h को एक ही डायरेक्ट्री में देखें.