तंत्रिका नेटवर्क और गहन शिक्षा, अध्याय 1: हस्तलिखित संख्याओं को पहचानने के लिए तंत्रिका नेटवर्क का उपयोग करना

टिप्पणी

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

जो लोग पुस्तक के लेखक को धन्यवाद देना चाहते हैं, वे अपने आधिकारिक पेज पर पेपाल या बिटकॉइन के माध्यम से स्थानांतरण कर सकते हैं। Habré पर अनुवादक का समर्थन करने के लिए "लेखक का समर्थन करने के लिए" एक रूप है।

परिचय

यह ट्यूटोरियल आपको अवधारणाओं के बारे में विस्तार से बताएगा जैसे:

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

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

यह किताब किस बारे में है

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

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

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

सिद्धांत आधारित दृष्टिकोण

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

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

व्यावहारिक दृष्टिकोण

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

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

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

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

व्यायाम और कार्य

तकनीकी पुस्तकों के लेखक अक्सर पाठक को चेतावनी देते हैं कि उसे बस सभी अभ्यासों को पूरा करने और सभी समस्याओं को हल करने की आवश्यकता है। मेरे लिए ऐसी चेतावनियाँ पढ़ते समय, वे हमेशा थोड़ा अजीब लगते हैं। अगर मैं व्यायाम नहीं करता और समस्याओं को हल करता तो क्या मेरे साथ कुछ बुरा होता? नहीं, बिल्कुल। मैं कम गहरी समझ से समय बचाऊंगा। कभी-कभी इसके लायक है। कभी-कभी नहीं।

इस पुस्तक के साथ क्या करने योग्य है? मैं आपको सलाह देता हूं कि अधिकांश अभ्यासों को पूरा करने का प्रयास करें, लेकिन अधिकांश कार्यों को हल करने का प्रयास न करें।

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

कार्य एक और मामला है। वे अभ्यास से अधिक कठिन हैं, और कुछ के साथ आपके पास कठिन समय होगा। यह कष्टप्रद है, लेकिन निश्चित रूप से इस तरह की निराशा का सामना करना ही सही मायने में इस विषय को समझने और अवशोषित करने का एकमात्र तरीका है।

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

बेशक, जबकि आपके पास ऐसी परियोजना नहीं हो सकती है। यह सामान्य है। उन कार्यों को हल करें जिनके लिए आप आंतरिक प्रेरणा महसूस करते हैं। व्यक्तिगत रचनात्मक परियोजनाओं के लिए विचारों को खोजने में मदद करने के लिए पुस्तक की सामग्री का उपयोग करें।

अध्याय 1

मानव दृश्य प्रणाली दुनिया के आश्चर्यों में से एक है। हस्तलिखित संख्याओं के निम्नलिखित अनुक्रम पर विचार करें:



ज्यादातर लोग उन्हें आसानी से पढ़ लेंगे, जैसे 504192. लेकिन यह सरलता धोखा है। मस्तिष्क के प्रत्येक गोलार्ध में, एक व्यक्ति के पास एक प्राथमिक दृश्य प्रांतस्था होती है , जिसे V1 के रूप में भी जाना जाता है, जिसमें 140 मिलियन न्यूरॉन्स और दसियों अरबों के बीच कनेक्शन होते हैं। इसी समय, न केवल वी 1 मानव दृष्टि में शामिल है, बल्कि मस्तिष्क क्षेत्रों के एक पूरे अनुक्रम - वी 2, वी 3, वी 4 और वी 5 - जो तेजी से जटिल छवि प्रसंस्करण में लगे हुए हैं। हम अपने सिर को सैकड़ों लाखों वर्षों से विकास के द्वारा बनाए गए सुपर कंप्यूटर में ले जाते हैं, और दृश्यमान दुनिया को समझने के लिए पूरी तरह से अनुकूलित होते हैं। हस्तलिखित संख्याओं को पहचानना इतना आसान नहीं है। यह सिर्फ इतना है कि हम लोग, आश्चर्यजनक रूप से, आश्चर्यजनक रूप से अच्छी तरह से पहचानते हैं कि हमारी आँखें हमें क्या दिखाती हैं लेकिन इस काम के लगभग सभी अनजाने में किया जाता है। और आमतौर पर हम इस बात को महत्व नहीं देते हैं कि हमारे विज़ुअल सिस्टम में क्या मुश्किल काम है।

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

समस्या को अलग तरीके से हल करने के लिए NS दृष्टिकोण। शिक्षण उदाहरणों के रूप में ज्ञात कई हस्तलिखित संख्याओं को लेना है,



और इन उदाहरणों से सीख सकने वाली प्रणाली विकसित करें। दूसरे शब्दों में, नेशनल असेंबली स्वचालित रूप से हस्तलिखित अंक मान्यता नियमों के निर्माण के लिए उदाहरणों का उपयोग करती है। इसके अलावा, प्रशिक्षण के उदाहरणों की संख्या में वृद्धि करके, नेटवर्क हस्तलिखित संख्याओं के बारे में अधिक जान सकता है और इसकी सटीकता में सुधार कर सकता है। इसलिए, हालांकि मैंने सिर्फ 100 केस स्टडीज का हवाला दिया है, शायद हम हजारों या लाखों और अरबों केस स्टडी का उपयोग करके एक बेहतर लिखावट मान्यता प्रणाली बना सकते हैं।

इस अध्याय में हम एक कंप्यूटर प्रोग्राम लिखेंगे जो हस्तलिखित संख्याओं को पहचानने के लिए NS लर्निंग को लागू करता है। कार्यक्रम केवल 74 लाइनों लंबा होगा, और नेशनल असेंबली के लिए विशेष पुस्तकालयों का उपयोग नहीं करेगा। हालांकि, यह छोटा कार्यक्रम मानव हस्तक्षेप की आवश्यकता के बिना 96% से अधिक की सटीकता के साथ हस्तलिखित संख्याओं को पहचानने में सक्षम होगा। इसके अलावा, भविष्य के अध्यायों में हम ऐसे विचारों का विकास करेंगे जो 99% या उससे अधिक सटीकता में सुधार कर सकते हैं। वास्तव में, सबसे अच्छा वाणिज्यिक एनएस इतना अच्छा काम करते हैं कि वे बैंकों द्वारा चेक की प्रक्रिया के लिए उपयोग किए जाते हैं, और पते पहचानने के लिए डाक सेवा।

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

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

perceptrons

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

तो अवधारणात्मक कैसे काम करते हैं? परसेप्ट्रॉन कई बाइनरी नंबर x ₁ , x ₂ , ... प्राप्त करता है और एक बाइनरी नंबर देता है:



इस उदाहरण में, परसेप्ट्रॉन में तीन इनपुट नंबर हैं, x ₁ , x ₂ , x ₃ । सामान्य तौर पर, उनमें से कम या ज्यादा हो सकते हैं। रोसेनब्लट ने परिणाम की गणना के लिए एक सरल नियम प्रस्तावित किया। उन्होंने परिणाम के लिए संबंधित इनपुट संख्याओं के महत्व को व्यक्त करते हुए वजन, डब्ल्यू ₁ , डब्ल्यू ₂ , वास्तविक संख्याओं को पेश किया। एक न्यूरॉन, 0 या 1 का आउटपुट, यह निर्धारित करता है कि क्या भारित राशि एक निश्चित सीमा से कम या अधिक है [सीमा] $$$\ sum_j w_jx_j$ । भार की तरह, दहलीज एक वास्तविक संख्या है, एक न्यूरॉन का एक पैरामीटर है। गणितीय शब्दों में:

$$

$$आउटपुट = \ शुरू {मामलों} 0 ~ अगर ~ \ sum_j w_jx_j \ leq थ्रेशोल्ड \\ 1 ~ अगर ~ \ sum_j w_jx_j> थ्रेशोल्ड \ अंत {केस} \ टैग {1}$$

यह बोधगम्य का पूरा विवरण है!

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

1. क्या मौसम अच्छा है?
2. क्या आपका साथी आपके साथ जाना चाहता है?
3. क्या त्योहार सार्वजनिक परिवहन से दूर है? (आपके पास कार नहीं है)

इन तीन कारकों को द्विआधारी चर x ₁ , x ₂ , x _{3 के} रूप में दर्शाया जा सकता है। उदाहरण के लिए, x ₁ = 1 यदि मौसम अच्छा है, और 0 यदि यह खराब है। x ₂ = 1 यदि आपका साथी जाना चाहता है, और 0 नहीं तो। एक्स _{3 के लिए भी} ।

अब, मान लीजिए कि आप पनीर के इतने अधिक प्रशंसक हैं कि आप त्योहार पर जाने के लिए तैयार हैं, भले ही आपके साथी को इसमें दिलचस्पी न हो और इसे प्राप्त करना मुश्किल हो। लेकिन शायद आप सिर्फ खराब मौसम से नफरत करते हैं, और खराब मौसम के मामले में आप उत्सव में नहीं जाते हैं। इस तरह की निर्णय लेने की प्रक्रिया को मॉडल बनाने के लिए आप पेरीसेप्ट्रॉन का उपयोग कर सकते हैं। एक तरीका यह है कि मौसम के लिए वेट ₁ = 6 और दूसरी स्थितियों के लिए w ₂ = 2, w ₃ = 2 का चयन करें। डब्ल्यू ₁ का एक बड़ा मूल्य का मतलब है कि मौसम आपके लिए ज्यादा मायने रखता है कि क्या आपका साथी आपसे जुड़ जाएगा या त्योहार की निकटता को रोक देगा। अंत में, मान लें कि आप परसेप्ट्रोन के लिए थ्रेशोल्ड 5 का चयन करते हैं। इन विकल्पों के साथ, पेसेप्ट्रोन वांछित निर्णय मॉडल को लागू करता है, 1 देता है जब मौसम अच्छा होता है और 0 खराब होने पर। साथी की इच्छा और स्टॉप की निकटता आउटपुट मूल्य को प्रभावित नहीं करती है।

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

जाहिर है, परसेप्ट्रॉन पूर्ण मानव निर्णय लेने वाला मॉडल नहीं है! लेकिन यह उदाहरण दिखाता है कि निर्णय लेने के लिए एक अवधारणात्मक विभिन्न प्रकार के सबूतों का वजन कैसे कर सकता है। ऐसा लगता है कि पेसेप्ट्रॉन का एक जटिल नेटवर्क बहुत जटिल निर्णय ले सकता है:



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

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

चलो अवधारणात्मक लोगों के विवरण को सरल करते हैं। शर्त$$$\sum_j w_jx_j > treshold$ अजीब है, और हम इसे सरल बनाने के लिए रिकॉर्ड में दो बदलावों पर सहमत हो सकते हैं। पहला रिकॉर्ड है$$$\sum_j w_jx_j$स्केलर उत्पाद के रूप में ∑ जे डब्ल्यू जे एक्स जे ,$$$w \cdot x = \sum_j w_jx_j$ , जहां डब्ल्यू और एक्स - एक वेक्टर जिसका घटकों वजन और इनपुट डेटा क्रमश: कर रहे हैं। दूसरा दहलीज को असमानता के दूसरे हिस्से में स्थानांतरित करना है, और इसे एक मूल्य के साथ परसेप्ट्रान विस्थापन [पूर्वाग्रह] के रूप में जाना जाता है,$$$b \equiv −threshold$ । एक सीमा के बजाय विस्थापन का उपयोग करते हुए, हम अवधारणात्मक नियम को फिर से लिख सकते हैं:

$$

$$output = \begin{cases} 0 ~ if ~ w \cdot x + b \leq 0 \\ 1 ~ if ~ w \cdot x + b > 0 \end{cases} \tag{2}$$

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

