Pytorch में reshape और view के बीच क्या अंतर है?

Question 1

सुन्न में, हम ndarray.reshape()एक सरणी को फिर से व्यवस्थित करने के लिए उपयोग करते हैं।

मैंने देखा कि पाइटोरेक में, लोग torch.view(...)एक ही उद्देश्य के लिए उपयोग करते हैं, लेकिन एक ही समय में, एक torch.reshape(...)मौजूदा भी है ।

इसलिए मैं सोच रहा हूं कि उनके बीच क्या अंतर हैं और मुझे उनमें से किसी का उपयोग कब करना चाहिए?

Question 2

torch.viewलंबे समय से अस्तित्व में है। यह नए आकार के साथ एक टेंसर को लौटाएगा। लौटा हुआ टेनर मूल डेटा को मूल टेनर के साथ साझा करेगा। यहां प्रलेखन देखें ।

दूसरी ओर, ऐसा लगता है कि torch.reshape हाल ही में संस्करण 0.4 में पेश किया गया है । दस्तावेज़ के अनुसार , यह विधि होगी

इनपुट के रूप में एक ही डेटा और तत्वों की संख्या के साथ एक टेंसर लौटाता है, लेकिन निर्दिष्ट आकार के साथ। जब संभव हो, तो लौटा हुआ टेंसर इनपुट का एक दृश्य होगा। अन्यथा, यह एक प्रति होगी। संगत प्रगति के साथ संगत इनपुट और इनपुट को कॉपी किए बिना फिर से आकार दिया जा सकता है, लेकिन आपको नकल बनाम देखने के व्यवहार पर निर्भर नहीं होना चाहिए।

इसका मतलब है कि torch.reshapeमूल प्रति का एक प्रति या एक दृश्य वापस कर सकते हैं। आप एक दृश्य या एक प्रति वापस करने के लिए उस पर भरोसा नहीं कर सकते। डेवलपर के अनुसार:

यदि आपको एक कॉपी उपयोग क्लोन () की आवश्यकता है, यदि आपको समान स्टोरेज उपयोग दृश्य () की आवश्यकता है। रिशेप () का शब्दार्थ यह है कि यह भंडारण को साझा कर सकता है या नहीं और आप पहले से नहीं जानते हैं।

एक और अंतर यह है कि reshape()दोनों सन्निहित और गैर-सन्निहित टेंसर view()पर काम कर सकते हैं, जबकि केवल सन्निहित टेंसर पर काम कर सकते हैं। इसके अर्थ के बारे में भी यहाँ देखें contiguous।

Question 3

हालांकि दोनों torch.viewऔर torch.reshapeटेंसरों को फिर से व्यवस्थित करने के लिए उपयोग किया जाता है, यहां उनके बीच अंतर हैं।

जैसा कि नाम से पता चलता है, torch.viewकेवल मूल टेंसर का एक दृश्य बनाता है । नया टेंसर हमेशा अपना डेटा ऑरिजनल टेंसर के साथ साझा करेगा । इसका मतलब यह है कि यदि आप मूल टेंसर को बदलते हैं, तो फिर से आकार का टेंसर बदल जाएगा और इसके विपरीत।

>>> z = torch.zeros(3, 2)
>>> x = z.view(2, 3)
>>> z.fill_(1)
>>> x
tensor([[1., 1., 1.],
        [1., 1., 1.]])

यह सुनिश्चित करने के लिए कि नया टेंसर हमेशा अपने डेटा को मूल के साथ साझा torch.viewकरता है, दो टेनसर्स [ डॉक्स ] के आकार पर कुछ आकस्मिक बाधाओं को लगाता है । अधिक बार नहीं यह एक चिंता का विषय नहीं है, लेकिन कभी-कभी torch.viewएक त्रुटि फेंकता है भले ही दो टेनर्स के आकार संगत हों। यहाँ एक प्रसिद्ध प्रति-उदाहरण है।

>>> z = torch.zeros(3, 2)
>>> y = z.t()
>>> y.size()
torch.Size([2, 3])
>>> y.view(6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: invalid argument 2: view size is not compatible with input tensor's
size and stride (at least one dimension spans across two contiguous subspaces).
Call .contiguous() before .view().

torch.reshapeकिसी भी आकस्मिक बाधा को लागू नहीं करता है, लेकिन यह भी डेटा साझा करने की गारंटी नहीं देता है। नया टेंसर मूल टेंसर का एक दृश्य हो सकता है, या यह पूरी तरह से एक नया टेंसर हो सकता है।

>>> z = torch.zeros(3, 2)
>>> y = z.reshape(6)
>>> x = z.t().reshape(6)
>>> z.fill_(1)
tensor([[1., 1.],
        [1., 1.],
        [1., 1.]])
>>> y
tensor([1., 1., 1., 1., 1., 1.])
>>> x
tensor([0., 0., 0., 0., 0., 0.])

टीएल; डीआर:
यदि आप केवल टेनर्स को फिर से जोड़ना चाहते हैं, तो उपयोग करें torch.reshape। यदि आप मेमोरी उपयोग के बारे में भी चिंतित हैं और यह सुनिश्चित करना चाहते हैं कि दो टेनर्स एक ही डेटा, उपयोग साझा करें torch.view।

Question 4

Tensor.reshape()अधिक मजबूत है। यह किसी भी टेन्सर पर काम करेंगे, जबकि Tensor.view()टेन्सर पर ही काम करता है t, जहां t.is_contiguous()==True।

गैर-सन्निहित और सन्निहित के बारे में समझाने के लिए एक और समय की कहानी है, लेकिन आप हमेशा यह कह सकते हैं कि टेंसर tसन्निहित है जिसे आप कॉल कर रहे हैं t.contiguous()और फिर आप view()त्रुटि के बिना कॉल कर सकते हैं ।