तंत्रिका नेटवर्क और गहन शिक्षण, अध्याय 2: बैकप्रॉपैग्मेशन एल्गोरिदम कैसे काम करता है

पिछले अध्याय में, हमने देखा कि कैसे तंत्रिका नेटवर्क स्वतंत्र रूप से ढाल वंश एल्गोरिथ्म का उपयोग करके वज़न और ऑफसेट सीख सकते हैं। हालांकि, हमारे स्पष्टीकरण में एक अंतर था: हमने लागत फ़ंक्शन के ग्रेडिएंट की गणना पर चर्चा नहीं की। और यह एक सभ्य अंतर है! इस अध्याय में, मैं ऐसे ग्रेडिएंट्स की गणना करने के लिए एक त्वरित एल्गोरिदम पेश करूंगा, जिन्हें बैक प्रोपगेशन के रूप में जाना जाता है।

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

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

कारण, निश्चित रूप से, समझ है। पिछला प्रसार नेटवर्क के वजन w (या पूर्वाग्रह ख) के संबंध में लागत फ़ंक्शन C के आंशिक व्युत्पन्न ∂C / agw की अभिव्यक्ति पर आधारित है। अभिव्यक्ति से पता चलता है कि जब वजन और ऑफसेट बदलते हैं तो मूल्य कितनी जल्दी बदलता है। और यद्यपि यह अभिव्यक्ति काफी जटिल है, इसकी अपनी सुंदरता है, क्योंकि इसके प्रत्येक तत्व की एक प्राकृतिक और सहज व्याख्या है। इसलिए, बैकप्रॉपैजेशन केवल एक तेजी से सीखने का एल्गोरिथ्म नहीं है। यह हमें एक विस्तृत समझ देता है कि बदलते वजन और ऑफसेट सभी नेटवर्क व्यवहार को कैसे बदलते हैं। और विवरणों का अध्ययन करने के लिए इसके लायक है।

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

वार्म अप के लिए: तंत्रिका नेटवर्क के आउटपुट की गणना के लिए एक त्वरित मैट्रिक्स दृष्टिकोण

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

आइए एक रिकॉर्ड से शुरू करें जो हमें नेट पर वेट स्पष्ट रूप से इंगित करने की अनुमति देता है। हम लेयर नंबर l में न्यूरॉन नंबर k (l-1) के साथ न्यूरॉन नंबर k के कनेक्शन वजन को दर्शाने के लिए w ^l _jk का उपयोग करेंगे। इसलिए, उदाहरण के लिए, नीचे दिए गए आरेख में तीसरे परत के दूसरे न्यूरॉन के साथ दूसरी परत के चौथे न्यूरॉन का कनेक्शन वजन दिखाया गया है:



सबसे पहले, ऐसी रिकॉर्डिंग अजीब लगती है, और इसके लिए कुछ उपयोग करने की आवश्यकता होती है। हालाँकि, जल्द ही यह आपको सरल और स्वाभाविक लगने लगेगा। इसकी विशेषताओं में से एक सूचकांक जम्मू और कश्मीर का क्रम है। आप तय कर सकते हैं कि इनपुट न्यूरॉन को नामित करने के लिए j का उपयोग करना अधिक उचित होगा, और k - आउटपुट न्यूरॉन के लिए, और इसके विपरीत नहीं, जैसा कि हमारे पास है। मैं नीचे इस सुविधा का कारण बताऊंगा।

हम ऑफसेट और नेटवर्क सक्रियण के लिए समान सूचनाओं का उपयोग करेंगे। विशेष रूप से, b ^l _j परत संख्या l में न्यूरॉन नंबर j के विस्थापन को निरूपित करेगा। एक ^l _j परत संख्या l में न्यूरॉन नंबर j के सक्रियण को निरूपित करेगी। निम्नलिखित आरेख इस प्रविष्टि का उपयोग करने के तरीके दिखाता है:



इस तरह के रिकॉर्ड के साथ, परत संख्या l में न्यूरॉन नं। _{J के} ^l _{j की} सक्रियता निम्नलिखित समीकरण द्वारा परत संख्या (l-1) में सक्रियण से जुड़ी है (समीकरण (4) के साथ तुलना और पिछले अध्याय में इसकी चर्चा):

$$

$$a ^ l_j = \ sigma (\ sum_k w ^ l_ {jk} a ^ {l - 1} _k + b ^ l_j) \ tag {23}$$

जहाँ योग परत (l-1) में सभी न्यूरॉन्स k के ऊपर जाता है। मैट्रिक्स रूप में इस अभिव्यक्ति को फिर से लिखने के लिए, हम प्रत्येक परत l के लिए एक भार मैट्रिक्स w ^l को परिभाषित करते हैं। भार मैट्रिक्स के तत्व केवल परत संख्या l से जुड़े भार हैं, अर्थात पंक्ति संख्या j और स्तंभ संख्या k में तत्व w ^l _{jk होगा} । इसी तरह, प्रत्येक लेयर l के लिए हम विस्थापन वेक्टर b ^l को परिभाषित करते हैं। आपने शायद अनुमान लगाया कि यह कैसे काम करता है - विस्थापन सदिश के घटक केवल मान b ^l _{j होंगे} , परत संख्या l में प्रत्येक न्यूरॉन के लिए एक घटक। और अंत में, हम सक्रियण वेक्टर को ^l परिभाषित करते हैं, जिसके घटक सक्रियण ^l _{j हैं} ।

फिर से लिखने के लिए आवश्यक अंतिम घटक (23) फ़ंक्शन के वेक्टरकरण का मैट्रिक्स रूप है re। हमने अंतिम अध्याय में लापरवाही से वेक्टराइजेशन का सामना किया - विचार यह है कि हम वेक्टर v के प्रत्येक तत्व के लिए फ़ंक्शन encountered को लागू करना चाहते हैं। हम फ़ंक्शन के तत्व-वार अनुप्रयोग को दर्शाने के लिए स्पष्ट संकेतन σ (v) का उपयोग करते हैं। अर्थात, घटक σ (v) बस v (v) _j = v (v _j ) हैं। उदाहरण के लिए, यदि हमारे पास एक फ़ंक्शन f (x) = x ^{2 है} , तो वेक्टरकृत फॉर्म f हमें देता है

$$

$$f (\ start {bmatrix} 2 \\ 3 \ end {bmatrix}) = \ start {bmatrix} f (2) \\ f (3) \ end {bmatrix} = \ start {bmatrix} 4 \ _ 9 \ _ अंत {bmatrix} \ टैग {24}$$

यह है, एक सदिश च बस वेक्टर के हर तत्व को वर्ग करता है।

लेखन के इन सभी रूपों को देखते हुए, समीकरण (23) को एक सुंदर और कॉम्पैक्ट वेक्टर रूप में फिर से लिखा जा सकता है:

$$

$$a ^ l = \ sigma (w ^ l a ^ {l - 1} + b ^ l) \ टैग {25}$$

इस तरह की अभिव्यक्ति हमें एक परत की सक्रियता और पिछले एक की सक्रियता के बीच संबंधों पर अधिक वैश्विक नज़र डालने की अनुमति देती है: हम बस सक्रियण के लिए वजन मैट्रिक्स को लागू करते हैं, विस्थापन वेक्टर को जोड़ते हैं और फिर सिग्मॉइड को लागू करते हैं। वैसे, यह यह रिकॉर्ड है जिसे रिकॉर्ड w ^l _jk के उपयोग की आवश्यकता होती है। यदि हमने इनपुट न्यूरॉन को सूचित करने के लिए इंडेक्स जे का उपयोग किया है, और आउटपुट न्यूरॉन के लिए k, तो हमें ट्रांसपोज़्ड के साथ समीकरण (25) में वेट मैट्रिक्स को बदलना होगा। यह एक छोटा लेकिन कष्टप्रद परिवर्तन है, और हम "वजन मैट्रिक्स को सक्रिय करने के लिए लागू करने" के बारे में कथन (और प्रतिबिंब) की सादगी को खो देंगे। इस तरह का एक वैश्विक दृष्टिकोण सरल और अधिक संक्षिप्त है (और कम इंडेक्स का उपयोग करता है!) पोनूरन एक की तुलना में। यह क्या हो रहा है की सटीकता को खोए बिना सूचकांक नरक से बचने का एक तरीका है। यह अभिव्यक्ति व्यवहार में भी उपयोगी है, क्योंकि अधिकांश मैट्रिक्स लाइब्रेरी मैट्रिस को गुणा करने, वैक्टर जोड़ने और वेक्टर बनाने के त्वरित तरीके प्रदान करते हैं। पिछले अध्याय के कोड ने सीधे नेटवर्क व्यवहार की गणना करने के लिए इस अभिव्यक्ति का उपयोग किया।