मैंने निर्णय लेने के लिए साक्ष्य तौलने की विधि के संदर्भ में अवधारणात्मक का वर्णन किया। उनके उपयोग का एक अन्य तरीका प्राथमिक तार्किक कार्यों की गणना है, जिसे हम आमतौर पर मुख्य गणनाओं जैसे कि, या, और नंद के रूप में मानते हैं। उदाहरण के लिए, मान लें कि हमारे पास दो इनपुट के साथ एक अवधारणात्मक है, जिसमें से प्रत्येक का वजन -2 है, और इसकी भरपाई 3. है: यह है:



इनपुट 00 आउटपुट 1 देता है, क्योंकि ()2) + 0 + (- 2 )। 0 + 3 = 3 शून्य से अधिक है। उसी गणना में कहा गया है कि इनपुट 01 और 10 देता है। लेकिन इनपुट पर 11 आउटपुट पर 0 देता है, क्योंकि (−2) 2 1 + (- 2) + 1 + 3 = ,1, शून्य से कम। इसलिए, हमारे अवधारणात्मक एनएंड फ़ंक्शन को लागू करता है!

यह उदाहरण दिखाता है कि बुनियादी तर्क कार्यों की गणना करने के लिए पेरेसेट्रॉन का उपयोग किया जा सकता है। वास्तव में, हम सामान्य रूप से किसी भी तार्किक कार्यों की गणना करने के लिए पेरेसेट्रॉन नेटवर्क का उपयोग कर सकते हैं। तथ्य यह है कि नंद तर्क द्वार गणना के लिए सार्वभौमिक है - इसके आधार पर किसी भी गणना का निर्माण संभव है। उदाहरण के लिए, आप दो बिट्स, x ₁ और x _{2 को} जोड़ने वाले सर्किट बनाने के लिए NAND गेट्स का उपयोग कर सकते हैं । ऐसा करने के लिए, बिटवाइज़ राशि की गणना करें$$$x_1 \oplus x_2$ औरकैरी झंडाहै, जो 1 के बराबर होती है जब दोनों एक्स₁और एक्स₂- 1 के बराबर है यह है कि, कैरी झंडा बस बिटवाइज़ गुणन का परिणाम है x₁x₂:



perceptrons के समतुल्य नेटवर्क प्राप्त करने के लिए, हम सब की जगह नंद द्वार दो इनपुट के साथ परसेप्ट्रान हैं, जिनमें से प्रत्येक का वजन -2 है, और 3. के ऑफसेट के साथ यहां परिणामी नेटवर्क है। ध्यान दें कि मैंने निचले दाहिने वाल्व के अनुरूप पर्सेप्ट्रोन को स्थानांतरित किया, बस तीर को खींचने के लिए इसे और अधिक सुविधाजनक बनाने के लिए:



इस परसेप्ट्रॉन नेटवर्क का एक उल्लेखनीय पहलू यह है कि सबसे बाईं ओर के आउटपुट को नीचे से इनपुट के रूप में दो बार उपयोग किया जाता है। परसेप्ट्रोन के मॉडल को परिभाषित करते हुए, मैंने एक ही स्थान पर इस तरह की दोहरी निकास योजना की स्वीकार्यता का उल्लेख नहीं किया। वास्तव में, यह वास्तव में मायने नहीं रखता है। यदि हम इसकी अनुमति नहीं देना चाहते हैं, तो हम -2 की वज़न वाली दो रेखाओं को जोड़ सकते हैं, जिनमें से एक का वजन -4 है। (यदि यह आपको स्पष्ट नहीं लगता है, तो रोकें और इसे अपने आप को साबित करें)। इस परिवर्तन के बाद, नेटवर्क निम्नानुसार दिखता है, -2 के बराबर सभी असमान वज़न के साथ, 3 के बराबर सभी ऑफ़सेट्स, और एक वज़न -4 चिह्नित है:



परसेप्ट्रॉन का ऐसा रिकॉर्ड जिसमें आउटपुट होता है, लेकिन कोई इनपुट नहीं:



बस एक संक्षिप्त नाम है। इसका मतलब यह नहीं है कि उसके पास कोई इनपुट नहीं है। इसे समझने के लिए, मान लीजिए कि हमारे पास इनपुट के बिना एक परसेप्ट्रॉन है। तब भारित राशि w _जे डब्ल्यू _जे x _जे हमेशा शून्य होगी, इसलिए बोधक 1 बी के लिए 1 और 0 के लिए बी That 0 देगा। यही है, अवधारणात्मक बस एक निश्चित मूल्य देगा, और न कि हमें क्या चाहिए (x ₁ उदाहरण में) इसके बाद के संस्करण)। यह माना जाता है कि इनपुट परसेप्ट्रोन को पेरिसेप्ट्रोन के रूप में नहीं माना जाता है, लेकिन विशेष इकाइयों के रूप में जिन्हें केवल परिभाषित किया गया है ताकि वांछित मानों x ₁ , x ₂ , ... का उत्पादन किया जा सके ।

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

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

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

सिग्माइड न्यूरॉन्स

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



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

समस्या यह है कि यदि नेटवर्क में पेसेप्ट्रॉन हैं, तो ऐसा नहीं होता है। किसी भी बोधक के वजन या विस्थापन में एक छोटा सा परिवर्तन कभी-कभी इसके आउटपुट में विपरीत के लिए बदलाव ला सकता है, कहते हैं, 0 से 1 तक। इस तरह के फ्लिप से नेटवर्क के बाकी हिस्सों का व्यवहार बहुत जटिल तरीके से बदल सकता है। और यहां तक ​​कि अगर अब हमारे "9" को सही ढंग से मान्यता प्राप्त है, तो अन्य सभी छवियों के साथ नेटवर्क का व्यवहार शायद पूरी तरह से बदल गया है जिसे नियंत्रित करना मुश्किल है। इस वजह से, यह कल्पना करना मुश्किल है कि हम धीरे-धीरे वज़न और ऑफसेट को कैसे समायोजित कर सकते हैं ताकि नेटवर्क धीरे-धीरे वांछित व्यवहार से संपर्क करे। शायद इस समस्या के आसपास कोई चतुर तरीका है। लेकिन परसेप्ट्रोन के नेटवर्क को सीखने की समस्या का कोई सरल समाधान नहीं है।

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

मुझे एक सिग्मॉइड न्यूरॉन का वर्णन करने दें। हम उन्हें उसी तरह आकर्षित करेंगे जैसे कि अवधारणात्मक:



इसमें समान इनपुट x ₁ , x ₂ , ... लेकिन 0 या 1 के बराबर होने के बजाय, इन इनपुट का 0 से 1 तक की सीमा में कोई भी मूल्य हो सकता है। उदाहरण के लिए, 0.638 का मान एक मान्य इनपुट होगा सिग्मॉइड न्यूरॉन (सीएच)। पर्सेप्ट्रोन की तरह, एसएन में प्रत्येक इनपुट के लिए वेट होता है, डब्ल्यू ₁ , डब्ल्यू ₂ , ... और कुल बायस बी। लेकिन इसका आउटपुट मान 0 या 1. नहीं होगा। यह σ (w +x + b) होगा, जहां σ सिग्मॉइड है।

वैसे, the को कभी-कभी लॉजिस्टिक फ़ंक्शन कहा जाता है, और न्यूरॉन्स के इस वर्ग को लॉजिस्टिक न्यूरॉन्स कहा जाता है। इस शब्दावली को याद रखना उपयोगी है, क्योंकि ये शब्द तंत्रिका नेटवर्क के साथ काम करने वाले कई लोगों द्वारा उपयोग किए जाते हैं। हालाँकि, हम सिग्मॉइड शब्दावली का पालन करेंगे।

फ़ंक्शन को निम्नानुसार परिभाषित किया गया है:

$$

$$\ सिग्मा (z) \ equiv \ frac {1} {1 + e ^ {- z}} \ टैग 3}$$

हमारे मामले में, इनपुट डेटा x ₁ , x ₂ , ... वेट्स ₁ , डब्ल्यू ₂ , ... और ऑफसेट बी के साथ सिग्माइड न्यूरॉन का आउटपुट मान इस प्रकार माना जाएगा:

$$

$$\ frac {1} {1 + exp (- \ sum_j w_jx_j - b)} \ टैग / 4}$$

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

परसेप्ट्रॉन मॉडल के समानताओं को समझने के लिए, मान लीजिए कि z ⋅ w b x + b एक बड़ा धनात्मक संख्या है। तब e - z, 0, इसलिए, - (z) ≈ 1. दूसरे शब्दों में, जब z = w large x + b बड़ा और धनात्मक होता है, तो SN उपज लगभग 1 होती है, जैसा कि परसेप्ट्रान में होता है। मान लीजिए कि z = w + x + b एक ऋण चिह्न के साथ बड़ा है। फिर e - z → ∞, और σ (z) So 0. तो बड़े z के लिए माइनस साइन के साथ, SN का व्यवहार भी परसेप्ट्रॉन से संपर्क करता है। और केवल जब w + x + b का औसत आकार है, तो मनाया गया मॉडल से गंभीर विचलन हैं।

बीजगणितीय रूप bra के बारे में क्या? हम उसे कैसे समझेंगे? वास्तव में, fact का सटीक रूप इतना महत्वपूर्ण नहीं है - ग्राफ़ पर फ़ंक्शन का आकार महत्वपूर्ण है। यहाँ यह है:



यह चरण फ़ंक्शन का एक आसान संस्करण है:



यदि per स्टेपवाइज थे, तो एसएन एक परसेप्ट्रॉन होगा, क्योंकि इसमें 0 या 1 आउटपुट होगा जो साइन डब्ल्यू sign x + b (अच्छी तरह से, वास्तव में, z = 0 पर निर्भर करता है), perceptron 0 देता है, और स्टेप फंक्शन - 1 , इसलिए उस बिंदु पर, फ़ंक्शन को बदलना होगा)।

वास्तविक फ़ंक्शन σ का उपयोग करते हुए, हमें एक सुस्पष्ट अवधारण प्राप्त होता है। और यहां मुख्य बात फ़ंक्शन की चिकनाई है, न कि इसका सटीक रूप। चिकनाई का मतलब है कि छोटे बदलाव jw _j वेट और sb ऑफसेट आउटपुट के छोटे बदलाव smalloutput देंगे। बीजगणित हमें बताता है कि isoutput अच्छी तरह से अनुमानित है:

$$

$$\ Delta आउटपुट \ लगभग \ sum_j \ frac {\ आंशिक उत्पादन} {\ आंशिक w_j} \ Delta w_j + \ frac {\ आंशिक उत्पादन} {\ आंशिक b} \ Delta b \ टैग {5}$$

जहाँ पर सम्‍पन्‍नता सभी भारों w _{j से अधिक है} , और putoutput / andw _j और putoutput / theb क्रमशः w _j और b के संबंध में आउटपुट के आंशिक व्युत्पन्न को दर्शाते हैं। यदि आप निजी डेरिवेटिव की कंपनी में असुरक्षित महसूस करते हैं तो घबराएं नहीं! यद्यपि सूत्र जटिल दिखता है, इन सभी आंशिक व्युत्पत्तियों के साथ, यह वास्तव में कुछ काफी सरल (और उपयोगी) कहता है: putoutput onw _j और web भार और पूर्वाग्रह के आधार पर एक रैखिक कार्य है। इसकी रैखिकता किसी भी वांछित छोटे आउटपुट पूर्वाग्रह को प्राप्त करने के लिए भार और ऑफसेट में छोटे बदलावों का चयन करना आसान बनाती है। इसलिए, हालांकि एसएन गुणात्मक व्यवहार में पेसेप्ट्रॉन के समान होते हैं, वे यह समझना आसान बनाते हैं कि कैसे वजन और विस्थापन को बदलकर आउटपुट को बदला जा सकता है।

