जब मेरा तंत्रिका नेटवर्क नहीं सीखता है तो मुझे क्या करना चाहिए?

Question

मैं एक तंत्रिका नेटवर्क का प्रशिक्षण ले रहा हूं लेकिन प्रशिक्षण हानि कम नहीं होती है। मैं इसे कैसे ठीक करूं?

मैं ओवरफिटिंग या नियमितीकरण के बारे में नहीं पूछ रहा हूं। मैं उस समस्या को हल करने के बारे में पूछ रहा हूं जहां प्रशिक्षण सेट पर मेरे नेटवर्क का प्रदर्शन बेहतर नहीं होता है ।

---

यह प्रश्न जानबूझकर सामान्य है ताकि तंत्रिका नेटवर्क को कैसे प्रशिक्षित किया जाए, इस बारे में अन्य प्रश्न इस एक के डुप्लिकेट के रूप में बंद किए जा सकते हैं, इस दृष्टिकोण के साथ कि "यदि आप एक आदमी को एक मछली देते हैं जो आप उसे एक दिन के लिए खिलाते हैं, लेकिन यदि आप एक सिखाते हैं आदमी मछली के लिए, आप उसे अपने जीवन के बाकी हिस्सों के लिए खिला सकते हैं। " इस मेटा थ्रेड को चर्चा के लिए देखें: "मेरा तंत्रिका नेटवर्क काम नहीं करता है, कृपया जवाब देने के लिए सबसे अच्छा तरीका है" प्रश्नों को ठीक करें?

यदि आपका तंत्रिका नेटवर्क अच्छी तरह से सामान्य नहीं होता है, तो देखें: जब मेरा तंत्रिका नेटवर्क अच्छी तरह से सामान्य नहीं होता है, तो मुझे क्या करना चाहिए?

Comments

यहाँ मामला है जहाँ NN प्रगति नहीं कर सका। youtu.be/iakFfOmanJU?t=144

— जोशुआ

इवानोव का ब्लॉग " कारण आपके तंत्रिका नेटवर्क काम नहीं कर रहा है ", विशेष रूप से अनुभाग II, III और IV, सहायक हो सकते हैं।

— user5228

Answer 1

इकाई परीक्षण आपका मित्र है

लेखकों के बीच एक कहावत है कि "सभी लेखन फिर से लिख रहे हैं" - अर्थात, लेखन का बड़ा हिस्सा संशोधित है। प्रोग्रामर (या कम से कम डेटा वैज्ञानिकों) के लिए अभिव्यक्ति को "सभी कोडिंग डीबगिंग" के रूप में फिर से प्रकाशित किया जा सकता है।

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

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

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

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

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

चेस रॉबर्ट्स द्वारा यह मीडियम पोस्ट, " यूनिट टेस्ट मशीन लर्निंग कोड कैसे करें ", मशीन लर्निंग मॉडल के लिए यूनिट-परीक्षण पर अधिक विस्तार से चर्चा करता है। मैंने लेख से छोटी गाड़ी कोड का यह उदाहरण उधार लिया है:

def make_convnet(input_image):
    net = slim.conv2d(input_image, 32, [11, 11], scope="conv1_11x11")
    net = slim.conv2d(input_image, 64, [5, 5], scope="conv2_5x5")
    net = slim.max_pool2d(net, [4, 4], stride=4, scope='pool1')
    net = slim.conv2d(input_image, 64, [5, 5], scope="conv3_5x5")
    net = slim.conv2d(input_image, 128, [3, 3], scope="conv4_3x3")
    net = slim.max_pool2d(net, [2, 2], scope='pool2')
    net = slim.conv2d(input_image, 128, [3, 3], scope="conv5_3x3")
    net = slim.max_pool2d(net, [2, 2], scope='pool3')
    net = slim.conv2d(input_image, 32, [1, 1], scope="conv6_1x1")
    return net

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

तंत्रिका नेटवर्क से संबंधित सबसे आम प्रोग्रामिंग त्रुटियां हैं

