प्राकृतिक भाषा प्रसंस्करण अनुसंधान के लिए कोड लिखना

"कोड अनुरोध पर उपलब्ध है", "लेखक वादा करते हैं ..", एक रेपो जिसमें केवल मॉडल एरोकोम होता है .. हम सभी जानते हैं ... आगे समझाने की आवश्यकता नहीं है।

Beeeeeeeeeeeeeeeeep ...।

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

इस ट्यूटोरियल में, वे एनएलपी अनुसंधान के लिए कोड लिखते समय और एलन एनएलएन टूलकिट के विकास से सीखे गए अपने सर्वोत्तम अभ्यासों और पाठ को संक्षेप में प्रस्तुत करते हैं।

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

शुरू:

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

ट्यूटोरियल भाग 1: प्रोटोटाइप

प्रोटोटाइपिंग के प्राथमिक लक्ष्य हैं:
1) कोड जल्दी लिख।
2) न्यूनतम त्रुटियों के साथ कुछ प्रयोग चलाएं।
3) डिबगिंग मॉडल का व्यवहार।

1) कोड जल्दी लिखना

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

यह अभी भी आपको एक पठनीय कोड के लिए बाध्य करता है, ताकि आप समझ सकें और बनाए रख सकें। यहाँ कुछ उपयोगी सुझाव दिए गए हैं:

  • <<< SHAPE टिप्पणियाँ >>> बाद में आसान डिबगिंग के लिए दसियों पर
  • मशीन नहीं लोगों के लिए कोड लिखें: गैर-स्पष्ट तर्क का वर्णन करने वाली लंबी टिप्पणियां लिखें

न्यूनतम परीक्षण:

  • न्यूनतम परीक्षण करें (लेकिन कोई परीक्षण नहीं): "यदि आप ऐसे परीक्षण लिखते हैं जो प्रायोगिक व्यवहार की जांच करते हैं तो यह समय की बर्बादी है क्योंकि इसे बाद में बदला जा सकता है"
  • हालाँकि, डेटा प्रस्तुत करने के लिए परीक्षण लिखें। कोड। इसका उपयोग बैचों को प्रीप्रोसेस और जेनरेट करने के लिए किया जाएगा और मॉडल समायोजन पर स्वतंत्र होगा इसलिए यह जांचना बेहतर है कि यह सही तरीके से काम कर रहा है। (उदा। यह सुनिश्चित करने के लिए परीक्षण लिखें कि SQUAD डेटासेट पर पढ़ने और मूल्यांकन के लिए कोड सही तरीके से काम कर रहा है)।

हार्ड-कोड, केवल उन हिस्सों पर जो आप ध्यान केंद्रित नहीं कर रहे हैं।

  • इससे नियंत्रित प्रयोग काफी आसान हो जाते हैं (आपके लिए और बाद में आपके कोड का पुनः उपयोग करने वाले लोगों के लिए (यदि कोई हो तो))।

2) चल प्रयोग:

प्रयोग करते समय आपके द्वारा चलाए गए चीज़ों पर नज़र रखें

  • ऐसा करने का सबसे आसान तरीका एक फैल शीट में प्रयोगों के परिणामों में डाल रहा है।
    ध्यान दें कि कोड के किस संस्करण का उपयोग संस्करण नियंत्रण का उपयोग करने के लिए किया गया था।

नियंत्रित प्रयोग: एक समय में केवल एक ही चीज का परीक्षण करें (परीक्षण समाप्त करें)

  • कई चलते भागों के साथ प्रयोग न करें।
  • हर चीज को स्थिर रखते हुए हर बार एक चीज बदलें। यह प्रयोगों को नियंत्रित करने और प्रदर्शन में सुधार लाने के लिए महत्वपूर्ण है।

नियंत्रित प्रयोग कैसे लिखें:

  • मॉडल के लिए एक परम के रूप में सब कुछ नियंत्रित करें।
  • उन मॉडलों को एक कॉन्फ़िगरेशन कोड या एक रनिंग स्क्रिप्ट से लोड करें

3) मॉडल प्रदर्शन का विश्लेषण

