CNN में, प्रत्येक इनपुट चैनल के लिए प्रत्येक नए फ़िल्टर में अलग-अलग वज़न होता है, या इनपुट चैनलों में उपयोग किए जाने वाले प्रत्येक फ़िल्टर का समान भार होता है?

Question

मेरी समझ यह है कि एक दृढ़ तंत्रिका नेटवर्क की दृढ़ परत के चार आयाम होते हैं: input_channels, filter_height, filter_width, number_of_filters। इसके अलावा, यह मेरी समझ है कि प्रत्येक नया फ़िल्टर बस सभी इनपुट_चैनल्स (या पिछली परत से विशेषता / सक्रियण नक्शे) पर दृढ़ हो जाता है।

फिर भी, CS231 से नीचे का ग्राफिक चैनलों में इस्तेमाल किए जा रहे एक ही फिल्टर के बजाय एक सिंगल चैनल पर प्रत्येक फ़िल्टर (लाल रंग में) को दिखाता है। यह इंगित करता है कि EACH चैनल के लिए एक अलग फ़िल्टर है (इस मामले में मैं मान रहा हूं कि वे एक इनपुट छवि के तीन रंग चैनल हैं, लेकिन सभी इनपुट चैनलों के लिए भी यही लागू होगा)।

यह भ्रामक है - क्या प्रत्येक इनपुट चैनल के लिए एक अलग अनूठा फ़िल्टर है?

स्रोत: http://cs231n.github.io/convolutional-networks/

ऊपर की छवि O'reilly के "फंडामेंटल ऑफ़ डीप लर्निंग" के एक अंश से विरोधाभासी लगती है :

"... फ़िल्टर्स केवल एक फ़ीचर मैप पर काम नहीं करते हैं। वे एक विशेष लेयर पर उत्पन्न होने वाले फ़ीचर मैप्स की संपूर्ण मात्रा पर काम करते हैं ... परिणामस्वरूप, फ़ीचर मैप्स को वॉल्यूम पर काम करने में सक्षम होना चाहिए, सिर्फ क्षेत्र नहीं ”

... इसके अलावा, यह मेरी समझ है कि नीचे दिए गए ये चित्र एक ही फ़िल्टर का संकेत कर रहे हैं , बस तीनों इनपुट चैनलों (ऊपर दिए गए CS231 ग्राफिक में दिखाया गया है) के विरोधाभासी हैं:

Comments

arxiv.org/pdf/1707.09725 अध्याय 2

— मार्टिन थोमा

Answer 1

एक दृढ़ तंत्रिका नेटवर्क में, क्या ए प्रत्येक इनपुट चैनल के लिए अनूठा फ़िल्टर है या सभी इनपुट चैनलों में समान नए फ़िल्टर उपयोग किए जाते हैं?

भूतपूर्व। वास्तव में प्रत्येक इनपुट चैनल / आउटपुट चैनल संयोजन के लिए एक अलग कर्नेल परिभाषित है।

आमतौर पर CNN आर्किटेक्चर के लिए, आपके द्वारा वर्णित एकल फ़िल्टर में number_of_filters पैरामीटर , इनपुट चैनल प्रति एक 2d कर्नेल होता है। input_channels * number_of_filtersभार के सेट हैं , जिनमें से प्रत्येक एक सजा कर्नेल का वर्णन करता है। तो प्रत्येक फिल्टर के लिए प्रति इनपुट चैनल वजन के एक सेट को दर्शाने वाले आरेख सही हैं। पहला आरेख यह भी स्पष्ट रूप से दर्शाता है कि उन गुठली को लागू करने के परिणाम उन्हें जोड़कर और प्रत्येक आउटपुट चैनल के लिए पूर्वाग्रह जोड़कर हैं।

इसे प्रत्येक आउटपुट चैनल के लिए 3 डी कनवल्शन का उपयोग करने के रूप में भी देखा जा सकता है, ऐसा इनपुट के समान गहराई में होता है। जो कि आपका दूसरा आरेख दिखा रहा है, और यह भी कि कई पुस्तकालय आंतरिक रूप से क्या करेंगे। गणितीय रूप से यह एक ही परिणाम है (बशर्ते गहराई से मेल खाता है), हालांकि परत प्रकार को आमतौर पर "Conv2D" या समान के रूप में लेबल किया जाता है। इसी तरह यदि आपका इनपुट प्रकार स्वाभाविक रूप से 3 डी है, जैसे स्वर या वीडियो, तो आप "कन्वोक 3 डी" लेयर का उपयोग कर सकते हैं, लेकिन आंतरिक रूप से इसे 4 डी के रूप में अच्छी तरह से लागू किया जा सकता है।

