मशीन लर्निंग और डीप न्यूरल नेटवर्क्स में सबसे नरम और सबसे तेज़ रास्ता

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

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

स्पॉइलर। चेतावनी!

यह कहानी:

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

वक्ता के बारे में: अलेक्सी ओखरीमेन्को फ्रंटेंड आर्किटेक्चर विभाग में एविटो में काम करता है, और अपने खाली समय में कोणीय मॉस्को मीटअप आयोजित करता है और "फाइव मिनट एंगुलर" जारी करता है। लंबे करियर के दौरान, उन्होंने डिजाइन पैटर्न MALEVICH, PEG व्याकरण पार्सर SimplePEG विकसित किया है। एलेक्सी CSSComb अनुचर नियमित रूप से सम्मेलनों में और अपने JS मशीन लर्निंग टेलीग्राम चैनल पर नई तकनीकों के बारे में ज्ञान साझा करता है ।

मशीन लर्निंग बहुत लोकप्रिय है।

आवाज सहायक, सिरी, Google सहायक, ऐलिस, लोकप्रिय हैं और अक्सर हमारे जीवन में पाए जाते हैं। कई उत्पादों ने पारंपरिक एल्गोरिदम डेटा प्रोसेसिंग से मशीन लर्निंग पर स्विच किया है। एक शानदार उदाहरण Google Translate है।


सभी नवाचार और स्मार्टफोन में सबसे अच्छे चिप्स मशीन सीखने पर आधारित हैं।



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

एक सरल से शुरू करते हैं

हमारी दैनिक प्रोग्रामिंग दिनचर्या क्या है, हम आमतौर पर फ़ंक्शन कैसे लिखते हैं?

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

हम चीजों के इस क्रम के आदी हैं, लेकिन एल्गोरिदम को जाने बिना ऐसा अवसर होगा, लेकिन केवल डेटा और उत्तर होने से, उनसे एल्गोरिथ्म प्राप्त करें।



आप कह सकते हैं: "मैं एक प्रोग्रामर हूं, मैं हमेशा एक एल्गोरिथ्म लिख सकता हूं।"

ठीक है, लेकिन उदाहरण के लिए, यहाँ क्या एल्गोरिथ्म की आवश्यकता है?



मान लीजिए कि बिल्ली के पास तेज कान हैं, और कुत्ते के कान एक पग की तरह सुस्त, छोटे हैं।



आइए समझने की कोशिश करते हैं कि कानों से कौन है। लेकिन कुछ बिंदु पर, हमें पता चलता है कि कुत्तों के पास तेज कान हो सकते हैं।



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

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

एक समाधान है - यह मशीन लर्निंग है, जिसका एक भाग है - गहरे तंत्रिका नेटवर्क।

गहरी तंत्रिका नेटवर्क

मशीन लर्निंग एक बहुत बड़ा क्षेत्र है। यह एक विशाल मात्रा में विधियाँ प्रदान करता है, और प्रत्येक अपने तरीके से अच्छा है।



उनमें से एक डीप न्यूरल नेटवर्क है। डीप लर्निंग का एक निर्विवाद लाभ है जिसके कारण यह लोकप्रिय हो गया है।

इस लाभ को समझने के लिए, आइए एक उदाहरण के रूप में बिल्लियों और कुत्तों का उपयोग करके शास्त्रीय वर्गीकरण समस्या को देखें।

डेटा है: चित्र या तस्वीरें। पहली बात यह है कि एम्बेड करना (एम्बेड करना), यानी डेटा को बदलना ताकि मशीन उनके साथ काम करने में सहज हो। चित्रों के साथ काम करने के लिए यह असुविधाजनक है, कार को कुछ सरल चाहिए।

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



डेटा की इस प्रस्तुति के साथ, तंत्रिका नेटवर्क पहले से ही काम कर सकते हैं।

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

• पहला फ़ंक्शन 1 पर लौटेगा यदि यह एक बिल्ली है, और 0 अगर यह बिल्ली नहीं है।
• अगर यह कुत्ता है तो दूसरा फंक्शन 1 लौटेगा, और अगर कुत्ता नहीं तो 0।

किसी प्रतिक्रिया को कोड करने के लिए इस दृष्टिकोण को वन-हॉट एन्कोडिंग कहा जाता है।



