तंत्रिका नेटवर्क और गहरी शिक्षा, अध्याय 5: प्रशिक्षण के लिए गहरे तंत्रिका नेटवर्क इतने कठिन क्यों हैं?

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



आप चकित हैं और बॉस को बताएं: "हाँ, ग्राहक पागल है!"

बॉस जवाब देता है: “मुझे भी यही लगता है। लेकिन क्लाइंट को वह मिलना चाहिए जो वह चाहता है। ”

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

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

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



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

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

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



ये सरल नेटवर्क बहुत उपयोगी निकले: पिछले अध्यायों में हमने ऐसे नेटवर्क का उपयोग 98% से अधिक सटीकता के साथ हस्तलिखित संख्याओं को वर्गीकृत करने के लिए किया था! हालाँकि, यह स्पष्ट रूप से स्पष्ट है कि कई छिपी हुई परतों वाले नेटवर्क बहुत अधिक शक्तिशाली होंगे:



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

हम इन गहरे तंत्रिका नेटवर्क (GNS) को कैसे प्रशिक्षित करते हैं? इस अध्याय में, हम एसटीएस को अपने एल्गोरिथ्म के बीच प्रशिक्षण एल्गोरिदम - स्टोचैस्टिक ढाल पिछड़े प्रसार वंश के बीच प्रशिक्षित करने का प्रयास करेंगे। हालांकि, हम एक समस्या का सामना करेंगे - हमारे एसटीएस उथले वाले की तुलना में बहुत बेहतर काम नहीं करेंगे (यदि सभी से अधिक है)।

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

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

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

लुप्त होती ढाल समस्या

तो क्या गलत है जब हम एक गहरे नेटवर्क को प्रशिक्षित करने की कोशिश करते हैं?

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

यदि आप कंप्यूटर पर इन सभी चरणों को दोहराना चाहते हैं, तो आपके पास पायथन 2.7 स्थापित होना चाहिए, Numpy लाइब्रेरी, और कोड की एक प्रति जो रिपॉजिटरी से ली जा सकती है:

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

आप केवल डेटा और कोड को डाउनलोड करके बिना गिट के कर सकते हैं। Src उपनिर्देशिका पर जाएं और अजगर शेल से MNIST डेटा लोड करें:

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

नेटवर्क कॉन्फ़िगर करें:

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

इस तरह के नेटवर्क में इनपुट परत में 784 न्यूरॉन्स होते हैं, जो इनपुट छवि के 28 × 28 = 784 पिक्सल के अनुरूप होते हैं। हम 30 छिपे हुए न्यूरॉन्स और 10 सप्ताहांत का उपयोग करते हैं, एमएनआईएसटी ('0', '1', '2', ..., '9') संख्याओं के लिए दस संभावित वर्गीकरण विकल्पों के अनुरूप।

आइए एक समय में 10 प्रशिक्षण उदाहरणों के मिनी-पैकेजों का उपयोग करके 30 पूरे युगों के लिए हमारे नेटवर्क को प्रशिक्षित करने की कोशिश करें, गति regular = 0.1 और नियमितीकरण पैरामीटर λ = 5.0। प्रशिक्षण के दौरान, हम वर्गीकरण की सटीकता को वैधीकरण_डेटा के माध्यम से ट्रैक करेंगे:

 >>> net.SGD(training_data, 30, 10, 0.1, lmbda=5.0, ... evaluation_data=validation_data, monitor_evaluation_accuracy=True) 

हमें 96.48% (या - इतनी संख्या अलग-अलग लॉन्च के साथ अलग-अलग होगी) की एक वर्गीकरण सटीकता प्राप्त होती है, जो समान सेटिंग्स के साथ हमारे पहले के परिणामों के बराबर है।

आइए एक और छिपी हुई परत जोड़ें, जिसमें 30 न्यूरॉन्स भी हों, और एक ही हाइपरपैरामीटर के साथ नेटवर्क को प्रशिक्षित करने का प्रयास करें:

 >>> net = network2.Network([784, 30, 30, 10]) >>> net.SGD(training_data, 30, 10, 0.1, lmbda=5.0, ... evaluation_data=validation_data, monitor_evaluation_accuracy=True) 