एक ^{एल की} गणना करने के लिए समीकरण (25) का उपयोग करते हुए, हम मध्यवर्ती मान z ^{l l} w ^{l l} a ^{l - 1} + b ^{l की} गणना करते हैं। यह मान नामकरण के लिए काफी उपयोगी है: हम z को लेयर नंबर l के न्यूरॉन्स का भारित इनपुट कहते हैं। बाद में हम सक्रिय रूप से इस भारित इनपुट का उपयोग करेंगे। समीकरण (25) को कभी-कभी भारित इनपुट के माध्यम से, ^l = σ (z ^l ) के रूप में लिखा जाता है। यह भी ध्यान देने योग्य है कि z ^l में घटक हैं $$$z ^ l_j = \ sum_k w ^ l_ {jk} a ^ {l - 1} _k + b ^ l_j$ यह है, z ^l j, लेयर l में न्यूरॉन j के सक्रियण कार्य का एक भारित इनपुट है।

लागत समारोह के बारे में दो आवश्यक धारणाएं

Backpropagation का लक्ष्य प्रत्येक वजन और नेटवर्क के पूर्वाग्रह ख के लिए लागत फ़ंक्शन C के आंशिक डेरिवेटिव ∂C / ∂w और /C / costb की गणना करना है। काम के लिए बैकप्रोपेगेशन के लिए, हमें लागत फ़ंक्शन के रूप के बारे में दो मुख्य धारणाएं बनाने की आवश्यकता है। हालांकि, इससे पहले एक लागत समारोह के उदाहरण की कल्पना करना उपयोगी होगा। हम पिछले अध्याय (समीकरण (6)) से द्विघात फ़ंक्शन का उपयोग करते हैं। पिछले अनुभाग से प्रविष्टि में, यह दिखेगा

$$

$$C = \ frac {1} {2n} \ sum_x || y (x) - a ^ L (x) || ^ 2 \ tag {26} $ |$$

जहाँ: n प्रशिक्षण के उदाहरणों की कुल संख्या है; योग सभी उदाहरणों के लिए जाता है x; y = y (x) आवश्यक आउटपुट है; एल नेटवर्क में परतों की संख्या को दर्शाता है; ^L = a ^L (x) इनपुट पर x होने पर नेटवर्क सक्रियण का आउटपुट वेक्टर है।

ठीक है, इसलिए बैकप्रोपेगैशन लागू करने के लिए हमें लागत फ़ंक्शन C के बारे में किस तरह की धारणाओं की आवश्यकता है? सबसे पहले, लागत फ़ंक्शन को व्यक्तिगत प्रशिक्षण उदाहरण x के लिए लागत फ़ंक्शन C _x के औसत C = 1 / n _{x x} C _x के रूप में लिखा जा सकता है। यह एक द्विघात लागत फ़ंक्शन के मामले में किया जाता है, जहां एक प्रशिक्षण उदाहरण की लागत C _x = 1/2 है। y - a ^L || ^२ । यह धारणा अन्य सभी लागत कार्यों के लिए सही होगी जो हम पुस्तक में मिलेंगे।

हमें इस धारणा की आवश्यकता है क्योंकि वास्तव में पीछे प्रसार हमें प्रशिक्षण उदाहरणों पर औसत डेरिवेटिव ∂C / andw और ∂C / ∂b की गणना करने की अनुमति देता है। इस धारणा को स्वीकार करते हुए, हम मानते हैं कि प्रशिक्षण उदाहरण x तय हो गया है, और सी को _x के मान के रूप में लिखते हुए सूचकांक x को निर्दिष्ट करना बंद कर दें। फिर हम x वापस आएंगे, लेकिन अभी के लिए इसका अर्थ बेहतर है।

लागत समारोह के संबंध में दूसरी धारणा - इसे तंत्रिका नेटवर्क के उत्पादन के कार्य के रूप में लिखा जा सकता है:



उदाहरण के लिए, द्विघात लागत फ़ंक्शन इस आवश्यकता को पूरा करता है, क्योंकि एक प्रशिक्षण उदाहरण x के द्विघात लागत को लिखा जा सकता है

$$

$$C = 1/2 || y - a ^ L || ^ 2 = 1/2 \ sum_j (y_j - a L_j) ^ 2 \ टैग {27}$$

जो आउटपुट एक्टीविटीज का कार्य करेगा। बेशक, यह लागत फ़ंक्शन वांछित आउटपुट y पर भी निर्भर करता है, और आपको आश्चर्य हो सकता है कि हम C को एक फ़ंक्शन के रूप में भी क्यों नहीं मानते हैं। हालाँकि, याद रखें कि इनपुट प्रशिक्षण उदाहरण x तय है, इसलिए आउटपुट y भी निश्चित है। विशेष रूप से, हम इसे वजन और विस्थापन को बदलकर बदल नहीं सकते हैं, अर्थात यह वह नहीं है जो तंत्रिका नेटवर्क सीखता है। इसलिए, सी को केवल आउटपुट ए ^एल , और वाई को केवल एक पैरामीटर के रूप में माना जाता है जो इसे निर्धारित करने में मदद करता है।

हद्दाम का काम sardt

Backpropagation एल्गोरिथ्म रैखिक बीजगणित के सामान्य संचालन पर आधारित है - वैक्टर के अलावा, एक मैट्रिक्स द्वारा वेक्टर का गुणन, आदि। हालांकि, किसी एक ऑपरेशन का कम बार उपयोग किया जाता है। मान लीजिए कि s और t एक ही आयाम के दो वैक्टर हैं। फिर slict द्वारा हम दो वैक्टरों के मूल तत्व गुणन को दर्शाते हैं। तब घटक s jt बस (s⊙t) _j = s _j t t _{होते हैं} । उदाहरण के लिए:

$$

$$\ start {bmatrix} 1 \\ 2 \ end {bmatrix} \ odot \ start {bmatrix} 3 \\ 4 \ end {bmatrix} = \ start {bmatrix} 1 * 3 \\ 2 * 4 अंत {bmatrix} = \ start {bmatrix} 3 \\ 8 \ end {bmatrix} \ टैग {28}$$

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

वापस प्रसार के लिए चार मौलिक समीकरण

बैकप्रॉपैगैनेशन में यह समझना शामिल है कि नेटवर्क के वज़न और ऑफसेट को बदलने से लागत फ़ंक्शन कैसे बदल जाता है। संक्षेप में, इसका अर्थ है आंशिक डेरिवेटिव ∂C / jw ^l _jk और thisC / jb ^l _{j की} गणना करना। लेकिन उनकी गणना के लिए, हम पहले मध्यवर्ती मान, ^l _{j की} गणना करते हैं, जिसे हम न्यूरॉन नंबर j में लेयर नंबर l में त्रुटि कहते हैं। वापस प्रसार हमें त्रुटि, ^एल _{जे की} गणना के लिए एक प्रक्रिया देगा, और फिर ∂C / ∂w ^l _jk और ∂C / lb ^l _{j के} साथ with ^l _j को संबद्ध करेगा।

यह समझने के लिए कि कोई त्रुटि कैसे निर्धारित की जाती है, कल्पना करें कि हमारे तंत्रिका नेटवर्क में एक दानव शुरू हो गया है:



वह परत संख्या l में न्यूरॉन नं। J पर बैठता है। इनपुट डेटा प्राप्त होने पर, डेमॉन न्यूरॉन के संचालन को बाधित करता है। यह न्यूरॉन के भारित इनपुट में lz ^l _j में एक छोटा सा बदलाव जोड़ता है, और ding (z ^l _j ) उपज के बजाय, न्यूरॉन σ (z ^l _j + Δz ^l _j ) का उत्पादन करेगा। यह परिवर्तन नेटवर्क की निम्न परतों के माध्यम से भी फैल जाएगा, जो अंततः (/C / *z ^l _j ) * lz ^l _j द्वारा कुल लागत को बदल देगा।

