प्रकार टी के एनडी टेंसर के लिए बैचटूस्पेस।
यह ऑपरेशन "बैच" आयाम 0 को "एम + 1" आकार के आयामों "ब्लॉक_शेप + [बैच]" में बदल देता है, इन ब्लॉकों को स्थानिक आयामों "[1, ..., एम]" द्वारा परिभाषित ग्रिड में वापस छोड़ देता है। इनपुट के समान रैंक वाला परिणाम प्राप्त करने के लिए। इस मध्यवर्ती परिणाम के स्थानिक आयामों को आउटपुट उत्पन्न करने के लिए वैकल्पिक रूप से 'फसलों' के अनुसार काटा जाता है। यह SpaceToBatch का उल्टा है। सटीक विवरण के लिए नीचे देखें।
सार्वजनिक तरीके
आउटपुट <T> | आउटपुट के रूप में () टेंसर का प्रतीकात्मक हैंडल लौटाता है। |
स्थिर <T, U संख्या बढ़ाता है, V संख्या बढ़ाता है> BatchToSpaceNd <T> | |
आउटपुट <T> | आउटपुट () |
विरासत में मिले तरीके
सार्वजनिक तरीके
सार्वजनिक आउटपुट <T> asOutput ()
टेंसर का प्रतीकात्मक हैंडल लौटाता है।
TensorFlow संचालन के इनपुट किसी अन्य TensorFlow ऑपरेशन के आउटपुट हैं। इस पद्धति का उपयोग एक प्रतीकात्मक हैंडल प्राप्त करने के लिए किया जाता है जो इनपुट की गणना का प्रतिनिधित्व करता है।
सार्वजनिक स्थैतिक BatchToSpaceNd <T> बनाएं ( स्कोप स्कोप, ऑपरेंड <T> इनपुट, ऑपरेंड <U> ब्लॉकशेप, ऑपरेंड <V> क्रॉप)
एक नया BatchToSpaceNd ऑपरेशन लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।
पैरामीटर
दायरा | वर्तमान दायरा |
---|---|
इनपुट | आकार के साथ एनडी `इनपुट_शेप = [बैच] + स्थानिक_आकार + शेष_आकार`, जहां स्थानिक_आकार में एम आयाम हैं। |
ब्लॉक आकार | 1-डी आकार `[एम]` के साथ, सभी मान >= 1 होने चाहिए। |
फसलें | 2-डी आकार `[एम, 2]` के साथ, सभी मान >= 0 होने चाहिए। `क्रॉप्स[i] = [क्रॉप_स्टार्ट, क्रॉप_एंड]` इनपुट आयाम `i + 1` से क्रॉप करने की मात्रा निर्दिष्ट करता है, जो इससे मेल खाता है स्थानिक आयाम `i`. यह आवश्यक है कि `क्रॉप_स्टार्ट[i] + क्रॉप_एंड[i] <= ब्लॉक_शेप[i] * इनपुट_शेप[i + 1]`। यह ऑपरेशन निम्नलिखित चरणों के बराबर है: 1. `इनपुट` को आकार के `रीशेप्ड` में दोबारा आकार दें: [ब्लॉक_शेप[0], ..., ब्लॉक_शेप[एम-1], बैच/प्रोड(ब्लॉक_शेप), इनपुट_शेप[1], ..., इनपुट_शेप[एन- 1]] 2. आकार के `अनुक्रमित` उत्पन्न करने के लिए `पुनर्निर्मित` के आयामों को क्रमबद्ध करें [बैच / प्रोड(ब्लॉक_शेप), इनपुट_शेप[1], ब्लॉक_शेप[0], ..., इनपुट_शेप[एम], ब्लॉक_शेप[एम-1], इनपुट_शेप[एम+1], ..., इनपुट_शेप[एन-1]] 3. 'permuted' को फिर से आकार दें ताकि 'resize_permuted' आकार का निर्माण हो सके [बैच/प्रोड(ब्लॉक_शेप), इनपुट_शेप[1] * ब्लॉक_शेप[0], ..., इनपुट_शेप[एम] * ब्लॉक_शेप[एम-1], इनपुट_शेप[एम+1], ..., इनपुट_शेप[एन-1]] 4. आकार के आउटपुट का उत्पादन करने के लिए `क्रॉप्स` के अनुसार `रीशेप्ड_परम्यूटेड` के `[1, ..., एम]` आयामों की शुरुआत और अंत को क्रॉप करें: [बैच / प्रोड (ब्लॉक_शेप), इनपुट_शेप[1] * ब्लॉक_शेप[0] - फसलें[0,0] - फसलें[0,1], ..., इनपुट_शेप[एम] * ब्लॉक_शेप[एम-1] - फसलें[एम-1,0] - फसलें [एम-1,1], इनपुट_शेप[एम+1], ..., इनपुट_शेप[एन-1]] कुछ उदाहरण: (1) आकार के निम्नलिखित इनपुट के लिए `[4, 1, 1, 1]`, `ब्लॉक_शेप = [2, 2]`, और `क्रॉप्स = [[0, 0], [0, 0]]`:
|
रिटर्न
- BatchToSpaceNd का एक नया उदाहरण