पहले से ही, गहरे तंत्रिका नेटवर्क की कई विशेषताएं ध्यान देने योग्य हैं:

• तंत्रिका नेटवर्क के साथ काम करने के लिए, आपको इनपुट पर डेटा को एनकोड करना होगा और आउटपुट पर डीकोड करना होगा।
• एन्कोडिंग हमें डेटा से अमूर्त करने की अनुमति देता है।
• इनपुट डेटा को बदलकर, हम विभिन्न डोमेन डोमेन के लिए तंत्रिका नेटवर्क उत्पन्न कर सकते हैं। यहां तक ​​कि जिनमें हम विशेषज्ञ नहीं हैं।

यह जानना आवश्यक नहीं है कि बिल्ली क्या है, कुत्ता क्या है। यह एक अतिरिक्त परत के लिए आवश्यक संख्याओं का चयन करने के लिए पर्याप्त है।

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



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

अब देखते हैं कि इन सभी परतों के लिए मूल्यों का चयन कैसे किया जाता है। एक शांत दृश्य है जो आपको यह समझने की अनुमति देता है कि सीखने की प्रक्रिया कैसे होती है।



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

मशीन सीखना कठिन है

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

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



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

ब्लैकबॉक्स - एक साधारण दृष्टिकोण

यह जानने के लिए मशीन सीखने के सभी पहलुओं को समझना आवश्यक नहीं है कि अपने व्यावसायिक कार्यों में तंत्रिका नेटवर्क कैसे लागू करें। मैं कुछ उदाहरण दिखाऊंगा जो आपको प्रेरणा देते हैं।

कई लोगों के लिए, एक कार एक ब्लैक बॉक्स भी है। लेकिन अगर आप यह नहीं जानते कि यह कैसे काम करता है, तो आपको नियमों को सीखने की जरूरत है। तो मशीन सीखने के साथ - आपको अभी भी कुछ नियमों को जानने की आवश्यकता है:

• TensorFlow JS (तंत्रिका नेटवर्क के साथ काम करने के लिए पुस्तकालय) जानें।
• मॉडल चुनना सीखें।

हम इन कार्यों पर ध्यान केंद्रित करते हैं और कोड के साथ शुरू करते हैं।

कोड बनाकर सीखना

TensorFlow लाइब्रेरी को भारी संख्या में भाषाओं के लिए लिखा गया है: अजगर, C / C ++, JavaScript, Go, Java, Swift, C #, Haskell, Julia, R, Scala, Rust, OCaml, Crystal। लेकिन हम निश्चित रूप से सर्वश्रेष्ठ - जावास्क्रिप्ट का चयन करेंगे।

TensorFlow एक स्क्रिप्ट को CDN से जोड़कर हमारे पेज से जुड़ सकता है:

<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@1.0.0/dist/tf.min.js"></script> 

या npm का उपयोग करें:

• npm install @tensorflow/tfjs-node - नोड प्रक्रिया (वेबसाइट) के लिए;
• npm install @tensorflow/tfjs-node-gpu (लिनक्स CUDA) npm install @tensorflow/tfjs-node-gpu , लेकिन केवल अगर लिनक्स मशीन और वीडियो कार्ड CUDA तकनीक का समर्थन करता है। यह सुनिश्चित करना सुनिश्चित करें कि CUDA कंप्यूट क्षमता आपकी लाइब्रेरी से मेल खाती है, ताकि यह पता न चले कि महंगा हार्डवेयर उपयुक्त नहीं है।
• npm install @tensorflow/tfjs का उपयोग किए बिना एक ब्राउज़र के लिए npm install @tensorflow/tfjs (सबसे धीमा / ब्राउज़र) -

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

tensors

जब प्रारंभिक डेटा तैयार हो जाता है, तो सबसे पहले TensorFlow आयात किया जाता है । वीडियो कार्ड की शक्ति के कारण त्वरण प्राप्त करने के लिए हम टेंसरफ़्लो / tfjs-node-gpu का उपयोग करेंगे।

 //  @tensorflow/tfjs-node-gpu  node.js const tf = require('@tensorflow/tfjs'); const a = [[1,2], [3,4]]; 

एक दो-आयामी डेटा सरणी है - हम इसके साथ काम करेंगे।