उसके लिए Tensorboard बहुत उपयोगी है। यह लगभग सभी डीएल पुस्तकालयों के साथ ही नहीं टेंसरफ्लो के साथ भी संगत है।

यहाँ विज़ुअलाइज़ करने के लिए कुछ उपयोगी मैट्रिक्स की एक सूची दी गई है:
1) हानि, सटीकता
2) स्नातक: मतलब, एसटीडी, वास्तविक अद्यतन मूल्य
3) पैरामीटर: माध्य, एसटीडी
4) सक्रियण: समस्याग्रस्त गतिविधियों को लॉग करें

अपने डेटा को देखें:

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

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

ट्यूटोरियल भाग 2: अच्छी प्रक्रियाओं का विकास:

लेकिन आपको उनमें से कुछ की आवश्यकता है :)

ट्यूटोरियल का दूसरा भाग हर जगह फिर से चलने योग्य होने के लिए अपने प्रयोग में एक अच्छी विकास प्रक्रिया विकसित करने के बारे में था।

  1. स्रोत नियंत्रण का उपयोग करें: "आशा है कि आप पहले से ही ऐसा करते हैं"
  2. कोड समीक्षाएँ:
    * आप के लिए कीड़े का पता लगाएं
    * आप अपने कोड को पठनीय बनाने के लिए बाध्य करें
    * स्पष्ट कोड लिखना कोड की समीक्षा करने की अनुमति देता है मॉडल के लिए ही कोड की चर्चा करें
    * एक कोड प्रकाशित करने से रोकता है और बाद में इसमें ऐसे कीड़े पाए जाते हैं जो आपके परिणामों को गलत बना सकते हैं - यह btw होता है और आपको आपके स्वीकृत कागजात में से एक को वापस लेने के लिए ले जा सकता है।
  3. निरंतर एकीकरण (निर्माण स्वचालन)
  • निरंतर एकीकरण हमेशा एक शाखा में विलय हो सकता है
  • निर्माण स्वचालन हमेशा प्रत्येक मर्ज के साथ परीक्षण चल रहा है

4. अपने कोड का परीक्षण (फिर से परीक्षण फिर से करना)

  • इकाई परीक्षण: एक स्वचालित जाँच है जो आपके कोड का हिस्सा सही ढंग से काम करती है।
  • यदि आप प्रोटोटाइप कर रहे हैं, तो आपको परीक्षण के लिए क्या लिखना चाहिए?
    * बुनियादी बातों का परीक्षण करें: आगे की दिशा दिशाओं का परीक्षण करें जो सीधे परिणामों पर निर्भर नहीं करते हैं
    * जैसे उस बैच को आकार दें जिस आकार की आपको अपेक्षा है
    * जैसे बैच के सभी शब्द शब्दावली में हैं
  • यदि आप एक पुन: प्रयोज्य पुस्तकालय बना रहे हैं, तो आपको किसके लिए परीक्षण लिखना चाहिए?
    << सब कुछ >>
    * मॉडल प्रशिक्षित कर सकते हैं, बचा सकते हैं और लोड कर सकते हैं
    * कि यह बैकप्रॉप ग्रेडिएंट की गणना कर रहा है
  • टेस्ट फिक्सेचर: बड़े डेटासेट पर चल रहे परीक्षण हर बार जब आप विलय करते हैं तो बड़े और धीमे होते हैं। इसके बजाय डेटा की एक छोटी राशि रखें जो रेपो में है और उन पर उन परीक्षणों को चलाएं।
  • चतुर परीक्षणों को लिखने के लिए अपने ज्ञान का उपयोग करें: ध्यान देना कठिन है क्योंकि यह मापदंडों पर निर्भर है: उदा। ध्यान मॉडल का परीक्षण कठिन है, लेकिन आप उस परीक्षण को हैक कर सकते हैं यदि आप सभी ध्यान वजन को बराबर करते हैं जो सभी इनपुट वायरस के औसत के बराबर होगा

ट्यूटोरियल भाग 3: पुन: प्रयोज्य घटकों के लिए कोड लिखना

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

कुछ अमूर्त (अमूर्तता केवल इस प्रकार की कक्षाओं के लिए एक सामान्य वर्ग बना रहा है) उपयोगी साबित हुआ है, लेकिन कुछ नहीं है।

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