यदि सामान्य रूप the हमारे लिए महत्वपूर्ण है, और इसका सटीक रूप नहीं है, तो हम इस तरह के सूत्र (3) का उपयोग क्यों करते हैं? वास्तव में, बाद में हम कभी-कभी उन न्यूरॉन्स पर विचार करेंगे जिनका आउटपुट f (w b x + b) है, जहां f () कुछ अन्य सक्रियण फ़ंक्शन है। जब फ़ंक्शन बदलता है तो मुख्य चीज समीकरण (5) में आंशिक डेरिवेटिव का मूल्य है। यह पता चला है कि जब हम इन आंशिक व्युत्पन्नों की गणना करते हैं, तो simpl का उपयोग बीजगणित को बहुत सरल करता है, क्योंकि जब विभेदकों में विभेदकों के बहुत अच्छे गुण होते हैं। किसी भी मामले में, in अक्सर तंत्रिका नेटवर्क के साथ काम करने में उपयोग किया जाता है, और इस पुस्तक में सबसे अधिक बार हम इस तरह के एक सक्रियण फ़ंक्शन का उपयोग करेंगे।

सीएच के काम के परिणाम की व्याख्या कैसे करें? स्पष्ट रूप से, अवधारणात्मक और सीएच के बीच मुख्य अंतर यह है कि सीएच केवल 0 या 1 नहीं देता है। उनका आउटपुट 0 से 1 तक कोई भी वास्तविक संख्या हो सकती है, इसलिए 0.173 या 0.689 जैसे मान मान्य हैं। यह उपयोगी हो सकता है, उदाहरण के लिए, यदि आप आउटपुट मूल्य को इंगित करना चाहते हैं, उदाहरण के लिए, एनएस के इनपुट पर प्राप्त छवि के पिक्सल की औसत चमक। लेकिन कभी-कभी यह असुविधाजनक हो सकता है। मान लीजिए कि हम चाहते हैं कि नेटवर्क आउटपुट यह कहे कि "छवि 9 इनपुट थी" या "इनपुट छवि 9 नहीं"। जाहिर है, यह आसान होगा यदि आउटपुट मान 0 या 1, एक अवधारणात्मक की तरह हो। लेकिन व्यवहार में, हम सहमत हो सकते हैं कि इनपुट पर कम से कम 0.5 के किसी भी आउटपुट मूल्य का मतलब "9" होगा, और 0.5 से कम के किसी भी मूल्य का मतलब यह होगा कि यह "9 नहीं" है। मैं हमेशा ऐसे समझौतों के अस्तित्व को स्पष्ट रूप से इंगित करता हूँ।

अभ्यास

• सीएच अनुकरण perceptrons, भाग 1

मान लीजिए कि हम सभी वेट और ऑफ़सेट को परसेप्ट्रोन के एक नेटवर्क से लेते हैं, और उन्हें एक सकारात्मक निरंतर c> 0 से गुणा करते हैं। दिखाएँ कि नेटवर्क व्यवहार नहीं बदलता है।

• सीएच अनुकरण perceptrons, भाग 2

मान लीजिए कि हमारे पास पिछली समस्या के समान स्थिति है - अवधारणात्मक का एक नेटवर्क। यह भी मान लीजिए कि नेटवर्क के लिए इनपुट डेटा चुना गया है। हमें एक विशिष्ट मूल्य की आवश्यकता नहीं है, मुख्य बात यह है कि यह तय हो गया है। मान लीजिए कि वज़न और विस्थापन ऐसे हैं जैसे कि w +x + b where 0, जहां x नेटवर्क के किसी भी अवधारणात्मक का इनपुट मान है। अब हम एसएन के साथ नेटवर्क में सभी पेसेप्ट्रॉन को प्रतिस्थापित करते हैं, और सकारात्मक निरंतर c> 0 द्वारा वजन और विस्थापन को गुणा करते हैं। दिखाएँ कि सी में सीमा → ∞ एसएन से नेटवर्क का व्यवहार ठीक वैसा ही होगा जैसा कि पेसेप्ट्रॉन के नेटवर्क का। यदि इस अवधारणा का उल्लंघन किया गया हो, तो एक अवधारणात्मक w violx + b = 0 के लिए कैसे होगा?

तंत्रिका नेटवर्क वास्तुकला

अगले भाग में, मैं एक तंत्रिका नेटवर्क पेश करूँगा जो हस्तलिखित संख्याओं के अच्छे वर्गीकरण में सक्षम है। इससे पहले, शब्दावली की व्याख्या करना उपयोगी है जो हमें नेटवर्क के विभिन्न हिस्सों को इंगित करने की अनुमति देता है। मान लें कि हमारे पास निम्नलिखित नेटवर्क हैं:



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



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

डिजाइनिंग इनपुट और आउटपुट लेयर कभी-कभी एक सरल कार्य है। उदाहरण के लिए, मान लें कि हम यह निर्धारित करने की कोशिश कर रहे हैं कि हस्तलिखित संख्या का अर्थ "9" है या नहीं। एक प्राकृतिक नेटवर्क सर्किट इनपुट न्यूरॉन्स में छवि पिक्सल की चमक को एन्कोड करेगा। यदि छवि काली और सफेद है, तो आकार में 64x64 पिक्सेल है, तो हमारे पास 64x64 = 4096 इनपुट न्यूरॉन्स होंगे, जिसमें 0 से 1 तक की सीमा में चमक होगी। आउटपुट परत में केवल एक न्यूरॉन होगा, जिसका मान 0.5 से कम होगा। इनपुट 9 नहीं था ", लेकिन मूल्यों का अधिक अर्थ होगा कि" इनपुट 9 था "।

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

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

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

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

सरल स्याही वर्गीकरण नेटवर्क

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



छह अलग में



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



यह 5 है।

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

व्यक्तिगत अंकों को पहचानने के लिए, हम तीन परतों से NS का उपयोग करेंगे:



इनपुट नेटवर्क लेयर में इनपुट पिक्सल्स के विभिन्न मानों को न्यूरॉन्स एन्कोडिंग होता है। जैसा कि अगले भाग में इंगित किया जाएगा, हमारे प्रशिक्षण डेटा में 28x28 पिक्सेल आकार के स्कैन किए गए हस्तलिखित अंकों की कई छवियां शामिल होंगी, इसलिए इनपुट परत में 28x28 = 784 न्यूरॉन्स होते हैं। सरलता के लिए, मैंने आरेख में अधिकांश 784 न्यूरॉन्स का संकेत नहीं दिया। आने वाले पिक्सेल काले और सफेद होते हैं, जिनमें 0.0 का मान सफेद होता है, 1.0 का संकेत काले रंग का होता है, और मध्यवर्ती मूल्यों में ग्रे के बढ़ते गहरे रंगों का संकेत होता है।

नेटवर्क की दूसरी परत छिपी हुई है। हम इस परत n में न्यूरॉन्स की संख्या को निरूपित करते हैं, और हम n के विभिन्न मूल्यों के साथ प्रयोग करेंगे। उपरोक्त उदाहरण में केवल n = 15 न्यूरॉन्स वाली एक छोटी छिपी हुई परत दिखाई देती है।

नेटवर्क की आउटपुट लेयर में 10 न्यूरॉन्स होते हैं। यदि पहला न्यूरॉन सक्रिय है, अर्थात इसका आउटपुट मान, 1 है, तो यह इंगित करता है कि नेटवर्क मानता है कि इनपुट 0. था। यदि दूसरा न्यूरॉन सक्रिय है, तो नेटवर्क का मानना ​​है कि इनपुट 1 था। और इसी तरह। सख्ती से बोलते हुए, हम आउटपुट न्यूरॉन्स को 0 से 9 तक संख्या देते हैं, और देखें कि उनमें से किसका अधिकतम सक्रियण मूल्य था। यदि यह, कहते हैं, न्यूरॉन नंबर 6, तो हमारे नेटवर्क का मानना ​​है कि इनपुट नंबर 6. और इसी तरह था।

आपको आश्चर्य हो सकता है कि हमें दस न्यूरॉन्स का उपयोग करने की आवश्यकता क्यों है। आखिरकार, हम यह जानना चाहते हैं कि 0 से 9 तक कौन सा अंक इनपुट छवि से मेल खाता है। केवल 4 आउटपुट न्यूरॉन्स का उपयोग करना स्वाभाविक होगा, जिनमें से प्रत्येक एक द्विआधारी मूल्य लेगा, इस पर निर्भर करता है कि इसका आउटपुट मान 0 या 1 के करीब है। 2 ⁴ = 16 के बाद से चार न्यूरॉन्स पर्याप्त होंगे, 10 से अधिक संभावित मान। हमारे नेटवर्क को 10 न्यूरॉन्स का उपयोग क्यों करना चाहिए? क्या यह अप्रभावी है? इसके लिए आधार अनुभवजन्य है; हम नेटवर्क के दोनों प्रकारों की कोशिश कर सकते हैं, और यह पता चलता है कि इस कार्य के लिए, 10 आउटपुट न्यूरॉन्स वाला नेटवर्क 4 के साथ नेटवर्क की तुलना में संख्याओं को पहचानने के लिए बेहतर प्रशिक्षित है। हालांकि, सवाल यह है कि 10 आउटपुट न्यूरॉन्स बेहतर क्यों हैं। क्या कोई ऐसा अनुमान है जो हमें पहले से बताएगा कि 4 के बजाय 10 आउटपुट न्यूरॉन्स का उपयोग किया जाना चाहिए?

यह समझने के लिए कि, यह सोचना उपयोगी है कि तंत्रिका नेटवर्क क्या करता है। सबसे पहले, 10 आउटपुट न्यूरॉन्स के साथ विकल्प पर विचार करें। हम पहले आउटपुट न्यूरॉन पर ध्यान केंद्रित करते हैं, जो यह तय करने की कोशिश कर रहा है कि क्या आने वाली छवि शून्य है। वह एक छिपी हुई परत से प्राप्त सबूतों का वजन करके ऐसा करता है। छिपे हुए न्यूरॉन क्या करते हैं? मान लीजिए कि छिपी हुई परत में पहला न्यूरॉन यह निर्धारित करता है कि क्या तस्वीर में ऐसा कुछ है:



वह इस छवि से मेल खाते पिक्सेल के लिए बड़े वजन, और बाकी के लिए छोटे वजन को असाइन करके कर सकते हैं। उसी तरह, मान लीजिए कि छिपी हुई परत में दूसरा, तीसरा और चौथा न्यूरॉन्स देख रहे हैं कि क्या छवि में समान टुकड़े हैं:



जैसा कि आपने अनुमान लगाया होगा, ये सभी चार टुकड़े छवि 0 को देते हैं, जिसे हमने पहले देखा था:



इसलिए, यदि चार छिपे हुए न्यूरॉन्स सक्रिय होते हैं, तो हम यह निष्कर्ष निकाल सकते हैं कि संख्या 0. है। यह एकमात्र प्रमाण नहीं है कि 0 को वहां प्रदर्शित किया गया था - हम 0 को कई अन्य तरीकों से प्राप्त कर सकते हैं (इन चित्रों को थोड़ा स्थानांतरित करके या उन्हें थोड़ा विकृत करके)। हालांकि, हम यह सुनिश्चित कर सकते हैं कि कम से कम इस मामले में, हम यह निष्कर्ष निकाल सकते हैं कि इनपुट पर 0 था।