लेकिन हमारा दानव अच्छा है, और वह आपको लागत में सुधार करने में मदद करने की कोशिश कर रहा है, अर्थात lz ^l _{j खोजें} जो लागत को कम करता है। मान लीजिए /C / ∂z ^l _j बड़ी (धनात्मक या ऋणात्मक) है। तब दानव गंभीर रूप से canz ^l _j को canC / lz ^l _{j के} विपरीत चिन्ह के साथ चुनकर लागत को कम कर सकता है। लेकिन अगर toC / lz ^l _j शून्य के करीब है, तो दानव भारित इनपुट z _{j j} को बदलकर लागत में बहुत सुधार नहीं कर सकता है। इसलिए, दानव के दृष्टिकोण से, न्यूरॉन पहले से ही इष्टतम के करीब है (यह, ज़ाहिर है, केवल छोटे smallz ^l _{j के} लिए सही है। मान लीजिए कि ये दानव के कार्यों की सीमाएं हैं)। इसलिए, हेयुरिस्टिक अर्थों में, inC / jz ^l _j न्यूरॉन त्रुटि का एक उपाय है।

इस कहानी से प्रेरणा के तहत, हम परत l, में न्यूरॉन j के त्रुटि mot ^l _{j को} परिभाषित करते हैं

$$

$$\ delta l_j \ equiv \ frac {\ आंशिक C} {\ आंशिक z ^ l_j} \ tag {29}$$

हमारे सामान्य सम्मेलन द्वारा, हम परत l से जुड़े त्रुटि वेक्टर को दर्शाने के लिए to ^l का उपयोग करते हैं। वापस प्रसार हमें किसी भी परत के लिए any ^{l की} गणना करने का एक तरीका देगा, और फिर इन त्रुटियों को उन मात्राओं के साथ सहसंबंधित करेगा जो वास्तव में हमारी रुचि रखते हैं, /C / ∂w ^l _jk और ∂C / lb ^l _j ।

आप सोच रहे होंगे कि डेमन वेटेड इनपुट z ^l _{j को} क्यों बदलता है। आखिरकार, यह कल्पना करना अधिक स्वाभाविक होगा कि दानव आउटपुट सक्रियण को ^l _j बदलता है ताकि हम त्रुटि के माप के रूप में /C / aa ^l _{j का} उपयोग करें। वास्तव में, यदि आप ऐसा करते हैं, तो सब कुछ बहुत समान है जो हम आगे चर्चा करेंगे। हालांकि, इस मामले में, बैकप्रोपेगैनेशन का प्रतिनिधित्व बीजगणितीय रूप से थोड़ा अधिक जटिल होगा। इसलिए, हम त्रुटि के माप के रूप में δ ^l _j = ∂C / jz ^l _j पर वास करते हैं।

वर्गीकरण की समस्याओं में, "त्रुटि" शब्द का अर्थ कभी-कभी गलत वर्गीकरण की संख्या होता है। उदाहरण के लिए, यदि कोई तंत्रिका नेटवर्क 96.0% अंकों को सही ढंग से वर्गीकृत करता है, तो त्रुटि 4.0% होगी। जाहिर है, यह बिल्कुल नहीं है कि हम वैक्टर δ से क्या मतलब है। लेकिन व्यवहार में, आप आमतौर पर आसानी से समझ सकते हैं कि क्या अर्थ है।

अटैक प्लान : बैकप्रॉपैजेशन चार मूलभूत समीकरणों पर आधारित है। साथ में, वे हमें त्रुटि δ ^l और लागत फ़ंक्शन के ढाल की गणना करने का एक तरीका देते हैं। मैं उन्हें नीचे देता हूं। उनके त्वरित विकास की उम्मीद करने की जरूरत नहीं है। आप निराश होंगे। बैकप्रॉपैगेशन समीकरण इतने गहरे हैं कि एक अच्छी समझ के लिए ठोस समय और धैर्य की आवश्यकता होती है, और सवाल का एक क्रमिक गहरापन। अच्छी खबर यह है कि यह धैर्य सुंदर रूप से चुकाएगा। इसलिए, इस खंड में, हमारा तर्क अभी शुरू हो रहा है, जिससे आपको समीकरणों की गहरी समझ का मार्ग अपनाने में मदद मिलेगी।

यहाँ एक आरेख है कि हम बाद में इन समीकरणों में कैसे तल्लीन हो जाएंगे: मैं उन्हें स्पष्ट करने में मदद करने का एक संक्षिप्त प्रमाण दूंगा कि वे सच क्यों हैं; हम उन्हें pseudocode के रूप में एक एल्गोरिथम रूप में फिर से लिखेंगे, और देखेंगे कि वास्तविक पायथन कोड में इसे कैसे लागू किया जाए; अध्याय के अंतिम भाग में, हम बैकप्रोगैगेशन समीकरणों के अर्थ के बारे में एक सहज ज्ञान युक्त विचार विकसित करेंगे, और उन्हें खरोंच से कैसे पाया जा सकता है। हम समय-समय पर चार मूलभूत समीकरणों की ओर लौटेंगे, और आप उन्हें जितना गहराई से समझेंगे, वे उतने ही सहज और सुंदर और स्वाभाविक लगेंगे।

आउटपुट लेयर की त्रुटि का समीकरण, the ^L : considered ^L के घटकों को माना जाता है

$$

$$\ डेल्टा ^ L_j = \ frac {\ आंशिक C} {\ आंशिक a L_j} \ sigma '(z ^ L_j) \ टैग {BP1}$$

बहुत ही स्वाभाविक अभिव्यक्ति। दाईं ओर पहला शब्द, /C / La ^L _j , यह बताता है कि आउटपुट सक्रियण सं। J के कार्य के रूप में लागत कितनी जल्दी बदलती है। यदि, उदाहरण के लिए, C विशेष रूप से आउटपुट न्यूरॉन j पर निर्भर नहीं है, तो will ^L _j उम्मीद के मुताबिक छोटा होगा। दाईं ओर दूसरा शब्द, σ '(z ^L _j ), मापता है कि सक्रियण फ़ंक्शन σ z ^L _j में कितनी जल्दी बदलता है।

ध्यान दें कि (BP1) में सब कुछ गिनना आसान है। विशेष रूप से, हम नेटवर्क के व्यवहार की गणना करते समय z ^L _{j की} गणना करते हैं, और ^L '(z ^L _j ) की गणना करने के लिए इसे थोड़ा और संसाधन लगेगा। बेशक, सटीक रूप ∂C / ,a ^L _j लागत फ़ंक्शन के रूप पर निर्भर करता है। हालांकि, यदि लागत फ़ंक्शन ज्ञात है, तो ∂C / La ^L _{j की} गणना के साथ कोई समस्या नहीं होनी चाहिए। उदाहरण के लिए, यदि हम द्विघात लागत फ़ंक्शन का उपयोग करते हैं, तो C = 1/2 y _j (y _j - a ^L _j ) ² , इसलिए ,C / ∂a ^L _j = (a ^L _j - y _j ), जिसकी गणना करना आसान है।

समीकरण (BP1)) L की एक विस्फोटित अभिव्यक्ति है ^। यह पूरी तरह से सामान्य है, लेकिन मैट्रिक्स के रूप में दर्ज नहीं किया गया है, जिसे हमें वापस वितरण की आवश्यकता है। हालाँकि, मैट्रिक्स के रूप में, इसे फिर से लिखना आसान है

$$

$$\ delta ^ L = \ nabla_a C \ odot \ sigma '(z ^ L) \ टैग {BP1a}$$

यहाँ are C को एक वेक्टर के रूप में परिभाषित किया गया है जिसके घटक आंशिक डेरिवेटिव ∂C / ∇a ^L _{j हैं} । इसे आउटपुट सक्रियताओं के संबंध में सी के परिवर्तन की दर की अभिव्यक्ति के रूप में दर्शाया जा सकता है। यह देखना आसान है कि समीकरण (BP1a) और (BP1) समतुल्य हैं, इसलिए हम उनमें से किसी को भी संदर्भित करने के लिए (BP1) का उपयोग करेंगे। उदाहरण के लिए, द्विघात मान के मामले में, हमारे पास _a C = (एक ^L - y) है, इसलिए पूर्ण मैट्रिक्स रूप (BP1) होगा

$$

