तंत्रिका नेटवर्क और गहरी सीख: एक ऑनलाइन ट्यूटोरियल, अध्याय 6, भाग 1: गहरी शिक्षा

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

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

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



हम उथले नेटवर्क के साथ दृढ़ नेटवर्क की अपनी समीक्षा शुरू करते हैं, जिसका उपयोग हम पहले पुस्तक में इस समस्या को हल करने के लिए करते थे। कई चरणों में हम अधिक से अधिक शक्तिशाली नेटवर्क बनाएंगे। रास्ते के साथ, हमें कई शक्तिशाली तकनीकों का पता चल जाएगा: संकल्प, पूलिंग, GPU का उपयोग करके हमने उथले नेटवर्क के साथ प्रशिक्षण की मात्रा को गंभीरता से बढ़ाने के लिए, ड्रॉपआउट तकनीक का उपयोग करते हुए प्रशिक्षण डेटा के एल्गोरिथम विस्तार (ओवरफिटिंग को कम करने के लिए) का उपयोग किया। (रिट्रेस्टिंग को कम करने के लिए भी), नेटवर्क और अन्य लोगों के ज़रिए। नतीजतन, हम एक ऐसी प्रणाली के लिए आएंगे जिसकी क्षमता लगभग मानव स्तर पर है। 10,000 एमएनआईएसटी सत्यापन छवियों में से - जो कि प्रशिक्षण के दौरान सिस्टम ने नहीं देखा था - यह 9967 को सही ढंग से पहचानने में सक्षम होगा। और यहां उन चित्रों में से कुछ हैं जिन्हें सही ढंग से मान्यता नहीं दी गई थी। ऊपरी दाएं कोने में सही विकल्प हैं; हमारे कार्यक्रम ने जो दिखाया वह निचले दाएं कोने में दर्शाया गया है।



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

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

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

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

दृढ़ तंत्रिका नेटवर्क का परिचय

पिछले अध्यायों में, हमने अपने तंत्रिका नेटवर्क को सिखाया कि हस्तलिखित संख्याओं की छवियों को पहचानना बहुत अच्छा है:



हमने यह नेटवर्क का उपयोग करके किया था जिसमें पड़ोसी परतें एक दूसरे से पूरी तरह से जुड़ी हुई थीं। यही है, नेटवर्क का प्रत्येक न्यूरॉन पड़ोसी परत के प्रत्येक न्यूरॉन के साथ जुड़ा हुआ था:



विशेष रूप से, हमने इनपुट लेयर के संबंधित न्यूरॉन के मान के रूप में छवि में प्रत्येक पिक्सेल की तीव्रता को एन्कोड किया। आकार में 28x28 पिक्सेल की छवियों के लिए, इसका मतलब है कि नेटवर्क में 784 (= 28 × 28) आने वाले न्यूरॉन्स होंगे। फिर हमने नेटवर्क के वजन और ऑफसेट को प्रशिक्षित किया ताकि नेटवर्क आउटपुट (ऐसी उम्मीद थी) ने आने वाली छवि को सही ढंग से पहचाना: '0', '1', '2', ..., '8', या '9'।

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

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

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

स्थानीय ग्रहणशील क्षेत्र

पूरी तरह से जुड़े नेटवर्क परतों में, इनपुट परतें न्यूरॉन्स की ऊर्ध्वाधर लाइनों द्वारा इंगित की जाती हैं। एसएनए में, 28x28 के आयाम के साथ न्यूरॉन्स के एक वर्ग के रूप में इनपुट परत का प्रतिनिधित्व करना अधिक सुविधाजनक है, जिनमें से मान 28x28 छवि के पिक्सेल तीव्रता के अनुरूप हैं:



हमेशा की तरह, हम आने वाले पिक्सेल को छिपे हुए न्यूरॉन्स की एक परत के साथ जोड़ते हैं। हालाँकि, हम प्रत्येक पिक्सेल को प्रत्येक छिपे हुए न्यूरॉन के साथ नहीं जोड़ेंगे। हम आने वाली छवि के छोटे, स्थानीय क्षेत्रों में संचार व्यवस्थित करते हैं।

अधिक सटीक रूप से, पहली छिपी हुई परत का प्रत्येक न्यूरॉन आने वाले न्यूरॉन्स के एक छोटे हिस्से से जुड़ा होगा, उदाहरण के लिए, 25 आने वाले पिक्सल के अनुरूप 5x5 क्षेत्र। तो, कुछ छिपे हुए न्यूरॉन के लिए, कनेक्शन इस तरह दिख सकता है:



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

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



स्थानीय ग्रहणशील क्षेत्र एक पिक्सेल को दाईं ओर (एक न्यूरॉन) पर ले जाएं ताकि इसे दूसरे छिपे हुए न्यूरॉन के साथ जोड़ा जा सके:



तो हम पहली छिपी हुई परत का निर्माण करते हैं। ध्यान दें कि यदि हमारी आने वाली छवि 28x28 है और स्थानीय ग्रहणशील क्षेत्र 5x5 है, तो छिपी हुई परत में 24x24 न्यूरॉन्स होंगे। ऐसा इसलिए है क्योंकि हम केवल स्थानीय रिसेप्टिव फ़ील्ड को 23 न्यूरॉन्स द्वारा दाईं ओर (या नीचे) स्थानांतरित कर सकते हैं, और फिर हम आने वाली छवि के दाईं ओर (या नीचे) का सामना करेंगे।

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

कुल वजन और ऑफसेट

मैंने उल्लेख किया है कि प्रत्येक छिपे हुए न्यूरॉन में एक ऑफसेट और 5x5 वज़न है जो इसके स्थानीय ग्रहणशील क्षेत्र से जुड़ा हुआ है। लेकिन मैंने यह उल्लेख नहीं किया कि हम सभी 24x24 छिपे हुए न्यूरॉन्स के लिए समान वजन और विस्थापन का उपयोग करेंगे। दूसरे शब्दों में, छिपे हुए न्यूरॉन j, k के लिए, आउटपुट इसके बराबर होगा:

$$

$$\ sigma \ left (b + \ sum_ {l = 0} ^ 4 \ sum_ {m = 0} ^ 4 w_ {l, m} a_ {j + l, k + m} \ right) \ tag {125}$$

यहाँ σ सक्रियण फ़ंक्शन है, संभवतः पिछले अध्यायों से एक सिग्मॉइड है। बी कुल ऑफसेट मूल्य है। डब्ल्यू _{एल, एम} - कुल वजन की सरणी 5x5। और अंत में, _{x, y} स्थिति x पर इनपुट सक्रियण को दर्शाता है।

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

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

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



उदाहरण 3 सुविधा मानचित्र दिखाता है। प्रत्येक कार्ड 5x5 कुल वजन और एक सामान्य ऑफसेट के सेट द्वारा निर्धारित किया जाता है। नतीजतन, ऐसा नेटवर्क तीन अलग-अलग प्रकार के संकेतों को पहचान सकता है, और प्रत्येक चिह्न छवि के किसी भी हिस्से में पाया जा सकता है।

मैंने सादगी के लिए तीन विशेषता कार्ड बनाए हैं। व्यवहार में, SNA अधिक (संभवतः बहुत अधिक) सुविधा मानचित्रों का उपयोग कर सकता है। शुरुआती SNS में से एक, LeNet-5 में 6 फीचर कार्ड का उपयोग किया गया था, जिनमें से प्रत्येक MNX अंकों को पहचानने के लिए 5x5 ग्रहणशील क्षेत्र से जुड़ा था। इसलिए, उपरोक्त उदाहरण LeNet-5 के समान है। उदाहरणों में कि हम स्वतंत्र रूप से और विकसित होंगे, हम 20 और 40 फ़ीचर कार्ड वाले दृढ़ परतों का उपयोग करेंगे। आइए उन संकेतों पर एक त्वरित नज़र डालें जिनकी हम जाँच करेंगे:



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

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