Comments

इस स्पष्टीकरण के लिए धन्यवाद। ऐसा लगता है कि प्रत्येक फ़िल्टर वास्तव में विभिन्न भारों केinput_channels साथ संस्करणों की संख्या है । क्या आपके पास एक "आधिकारिक" स्रोत है जो इस समझ की पुष्टि करता है?

— रयान चेस

@ रेयानचेज़: हाँ यह सही है। मैं सिर्फ सीएनएन

— स्लेटर

मैं यह नोट करना चाहूंगा कि, उस स्रोत में ( cs231n.github.io/convolutional-networks ), फ़िल्टर (वज़न या कर्नेल) वॉल्यूम हैं (यानी 3-आयामी), और उनके पास समान 3 आयाम हैं इनपुट में से एक मात्रा। इसके अलावा, जैसा कि यह है (कम से कम) अब उस स्रोत में कहा गया है, इनपुट वॉल्यूम के लिए फ़िल्टर के बेहतर अनुप्रयोग की कल्पना करने के लिए वॉल्यूम को तीसरे आयाम में कटा हुआ किया गया है। मुझे नहीं लगता कि, सामान्य रूप से, "प्रत्येक इनपुट चैनल / आउटपुट चैनल संयोजन के लिए एक अलग कर्नेल परिभाषित है।" सही है।

— nbro

ध्यान दें कि फ़िल्टर (या गुठली) वे वज़न हैं जिन्हें सीखने की आवश्यकता है (अर्थात वे निश्चित नहीं हैं, लेकिन वे वास्तव में सीएनएन के पैरामीटर हैं)। यह हो सकता है कि वे (यानी फ़िल्टर के स्लाइस), अंत में, तीसरे आयाम में समान हों।

— nob

@nbro: हाँ आप कर्नेल गहराई के साथ एक ही 3D चैनल के रूप में कई 2D स्लाइस में 2 डी कनवल्शन लागू कर सकते हैं और साथ ही साथ चैनल की संख्या भी। गणितीय रूप से यह मेरे विवरण के समान है। आप इसे साझा भार (जिनमें से कई शून्य हैं) के साथ पूरी तरह से कनेक्टेड फीड-फॉरवर्ड नेटवर्क के रूप में देख सकते हैं। यह उत्तर इस बात पर केंद्रित है कि 2 डी फिल्टर का दृश्य क्या है, क्योंकि ओपी पूछ रहा है कि 2 डी फिल्टर कैसे व्यवस्थित होते हैं। वे वास्तव में एक बड़े 3 डी कर्नेल में व्यवस्थित हो सकते हैं, लेकिन उन्हें अभी भी 2 डी कर्नेल के रूप में "ट्रिक" का उपयोग करके लागू किया जाता है कि 3 डी कनवल्शन बराबर है।

— नील स्लेटर

Answer 2

निम्नलिखित चित्र जो आपने अपने प्रश्न में उपयोग किया था, बहुत सटीक रूप से बताता है कि क्या हो रहा है। याद रखें कि 3 डी फिल्टर (ग्रे क्यूब) का प्रत्येक तत्व एक अलग मूल्य ( 3x3x3=27मान) से बना है। तो, तीन अलग-अलग 2 डी फिल्टर आकार के 3x3इस एक के रूप में श्रेणीबद्ध किया जा सकता है 3 डी फिल्टर आकार की 3x3x3।

3x3x3तस्वीर से आरजीबी हिस्सा गुणा किया जाता है elementwise एक से 3 डी फिल्टर (ग्रे के रूप में दिखाया गया है)। इस स्थिति में, फ़िल्टर में 3x3x3=27वजन होता है। जब इन भारों को गुणा तत्व वार और फिर सम्मनित किया जाता है, तो यह एक मूल्य देता है।

तो, क्या प्रत्येक इनपुट चैनल के लिए एक अलग फ़िल्टर है?

