computer science - तंत्रिका नेटवर्क बैकप्रोपैगेशन को समझना




computer-science machine-learning (2)

अद्यतन: इस मुद्दे का एक बेहतर फॉर्मूलेशन।

मैं एक उदाहरण के रूप में एक एक्सओआर तंत्रिका नेटवर्क के साथ बैकप्रोपैगेशन एल्गोरिदम को समझने की कोशिश कर रहा हूं। इस मामले के लिए छिपी परत + 1 पूर्वाग्रह, और 1 आउटपुट न्यूरॉन में 2 इनपुट न्यूरॉन्स + 1 पूर्वाग्रह, 2 न्यूरॉन्स हैं।

 A   B  A XOR B
 1    1   -1
 1   -1    1
-1    1    1
-1   -1   -1

मैं स्टोकास्टिक बैकप्रोपैगेशन का उपयोग कर रहा हूं।

थोड़ा और पढ़ने के बाद मुझे पता चला है कि आउटपुट इकाई की त्रुटि छिपी परतों के लिए प्रचारित है ... शुरुआत में यह भ्रमित था, क्योंकि जब आप तंत्रिका नेटवर्क की इनपुट परत तक पहुंच जाते हैं, तो प्रत्येक न्यूरॉन को त्रुटि समायोजन मिलता है छिपी हुई परत में दोनों न्यूरॉन्स से। विशेष रूप से, त्रुटि वितरित करने के तरीके को पहले समझना मुश्किल होता है।

चरण 1 इनपुट के प्रत्येक उदाहरण के लिए आउटपुट की गणना करें।
चरण 2 आउटपुट न्यूरॉन (हमारे मामले में केवल एक ही है) और लक्ष्य मान (ओं) के बीच की त्रुटि की गणना करता है:
चरण 2 http://pandamatak.com/people/anand/771/html/img342.gif
चरण 3 हम प्रत्येक छिपी इकाई एच के लिए त्रुटि की गणना करने के लिए चरण 2 से त्रुटि का उपयोग करते हैं:
चरण 3 http://pandamatak.com/people/anand/771/html/img343.gif

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

क्या मैं सब कुछ ठीक से समझ रहा हूँ? क्या कोई इसकी पुष्टि कर सकता है?

इनपुट परत के ओ (एच) क्या है? मेरी समझ यह है कि प्रत्येक इनपुट नोड में दो आउटपुट होते हैं: वह जो छुपा परत के पहले नोड में जाता है और वह दूसरा जो नोड छिपी हुई परत में जाता है। फॉर्मूला के O(h)*(1 - O(h)) भाग में से कौन सा आउटपुट प्लग किया जाना चाहिए?
चरण 3 http://pandamatak.com/people/anand/771/html/img343.gif


आपके द्वारा यहां पोस्ट किया गया ट्यूटोरियल वास्तव में गलत कर रहा है। मैंने बिशप की दो मानक किताबों और मेरे दो कामकाजी कार्यान्वयन के खिलाफ इसे दोहराया। मैं बिल्कुल नीचे बताऊंगा।

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

यदि आप बैकप्रोपैगेशन को समझना चाहते हैं, तो आपको चेन नियम को समझना होगा। यह श्रृंखला श्रृंखला के बारे में सब कुछ है। यदि आपको नहीं पता कि यह वास्तव में कैसे काम करता है, विकिपीडिया पर जांचें - यह मुश्किल नहीं है। लेकिन जैसे ही आप व्युत्पत्ति को समझते हैं, सब कुछ जगह में पड़ता है। पक्का वादा! :)

∂E / ∂W श्रृंखला नियम के माध्यम से ∂E / ∂o ∂o / ∂W में बनाया जा सकता है। ∂o / ∂W आसानी से गणना की जाती है, क्योंकि यह वजन के संबंध में एक इकाई के सक्रियण / आउटपुट का व्युत्पन्न है। ∂E / ∂o वास्तव में हम डेल्टा कहते हैं। (मुझे लगता है कि ई, ओ और डब्ल्यू वैक्टर / मैट्रिस हैं)

हमारे पास आउटपुट इकाइयों के लिए है, क्योंकि वह वह जगह है जहां हम त्रुटि की गणना कर सकते हैं। (अधिकांशतः हमारे पास एक त्रुटि फ़ंक्शन होता है जो (t_k - o_k) के डेल्टा पर आता है, उदाहरण के लिए रसद आउटपुट के मामले में रैखिक आउटपुट और क्रॉस एन्ट्रॉपी के मामले में श्रेणीबद्ध त्रुटि फ़ंक्शन के लिए।)

सवाल यह है कि, हम आंतरिक इकाइयों के लिए डेरिवेटिव कैसे प्राप्त करते हैं? खैर, हम जानते हैं कि एक इकाई का उत्पादन उनके वजन से भारित सभी आने वाली इकाइयों और बाद में स्थानांतरण समारोह के आवेदन का योग है। तो o_k = f (sum (w_kj * o_j, सभी जे के लिए))।

तो हम क्या करते हैं, o_j के संबंध में o_k प्राप्त करें। चूंकि delta_j = ∂E / ∂o_j = ∂E / ∂o_k ∂o_k / ∂o_j = delta_k ∂o_k / o_j। तो delta_k दिया, हम delta_j की गणना कर सकते हैं!

आओ इसे करें। o_k = f (sum (w_kj * o_j, सभी जे के लिए)) => ∂o_k / ∂o_j = f '(sum (w_kj * o_j, सभी जे के लिए)) * w_kj = f' (z_k) * w_kj।

सिग्मोडायड ट्रांसफर फ़ंक्शन के मामले में, यह z_k (1 - z_k) * w_kj बन जाता है। ( यहां ट्यूटोरियल में त्रुटि है, लेखक कहते हैं o_k (1 - o_k) * w_kj! )


चरण 3 के समीकरण से मैंने जो पढ़ा है वह है:

  1. O_h = इस छिपी हुई इकाई का अंतिम आउटपुट (इनपुट परत पर O_h वास्तविक इनपुट मान है)
  2. w_kh = इस छिपी इकाई के बीच कनेक्शन का भार और अगली परत की एक इकाई (आउटपुट की ओर)
  3. delta_k = अगली परत की इकाई की त्रुटि (आउटपुट की ओर, पिछले बुलेट के समान इकाई)

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

आउटपुट पक्ष से शुरू होने पर त्रुटि को लेयर द्वारा परत की गणना करने की आवश्यकता होती है, क्योंकि परत परत की गणना करने के लिए हमें परत एन + 1 के त्रुटि मानों की आवश्यकता होती है। आप सही हैं, बैकप्रोपैगेशन में इनपुट और आउटपुट के बीच कोई सीधा संबंध नहीं है।

मेरा मानना ​​है कि समीकरण सही है, अगर counterintuitive। शायद भ्रमित करने वाला यह है कि प्रत्येक इकाई के लिए आगे के प्रचार में हमें यूनिट (इनपुट मान) के बाईं ओर सभी इकाइयों और लिंक पर विचार करना होगा, लेकिन त्रुटि प्रसार (बैकप्रोपैगेशन) के लिए इकाइयों को दाएं (आउटपुट) पर विचार करना होगा मूल्य) इकाई की संसाधित की जा रही है।