अगली महत्वपूर्ण बात यह है कि एक टेंसर बनाएं । इस स्थिति में, एक टेंसर रैंक 2 से बना होता है, जो वास्तव में एक दो-आयामी सरणी है। हम डेटा ट्रांसफर करते हैं और 2x2 टेंसर प्राप्त करते हैं।

 //  rank-2  (/) const b = tf.tensor([[1,2], [3,4]]); console.log('shape:', b.shape); b.print() 

ध्यान दें कि print विधि को कहा जाता है, न कि console.log , क्योंकि b (हमने जो टेन्सर बनाया है) एक सामान्य ऑब्जेक्ट नहीं है, जिसका नाम टैंसर है। उसकी अपनी विधियाँ और गुण हैं।

आप एक प्लैनर सरणी से एक टेंसर भी बना सकते हैं और इसके आकार को ध्यान में रख सकते हैं, आइए बताते हैं। यही है, एक फॉर्म को घोषित करने के लिए - एक द्वि-आयामी सरणी - बस एक फ्लैट सरणी प्रसारित करने और सीधे रूप को इंगित करने के लिए। परिणाम वही होगा।

इस तथ्य के कारण कि डेटा और फ़ॉर्म को अलग-अलग संग्रहीत किया जा सकता है, टेंसर के आकार को बदलना संभव है। हम reshape विधि को कॉल कर सकते हैं और 2x2 से 4x1 तक आकृति बदल सकते हैं।

अगला महत्वपूर्ण कदम डेटा को आउटपुट करना है , इसे वास्तविक दुनिया में वापस लौटाएं।

 //   const g = tf.tensor([[1,2], [3,4]]); g.data().then((raw) => { console.log('async raw value of g:', raw); }); console.log('raw value of g:', g.dataSync()); console.log('raw multidimensional value of g:', g.arraySync()); 

सभी तीन चरणों के लिए कोड ।

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

dataSync विधि हमेशा समतल सरणी प्रारूप में डेटा लौटाती है। और अगर हम डेटा को उस प्रारूप में वापस करना चाहते हैं जिसमें वे टेंसर में संग्रहीत हैं, तो हमें arraySync को कॉल arraySync ।

ऑपरेटरों

TensorFlow में सभी ऑपरेटर डिफ़ॉल्ट रूप से अपरिवर्तनीय हैं, अर्थात प्रत्येक ऑपरेशन में एक नया टेंसर हमेशा वापस आ जाता है। ऊपर, बस हमारे सरणी को लें और इसके सभी तत्वों को वर्ग करें।

 //   Immutable const x = tf.tensor([1,2,3,4]); const y = x.square(); // tf.square(x); y.print(); 

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

अब सबसे महत्वपूर्ण चीज मॉडल है।

आदर्श

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

परत ही दसियों और ऑपरेटरों का एक अमूर्त हिस्सा है। मोटे तौर पर, ये सहायक कार्य हैं जो गणित की एक बड़ी मात्रा को आपसे छिपाते हैं।

 //    const model = tf.sequential({ layers: [ tf.layers.dense({ inputShape: [784], units: 32, activation: 'relu' }), tf.layers.dense({ units: 10, activation: 'softmax' }) ] }); 

आइए कार्यान्वयन विवरण में जाने के बिना मॉडल के साथ कैसे काम करें, यह समझने की कोशिश करें।

सबसे पहले, हम तंत्रिका नेटवर्क में आने वाले डेटा के रूप को इंगित करते हैं - inputShape एक आवश्यक पैरामीटर है। हम units इंगित करते units - बहुआयामी सरणियों की संख्या और सक्रियण फ़ंक्शन।

relu समारोह इस relu उल्लेखनीय है कि यह संयोग से पाया गया - यह कोशिश की गई, इसने बेहतर काम किया, और बहुत लंबे समय के लिए तब उन्होंने गणितीय स्पष्टीकरण की खोज की कि ऐसा क्यों होता है।

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

 //   const input = tf.input({ shape: [784] }); const dense1 = tf.layers.dense({ units: 32, activation: 'relu' }).apply(input); const dense2 = tf.layers.dense({ units: 10, activation: 'softmax' }).apply(dense1); const model = tf.model({ inputs: input, outputs: dense2 }); 

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

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

इसके बाद, मॉडल को संकलित करने के लिए एक महत्वपूर्ण कदम है। आइए समझने की कोशिश करें कि tjjs के संदर्भ में क्या संकलन है।

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

 //   (  ) model.compile({ optimizer: 'sgd', loss: 'categoricalCrossentropy', metrics: ['accuracy'] }); 