यदि हम मानते हैं कि नेटवर्क इस तरह काम करता है, तो हम यह बता सकते हैं कि 10 के बजाय 10 आउटपुट न्यूरॉन्स का उपयोग करना बेहतर क्यों है। अगर हमारे पास 4 आउटपुट न्यूरॉन्स थे, तो पहला न्यूरॉन यह तय करने की कोशिश करेगा कि आने वाले अंक का सबसे महत्वपूर्ण बिट क्या है। और ऊपर दिए गए सरल रूपों के साथ सबसे महत्वपूर्ण बिट को संबद्ध करने का कोई आसान तरीका नहीं है। किसी भी ऐतिहासिक कारणों की कल्पना करना कठिन है कि अंक के रूप के कुछ हिस्से किसी भी तरह उत्पादन के सबसे महत्वपूर्ण बिट से संबंधित क्यों होंगे।

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

अभ्यास

• , . , . . , 3 , ( ) 0,99, 0,01.

तो, हमारे पास NA योजना है - संख्याओं को पहचानना कैसे सीखें? पहली चीज जो हमें चाहिए वह है प्रशिक्षण डेटा, तथाकथित प्रशिक्षण डेटा सेट। हम MNIST किट का उपयोग हजारों हस्तलिखित संख्याओं की स्कैन की गई छवियों और उनके सही वर्गीकरण से करेंगे। एमएनआईएसटी नाम इस तथ्य के कारण प्राप्त हुआ कि यह NIST , यूएस नेशनल इंस्टीट्यूट ऑफ स्टैंडर्ड एंड टेक्नोलॉजी द्वारा एकत्र किए गए दो डेटा सेटों का एक संशोधित सबसेट है । यहाँ MNIST से कुछ चित्र दिए गए हैं:



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

MNIST डेटा में दो भाग होते हैं। पहले प्रशिक्षण के लिए 60,000 छवियां शामिल हैं। ये 250 लोगों की पांडुलिपियां हैं, जिनमें से आधे अमेरिकी जनगणना ब्यूरो के कर्मचारी थे, और दूसरे आधे उच्च विद्यालय के छात्र थे। चित्र काले और सफेद हैं, जिनकी माप 28x28 पिक्सेल है। नेटवर्क का परीक्षण करने के लिए MNIST डेटासेट का दूसरा भाग 10,000 चित्र है। यह भी एक काले और सफेद छवि 28x28 पिक्सेल है। हम इस डेटा का उपयोग मूल्यांकन करने के लिए करेंगे कि नेटवर्क ने संख्याओं को पहचानना कितना अच्छा सीखा है। मूल्यांकन की गुणवत्ता में सुधार के लिए, ये आंकड़े अन्य 250 लोगों से लिए गए थे, जिन्होंने प्रशिक्षण सेट की रिकॉर्डिंग में भाग नहीं लिया था (हालाँकि ये ब्यूरो कर्मचारी और हाई स्कूल के छात्र भी थे)। यह हमें यह सुनिश्चित करने में मदद करता है कि हमारा सिस्टम उन लोगों की लिखावट को पहचान सके जो प्रशिक्षण के दौरान उसे नहीं मिले थे।

प्रशिक्षण इनपुट x द्वारा निरूपित किया जाएगा। 28x28 = 784 माप के साथ वेक्टर के रूप में प्रत्येक इनपुट छवि x का इलाज करना सुविधाजनक होगा। वेक्टर के अंदर प्रत्येक मान छवि में एक पिक्सेल की चमक को इंगित करता है। हम आउटपुट मान को y = y (x) के रूप में निरूपित करेंगे, जहाँ y एक दस-आयामी वेक्टर है। उदाहरण के लिए, यदि एक निश्चित प्रशिक्षण छवि x में 6 हैं, तो y (x) = (0,0,0,0,0,0,1,0,0,0) ^T वह वेक्टर होगा जिसकी हमें आवश्यकता है। टी एक ट्रांसपोज़ ऑपरेशन है जो एक पंक्ति वेक्टर को कॉलम वेक्टर में बदलता है।

हम एक ऐसा एल्गोरिथ्म ढूंढना चाहते हैं जो हमें ऐसे वज़न और ऑफ़सेट की तलाश करने की अनुमति देता है ताकि नेटवर्क आउटपुट सभी प्रशिक्षण इनपुट x के लिए y (x) तक पहुंचे। इस लक्ष्य के सन्निकटन को निर्धारित करने के लिए, हम एक लागत फ़ंक्शन (कभी-कभी एक हानि फ़ंक्शन कहा जाता है) को परिभाषित करते हैं; पुस्तक में हम लागत फ़ंक्शन का उपयोग करेंगे, लेकिन दूसरे नाम को ध्यान में रखें):

$$

$$C(w, b) = \frac{1}{2n} \sum_x || y(x) – a ||^2 \tag{6}$$

यहाँ w नेटवर्क बाइट्स के एक सेट को दर्शाता है, बी ऑफ़सेट्स का एक सेट है, n प्रशिक्षण इनपुट डेटा की संख्या है, एक आउटपुट डेटा का वेक्टर है जब x इनपुट डेटा होता है, और योग सभी प्रशिक्षण इनपुट x से गुजरता है। आउटपुट, ज़ाहिर है, एक्स, डब्ल्यू और बी पर निर्भर करता है, लेकिन सादगी के लिए मैंने इस निर्भरता को नामित नहीं किया। अंकन || v || वेक्टर की लंबाई का मतलब है v। हम सी को एक द्विघात लागत फ़ंक्शन कहेंगे; कभी-कभी इसे मानक त्रुटि या MSE भी कहा जाता है। यदि आप C को करीब से देखते हैं, तो आप देख सकते हैं कि यह नकारात्मक नहीं है, क्योंकि योग के सभी सदस्य गैर-नकारात्मक हैं। इसके अलावा, C (w, b) की लागत छोटी हो जाती है, यानी C (w, b), 0, ठीक है जब y (x) लगभग सभी प्रशिक्षण इनपुट डेटा x के लिए आउटपुट वेक्टर के बराबर है। तो हमारे एल्गोरिथ्म ने अच्छी तरह से काम किया अगर हम वजन और ऑफसेट को खोजने में कामयाब रहे जैसे कि सी (डब्ल्यू, बी) And 0. और इसके विपरीत, यह खराब काम किया जब सी (डब्ल्यू,b) बड़ा - इसका मतलब है कि y (x) बड़ी मात्रा में इनपुट के लिए आउटपुट से मेल नहीं खाता है। यह पता चलता है कि प्रशिक्षण एल्गोरिथ्म का लक्ष्य वजन और ऑफसेट के एक समारोह के रूप में सी (डब्ल्यू, बी) की लागत को कम करना है। दूसरे शब्दों में, हमें वज़न और ऑफ़सेट का एक सेट खोजने की ज़रूरत है जो लागत के मूल्य को कम से कम करे। हम ऐसा एक एल्गोरिथ्म का उपयोग करके करेंगे, जिसे ग्रेडिएंट डीसेंट कहा जाता है।

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

यहां तक ​​कि यह देखते हुए कि हम एक चिकनी लागत फ़ंक्शन का उपयोग करना चाहते हैं, आप अभी भी इस बात में दिलचस्पी ले सकते हैं कि हमने समीकरण (6) के लिए द्विघात फ़ंक्शन को क्यों चुना? क्या इसे मनमाने ढंग से चुनना संभव नहीं है? शायद अगर हमने एक अलग फ़ंक्शन चुना, तो हमें कम से कम वज़न और ऑफसेट का एक अलग सेट मिलेगा? एक उचित प्रश्न, और बाद में हम फिर से लागत समारोह की जांच करेंगे और इसके लिए कुछ सुधार करेंगे। हालांकि, एनएस सीखने में बुनियादी चीजों को समझने के लिए द्विघात लागत फ़ंक्शन बहुत अच्छा काम करता है, इसलिए अभी के लिए हम इससे चिपके रहेंगे।

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

ठीक है, मान लें कि हम कुछ फ़ंक्शन C (v) को कम करने का प्रयास कर रहे हैं। यह कई चर v = v ₁ , v ₂ , ... के वास्तविक मानों के साथ कोई भी कार्य हो सकता है ... ध्यान दें कि मैंने नोटेशन w और b को v के साथ बदल दिया है ताकि यह पता चले कि यह कोई भी कार्य हो सकता है - हम अब HC के प्रति जुनूनी नहीं हैं। यह कल्पना करना उपयोगी है कि एक फ़ंक्शन C के केवल दो चर हैं - v ₁ और v ₂ :



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

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

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

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

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

समस्या को स्पष्ट करने के लिए, हम यह सोचते हैं कि क्या होगा यदि हम गेंद को v ₁ की दिशा में एक छोटी दूरी 1v ₁ से आगे बढ़ाते हैं।और कुछ ही दूरी पर Δv ₂ वी की दिशा में ₂ । बीजगणित हमें बताता है कि C निम्नानुसार बदलता है:

$$

$$\Delta C \approx \frac{\partial C}{\partial v_1} \Delta v_1 + \frac{\partial C}{\partial v_2} \Delta v_2 \tag{7}$$

हम ऐसे findv ₁ और sov ₂ को चुनने का एक तरीका खोज लेंगे ताकि lessC शून्य से कम हो; वह यह है कि हम उनका चयन करेंगे ताकि गेंद लुढ़क जाए। यह समझने के लिए कि यह कैसे करना है, परिवर्तन के वेक्टर के रूप में thev को परिभाषित करना उपयोगी है, अर्थात, ≡v Δ (≡v ₁ , ) v ₂ ) ^T , जहां T वह पारगमन ऑपरेशन है जो पंक्ति वैक्टर को कॉलम डॉक्टर्स में बदलता है। हम यह भी आंशिक डेरिवेटिव के रूप में ढाल वेक्टर सी परिभाषित करते हैं (∂S / ∂v ₁ , ∂S / ∂v ₂ ) ^टी । हम by द्वारा ग्रेडिएंट वेक्टर को निरूपित करते हैं:

$$

$$\nabla C \equiv (\frac{\partial C}{\partial v_1}, \frac{\partial C}{\partial v_2})^T \tag{8}$$

जल्द ही हम willv और ढाल reC के माध्यम से willC में परिवर्तन को फिर से लिखेंगे। इस बीच, मैं कुछ स्पष्ट करना चाहता हूं, जिसके कारण लोग अक्सर ढाल पर लटक जाते हैं। जब वे पहली बार ,C से मिले थे, तो लोग कभी-कभी यह नहीं समझ पाते कि उन्हें प्रतीक ∇ को कैसे समझना चाहिए। इसका विशेष रूप से क्या मतलब है? वास्तव में, आप सुरक्षित रूप से --C को एक एकल गणितीय वस्तु - पहले से परिभाषित वेक्टर - जो केवल दो वर्णों का उपयोग करके लिखा गया है, पर विचार कर सकते हैं। इस दृष्टिकोण से, ∇ एक ध्वज को लहराते हुए सूचित करता है कि "aC एक ढाल वेक्टर है।" देखने के और अधिक उन्नत बिंदु हैं जिनसे of को एक स्वतंत्र गणितीय इकाई के रूप में माना जा सकता है (उदाहरण के लिए, एक भेदभाव ऑपरेटर के रूप में), लेकिन हमें उनकी आवश्यकता नहीं है।

ऐसी परिभाषाओं के साथ, अभिव्यक्ति (7) को फिर से लिखा जा सकता है:

$$

$$\Delta C \approx \nabla C \cdot \Delta v \tag{9}$$