वर्गीकरण सटीकता 96.90% तक सुधरती है। यह प्रेरणादायक है - गहराई में थोड़ी वृद्धि मदद करती है। आइए 30 न्यूरॉन्स की एक और छिपी हुई परत जोड़ें:

 >>> net = network2.Network([784, 30, 30, 30, 10]) >>> net.SGD(training_data, 30, 10, 0.1, lmbda=5.0, ... evaluation_data=validation_data, monitor_evaluation_accuracy=True) 

इसने मदद नहीं की परिणाम भी 96.57% तक गिर गया, मूल उथले नेटवर्क के करीब मूल्य। और अगर हम एक और छिपी परत जोड़ते हैं:

 >>> net = network2.Network([784, 30, 30, 30, 30, 10]) >>> net.SGD(training_data, 30, 10, 0.1, lmbda=5.0, ... evaluation_data=validation_data, monitor_evaluation_accuracy=True) 

फिर वर्गीकरण सटीकता फिर से गिर जाएगी, पहले से ही 96.53% तक। सांख्यिकीय रूप से, यह गिरावट संभवतः महत्वहीन है, लेकिन इसके बारे में कुछ भी अच्छा नहीं है।

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

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

यह समझने के लिए कि क्या गलत हुआ, चलो नेटवर्क सीखने की प्रक्रिया की कल्पना करें। नीचे, मैंने नेटवर्क का एक हिस्सा बनाया [784,30,30,10], जिसमें दो छिपी हुई परतें हैं, जिनमें से प्रत्येक में 30 छिपे हुए न्यूरॉन्स हैं। आरेख पर, प्रत्येक न्यूरॉन में एक बार होता है जो नेटवर्क को सीखने की प्रक्रिया में बदलाव की दर का संकेत देता है। एक बड़ी पट्टी का मतलब है कि न्यूरॉन के वजन और विस्थापन जल्दी से बदल जाते हैं, और एक छोटे का मतलब है कि वे धीरे-धीरे बदलते हैं। अधिक सटीक रूप से, बार न्यूरॉन के /C / ientb ढाल को दर्शाता है, अर्थात, विस्थापन के संबंध में लागत के परिवर्तन की दर। अध्याय 2 में, हमने देखा कि यह ढाल मूल्य न केवल प्रशिक्षण के दौरान विस्थापन के परिवर्तन की दर को नियंत्रित करता है, बल्कि इनपुट न्यूरॉन वेट के परिवर्तन की दर को भी नियंत्रित करता है। चिंता मत करो अगर आप इन विवरणों को याद नहीं कर सकते हैं: आपको बस यह ध्यान रखने की ज़रूरत है कि ये बार नेटवर्क के प्रशिक्षण के दौरान न्यूरॉन्स के वजन और विस्थापन को कितनी जल्दी बदलते हैं।

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



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

वास्तव में जानने के लिए, पहले और दूसरे छिपे हुए परतों में सीखने की गति की तुलना करने का एक सामान्य तरीका अच्छा होगा। ऐसा करने के लिए, हम = ^l _j = ∂C / ,b ^l _{j के} रूप में ग्रेडिएंट को निरूपित करते हैं, अर्थात परत संख्या l में न्यूरॉन नंबर j के ग्रेडिएंट के रूप में। दूसरे अध्याय में, हमने इसे "गलती" कहा, लेकिन यहां मैं अनौपचारिक रूप से इसे "ढाल" कहूंगा। अनौपचारिक रूप से - चूंकि यह मूल्य स्पष्ट रूप से वजन, ∂C / .w द्वारा लागत के आंशिक डेरिवेटिव को शामिल नहीं करता है। ग्रेडिएंट of ¹ को एक वेक्टर के रूप में माना जा सकता है, जिनके तत्व यह निर्धारित करते हैं कि पहली छिपी हुई परत कितनी जल्दी सीखती है, और whose ² एक वेक्टर के रूप में जिसका तत्व यह निर्धारित करता है कि दूसरी छिपी हुई परत कितनी जल्दी सीखती है। हम इन वैक्टर की लंबाई का उपयोग परतों की सीखने की गति के अनुमानित अनुमानों के रूप में करते हैं। उदाहरण के लिए, लंबाई || δ ¹ || पहले छिपी हुई परत, और लंबाई की सीखने की गति को मापता है || δ ² || दूसरी छिपी परत की सीखने की गति को मापता है।