$$\ delta ^ L = (a ^ L - y) \ odot \ sigma '(z ^ L) \ टैग {30}$$

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

त्रुटि की अभिव्यक्ति through ^एल अगली परत में त्रुटि के माध्यम से, ^{1 l + 1} : विशेष रूप से,

$$

$$\ delta ^ l = ((w ^ {l + 1}) ^ T \ delta ^ {l + 1}) \ cdot \ sigma '(z ^ l) \ टैग {BP2}$$

जहाँ (w ^{l + 1} ) ^T परत संख्या (l + 1) के लिए भार मैट्रिक्स w ^{l + 1} का स्थानान्तरण है। समीकरण जटिल लगता है, लेकिन प्रत्येक तत्व की व्याख्या करना आसान है। मान लें कि हम परत (l + 1) के लिए त्रुटि ^{+ l + 1} जानते हैं। वजन मैट्रिक्स के ट्रांसपोज़ेशन, (w ^{l + 1} ) ^T , नेटवर्क के माध्यम से त्रुटि को पीछे की ओर ले जाने के रूप में कल्पना की जा सकती है, जो हमें परत संख्या l के आउटपुट में त्रुटि के कुछ माप देता है। तब हम हैडमार्ड उत्पाद ('(z ^l ) पर विचार करते हैं। यह परत l में सक्रियण फ़ंक्शन के माध्यम से त्रुटि को वापस लाता है, जिससे हमें परत l के लिए भारित इनपुट में त्रुटि मान मिल जाता है।

(BP1) के साथ संयोजन करके (BP1), हम किसी भी नेटवर्क लेयर के लिए त्रुटि any ^{l की} गणना कर सकते हैं।हम start ^{L की} गणना करने के लिए (BP1) का उपयोग करके शुरू करते हैं , फिर समीकरण (BP2) का उपयोग- ^{L-1 की} गणना करने के लिए करते हैं, फिर- ^{L-2 की} गणना करने के लिए , और इसी तरह, नेटवर्क के पीछे सभी तरह से।

नेटवर्क में किसी भी ऑफसेट के संबंध में लागत में परिवर्तन की दर का समीकरण : विशेष रूप से:

$$

$$\frac{\partial C}{\partial b^l_j} = \delta^l_j \tag{BP3}$$

यही है, त्रुटि _j ^l _j परिवर्तन की दर के बराबर है ∂C / lb ^l _j । यह उत्कृष्ट है क्योंकि (BP1) और (BP2) ने हमें पहले ही बताया है कि δ ^l _{j की} गणना कैसे करें । हम (BP3) को फिर से छोटा कर सकते हैं

$$

$$\frac{\partial C}{\partial b} = \delta \tag{31}$$

जहां δ पूर्वाग्रह के रूप में एक ही न्यूरॉन के लिए अनुमानित है।

नेटवर्क में किसी भी वजन के संबंध में मूल्य परिवर्तन की दर के लिए समीकरण : विशेष रूप से:

$$

$$\frac{\partial C}{\partial w^l_{jk}} = a^{l-1}_k \delta^l_j \tag{BP4}$$

यहां से हम सीखते हैं कि आंशिक व्युत्पन्न ∂C / jw ^l _{jk की} गणना- ^l और ^l-1 के मानों के माध्यम से की जाती है, जिसकी गणना विधि हम पहले से ही जानते हैं। इस समीकरण को कम लोड किए गए फॉर्म में फिर से लिखा जा सकता है:

$$

$$\frac{\partial C}{\partial w} = a_{\rm in} \delta_{\rm out} \tag{32}$$

जहां एक _में - वजन w के लिए तंत्रिका आदानों की सक्रियता, और डेल्टा _बाहर - वजन w के तंत्रिका उत्पादन त्रुटि। आप अधिक वजन डब्ल्यू और दो न्यूरॉन उन्हें से जुड़ा को देखें, तो फिर हम इस तरह से आकर्षित कर सकते हैं:



जब एक को सक्रिय समीकरण (32) इस बात का सुखद परिणाम _में छोटे, एक _में ≈ 0, ∂C / ∂w ढाल सदस्य भी जाता है शून्य करने के लिए। इस मामले में, हम कहते हैं कि वजन को धीरे-धीरे प्रशिक्षित किया जाता है, अर्थात ढाल के दौरान यह ज्यादा नहीं बदलता है। दूसरे शब्दों में, परिणामों में से एक (BP4) यह है कि कम सक्रियण वाले न्यूरॉन्स का भारित आउटपुट धीरे-धीरे सीखता है।

अन्य विचार (BP1) - (BP4) से लिए जा सकते हैं। चलिए आउटपुट लेयर से शुरू करते हैं। शब्द σ '(z ^L _j ) पर विचार करें) (बीपी 1) में। अंतिम अध्याय से सिग्मॉइड के ग्राफ को याद करें कि यह when (z ^L _j ) 0 या 1 के निकट आने पर सपाट हो जाता है । इन मामलों में, σ '(z ^L _j ) Therefore 0. इसलिए, सक्रिय होने पर अंतिम परत में भार को धीरे-धीरे प्रशिक्षित किया जाएगा। आउटपुट न्यूरॉन छोटा () 0) या बड़ा (। 1) है। इस मामले में, यह आमतौर पर कहा जाता है कि आउटपुट न्यूरॉन संतृप्त होता है, और इसके परिणामस्वरूप, वजन प्रशिक्षण के लिए बंद हो गया है (या धीरे-धीरे प्रशिक्षित किया जा रहा है)। आउटपुट न्यूरॉन के विस्थापन के लिए भी यही टिप्पणी मान्य है।

इसी तरह के विचार पहले की परतों के बारे में प्राप्त किए जा सकते हैं। विशेष रूप से, (BP2) में ( '(z ^l ) शब्द पर विचार करें । इसका मतलब है कि δ ^l _jसबसे अधिक संभावना छोटी होगी क्योंकि न्यूरॉन संतृप्ति के करीब पहुंचता है। यह, बारी में, साधन इनलेट संतृप्त न्यूरॉन पर किसी भी वजन धीरे-धीरे प्रशिक्षित किया जाएगा कि (लेकिन यह होगा काम नहीं करता है, तो डब्ल्यू ^{एल + 1 टी} δ ^{एल + 1} (जेड पर्याप्त रूप से बड़े तत्व हैं छोटे मूल्य σ के लिए क्षतिपूर्ति ' ^एल _j ))।

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

यह विशेष रूप से आश्चर्यजनक नहीं है। और फिर भी, ये अवलोकन हमारी समझ को बेहतर बनाने में मदद करते हैं कि जब हम नेटवर्क को प्रशिक्षित करते हैं तो क्या होता है। इसके अलावा, हम इन तर्कों को दूसरी तरफ से देख सकते हैं। चार मौलिक समीकरण किसी भी सक्रियण फ़ंक्शन के लिए मान्य हैं, और न केवल मानक सिग्मॉइड के लिए (क्योंकि, जैसा कि हम बाद में देखेंगे, गुण सिग्मॉइड का उपयोग नहीं करते हैं)। इसलिए, कुछ आवश्यक शिक्षण गुणों के साथ सक्रियण कार्यों को विकसित करने के लिए इन समीकरणों का उपयोग किया जा सकता है। उदाहरण के लिए, मान लें कि हम एक सक्रियण फ़ंक्शन का चयन करते हैं we जो एक सिग्मोइड से भिन्न होता है, जैसे कि is 'हमेशा सकारात्मक होता है और शून्य तक नहीं पहुंचता है। यह सीखने की मंदी को रोकता है जो तब होता है जब सामान्य सिग्माइड न्यूरॉन्स संतृप्त होते हैं। बाद में पुस्तक में हम उदाहरण देखेंगे कि सक्रियण फ़ंक्शन समान तरीके से बदलता है।समीकरणों (BP1) - (BP4) को देखते हुए, हम यह बता सकते हैं कि ऐसे संशोधनों की आवश्यकता क्यों है, और वे कैसे स्थिति को प्रभावित कर सकते हैं।


:

• . . , . , , . , (BP1) ,

$$

$$\delta^L = \Sigma'(z^L) \nabla_a C \tag{33}$$

जहाँ where '(z ^L ) 0. के बराबर स्थित विकर्ण और अन्य तत्वों के साथ स्थित σ' (z ^L _j ) के मानों के साथ एक वर्ग मैट्रिक्स है। यह मैट्रिक्स साधारण मैट्रिक्स गुणन के माध्यम से C C के साथ परस्पर क्रिया _करता है।

