SpaceToBatchNd

सार्वजनिक अंतिम वर्ग SpaceToBatchNd

टी प्रकार के एनडी टेंसर के लिए स्पेसटूबैच।

यह ऑपरेशन इनपुट के "स्थानिक" आयामों `[1, ..., M]` को `ब्लॉक_शेप` आकार के ब्लॉकों के ग्रिड में विभाजित करता है, और इन ब्लॉकों को "बैच" आयाम (0) के साथ इस तरह से जोड़ता है कि आउटपुट में , स्थानिक आयाम `[1, ..., एम]` ग्रिड के भीतर की स्थिति के अनुरूप है, और बैच आयाम एक स्थानिक ब्लॉक के भीतर की स्थिति और मूल बैच स्थिति दोनों को जोड़ता है। ब्लॉकों में विभाजित करने से पहले, इनपुट के स्थानिक आयाम वैकल्पिक रूप से `पैडिंग` के अनुसार शून्य पैडेड होते हैं। सटीक विवरण के लिए नीचे देखें।

यह ऑपरेशन निम्नलिखित चरणों के बराबर है:

1. 'पैडेड_शेप' आकार का 'पैडेड' बनाने के लिए 'पैडिंग' के अनुसार इनपुट के आयाम '[1, ..., एम]' की शुरुआत और अंत को शून्य-पैड करें।

2. `पैडेड` को `रीशेप्ड_पैडेड` आकार में पुनः आकार दें:

[बैच] + [पैडेड_शेप[1] / ब्लॉक_शेप[0], ब्लॉक_शेप[0], ..., पैडेड_शेप[एम] / ब्लॉक_शेप[एम-1], ब्लॉक_शेप[एम-1]] + शेष_शेप

3. आकार का `permuted_resize_padded` बनाने के लिए `relapsed_padded` के आयामों को क्रमपरिवर्तित करें:

ब्लॉक_शेप + [बैच] + [पैडेड_शेप[1] / ब्लॉक_शेप[0], ..., पैडेड_शेप[एम] / ब्लॉक_शेप[एम-1]] + शेष_शेप

4. `ब्लॉक_शेप' को बैच आयाम में समतल करने के लिए `permuted_relapsed_padded' को दोबारा आकार दें, जिससे आकार का आउटपुट टेंसर तैयार हो सके:

[बैच * प्रोड(ब्लॉक_शेप)] + [पैडेड_शेप[1] / ब्लॉक_शेप[0], ..., पैडेड_शेप[एम] / ब्लॉक_शेप[एम-1]] + शेष_शेप

कुछ उदाहरण:

(1) आकार के निम्नलिखित इनपुट के लिए `[1, 2, 2, 1]`, `ब्लॉक_शेप = [2, 2]`, और `पैडिंग = [[0, 0], [0, 0]]`:

x = [[[[1], [2]], [[3], [4]]]]
 
आउटपुट टेंसर का आकार `[4, 1, 1, 1]` और मान है:
[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
 
(2) आकृति के निम्नलिखित इनपुट के लिए `[1, 2, 2, 3]`, `ब्लॉक_शेप = [2, 2]`, और `पैडिंग = [[0, 0], [0, 0]]`:
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
 
आउटपुट टेंसर का आकार `[4, 1, 1, 3]` और मान है:
[[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
 
(3) आकृति के निम्नलिखित इनपुट के लिए `[1, 4, 4, 1]`, `ब्लॉक_शेप = [2, 2]`, और `पैडिंग = [[0, 0], [0, 0]]`:
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]],
       [[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
 
आउटपुट टेंसर का आकार `[4, 2, 2, 1]` और मान है:
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
 
(4) आकार के निम्नलिखित इनपुट के लिए `[2, 2, 4, 1]`, ब्लॉक_शेप = `[2, 2]`, और पैडिंग = `[[0, 0], [2, 0]]`:
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]
 
आउटपुट टेंसर का आकार `[8, 1, 3, 1]` और मान है:
x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
      [[[0], [2], [4]]], [[[0], [10], [12]]],
      [[[0], [5], [7]]], [[[0], [13], [15]]],
      [[[0], [6], [8]]], [[[0], [14], [16]]]]
 
अन्य बातों के अलावा, यह ऑपरेशन एट्रस कनवल्शन को नियमित कनवल्शन में कम करने के लिए उपयोगी है।

सार्वजनिक तरीके

आउटपुट <T>
आउटपुट के रूप में ()
टेंसर का प्रतीकात्मक हैंडल लौटाता है।
स्थिर <T, U संख्या बढ़ाता है, V संख्या बढ़ाता है> SpaceToBatchNd <T>
बनाएं ( स्कोप स्कोप, ऑपरेंड <T> इनपुट, ऑपरेंड <U> ब्लॉकशेप, ऑपरेंड <V> पैडिंग)
एक नया SpaceToBatchNd ऑपरेशन लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।
आउटपुट <T>

विरासत में मिली विधियाँ

सार्वजनिक तरीके

सार्वजनिक आउटपुट <T> asOutput ()

टेंसर का प्रतीकात्मक हैंडल लौटाता है।

TensorFlow संचालन के इनपुट किसी अन्य TensorFlow ऑपरेशन के आउटपुट हैं। इस पद्धति का उपयोग एक प्रतीकात्मक हैंडल प्राप्त करने के लिए किया जाता है जो इनपुट की गणना का प्रतिनिधित्व करता है।

सार्वजनिक स्थैतिक SpaceToBatchNd <T> बनाएं ( स्कोप स्कोप, ऑपरेंड <T> इनपुट, ऑपरेंड <U> ब्लॉकशेप, ऑपरेंड <V> पैडिंग)

एक नया SpaceToBatchNd ऑपरेशन लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।

पैरामीटर
दायरा वर्तमान दायरा
इनपुट एनडी आकार के साथ `इनपुट_शेप = [बैच] + स्थानिक_आकार + शेष_आकार`, जहां स्थानिक_आकार में `एम` आयाम हैं।
ब्लॉक आकार 1-डी आकार `[एम]` के साथ, सभी मान >= 1 होने चाहिए।
गद्दी 2-डी आकार `[एम, 2]` के साथ, सभी मान >= 0 होने चाहिए। `पैडिंग[i] = [पैड_स्टार्ट, पैड_एंड]` इनपुट आयाम `i + 1` के लिए पैडिंग निर्दिष्ट करता है, जो स्थानिक आयाम से मेल खाता है `मैं`. यह आवश्यक है कि `ब्लॉक_शेप[i]` `इनपुट_शेप[i + 1] + पैड_स्टार्ट + पैड_एंड` को विभाजित करे।
रिटर्न
  • SpaceToBatchNd का एक नया उदाहरण

सार्वजनिक आउटपुट <T> आउटपुट ()