एलन एनएलपी से सर्वोत्तम अभ्यास

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

  • मॉडल: मशाल का विस्तार है। nn.module पाइटोरेक से एक ही मॉडल अमूर्त का उपयोग करता है।
    * शब्दावली: all_tokens, tokens2id, id2token ..etc
    * उदाहरण: डेटासेट में ऐसे उदाहरण, जिनका उपयोग शब्दावली बनाने के लिए किया जाता है
    * उदाहरणों में फ़ील्ड्स होते हैं: (स्रोत पाठ, टीजीटी पाठ .. आदि)

और कुछ और सार…
* टोकनइंडेक्सर:
* DataReader:
* DataIterator: बेसिक इटेरेटर: शफल्स बैच
* बकेटाइटर: समूह समान लंबाई वाले उदाहरण हैं
* टोकन
* टोकनएम्बेडर
* RNNs (Seq2Seq, Seq2Vec) के लिए दो अलग-अलग सार |
* ध्यान
* मैट्रिक्सएटेंशन

घोषणात्मक वाक्य रचना:

एलन एनएलपी की अधिकांश वस्तुओं को जेनेटनेट ब्लब्स से त्वरित किया जा सकता है
* यह json का उपयोग करके प्रयोगों को निर्दिष्ट करने की अनुमति देता है
* किसी भी कोड को बदलने के बिना भी वास्तुकला को बदलने की अनुमति देता है।

मॉडल अभिलेखागार:

प्रत्येक प्रशिक्षण लूप एक मॉडल संग्रह बनाता है जो है:
config.json + vocab + प्रशिक्षित मॉडल वज़न

इसका उपयोग परीक्षण पर परीक्षण करने या डेमो करने के लिए किया जा सकता है

डेमो बनाना:

एक मॉडल बनाने के लिए आपको अपने मॉडल की आवश्यकता होती है जोसन और आउटपुट जोंस को स्वीकार करता है
`प्रीडिक्टर्स` आपके मॉडल का एक साधारण जंपर रैपर है जो इसके लिए डिज़ाइन किया गया है।

अभी भी बहुत सारा सामान एलनएनएलपी में नहीं मिला है:

* नियमितीकरण / आरंभीकरण
* प्रीट्रेन किए गए घटकों के साथ मॉडल
* मॉडल जटिल प्रशिक्षण लूप
* कैप्रोप्राइज्ड डेटा कैशिंग
* विस्तार स्वर

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

ट्यूटोरियल भाग 4: अपना कोड कैसे साझा करें

डॉकटर कंटेनरों का उपयोग करें:

डॉकटर द्वारा डराया नहीं जा रहा है, यह काफी सरल है:
1) डॉकटराइल लिखें
2) डॉकर फ़ाइल का उपयोग डॉक चित्र बनाने के लिए किया जाता है
3) कंटेनरों पर डॉक चित्र चलाएँ

स्लाइड्स में तेज़ डॉकटर ट्यूटोरियल है जिसमें सभी महत्वपूर्ण कमांड हैं जिनकी आपको संभवतः आवश्यकता होगी।

अपना कोड जारी करना:

अपना कोड जारी करते समय सुनिश्चित करें कि लोगों के पास आपके कोड को पुन: एकत्रित करने के लिए सही डेटा है, विशिष्ट हो "वेबसाइट पर 27 corenlp जार फाइलें हैं"। लोग आसानी से गलत चीज डाउनलोड कर सकते हैं।

फ़ाइल कैश का उपयोग करें:

अजगर पर्यावरण का उपयोग करें: इसके लिए आप virtualenvs या anaconda पर भरोसा कर सकते हैं। प्रत्येक प्रोजेक्ट के लिए एक नया वर्चुअल एनवी बनाएं। इसे एक आवश्यकता के लिए निर्यात करें। फ़ाइल जो आपके कोड का पुन: उपयोग करने वाले किसी भी व्यक्ति द्वारा स्थापित की जा सकती है

ट्यूटोरियल यहाँ समाप्त होता है ।।

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

ओह स्लाइड्स के बोल, यहाँ आप हैं ..