अनुक्रमिक परतों और संकलन के विवरण के लिए कोड ।

मैं यह बताऊंगा कि एक ऑप्टिमाइज़र क्या है और एक नुकसान फ़ंक्शन क्या है।



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

हानि फ़ंक्शन वह तरीका है जिसके द्वारा हम इष्टतम मूल्य (छोटे काले तीर) की तलाश करते हैं। यह समझने में मदद करता है कि हमारे तंत्रिका नेटवर्क को प्रशिक्षित करने के लिए किन ढाल मूल्यों का उपयोग करना है।

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

नेटवर्क लर्निंग उदाहरण

हम यादृच्छिक डेटा और यादृच्छिक उत्तर (लेबल) उत्पन्न करेंगे। हम fit मॉड्यूल को कॉल करते हैं, डेटा, उत्तर और कई महत्वपूर्ण पैरामीटर पास करते हैं:

• epochs - 5 बार, यानी मोटे तौर पर, 5 बार हम एक पूर्ण प्रशिक्षण का संचालन करेंगे;
• batchSize , जो कहता है कि एक बार उठाने के लिए कितने वज़न को बदला जा सकता है - एक ही समय में कितने तत्वों को संसाधित करने के लिए। वीडियो कार्ड जितना बेहतर होगा, इसकी मेमोरी batchSize ही अधिक batchSize होगी।

 //   const data = tf.randomNormal([100, 784]); const labels = tf.randomNormal([100, 10]); //   model.fit(data, labels, { epochs: 5, batchSize: 32 }).then(info => { console.log('  :', info.history.acc); }) 

सभी अंतिम चरणों का कोड ।

Model.fit एसिंक्रोनस विधि, रिटर्न का वादा करें। लेकिन आप async / प्रतीक्षा का उपयोग कर सकते हैं और उस तरह से निष्पादन की प्रतीक्षा कर सकते हैं।

अगला अप उपयोग है । हमने अपने मॉडल को प्रशिक्षित किया, फिर हम उस डेटा को लेते हैं जिसे हम संसाधित करना चाहते हैं, और हम predict विधि कहते हैं, हम कहते हैं: "भविष्यवाणी करें कि वास्तव में क्या है?", और इसके लिए धन्यवाद हमें परिणाम मिलता है।

मानक संरचना

प्रत्येक तंत्रिका नेटवर्क में तीन मुख्य फाइलें होती हैं:

• index.js - फाइल जिसमें तंत्रिका नेटवर्क के सभी मापदंडों को संग्रहीत किया जाता है;
• model.js - एक फ़ाइल जिसमें मॉडल और इसकी वास्तुकला को सीधे संग्रहीत किया जाता है;
• data.js - एक फाइल जहां डेटा को एकत्र किया जाता है, संसाधित किया जाता है, और हमारे सिस्टम में एम्बेडेड होता है।

इसलिए, मैंने TensorFlow.js को सीखने के तरीके के बारे में बात की। लघु व्यवसाय, यह एक मॉडल का चयन करने के लिए रहता है ।

दुर्भाग्य से, यह पूरी तरह सच नहीं है। वास्तव में, हर बार जब आप एक मॉडल चुनते हैं, तो आपको कुछ चरणों को दोहराना होगा।

• इसके लिए डेटा तैयार करें, यानी एम्बेडिंग करें, इसे आर्किटेक्चर में समायोजित करें।
• हाइपर सेटिंग्स कॉन्फ़िगर करें (मैं आपको बाद में बताऊंगा कि इसका क्या अर्थ है)।
• प्रत्येक तंत्रिका नेटवर्क को प्रशिक्षित / प्रशिक्षित करना (प्रत्येक मॉडल की अपनी बारीकियां हो सकती हैं)।
• एक तंत्रिका मॉडल लागू करें, और फिर से, आप विभिन्न तरीकों से आवेदन कर सकते हैं।

एक मॉडल चुनें

आइए उन बुनियादी विकल्पों से शुरू करें जिन्हें आप अक्सर सामना करेंगे।

गहरा भाव

यह एक गहरे तंत्रिका नेटवर्क का एक लोकप्रिय उदाहरण है। सब कुछ काफी सरलता से किया जाता है: सार्वजनिक रूप से उपलब्ध डेटासेट - MNIST डाटासेट है।