यह समीकरण यह समझाने में मदद करता है कि isC को ग्रेडिएंट वेक्टर क्यों कहा जाता है: यह सी में परिवर्तनों के साथ v में परिवर्तनों को जोड़ता है, जैसे कि एक इकाई से अपेक्षित ग्रेडिएंट। [अभियांत्रिकी। gradient - विचलन / लगभग। अनुवाद।] हालांकि, यह अधिक दिलचस्प है कि यह समीकरण हमें यह देखने की अनुमति देता है कि sov कैसे चुनें ताकि isC नकारात्मक हो। मान लीजिए हम चुनते हैं

$$

$$\Delta v = - \eta \nabla C \tag{10}$$

जहां parameter एक छोटा सा सकारात्मक पैरामीटर (सीखने की गति) है। तब समीकरण (9) हमें बताता है कि ≈C η - ⋅C ∇ 9C = - ∇ || tellsC || ^२ । चूँकि SinceC || ² ≤ 0, यह सुनिश्चित करता है कि ≤C that 0, यानी C हर समय घटेगा जब हम v बदलेंगे, जैसा कि (10) में निर्धारित है (बेशक, समीकरण (9) से सन्निकटन के हिस्से के रूप में)। और यह वही है जो हमें चाहिए! इसलिए, हम अपने ढाल वंश एल्गोरिथ्म में गेंद के "गति के नियम" को निर्धारित करने के लिए समीकरण (10) लेते हैं। यही है, हम andv मान की गणना करने के लिए समीकरण (10) का उपयोग करेंगे, और फिर हम गेंद को इस मूल्य पर ले जाएंगे:

$$

$$v \rightarrow v' = v - \eta \nabla C \tag{11}$$

फिर हम फिर से अगले कदम के लिए इस नियम को लागू करते हैं। पुनरावृत्ति को जारी रखते हुए, हम सी को कम करेंगे, उम्मीद है कि हम एक वैश्विक न्यूनतम तक पहुंचेंगे।

सुमिंगिंग, ग्रेडिएंट डीसेंट ग्रेडिएंट and C की क्रमिक गणना के माध्यम से काम करता है, और बाद में विपरीत दिशा में विस्थापन होता है, जो घाटी के ढलान के साथ "गिरावट" की ओर जाता है। इसे निम्नानुसार कल्पना की जा सकती है:



ध्यान दें कि इस नियम के साथ, ढाल वंश वास्तविक भौतिक गति को पुन: पेश नहीं करता है। वास्तविक जीवन में, गेंद में एक आवेग होता है जो इसे ढलान के पार रोल करने की अनुमति दे सकता है, या कुछ समय के लिए भी रोल कर सकता है। घर्षण बल के काम के बाद ही घाटी में लुढ़कने की गारंटी है। हमारा चयन नियम selectionv सिर्फ "नीचे जाओ" कहता है। न्यूनतम खोजने के लिए एक बहुत अच्छा नियम!

धीरे-धीरे सही ढंग से काम करने के लिए, हमें सीखने की गति का पर्याप्त रूप से छोटा मूल्य चुनने की आवश्यकता है, ताकि समीकरण (9) एक अच्छा सन्निकटन हो। अन्यथा, यह पता चल सकता है कि >C> 0 - कुछ भी अच्छा नहीं है! उसी समय, यह आवश्यक नहीं है कि since बहुत छोटा हो, तब से willv में परिवर्तन छोटे होंगे, और एल्गोरिथ्म बहुत धीरे-धीरे काम करेगा। व्यवहार में, practice बदलता है ताकि समीकरण (9) एक अच्छा सन्निकटन देता है, और एल्गोरिथ्म भी धीरे-धीरे काम नहीं करता है। बाद में हम देखेंगे कि यह कैसे काम करता है।

जब क्रम C केवल दो चर पर निर्भर होता है तो मैंने ढाल मूल को समझाया। लेकिन सब कुछ उसी तरह से काम करता है अगर C कई वैरिएबल्स का फंक्शन है। मान लीजिए कि उसके पास m वैरिएबल, v ₁ , ..., v _{m है}। तब causedC में बदलाव (v = ( ... v ₁ , ..., willv _m ) ^T में एक छोटे से बदलाव के कारण होगा

$$

$$\Delta C \approx \nabla C \cdot \Delta v \tag{12}$$

जहां ढाल isC वेक्टर है

$$

$$\nabla C \equiv (\frac{\partial C}{\partial v_1},…, \frac{\partial C}{\partial v_m})^T \tag{13}$$

दो चरों के साथ, हम चुन सकते हैं

$$

$$\Delta v = - \eta \nabla C \tag{14}$$

और सुनिश्चित करें कि negativeC के लिए हमारी अनुमानित अभिव्यक्ति (12) नकारात्मक है। यह हमें एक न्यूनतम पर ग्रेडिएंट के साथ जाने का एक तरीका देता है, यहां तक ​​कि जब सी कई चर का एक फ़ंक्शन है, तो अपडेट नियम को बार-बार लागू करना।

$$

$$v \rightarrow v' = v - \eta \nabla C \tag{15}$$

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

एक अर्थ में, ढाल मूल को न्यूनतम न्यूनतम खोज रणनीति माना जा सकता है। मान लीजिए हम सी को कम करने के लिए tov को एक स्थिति में ले जाने की कोशिश कर रहे हैं। यह ≈C ⋅C। ⋅v को कम करने के बराबर है। हम कदम के आकार को सीमित करेंगे ताकि || sizev || = words कुछ छोटे स्थिरांक के लिए ε> 0. दूसरे शब्दों में, हम एक निश्चित आकार के एक छोटे से दूरी को स्थानांतरित करना चाहते हैं, और गति की दिशा को खोजने की कोशिश करते हैं जो सी जितना संभव हो उतना कम हो जाता है। यह सिद्ध किया जा सकता है कि minimv को कम करने का विकल्प ⋅C Δ Δv Δv = -C है, जहां η∇ = ε / || ∇C || प्रतिबंध द्वारा निर्धारित किया जाता है || ||v || = ε इसलिए ढाल वंश को उस दिशा में छोटे कदम उठाने का एक तरीका माना जा सकता है जो सी। सबसे कम हो जाता है।

अभ्यास

• . : — , , , .
• , , . , ? ?

लोगों ने ढाल वंश के लिए कई विकल्पों का अध्ययन किया है, जिनमें वे शामिल हैं जो वास्तविक शारीरिक गेंद को अधिक सटीक रूप से पुन: पेश करते हैं। ऐसे विकल्पों के अपने फायदे हैं, लेकिन एक बड़ी खामी भी है: सी के दूसरे आंशिक डेरिवेटिव की गणना करने की आवश्यकता है, जो बहुत सारे संसाधनों का उपभोग कर सकते हैं। इसे समझने के लिए, मान लीजिए कि हमें सभी दूसरे आंशिक डेरिवेटिव C ² C / jv _j kv _{k की} गणना करने की आवश्यकता है । यदि चर v _j मिलियन हैं, तो हमें दूसरे आंशिक व्युत्पन्न (वास्तव में, आधा ट्रिलियन) के एक ट्रिलियन (एक मिलियन वर्ग) की गणना करने की आवश्यकता है, क्योंकि C ² C / ∂v _j kv _k = C ² C / kv _k ∂v _j। लेकिन आपने सार को पकड़ा)। इसके लिए बहुत सारे कंप्यूटिंग संसाधनों की आवश्यकता होगी। इससे बचने के लिए ट्रिक्स हैं, और ग्रेडिएंट डीसेंट के विकल्प की खोज सक्रिय शोध का एक क्षेत्र है। हालांकि, इस पुस्तक में हम एनएस सीखने के लिए मुख्य दृष्टिकोण के रूप में ढाल वंश और इसके वेरिएंट का उपयोग करेंगे।

हम एनए सीखने के लिए ग्रेडिएंट डिसेंट कैसे लागू करें? हमें इसका उपयोग वज़न w _k और ऑफ़सेट b _{l की} खोज करने के लिए करना चाहिए जो लागत समीकरण (6) को कम करता है। आइए वी _जे वेरिएबल्स को वेट और ऑफ़सेट के साथ बदलकर ग्रेडिएंट डिसेंट अपडेट नियम को फिर से लिखें। दूसरे शब्दों में, अब हमारे "स्थिति" में घटक हैं _k और b _l , और ग्रेडिएंट वेक्टर hasC में संबंधित घटक correspondingC / ∂w हैं।_k और /C / lb _l । नए घटकों के साथ अपना अद्यतन नियम लिखने के बाद, हमें यह मिलता है:

$$

$$w_k \rightarrow w'_k = w_k - \eta \frac{\partial C}{\partial w_k} \tag{16}$$

$$

$$b_l \rightarrow b'_l = b_l - \eta \frac{\partial C}{\partial b_l} \tag{17}$$

इस अद्यतन नियम को फिर से लागू करके, हम "डाउनहिल रोल" कर सकते हैं और, किसी भी भाग्य के साथ, न्यूनतम लागत फ़ंक्शन ढूंढ सकते हैं। दूसरे शब्दों में, इस नियम का उपयोग नेशनल असेंबली को प्रशिक्षित करने के लिए किया जा सकता है।