सामान्य वज़न और ऑफसेट का बड़ा लाभ यह है कि यह SNA के लिए उपलब्ध मापदंडों की संख्या को काफी कम कर देता है। प्रत्येक फ़ीचर मैप के लिए, हमें 5 × 5 = 25 कुल वज़न और एक सामान्य ऑफसेट की आवश्यकता होती है। इसलिए, प्रत्येक सुविधा मानचित्र के लिए 26 पैरामीटर आवश्यक हैं। यदि हमारे पास 20 फ़ीचर मैप हैं, तो कुल मिलाकर हमारे पास 20 × 26 = 520 पैरामीटर होंगे जो कन्वेक्शन लेयर को परिभाषित करते हैं। तुलना के लिए, मान लें कि हमारे पास 28 × 28 = 784 आवक न्यूरॉन्स और अपेक्षाकृत मामूली 30 छिपे हुए न्यूरॉन्स के साथ एक पूरी तरह से जुड़ी हुई पहली परत है - हमने पहले कई उदाहरणों में इस योजना का उपयोग किया था। यह 784 × 30 वज़न, साथ ही 30 ऑफ़सेट, कुल 23,550 पैरामीटर निकला। दूसरे शब्दों में, एक पूरी तरह से जुड़ी परत में एक दृढ़ परत की तुलना में 40 गुना अधिक पैरामीटर होगा।

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

वैसे, "दृढ़" का नाम समीकरण (125) में ऑपरेशन से आता है, जिसे कभी-कभी कनवल्शन भी कहा जाता है । अधिक सटीक रूप से, कभी-कभी लोग इस समीकरण को ¹ = b (b + w ^{0 0} ) के रूप में लिखते हैं, जहां ¹ एक फीचर कार्ड के आउटपुट एक्टिविटीज के सेट को दर्शाता है, ⁰ - इनपुट एक्टिविटीज का एक सेट, और * एक कनफर्मेशन ऑपरेशन कहलाता है। हम दीक्षांत के गणित में गहरी खुदाई नहीं करेंगे, इसलिए आपको इस संबंध में विशेष रूप से चिंता करने की आवश्यकता नहीं है। लेकिन यह जानने लायक है कि नाम कहां से आया है।

पूलिंग परतें

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

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

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



चूंकि दृढ़ परत के न्यूरॉन्स का उत्पादन 24x24 मान देता है, खींचने के बाद हमें 12x12 न्यूरॉन्स मिलते हैं।

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



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

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

ऊपर जा रहा है

अब हम सभी सूचनाओं को एक साथ ला सकते हैं और एक पूर्ण SNA प्राप्त कर सकते हैं। यह उस वास्तुकला के समान है जिसकी हमने हाल ही में समीक्षा की है, हालांकि, इसमें MNIST अंकों ('0', '1', '2', ..) के 10 संभावित मानों के अनुरूप 10 आउटपुट न्यूरॉन्स की एक अतिरिक्त परत



होती है : नेटवर्क का उपयोग 28x286 न्यूरॉन्स के साथ शुरू होता है। MNIST छवि की पिक्सेल तीव्रता को एनकोड करने के लिए। उसके बाद एक ग्रहणशील परत आती है जो स्थानीय ग्रहणशील क्षेत्रों का उपयोग करती है 5x5 और 3 फ़ीचर मानचित्र। परिणाम 3x24x24 छिपे हुए लक्षण न्यूरॉन्स की एक परत है। अगला चरण तीन फ़ीचर मानचित्रों में से प्रत्येक पर 2x2 क्षेत्रों पर लागू एक अधिकतम पूलिंग परत है। परिणाम 3x12x12 छिपे हुए लक्षण न्यूरॉन्स की एक परत है।

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

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

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

कार्य

• . (BP1)-(BP4). , , - , . ?

हमने एसएनए के पीछे के विचारों पर चर्चा की। आइए देखें कि कुछ एसएनए को लागू करने और उन्हें एमएनआईएसटी अंक वर्गीकरण समस्या पर लागू करने के अभ्यास में कैसे काम करते हैं। हम network3.py प्रोग्राम का उपयोग करेंगे, पिछले चैप्टर्स में बनाए गए network.py और network2.py प्रोग्राम्स का एक बेहतर संस्करण। M3 डेनिल और क्रिस ओलाह के अपवाद के कार्यान्वयन से नेटवर्क 3 थ्रेडो प्रोग्राम थीनो लाइब्रेरी डॉक्यूमेंटेशन (विशेष रूप से, LeNet-5 कार्यान्वयन ) के विचारों का उपयोग करता है । प्रोग्राम कोड GitHub पर उपलब्ध है। अगले भाग में, हम network3.py प्रोग्राम के कोड का अध्ययन करेंगे, और इस खंड में हम इसे SNA बनाने के लिए एक पुस्तकालय के रूप में उपयोग करेंगे।

नेटवर्क थिंकपैड और नेटवर्क 2 ओडोम प्रोग्राम्स को नेम्पी मैट्रिक्स लाइब्रेरी का उपयोग करके अजगर में लिखा गया था। उन्होंने पहले सिद्धांतों के आधार पर काम किया, और वापस प्रसार, स्टोचस्टिक ग्रेडिएंट वंश, आदि के सबसे विस्तृत विवरण तक पहुंच गए। लेकिन अब, जब हम इन विवरणों को समझते हैं, तो network3.py के लिए हम थीनो मशीन लर्निंग लाइब्रेरी ( इसके विवरण के साथ वैज्ञानिक कार्य देखें ) का उपयोग करेंगे। एनए के लिए लोकप्रिय पुस्तकालयों के दिल में थेनो भी झूठ Pylearn2 और keras , साथ ही Caffe और मशाल ।

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

पुस्तक के समानांतर काम करने के लिए, आपको अपने सिस्टम पर थीनो को स्थापित करने की आवश्यकता है। ऐसा करने के लिए, प्रोजेक्ट होम पेज पर दिए गए निर्देशों का पालन करें। उदाहरण लिखने और लॉन्च करने के समय, थीनो 0.7 उपलब्ध था। मैंने मैक ओएस एक्स योसेमाइट पर कुछ प्रयोगों को बिना जीपीयू के चलाया। एक NVIDIA GPU के साथ Ubuntu 14.04 पर कुछ। और कुछ वहाँ हैं, और वहाँ। Network3.py शुरू करने के लिए, कोड को सही या गलत में GPU ध्वज सेट करें। इसके अलावा, निम्न निर्देश आपको अपने GPU पर Theano चलाने में मदद कर सकते हैं । प्रशिक्षण सामग्री ऑनलाइन खोजना आसान है। यदि आपका अपना GPU नहीं है, तो आप Amazon Web Services EC2 G2 की ओर देख सकते हैं। लेकिन एक GPU के साथ भी, हमारा कोड बहुत जल्दी काम नहीं करेगा। कई प्रयोग कुछ मिनटों से कई घंटों तक चले जाएंगे। एक ही सीपीयू में उनमें से सबसे जटिल को कई दिनों तक निष्पादित किया जाएगा। पिछले अध्यायों की तरह, मैं प्रयोग शुरू करने की सलाह देता हूं और समय-समय पर इसके संचालन की जांच करता रहता हूं। एक GPU का उपयोग किए बिना, मैं सुझाव देता हूं कि आप सबसे जटिल प्रयोगों के लिए प्रशिक्षण युग की संख्या कम करें।

