🌇 ♐️ 📐 नैनो-न्यूरॉन - 7 सरल जावास्क्रिप्ट कार्य दिखाते हैं कि मशीन "सीख" कैसे सकती है 👲🏿 🤸🏽 📋

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

NanoNeuron.js कोड में 7 सरल जावास्क्रिप्ट कार्य शामिल हैं, जिसमें मॉडल सिग्नल को सीखना, प्रशिक्षण, भविष्यवाणी करना और प्रत्यक्ष और पिछड़े प्रसार शामिल हैं। इन कार्यों को लिखने का उद्देश्य पाठक को एक न्यूनतम, बुनियादी स्पष्टीकरण (अंतर्ज्ञान) देना था कि आखिरकार, एक मशीन "कैसे सीख सकती है"। कोड तीसरे पक्ष के पुस्तकालयों का उपयोग नहीं करता है। जैसा कि कहा जाता है, केवल सरल "वेनिला" जावास्क्रिप्ट कार्य करता है।

ये कार्य किसी भी तरह से मशीन सीखने के लिए एक विस्तृत मार्गदर्शिका नहीं हैं। कई मशीन सीखने की अवधारणाएं गायब हैं या सरल हैं! इस सरलीकरण को एकमात्र उद्देश्य के लिए अनुमति दी जाती है - पाठक को मशीन में, सिद्धांत में, "सीखने" के बारे में सबसे बुनियादी समझ और अंतर्ज्ञान देने के लिए, ताकि परिणामस्वरूप, "मशीन सीखने का जादू" मशीन सीखने के "MATHEMATICS" के रूप में पाठक को अधिक से अधिक लगता है।

NanoNeuron

हमारे नैनो-न्यूरॉन "क्या सीखेंगे"

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

वैसे, डिग्री सेल्सियस को डिग्री फ़ारेनहाइट में बदलने का सूत्र निम्नानुसार है:

फारेनहाइट को सेल्सियस

लेकिन फिलहाल, हमारे नैनो-न्यूरॉन को इस सूत्र के बारे में कुछ नहीं पता है ...

नैनो-न्यूरॉन मॉडल

आइए एक फ़ंक्शन बनाकर शुरू करें जो हमारे नैनो-न्यूरॉन के मॉडल का वर्णन करता है। यह मॉडल x और y बीच का एक सरल रैखिक संबंध है, जो इस तरह दिखता है: y = w * x + b । सीधे शब्दों में कहें, हमारा नैनो-न्यूरॉन एक बच्चा है जो XY समन्वय प्रणाली में एक सीधी रेखा खींच सकता है।

चर w और b मॉडल पैरामीटर हैं । एक नैनो-न्यूरॉन एक रैखिक फ़ंक्शन के केवल इन दो मापदंडों को जानता है। ये पैरामीटर ठीक वही हैं जो हमारे नैनो-न्यूरॉन प्रशिक्षण प्रक्रिया के दौरान सीखेंगे।

केवल एक चीज जो इस स्तर पर नैनो-न्यूरॉन कर सकती है, वह है रैखिक संबंधों का अनुकरण करना। वह predict() विधि में ऐसा करता है, जो इनपुट पर एक चर x लेता है और आउटपुट पर चर y भविष्यवाणी करता है। कोई जादू नहीं।

 function NanoNeuron(w, b) { this.w = w; this.b = b; this.predict = (x) => { return x * this.w + this.b; } }

_ (... प्रतीक्षा करें ... रैखिक प्रतिगमन है आप, या क्या?) _

डिग्री सेल्सियस को फ़ारेनहाइट में परिवर्तित करें

डिग्री सेल्सियस में तापमान सूत्र के अनुसार डिग्री फ़ारेनहाइट में परिवर्तित किया जा सकता है: f = 1.8 * c + 32 , जहाँ c का तापमान डिग्री सेल्सियस और f का तापमान फ़ारेनहाइट में होता है।

 function celsiusToFahrenheit(c) { const w = 1.8; const b = 32; const f = c * w + b; return f; };

नतीजतन, हम चाहते हैं कि हमारे नैनो-न्यूरॉन इस विशेष फ़ंक्शन को अनुकरण करने में सक्षम हों। उसे पहले से पता चले बिना पैरामीटर w = 1.8 और b = 32 का अनुमान लगाना (सीखना) होगा।