• चर बनाए जाते हैं लेकिन कभी भी उपयोग नहीं किए जाते हैं (आमतौर पर कॉपी-पेस्ट त्रुटियों के कारण);
• ग्रेडिएंट अपडेट के लिए अभिव्यक्तियाँ गलत हैं;
• वजन अपडेट लागू नहीं होते हैं;
• हानि कार्यों को सही पैमाने पर नहीं मापा जाता है (उदाहरण के लिए, संभावना या प्रवेश के संदर्भ में क्रॉस-एन्ट्रापी नुकसान को व्यक्त किया जा सकता है)
• नुकसान कार्य के लिए उपयुक्त नहीं है (उदाहरण के लिए, प्रतिगमन कार्य के लिए श्रेणीबद्ध-एन्ट्रापी नुकसान का उपयोग करना)।

आप चलने से पहले क्रॉल करें; चलने से पहले चलें

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

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

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

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

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

न्यूरल नेटवर्क ट्रेनिंग लॉक पिकिंग की तरह है

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

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

यह कॉन्फ़िगरेशन विकल्पों की एक गैर-विस्तृत सूची है जो नियमितीकरण विकल्प या संख्यात्मक अनुकूलन विकल्प भी नहीं हैं।

ये सभी विषय अनुसंधान के सक्रिय क्षेत्र हैं।

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

• एक तंत्रिका नेटवर्क और एक प्रतिगमन मॉडल के बीच महत्वपूर्ण अंतर यह है कि एक तंत्रिका नेटवर्क कई nonlinear कार्यों की एक रचना है, जिसे सक्रियण फ़ंक्शन कहा जाता है । (देखें: तंत्रिका नेटवर्क और रैखिक प्रतिगमन के बीच आवश्यक अंतर क्या है )

  $\tanh$

  • एक एकल ReLU एक ReLU क्यों नहीं सीख सकता है?
  • मेरा ReLU नेटवर्क लॉन्च करने में विफल है

  कई अन्य विकल्प हैं। देखें: पेशेवरों / विपक्षों के साथ तंत्रिका नेटवर्क में सक्रियण कार्यों की व्यापक सूची

• अवशिष्ट कनेक्शन एक स्वच्छ विकास है जो तंत्रिका नेटवर्क को प्रशिक्षित करना आसान बना सकता है। "डीप अवशिष्ट लर्निंग फॉर इमेज रिकग्निशन" काइमिंग हे, जियानग्यु झांग, शाओकिंग रेन, जियान सन इन: सीवीपीआर। (2016)। इसके अतिरिक्त, अवशिष्ट ब्लॉक के भीतर संचालन के क्रम को बदलने से परिणामस्वरूप नेटवर्क में और सुधार हो सकता है। " दीप अवशिष्ट नेटवर्क में पहचान मैपिंग " Kaiming वह ज़ियांगयू जांग, Shaoqing रेन, और जियान सूर्य द्वारा

गैर-उत्तल अनुकूलन कठिन है

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

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

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

• धीरे - धीरे कतरन ढाल का मान बढ़ाता है अगर यह कुछ सीमा से ऊपर है। मैं समझता था कि यह एक सेट-एंड-भूल पैरामीटर था, आमतौर पर 1.0 पर, लेकिन मैंने पाया कि मैं एक LSTM भाषा मॉडल को नाटकीय रूप से बेहतर बनाकर इसे 0.25 पर सेट कर सकता हूं। मुझे नहीं पता कि ऐसा क्यों है।

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

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

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

  • जब एडजस्ट ठीक काम करता है तो एडम ऑप्टिमाइज़र का उपयोग करके सटीकता में कोई बदलाव नहीं होता है
  • स्टोचस्टिक ढाल वंश की एडम विधि कैसे काम करती है?
  • इस प्रसिद्ध छवि में एक काठी बिंदु से गति क्यों निकलती है?

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

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

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

मानकीकरण

डेटा का पैमाना प्रशिक्षण पर एक बड़ा बदलाव ला सकता है।

• $[-0.5, 0.5]$

  • $[0,1]$

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

  • जोहान ब्योर्क, कार्ला गोम्स, बार्ट सेलमैन द्वारा " अंडरस्टैंडिंग बैच सामान्यीकरण "
  • जोनास कोहलर, हाडी दानेशमंद, ऑरेलिन लुच्ची, मिंग झोउ, क्लाउस नेमेइर, थॉमस हॉफमैन द्वारा " बैच सामान्यीकरण की एक सैद्धांतिक समझ " की ओर
  • शिबनी सांतुरकर, दिमित्रीस सिप्रास, एंड्रयू इलियास, अलेक्जेंडर मैड्री द्वारा " कैसे सामान्यीकरण को बैच सामान्यीकरण मदद करता है? (नहीं, यह आंतरिक सहसंयोजक पारी के बारे में नहीं है) "