दिखाएँ कि (BP2) को फिर से लिखा जा सकता है

$$

$$\delta^l = \Sigma'(z^l) (w^{l+1})^T \delta^{l+1} \tag{34}$$

पिछले कार्यों को मिलाकर, यह दिखाएं:

$$

$$\delta^l = \Sigma'(z^l) (w^{l+1})^T \ldots \Sigma'(z^{L-1}) (w^L)^T \Sigma'(z^L) \nabla_a C \tag{35}$$

मैट्रिक्स गुणा के आदी पाठकों के लिए, यह समीकरण (BP1) और (BP2) की तुलना में समझना आसान होगा। मैं (BP1) और (BP2) पर ध्यान केंद्रित करता हूं क्योंकि यह दृष्टिकोण संख्यात्मक रूप से लागू करने के लिए तेज है। [यहाँ sum का योग (∑) नहीं है, लेकिन राजधानी) (सिग्मा) / लगभग है। ट्रांस। ]

चार मूलभूत समीकरणों का प्रमाण (वैकल्पिक अनुभाग)

अब हम चार मूलभूत समीकरणों (BP1) - (BP4) को साबित करते हैं। ये सभी कई चर के कार्यों के विश्लेषण से श्रृंखला नियम (एक जटिल कार्य के विभेदन का नियम) के परिणाम हैं। यदि आप श्रृंखला नियम से परिचित हैं, तो मैं पढ़ने के साथ जारी रखने से पहले अपने आप ही डेरिवेटिव की गणना करने की कोशिश कर रहा हूं।

के समीकरण (BP1) है, जो हमें उत्पादन त्रुटि डेल्टा के लिए एक अभिव्यक्ति देता है साथ शुरू करते हैं ^{एल की} । इसे साबित करने के लिए, हमें याद है कि, परिभाषा के अनुसार:

$$

$$\delta^L_j = \frac{\partial C}{\partial z^L_j} \tag{36}$$

चेन नियम को लागू करते हुए, हम आंशिक डेरिवेटिव को आउटपुट एक्टिविटी के आंशिक डेरिवेटिव के माध्यम से फिर से लिखते हैं:

$$

$$\delta^L_j = \sum_k \frac{\partial C}{\partial a^L_k} \frac{\partial a^L_k}{\partial z^L_j} \tag{37}$$

जहां आउटपुट आउटपुट परत में सभी न्यूरॉन्स k पर समन जाता है। बेशक, न्यूरॉन नं। _K का उत्पादन सक्रियण ^L _k केवल न्यूरॉन नंबर j के लिए भारित इनपुट z ^L _j पर निर्भर करता है जब = j। इसलिए, ,a ^L _k / Lz ^L _j गायब हो जाता है जब k। J। नतीजतन, हम पिछले समीकरण को सरल बनाते हैं

$$

$$\delta^L_j = \frac{\partial C}{\partial a^L_j} \frac{\partial a^L_j}{\partial z^L_j} \tag{38}$$

यह याद करते हुए कि एक ^L _j = σ (z ^L _j ), हम दाईं ओर on '(z ^L _j ) के रूप में दूसरा शब्द फिर से लिख सकते हैं , और समीकरण में बदल जाता है

$$

$$\delta^L_j = \frac{\partial C}{\partial a^L_j} \sigma'(z^L_j) \tag{39}$$

एक विस्फोट दृश्य में (बीपी 1) है।

फिर हम साबित करते हैं (बीपी 2), जो त्रुटि के लिए समीकरण देता है the ^एल अगली परत में त्रुटि के माध्यम से ^{1 एल + 1} । ऐसा करने के लिए, हमें = ^l _j = ∂C / ,z ^l _j को = ^{l + 1} _k = 1C / ∂z ^{l + 1} _{k के} माध्यम से फिर से लिखना होगा । यह श्रृंखला नियम का उपयोग करके किया जा सकता है:

$$

$$\delta^l_j = \frac{\partial C}{\partial z^l_j} \tag{40}$$

$$

$$= \sum_k \frac{\partial C}{\partial z^{l+1}_k} \frac{\partial z^{l+1}_k}{\partial z^l_j} \tag{41}$$

$$

$$= \sum_k \frac{\partial z^{l+1}_k}{\partial z^l_j} \delta^{l+1}_k \tag{42}$$

जहां अंतिम पंक्ति में हमने दाईं ओर दो शब्दों की अदला-बदली की, और ^{+ l + 1} _k की परिभाषा दी । अंतिम पंक्ति पर पहले शब्द की गणना करने के लिए, ध्यान दें

$$

$$z^{l+1}_k = \sum_j w^{l+1}_{kj} a^l_j +b^{l+1}_k = \sum_j w^{l+1}_{kj} \sigma(z^l_j) +b^{l+1}_k \tag{43}$$

भेद करना, हम प्राप्त करते हैं

$$

$$\frac{\partial z^{l+1}_k}{\partial z^l_j} = w^{l+1}_{kj} \sigma'(z^l_j). \tag{44}$$

इसे (42) में प्रतिस्थापित करते हुए, हम प्राप्त करते हैं

$$

$$\delta^l_j = \sum_k w^{l+1}_{kj} \delta^{l+1}_k \sigma'(z^l_j). \tag{45}$$

वह है, (BP2) विस्फोट में।

यह (BP3) और (BP4) साबित होता रहता है। वे श्रृंखला नियम से भी, लगभग उसी तरह से चलते हैं जैसे दो पिछले वाले। मैं उन्हें एक अभ्यास के रूप में आपके पास छोड़ दूँगा।

व्यायाम

• साबित (BP3) और (BP4)।

यह सभी चार मूलभूत बैकप्रॉपैजेशन समीकरणों का प्रमाण है। यह जटिल लग सकता है। लेकिन वास्तव में, यह केवल चेन नियम के सावधानीपूर्वक अनुप्रयोग का परिणाम है। कम संक्षिप्त रूप से बोलते हुए, कई प्रकारों के कार्यों के विश्लेषण से चेन शासन के व्यवस्थित अनुप्रयोग के माध्यम से लागत समारोह की ढाल की गणना के तरीके के रूप में वापस प्रसार की कल्पना की जा सकती है। और यह वास्तव में सभी कि वापस वितरण है - बाकी सिर्फ विवरण है।

बैकप्रॉपैगैशन एल्गोरिथ्म

Backpropagation समीकरण हमें लागत फ़ंक्शन की ढाल की गणना करने के लिए एक विधि प्रदान करते हैं। आइए इसे स्पष्ट रूप से एक एल्गोरिथ्म के रूप में लिखें:

1. इनपुट x: इनपुट लेयर के लिए उपयुक्त सक्रियण ¹ प्रदान करें।
2. : l = 2,3,…,L z ^l = w ^l a ^l−1 +b ^l a ^l = σ(z ^l ).
3. δ ^L : δ ^L = ∇ _a C ⊙ σ'(z ^L ).
4. : l = L−1,L−2,…,2 δ ^l = ((w ^l+1 ) ^T δ ^l+1 ) ⊙ σ'(z ^l ).
5. : $$$\frac{\partial C}{\partial w^l_{jk}} = a^{l-1}_k \delta^l_j$ और $$$\frac{\partial C}{\partial b^l_j} = \delta^l_j$ ।

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

अभ्यास

• . , , f(∑ _j w _j x _j +b), f – , . ?
• . , σ(z) = z . .

जैसा कि मैंने पहले बताया, बैकप्रॉपैगैशन एल्गोरिथ्म एक प्रशिक्षण उदाहरण, सी = सी _एक्स के लिए लागत फ़ंक्शन की ढाल की गणना करता है । व्यवहार में, पीठ के प्रसार को अक्सर एक सीखने के एल्गोरिथ्म के साथ जोड़ा जाता है, उदाहरण के लिए, स्टोचस्टिक ढाल वंश के साथ, जब हम कई प्रशिक्षण उदाहरणों के लिए ढाल की गणना करते हैं। विशेष रूप से, एम प्रशिक्षण उदाहरणों के दिए गए मिनी-पैकेज के लिए, निम्न एल्गोरिथ्म इस मिनी-पैकेज के आधार पर ढाल मूल लागू करता है:

1. प्रवेश: प्रशिक्षण उदाहरणों का एक सेट।
2. प्रत्येक प्रशिक्षण उदाहरण x के लिए, संबंधित इनपुट सक्रियण ^{x, 1 को} असाइन करें और निम्नलिखित चरण करें:
   
   • l=2,3,…,L z ^x,l = w ^l a ^x,l−1 +b ^l a ^x,l = σ(z ^x,l ).
   • δ ^x,L : δ ^x,L = ∇ _a C _x ⋅ σ'(z ^x,L ).
   • : l=L−1,L−2,…,2 δ ^x,l = ((w ^l+1 ) ^T δ ^x,l+1 ) ⋅ σ'(z ^x,l ).
3. : l=L,L−1,…,2 $$$w ^ l \ rightarrow w ^ l- \ frac {\ eta} {m} \ sum_x \ delta ^ {x, l} (a ^ {x, l-1}) ^ $$ , और नियम के अनुसार ऑफसेट $$$b ^ l \ rightarrow b ^ l- \ frac {\ eta} {m} \ sum_x \ delta ^ {x, l}$ ।

बेशक, अभ्यास में स्टोकेस्टिक ग्रेडिएंट वंश को लागू करने के लिए, आपको एक बाहरी चक्र की भी आवश्यकता होगी जो प्रशिक्षण के उदाहरणों के मिनी-पैकेट उत्पन्न करता है, और एक बाहरी चक्र जो प्रशिक्षण के कई युगों से गुजरता है। सादगी के लिए, मैंने उन्हें छोड़ दिया।

वितरण के लिए कोड

Backpropagation के अमूर्त पक्ष को समझने के बाद, हम अब पिछले अध्याय में उपयोग किए गए कोड को समझ सकते हैं जो backpropagation को लागू करता है। उस अध्याय से याद करें जो कोड को network_ के update_mini_batch और backprop तरीकों में समाहित किया गया था। इन विधियों के लिए कोड ऊपर वर्णित एल्गोरिथ्म का प्रत्यक्ष अनुवाद है। विशेष रूप से, update_mini_batch विधि अद्यतन नेटवर्क वेट और ऑफ़सेट को वर्तमान mini_batch प्रशिक्षण उदाहरणों के लिए ढाल की गणना करके:

class Network(object): ... def update_mini_batch(self, mini_batch, eta): """    ,          -. mini_batch –    (x, y),  eta –  .""" nabla_b = [np.zeros(b.shape) for b in self.biases] nabla_w = [np.zeros(w.shape) for w in self.weights] for x, y in mini_batch: delta_nabla_b, delta_nabla_w = self.backprop(x, y) nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)] nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)] self.weights = [w-(eta/len(mini_batch))*nw for w, nw in zip(self.weights, nabla_w)] self.biases = [b-(eta/len(mini_batch))*nb for b, nb in zip(self.biases, nabla_b)] 

अधिकांश काम लाइनों delta_nabla_b, delta_nabla_w = self.backprop (x, y) द्वारा किया जाता है, आंशिक डेरिवेटिव xC _x / ∂C ^l _j और xC _x / ∂w ^l _{jk की} गणना करने के लिए backprop विधि का उपयोग करता है। बैकप्रॉप विधि पिछले अनुभाग के एल्गोरिथ्म को लगभग दोहराती है। एक छोटा सा अंतर है - हम लेयर इंडेक्सिंग के लिए थोड़ा अलग दृष्टिकोण का उपयोग करते हैं। यह अजगर सुविधा, नकारात्मक सरणी अनुक्रमणिका का लाभ उठाने के लिए किया जाता है जो आपको तत्वों को अंत से पीछे की ओर गिनने की अनुमति देता है। l [-3] सरणी l के अंत से तीसरा तत्व होगा। बैकप्रॉप कोड नीचे दिया गया है, सिग्मॉइड की गणना के लिए उपयोग किए जाने वाले सहायक कार्यों के साथ, इसके व्युत्पन्न और लागत फ़ंक्शन के व्युत्पन्न हैं। उनके साथ, कोड पूरा और समझ में आता है। यदि कुछ स्पष्ट नहीं है, तो पहले पूर्ण सूची कोड विवरण देखें।

 class Network(object): ... def backprop(self, x, y): """  ``(nabla_b, nabla_w)``,      C_x. ``nabla_b``  ``nabla_w`` -    numpy,   ``self.biases`` and ``self.weights``.""" nabla_b = [np.zeros(b.shape) for b in self.biases] nabla_w = [np.zeros(w.shape) for w in self.weights] #   activation = x activations = [x] #      zs = [] #     z- for b, w in zip(self.biases, self.weights): z = np.dot(w, activation)+b zs.append(z) activation = sigmoid(z) activations.append(activation) #   delta = self.cost_derivative(activations[-1], y) * \ sigmoid_prime(zs[-1]) nabla_b[-1] = delta nabla_w[-1] = np.dot(delta, activations[-2].transpose()) """ l      ,      . l = 1    , l = 2 – ,   .    ,   python      .""" for l in xrange(2, self.num_layers): z = zs[-l] sp = sigmoid_prime(z) delta = np.dot(self.weights[-l+1].transpose(), delta) * sp nabla_b[-l] = delta nabla_w[-l] = np.dot(delta, activations[-l-1].transpose()) return (nabla_b, nabla_w) ... def cost_derivative(self, output_activations, y): """    ( C_x /  a)   .""" return (output_activations-y) def sigmoid(z): """.""" return 1.0/(1.0+np.exp(-z)) def sigmoid_prime(z): """ .""" return sigmoid(z)*(1-sigmoid(z)) 

कार्य

• मिनीपैक पर पूरी तरह से मैट्रिक्स-आधारित बैकप्रोपैजेशन दृष्टिकोण। स्टोकेस्टिक ग्रेडिएंट डिसेंट का हमारा कार्यान्वयन मिनी-पैकेज से प्रशिक्षण उदाहरणों की एक श्रृंखला का उपयोग करता है। बैकप्रॉपैगैशन एल्गोरिथ्म को बदला जा सकता है ताकि यह एक ही समय में मिनी-पैकेज के सभी प्रशिक्षण उदाहरणों के लिए ग्रेडिएंट्स की गणना करे। एकल वेक्टर x के साथ शुरू करने के बजाय, हम मैट्रिक्स X = [x ₁ x ₂ ... x _m ] से शुरू कर सकते हैं, जिसके स्तंभ मिनीपैक के वैक्टर हैं। प्रत्यक्ष वितरण वजन मैट्रिक्स के उत्पाद के माध्यम से है, विस्थापन के लिए एक उपयुक्त मैट्रिक्स के अलावा और सिगॉइड का व्यापक उपयोग। पीछे प्रचार उसी पैटर्न का अनुसरण करता है। Backpropagation एल्गोरिथ्म के लिए इस दृष्टिकोण के लिए छद्म कोड लिखें। Network.py संशोधित करें ताकि वह इस मैट्रिक्स दृष्टिकोण का उपयोग करे। इस दृष्टिकोण का लाभ रैखिक बीजगणित के लिए आधुनिक पुस्तकालयों के सभी लाभों का उपयोग होगा। नतीजतन, यह मिनी-पैकेट चक्र की तुलना में तेजी से चल सकता है (उदाहरण के लिए, मेरे कंप्यूटर पर एमएनआईएसटी के वर्गीकरण कार्यों पर कार्यक्रम लगभग 2 बार तेज होता है)। व्यवहार में, बैक डिस्ट्रीब्यूशन के लिए सभी गंभीर लाइब्रेरी ऐसे फुल-मैट्रिक्स दृष्टिकोण या इसके कुछ संस्करण का उपयोग करते हैं।

किस अर्थ में वापस एक तेजी से एल्गोरिथ्म प्रचार है?

