ResNet स्किप कनेक्शन के माध्यम से ग्रैडिएंट बैकप्रोपैजेशन

Question

मैं इस बात को लेकर उत्सुक हूं कि कैसे न्यूट्रल नेटवर्क का उपयोग नेट-रेस्पेक्ट्स / स्किप कनेक्शन के माध्यम से किया जाता है। मैंने ResNet (जैसे स्किप-लेयर कनेक्शन वाले न्यूरल नेटवर्क ) के बारे में कुछ सवाल देखे हैं, लेकिन यह विशेष रूप से प्रशिक्षण के दौरान ग्रेडिएंट्स के बैक-प्रचार के बारे में पूछ रहा है।

बुनियादी वास्तुकला यहाँ है:

मैंने इस पेपर को पढ़ा, स्टडी ऑफ़ रेजिडेंशियल नेटवर्क्स फॉर इमेज रिकॉग्निशन , और सेक्शन 2 में वे बात करते हैं कि कैसे रेजनेट के लक्ष्यों में से एक आधार परत के बैकग्रैगेट के लिए ढाल के लिए एक छोटे / स्पष्ट मार्ग की अनुमति देना है।

क्या कोई समझा सकता है कि इस प्रकार के नेटवर्क के माध्यम से ढाल कैसे बह रही है? मुझे यह समझ में नहीं आता है कि अतिरिक्त संचालन, और इसके बाद एक पैरामीटर वाली परत की कमी, बेहतर ढाल प्रसार के लिए कैसे अनुमति देता है। क्या इसके साथ कुछ करना है कि कैसे एक ढाल ऑपरेटर के माध्यम से बहते समय ढाल नहीं बदलता है और किसी तरह गुणा के बिना पुनर्वितरित होता है?

इसके अलावा, मैं समझ सकता हूं कि कैसे गायब होने वाली ढाल की समस्या को कम किया जा सकता है अगर ढाल को वजन परतों के माध्यम से प्रवाह करने की आवश्यकता नहीं है, लेकिन यदि भार के माध्यम से कोई ढाल प्रवाह नहीं होता है तो वे पिछड़े पास के बाद कैसे अपडेट होते हैं?

Comments

सिर्फ एक मुहावरेदार सवाल, हम एक्स को स्किप कनेक्शन के रूप में क्यों पास करते हैं और अंत में x प्राप्त करने के लिए व्युत्क्रम (F (x)) की गणना नहीं करते हैं। क्या यह कम्प्यूटेशनल जटिलता का कारण है?

— यश कुमार अत्रि

मुझे आपकी बात नहीं मिली the gradient doesn't need to flow through the weight layers, क्या आप समझा सकते हैं?

— अनु

Answer 1

जोड़ें ढाल दोनों इनपुट के लिए समान रूप से वापस भेजता है। आप निम्नलिखित में से दसवें भाग को चलाकर खुद को समझा सकते हैं:

import tensorflow as tf

graph = tf.Graph()
with graph.as_default():
    x1_tf = tf.Variable(1.5, name='x1')
    x2_tf = tf.Variable(3.5, name='x2')
    out_tf = x1_tf + x2_tf

    grads_tf = tf.gradients(ys=[out_tf], xs=[x1_tf, x2_tf])
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        fd = {
            out_tf: 10.0
        }
        print(sess.run(grads_tf, feed_dict=fd))

आउटपुट:

[1.0, 1.0]

तो, ढाल होगा:

• स्किप-लेयर कनेक्शन के माध्यम से, और भी, अपरिवर्तित पिछली परतों में वापस आ गया
• वज़न के साथ ब्लॉक में गए, और उन वज़न को अपडेट करने के लिए उपयोग किया गया

संपादित करें: एक सवाल है: "उस बिंदु पर ऑपरेशन क्या है जहां राजमार्ग कनेक्शन और तंत्रिका जाल ब्लॉक फिर से एक साथ जुड़ जाते हैं, चित्रा 2 के तल पर?"