यह चार्ट पर रूपांतरण फ़ंक्शन कैसे दिखता है। यही हमारे नैनो-न्यूरल "बेबी" को "आकर्षित" करना सीखना चाहिए:

फेरनहाइट रूपांतरण के लिए सेल्सियस

डेटा जनरेशन

शास्त्रीय प्रोग्रामिंग में, हम इस डेटा (पैरामीटर w और b ) को परिवर्तित करने के लिए इनपुट डेटा ( x ) और एल्गोरिदम को जानते हैं, लेकिन आउटपुट डेटा ( y ) अज्ञात है। आउटपुट की गणना एक ज्ञात एल्गोरिथ्म का उपयोग करते हुए इनपुट के आधार पर की जाती है। मशीन लर्निंग में, इसके विपरीत, केवल इनपुट और आउटपुट डेटा ( x और y ) ज्ञात हैं, लेकिन x से y स्विच करने के लिए एल्गोरिथ्म अज्ञात है (पैरामीटर w और b )।

यह इनपुट और आउटपुट की पीढ़ी है जो अब हम करने जा रहे हैं। हमें मॉडल का परीक्षण करने के लिए अपने मॉडल और डेटा के प्रशिक्षण के लिए डेटा उत्पन्न करने की आवश्यकता है। द celsiusToFahrenheit() हेल्पर फंक्शन हमें इसमें मदद करेगा। प्रत्येक प्रशिक्षण और परीक्षण डेटा सेट जोड़े x और y का एक सेट है। उदाहरण के लिए, यदि x = 2 , तो y = 35,6 और इसी तरह।

वास्तविक दुनिया में, अधिकांश डेटा एकत्र होने की संभावना है, उत्पन्न नहीं। उदाहरण के लिए, ऐसे एकत्र किए गए डेटा "फेस फोटोज" -> "व्यक्ति का नाम" के जोड़े का एक सेट हो सकते हैं।

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

वैसे, यहां जीवन सिद्धांत "प्रवेश द्वार पर कचरा - निकास पर कचरा" स्पष्ट रूप से पता लगाया गया है। यदि एक नैनो-न्यूरॉन प्रशिक्षण किट में "झूठ" फेंकता है कि 5 ° C 1000 ° F में बदल जाता है, तो प्रशिक्षण के कई पुनरावृत्तियों के बाद, वह इस पर विश्वास करेगा और 5 ° C को छोड़कर सभी तापमान मानों को सही रूप से परिवर्तित कर देगा। हमें प्रशिक्षण डेटा के साथ बहुत सावधानी बरतने की आवश्यकता है जो हम हर दिन अपने मस्तिष्क तंत्रिका नेटवर्क में लोड करते हैं।

पीछे हटना। चलिए जारी रखते हैं।