किस अर्थ में वापस एक तेजी से एल्गोरिथ्म प्रचार है? इस प्रश्न का उत्तर देने के लिए, ढाल की गणना करने के लिए एक और दृष्टिकोण पर विचार करें। तंत्रिका नेटवर्क अनुसंधान के शुरुआती दिनों की कल्पना करें। शायद यह 1950 या 1960 का दशक है, और आप दुनिया के पहले व्यक्ति हैं जो प्रशिक्षण के लिए ढाल वंश का उपयोग करने के विचार के साथ आए थे! लेकिन इसके लिए काम करने के लिए, आपको लागत फ़ंक्शन के ग्रेडिएंट की गणना करने की आवश्यकता है। आप बीजगणित को याद करते हैं और यह देखने के लिए निर्णय लेते हैं कि क्या आप ढाल की गणना करने के लिए श्रृंखला नियम का उपयोग कर सकते हैं। थोड़ा खेलने के बाद, आप देखते हैं कि बीजगणित कठिन लगता है, और आप निराश हैं। आप एक अलग दृष्टिकोण खोजने की कोशिश कर रहे हैं। आप लागत को केवल भार C = C (w) के कार्य के रूप में मानने का निर्णय लेते हैं (हम विस्थापन पर थोड़ी देर में लौट आएंगे)। आप वजन ₁ , डब्ल्यू ₂ , ... की संख्या और वजन डब्ल्यू के लिए jC / forw _{जे की} गणना करना चाहते हैं। स्पष्ट तरीका सन्निकटन का उपयोग करना है

$$

$$\ frac {\ आंशिक C} {\ आंशिक w_ {j}} \ लगभग \ frac {C (w + \ epsilon e_j) -C (w)} {\ epsilon} \ tag {46}$$

जहाँ Where> 0 एक छोटी धनात्मक संख्या है, और e _j इकाई दिशा वेक्टर j है। दूसरे शब्दों में, हम लगभग ∂C / calculw _{j का} अनुमान लगा सकते हैं कि w _{j के} दो अलग-अलग मूल्यों के लिए लागत C की गणना करके, और फिर समीकरण (46) लागू करें। यही विचार हमें विस्थापन के संबंध में ∂C / respectb के आंशिक डेरिवेटिव की गणना करने की अनुमति देता है।

दृष्टिकोण आशाजनक लगता है। वैचारिक रूप से सरल, लागू करने में आसान, कोड की केवल कुछ पंक्तियों का उपयोग करता है। यह ढाल की गणना करने के लिए एक चेन नियम का उपयोग करने के विचार से बहुत अधिक आशाजनक लगता है!

दुर्भाग्य से, हालांकि यह दृष्टिकोण आशाजनक दिखता है, जब कोड में लागू किया जाता है, तो यह पता चलता है कि यह बहुत धीरे-धीरे काम करता है। यह समझने के लिए कि क्यों, कल्पना करें कि हमारे पास नेटवर्क में एक मिलियन वज़न है। फिर प्रत्येक भार w के लिए हमें /C / .w _{j की} गणना करने के लिए C (w + toe _j ) की गणना करने की आवश्यकता है। और इसका मतलब यह है कि ग्रेडिएंट की गणना करने के लिए, हमें लागत फ़ंक्शन को एक लाख बार गणना करने की आवश्यकता है, जिसके लिए नेटवर्क (प्रत्येक प्रशिक्षण उदाहरण के लिए) से एक लाख प्रत्यक्ष पास की आवश्यकता होगी। और हमें सी (डब्ल्यू) की गणना करने की भी आवश्यकता है, इसलिए हमें नेटवर्क से एक मिलियन और एक पास मिलता है।

बैकप्रोपेगेशन की चाल यह है कि यह हमें एक साथ सभी आंशिक डेरिवेटिव backC / directw _{जे की} गणना करने की अनुमति देता है, नेटवर्क के माध्यम से केवल एक प्रत्यक्ष पास का उपयोग करता है, उसके बाद एक रिवर्स पास। मोटे तौर पर, वापसी पास की कम्प्यूटेशनल लागत लगभग उसी के समान है जो प्रत्यक्ष है।

इसलिए, पीठ प्रसार की कुल लागत लगभग वैसी ही है जैसी दो प्रत्यक्ष नेटवर्क से गुजरती है। विधि (46) को लागू करने के लिए आवश्यक मिलियन और एक प्रत्यक्ष पास के साथ इसकी तुलना करें! इसलिए, हालांकि बैकप्रोपैजेशन एक अधिक जटिल दृष्टिकोण की तरह दिखता है, वास्तव में यह बहुत तेज है।

पहली बार 1986 में इस त्वरण को पूरी तरह से सराहा गया था, और इसने नाटकीय रूप से तंत्रिका नेटवर्क की मदद से हल किए गए कार्यों की सीमा का विस्तार किया। बदले में, इससे तंत्रिका नेटवर्क का उपयोग करने वाले लोगों की संख्या में वृद्धि हुई है। बेशक, बैकप्रोपेगेंशन रामबाण नहीं है। 1980 के दशक के उत्तरार्ध में भी, लोगों को पहले से ही इसकी सीमाओं का सामना करना पड़ा था, खासकर जब गहरे तंत्रिका नेटवर्क, यानी कई छिपी परतों वाले नेटवर्क को प्रशिक्षित करने के लिए वापस प्रचार का उपयोग करने की कोशिश कर रहा था। बाद में हम देखेंगे कि आधुनिक कंप्यूटर और नए ट्रिकी विचार कैसे इस तरह के गहरे तंत्रिका नेटवर्क को प्रशिक्षित करने के लिए बैकप्रोपैजेशन का उपयोग करना संभव बनाते हैं।

रिवर्स वितरण: सामान्य तौर पर

जैसा कि मैंने पहले ही समझाया है, वापस प्रचार से हमें दो रहस्यों का पता चलता है। एल्गोरिथम वास्तव में क्या करता है? हमने आउटपुट से त्रुटि के लिए एक बैक प्रचार योजना विकसित की है। क्या अधिक गहराई तक जाना संभव है, वैक्टर और मैट्रिस के इन सभी गुणाओं के दौरान क्या होता है, इसका अधिक सहज ज्ञान प्राप्त करें। दूसरी पहेली यह है कि किसी ने भी कैसे वापस प्रचार का पता लगाया? एल्गोरिथ्म के चरणों या इसके संचालन के प्रमाण का पालन करना एक बात है। लेकिन इसका मतलब यह नहीं है कि आप समस्या को इतनी अच्छी तरह से समझ गए हैं कि आप इस एल्गोरिथ्म का आविष्कार कर सकते हैं। क्या तर्क की एक उचित रेखा है जो हमें बैकप्रॉपैगमेंट एल्गोरिथ्म की खोज के लिए प्रेरित कर सकती है? इस खंड में, मैं दोनों पहेलियों को शामिल करूंगा।

एल्गोरिथ्म के संचालन की समझ में सुधार करने के लिए, कल्पना करें कि हमने एक छोटा सा बदलाव किया है jw ^l _{jk of} a निश्चित वजन w ^l _jk :



वजन में इस बदलाव से संबंधित न्यूरॉन के आउटपुट सक्रियण में बदलाव होगा:



यह अगली परत की सभी गतिविधियों में बदलाव लाएगा:



इन परिवर्तनों से अगली परत में परिवर्तन होंगे, और इसी तरह, अंतिम तक, और फिर लागत फ़ंक्शन में परिवर्तन होंगे:



ChangeC में परिवर्तन समीकरण _{द्वारा} jw ^l _jk में परिवर्तन से संबंधित है

$$

$$\ Delta C \ लगभग \ frac {\ आंशिक C} {\ आंशिक w ^ l_ {jk}} \ Delta w ^ l_ {jk} \ tag {47}$$

यह निम्नानुसार है कि ∂C / jw ^l _{jk की} गणना करने के लिए एक संभावित दृष्टिकोण एक छोटे से परिवर्तन w ^l _jk के प्रसार की सावधानीपूर्वक निगरानी करना है, सी। में एक छोटे से बदलाव के लिए अग्रणी है। यदि हम ऐसा कर सकते हैं, तो ध्यान से सब कुछ मात्रा में जिस तरह से गणना करना आसान है, उसे व्यक्त करना। , तब हम /C / wew ^l _{jk की} गणना कर सकते हैं।

चलो इसे आजमाएँ। Changew ^l _jk में बदलाव से परत l में न्यूरॉन j के सक्रियण में ja ^l _j में थोड़ा बदलाव होता है। यह परिवर्तन सेट है।

$$

$$\ Delta a ^ l_j \ लगभग \ frac {\ आंशिक a_ l_j} {\ आंशिक w ^ l_ {jk}} \ Delta w ^ l_ {jk} \ tag {48}$$