ढाल वंश नियम को लागू करने में कई बाधाएं हैं। हम उन्हें निम्नलिखित अध्यायों में अधिक विस्तार से अध्ययन करेंगे। लेकिन अभी के लिए, मैं केवल एक समस्या का उल्लेख करना चाहता हूं। इसे समझने के लिए, आइए समीकरण (6) में द्विघात मान पर वापस जाएँ। ध्यान दें कि यह लागत फ़ंक्शन C = 1 / n _{x x} C _x जैसा दिखता है, अर्थात, यह व्यक्तिगत प्रशिक्षण उदाहरणों के लिए औसत लागत C || (((y (x) −a || ² ) / 2 है। अभ्यास में, ग्रेडिएंट ,C की गणना करने के लिए, हमें प्रत्येक प्रशिक्षण इनपुट x के लिए ग्रेडिएंट separatelyC _{x को} अलग से गणना करने की आवश्यकता है, और फिर उन्हें औसतन, =C = 1 / n ∇ _x xC _x । दुर्भाग्य से, जब इनपुट की मात्रा बहुत बड़ी होगी, तो इसमें बहुत लंबा समय लगेगा, और इस तरह का प्रशिक्षण धीमा होगा।

सीखने की गति बढ़ाने के लिए, आप स्टोचस्टिक ग्रेडिएंट वंश का उपयोग कर सकते हैं। प्रशिक्षण इनपुट के एक छोटे यादृच्छिक नमूने के लिए aC _{x की} गणना करके gradC ग्रेडिएंट की गणना करने का विचार है। उनके औसत की गणना करके, हम जल्दी से वास्तविक ढाल andC का एक अच्छा अनुमान प्राप्त कर सकते हैं, और यह ढाल वंश को तेज करने में मदद करता है, और इसलिए प्रशिक्षण।

एम प्रशिक्षण इनपुट डेटा की एक छोटी संख्या के यादृच्छिक नमूने के माध्यम से अधिक सटीक, स्टोकेस्टिक क्रमिक वंश कार्य करता है। हम इस यादृच्छिक डेटा को एक्स ₁ , एक्स ₂ , .., एक्स _एम , और इसे मिनी-पैकेट कहेंगे। यदि नमूना आकार एम काफी बड़ा है, तो jC _{X j} का औसत मूल्य सभी .Cx के औसत के करीब पर्याप्त होगा, अर्थात।

$$

$$\ frac {\ sum ^ m_ {j = 1} \ nabla C_ {X_j}} {m} \ लगभग \ frac {\ sum_x \ nabla C_x} {n} = \ nabla C \ tag {18}$$

जहां दूसरी राशि प्रशिक्षण डेटा के पूरे सेट पर जाती है। भागों को परस्पर जोड़कर, हम प्राप्त करते हैं

$$

$$\ nabla C \ लगभग \ frac {1} {m} \ sum ^ m_ {j = 1} \ nabla C_ {X_j} \ tag {19}$$

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

इसे सीधे एनएस के प्रशिक्षण से संबंधित करने के लिए, मान लें कि डब्ल्यू और बी _एल हमारे एनएस के वजन और विस्थापन को दर्शाते हैं। तब स्टॉचस्टिक ढाल वंश इनपुट डेटा के एक यादृच्छिक मिनी-पैकेट का चयन करता है, और उनसे सीखता है

$$

$$w_k \ rightarrow w'_k = w_k - \ frac {\ eta} {m} \ sum_j \ frac {\ आंशिक C_ {X_j}} {\ आंशिक w_k} \ "20"}$$

$$

$$b_l \ rightarrow b'_l = b_l - \ frac {\ eta} {m} \ sum_j \ frac {\ आंशिक C_ {X_j}} {\ आंशिक b_l} \ "21}$$

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

वैसे, यह ध्यान देने योग्य है कि लागत फ़ंक्शन के स्केलिंग और वेट्स और ऑफ़सेट्स को अपडेट करने के बारे में समझौते एक मिनी-पैकेज में भिन्न हैं। समीकरण (6) में, हमने लागत फ़ंक्शन को 1 / n गुना बढ़ाया। कभी-कभी लोग औसत गणना के बजाय, व्यक्तिगत प्रशिक्षण उदाहरणों की लागतों को जोड़कर 1 / n छोड़ देते हैं। यह उपयोगी है जब प्रशिक्षण के उदाहरणों की कुल संख्या अग्रिम में ज्ञात नहीं है। यह तब हो सकता है, उदाहरण के लिए, जब वास्तविक समय में अतिरिक्त डेटा दिखाई देता है। उसी तरह, मिनी-पैकेज अपडेट नियम (20) और (21) कभी-कभी योग के सामने 1 / मीटर सदस्य को छोड़ देते हैं। वैचारिक रूप से, यह कुछ भी प्रभावित नहीं करता है, क्योंकि यह सीखने की गति में परिवर्तन के बराबर है,। हालांकि, विभिन्न कार्यों की तुलना करते समय यह ध्यान देने योग्य है।

एक स्टोकेस्टिक ग्रेडिएंट वंश को राजनीतिक वोट के रूप में माना जा सकता है: पूर्ण पैकेज के लिए ग्रेडिएंट वंश को लागू करने की तुलना में मिनी-पैकेज के रूप में नमूना लेना बहुत आसान है - जैसे किसी साइट से बाहर निकलने पर एक पूर्ण चुनाव का संचालन करना आसान होता है। उदाहरण के लिए, यदि हमारे प्रशिक्षण सेट में MN = की तरह n = 60,000 का आकार है, और हम आकार m = 10 के एक मिनी-पैकेज का एक नमूना बनाते हैं, तो हम 6000 गुना ग्रेडिएंट आकलन को गति देंगे! बेशक, अनुमान आदर्श नहीं होगा - इसमें सांख्यिकीय उतार-चढ़ाव होगा - लेकिन इसे आदर्श होने की आवश्यकता नहीं है: हमें केवल उस दिशा में जाने की आवश्यकता है जो सी घट जाती है, जिसका अर्थ है कि हमें ग्रेडिएंट की सही गणना करने की आवश्यकता नहीं है। व्यवहार में, स्टोकेस्टिक ग्रेडिएंट वंश नेशनल असेंबली के लिए एक आम और शक्तिशाली शिक्षण तकनीक है, और अधिकांश शिक्षण तकनीकों का आधार है जिसे हम पुस्तक के हिस्से के रूप में विकसित करेंगे।

अभ्यास

• ग्रेडिएंट डिसेंट का चरम संस्करण 1. के मिनी-पैकेट आकार का उपयोग करता है। यही है, इनपुट x के साथ हम अपने वज़न और ऑफ़सेट्स को नियमों के अनुसार w _k → w = _k = w _k - ηC _x / ∂ _k और b _l → b के अनुसार अपडेट करते हैं। ′ _L = b _l - η ′C _x / .b _l । फिर हम प्रशिक्षण इनपुट का एक और उदाहरण चुनते हैं और फिर से वज़न और ऑफ़सेट अपडेट करते हैं। और इसी तरह। इस प्रक्रिया को ऑनलाइन या वृद्धिशील शिक्षण के रूप में जाना जाता है। ऑनलाइन सीखने में एक समय (जैसे लोगों) पर इनपुट डेटा की एक प्रशिक्षण प्रति के आधार पर एनएस अध्ययन। 20 के मिनी-पैकेट आकार के साथ स्टोचैस्टिक ढाल वंश की तुलना में ऑनलाइन सीखने के फायदे और नुकसान क्या हैं?

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

संख्याओं को वर्गीकृत करने के लिए एक नेटवर्क को लागू करना

ठीक है, अब चलो एक प्रोग्राम लिखते हैं जो एमएनआईएसटी से स्टोचस्टिक ढाल वंश और प्रशिक्षण डेटा का उपयोग करके हस्तलिखित संख्याओं को पहचानना सीखता है। हम केवल 74 लाइनों से मिलकर अजगर 2.7 में एक छोटे कार्यक्रम के साथ ऐसा करेंगे! पहली जरूरत हमें MNIST डेटा डाउनलोड करने की है। यदि आप git का उपयोग करते हैं, तो आप उन्हें इस पुस्तक के भंडार से क्लोन करके प्राप्त कर सकते हैं:

git clone https://github.com/mnielsen/neural-networks-and-deep-learning.git

यदि नहीं, तो लिंक से कोड डाउनलोड करें ।

वैसे, जब मैंने पहले एमएनआईएसटीटी डेटा का उल्लेख किया था, तो मैंने कहा कि वे 60,000 प्रशिक्षण छवियों और 10,000 परीक्षण छवियों में विभाजित हैं। यह MNIST का आधिकारिक विवरण है। हम डेटा को थोड़ा अलग तरीके से तोड़ेंगे। हम सत्यापन छवियों को अपरिवर्तित छोड़ देंगे, लेकिन हम प्रशिक्षण सेट को दो भागों में विभाजित करेंगे: 50,000 चित्र, जिसे हम नेशनल असेंबली को प्रशिक्षित करने के लिए उपयोग करेंगे, और अतिरिक्त पुष्टि के लिए व्यक्तिगत 10,000 चित्र। हालांकि हम उनका उपयोग नहीं करेंगे, लेकिन बाद में वे हमारे लिए उपयोगी होंगे जब हम एनएस के कुछ हाइपर मापदंडों के विन्यास को समझेंगे - सीखने की गति, आदि, - जो हमारे एल्गोरिथ्म सीधे नहीं चुनते हैं। हालाँकि, corroborating data मूल MNIST विनिर्देश का हिस्सा नहीं है, कई इस तरह से MNIST का उपयोग करते हैं, और HC के क्षेत्र में डेटा corroborating का उपयोग आम है। अब, "एमएनआईएसटीटी प्रशिक्षण डेटा" की बात करते हुए, मैं मूल 50,000,000 नहीं बल्कि हमारे 50,000 कारितनोक का उल्लेख करूंगा।

MNIST डेटा के अलावा, हमें त्वरित रैखिक बीजगणितीय गणनाओं के लिए Numpy नामक एक अजगर पुस्तकालय की भी आवश्यकता है। यदि आपके पास यह नहीं है, तो आप इसे लिंक से ले सकते हैं।

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

 class Network(object): def __init__(self, sizes): self.num_layers = len(sizes) self.sizes = sizes self.biases = [np.random.randn(y, 1) for y in sizes[1:]] self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])] 

आकार सरणी में संबंधित परतों में न्यूरॉन्स की संख्या होती है। इसलिए, यदि हम पहली परत में दो न्यूरॉन्स के साथ एक नेटवर्क ऑब्जेक्ट बनाना चाहते हैं, तो दूसरी परत में तीन न्यूरॉन्स, और तीसरे में एक न्यूरॉन, हम इसे इस तरह लिखेंगे:

 net = Network([2, 3, 1]) 

नेटवर्क ऑब्जेक्ट में ऑफ़सेट्स और वेट्स को संख्यात्मक रूप से npy.random.randn के उपयोग से यादृच्छिक रूप से आरंभीकृत किया जाता है, जो 0 की गणितीय अपेक्षा के साथ एक गाऊसी वितरण उत्पन्न करता है और 1 का एक मानक विचलन है। यह यादृच्छिक अनुकूलन हमारे स्टोकेस्टिक ग्रेडिएंट डीसेंट एल्गोरिथम को एक प्रारंभिक बिंदु देता है। निम्नलिखित अध्यायों में हम वज़न और ऑफ़सेट्स को इनिशियलाइज़ करने के सबसे अच्छे तरीके पाएंगे, लेकिन अभी के लिए यह पर्याप्त है। ध्यान दें कि नेटवर्क इनिशियलाइज़ेशन कोड मानता है कि न्यूरॉन्स की पहली परत इनपुट होगी, और उन्हें एक पूर्वाग्रह असाइन नहीं करता है, क्योंकि उनका उपयोग केवल आउटपुट की गणना करने के लिए किया जाता है।

यह भी ध्यान दें कि ऑफ़सेट और वेट को नेम्पी मैट्रिस की एक सरणी के रूप में संग्रहीत किया जाता है। उदाहरण के लिए, net.weights [1] एक Numpy मैट्रिक्स है जो न्यूरॉन्स की दूसरी और तीसरी परतों को जोड़ने वाले भार को संग्रहीत करता है (यह पहली और दूसरी परत नहीं है, क्योंकि अजगर में सरणी के तत्वों की संख्या स्क्रैच से आती है)। चूंकि net.weights [1] लिखने में बहुत समय लगेगा, हम इस मैट्रिक्स को w के रूप में दर्शाते हैं। यह एक ऐसा मैट्रिक्स है जो w _jk दूसरी परत में kth न्यूरॉन और तीसरे में jth न्यूरॉन के बीच संबंध का वजन है। सूचकांकों जम्मू और कश्मीर का ऐसा क्रम अजीब लग सकता है - क्या उन्हें स्वैप करना अधिक तर्कसंगत नहीं होगा? लेकिन इस तरह के रिकॉर्ड का बड़ा फायदा यह होगा कि न्यूरॉन्स की तीसरी परत का सक्रियण वेक्टर प्राप्त होता है:

$$

$$a = = \ सिग्मा (वा + बी) \ टैग {22}$$

आइए इस सुंदर समृद्ध समीकरण को देखें। a न्यूरॉन्स की दूसरी परत का सक्रियण वेक्टर है। 'पाने के लिए, हम वेट मैट्रिक्स w से गुणा करते हैं, और विस्थापन वेक्टर बी जोड़ते हैं। फिर हम सिग्मॉइड by एलिमेंट को एलिमेंट के एलिमेंट को वेक्टर वा + बी (इसे फंक्शन का वेक्टराइजेशन कहते हैं) कहते हैं। यह सत्यापित करना आसान है कि समीकरण (22) एक सिग्माइड न्यूरॉन की गणना के लिए नियम (4) के समान परिणाम देता है।

व्यायाम

• घटक रूप में समीकरण (22) लिखें, और सुनिश्चित करें कि यह सिग्मेंट न्यूरॉन की गणना के लिए नियम (4) के समान परिणाम देता है।

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

 def sigmoid(z): return 1.0/(1.0+np.exp(-z)) 

ध्यान दें कि जब z पैरामीटर Numpy वेक्टर या सरणी होता है, तो Numpy स्वचालित रूप से सिग्मॉइड एलिमेंट-वार यानी वेक्टर रूप में लागू होगा।

