चेतावनी: यह एपीआई हटा दिया गया है और प्रतिस्थापन के स्थिर होने के बाद TensorFlow के भविष्य के संस्करण में हटा दिया जाएगा।

BatchToSpaceNd

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.
सार्वजनिक अंतिम वर्ग BatchToSpaceNd

T प्रकार के ND टेंसर के लिए BatchToSpace.

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

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

आउटपुट <टी>
asOutput ()
टेंसर का प्रतीकात्मक हैंडल लौटाता है।
स्थिर <टी, यू संख्या फैली हुई है, वी संख्या फैली> BatchToSpaceNd <टी>
बनाने ( स्कोप गुंजाइश, ओपेरैंड <टी> इनपुट, ओपेरैंड <u> blockShape, ओपेरैंड <वी> फसलों)
एक नया BatchToSpaceNd ऑपरेशन रैपिंग क्लास बनाने के लिए फ़ैक्टरी विधि।
आउटपुट <टी>
उत्पादन ()

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

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

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

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

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

सार्वजनिक स्थिर BatchToSpaceNd <टी> बनाने ( स्कोप गुंजाइश, ओपेरैंड <टी> इनपुट, ओपेरैंड <u> blockShape, ओपेरैंड <वी> फसलों)

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

मापदंडों
दायरा वर्तमान दायरा
इनपुट एनडी आकार के साथ `input_shape = [बैच] + स्थानिक_आकार + शेष_आकार`, जहां स्थानिक_आकार में एम आयाम हैं।
ब्लॉक आकार 1-डी आकार `[एम]` के साथ, सभी मान >= 1 होने चाहिए।
फसलों 2-डी आकार `[एम, 2]` के साथ, सभी मान>= 0 होने चाहिए। `फसल [i] = [crop_start, फसल_एंड]` इनपुट आयाम `i + 1` से फसल की मात्रा निर्दिष्ट करता है, जो कि स्थानिक आयाम `i`। यह आवश्यक है कि `क्रॉप_स्टार्ट [i] + क्रॉप_एंड [i] <= block_shape [i] * input_shape [i + 1]`।

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

1. आकार के `इनपुट` को `रीशेप्ड` में दोबारा बदलें: [ब्लॉक_शेप [0], ..., ब्लॉक_शेप [एम -1], बैच / प्रोड (ब्लॉक_शेप), इनपुट_शेप [1], ..., इनपुट_शेप [एन- 1]]

2. आकार के `अनुमतिकृत` का उत्पादन करने के लिए `रिशेप्ड` के आयामों की अनुमति दें [बैच / प्रोड (ब्लॉक_शेप),

input_shape[1], block_shape[0], ..., input_shape[M], block_shape[M-1],

input_shape[M+1], ..., input_shape[N-1]]

3. आकार का `reshape_permuted` बनाने के लिए `permuted` को फिर से आकार दें [batch / prod(block_shape),

input_shape[1] * block_shape[0], ..., input_shape[M] * block_shape[M-1],

input_shape[M+1], ..., input_shape[N-1]]

4. आकार के आउटपुट का उत्पादन करने के लिए `फसलों` के अनुसार आयामों की शुरुआत और अंत [1, ..., एम]` को क्रॉप करें: [बैच / प्रोड (ब्लॉक_शेप),

input_shape[1] * block_shape[0] - फसलें[0,0] - फसलें[0,1], ..., input_shape[M] * block_shape[M-1] - फसलें[M-1,0] - फसलें [एम-1,1],

input_shape[M+1], ..., input_shape[N-1]]

कुछ उदाहरण:

(1) आकृति के निम्नलिखित इनपुट के लिए `[4, 1, 1, 1]`, `block_shape = [2, 2]`, और `फसल = [[0, 0], [0, 0]]`: 

[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
उत्पादन टेन्सर आकार `[1, 2, 2, 1]` और मूल्य: 
x = [[[[1], [2]], [[3], [4]]]]
(2) आकार के निम्न इनपुट `के लिए [4, 1, 1, 3]`, `block_shape = [ 2, 2] `, और` फसलों = [[0, 0], [0, 0]] `: 
[[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
उत्पादन टेन्सर आकार` [1, 2, 2, 3] `और मूल्य: 
x = [[[[1, 2, 3], [4, 5, 6]],
       [[7, 8, 9], [10, 11, 12]]]]
(3) आकृति के निम्नलिखित इनपुट के लिए `[4, 2, 2, 1]`, `block_shape = [2, 2]`, और `फसल = [[0, 0], [0, 0]]`: 
x = [[[[1], [3]], [[9], [11]]],
      [[[2], [4]], [[10], [12]]],
      [[[5], [7]], [[13], [15]]],
      [[[6], [8]], [[14], [16]]]]
उत्पादन टेन्सर आकार `[1, 4, 4, 1]` और मूल्य: 
x = [[[[1],   [2],  [3],  [4]],
      [[5],   [6],  [7],  [8]],
      [[9],  [10], [11],  [12]],
      [[13], [14], [15],  [16]]]]
(4) आकार के निम्न इनपुट `के लिए [8, 1, 3, 1]`, `block_shape = [ 2, 2] `, और` फसलों = [[0, 0], [2, 0]] `: 
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]]]]
उत्पादन टेन्सर आकार` [2, 2, 4, 1] `और मूल्य: 
x = [[[[1],   [2],  [3],  [4]],
       [[5],   [6],  [7],  [8]]],
      [[[9],  [10], [11],  [12]],
       [[13], [14], [15],  [16]]]]

रिटर्न
  • BatchToSpaceNd का एक नया उदाहरण

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