तुलना के लिए बुनियादी परिणाम प्राप्त करने के लिए, आइए एक उथली वास्तुकला के साथ शुरू करें जिसमें एक छिपी हुई परत है जिसमें 100 छिपे हुए न्यूरॉन्स हैं। हम 60 युगों का अध्ययन करेंगे, सीखने की गति का उपयोग करेंगे as = 0.1, मिनी-पैकेज का आकार 10 है, और हम नियमितीकरण के साथ अध्ययन करेंगे।

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

>>> import network3 >>> from network3 import Network >>> from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer >>> training_data, validation_data, test_data = network3.load_data_shared() >>> mini_batch_size = 10 >>> net = Network([ FullyConnectedLayer(n_in=784, n_out=100), SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size) >>> net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data) 

सबसे अच्छी वर्गीकरण सटीकता 97.80% थी। यह वर्गीकरण सटीकता test_data है, जो प्रशिक्षण युग से अनुमानित है, जिसमें हमने सत्यापन_डेटा से डेटा के लिए सर्वश्रेष्ठ वर्गीकरण सटीकता प्राप्त की है। सटीकता मूल्यांकन के बारे में निर्णय लेने के लिए मान्य डेटा का उपयोग करने से मुकरने से बचने में मदद मिलती है। फिर हम ऐसा करेंगे। आपके परिणाम थोड़े भिन्न हो सकते हैं, क्योंकि नेटवर्क वज़न और ऑफ़सेट यादृच्छिक रूप से आरंभिक होते हैं।

97.80% की सटीकता अध्याय 3 में प्राप्त 98.04% की सटीकता के बहुत करीब है, समान नेटवर्क वास्तुकला और प्रशिक्षण हाइपरपामेटर्स का उपयोग करते हुए। विशेष रूप से, दोनों उदाहरण 100 छिपी न्यूरॉन्स युक्त एक छिपी हुई परत के साथ उथले नेटवर्क का उपयोग करते हैं। दोनों नेटवर्क 10 के मिनी-पैकेट आकार और 0.1 = 0.1 के सीखने की दर के साथ 60 युग सीखते हैं।

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

क्या हम एक गहरी नेटवर्क वास्तुकला का उपयोग करके परिणामों में सुधार कर सकते हैं?

नेटवर्क के आरंभ में, एक संकेंद्रित परत डालकर शुरू करते हैं। हम स्थानीय ग्रहणशील क्षेत्र 5x5, 1 की लंबाई और 20 फ़ीचर कार्ड का उपयोग करेंगे। हम 2x2 पूलिंग विंडो का उपयोग करके सुविधाओं के संयोजन के लिए एक अधिकतम पूलिंग परत भी डालेंगे। इसलिए समग्र नेटवर्क आर्किटेक्चर उसी के समान होगा जिसे हमने पिछले अनुभाग में चर्चा की थी, लेकिन एक अतिरिक्त पूरी तरह से जुड़े परत के साथ:



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

आइए ऐसे नेटवर्क को प्रशिक्षित करें, और देखें कि यह कैसे व्यवहार करता है।

 >>> net = Network([ ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2)), FullyConnectedLayer(n_in=20*12*12, n_out=100), SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size) >>> net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data) 

हमें 98.78% की सटीकता प्राप्त होती है, जो पिछले परिणामों की तुलना में काफी अधिक है। हमने त्रुटि को एक तिहाई से अधिक घटा दिया - एक उत्कृष्ट परिणाम।

नेटवर्क संरचना का वर्णन करते हुए, मैंने एक परत के रूप में दृढ़ और पूलिंग परतों पर विचार किया। उन्हें अलग-अलग परतों के रूप में, या एक परत के रूप में विचार करें - वरीयता का मामला। network3.py उन्हें एक परत मानता है, क्योंकि इस तरह से कोड अधिक कॉम्पैक्ट है। हालाँकि, network3.py को संशोधित करना आसान है ताकि परतों को व्यक्तिगत रूप से सेट किया जा सके।

व्यायाम

• यदि हम पूरी तरह से जुड़ी हुई परत को कम करते हैं और केवल कनवल्शन / पूल लेयर और सॉफ्टमैक्स परत का उपयोग करते हैं तो हमें क्या वर्गीकरण सटीकता प्राप्त होगी? क्या एक पूरी तरह से जुड़े परत की मदद शामिल है?

क्या हम 98.78% परिणाम बेहतर कर सकते हैं?

आइए दूसरे कनवल्शन / पूलिंग लेयर को सम्मिलित करने का प्रयास करें। हम इसे मौजूदा कनवल्शन / पूलिंग और पूरी तरह से कनेक्टेड लेयर्स के बीच डालेंगे। हम फिर से 2x2 वर्गों में स्थानीय 5x5 ग्रहणशील क्षेत्र और पूल का उपयोग करते हैं। आइए देखें कि क्या होता है जब हम पहले की ही तरह लगभग हाइपरपैरामीटर वाले नेटवर्क को प्रशिक्षित करते हैं:

 >>> net = Network([ ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2)), ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12), filter_shape=(40, 20, 5, 5), poolsize=(2, 2)), FullyConnectedLayer(n_in=40*4*4, n_out=100), SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size) >>> net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data) 

और फिर, हमारे पास एक सुधार है: अब हमें 99.06% की सटीकता प्राप्त होती है!

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

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

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

कार्य

• हाइपरबोलिक स्पर्शरेखा के रूप में सक्रियण फ़ंक्शन का उपयोग करना। इस पुस्तक में इससे पहले, मैंने कई बार सबूतों का उल्लेख किया है कि तानाह फ़ंक्शन, एक हाइपरबोलिक स्पर्शरेखा, सिग्माइड की तुलना में सक्रियण फ़ंक्शन के लिए बेहतर अनुकूल हो सकता है। हमने इसके साथ कुछ भी नहीं किया, क्योंकि हमने सिग्माइड के साथ अच्छी प्रगति की थी। लेकिन आइए तन के साथ कुछ प्रयोगों को एक सक्रियण फ़ंक्शन के रूप में आज़माएं। तात्कालिक और पूरी तरह से जुड़े परतों के साथ एक स्पर्श-सक्रिय नेटवर्क को प्रशिक्षित करने का प्रयास करें (आप ConvPoolLayer और FullConnectedLayer कक्षाओं के लिए एक पैरामीटर के रूप में सक्रियण_fn = tanh पास कर सकते हैं)। उसी हाइपरपैरामीटर से शुरू करें जो सिग्मॉइड नेटवर्क के पास था, लेकिन 20 युगों के नेटवर्क को प्रशिक्षित करता है, न कि 60 को। नेटवर्क कैसे व्यवहार करता है? 60 वें युग तक जारी रहने पर क्या होगा? 60 वें युग तक स्पर्शरेखा और सिग्मॉइड के लिए युगों द्वारा काम की पुष्टि की सटीकता का एक ग्राफ बनाने की कोशिश करें। यदि आपके परिणाम मेरे समान हैं, तो आप पाएंगे कि स्पर्शरेखा-आधारित नेटवर्क थोड़ा तेज़ी से सीखता है, लेकिन दोनों नेटवर्क की परिणामी सटीकता समान है। क्या आप बता सकते हैं कि ऐसा क्यों होता है? क्या सिग्मॉइड के साथ समान सीखने की गति प्राप्त करना संभव है - उदाहरण के लिए, सीखने की गति को बदलकर या स्केलिंग के माध्यम से (याद रखें कि ((z) = (1 + tanh (z / 2)) / 2)? पाँच या छह अलग-अलग हाइपरपामेटर्स या नेटवर्क आर्किटेक्चर आज़माएँ, जहाँ स्पर्शरेखा सिग्मॉइड के आगे हो सकती है, वहाँ देखें। मैं ध्यान देता हूं कि यह कार्य खुला है। व्यक्तिगत रूप से, मुझे स्पर्शरेखा पर स्विच करने में कोई गंभीर लाभ नहीं मिला, हालांकि मैंने व्यापक प्रयोग नहीं किए थे, और शायद आप उन्हें पाएंगे। किसी भी मामले में, हम जल्द ही एक सीधा रैखिक सक्रियण फ़ंक्शन पर स्विच करने में एक फायदा पाएंगे, इसलिए हम अब हाइपरबोलिक स्पर्शरेखा के मुद्दे पर नहीं जाएंगे।

सीधे रैखिक तत्वों का उपयोग करना

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

सबसे पहले, अपने न्यूरॉन्स को बदलें ताकि सिग्मॉइड सक्रियण फ़ंक्शन का उपयोग करने के बजाय, हम सीधे रैखिक तत्वों (ReLU) का उपयोग कर सकें। यही है, हम फॉर्म f (z) 0 मैक्स (0, z) के सक्रियण फ़ंक्शन का उपयोग करेंगे। हम as = 0.03 की गति के साथ 60 युगों के एक नेटवर्क को प्रशिक्षित करेंगे। मैंने यह भी पाया कि नियमितीकरण पैरामीटर λ = 0.1 के साथ L2 नियमितीकरण का उपयोग करना थोड़ा अधिक सुविधाजनक है:

 >>> from network3 import ReLU >>> net = Network([ ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2), activation_fn=ReLU), ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12), filter_shape=(40, 20, 5, 5), poolsize=(2, 2), activation_fn=ReLU), FullyConnectedLayer(n_in=40*4*4, n_out=100, activation_fn=ReLU), SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size) >>> net.SGD(training_data, 60, mini_batch_size, 0.03, validation_data, test_data, lmbda=0.1) 