नेटवर्क वर्ग के लिए एक प्रत्यक्ष प्रसार विधि जोड़ें, जो इनपुट के रूप में नेटवर्क से लेता है और संबंधित आउटपुट देता है। यह माना जाता है कि पैरामीटर a (n, 1) Numpy ndarray है, न कि कोई सदिश (n)। यहाँ n इनपुट न्यूरॉन्स की संख्या है। यदि आप वेक्टर (एन) का उपयोग करने की कोशिश करते हैं, तो आपको अजीब परिणाम मिलेंगे।

विधि प्रत्येक परत पर समीकरण (22) लागू करती है:

  def feedforward(self, a): """       "a"""" for b, w in zip(self.biases, self.weights): a = sigmoid(np.dot(w, a)+b) return a 

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

  def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None): """    -    . training_data –   "(x, y)",       .       .  test_data ,          ,     .     ,    . """ if test_data: n_test = len(test_data) n = len(training_data) for j in xrange(epochs): random.shuffle(training_data) mini_batches = [ training_data[k:k+mini_batch_size] for k in xrange(0, n, mini_batch_size)] for mini_batch in mini_batches: self.update_mini_batch(mini_batch, eta) if test_data: print "Epoch {0}: {1} / {2}".format( j, self.evaluate(test_data), n_test) else: print "Epoch {0} complete".format(j) 

training_data tuples "(x, y)" प्रशिक्षण इनपुट और वांछित आउटपुट का प्रतिनिधित्व करने वाली एक सूची है। युग और mini_batch_size चर सीखने के लिए युग की संख्या और उपयोग करने के लिए मिनी-पैकेट के आकार हैं। एटा - सीखने की गति,,। यदि test_data सेट है, तो प्रत्येक युग के बाद सत्यापन डेटा के खिलाफ नेटवर्क का मूल्यांकन किया जाएगा, और वर्तमान प्रगति प्रदर्शित की जाएगी। यह ट्रैकिंग प्रगति के लिए उपयोगी है, लेकिन काम को धीमा कर देता है।

कोड इस तरह काम करता है। प्रत्येक युग में, वह गलती से प्रशिक्षण डेटा को मिलाकर शुरू करता है, और फिर उन्हें सही आकार के मिनी-पैकेट में तोड़ देता है। यह प्रशिक्षण डेटा का एक नमूना बनाने का एक आसान तरीका है। फिर प्रत्येक mini_batch के लिए हम ढाल वंश का एक चरण लागू करते हैं। यह self.update_mini_batch कोड (mini_batch, eta) द्वारा किया जाता है, जो mini_batch में केवल प्रशिक्षण डेटा का उपयोग करके एकल ढाल वंशानुक्रम के अनुसार नेटवर्क वज़न और ऑफ़सेट अपडेट करता है। यहाँ update_mini_batch विधि के लिए कोड है:

  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) 

यह एक बैकप्रोपैगैस एल्गोरिथ्म को आमंत्रित करता है - एक लागत फ़ंक्शन के ढाल की गणना करने का एक त्वरित तरीका। इसलिए update_mini_batch केवल mini_batch से प्रत्येक प्रशिक्षण उदाहरण के लिए इन ग्रेडिएंट्स की गणना करता है, और फिर self.weights और self.biases को अपडेट करता है।

अब तक, मैं self.backprop के लिए कोड प्रदर्शित नहीं करूंगा। हम अगले अध्याय में बैकप्रॉपैगैशन के बारे में जानेंगे, और स्व.बैकप कोड होगा। अभी के लिए, मान लीजिए कि यह कहा गया है, प्रशिक्षण उदाहरण x से संबंधित लागत के लिए एक उपयुक्त ढाल लौटाता है।

चलो व्याख्यात्मक टिप्पणियों सहित पूरे कार्यक्रम को देखें। Self.backprop फ़ंक्शन के अपवाद के साथ, प्रोग्राम स्वयं के लिए बोलता है - मुख्य कार्य self.SGD और self.update_mini_batch द्वारा किया जाता है। स्व.बैकप्रॉप पद्धति ढाल को गणना करने के लिए कई अतिरिक्त कार्यों का उपयोग करती है, अर्थात् sigmoid_prime, जो कि सिग्मायॉइड के व्युत्पन्न की गणना करता है, और self.cost_derivative, जिसका मैं यहां वर्णन नहीं करूंगा। आप कोड और टिप्पणियों को देखकर उनके बारे में विचार कर सकते हैं। अगले अध्याय में हम उन पर अधिक विस्तार से विचार करेंगे। ध्यान रखें कि जब प्रोग्राम लंबा लगता है, तो अधिकांश कोड ऐसी टिप्पणियाँ होती हैं जो समझने में आसान बनाती हैं। वास्तव में, कार्यक्रम में कोड की केवल 74 गैर-लाइनें शामिल हैं - खाली नहीं और टिप्पणियां नहीं। सभी कोड GitHub पर उपलब्ध है ।

 """ network.py ~~~~~~~~~~           .      .     ,    .   ,       . """ ####  #   import random #   import numpy as np class Network(object): def __init__(self, sizes): """  sizes      .  ,      Network      ,     ,     ,    ,  [2, 3, 1].               0    1. ,      ,       ,        . """ self.num_layers = len(sizes) self.sizes = sizes self.biases = [np.random.randn(y, 1) for y in sizes[1:]] self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])] def feedforward(self, a): """   ,  ``a`` -  .""" for b, w in zip(self.biases, self.weights): a = sigmoid(np.dot(w, a)+b) return a def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None): """    -    . training_data –   "(x, y)",       .       .  test_data ,          ,     .     ,    . """ if test_data: n_test = len(test_data) n = len(training_data) for j in xrange(epochs): random.shuffle(training_data) mini_batches = [ training_data[k:k+mini_batch_size] for k in xrange(0, n, mini_batch_size)] for mini_batch in mini_batches: self.update_mini_batch(mini_batch, eta) if test_data: print "Epoch {0}: {1} / {2}".format( j, self.evaluate(test_data), n_test) else: print "Epoch {0} complete".format(j) 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)] 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 evaluate(self, test_data): """    ,      .    –          .""" test_results = [(np.argmax(self.feedforward(x)), y) for (x, y) in test_data] return sum(int(x == y) for (x, y) in test_results) 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)) 

कार्यक्रम हस्तलिखित संख्याओं को कितनी अच्छी तरह से पहचानता है? चलिए MNIST डेटा लोड करके शुरू करते हैं। हम इसे छोटे हेल्पर प्रोग्राम mnist_loader.py का उपयोग करके करेंगे, जिसका मैं नीचे वर्णन करूंगा। अजगर शेल में निम्नलिखित कमांड चलाएँ:

 >>> import mnist_loader >>> training_data, validation_data, test_data = \ ... mnist_loader.load_data_wrapper() 

यह, ज़ाहिर है, एक अलग कार्यक्रम में किया जा सकता है, लेकिन यदि आप एक किताब के समानांतर काम करते हैं, तो यह आसान होगा।

MNIST डेटा डाउनलोड करने के बाद, 30 छिपे हुए न्यूरॉन्स का एक नेटवर्क सेट करें। हम ऊपर वर्णित कार्यक्रम को आयात करने के बाद करेंगे, जिसे नेटवर्क कहा जाता है:

 >>> import network >>> net = network.Network([784, 30, 10]) 

अंत में, हम 30 युगों के प्रशिक्षण डेटा पर प्रशिक्षण के लिए स्टोकेस्टिक ग्रेडिएंट वंश का उपयोग करते हैं, 10 के मिनी-पैकेट आकार के साथ, और of = 3.0 की सीखने की गति।

 >>> net.SGD(training_data, 30, 10, 3.0, test_data=test_data) 

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

Epoch 0: 9129 / 10000
Epoch 1: 9295 / 10000
Epoch 2: 9348 / 10000
...
Epoch 27: 9528 / 10000
Epoch 28: 9542 / 10000
Epoch 29: 9534 / 10000

यह पता चला है कि प्रशिक्षित नेटवर्क अधिकतम 95 - 95.42% के सही वर्गीकरण का प्रतिशत देता है! एक बहुत ही पहला प्रयास होनहार। मैं आपको चेतावनी देता हूं कि आपका कोड आवश्यक रूप से ठीक उसी परिणाम का उत्पादन नहीं करेगा, क्योंकि हम नेटवर्क को यादृच्छिक भार और ऑफसेट के साथ आरंभ करते हैं। इस अध्याय के लिए, मैंने तीन प्रयासों में से सर्वश्रेष्ठ को चुना है।

आइए, छिपे हुए न्यूरॉन्स की संख्या को 100 में बदलकर प्रयोग को फिर से शुरू करें। पहले की तरह, यदि आप कोड को पढ़ने के समान समय पर चलाते हैं, तो ध्यान रखें कि इसमें काफी समय लगता है (मेरी मशीन पर, प्रत्येक युग में कई सेकंड लगते हैं), इसलिए समानांतर में पढ़ना बेहतर है। कोड निष्पादन के साथ।

 >>> net = network.Network([784, 100, 10]) >>> net.SGD(training_data, 30, 10, 3.0, test_data=test_data) 

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

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

बेशक, इस तरह की सटीकता को प्राप्त करने के लिए, मुझे सीखने के लिए निश्चित संख्या में मिनी, पैकेज के आकार और सीखने की गति to का चयन करना था। जैसा कि मैंने ऊपर उल्लेख किया है, उन्हें हमारे नेशनल असेंबली के हाइपरपरमेटर्स कहा जाता है - उन्हें सरल मापदंडों (भार और ऑफसेट) से अलग करने के लिए जिसे एल्गोरिथ्म प्रशिक्षण के दौरान समायोजित करता है। यदि हम हाइपरपरमेटर्स को खराब तरीके से चुनते हैं, तो हम खराब परिणाम प्राप्त करेंगे। उदाहरण के लिए, मान लीजिए कि हमने सीखने की दर चुन ली है 001 = 0.001:

 >>> net = network.Network([784, 100, 10]) >>> net.SGD(training_data, 30, 10, 0.001, test_data=test_data) 

परिणाम बहुत कम प्रभावशाली हैं:

Epoch 0: 1139 / 10000
Epoch 1: 1136 / 10000
Epoch 2: 1135 / 10000
...
Epoch 27: 2101 / 10000
Epoch 28: 2123 / 10000
Epoch 29: 2142 / 10000