इन्हें संख्याओं के साथ लेबल किए गए चित्र हैं, जिसके आधार पर तंत्रिका नेटवर्क को प्रशिक्षित करना सुविधाजनक है।

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

 const model = tf.sequential({ layers: [ tf.layers.dense({ inputShape: [784], units: 512, activation: 'relu' }), tf.layers.dense({ units: 256, activation: 'relu' }), tf.layers.dense({ units: 10, activation: 'softmax' }), ] }); 

हम चित्र को एक आयामी सरणी में सीधा करते हैं, हमें 784 तत्व मिलते हैं। एक परत में 512 सरणियाँ। सक्रियण समारोह 'relu' ।

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

अंत में हम 10 मैट्रीक बनाते हैं और वन-हॉट एन्कोडिंग के लिए सॉफ्टमैक्स सक्रियण का उपयोग करते हैं - इस प्रकार की प्रतिक्रिया एन्कोडिंग के साथ इस प्रकार की सक्रियता अच्छी तरह से काम करती है।

दीप नेटवर्क आपको 80-90% चित्रों को सही ढंग से पहचानने की अनुमति देता है - मुझे और चाहिए। एक व्यक्ति लगभग 96% की गुणवत्ता के साथ पहचानता है। क्या तंत्रिका नेटवर्क किसी व्यक्ति को पकड़ सकते हैं और उससे आगे निकल सकते हैं?

सीएनएन (संवेदी तंत्रिका नेटवर्क)

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

इस प्रकार, छवि का आकार कम हो जाता है, लेकिन एक ही समय में छवि के कुछ हिस्सों को बेहतर और बेहतर माना जाता है। कन्वर्ज़न नेटवर्क, पैटर्न रिकग्निशन के लिए बहुत अच्छा काम करता है, यहाँ तक कि इंसानों से भी बेहतर।

चित्रों को पहचानना एक व्यक्ति की तुलना में कार को बेहतर ढंग से सौंपा गया है। एक विशेष अध्ययन था, और व्यक्ति, दुर्भाग्य से, खो गया।

CNN बहुत सरलता से काम करते हैं:

 const model = tf.sequential({ layers: [ tf.layers.conv2d({ inputShape: [28, 28, 1], filters: 32, kernelSize: 3, activation: 'relu', }), tf.layers.conv2d({ filters: 32, kernelSize: 3, activation: 'relu', }), tf.layers.maxPooling2d({poolSize: [2, 2]}), tf.layers.conv2d({ filters: 64, kernelSize: 3, activation: 'relu', }) tf.layers.flatten(tf.layers.maxPooling2d({ poolSize: [2, 2] })), tf.layers.dense({units: 512, activation: 'relu'}), tf.layers.dense({units: 10, activation: 'softmax'}) ] }); 

हम एक विशिष्ट बहुआयामी सरणी इनपुट करते हैं: 28x28 पिक्सेल की छवि, चमक के लिए एक आयाम, इस मामले में छवि काली और सफेद है, इसलिए तीसरा आयाम 1 है।

अगला, हम filters और kernelSize की संख्या निर्धारित करते kernelSize - कितने पिक्सेल संकीर्ण होंगे। सक्रियण समारोह हर जगह relu ।

एक और परत है maxPooling2d , जिसे और भी अधिक कुशलता से आकार को कम करने की आवश्यकता है। संवेगात्मक नेटवर्क आकार को बहुत धीरे-धीरे संकीर्ण करते हैं, और अक्सर बहुत गहरे संवादात्मक नेटवर्क बनाने की आवश्यकता नहीं होती है।

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

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

यू नेट

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

एक सरल उदाहरण: शोर डेटा के बीच आपको कैंसर कोशिकाओं (हलकों) को खोजने की आवश्यकता है।



यू-नेट इतना अच्छा है कि यह उन्हें लगभग पूरी तरह से पा सकता है। वास्तुकला बहुत सरल है:



मैक्सपूलिंग की तरह ही कनवल्शन नेटवर्क भी हैं, जो आकार को कम करता है। एकमात्र अंतर: मॉडल स्कैन नेटवर्क का भी उपयोग करता है - डीकोनवेल्वेशनल नेटवर्क ।

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

 //First part (down climb) const input = buildInput(...IMAGE_INPUT); const conv1 = genConv2D(64).apply(input); const conv2 = genConv2D(64).apply(conv1); const pool1 = geMaxPool2D(2).apply(conv2); const conv3 = genConv2D(128).apply(pool1); const conv4 = genConv2D(128).apply(conv3); const pool2 = geMaxPool2D(2).apply(conv4); const conv5 = genConv2D(256).apply(pool2); const conv6 = genConv2D(256).apply(conv5); const pool3 = geMaxPool2D(2).apply(conv6); const conv7 = genConv2D(512).apply(pool3); const conv8 = genConv2D(512).apply(conv7); const pool4 = geMaxPool2D(2).apply(conv8); const conv9 = genConv2D(1024).apply(pool4); const conv10 = genConv2D(1024).apply(conv9); const up1 = genUp2D().apply(conv10); const merge1 = tf.layers.concatenate({ axis: 3 }).apply([up1, conv8]); //Second part (up climb) const conv11 = genConv2D(512).apply(merge1); const conv12 = genConv2D(512).apply(conv11); const up2 = genUp2D().apply(conv12); const merge2 = tf.layers.concatenate({ axis: 3 }).apply([up2, conv6]); const conv13 = genConv2D(256).apply(merge2); const conv14 = genConv2D(256).apply(conv13); const up3 = genUp2D().apply(conv14); const merge3 = tf.layers.concatenate({ axis: 3 }).apply([up3, conv4]); const conv15 = genConv2D(128).apply(merge3); const conv16 = genConv2D(128).apply(conv15); const up4 = genUp2D().apply(conv16); const merge4 = tf.layers.concatenate({ axis: 3 }).apply([up4, conv2]); const conv17 = genConv2D(64).apply(merge4); const conv18 = genConv2D(64).apply(conv17); const conv19 = tf.layers .conv2d({ kernelSize: [1, 1], activation: "sigmoid", filters: 1, padding: "same" }) .apply(conv18); const model = tf.model({ inputs: input, outputs: conv19 }); 

यह कोड संपादक में सीखना आसान है। सामान्य तौर पर, बड़ी संख्या में दृढ़ संकल्प नेटवर्क यहां बनाए जाते हैं, और फिर उन्हें वापस तैनात करने के लिए, हम कई परतों को concatenate और विलय करते हैं। यह केवल कोड रूप में, किसी चित्र का दृश्य है। सब कुछ काफी सरल है - ऐसे मॉडल की नकल करना और पुन: पेश करना आसान है।

LSTM (लंबी अवधि की मेमोरी)

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

उदाहरण के लिए, एक सेवा Yandex.Referats है, जो अमूर्त उत्पन्न करती है।



वह पूरी तरह से अबरकदबरा देता है, लेकिन एक ही समय में सच के समान है:

विषय पर गणित में सार: "एक स्वयंसिद्ध न्यूटन की द्विपद"

पूर्ववर्ती के अनुसार, सतह अभिन्न एक वक्रता अभिन्न उत्पादन करता है। नीचे तक फ़ंक्शन उत्तल अभी भी मांग में है।

यह स्वाभाविक रूप से इस प्रकार है कि सतह पर सामान्य अभी भी मांग में है। पिछले के अनुसार, पॉइसन इंटीग्रल अनिवार्य रूप से त्रिकोणमितीय पॉइसोन इंटीग्रल को निर्दिष्ट करता है।

सेवा Seq-to-Seq तंत्रिका नेटवर्क पर आधारित है। उनकी वास्तुकला अधिक जटिल है।



परतों को एक जटिल प्रणाली में व्यवस्थित किया जाता है। लेकिन चिंतित मत हो - आपको इन सभी तीरों का संचालन करने की आवश्यकता नहीं है। यदि आप चाहें, तो आप कर सकते हैं, लेकिन आवश्यक नहीं। एक सहायक है जो आपके लिए ऐसा करेगा।

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

कोड में सब कुछ सुंदर दिखता है:

 tf.sequential({ layers: [ tf.layers.lstm({ units: 512, returnSequences: true, inputShape: [10000, 64] }), tf.layers.lstm({ units: 512, returnSequences: false }), tf.layers.dense({ units: 64, activation: 'softmax' }) ] }) ; 