वहाँ जवाब है: वे अभिव्यक्त हैं। आप इसे चित्र 2 के सूत्र से देख सकते हैं:

$$\mathbf{\text{output}} \leftarrow \mathcal{F}(\mathbf{x}) + \mathbf{x}$$

यह क्या कहता है:

• बस में मूल्य ( )$\mathbf{x}$
• नेटवर्क के माध्यम से बस मान, , यानी को पास करने के परिणामों में जोड़ा जाता हैF ( x$\mathbf{x}$$\mathcal{F}(\mathbf{x})$
• अवशिष्ट ब्लॉक से आउटपुट देने के लिए, जिसे मैंने यहाँ रूप में लेबल किया है$\mathbf{\text{output}}$

2 संपादित करें:

थोड़ा अलग शब्दों में फिर से लिखना:

• आगे की दिशा में, इनपुट डेटा बस के नीचे बहता है
  • बस के साथ बिंदुओं पर, अवशिष्ट ब्लॉक बस वेक्टर में मूल्यों को जोड़ना / निकालना सीख सकते हैं
• पीछे की दिशा में, ढाल बस के नीचे वापस बहती है
  • जिस तरह से, ग्रेडिएंट उन अवशिष्ट ब्लॉकों को अपडेट करते हैं, जो वे अतीत में जाते हैं
  • अवशिष्ट ब्लॉक स्वयं ग्रेडिएंट्स को थोड़ा संशोधित करेंगे

अवशिष्ट ब्लॉक पीछे की ओर बहने वाले ग्रेडिएंट्स को संशोधित करते हैं, लेकिन कोई 'स्क्वैशिंग' या 'सक्रियण' फ़ंक्शन नहीं होते हैं जो ग्रेडिएंट प्रवाह के माध्यम से होते हैं। 'स्क्वैशिंग' / 'सक्रियण' कार्य वे हैं जो विस्फोट / गायब होने वाली ढाल समस्या का कारण बनते हैं, इसलिए बस से उन लोगों को हटाकर, हम इस समस्या को काफी कम कर देते हैं।

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

Comments

अगर ढाल को वजन ब्लॉकों (नियमित नेटवर्क की तरह) के माध्यम से भी पारित किया जा रहा है, तो रेजनेट लाभ कहां से आ रहा है? यकीन है, यह ढाल को सीधे आधार इनपुट पर छोड़ देता है, लेकिन जब दूसरा रास्ता अभी भी सामान्य रूप से प्रशिक्षित होता है, तो यह प्रदर्शन कैसे बढ़ाता है?

— साइमन

समझा। तो एक ग्रेडिएंट सीधे वापस x पर जा रहा है, दूसरा वज़न वापस x पर प्रचारित करता है। जब वे x को 2 रास्तों में विभाजित होने के कारण x तक पहुँचते हैं, तो वे सम्मनित हो जाते हैं? यदि हां, तो ढाल अभी भी नहीं बदल रहा है क्योंकि यह इन परतों के माध्यम से वापस जाता है?

— शमौन

ग्रेडिएंट्स स्टैक के नीचे सभी तरह से बहते हैं, अपरिवर्तित। हालांकि, प्रत्येक ब्लॉक अपने भार अपडेट को लागू करने, और ग्रेडिएंट के अपने सेट को उत्पन्न करने के बाद, स्टैक में अपने स्वयं के ढाल परिवर्तन में योगदान देता है। प्रत्येक ब्लॉक में इनपुट और आउटपुट दोनों हैं, और ग्रेडिएंट इनपुट से बाहर निकल जाएंगे, वापस ग्रेडिएंट "हाईवे" में।

— ह्यूग पर्किंस

@RonakAgrawal ने चित्र 2 से राशि संचालिका दिखाते हुए एक संपादन जोड़ा, और इसे समझाते हुए कहा

— ह्यूग पर्किंस

मेरी व्याख्या को थोड़ा बढ़ाते हुए एक दूसरा संपादन जोड़ा गया :)

— ह्यूग पर्किंस