हालाँकि, आप देख सकते हैं कि नेटवर्क दक्षता धीरे-धीरे समय के साथ बढ़ रही है। इससे पता चलता है कि आप सीखने की गति को बढ़ाने की कोशिश कर सकते हैं, उदाहरण के लिए, 0.01 तक। इस मामले में, परिणाम बेहतर होंगे, जो गति को और बढ़ाने की आवश्यकता को इंगित करता है (यदि परिवर्तन स्थिति में सुधार करता है, तो आगे बदल सकता है!)। यदि आप ऐसा कई बार करते हैं, तो हम अंततः (= 1.0 (और कभी-कभी 3.0) पर भी पहुंचेंगे, जो हमारे पहले के प्रयोगों के करीब है। इसलिए, हालांकि हमने शुरू में हाइपरपरमेटर्स को खराब तरीके से चुना था, कम से कम हमने मापदंडों की हमारी पसंद को बेहतर बनाने में सक्षम होने के लिए पर्याप्त जानकारी एकत्र की।

सामान्य तौर पर, NA डिबगिंग एक जटिल मामला है। यह विशेष रूप से तब होता है जब प्रारंभिक हाइपरपामेटर्स की पसंद ऐसे परिणाम उत्पन्न करती है जो यादृच्छिक शोर से अधिक नहीं होते हैं। मान लीजिए कि हम 30 न्यूरॉन्स की एक सफल वास्तुकला का उपयोग करने की कोशिश करते हैं, लेकिन सीखने की गति को 100.0 में बदल देते हैं:

 >>> net = network.Network([784, 30, 10]) >>> net.SGD(training_data, 30, 10, 100.0, test_data=test_data) 

अंत में, यह पता चला कि हम बहुत दूर चले गए और बहुत अधिक गति ले ली:

Epoch 0: 1009 / 10000
Epoch 1: 1009 / 10000
Epoch 2: 1009 / 10000
Epoch 3: 1009 / 10000
...
Epoch 27: 982 / 10000
Epoch 28: 982 / 10000
Epoch 29: 982 / 10000

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

इससे यह एक सबक सीखने के लायक है कि एनएस को डिबग करना एक तुच्छ कार्य नहीं है, और यह, नियमित प्रोग्रामिंग की तरह, यह कला का हिस्सा है। NS से ​​अच्छे परिणाम प्राप्त करने के लिए आपको इस डिबगिंग कला को सीखना चाहिए। सामान्य तौर पर, हमें अच्छे हाइपरपैरामीटर और अच्छे आर्किटेक्चर का चयन करने के लिए एक अनुमान विकसित करने की आवश्यकता है। हम इस पुस्तक पर विस्तार से चर्चा करेंगे, जिसमें यह भी शामिल है कि कैसे मैंने उपरोक्त हाइपरपैरमीटर का चयन किया।

व्यायाम

• क्रमशः 784 और 10 न्यूरॉन्स के साथ, केवल दो परतों का एक नेटवर्क बनाने की कोशिश करें - इनपुट और आउटपुट, छिपे हुए बिना। स्टोचस्टिक ढाल वंश के साथ नेटवर्क को प्रशिक्षित करें। आपको कौन सी वर्गीकरण सटीकता प्राप्त है?

मैंने पहले MNIST डेटा लोड करने के विवरण को छोड़ दिया था। यह काफी सरलता से होता है। यहाँ तस्वीर को पूरा करने के लिए कोड है। टिप्पणियों में डेटा संरचनाओं का वर्णन किया गया है - सब कुछ सरल है, गुच्छेदार और Numpy ndarray ऑब्जेक्ट्स के arrays (यदि आप ऐसी वस्तुओं से परिचित नहीं हैं, तो उन्हें वैक्टर के रूप में कल्पना करें)।

 """ mnist_loader ~~~~~~~~~~~~      MNIST.       ``load_data``  ``load_data_wrapper``.  , ``load_data_wrapper`` -  ,     . """ ####  #  import cPickle import gzip #  import numpy as np def load_data(): """  MNIST   ,  ,    . ``training_data``      .    .  numpy ndarray  50 000 .   –     numpy ndarray  784 ,  28 * 28 = 784    MNIST.  –  numpy ndarray  50 000 .   –   0  9   ,    . ``validation_data``  ``test_data`` ,    10 000 .    ,           ``training_data``.    - ``load_data_wrapper()``. """ f = gzip.open('../data/mnist.pkl.gz', 'rb') training_data, validation_data, test_data = cPickle.load(f) f.close() return (training_data, validation_data, test_data) def load_data_wrapper(): """ ,  ``(training_data, validation_data, test_data)``.   ``load_data``,         .  , ``training_data`` -    50 000    , ``(x, y)``. ``x`` -  784- numpy.ndarray,   . ``y`` -  10- numpy.ndarray,   ,     ``x``. ``validation_data``  ``test_data`` -  ,   10 000    , ``(x, y)``. ``x`` -  784- numpy.ndarray,   ,  ``y`` -   ,  ,   ( ),  ``x``. ,  ,           .         .""" tr_d, va_d, te_d = load_data() training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]] training_results = [vectorized_result(y) for y in tr_d[1]] training_data = zip(training_inputs, training_results) validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]] validation_data = zip(validation_inputs, va_d[1]) test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]] test_data = zip(test_inputs, te_d[1]) return (training_data, validation_data, test_data) def vectorized_result(j): """ 10-    1.0   j     .      (0..9)     .""" e = np.zeros((10, 1)) e[j] = 1.0 return e 

मैंने कहा कि हमारा कार्यक्रम बहुत अच्छे परिणाम प्राप्त कर रहा है। इसका क्या मतलब है? क्या की तुलना में अच्छा है? कुछ सरल, बुनियादी परीक्षणों के परिणाम प्राप्त करना उपयोगी है, जिनके साथ आप यह समझने के लिए तुलना कर सकते हैं कि "अच्छे परिणाम" का क्या मतलब है। सबसे सरल आधार स्तर, निश्चित रूप से, एक यादृच्छिक अनुमान होगा। यह लगभग 10% मामलों में किया जा सकता है। और हम एक बेहतर परिणाम दिखाते हैं!

कम तुच्छ आधार स्तर के बारे में क्या? आइए देखें कि तस्वीर कितनी गहरी है। उदाहरण के लिए, चित्र 2 आमतौर पर छवि 1 की तुलना में गहरा होगा, केवल इसलिए कि इसमें अधिक गहरे पिक्सेल हैं, जैसा कि नीचे दिए गए उदाहरणों में देखा गया है:



यह निम्नानुसार है कि हम प्रत्येक अंक के लिए 0 से 9 तक औसत अंधेरे की गणना कर सकते हैं। जब हम एक नई छवि प्राप्त करते हैं, तो हम इसके अंधेरे की गणना करते हैं, और हम अनुमान लगाते हैं कि यह निकटतम औसत अंधेरे के साथ एक आंकड़ा दिखाता है। यह एक सरल प्रक्रिया है जिसे प्रोग्राम करना आसान है, इसलिए मैं कोड नहीं लिखूंगा - अगर दिलचस्पी है, तो यह GitHub पर निहित है । लेकिन यादृच्छिक अनुमानों की तुलना में यह एक गंभीर सुधार है - कोड 10,000 छवियों में से 2,225 को सही ढंग से पहचानता है, अर्थात यह 22.25% की सटीकता देता है।

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

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

लेकिन यह सब नहीं है।स्किकिट-लर्न से 10 000 में से 9 9 9 परिणाम डिफ़ॉल्ट सेटिंग्स के लिए निर्दिष्ट किया गया है। एसवीएम में कई पैरामीटर हैं जिन्हें ट्यून किया जा सकता है, और आप उन मापदंडों की तलाश कर सकते हैं जो इस परिणाम को बेहतर बनाते हैं। मैं विवरण में नहीं जाऊंगा, उन्हें एंड्रियास मुलर द्वारा लेख में पढ़ा जा सकता है । उन्होंने दिखाया कि मापदंडों को अनुकूलित करने के लिए काम करने से, कम से कम 98.5% की सटीकता प्राप्त करना संभव है। दूसरे शब्दों में, एक अच्छी तरह से तैयार एसवीएम 70 त्रुटियों में से केवल एक अंक बनाता है। एक अच्छा परिणाम! क्या NA अधिक हासिल कर सकता है?

यह पता चला कि वे कर सकते हैं। आज, एक अच्छी तरह से तैयार एनएस, एमएनआईएसटी समाधान में किसी भी अन्य ज्ञात तकनीक को पछाड़ देती है, जिसमें एसवीएम भी शामिल है। 2013 के लिए रिकॉर्ड10,000 छवियों में से 9,979 को सही ढंग से वर्गीकृत किया गया है। और हम इस पुस्तक में इसके लिए उपयोग की जाने वाली अधिकांश तकनीकों को देखेंगे। सटीकता का यह स्तर मानव के करीब है, और शायद इससे भी अधिक है, क्योंकि एमएनआईएसटी से कई छवियां मनुष्यों के लिए भी समझने में मुश्किल हैं, उदाहरण के लिए:



मुझे लगता है कि आप सहमत होंगे कि उन्हें वर्गीकृत करना मुश्किल है! MNIST डेटासेट में ऐसी छवियों के साथ, यह आश्चर्यजनक है कि एनएस 21 को छोड़कर सभी 10,000 छवियों को सही ढंग से पहचान सकता है। आमतौर पर, प्रोग्रामर मानते हैं कि इस तरह के जटिल कार्य को हल करने के लिए एक जटिल एल्गोरिथ्म की आवश्यकता होती है। लेकिन यहां तक ​​कि एनएस काम पर हैरिकॉर्ड धारक काफी सरल एल्गोरिदम का उपयोग करता है, जो कि इस अध्याय में हमारे द्वारा जांच की गई छोटी विविधताएँ हैं। प्रशिक्षण डेटा के आधार पर प्रशिक्षण के दौरान सभी जटिलता स्वचालित रूप से प्रकट होती है। एक अर्थ में, हमारे परिणामों और अधिक जटिल कार्यों में निहित नैतिकता कुछ कार्यों के लिए है

जटिल एल्गोरिथ्म ≤ सरल प्रशिक्षण एल्गोरिथ्म + अच्छा प्रशिक्षण डेटा

गहन सीखने के लिए

यद्यपि हमारा नेटवर्क प्रभावशाली प्रदर्शन दिखा रहा है, यह एक रहस्यमय तरीके से हासिल किया गया है। वेट और मिक्सिंग नेटवर्क का स्वतः पता लगाया जाता है। इसलिए, हमारे पास तैयार विवरण नहीं है कि नेटवर्क यह कैसे करता है। क्या हस्तलिखित संख्याओं के नेटवर्क द्वारा वर्गीकरण के मूल सिद्धांतों को समझने का कोई तरीका है? और क्या यह संभव है, उन्हें दिया, परिणाम में सुधार करने के लिए?

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

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







यह समस्या उसी तरह से लिखी जा सकती है जैसे कि लिखावट की मान्यता: एनएस के लिए इनपुट के रूप में छवि पिक्सेल का उपयोग करना, और एनएस का उत्पादन एक न्यूरॉन होगा जो कहेगा, "हाँ, यह एक चेहरा है", या "नहीं, यह एक चेहरा नहीं है। "।

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

यदि इनमें से कुछ सवालों के जवाब सकारात्मक हैं, या यहां तक ​​कि "शायद हां", तो हम निष्कर्ष निकालते हैं कि छवि का एक चेहरा हो सकता है। इसके विपरीत, यदि उत्तर नहीं हैं, तो शायद कोई व्यक्ति नहीं है।

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


आयतों में उप-मुखौटे होते हैं: क्या आंखों की छवि ऊपरी बाएं कोने में है? क्या ऊपरी दाएं कोने में एक आंख है? क्या कोई मध्य नाक है? क्या बीच में कोई मुंह है? क्या शीर्ष पर बाल हैं? और इसी तरह।

यह संभव है कि सबनेट को घटकों में भी विघटित किया जा सकता है। ऊपरी बाएँ कोने में एक आँख होने का प्रश्न उठाएँ। इसे इस तरह के सवालों से अलग किया जा सकता है: "क्या कोई आइब्रो है?", "क्या कोई पलकें हैं?", "क्या कोई शिष्य है?" और इसी तरह। बेशक, प्रश्नों में स्थान के बारे में जानकारी होनी चाहिए - "क्या पुतली के ऊपर ऊपरी बाईं ओर स्थित भौं है?", और इसी तरह - लेकिन चलो इसे अभी के लिए सरल करें। इसलिए, नेटवर्क जो आंख की उपस्थिति के बारे में सवाल का जवाब देता है, उसे घटकों में विभाजित किया जा सकता है:


"क्या एक भौं है?", "क्या पलकें हैं?", "क्या कोई शिष्य है?"

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

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

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

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