ऐसी परिभाषाओं और उपरोक्त विन्यास के साथ, हम पाते हैं कि || δ ¹ || = ०.० =, और || δ ² || = 0.31। यह हमारे संदेह की पुष्टि करता है: दूसरी छिपी परत में न्यूरॉन्स पहली छिपी परत में न्यूरॉन्स की तुलना में बहुत तेजी से सीखते हैं।

यदि हम अधिक छिपी हुई परतों को जोड़ते हैं तो क्या होता है? नेटवर्क में तीन छिपी हुई परतों के साथ [784,30,30,30,10] संबंधित सीखने की गति 0.012, 0.060 और 0.283 होगी। फिर से, पहले छिपी हुई परतें पिछले की तुलना में बहुत धीमी सीखती हैं। 30 न्यूरॉन्स के साथ एक और छिपी परत जोड़ें। इस मामले में, सीखने की गति 0.003, 0.017, 0.070 और 0.285 होगी। पैटर्न संरक्षित है: शुरुआती परतें बाद के लोगों की तुलना में अधिक धीरे-धीरे सीखती हैं।

हमने शुरुआत में सीखने की गति का अध्ययन किया - नेटवर्क आरंभ होने के ठीक बाद। सीखते ही यह गति कैसे बदल जाती है? चलो वापस जाते हैं और दो छिपी हुई परतों के साथ नेटवर्क को देखते हैं। सीखने की गति इस तरह से बदल जाती है:



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

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

अधिक जटिल नेटवर्क के बारे में क्या? यहां एक समान प्रयोग के परिणाम हैं, लेकिन तीन छिपी परतों के साथ एक नेटवर्क के साथ [784,30,30,30,10]



और फिर, पहली छिपी हुई परतें पिछले की तुलना में बहुत धीमी सीखती हैं। अंत में, आइए एक चौथी छिपी हुई परत (नेटवर्क [784,30,30,30,30,10]) को जोड़ने का प्रयास करें, और देखें कि क्या होता है जब इसे प्रशिक्षित किया जाता है:



और फिर, पहली छिपी हुई परतें पिछले की तुलना में बहुत धीमी सीखती हैं। इस मामले में, पहली छिपी हुई परत आखिरी की तुलना में लगभग 100 गुना धीमी सीखती है। कोई आश्चर्य नहीं कि हमें इन नेटवर्क को सीखने में ऐसी समस्याएं थीं!

हमने एक महत्वपूर्ण अवलोकन किया: कम से कम कुछ जीएनएस में, छिपी हुई परतों के साथ विपरीत दिशा में बढ़ने पर ढाल घट जाती है। यही है, पहली परतों में न्यूरॉन्स को आखिरी में न्यूरॉन्स की तुलना में बहुत धीरे से प्रशिक्षित किया जाता है। और यद्यपि हमने इस प्रभाव को केवल एक नेटवर्क में देखा, लेकिन कई एनएस में ऐसा होने के मूलभूत कारण हैं। इस घटना को "लुप्त होने वाली समस्या" के रूप में जाना जाता है (देखें कार्य 1 , 2 )।

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

एक लुप्त होती (या अस्थिर) प्रवणता के लिए प्रतिक्रियाओं में से एक यह सोचना है कि क्या यह वास्तव में एक गंभीर समस्या है? आइए हम संक्षेप में NS से ​​विचलित होते हैं, और कल्पना करते हैं कि हम एक चर से फ़ंक्शन f (x) को संख्यात्मक रूप से कम करने की कोशिश कर रहे हैं। यदि व्युत्पन्न च if (x) छोटा था तो क्या यह अच्छा नहीं होगा? इसका मतलब यह नहीं होगा कि हम पहले से ही चरम के करीब हैं? और इसी तरह, जीएनएस की पहली परतों में एक छोटे से ढाल का मतलब यह नहीं है कि अब हमें वज़न और विस्थापन को समायोजित करने की आवश्यकता नहीं है?

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

लुप्त होती ढाल समस्या का कारण क्या है? जीएनएस में अस्थिर ग्रेडिएंट्स

यह समझने के लिए कि एक लुप्तप्राय ढाल की समस्या कैसे दिखाई देती है, सरलतम एनएस पर विचार करें: प्रत्येक परत में केवल एक न्यूरॉन के साथ। यहां तीन छिपी हुई परतों वाला एक नेटवर्क है:



यहां डब्ल्यू ₁ , डब्ल्यू ₂ , ... वेट हैं, बी ₁ , बी ₂ , ... विस्थापन हैं, सी एक निश्चित लागत फ़ंक्शन है। बस आपको याद दिलाने के लिए, मैं कहूँगा कि आउटपुट a _j न्यूरॉन नं। _J से you (z _j ) के बराबर है, जहाँ s सामान्य सिग्माइड एक्टिवेशन फंक्शन है, और z _j = w _{j j - 1} + b _j न्यूरॉन का भारित इनपुट है। मैंने लागत फ़ंक्शन को इस बात पर जोर देने के लिए अंत में दर्शाया कि लागत नेटवर्क आउटपुट का एक फ़ंक्शन है, और ₄ : यदि वास्तविक आउटपुट आपके इच्छित के करीब है, तो लागत छोटी होगी, और यदि दूर है, तो यह बड़ी होगी।

हम पहले छिपे हुए न्यूरॉन से जुड़े ग्रेडिएंट /C / theb _{1 का} अध्ययन करते हैं। हम /C / theb _{1 के} लिए अभिव्यक्ति पाते हैं और, इसका अध्ययन करने पर, हम समझेंगे कि लुप्त हो रही ढाल की समस्या क्यों उत्पन्न होती है।

हम /C / .b _{1 के} लिए अभिव्यक्ति प्रदर्शित करके शुरू करते हैं। यह अभेद्य दिखता है, लेकिन वास्तव में इसकी संरचना सरल है, और मैं जल्द ही इसका वर्णन करूंगा। यहां यह अभिव्यक्ति है (अभी के लिए, नेटवर्क को ही अनदेखा करें और ध्यान दें कि just केवल फ़ंक्शन का व्युत्पन्न है σ):



अभिव्यक्ति की संरचना इस प्रकार है: नेटवर्क में प्रत्येक न्यूरॉन के लिए एक गुणन शब्द, is (z _j ) होता है, प्रत्येक भार के लिए w _{j होता है} , और लागत फ़ंक्शन के अनुसार अंतिम शब्द, /C / ∂a ₄ भी होता है। ध्यान दें कि मैंने संबंधित सदस्यों को नेटवर्क के संबंधित भागों के ऊपर रखा है। इसलिए, नेटवर्क ही अभिव्यक्ति के लिए एक मात्र नियम है।

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

कल्पना कीजिए कि हमने web ₁ से ऑफसेट b ₁ में एक छोटा सा परिवर्तन किया। यह नेटवर्क के बाकी हिस्सों में कैस्केडिंग परिवर्तनों की एक श्रृंखला भेजेगा। सबसे पहले, यह बदलने के लिए पहले छिपे हुए न्यूरॉन toa ₁ के आउटपुट का कारण होगा। यह बदले में, onz ₂ को दूसरे छिपे हुए न्यूरॉन के लिए भारित इनपुट में बदलने के लिए मजबूर करता है। फिर दूसरे छिपे हुए न्यूरॉन के आउटपुट में ina ₂ में बदलाव होगा। और इसी तरह, आउटपुट वैल्यू में onC में बदलाव तक। यह पता चला है कि:

$$

$$\ frac {\ आंशिक C} {\ आंशिक b_1} \ लगभग \ frac {\ Delta C} {\ Delta b_1} \ tag {114}$$

इससे पता चलता है कि हम ढाल ∂C / ,b _{1 के} लिए एक अभिव्यक्ति प्राप्त कर सकते हैं, इस कैस्केड में प्रत्येक चरण के प्रभाव की सावधानीपूर्वक निगरानी कर सकते हैं।

ऐसा करने के लिए, हमें लगता है कि कैसे thisb ₁ आउटपुट को बदलने _{के लिए} पहले छिपे हुए न्यूरॉन के _{1 का} कारण बनता है। हमारे पास ₁ = σ (z ₁ ) = w (w ₁ a ₀ + b ₁ ) है, इसलिए

$$

$$\ Delta a_1 \ लगभग \ frac {\ आंशिक \ sigma (w_1 a_0 + b_1)} {\ आंशिक b_1} \ Delta b_1 \ tag {115}$$

$$

$$= \ sigma '(z_1) \ Delta b_1 \ tag {116}$$