एक विशेष सहायक है जो कहता है कि हमारे पास 512 ऑब्जेक्ट्स (सरणियाँ) हैं। अगला, अनुक्रम और इनपुट फॉर्म ( inputShape: [10000, 64] ) वापस करें। आगे हम एक और परत पेश करते हैं, लेकिन हम अनुक्रम नहीं लौटाते हैं ( returnSequences: false ), क्योंकि अंत में हम कहते हैं कि अब हमें 64 विभिन्न वर्णों (लोअरकेस और अपरकेस अक्षरों) के लिए सक्रियण फ़ंक्शन का उपयोग करने की आवश्यकता है। वन-हॉट एन्कोडिंग का उपयोग करके 64 विकल्प सक्रिय हैं।

सबसे दिलचस्प

अब, आप शायद सोच रहे हैं: "यह सब, निश्चित रूप से, अच्छा है, लेकिन मुझे इसकी आवश्यकता क्यों है? "कैंसर से लड़ना अच्छा है, लेकिन मुझे फ्रंट-लाइन में इसकी आवश्यकता क्यों है?"

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

तंत्रिका नेटवर्क की मदद से उन समस्याओं को हल करना संभव है जो पहले हल करना असंभव था। कुछ ऐसा जो आप सोच भी नहीं सकते थे। यह सब आप पर निर्भर करता है, आपकी कल्पना और थोड़ा अभ्यास।

अब मैं उन मॉडलों के उपयोग के दिलचस्प उदाहरण दिखाऊंगा जिनकी हमने जांच की थी।

सीएनएन। ऑडियो टीमों

कनवल्शन नेटवर्क का उपयोग करके, आप न केवल चित्रों को, बल्कि ऑडियो कमांड्स को भी पहचान सकते हैं, और 97% मान्यता गुणवत्ता के साथ, अर्थात, Google सहायक और यांडेक्स-एलिस के स्तर पर।

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

एलिस के बारे में अधिक जानकारी निकिता दुबो की रिपोर्ट में और Google सहायक के बारे में मिल सकती है कि इसमें आवाज के साथ कैसे काम किया जाए, और ब्राउज़र मानकों के बारे में, यहाँ ।

तथ्य यह है कि किसी भी शब्द, किसी भी आदेश को एक स्पेक्ट्रोग्राम में बदल दिया जा सकता है।


आप किसी भी ऑडियो जानकारी को ऐसे स्पेक्ट्रोग्राम में बदल सकते हैं। और फिर आप तस्वीर में ऑडियो को एनकोड कर सकते हैं, और सीएनएन को तस्वीर पर लागू कर सकते हैं और सरल वॉइस कमांड को पहचान सकते हैं।

यू-नेट। स्क्रीनशॉट परीक्षण

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

स्क्रीनशॉट के परीक्षण के लिए, दो स्क्रीनशॉट की आवश्यकता है:

• बुनियादी (संदर्भ) जिसके साथ हम तुलना कर रहे हैं;
• परीक्षण के लिए स्क्रीनशॉट।

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

याद रखें, हमने उस क्षेत्र पर छवि को चिह्नित किया है जहां कैंसर है और नहीं। वही यहां किया जा सकता है।



यदि हम एक अच्छे लेआउट के साथ एक तस्वीर देखते हैं, तो हम इसे चिह्नित नहीं करते हैं, और हम एक खराब लेआउट के साथ चित्रों को चिह्नित करते हैं। इस प्रकार, आप एकल चित्र के साथ लेआउट का परीक्षण कर सकते हैं। , , , . U-Net .

, , . , U-Net, . , .

LSTM. Twitter — 2000

, , , .

, LSTM . 40 - , : « — » .

, :



- , ?

— . - :





, «» , , (, ).

: « » « » .

— .

« ».

:

EPOCS 250

, .

- , , , . , Overfitting — .

, — . , , . , , , .

, , .

, .



, , , . ( , ), . .

— . .

overfitting. , helper-: Dropout; BatchNormalization.

LSTM. Prettier

, — Prettier . , .

const a = 1 . : []c co on ns st , , : [][] []c co on ns st , .

, , .

, , . , , 0 — , - , - . .

, . .

निष्कर्ष के बजाय

, , . . , , Deep Neural Network.

. , . . . .

JS, , . , . , JavaScript, . TensorFlow.js.

, . telegram- JS.

FrontendConf , 13 . 32 .

, , . Saint AppsConf, . , , , .