मुझे 99.23% की वर्गीकरण सटीकता मिली। सिग्मोइड परिणाम (99.06%) पर एक मामूली सुधार। हालाँकि, मेरे सभी प्रयोगों में, मैंने पाया कि ReLU पर आधारित नेटवर्क सिलेबॉइड एक्टिवेशन फंक्शन के आधार पर नेटवर्क से आगे थे, जो कि निरंतर गति के साथ सक्रिय थे। जाहिर है, इस समस्या को हल करने के लिए ReLU पर स्विच करने में वास्तविक फायदे हैं।

ReLU सक्रियण फ़ंक्शन सिग्मॉइड या हाइपरबोलिक स्पर्शरेखा से बेहतर क्या बनाता है? फिलहाल, हम इसे विशेष रूप से नहीं समझते हैं। यह आमतौर पर कहा जाता है कि फ़ंक्शन मैक्स (0, z) सिग्माइड न्यूरॉन्स के विपरीत, बड़े z पर संतृप्त नहीं होता है, और यह ReLU न्यूरॉन्स को सीखने को जारी रखने में मदद करता है। मैं बहस नहीं करता, लेकिन इस तरह के बहाने को व्यापक नहीं कहा जा सकता है, यह केवल किसी प्रकार का अवलोकन है (मैं आपको याद दिलाता हूं कि हमने अध्याय 2 में संतृप्ति पर चर्चा की थी)।

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

प्रशिक्षण डेटा का विस्तार

दूसरा तरीका जो संभवतः हमारे परिणामों को बेहतर बनाने में हमारी मदद कर सकता है वह है प्रशिक्षण डेटा का एल्गोरिदम का विस्तार करना। प्रशिक्षण डेटा का विस्तार करने का सबसे आसान तरीका प्रत्येक प्रशिक्षण चित्र को एक पिक्सेल, ऊपर, नीचे, दाएं या बाएं से स्थानांतरित करना है। यह Expand_mnist.py प्रोग्राम चलाकर किया जा सकता है।

 $ python expand_mnist.py 

कार्यक्रम का शुभारंभ एमएनआईएसटी की 50,000 प्रशिक्षण छवियों को 250,000 प्रशिक्षण छवियों के विस्तारित सेट में बदल देता है। फिर हम नेटवर्क को प्रशिक्षित करने के लिए इन प्रशिक्षण छवियों का उपयोग कर सकते हैं। हम ReLU के साथ पहले की तरह ही नेटवर्क का उपयोग करेंगे। अपने पहले प्रयोगों में, मैंने प्रशिक्षण युग की संख्या कम कर दी - यह समझ में आया, क्योंकि हमारे पास 5 गुना अधिक प्रशिक्षण डेटा है। हालांकि, डेटा सेट के विस्तार ने रिट्रीटिंग के प्रभाव को काफी कम कर दिया। इसलिए, कई प्रयोग करने के बाद, मैं एरस 60 की संख्या पर लौट आया। किसी भी मामले में, आइए ट्रेन करें:

 >>> expanded_training_data, _, _ = network3.load_data_shared( "../data/mnist_expanded.pkl.gz") >>> net = Network([ ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2), activation_fn=ReLU), ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12), filter_shape=(40, 20, 5, 5), poolsize=(2, 2), activation_fn=ReLU), FullyConnectedLayer(n_in=40*4*4, n_out=100, activation_fn=ReLU), SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size) >>> net.SGD(expanded_training_data, 60, mini_batch_size, 0.03, validation_data, test_data, lmbda=0.1) 

उन्नत प्रशिक्षण डेटा का उपयोग करते हुए, मुझे 99.37% की सटीकता प्राप्त हुई। इस तरह के लगभग तुच्छ परिवर्तन वर्गीकरण सटीकता में एक महत्वपूर्ण सुधार प्रदान करता है। और, जैसा कि हमने पहले चर्चा की थी, एल्गोरिथम डेटा एक्सटेंशन को और विकसित किया जा सकता है। बस आपको याद दिलाने के लिए: 2003 में , सिमर, स्टिंक्रास और प्लाट ने अपने नेटवर्क की सटीकता में 99.6% तक सुधार किया। उनका नेटवर्क हमारे जैसा था, उन्होंने दो कनवल्शन / पूल लेयर्स का इस्तेमाल किया, उसके बाद 100 न्यूरॉन्स के साथ एक पूरी तरह से कनेक्ट की गई परत। उनके वास्तुकला के विवरण में विविधता है - उनके पास ReLU का लाभ उठाने का अवसर नहीं था, उदाहरण के लिए - हालांकि, काम की गुणवत्ता में सुधार करने की कुंजी प्रशिक्षण डेटा का विस्तार था। उन्होंने एमएनआईएसटी प्रशिक्षण छवियों को बदलकर, स्थानांतरित करके और विकृत करके इसे हासिल किया। उन्होंने "लोचदार विकृति" प्रक्रिया भी विकसित की, लिखते समय हाथ की मांसपेशियों के यादृच्छिक कंपन का अनुकरण किया। इन सभी प्रक्रियाओं को मिलाकर, उन्होंने अपने प्रशिक्षण डेटा बेस की प्रभावी मात्रा में काफी वृद्धि की और इसके कारण 99.6% की सटीकता प्राप्त की।

कार्य

• छवि में स्थान की परवाह किए बिना कार्यशील परतों का विचार काम करना है। लेकिन तब यह अजीब लग सकता है कि जब हम बस इनपुट इमेज को शिफ्ट करते हैं तो हमारा नेटवर्क बेहतर प्रशिक्षित होता है। क्या आप बता सकते हैं कि यह वास्तव में काफी उचित क्यों है?

एक अतिरिक्त पूरी तरह से कनेक्टेड परत जोड़ना