हाँ , छवि में इनपुट चैनलों की संख्या के रूप में कई 2D फिल्टर हैं । हालांकि , यह मदद करता है अगर आपको लगता है कि एक से अधिक चैनल वाले इनपुट मैट्रिस के लिए केवल एक 3 डी फिल्टर है (जैसा कि छवि में दिखाया गया है)।

फिर इसे 2D कनवल्शन क्यों कहा जाता है (यदि फ़िल्टर 3D है और इनपुट मैट्रिक्स 3D है)?

यह 2 डी घुमाव क्योंकि फिल्टर की प्रगति ऊंचाई के साथ और आयाम चौड़ाई केवल (है नहीं गहराई) और इसलिए, उत्पादन इस घुमाव के द्वारा उत्पादित भी एक 2 डी मैट्रिक्स है। फिल्टर के आंदोलन दिशाओं की संख्या दृढ़ संकल्प के आयामों को निर्धारित करती है।

नोट: यदि आप किसी एकल 3D फ़िल्टर की कल्पना करके अपनी समझ का निर्माण करते हैं कई 2D फ़िल्टर (प्रत्येक परत के लिए एक) के बजाय , तो आपको उन्नत CNN आर्किटेक्चर जैसे Resnet, InceptionV3, आदि समझने में आसान समय होगा।

Comments

यह एक अच्छी व्याख्या है, लेकिन अधिक विशेष रूप से यह सवाल जो मैं समझने की कोशिश कर रहा हूं, क्या यह है कि प्रत्येक इनपुट चैनल पर चलने वाले फिल्टर एक ही भार या पूरी तरह से अलग-अलग वजन की प्रतियां हैं। यह वास्तव में छवि में नहीं दिखाया गया है और वास्तव में मुझे लगता है कि छवि प्रकार का सुझाव है कि यह प्रत्येक चैनल पर एक ही भार लागू होता है (क्योंकि उनके समान रंग) ... प्रति @ स्लेटर का जवाब, यह प्रत्येक की तरह लगता है फ़िल्टर वास्तव में विभिन्न भार के input_channelsसाथ संस्करणों की संख्या है । यदि यह भी आपकी समझ है, तो क्या कोई "आधिकारिक" स्रोत इसकी पुष्टि कर रहा है?

— रयान चेस

हाँ, वास्तव में, यह भी मेरी समझ है। मेरे लिए, वह स्पष्ट था जब मैंने उस ग्रे क्यूब को 27 अलग-अलग वजन मूल्यों से बना होने के बारे में सोचने की कोशिश की थी । इसका मतलब यह है कि प्रत्येक इनपुट परत पर लागू 3 डी फिल्टर के बजाय 3 अलग 2 डी फिल्टर हैं।

— मोहसिन बुखारी

मुझे इसकी पुष्टि के लिए कोई आधिकारिक स्रोत नहीं मिला। हालांकि, जब मैं इसी अवधारणा के आसपास अपना सिर लपेटने की कोशिश कर रहा था, तो मैंने टेन्सरफ़्लो में एक डमी इनपुट और वेट फ़िल्टर बनाया और आउटपुट का अवलोकन किया। मुझे इससे संतोष था। अगर मुझे कोई आधिकारिक स्पष्टीकरण मिलता है। मैं अपने उत्तर को ऊपर संपादित करूंगा।

— मोहसिन बुखारी

यदि आप Tensorflow पाथ का पालन करते हैं। आप अपने डमी CNN परत को एक इनपुट सैंपल दिखाने के बाद अपना वेट फ़िल्टर प्रिंट कर सकते हैं।

— मोहसिन बुखारी

@ मोशिन बुखारी मैं निश्चित रूप से टेनसॉरफ्लो के भीतर फिल्टर का पता लगाने की कोशिश करूंगा। क्या आप अपने कोड को साझा करने के लिए तैयार हैं, कैसे आप फ़िल्टर में निहित है, यह जानने के लिए कि आप क्या कर रहे हैं? क्या आप उदाहरण के लिए नेटवर्क में प्रत्येक चरण पर फ़िल्टर के मूल्यों को प्रिंट करने में सक्षम हैं?

— रयान चेज़

Answer 3

मैं ऊपर दिए गए जवाबों पर एक ठोस उदाहरण के साथ उम्मीद कर रहा हूं कि आगे यह स्पष्ट किया जाएगा कि इनपुट और आउटपुट चैनल और वेट के संबंध में क्रमशः कैसे काम करता है:

उदाहरण इस प्रकार है (1 कंठनीय परत के लिए):

• इनपुट टेंसर 9x9x5, यानी 5 इनपुट चैनल हैं input_channels=5
• फ़िल्टर / कर्नेल का आकार 4x4 है और स्ट्राइड 1 है
• आउटपुट टेंसर 6x6x56 है, यानी 56 आउटपुट चैनल, इसलिए output_channels=56
• गद्दी का प्रकार 'वैध' है (अर्थात कोई गद्दी नहीं)

हमने ध्यान दिया कि:

• चूँकि इनपुट में 5 चैनल हैं, फ़िल्टर का आयाम 4x4x5 हो जाता है, अर्थात 5 अलग-अलग हैं, आकार के 4x4 के अनूठे 2 डी फिल्टर (यानी प्रत्येक में 16 वज़न है); 9x9x5 आकार के इनपुट पर समझाने के लिए फ़िल्टर 3 डी बन जाता है और इसका आकार 4x4x5 होना चाहिए
• इसलिए: प्रत्येक इनपुट चैनल के लिए, एक अलग 2 डी फिल्टर होता है जिसमें 16 अलग-अलग वजन होते हैं। दूसरे शब्दों में, 2 डी फिल्टर की संख्या इनपुट चैनलों की संख्या से मेल खाती है
• चूंकि 56 आउटपुट चैनल हैं, इसलिए 56 3-आयामी फ़िल्टर W0, W1, ... होना चाहिए, आकार का W55 4x4x5 (CS231 ग्राफ़िक में cf.) 2 आउटपुट के लिए खाते में 2 3-आयामी फ़िल्टर W0, W1 हैं। चैनल), जहां आकार 5 का 3 आयाम 5 इनपुट चैनलों के लिंक का प्रतिनिधित्व करता है (cf. CS231 ग्राफिक में प्रत्येक 3 डी फिल्टर W0, W1 में 3 आयाम 3 है, जो 3 इनपुट चैनलों से मेल खाता है)
• इसलिए: 3 डी फिल्टर की संख्या आउटपुट चैनलों की संख्या के बराबर होती है

इस प्रकार यह परतदार परत शामिल है:

56 आउटपुट चैनलों के लिए जहां 4 इनपुट चैनलों से मिलान करने के लिए 5 के तीसरे आयाम के लिए प्रत्येक का मूल्य है, 4 56xx5 (= 80 अलग-अलग वजन प्रत्येक) आकार के 56 3-आयामी फिल्टर। कुल में हैं

number_of_filters=input_channel*output_channels=5*56=280

4x4 के आकार के 2 डी फिल्टर (कुल मिलाकर 280x16 अलग-अलग वजन)।

Answer 4

2 डी में केवल प्रतिबंध हैं। क्यूं कर?

पूरी तरह से जुड़ी हुई परत की कल्पना करें।

यह बहुत बड़ा होगा, प्रत्येक न्यूरॉन 1000x1000x3 इनपुट न्यूरॉन्स से जुड़ा होगा। लेकिन हम जानते हैं कि आस-पास के पिक्सेल का प्रसंस्करण समझ में आता है, इसलिए हम खुद को एक छोटे 2 डी-पड़ोस में सीमित कर लेते हैं, इसलिए प्रत्येक न्यूरॉन 2 डी में न्यूरॉन्स के पास केवल 3x3 से जुड़ा होता है। हमें चैनलों के बारे में ऐसी कोई जानकारी नहीं है, इसलिए हम सभी चैनलों से जुड़ते हैं।

फिर भी, बहुत सारे वजन होंगे। लेकिन अनुवाद के कारण, एक क्षेत्र में अच्छी तरह से काम करने वाला एक फिल्टर एक अलग क्षेत्र में सबसे अधिक उपयोगी है। तो हम 2 डी में वजन के एक ही सेट का उपयोग करते हैं। फिर से, चैनलों के बीच ऐसा कोई अनुवाद नहीं है, इसलिए वहां ऐसा कोई प्रतिबंध नहीं है।

Answer 5

Http://cs231n.github.io/convolutional-networks/ में "स्थानीय कनेक्टिविटी" अनुभाग देखें और 7-18 स्लाइड करें।