नियमितीकरण

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

जब मेरा नेटवर्क नहीं सीखता है, तो मैं सभी नियमितीकरण को बंद कर देता हूं और सत्यापित करता हूं कि गैर-नियमित नेटवर्क सही तरीके से काम करता है। फिर मैं प्रत्येक नियमितीकरण टुकड़े को वापस जोड़ता हूं, और सत्यापित करता हूं कि उनमें से प्रत्येक रास्ते में काम करता है।

यह रणनीति इंगित कर सकती है जहां कुछ नियमितीकरण खराब सेट हो सकते हैं। कुछ उदाहरण निम्न हैं

• $L^2$$L^1$

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

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

प्रयोग की एक लॉगबुक रखें

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

$k$

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

Comments

वहाँ अच्छी सलाह के बहुत सारे। यह दिलचस्प है कि आपकी कितनी टिप्पणियां ऐसी हैं जो मैंने MCMC नमूनाकरण योजनाओं के साथ जटिल मॉडल के मापदंडों या पूर्वानुमानों के डिबगिंग अनुमान के संबंध में की गई टिप्पणियों के समान हैं (या दूसरों को बनाते देखा है)। (उदाहरण के लिए, कोड तब काम कर सकता है जब यह सही ढंग से लागू न हो।)

— Glen_b

@ गेन_ब मुझे नहीं लगता कि सर्वोत्तम प्रथाओं को कोडिंग करने से अधिकांश आँकड़े / मशीन लर्निंग पाठ्यक्रम में पर्याप्त जोर मिलता है यही कारण है कि मैंने उस बिंदु पर बहुत जोर दिया। मैंने कई NN पोस्ट देखे हैं जहाँ ओपी ने एक टिप्पणी छोड़ी थी "ओह, मुझे एक बग अब मिल गया है। यह काम करता है।"

— साइकोरैक्स

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

— मैथ्यू डॉरी

"सभी कोडिंग डिबगिंग है" के लिए +1। मुझे आश्चर्य है कि एसओ पर कितने पोस्टर लगते हैं लगता है कि कोडिंग एक सरल अभ्यास है जिसमें थोड़े प्रयास की आवश्यकता होती है; जो अपने कोड को सही ढंग से काम करने की उम्मीद करते हैं, पहली बार वे इसे चलाते हैं; और जो ऐसा नहीं होने पर आगे बढ़ने में असमर्थ प्रतीत होते हैं। अजीब बात यह है कि वे आधे सही हो रहा है: कोडिंग है आसान है - लेकिन प्रोग्रामिंग कठिन है।

— बॉब जार्विस

Answer 2

पोस्ट किए गए उत्तर बहुत अच्छे हैं, और मैं कुछ "सनिटी चेक" जोड़ना चाहता था जिन्होंने मुझे अतीत में बहुत मदद की है।

1) एक एकल बिंदु पर अपने मॉडल को प्रशिक्षित करें। यदि यह काम करता है, तो इसे दो आउटपुट पर अलग-अलग आउटपुट के साथ प्रशिक्षित करें।

यह कुछ बातों की पुष्टि करता है। सबसे पहले, यह जल्दी से आपको दिखाता है कि आपका मॉडल यह जांचने में सक्षम है कि क्या आपका मॉडल आपके डेटा को ओवरफिट कर सकता है। मेरे मामले में, मैं लगातार बाइनरी भविष्यवाणियों के लिए Dense(1,activation='softmax')बनाम करने की मूर्खतापूर्ण गलतियाँ करता हूं Dense(1,activation='sigmoid'), और पहले वाला कचरा परिणाम देता है।

यदि आपका मॉडल कुछ डेटा बिंदुओं को ओवरफिट करने में असमर्थ है, तो या तो यह बहुत छोटा है (जो कि आज के युग में संभावना नहीं है), या इसकी संरचना या सीखने के एल्गोरिथ्म में कुछ गलत है।

2) अपने प्रारंभिक नुकसान पर ध्यान दें।