क्या स्थिति में सुधार करना संभव है? एक संभावना सटीक एक ही प्रक्रिया का उपयोग करने के लिए है, लेकिन एक ही समय में पूरी तरह से जुड़े परत के आकार में वृद्धि। मैंने 300 और 1000 न्यूरॉन्स के साथ कार्यक्रम चलाया, और क्रमशः 99.46% और 99.43% में परिणाम मिला। यह दिलचस्प है, लेकिन पिछले परिणाम (99.37%) की तुलना में विशेष रूप से आश्वस्त नहीं है।

एक अतिरिक्त पूरी तरह से जुड़े परत को जोड़ने के बारे में क्या? आइए एक अतिरिक्त पूरी तरह से जुड़ी हुई परत को जोड़ने का प्रयास करें ताकि हमारे पास 100 न्यूरॉन्स की दो पूरी तरह से जुड़ी हुई परतें हों:

 >>> net = Network([ ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2), activation_fn=ReLU), ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12), filter_shape=(40, 20, 5, 5), poolsize=(2, 2), activation_fn=ReLU), FullyConnectedLayer(n_in=40*4*4, n_out=100, activation_fn=ReLU), FullyConnectedLayer(n_in=100, n_out=100, activation_fn=ReLU), SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size) >>> net.SGD(expanded_training_data, 60, mini_batch_size, 0.03, validation_data, test_data, lmbda=0.1) 

इस प्रकार, मैंने 99.43% की सत्यापन सटीकता हासिल की। विस्तारित नेटवर्क ने फिर से प्रदर्शन में बहुत सुधार नहीं किया। 300 और 100 न्यूरॉन्स की पूरी तरह से जुड़े परतों के साथ इसी तरह के प्रयोगों का संचालन करने के बाद, मुझे 99.48% और 99.47% की सटीकता प्राप्त हुई। प्रेरणादायक, लेकिन असली जीत की तरह नहीं।

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

 >>> net = Network([ ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2), activation_fn=ReLU), ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12), filter_shape=(40, 20, 5, 5), poolsize=(2, 2), activation_fn=ReLU), FullyConnectedLayer( n_in=40*4*4, n_out=1000, activation_fn=ReLU, p_dropout=0.5), FullyConnectedLayer( n_in=1000, n_out=1000, activation_fn=ReLU, p_dropout=0.5), SoftmaxLayer(n_in=1000, n_out=10, p_dropout=0.5)], mini_batch_size) >>> net.SGD(expanded_training_data, 40, mini_batch_size, 0.03, validation_data, test_data) 

इस दृष्टिकोण का उपयोग करते हुए, हम 99.60% की सटीकता प्राप्त करते हैं, जो पिछले वाले की तुलना में बहुत बेहतर है, विशेष रूप से हमारे मूल मूल्यांकन - 100 छिपे हुए न्यूरॉन्स के साथ एक नेटवर्क, जो 99.37% की सटीकता देता है।

दो बदलाव यहां ध्यान देने योग्य हैं।

सबसे पहले, मैंने प्रशिक्षण युग की संख्या घटाकर 40: अपवाद को कम कर दिया है, और हम तेजी से सीखते हैं।

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

नेटवर्क एनसेंबल का उपयोग करना

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

यह सच होने के लिए बहुत अच्छा लगता है, लेकिन ऐसे असेंबली को इकट्ठा करना नेशनल असेंबली और अन्य एमओ तकनीकों दोनों के लिए एक आम चाल है। और यह वास्तव में दक्षता में सुधार देता है: हमें 99.67% की सटीकता प्राप्त होती है। दूसरे शब्दों में, हमारा नेटवर्क 33 के अपवाद के साथ सभी 10,000 सत्यापन छवियों को सही ढंग से वर्गीकृत करता है।

शेष त्रुटियों को नीचे दिखाया गया है। ऊपरी दाएं कोने में लेबल MNIST डेटा के अनुसार सही वर्गीकरण है, और निचले दाएं कोने में नेटवर्क पहनावा द्वारा प्राप्त लेबल है:



छवियों पर वास करना सार्थक है। पहले दो अंक, 6 और 5 हमारे पहनावा की असली गलतियाँ हैं। हालांकि, उन्हें समझा जा सकता है, ऐसी गलती मनुष्य द्वारा की जा सकती है। यह 6 वास्तव में 0 के समान है, और 5 बहुत ही 3 के समान है। तीसरी तस्वीर, माना जाता है कि 8, वास्तव में 9 की तरह अधिक दिखता है। मैं नेटवर्क के कलाकारों की टुकड़ी के साथ हूं: मुझे लगता है कि उसने उस व्यक्ति की तुलना में बेहतर काम किया जिसने यह आंकड़ा लिखा था। दूसरी ओर, चौथी छवि, 6, को वास्तव में नेटवर्क द्वारा गलत तरीके से वर्गीकृत किया गया है।

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

हमने अपवाद को केवल पूरी तरह से कनेक्ट की गई परतों पर लागू क्यों किया

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

चल रहा है

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

अधिकांश भाग के लिए, मैं हाल के काम की समीक्षा करने की कोशिश नहीं करूंगा। लेकिन मैं एक अपवाद का विरोध नहीं कर सकता। यह 2010 में एक काम के बारे में है। मुझे उसकी सादगी पसंद है। नेटवर्क बहुपरत है, और केवल पूर्णतया कनेक्टेड लेयर्स (बिना कनवल्शन के) का उपयोग करता है। उनके सबसे सफल नेटवर्क में क्रमशः 2500, 2000, 1500, 1000 और 500 न्यूरॉन्स वाली छिपी हुई परतें हैं। उन्होंने प्रशिक्षण डेटा का विस्तार करने के लिए समान विचारों का उपयोग किया। लेकिन इसके अलावा, उन्होंने कई और तरकीबें लगाईं, जिनमें कंफर्टेबल लेयर्स की कमी शामिल है: यह सबसे सरल, वैनिला नेटवर्क था, जो उचित धैर्य और उपयुक्त कंप्यूटर क्षमताओं की उपलब्धता के साथ 1980 के दशक में वापस पढ़ाया जा सकता था (यदि एमएनआर सेट मौजूद है तो)। उन्होंने 99.65% की वर्गीकरण सटीकता हासिल की, जो मोटे तौर पर हमारे साथ मेल खाता है। उनके काम में मुख्य बात एक बहुत बड़े और गहरे नेटवर्क का उपयोग है, और सीखने में तेजी लाने के लिए जीपीयू का उपयोग है। इससे उन्हें कई युग सीखने की अनुमति मिली। उन्होंने प्रशिक्षण अंतराल की लंबी लंबाई का भी फायदा उठाया,और धीरे-धीरे सीखने की गति को 10 से कम कर दिया^-3 से 10 ^-6 । उनकी जैसी वास्तुकला के साथ समान परिणाम प्राप्त करने की कोशिश करना एक दिलचस्प अभ्यास है।

हमें सीखने को क्यों मिलता है?

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

हमने उनसे बचने का प्रबंधन कैसे किया?