"रिसेप्टिव फील्ड" फिल्टर का हाइपरपरमीटर केवल ऊंचाई और चौड़ाई द्वारा परिभाषित किया जाता है, क्योंकि गहराई परत की गहराई से तय होती है।

ध्यान दें कि "गहराई अक्ष के साथ कनेक्टिविटी की सीमा हमेशा इनपुट वॉल्यूम के DEPTH के बराबर होती है" -या- सक्रियण मानचित्र की DEPTH (बाद की परतों के मामले में)।

वास्तव में, यह इस तथ्य के कारण होना चाहिए कि छवि चैनल डेटा इंटरलेयर्ड हैं, न कि प्लानर। इस तरह, फ़िल्टरिंग आवेदन केवल कॉलम वैक्टर गुणा द्वारा प्राप्त किया जा सकता है।

ध्यान दें कि रूपांतरण नेटवर्क सभी फ़िल्टर पैरामीटर (गहराई आयाम सहित) सीखता है और वे कुल "h w input_layer_depth + 1 (पूर्वाग्रह)" हैं।

Answer 6

मैं एक जवाब के रूप में अपने स्वामी की थीसिस के अध्याय 2.2.1 की सिफारिश करता हूं । शेष उत्तरों में जोड़ने के लिए:

क्या होता है यह समझने के लिए केर आपका मित्र है:

from keras.models import Sequential
from keras.layers import Conv2D

model = Sequential()
model.add(Conv2D(32, input_shape=(28, 28, 3),
          kernel_size=(5, 5),
          padding='same',
          use_bias=False))
model.add(Conv2D(17, (3, 3), padding='same', use_bias=False))
model.add(Conv2D(13, (3, 3), padding='same', use_bias=False))
model.add(Conv2D(7, (3, 3), padding='same', use_bias=False))
model.compile(loss='categorical_crossentropy', optimizer='adam')

print(model.summary())

देता है

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 28, 28, 32)        2400      
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 28, 28, 17)        4896      
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 28, 28, 13)        1989      
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 28, 28, 7)         819       
=================================================================
Total params: 10,104

अपने विकल्प तैयार करने की कोशिश करें। पैरामीटर के लिए इसका क्या मतलब होगा अगर कुछ और मामला होगा?

संकेत: $2400 = 32 \cdot (3 \cdot 5 \cdot 5)$

यह दृष्टिकोण अन्य परतों के प्रकारों में भी आपकी मदद करता है, न कि केवल दृढ़ परतें।

कृपया यह भी ध्यान दें कि आप विभिन्न समाधानों को लागू करने के लिए स्वतंत्र हैं, जिनमें अन्य मापदंडों की संख्या हो सकती है।

Answer 7

बस दो विवरण बिल्कुल स्पष्ट करने के लिए:

बोलो तुम्हारे पास है $N$ 2 डी इनपुट चैनल जा रहे हैं $N$2 डी आउटपुट चैनल। 2 डी की कुल संख्या$3\times3$ फिल्टर वेट वास्तव में है $N^2$। लेकिन 3D कनवल्शन कैसे प्रभावित होता है, अर्थात, यदि हर इनपुट चैनल हर आउटपुट चैनल में एक 2D परत का योगदान देता है, तो प्रत्येक आउटपुट चैनल की रचना पूरी तरह से की जाती है$N$ 2D परतें, उन्हें कैसे संयोजित किया जाता है?

यह लगभग हर प्रकाशन में मैंने देखा है, लेकिन मुख्य अवधारणा है $N^2$ 2 डी आउटपुट चैनल को बनाने के लिए एक दूसरे के साथ इंटरलेक्ट किया जाता है $N$आउटपुट चैनल, जैसे कि कार्ड के डेक से फेरबदल, एक साथ सम्‍मिलित होने से पहले। यह सब तर्कसंगत है जब आपको पता चलता है कि एक कनवल्शन के चैनल आयाम (जो कि कभी सचित्र नहीं है) के साथ, आपके पास वास्तव में पूरी तरह से जुड़ी हुई परत है! हर इनपुट 2 डी चैनल, एक अद्वितीय द्वारा गुणा किया जाता है$3\times 3$फ़िल्टर, एकल आउटपुट चैनल में 2D आउटपुट लेयर योगदान देता है। एक बार संयुक्त हो जाने पर, प्रत्येक आउटपुट परत प्रत्येक इनपुट परत का एक संयोजन है$\times$एक अद्वितीय फ़िल्टर। यह सभी के लिए एक योगदान है।