$L=-0.3\ln(0.5)-0.7\ln(0.5)\approx 0.7$

$-0.3\ln(0.99)-0.7\ln(0.01) = 3.2$

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

3) डिबग करने के लिए अपने मॉडल आउटपुट को सामान्य करें

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

4) व्यक्तिगत परतों को देखें

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

5) पहले एक सरल मॉडल बनाएँ

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

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

6) अपने प्रीप्रोसेसिंग और पैकेज संस्करणों को मानकीकृत करें

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

इसलिए यदि आप किसी के मॉडल को जीथब से डाउनलोड कर रहे हैं, तो उनके प्रीप्रोसेसिंग पर पूरा ध्यान दें। वे किस छवि लोडर का उपयोग करते हैं? वे कौन सी छवि प्रीप्रोसेसिंग दिनचर्या का उपयोग करते हैं? छवि का आकार बदलते समय, वे किस प्रक्षेप का उपयोग करते हैं? क्या वे पहले आकार बदलते हैं और फिर छवि को सामान्य करते हैं? या फिर इसके विपरीत? RGB छवियों के लिए चैनल ऑर्डर क्या है?

पैकेजों को मानकीकृत करने का सबसे सुरक्षित तरीका एक requirements.txtफ़ाइल का उपयोग करना है जो आपके सभी पैकेजों की तरह ही आपके प्रशिक्षण प्रणाली सेटअप पर, keras==2.1.5संस्करण संख्याओं के नीचे की रूपरेखा तैयार करता है । सिद्धांत रूप में, अपने प्रशिक्षण प्रणाली के समान ही GPU के साथ Docker का उपयोग करना तब उसी परिणाम का उत्पादन करना चाहिए।

Comments

(+1) प्रारंभिक हानि की जाँच करना एक बेहतरीन सुझाव है। मुझे अफसोस है कि मैंने इसे अपने जवाब से बाहर कर दिया।

— साइकोरैक्स

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

— जॉन कोलमैन

Answer 3

शुरू करने के लिए एक तंत्रिका नेटवर्क को प्रशिक्षित न करें!

सभी उत्तर महान हैं, लेकिन एक बिंदु है जिसका उल्लेख किया जाना चाहिए: क्या आपके डेटा से कुछ सीखना है? (जिसे किसी प्रकार का परीक्षण माना जा सकता है)।

यदि आप जिस लेबल की भविष्यवाणी करने की कोशिश कर रहे हैं, वह आपकी विशेषताओं से स्वतंत्र है, तो यह संभावना है कि प्रशिक्षण के नुकसान को कम करने में एक कठिन समय होगा।

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

फिर, यदि आप इन मॉडलों पर एक अच्छा प्रदर्शन प्राप्त करते हैं (यादृच्छिक अनुमान से बेहतर), तो आप एक तंत्रिका नेटवर्क (और @ साइकोरैक्स का जवाब अधिकांश मुद्दों को हल करेंगे) को ट्यून करना शुरू कर सकते हैं।

Comments

$x_k$

— ingolifs

Answer 4

इसके मूल में, एनएन / डीएनएन मॉडल के प्रशिक्षण के लिए मूल वर्कफ़्लो कमोबेश हमेशा एक जैसा होता है:

1. एनएन वास्तुकला (कितनी परतें, किस तरह की परतें, परतों के बीच संबंध, सक्रियण कार्य आदि) को परिभाषित करें।

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

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

4. क्रॉस-मान्यता का उपयोग करते हुए प्रशिक्षण / सत्यापन / परीक्षण सेट में या कई गुना में डेटा को विभाजित करें।

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

6. परीक्षण सेट पर सटीकता की जांच करें, और कुछ नैदानिक ​​भूखंड / टेबल बनाएं।

7. बिंदु 1 पर वापस जाएं क्योंकि परिणाम अच्छे नहीं हैं। पुनरावर्ती विज्ञापन nauseam ।

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

बुनियादी वास्तुकला की जाँच

यह मुद्दों का एक स्रोत हो सकता है। आमतौर पर मैं ये प्रारंभिक जांच करता हूं:

• एक साधारण वास्तुकला की तलाश करें जो आपकी समस्या पर काम करती है (उदाहरण के लिए, छवि वर्गीकरण के मामले में MobileNetV2) और एक उपयुक्त इनिशियलाइज़ेशन लागू करें (इस स्तर पर, यादृच्छिक आमतौर पर करेंगे)। यदि यह आपके डेटा पर सही ढंग से काम करता है, तो कम से कम आप जानते हैं कि डेटा सेट में कोई चकाचौंध के मुद्दे नहीं हैं। यदि आपको एक सरल, परीक्षणित वास्तुकला नहीं मिल रही है जो आपके मामले में काम करती है, तो एक साधारण आधार रेखा के बारे में सोचें । उदाहरण के लिए वर्गीकरण के लिए एक Naive Bayes क्लासिफायर (या यहां तक ​​कि हमेशा सबसे सामान्य वर्ग का वर्गीकरण), या लंबे समय तक श्रृंखला के पूर्वानुमान के लिए एक ARIMA मॉडल।

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

प्रशिक्षण सेट

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

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

अंत में, यह जांचने का सबसे अच्छा तरीका है कि आपके पास प्रशिक्षण सेट समस्याएँ हैं, तो दूसरे प्रशिक्षण सेट का उपयोग करें। यदि आप छवि वर्गीकरण कर रहे हैं, तो आपके द्वारा एकत्र की गई छवियों के बजाय, एक मानक डेटासेट का उपयोग करें जैसे कि CIFAR10 या CIFAR100 (या ImageNet, यदि आप उस पर प्रशिक्षित कर सकते हैं)। इन डेटा सेटों का अच्छी तरह से परीक्षण किया जाता है: यदि आपका प्रशिक्षण नुकसान यहां से नीचे चला जाता है, लेकिन आपके मूल डेटा सेट पर नहीं, तो आपके डेटा सेट में समस्याएँ हो सकती हैं।

गोल्डन टेस्ट करो

दो परीक्षण हैं जिन्हें मैं गोल्डन टेस्ट कहता हूं, जो एक एनएन में मुद्दों को खोजने के लिए बहुत उपयोगी हैं जो ट्रेन नहीं करता है:

• प्रशिक्षण सेट को 1 या 2 नमूने तक कम करें, और इस पर प्रशिक्षण दें। NN को तुरंत प्रशिक्षण सेट पर ओवरफिट करना चाहिए, प्रशिक्षण सेट पर 100% की सटीकता तक बहुत तेज़ी से पहुंचना चाहिए, जबकि सत्यापन / परीक्षण सेट पर सटीकता 0% तक जाएगी। यदि ऐसा नहीं होता है, तो आपके कोड में एक बग है।

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

जांचें कि आपका प्रशिक्षण मीट्रिक समझ में आता है

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

बड़ी तोपों को बाहर लाओ

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

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

Comments

+1, लेकिन "खूनी बृहस्पति नोटबुक"? उस पर टिप्पणी करने के लिए परवाह है? :)

— अमीबा

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

— DeltaIV

मैं संभवतः बहुत नकारात्मक हो रहा हूं, लेकिन स्पष्ट रूप से मैंने GitHub से जुपिटर नोटबुक को क्लोन करने वाले लोगों के साथ पर्याप्त किया है, यह सोचते हुए कि कोड को उनके उपयोग के मामले में अनुकूलित करने के लिए कुछ मिनटों की बात होगी और फिर मेरे पास आकर शिकायत करेंगे कि कुछ भी काम नहीं करता है। Cripes की खातिर, एक असली IDE प्राप्त करें जैसे PyCharm या VisualStudio कोड और नोटबुक बनाने के बजाय एक अच्छी तरह से संरचित कोड बनाएं! खासकर यदि आप मॉडल को उत्पादन के लिए शिपिंग करने की योजना बनाते हैं, तो यह चीजों को बहुत आसान बना देगा।

— DeltaIV

जबरदस्त हंसी। 'ज्यूपिटर नोटबुक' और 'यूनिट टेस्टिंग' परस्पर-विरोधी हैं।

— साइकोरैक्स

(+1) यह एक अच्छा लेखन है। यादृच्छिक परीक्षण के लिए सुझाव, बिगड़े हुए नेटवर्क पर प्राप्त करने के लिए बहुत अच्छे तरीके हैं।

— साइकोरैक्स

Answer 5

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

$\epsilon$