जवाब, स्वाभाविक रूप से, यह है: हम उनसे बचने में सक्षम नहीं थे। इसके बजाय, हमने कुछ चीजें कीं, जिसने हमें इसके बावजूद काम जारी रखने की अनुमति दी। विशेष रूप से: (1) दृढ़ परतों का उपयोग उनमें निहित मापदंडों की संख्या को बहुत कम कर देता है, सीखने की समस्या को बहुत सुविधाजनक बनाता है; (2) अधिक कुशल नियमितीकरण तकनीकों का उपयोग (बहिष्करण और दृढ़ परतें); (3) सीखने में तेजी लाने के लिए सिग्मॉइड न्यूरॉन्स के बजाय ReLU का उपयोग करना - आनुभविक रूप से 3-5 गुना तक; (4) GPU का उपयोग और समय के साथ सीखने की क्षमता। विशेष रूप से, हाल के प्रयोगों में, हमने मानक MNIST प्रशिक्षण डेटा की तुलना में 5 गुना बड़ा डेटा सेट का उपयोग करके 40 युगों का अध्ययन किया। इससे पहले पुस्तक में, हमने मुख्य रूप से मानक प्रशिक्षण डेटा का उपयोग करके 30 युगों का अध्ययन किया। कारकों का संयोजन (3) और (4) ऐसा प्रभाव देता है,जैसे कि हमने पहले की तुलना में 30 गुना लंबा अध्ययन किया।

आप शायद कहते हैं, "क्या यह सब है?" क्या यह सब गहरे तंत्रिका नेटवर्क को प्रशिक्षित करने के लिए लेता है? और किस वजह से उपद्रव में आग लगी? ”

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

सभी संकेतों से, यह विचारों का एक काफी सरल सेट है। सरल, हालांकि, एक परिसर में उपयोग किए जाने पर बहुत सक्षम है। यह पता चला कि गहरी शिक्षा के साथ शुरुआत करना बहुत आसान था!

?

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

प्रक्रियात्मक मुद्दा

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

हमारे दृढ़ संकल्प नेटवर्क के लिए कोड

ठीक है, चलो अब हमारे network3.py कार्यक्रम के लिए कोड को देखते हैं। संरचनात्मक रूप से, यह network2.py के समान है, जिसे हमने अध्याय 3 में विकसित किया था, लेकिन थीन लाइब्रेरी के उपयोग के कारण विवरण भिन्न हैं। आइए फ़र्स्टकनेक्टेड लेयर क्लास से शुरू करते हैं, जो पहले पढ़ी गई परतों के समान है।

 class FullyConnectedLayer(object): def __init__(self, n_in, n_out, activation_fn=sigmoid, p_dropout=0.0): self.n_in = n_in self.n_out = n_out self.activation_fn = activation_fn self.p_dropout = p_dropout # Initialize weights and biases self.w = theano.shared( np.asarray( np.random.normal( loc=0.0, scale=np.sqrt(1.0/n_out), size=(n_in, n_out)), dtype=theano.config.floatX), name='w', borrow=True) self.b = theano.shared( np.asarray(np.random.normal(loc=0.0, scale=1.0, size=(n_out,)), dtype=theano.config.floatX), name='b', borrow=True) self.params = [self.w, self.b] def set_inpt(self, inpt, inpt_dropout, mini_batch_size): self.inpt = inpt.reshape((mini_batch_size, self.n_in)) self.output = self.activation_fn( (1-self.p_dropout)*T.dot(self.inpt, self.w) + self.b) self.y_out = T.argmax(self.output, axis=1) self.inpt_dropout = dropout_layer( inpt_dropout.reshape((mini_batch_size, self.n_in)), self.p_dropout) self.output_dropout = self.activation_fn( T.dot(self.inpt_dropout, self.w) + self.b) def accuracy(self, y): "Return the accuracy for the mini-batch." return T.mean(T.eq(y, self.y_out)) 

अधिकांश __in____ विधि स्वयं के लिए बोलती है, लेकिन कुछ नोट्स कोड को स्पष्ट करने में मदद कर सकते हैं। हमेशा की तरह, हम उपयुक्त मानक विचलन के साथ सामान्य यादृच्छिक मूल्यों का उपयोग करके वज़न और ऑफ़सेट को यादृच्छिक रूप से आरंभ करते हैं। ये रेखाएँ थोड़ी असंगत लगती हैं। हालाँकि, अधिकांश अजीब कोड वज़न और ऑफ़सेट को लोड कर रहे हैं, जिसमें थीनो लाइब्रेरी साझा चर कहती है। यह सुनिश्चित करता है कि यदि उपलब्ध हो, तो चर को GPU पर संसाधित किया जा सकता है। हम इस मुद्दे में नहीं उतरेंगे - यदि रुचि है, तो थीनो के लिए प्रलेखन पढ़ें। यह भी ध्यान दें कि वज़न और ऑफ़सेट्स का यह इनिशियलाइज़ेशन सिग्मॉइड ऐक्टिवेशन फंक्शन के लिए है। आदर्श रूप से, हाइपरबोलिक स्पर्शरेखा और ReLU जैसे फ़ंक्शंस के लिए, हम वज़न और ऑफ़सेट को अलग-अलग तरीके से प्रारंभ करेंगे। इस मुद्दे पर भविष्य के कार्यों में चर्चा की गई है।__Init__ विधि कथन के साथ समाप्त होती है। self.params = [self.w, self.b]। यह एक परत के साथ जुड़े सभी शिक्षण मापदंडों को एक साथ लाने का एक सुविधाजनक तरीका है। Network.SGD बाद में params विशेषताओं का उपयोग करके यह पता लगाता है कि नेटवर्क वर्ग उदाहरण में कौन से चर प्रशिक्षित किए जा सकते हैं।

Set_inpt मेथड को एक लेयर में इनपुट पास करने और संबंधित आउटपुट की गणना करने के लिए उपयोग किया जाता है। मैं इनपुट के बजाय निष्क्रिय लिखता हूं, क्योंकि इनपुट एक अंतर्निहित अजगर फ़ंक्शन है, और यदि आप उनके साथ खेलते हैं, तो यह अप्रत्याशित प्रोग्राम व्यवहार और त्रुटियों का निदान करने में मुश्किल हो सकता है। वास्तव में, हम इनपुट को दो तरीकों से पास करते हैं: self.inpt और self.inpt_dropout के माध्यम से। यह किया जाता है क्योंकि हम प्रशिक्षण के दौरान अपवाद का उपयोग करना चाहते हैं। और फिर हमें self.p_dropout न्यूरॉन्स के हिस्से को हटाने की आवश्यकता होगी। यह वही है जो drop_layer फंक्शन को set_inpt मेथड की पेनल्टिकल लाइन में करता है। तो, self.inpt_dropout और self.output_dropout का उपयोग प्रशिक्षण के दौरान किया जाता है, और self.inpt और self.output का उपयोग अन्य सभी उद्देश्यों के लिए किया जाता है, उदाहरण के लिए, मान्य और परीक्षण डेटा पर सटीकता का मूल्यांकन।

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

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

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

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

 class Network(object): def __init__(self, layers, mini_batch_size): """   layers,   ,   mini_batch_size          """ self.layers = layers self.mini_batch_size = mini_batch_size self.params = [param for layer in self.layers for param in layer.params] self.x = T.matrix("x") self.y = T.ivector("y") init_layer = self.layers[0] init_layer.set_inpt(self.x, self.x, self.mini_batch_size) for j in xrange(1, len(self.layers)): prev_layer, layer = self.layers[j-1], self.layers[j] layer.set_inpt( prev_layer.output, prev_layer.output_dropout, self.mini_batch_size) self.output = self.layers[-1].output self.output_dropout = self.layers[-1].output_dropout 

अधिकांश कोड अपने लिए बोलते हैं। लाइन self.params = [में परत के लिए परम ...] प्रत्येक परत के लिए सभी मापदंडों को एक सूची में एकत्र करता है। जैसा कि पहले सुझाव दिया गया है, नेटवर्क वीईडी विधि स्व.प्रेम का उपयोग करता है ताकि यह पता लगाया जा सके कि नेटवर्क किन मापदंडों से सीख सकता है। रेखाएँ self.x = T.matrix ("x") और self.y = T.ivector ("y") थीनो x और y प्रतीकात्मक चर को परिभाषित करती हैं। वे इनपुट और नेटवर्क के वांछित आउटपुट का प्रतिनिधित्व करेंगे।

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

  init_layer.set_inpt(self.x, self.x, self.mini_batch_size) 