इसका खुद को समझाने का सबसे आसान तरीका यह है कि अन्य परिदृश्यों में क्या होता है, इसकी कल्पना करें और देखें कि अभिकलन पतित हो जाता है - यही है, यदि आप परिणामों को इंटरलेव और पुनर्संयोजित नहीं करते हैं, तो विभिन्न आउटपुट वास्तव में कुछ भी नहीं करेंगे - वे संयुक्त भार के साथ एकल आउटपुट के रूप में इसका प्रभाव समान है।

Answer 8

किसी को समझने की कोशिश करने के लिए कि कैसे संकल्पों की गणना की जाती है, यहां पाइटोर में एक उपयोगी कोड स्निपेट है:

batch_size = 1
height = 3 
width = 3
conv1_in_channels = 2
conv1_out_channels = 2
conv2_out_channels = 2
kernel_size = 2
# (N, C_in, H, W) is shape of all tensors. (batch_size, channels, height, width)
input = torch.Tensor(np.arange(0, batch_size*height*width*in_channels).reshape(batch_size, in_channels, height, width))
conv1 = nn.Conv2d(in_channels, conv1_out_channels, kernel_size, bias=False) # no bias to make calculations easier
# set the weights of the convolutions to make the convolutions easier to follow
nn.init.constant_(conv1.weight[0][0], 0.25)
nn.init.constant_(conv1.weight[0][1], 0.5)
nn.init.constant_(conv1.weight[1][0], 1) 
nn.init.constant_(conv1.weight[1][1], 2) 
out1 = conv1(input) # compute the convolution

conv2 = nn.Conv2d(conv1_out_channels, conv2_out_channels, kernel_size, bias=False)
nn.init.constant_(conv2.weight[0][0], 0.25)
nn.init.constant_(conv2.weight[0][1], 0.5)
nn.init.constant_(conv2.weight[1][0], 1) 
nn.init.constant_(conv2.weight[1][1], 2) 
out2 = conv2(out1) # compute the convolution

for tensor, name in zip([input, conv1.weight, out1, conv2.weight, out2], ['input', 'conv1', 'out1', 'conv2', 'out2']):
    print('{}: {}'.format(name, tensor))
    print('{} shape: {}'.format(name, tensor.shape))

इसे चलाने से निम्नलिखित आउटपुट मिलते हैं:

input: tensor([[[[ 0.,  1.,  2.],
          [ 3.,  4.,  5.],
          [ 6.,  7.,  8.]],

         [[ 9., 10., 11.],
          [12., 13., 14.],
          [15., 16., 17.]]]])
input shape: torch.Size([1, 2, 3, 3])
conv1: Parameter containing:
tensor([[[[0.2500, 0.2500],
          [0.2500, 0.2500]],

         [[0.5000, 0.5000],
          [0.5000, 0.5000]]],


        [[[1.0000, 1.0000],
          [1.0000, 1.0000]],

         [[2.0000, 2.0000],
          [2.0000, 2.0000]]]], requires_grad=True)
conv1 shape: torch.Size([2, 2, 2, 2])
out1: tensor([[[[ 24.,  27.],
          [ 33.,  36.]],

         [[ 96., 108.],
          [132., 144.]]]], grad_fn=<MkldnnConvolutionBackward>)
out1 shape: torch.Size([1, 2, 2, 2])
conv2: Parameter containing:
tensor([[[[0.2500, 0.2500],
          [0.2500, 0.2500]],

         [[0.5000, 0.5000],
          [0.5000, 0.5000]]],


        [[[1.0000, 1.0000],
          [1.0000, 1.0000]],

         [[2.0000, 2.0000],
          [2.0000, 2.0000]]]], requires_grad=True)
conv2 shape: torch.Size([2, 2, 2, 2])
out2: tensor([[[[ 270.]],

         [[1080.]]]], grad_fn=<MkldnnConvolutionBackward>)
out2 shape: torch.Size([1, 2, 1, 1])

ध्यान दें कि सजा के प्रत्येक चैनल को पिछले सभी चैनलों के आउटपुट पर कैसे लिखा जाता है।