शब्द: term (z ₁ ) परिचित दिखना चाहिए: यह ग्रेडिएंट ∂C / ∂b _{1 के} लिए हमारी अभिव्यक्ति का पहला शब्द है। सहज रूप से, यह ऑफसेट 1b ₁ में बदलाव _को आउटपुट सक्रियण के बदलाव ofa ₁ में बदल देता है। बदले में ina ₁ में बदलाव के कारण दूसरे छिपे हुए हारून के भारित इनपुट z ₂ = w ₂ a + b ₂ में परिवर्तन होता है:

$$

$$\ Delta z_2 \ लगभग \ frac {\ आंशिक z_2} {\ आंशिक a_1} \ Delta a_1 \ tag {117}$$

$$

$$= w_2 \ Delta a_1 \ टैग {118}$$

Andz ₂ और wea _{1 के} लिए भावों को मिलाने पर, हम देखते हैं कि पूर्वाग्रह b ₁ में परिवर्तन नेटवर्क के साथ कैसे फैलता है और z _{2 को} प्रभावित करता है:

$$

$$\ Delta z_2 \ लगभग \ sigma '(z_1) w_2 \ Delta b_1 \ tag {119}$$

और यह भी परिचित होना चाहिए: ये क्रमिक /C / 1b _{1 के} लिए हमारी बताई गई अभिव्यक्ति में पहले दो पद हैं।

इसे बाकी नेटवर्क के दौरान कैसे प्रचारित किया जाता है इसकी निगरानी करके आगे जारी रखा जा सकता है। प्रत्येक न्यूरॉन पर हम σ neur (z _j ) शब्द का चयन करते हैं, और प्रत्येक भार के माध्यम से हम w _j शब्द का चयन करते हैं। नतीजतन, एक अभिव्यक्ति प्राप्त की जाती है जो लागत परिवर्तन के अंतिम परिवर्तन theC _को पूर्वाग्रह के प्रारंभिक परिवर्तन bib _{1 से संबंधित करती} है:

$$

$$\ Delta C \ लगभग \ sigma '(z_1) w_2 \ sigma' (z_2) \ ldots \ sigma '(z_4) \ frac {\ आंशिक C} {\ आंशिक a_4} / डेल्टा b_1 \ टैग {120}$$

इसे ,b _{1 से} विभाजित करते हुए, हम वास्तव में ढाल के लिए वांछित अभिव्यक्ति प्राप्त करते हैं:

$$