इनपुट डेटा को एक बार में एक मिनी-पैकेट प्रेषित किया जाता है, इसलिए इसका आकार वहां इंगित किया गया है। हम स्वयं का इनपुट दो बार पास करते हैं: तथ्य यह है कि हम नेटवर्क को दो अलग-अलग तरीकों से (अपवाद के बिना या बिना) उपयोग कर सकते हैं। लूप के लिए नेटवर्क परतों के माध्यम से प्रतीकात्मक चर self.x का प्रचार करता है। यह हमें अंतिम विशेषताओं आउटपुट और output_dropout को परिभाषित करने की अनुमति देता है, जो प्रतीकात्मक रूप से नेटवर्क के आउटपुट का प्रतिनिधित्व करते हैं।

नेटवर्क के आरंभीकरण से निपटने के बाद, आइए हम इसके प्रशिक्षण को SGD पद्धति के माध्यम से देखें। कोड लंबा दिखता है, लेकिन इसकी संरचना काफी सरल है। स्पष्टीकरण कोड का पालन करें:

  def SGD(self, training_data, epochs, mini_batch_size, eta, validation_data, test_data, lmbda=0.0): """    -    .""" training_x, training_y = training_data validation_x, validation_y = validation_data test_x, test_y = test_data #   -  ,    num_training_batches = size(training_data)/mini_batch_size num_validation_batches = size(validation_data)/mini_batch_size num_test_batches = size(test_data)/mini_batch_size #    ,     l2_norm_squared = sum([(layer.w**2).sum() for layer in self.layers]) cost = self.layers[-1].cost(self)+\ 0.5*lmbda*l2_norm_squared/num_training_batches grads = T.grad(cost, self.params) updates = [(param, param-eta*grad) for param, grad in zip(self.params, grads)] #     -    #      -. i = T.lscalar() # mini-batch index train_mb = theano.function( [i], cost, updates=updates, givens={ self.x: training_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size], self.y: training_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size] }) validate_mb_accuracy = theano.function( [i], self.layers[-1].accuracy(self.y), givens={ self.x: validation_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size], self.y: validation_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size] }) test_mb_accuracy = theano.function( [i], self.layers[-1].accuracy(self.y), givens={ self.x: test_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size], self.y: test_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size] }) self.test_mb_predictions = theano.function( [i], self.layers[-1].y_out, givens={ self.x: test_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size] }) #    best_validation_accuracy = 0.0 for epoch in xrange(epochs): for minibatch_index in xrange(num_training_batches): iteration = num_training_batches*epoch+minibatch_index if iteration print("Training mini-batch number {0}".format(iteration)) cost_ij = train_mb(minibatch_index) if (iteration+1) validation_accuracy = np.mean( [validate_mb_accuracy(j) for j in xrange(num_validation_batches)]) print("Epoch {0}: validation accuracy {1:.2 epoch, validation_accuracy)) if validation_accuracy >= best_validation_accuracy: print("This is the best validation accuracy to date.") best_validation_accuracy = validation_accuracy best_iteration = iteration if test_data: test_accuracy = np.mean( [test_mb_accuracy(j) for j in xrange(num_test_batches)]) print('The corresponding test accuracy is {0:.2 test_accuracy)) print("Finished training network.") print("Best validation accuracy of {0:.2 best_validation_accuracy, best_iteration)) print("Corresponding test accuracy of {0:.2 

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

  #    ,     l2_norm_squared = sum([(layer.w**2).sum() for layer in self.layers]) cost = self.layers[-1].cost(self)+\ 0.5*lmbda*l2_norm_squared/num_training_batches grads = T.grad(cost, self.params) updates = [(param, param-eta*grad) for param, grad in zip(self.params, grads)] 

इन पंक्तियों में, हम प्रतीकात्मक रूप से लॉगरिदमिक संभावना फ़ंक्शन के आधार पर नियमित लागत फ़ंक्शन को परिभाषित करते हैं, ग्रेडिएंट फ़ंक्शन में संबंधित डेरिवेटिव की गणना करते हैं, और इसी पैरामीटर अपडेट भी करते हैं। थीनो हमें यह सब कुछ ही लाइनों में करने की अनुमति देता है। केवल छिपी हुई बात यह है कि लागत की गणना में आउटपुट परत के लिए लागत विधि को शामिल करना शामिल है; यह कोड network3.py में कहीं और स्थित है। लेकिन यह छोटा और सरल है। इस सब की परिभाषा के साथ, सब कुछ train_mb फ़ंक्शन को परिभाषित करने के लिए तैयार है, थीनो प्रतीकात्मक फ़ंक्शन जो मिनी-पैकेट इंडेक्स द्वारा नेटवर्क मापदंडों को अपडेट करने के लिए अपडेट का उपयोग करता है। इसी प्रकार, validate_mb_accuracy और test_mb_accuracy फ़ंक्शन सत्यापन या सत्यापन डेटा के किसी भी मिनी-पैकेट पर नेटवर्क सटीकता की गणना करते हैं। इन कार्यों का लाभ उठाते हुए,हम संपूर्ण सत्यापन और सत्यापन डेटासेट पर सटीकता की गणना कर सकते हैं।