हम मूल्यांकन करने के लिए TEST डेटासेट का उपयोग करेंगे कि हमारे नैनो-न्यूरॉन ने कितनी अच्छी तरह प्रशिक्षित किया है और नए डेटा पर सही अनुमान लगा सकते हैं जो उन्होंने अपने प्रशिक्षण के दौरान नहीं देखा था।

 function generateDataSets() { // xTrain -> [0, 1, 2, ...], // yTrain -> [32, 33.8, 35.6, ...] const xTrain = []; const yTrain = []; for (let x = 0; x < 100; x += 1) { const y = celsiusToFahrenheit(x); xTrain.push(x); yTrain.push(y); } // xTest -> [0.5, 1.5, 2.5, ...] // yTest -> [32.9, 34.7, 36.5, ...] const xTest = []; const yTest = []; //   0.5    1,       //   ,       . for (let x = 0.5; x < 100; x += 1) { const y = celsiusToFahrenheit(x); xTest.push(x); yTest.push(y); } return [xTrain, yTrain, xTest, yTest]; }

भविष्यवाणी त्रुटि अनुमान

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

एक नैनो-न्यूरॉन के मामले में, y के वास्तविक मूल्य और भविष्यवाणी के अनुमानित मूल्य के बीच इसकी त्रुटि (त्रुटि) सूत्र द्वारा उत्पादित की जाएगी:

भविष्यवाणी की लागत

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

इस मामले में त्रुटि समारोह इस तरह दिखेगा:

 function predictionCost(y, prediction) { return (y - prediction) ** 2 / 2; // ie -> 235.6 }

प्रत्यक्ष संकेत प्रसार

हमारे मॉडल के माध्यम से प्रत्यक्ष संकेत प्रसार का मतलब है, xTrain और yTrain प्रशिक्षण डेटासेट से सभी जोड़े के लिए भविष्यवाणियां xTrain और इन पूर्वानुमानों की औसत त्रुटि (त्रुटि) की गणना करना।

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

नैनो-न्यूरॉन की औसत भविष्यवाणी त्रुटि निम्नलिखित सूत्र का उपयोग करके की जाएगी:

औसत लागत

जहाँ m प्रशिक्षण प्रतियों की संख्या है (हमारे मामले में, हमारे पास 100 डेटा जोड़े हैं)।

यहाँ हम इसे कोड में कैसे लागू कर सकते हैं:

 function forwardPropagation(model, xTrain, yTrain) { const m = xTrain.length; const predictions = []; let cost = 0; for (let i = 0; i < m; i += 1) { const prediction = nanoNeuron.predict(xTrain[i]); cost += predictionCost(yTrain[i], prediction); predictions.push(prediction); } //     . cost /= m; return [predictions, cost]; }

संकेत उल्टा प्रसार

अब जब हम जानते हैं कि हमारा नैनो-न्यूरॉन अपनी भविष्यवाणियों में सही या गलत है (त्रुटि के औसत मूल्य के आधार पर), तो हम भविष्यवाणियों को अधिक सटीक कैसे बना सकते हैं?

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

यह वह जगह है जहाँ मशीन सीखना जादू की तरह हो जाता है। यहां मुख्य अवधारणा फ़ंक्शन का व्युत्पन्न है , जो दिखाता है कि फ़ंक्शन के न्यूनतम (हमारे मामले में, त्रुटि फ़ंक्शन का न्यूनतम) दृष्टिकोण करने के लिए हमें किस आकार के चरण और किस तरीके की आवश्यकता है।

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

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

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

व्युत्पन्न ढलान

छवि MathIsFun से ली गई है

उदाहरण के लिए, ऊपर दिए गए ग्राफ़ में, आप देखते हैं कि बिंदु पर (x=2, y=4) स्पर्शरेखा (x=2, y=4) ढलान हमें दिखाता है कि हमें फ़ंक्शन के न्यूनतम तक पहुंचने के लिए और जाने की आवश्यकता है। यह भी ध्यान दें कि स्पर्शरेखा का ढलान जितना अधिक होता है, उतनी ही तेजी से हमें न्यूनतम बिंदु तक जाना चाहिए।

w और b के मापदंडों के averageCost में हमारी औसत एरर फंक्शन averageCost का डेरिवेटिव इस तरह दिखेगा:

डीबी

आप यहां जटिल कार्यों के व्युत्पन्न लेने के तरीके के बारे में अधिक विस्तार से पढ़ सकते हैं।

 function backwardPropagation(predictions, xTrain, yTrain) { const m = xTrain.length; //           'w'  'b'. //      0. let dW = 0; let dB = 0; for (let i = 0; i < m; i += 1) { dW += (yTrain[i] - predictions[i]) * xTrain[i]; dB += yTrain[i] - predictions[i]; } //    . dW /= m; dB /= m; return [dW, dB]; }

मॉडल प्रशिक्षण

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

इसलिए, हमें संकेत के आगे और पीछे के प्रसार को कई बार दोहराना होगा। यह trainModel() है trainModel() फ़ंक्शन trainModel() । वह हमारे नैनो-न्यूरॉन के मॉडल के लिए एक "शिक्षक" की तरह है:

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

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

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

हम अपने मॉडल w और b के मापदंडों को निम्नानुसार अपडेट करेंगे:

और इस तरह से प्रशिक्षण ही दिखता है:

 function trainModel({model, epochs, alpha, xTrain, yTrain}) { //     -.  . const costHistory = []; //    ()  for (let epoch = 0; epoch < epochs; epoch += 1) { //   . const [predictions, cost] = forwardPropagation(model, xTrain, yTrain); costHistory.push(cost); //   . const [dW, dB] = backwardPropagation(predictions, xTrain, yTrain); //    -,    . nanoNeuron.w += alpha * dW; nanoNeuron.b += alpha * dB; } return costHistory; }

सभी सुविधाओं को एक साथ रखकर

पहले से बनाए गए सभी कार्यों का एक साथ उपयोग करने का समय।

नैनो-न्यूरॉन मॉडल का एक उदाहरण बनाएँ। फिलहाल, नैनो-न्यूरॉन को इस बारे में कुछ पता नहीं है कि पैरामीटर और b क्या होना चाहिए। तो चलिए w और b बेतरतीब ढंग से सेट करते हैं।

 const w = Math.random(); // ie -> 0.9492 const b = Math.random(); // ie -> 0.4570 const nanoNeuron = new NanoNeuron(w, b);

हम प्रशिक्षण और डेटा सेट का परीक्षण करते हैं।

 const [xTrain, yTrain, xTest, yTest] = generateDataSets();

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

 const epochs = 70000; const alpha = 0.0005; const trainingCostHistory = trainModel({model: nanoNeuron, epochs, alpha, xTrain, yTrain});

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

 console.log('  :', trainingCostHistory[0]); // ie -> 4694.3335043 console.log('  :', trainingCostHistory[epochs - 1]); // ie -> 0.0000024

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

प्रशिक्षण प्रक्रिया

आइए देखें कि हमारे नैनो-न्यूरॉन "सीखे गए" कौन से पैरामीटर हैं। हम उम्मीद करते हैं कि पैरामीटर w और b उसी नाम के मापदंडों से मिलते-जुलते होंगे जैसे कि celsiusToFahrenheit() फ़ंक्शन ( w = 1.8 और b = 32 ), क्योंकि यह उसका नैनो-न्यूरॉन था जिसे मैंने अनुकरण करने की कोशिश की थी।

 console.log(' -:', {w: nanoNeuron.w, b: nanoNeuron.b}); // ie -> {w: 1.8, b: 31.99}

जैसा कि आप देख सकते हैं, नैनो-न्यूरॉन celsiusToFahrenheit() फ़ंक्शन के बहुत करीब है।

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

 [testPredictions, testCost] = forwardPropagation(nanoNeuron, xTest, yTest); console.log('   :', testCost); // ie -> 0.0000023

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

 const tempInCelsius = 70; const customPrediction = nanoNeuron.predict(tempInCelsius); console.log(`- "",  ${tempInCelsius}°C   :`, customPrediction); // -> 158.0002 console.log('  :', celsiusToFahrenheit(tempInCelsius)); // -> 158

बहुत करीब! लोगों की तरह, हमारे नैनो-न्यूरॉन अच्छे हैं, लेकिन सही नहीं :)

सफल कोडिंग!

नैनो-न्यूरॉन को कैसे चलाना और परीक्षण करना है

आप रिपॉजिटरी को क्लोन कर सकते हैं और नैनो न्यूरॉन को स्थानीय रूप से चला सकते हैं:

 git clone https://github.com/trekhleb/nano-neuron.git cd nano-neuron

 node ./NanoNeuron.js

छूटी हुई अवधारणाएँ

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

प्रशिक्षण और परीक्षण डेटा सेट का पृथक्करण

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

ऑनलाइन शक्ति

आमतौर पर आपको ऐसे मामले नहीं मिलेंगे जब केवल एक न्यूरॉन का उपयोग किया जाता है। ताकत ऐसे न्यूरॉन्स के नेटवर्क में है । एक तंत्रिका नेटवर्क बहुत अधिक जटिल निर्भरता सीख सकता है।

ऊपर के उदाहरण में भी, हमारे नैनो-न्यूरॉन एक तंत्रिका नेटवर्क की तुलना में एक सरल रैखिक प्रतिगमन की तरह लग सकते हैं।

इनपुट सामान्यीकरण

प्रशिक्षण से पहले, इनपुट डेटा को सामान्य करने के लिए प्रथागत है।

वेक्टर कार्यान्वयन

तंत्रिका नेटवर्क के लिए, वेक्टर (मैट्रिक्स) गणना छोरों के for गणना की तुलना में बहुत तेज है। आमतौर पर प्रत्यक्ष और रिवर्स सिग्नल प्रसार मैट्रिक्स ऑपरेशन का उपयोग करके किया जाता है, उदाहरण के लिए, पायथन नेम्पी पुस्तकालय।

न्यूनतम त्रुटि समारोह

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

सक्रियण समारोह

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

नैनो-न्यूरॉन - 7 सरल जावास्क्रिप्ट कार्य दिखाते हैं कि मशीन "सीख" कैसे सकती है