$$\ frac {\ आंशिक C} {\ आंशिक b_1} = \ sigma ’(z_1) w_2 \ sigma’ (z_2) \ ldots \ sigma ’(z_4) \ frac {\ _ आंशिक \ _} {{आंशिक a_4} \ _ {टैग { 121}$$

क्यों एक लुप्त होती ढाल समस्या है?

यह समझने के लिए कि गायब होने वाली ढाल की समस्या क्यों उत्पन्न होती है, आइए विस्तार से हमारी पूरी अभिव्यक्ति के लिए लिखें:

$$

$$\ frac {\ आंशिक C} {\ आंशिक b_1} = \ sigma '(z_1) \ w_2 \ sigma' (z_2) \ w_3 \ sigma '(z_3) \, w_4' sigma '(z_4) \ \ frac {\ _ आंशिक सी} {\ आंशिक a_4} \ टैग {122}$$

अंतिम शब्द के अलावा, यह अभिव्यक्ति फॉर्म w _j ′ the (z _j ) के शब्दों का उत्पाद है। यह समझने के लिए कि उनमें से प्रत्येक कैसे व्यवहार करता है, हम फ़ंक्शन के ग्राफ को देखते हैं:



ग्राफ बिंदु ′ reaches (0) = 1/4 पर अधिकतम पहुंचता है। यदि हम नेटवर्क वेट को आरंभ करने के लिए मानक दृष्टिकोण का उपयोग करते हैं, तो हम गौसियन वितरण का उपयोग करके वज़न का चयन करते हैं, अर्थात्, रूट माध्य वर्ग शून्य और मानक विचलन 1. इसलिए, आमतौर पर वज़न असमानता को संतुष्ट करेगा। w _j <1 | इन सभी अवलोकनों की तुलना करते हुए, हम देखते हैं कि आमतौर पर असमानता को संतुष्ट करने वाले शब्द w σ ′ (z _j ) | w _j w ′ (z _j ) | <1/4 और अगर हम ऐसे शब्दों के सेट का उत्पाद लेते हैं, तो यह तेजी से घटेगा: जितना अधिक उत्पाद, उतना ही छोटा। यह गायब ढाल की समस्या के संभावित समाधान की तरह प्रतीत होने लगता है।

इसे और अधिक सटीक रूप से लिखने के लिए, हम ,C / withb ₁ के लिए अभिव्यक्ति की तुलना अगले ऑफसेट के संबंध में ग्रेडिएंट की अभिव्यक्ति के साथ करते हैं, उदाहरण के लिए, /C / 3b ₃ । बेशक, हमने ∂C / ,b _{3 के} लिए एक विस्तृत अभिव्यक्ति नहीं लिखी है, लेकिन यह asC / 1b _{1 के} लिए ऊपर वर्णित समान कानूनों का पालन करता है। और यहाँ दो भावों की तुलना है:



उनके कई सामान्य सदस्य हैं। हालाँकि, ग्रेडिएंट /C / theb ₁ में दो अतिरिक्त शब्द शामिल हैं, जिनमें से प्रत्येक में w _j z) (z _j ) फॉर्म है। जैसा कि हमने देखा है, ऐसे शब्द आमतौर पर 1/4 से अधिक नहीं होते हैं। इसलिए, ग्रेडिएंट /C / theb ₁ आमतौर पर /C / .b ₃ से 16 (या अधिक) गुना छोटा होगा। और यह गायब होने वाली ढाल समस्या का मुख्य कारण है।

बेशक, यह सटीक नहीं है, लेकिन समस्या का अनौपचारिक प्रमाण है। कई कैविएट हैं। विशेष रूप से, किसी को इस बात में दिलचस्पी हो सकती है कि क्या प्रशिक्षण के दौरान भार डब्ल्यू बढ़ेगा। यदि ऐसा होता है, तो उत्पाद में शब्द w _j ′ terms (z _j ) असमानता को पूरा नहीं करेगा। w _j | terms (z _j ) | <1/4 और अगर वे 1 से अधिक बड़े हो जाते हैं, तो हमें अब लुप्त होती ढाल की समस्या नहीं होगी। इसके बजाय, ढाल तेजी से बढ़ेगी क्योंकि आप परतों के माध्यम से वापस जाते हैं। और गायब ढाल की समस्या के बजाय, हम विस्फोटक ढाल वृद्धि की समस्या प्राप्त करते हैं।

विस्फोटक ढाल वृद्धि की समस्या

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

विस्फोटक ढाल वृद्धि के लिए, आपको दो कदम उठाने की जरूरत है। सबसे पहले, हम पूरे नेटवर्क में बड़े वजन चुनते हैं, उदाहरण के लिए, w1 = w2 = w3 = w4 = 100। फिर हम ऐसी पारियों का चयन करते हैं ताकि शब्द ′ ifts (z _j ) बहुत छोटे न हों। और यह करना काफी आसान है: हमें केवल ऐसे विस्थापन का चयन करने की आवश्यकता है ताकि प्रत्येक न्यूरॉन का भारित इनपुट zj = 0 (और फिर σ ′ (z _j ) = 1/4) हो। इसलिए, उदाहरण के लिए, हमें z ₁ = w ₁ a ₀ + b ₁ = 0 की आवश्यकता है। इसे b ₁ = be100 _{0 0} सेट करके प्राप्त किया जा सकता है। एक ही विचार का उपयोग अन्य ऑफसेट का चयन करने के लिए किया जा सकता है। परिणामस्वरूप, हम देखेंगे कि सभी शब्द w σ will _j (z _j ) 100 to 14 = 25 के बराबर होंगे। और फिर हमें एक विस्फोटक ढाल वृद्धि मिलती है।

अस्थिर ढाल की समस्या

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

व्यायाम

• , |σ′(z)|<1/4. , , . ?

हमने देखा है कि ढाल एक गहरे नेटवर्क की पहली परतों में विस्फोटक रूप से गायब या विकसित हो सकती है। वास्तव में, सिग्माइड न्यूरॉन्स का उपयोग करते समय, ढाल आमतौर पर गायब हो जाएगा। समझने के लिए क्यों, फिर से अभिव्यक्ति पर विचार करें। wσ z (z) | लुप्त होती क्रमिक समस्या से बचने के लिए, हमें चाहिए | wσ z (z) | .1 | आप तय कर सकते हैं कि w के बहुत बड़े मूल्यों के साथ यह हासिल करना आसान है। हालांकि, वास्तव में यह इतना सरल नहीं है। कारण यह है कि शब्द ′ ′ (z) भी w: ′ z (z) = wa b (wa + b) पर निर्भर करता है, जहां एक इनपुट सक्रियण है। और अगर हम w को बड़ा बनाते हैं, तो हमें समानांतर में σ wa (wa + b) को छोटा नहीं बनाने की कोशिश करनी होगी। और यह एक गंभीर सीमा है। कारण यह है कि जब हम w बड़ा बनाते हैं, तो हम वा + ब को बहुत बड़ा बनाते हैं। यदि आप σ graph के ग्राफ को देखते हैं, तो यह देखा जा सकता है कि यह हमें फ़ंक्शन "” "के" पंख "की ओर ले जाता है,जहां यह बहुत छोटे मूल्यों पर चलता है। और इससे बचने का एकमात्र तरीका आने वाली सक्रियता को मूल्यों की काफी संकीर्ण सीमा में रखना है। कभी-कभी दुर्घटना से ऐसा होता है। लेकिन अधिक बार ऐसा नहीं होता है। इसलिए, सामान्य मामले में, हमारे पास एक गायब होने वाली ढाल की समस्या है।

• |wσ′(wa+b)|. , |wσ′(wa+b)|≥1. , , |w|≥4.
• , |w|≥4, , |wσ′(wa+b)|≥1.
• , , ,

  $$

  $$\frac{2}{|w|} \ln\left( \frac{|w|(1+\sqrt{1-4/|w|})}{2}-1\right) \tag{123}$$
• , |w|≈6.9, ≈0,45. , , , .
• . x, w ₁ , b w ₂ . , , , w ₂ σ(w ₁ x+b)≈x for x∈[0,1]. , , ( ). : x=1/2+Δ, , w ₁ , w ₁ Δ .

हमने प्रत्येक छिपी हुई परत में सिर्फ एक न्यूरॉन के साथ खिलौना नेटवर्क का अध्ययन किया। अधिक जटिल गहरे नेटवर्क के बारे में जो प्रत्येक छिपी हुई परत में कई न्यूरॉन्स हैं?



वास्तव में, इस तरह के नेटवर्क में बहुत कुछ होता है। इससे पहले बैक प्रोपोगेशन के चैप्टर में, हमने देखा कि L लेयर्स वाले नेटवर्क के लेयर में # ग्रेडिएंट निम्नानुसार है:

$$

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

यहाँ Here ′ (z ^l ) विकर्ण मैट्रिक्स है, जिसके तत्व परत संख्या l के भारित इनपुट के लिए σ ′ (z) के मान हैं। डब्ल्यू ^एल अलग-अलग परतों के लिए वेट मैट्रेस हैं। एक ∇ _एक सी - सी उत्पादन सक्रियण का आंशिक डेरिवेटिव के वेक्टर।

यह अभिव्यक्ति एक न्यूरॉन के मामले की तुलना में बहुत अधिक जटिल है। और फिर भी, यदि आप बारीकी से देखते हैं, तो इसका सार बहुत समान होगा, फॉर्म के जोड़े (डब्ल्यू ^जे ) ^{टी j} ) (जेड ^जे ) के एक गुच्छा के साथ । इसके अलावा, मैट्रिसेस the ′ (z ^j ) तिरछे होते हैं, जिनका मूल्य 1/4 से अधिक नहीं होता है। यदि वेट मैट्रिसेस w ^j बहुत बड़ा नहीं है, तो प्रत्येक अतिरिक्त टर्म (w ^j ) ^T ′ ices (z ^l)) ग्रेडिएंट वेक्टर को कम करने के लिए जाता है, जो एक गायब ढाल की ओर जाता है। सामान्य मामले में, गुणा की एक बड़ी संख्या एक अस्थिर ढाल की ओर ले जाती है, जैसा कि हमारे पिछले उदाहरण में है। व्यवहार में, आमतौर पर सिग्मॉइड नेटवर्क में, पहली परतों में ग्रेडिएंट तेजी से तेजी से गायब हो जाते हैं। नतीजतन, इन परतों में सीखना धीमा हो जाता है। और मंदी एक दुर्घटना या असुविधा नहीं है: यह सीखने के लिए हमारे चुने हुए दृष्टिकोण का एक मौलिक परिणाम है।

गहरी सीखने की अन्य बाधाएँ

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

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

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

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