SGD की बाकी विधि स्वयं के लिए बोलती है - हम बस क्रमिक रूप से चलते हैं, नेटवर्क को बार-बार प्रशिक्षण डेटा के मिनी-पैकेट पर प्रशिक्षण देते हैं, और हम पुष्टि और सत्यापन की सटीकता की गणना करते हैं।

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

 """network3.py ~~~~~~~~~~~~~~     Theano      .     (, , -, softmax)    (,  , ReLU;   ).    CPU     ,  network.py  network2.py. ,    ,      GPU,    .     Theano,       network.py  network2.py.  ,       .  , API   network2.py.       ,  ,     .   ,     ,    .      Theano   (http://deeplearning.net/tutorial/lenet.html ),       (https://github.com/mdenil/dropout )      (http://colah.imtqy.com ).   Theano 0.6  0.7,       . """ ####  #  import cPickle import gzip #  import numpy as np import theano import theano.tensor as T from theano.tensor.nnet import conv from theano.tensor.nnet import softmax from theano.tensor import shared_randomstreams from theano.tensor.signal import downsample #    def linear(z): return z def ReLU(z): return T.maximum(0.0, z) from theano.tensor.nnet import sigmoid from theano.tensor import tanh ####  GPU = True if GPU: print "Trying to run under a GPU. If this is not desired, then modify "+\ "network3.py\nto set the GPU flag to False." try: theano.config.device = 'gpu' except: pass # it's already set theano.config.floatX = 'float32' else: print "Running with a CPU. If this is not desired, then the modify "+\ "network3.py to set\nthe GPU flag to True." ####   MNIST def load_data_shared(filename="../data/mnist.pkl.gz"): f = gzip.open(filename, 'rb') training_data, validation_data, test_data = cPickle.load(f) f.close() def shared(data): """    .   Theano    GPU,   . """ shared_x = theano.shared( np.asarray(data[0], dtype=theano.config.floatX), borrow=True) shared_y = theano.shared( np.asarray(data[1], dtype=theano.config.floatX), borrow=True) return shared_x, T.cast(shared_y, "int32") return [shared(training_data), shared(validation_data), shared(test_data)] ####        class Network(object): def __init__(self, layers, mini_batch_size): """   layers,   ,   mini_batch_size         . """ self.layers = layers self.mini_batch_size = mini_batch_size self.params = [param for layer in self.layers for param in layer.params] self.x = T.matrix("x") self.y = T.ivector("y") init_layer = self.layers[0] init_layer.set_inpt(self.x, self.x, self.mini_batch_size) for j in xrange(1, len(self.layers)): prev_layer, layer = self.layers[j-1], self.layers[j] layer.set_inpt( prev_layer.output, prev_layer.output_dropout, self.mini_batch_size) self.output = self.layers[-1].output self.output_dropout = self.layers[-1].output_dropout def SGD(self, training_data, epochs, mini_batch_size, eta, validation_data, test_data, lmbda=0.0): """    -    .""" training_x, training_y = training_data validation_x, validation_y = validation_data test_x, test_y = test_data #   -  ,    num_training_batches = size(training_data)/mini_batch_size num_validation_batches = size(validation_data)/mini_batch_size num_test_batches = size(test_data)/mini_batch_size #    ,     l2_norm_squared = sum([(layer.w**2).sum() for layer in self.layers]) cost = self.layers[-1].cost(self)+\ 0.5*lmbda*l2_norm_squared/num_training_batches grads = T.grad(cost, self.params) updates = [(param, param-eta*grad) for param, grad in zip(self.params, grads)] #     -    #      -. i = T.lscalar() # mini-batch index train_mb = theano.function( [i], cost, updates=updates, givens={ self.x: training_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size], self.y: training_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size] }) validate_mb_accuracy = theano.function( [i], self.layers[-1].accuracy(self.y), givens={ self.x: validation_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size], self.y: validation_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size] }) test_mb_accuracy = theano.function( [i], self.layers[-1].accuracy(self.y), givens={ self.x: test_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size], self.y: test_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size] }) self.test_mb_predictions = theano.function( [i], self.layers[-1].y_out, givens={ self.x: test_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size] }) #    best_validation_accuracy = 0.0 for epoch in xrange(epochs): for minibatch_index in xrange(num_training_batches): iteration = num_training_batches*epoch+minibatch_index if iteration % 1000 == 0: print("Training mini-batch number {0}".format(iteration)) cost_ij = train_mb(minibatch_index) if (iteration+1) % num_training_batches == 0: validation_accuracy = np.mean( [validate_mb_accuracy(j) for j in xrange(num_validation_batches)]) print("Epoch {0}: validation accuracy {1:.2%}".format( epoch, validation_accuracy)) if validation_accuracy >= best_validation_accuracy: print("This is the best validation accuracy to date.") best_validation_accuracy = validation_accuracy best_iteration = iteration if test_data: test_accuracy = np.mean( [test_mb_accuracy(j) for j in xrange(num_test_batches)]) print('The corresponding test accuracy is {0:.2%}'.format( test_accuracy)) print("Finished training network.") print("Best validation accuracy of {0:.2%} obtained at iteration {1}".format( best_validation_accuracy, best_iteration)) print("Corresponding test accuracy of {0:.2%}".format(test_accuracy)) ####    class ConvPoolLayer(object): """     - .        ,         ,    ,   . """ def __init__(self, filter_shape, image_shape, poolsize=(2, 2), activation_fn=sigmoid): """`filter_shape` -   4,   ,    ,     . `image_shape` -   4,   -,    ,    . `poolsize` -   2,    y  x. """ self.filter_shape = filter_shape self.image_shape = image_shape self.poolsize = poolsize self.activation_fn=activation_fn # initialize weights and biases n_out = (filter_shape[0]*np.prod(filter_shape[2:])/np.prod(poolsize)) self.w = theano.shared( np.asarray( np.random.normal(loc=0, scale=np.sqrt(1.0/n_out), size=filter_shape), dtype=theano.config.floatX), borrow=True) self.b = theano.shared( np.asarray( np.random.normal(loc=0, scale=1.0, size=(filter_shape[0],)), dtype=theano.config.floatX), borrow=True) self.params = [self.w, self.b] def set_inpt(self, inpt, inpt_dropout, mini_batch_size): self.inpt = inpt.reshape(self.image_shape) conv_out = conv.conv2d( input=self.inpt, filters=self.w, filter_shape=self.filter_shape, image_shape=self.image_shape) pooled_out = downsample.max_pool_2d( input=conv_out, ds=self.poolsize, ignore_border=True) self.output = self.activation_fn( pooled_out + self.b.dimshuffle('x', 0, 'x', 'x')) self.output_dropout = self.output # no dropout in the convolutional layers class FullyConnectedLayer(object): def __init__(self, n_in, n_out, activation_fn=sigmoid, p_dropout=0.0): self.n_in = n_in self.n_out = n_out self.activation_fn = activation_fn self.p_dropout = p_dropout # Initialize weights and biases self.w = theano.shared( np.asarray( np.random.normal( loc=0.0, scale=np.sqrt(1.0/n_out), size=(n_in, n_out)), dtype=theano.config.floatX), name='w', borrow=True) self.b = theano.shared( np.asarray(np.random.normal(loc=0.0, scale=1.0, size=(n_out,)), dtype=theano.config.floatX), name='b', borrow=True) self.params = [self.w, self.b] def set_inpt(self, inpt, inpt_dropout, mini_batch_size): self.inpt = inpt.reshape((mini_batch_size, self.n_in)) self.output = self.activation_fn( (1-self.p_dropout)*T.dot(self.inpt, self.w) + self.b) self.y_out = T.argmax(self.output, axis=1) self.inpt_dropout = dropout_layer( inpt_dropout.reshape((mini_batch_size, self.n_in)), self.p_dropout) self.output_dropout = self.activation_fn( T.dot(self.inpt_dropout, self.w) + self.b) def accuracy(self, y): "Return the accuracy for the mini-batch." return T.mean(T.eq(y, self.y_out)) class SoftmaxLayer(object): def __init__(self, n_in, n_out, p_dropout=0.0): self.n_in = n_in self.n_out = n_out self.p_dropout = p_dropout #     self.w = theano.shared( np.zeros((n_in, n_out), dtype=theano.config.floatX), name='w', borrow=True) self.b = theano.shared( np.zeros((n_out,), dtype=theano.config.floatX), name='b', borrow=True) self.params = [self.w, self.b] def set_inpt(self, inpt, inpt_dropout, mini_batch_size): self.inpt = inpt.reshape((mini_batch_size, self.n_in)) self.output = softmax((1-self.p_dropout)*T.dot(self.inpt, self.w) + self.b) self.y_out = T.argmax(self.output, axis=1) self.inpt_dropout = dropout_layer( inpt_dropout.reshape((mini_batch_size, self.n_in)), self.p_dropout) self.output_dropout = softmax(T.dot(self.inpt_dropout, self.w) + self.b) def cost(self, net): "   ." return -T.mean(T.log(self.output_dropout)[T.arange(net.y.shape[0]), net.y]) def accuracy(self, y): "  -." return T.mean(T.eq(y, self.y_out)) ####  def size(data): "    `data`." return data[0].get_value(borrow=True).shape[0] def dropout_layer(layer, p_dropout): srng = shared_randomstreams.RandomStreams( np.random.RandomState(0).randint(999999)) mask = srng.binomial(n=1, p=1-p_dropout, size=layer.shape) return layer*T.cast(mask, theano.config.floatX) 

कार्य

• SGD . , . network3.py , .
• Network , .
• SGD , η ( , , , ).
• , . network3.py, . , , . .
• .
• – . , , , ? .
• ReLU , ( -) . . , ReLU ( ). , c>0 c ^L−1 , L – . , softmax? ReLU? ? , , . , ReLU.
• . , ReLU? , ? : «» . – , - - .