सक्रियण ja ^l _j में परिवर्तन से अगली परत की सभी सक्रियता में परिवर्तन होता है, (l + 1)। हम इनमें से केवल एक परिवर्तित गतिविधि पर ध्यान केंद्रित करेंगे, उदाहरण के लिए, एक ^{l + 1} _q ,



इसके परिणामस्वरूप निम्नलिखित परिवर्तन होंगे:

$$

$$\ Delta a ^ {l + 1} _q \ लगभग \ frac {\ आंशिक a {{l + 1} _q} {\ आंशिक a ^ l_j} \ Delta a ^ l_j \ tag {49}$$

स्थानापन्न समीकरण (48), हम प्राप्त करते हैं:

$$

$$\ Delta a ^ {l + 1} _q \ लगभग \ frac {\ आंशिक a {{+ + 1} _q} {\ आंशिक a ^ l_j} \ frac {\ आंशिक a ^ l_j} {\ आंशिक w = l_ { jk}} \ Delta w ^ l_ {jk} \ tag {50}$$

बेशक, ⁺ a ^{l + 1} _{q में} परिवर्तन भी अगली परत में सक्रियण को बदल देगा। हम w ^l _jk से C तक पूरे नेटवर्क के साथ एक पथ की कल्पना भी कर सकते हैं, जहां सक्रियण में प्रत्येक परिवर्तन अगले सक्रियण में परिवर्तन की ओर जाता है, और अंत में, आउटपुट पर लागत में परिवर्तन के लिए। यदि पथ सक्रियण ^{l l} _j , a ^{l + 1} _q , ..., ^{L - 1} _n , ^L _m से होकर जाता है, तो अंतिम अभिव्यक्ति होगी

$$

$$\ Delta C \ लगभग \ frac {\ आंशिक C} {\ आंशिक a_ L_m} \ frac {\ आंशिक a ^ L_m} {\ आंशिक a ^ {L-1} _n} \ frac {\ आंशिक \ _ \ _} -1} _n} {\ आंशिक a ^ {L-2} _p} \ ldots \ frac {\ आंशिक a ^ {l + 1} _q} {\ आंशिक a ^ l_j} \ frac {\ आंशिक a ^ lj} { \ आंशिक w ^ l_ {jk}} \ Delta w ^ l_ {jk} \ टैग {51}$$

यही है, हम अगले पास के प्रत्येक न्यूरॉन के लिए फार्म ∂a / eacha का एक सदस्य चुनते हैं, साथ ही अंत में /C / La ^L _m शब्द के लिए। यह नेटवर्क के माध्यम से इस विशेष पथ पर सक्रियण में परिवर्तन के कारण सी में परिवर्तनों का एक प्रतिनिधित्व है। बेशक, ऐसे कई तरीके हैं, जिसमें w ^l _jk में परिवर्तन से गुजरना और लागत को प्रभावित कर सकता है, और हमने उनमें से केवल एक पर विचार किया। सी में कुल परिवर्तन की गणना करने के लिए, यह मान लेना उचित है कि हमें वजन से लेकर अंतिम लागत तक सभी संभावित रास्तों को संक्षेप में प्रस्तुत करना चाहिए:

$$

$$\ Delta C \ लगभग \ sum_ {mnp \ ldots q} \ frac {\ आंशिक C} {\ आंशिक a ^ L_m} \ frac {\ आंशिक a ^ L_m} {\ आंशिक a ^ {L-1} _n} \ C frac {\ आंशिक a ^ {L-1} _n} {\ आंशिक a {{L-2} _p} \ ldots \ frac {\ आंशिक a ^ {l + 1} _q} {\ आंशिक a ^ l_j_ \ frac {<आंशिक a ^ l_j} {\ आंशिक w ^ l_ {jk}} \ Delta w ^ l_ {jk} \ टैग {52}$$

जहां हमने रास्ते में मध्यवर्ती न्यूरॉन्स के लिए सभी संभावित विकल्पों को अभिव्यक्त किया। इसकी तुलना (47) के साथ, हम देखते हैं कि:

$$

$$\ frac {\ आंशिक C} {\ आंशिक w ^ l_ {jk}} = \ sum_ {mnp \ ldots q} \ frac {\ आंशिक C} {\ आंशिक a ^ L_m} \ frac {आंशिक \ _ ^__} {एक आंशिक ^ एक {{L-1} _n} \ frac {\ आंशिक एक {{L-1} _n} {\ आंशिक a ^ {L-2} _p} \ ldots \ frac {\ आंशिक a ^ {l + 1} _q} {\ आंशिक a ^ l_j} \ frac {\ आंशिक a l_j} {\ आंशिक w ^ l_ {jk}}। {टैग {५३}$$

समीकरण (53) जटिल दिखता है। हालाँकि, इसकी एक अच्छी सहज व्याख्या है। हम नेटवर्क भार के संबंध में C में परिवर्तन की गणना करते हैं। यह हमें बताता है कि नेटवर्क के दो न्यूरॉन्स के बीच प्रत्येक किनारे एक अनुपात कारक के साथ जुड़ा हुआ है, जो कि एक न्यूरॉन के सक्रियण का एक आंशिक व्युत्पन्न है जो किसी अन्य न्यूरॉन की सक्रियता के संबंध में है। पहले वजन से पहले न्यूरॉन तक एक पसली के लिए, अनुपात कारक /a ^l _j / lw ^l _{jk है} । पथ के लिए गुणांक केवल पथ के साथ गुणांक का उत्पाद है। और परिवर्तन का कुल गुणांक /C / jw ^l _jk प्रारंभिक भार से अंतिम लागत तक सभी तरह से गुणांक का योग है। यह प्रक्रिया नीचे एक पथ के लिए दिखाई गई है:



अब तक, हम एक अनुमानवादी तर्क दे रहे हैं, यह दर्शाने का एक तरीका है कि जब नेटवर्क वज़न बदलता है तो क्या होता है। मुझे इस तर्क के विकास के लिए इस विषय पर सोचने का एक और तरीका बताना चाहिए। सबसे पहले, हम समीकरण (53) में सभी व्यक्तिगत आंशिक डेरिवेटिव के लिए सटीक अभिव्यक्ति प्राप्त कर सकते हैं। यह सरल बीजगणित का उपयोग करना आसान है। उसके बाद, आप यह समझने की कोशिश कर सकते हैं कि मैट्रिक्स उत्पादों के रूप में सूचकांकों द्वारा सभी रकमों को कैसे लिखना है। यह एक थकाऊ काम है जो धैर्य की आवश्यकता है, लेकिन कुछ असाधारण नहीं है। यह सब और अधिकतम सरलीकरण के बाद, आप देखेंगे कि ठीक उसी बैकप्रॉपैगैशन एल्गोरिथ्म को प्राप्त किया गया है! इसलिए, सभी रास्तों के लिए गुणांक के योग की गणना करने के तरीके के रूप में बैकप्रॉपैगमेंट एल्गोरिथ्म की कल्पना की जा सकती है। या, इसे सुधारने के लिए, बैकप्रॉपैगैशन एल्गोरिथ्म एक मुश्किल तरीका है, जब वे नेटवर्क (नेटवर्क) के माध्यम से प्रचार करते हैं, आउटपुट तक पहुंचते हैं, और लागत को प्रभावित करते हैं।

यहां मैं यह सब नहीं करूंगा। यह व्यवसाय विवरणों के सावधानीपूर्वक अध्ययन की आवश्यकता के कारण अनाकर्षक है। यदि आप इसके लिए तैयार हैं, तो आप ऐसा करना पसंद कर सकते हैं। यदि नहीं, तो मुझे आशा है कि इस तरह के विचार आपको बैकप्रॉपैजेशन के लक्ष्यों के बारे में कुछ विचार देंगे।

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

हालांकि, इस प्रक्रिया में एक चतुर चाल है। समीकरण (53) में, मध्यवर्ती चर एक ^{l + 1} _q प्रकार की सक्रियण हैं। इंटरमीडिएट चर के रूप में z ^{l + 1} _q जैसे भारित इनपुट का उपयोग करने के लिए चाल है। यदि आप इसका उपयोग नहीं करते हैं और सक्रियण का उपयोग करना जारी रखते हैं, तो प्राप्त साक्ष्य इस अध्याय में दिए गए पहले की तुलना में थोड़ा अधिक जटिल होंगे।