Reshape

सार्वजनिक अंतिम वर्ग पुनःआकार

एक टेंसर को पुनः आकार देता है।

`टेन्सर` को देखते हुए, यह ऑपरेशन एक टेंसर लौटाता है जिसका आकार `आकार` के साथ `टेन्सर` के समान मान होता है।

यदि 1-डी टेंसर 'आकार' का एक घटक विशेष मान -1 है, तो उस आयाम के आकार की गणना की जाती है ताकि कुल आकार स्थिर रहे। विशेष रूप से, `[-1]` का `आकार` 1-डी में चपटा हो जाता है। 'आकार' का अधिकतम एक घटक अज्ञात हो सकता है।

'आकार' 1-डी होना चाहिए और ऑपरेशन 'आकार' के साथ एक टेंसर लौटाता है जो 'टेंसर' के मानों से भरा होता है। इस मामले में, 'आकार' द्वारा निहित तत्वों की संख्या 'टेंसर' में तत्वों की संख्या के समान होनी चाहिए।

यदि `आकार` 1-डी नहीं है तो यह एक त्रुटि है।

उदाहरण के लिए:

# tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]
 # tensor 't' has shape [9]
 reshape(t, [3, 3]) ==> [[1, 2, 3],
                         [4, 5, 6],
                         [7, 8, 9]]
 
 # tensor 't' is [[[1, 1], [2, 2]],
 #                [[3, 3], [4, 4]]]
 # tensor 't' has shape [2, 2, 2]
 reshape(t, [2, 4]) ==> [[1, 1, 2, 2],
                         [3, 3, 4, 4]]
 
 # tensor 't' is [[[1, 1, 1],
 #                 [2, 2, 2]],
 #                [[3, 3, 3],
 #                 [4, 4, 4]],
 #                [[5, 5, 5],
 #                 [6, 6, 6]]]
 # tensor 't' has shape [3, 2, 3]
 # pass '[-1]' to flatten 't'
 reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
 
 # -1 can also be used to infer the shape
 
 # -1 is inferred to be 9:
 reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
                          [4, 4, 4, 5, 5, 5, 6, 6, 6]]
 # -1 is inferred to be 2:
 reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
                          [4, 4, 4, 5, 5, 5, 6, 6, 6]]
 # -1 is inferred to be 3:
 reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1],
                               [2, 2, 2],
                               [3, 3, 3]],
                              [[4, 4, 4],
                               [5, 5, 5],
                               [6, 6, 6]]]
 
 # tensor 't' is [7]
 # shape `[]` reshapes to a scalar
 reshape(t, []) ==> 7
 

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

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

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

कक्षा org.tensorflow.op.PrimitiveOp से

अंतिम बूलियन	बराबर (वस्तु वस्तु)
अंतिम अंतर	हैशकोड ()
संचालन	ऑप () अंतर्निहित Operation लौटाता है
अंतिम स्ट्रिंग	स्ट्रिंग ()

कक्षा java.lang.Object से

बूलियन	बराबर (ऑब्जेक्ट arg0)
अंतिम कक्षा<?>	गेटक्लास ()
int यहाँ	हैशकोड ()
अंतिम शून्य	सूचित करें ()
अंतिम शून्य	सभी को सूचित करें ()
डोरी	स्ट्रिंग ()
अंतिम शून्य	प्रतीक्षा करें (लंबा arg0, int arg1)
अंतिम शून्य	प्रतीक्षा करें (लंबा arg0)
अंतिम शून्य	इंतज़ार ()

इंटरफ़ेस org.tensorflow.Operand से

सार आउटपुट <टी>

आउटपुट के रूप में () टेंसर का प्रतीकात्मक हैंडल लौटाता है।

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

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

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

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

सार्वजनिक स्थैतिक पुनः आकार <T> बनाएं ( स्कोप स्कोप, ऑपरेंड <T> टेंसर, ऑपरेंड <U> आकार)

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

पैरामीटर

दायरा	वर्तमान दायरा
आकार	आउटपुट टेंसर के आकार को परिभाषित करता है।

रिटर्न

• रीशेप का एक नया उदाहरण

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