👩‍✈️ 👨🏽‍🌾 💆🏽 डमी के लिए तंत्रिका नेटवर्क। भाग 2

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

प्रोग्रामिंग भाषा, इस बार - सी #।
रुचि कृपया बिल्ली के नीचे।

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

पहले लेख में, एक विशिष्ट अंक को पहचानने के लिए जिम्मेदार तत्व एक निश्चित "न्यूरॉन" था (जो वास्तव में, काफी नहीं था, लेकिन सादगी के लिए लिया गया था)।
गौर कीजिए कि यह क्या है।

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

क्योंकि यदि छवि काले और सफेद में इनपुट है, तो अक्षतंतु के इनपुट पर केवल 1 या 0 हो सकता है:

और आउटपुट या तो वजन मान या 0 है।
मोटे तौर पर, अगर प्रवेश द्वार पर कुछ है, तो पैर "चिकोटी" शुरू होता है, न्यूरॉन को बताता है कि इस पर जानकारी है। यह कितना "ट्विच" है, नेटवर्क द्वारा किया गया निर्णय निर्भर करेगा।
अक्षों की संख्या इनपुट सरणी में तत्वों की संख्या से मेल खाती है। इस लेख में, मैं इनपुट के रूप में 3x5 पिक्सेल आकार में उपयोग करूँगा। तदनुसार, न्यूरॉन में प्रवेश करने वाले कनेक्शनों की संख्या 3 x 5 = 15 होगी।

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

चलो सॉफ्टवेयर कार्यान्वयन के लिए आगे बढ़ते हैं।
एक न्यूरॉन वर्ग बनाएँ:

class Web { public int[,] mul; //      public int[,] weight; //     public int[,] input; //   public int limit = 9; //  -  ,    public int sum ; //      public Web(int sizex, int sizey,int[,] inP) //      { weight = new int[sizex, sizey]; //     ( ) mul = new int[sizex, sizey]; input = new int[sizex, sizey]; input = inP; //    }

हां, मैं जानता हूं कि सिग्नल को वजन से गुणा करने की प्रक्रिया, संकेतों को समेटना, दहलीज के साथ तुलना करना और परिणाम को एक ही स्थान पर संयोजित करना हो सकता है। लेकिन मुझे ऐसा लगा कि अगर हम प्रत्येक ऑपरेशन को अलग-अलग करते हैं और उन्हें एक-एक करके बुलाते हैं, तो यह स्पष्ट हो जाएगा:

स्केलिंग:

  public void mul_w() { for (int x = 0; x <= 2; x++) { for (int y = 0; y <= 4; y++) //     { mul[x, y] = input[x,y]*weight[x,y]; //    (0  1)        . } } }

इसके अलावा:

  public void Sum() { sum = 0; for (int x = 0; x <= 2; x++) { for (int y = 0; y <= 4; y++) { sum += mul[x, y]; } } }

की तुलना करें:

  public bool Rez() { if (sum >= limit) return true; else return false; }

कार्यक्रम इस तरह की एक तस्वीर फ़ाइल खोलेगा:

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

ताकि कार्यक्रम शटडाउन के बाद काम करना जारी रख सके, मैं एक पाठ फ़ाइल में भार के मूल्यों को बचाऊंगा।

  private void Form1_Load(object sender, EventArgs e) { NW1 = new Web(3, 5,input); //     openFileDialog1.Title = "  "; openFileDialog1.ShowDialog(); string s = openFileDialog1.FileName; StreamReader sr = File.OpenText(s); //    string line; string[] s1; int k = 0; while ((line = sr.ReadLine()) != null) { s1 = line.Split(' '); for (int i = 0; i < s1.Length; i++) { listBox1.Items.Add(""); if (k < 5) { NW1.weight[i, k] = Convert.ToInt32(s1[i]); //        listBox1.Items[k] += Convert.ToString(NW1.weight[i, k]); //  ,   } } k++; } sr.Close(); }

अगला, आपको इनपुट डेटा की एक सरणी बनाने की आवश्यकता है:

  Bitmap im = pictureBox1.Image as Bitmap; for (var i = 0; i <= 5; i++) listBox1.Items.Add(" "); for (var x = 0; x <= 2; x++) { for (var y = 0; y <= 4; y++) { int n = (im.GetPixel(x, y).R); if (n >= 250) n = 0; // ,    else n = 1; listBox1.Items[y] = listBox1.Items[y] + " " + Convert.ToString(n); input[x, y] = n; //        } }

हम ऊपर वर्णित कक्षा विधियों को कॉल करके चरित्र को पहचानते हैं:

  public void recognize() { NW1.mul_w(); NW1.Sum(); if (NW1.Rez()) listBox1.Items.Add(" - True, Sum = "+Convert.ToString(NW1.sum)); else listBox1.Items.Add( " - False, Sum = "+Convert.ToString(NW1.sum)); }

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

यदि नेटवर्क सही उत्तर देता है, तो हम आनन्दित होते हैं और कुछ भी नहीं करते हैं।
और अगर वह गलत है, तो हम उसके अनुसार दंड देते हैं:

- यदि उसका गलत उत्तर गलत है, तो हम इनपुट के मूल्यों को प्रत्येक पैर के भार (1 से लेग 1 - चित्र के मान [0,0] आदि) पर जोड़ते हैं:

  public void incW(int[,] inP) { for (int x = 0; x <= 2; x++) { for (int y = 0; y <= 4; y++) { weight[x, y] += inP[x, y]; } } }

- अगर उसका गलत जवाब सही है, तो प्रत्येक पैर के वजन से इनपुट के मूल्यों को घटाएं:

  public void decW(int[,] inP) { for (int x = 0; x <= 2; x++) { for (int y = 0; y <= 4; y++) { weight[x, y] -= inP[x, y]; } } }

फिर हम वज़न की सरणी में प्राप्त परिवर्तनों को सहेजते हैं और प्रशिक्षण जारी रखते हैं।
जैसा कि मैंने कहा, मैंने नमूने के लिए 5 नंबर लिया:

इसके अलावा, मैंने 5 नंबर के लिए शेष संख्या और कई विकल्प तैयार किए:

उम्मीद है कि संख्या 6 सबसे अधिक समस्याग्रस्त होगी, हालांकि हम प्रशिक्षण के माध्यम से इसे दूर करेंगे।
3x5 शून्य से भरी एक टेक्स्ट फ़ाइल बनाएं - हमारे नेटवर्क की शुद्ध मेमोरी:

000
000
000
000
000

हम प्रोग्राम शुरू करते हैं और इसे इस फ़ाइल पर इंगित करते हैं।
नंबर 5 की तस्वीर डाउनलोड करें:

स्वाभाविक रूप से, उत्तर गलत है। "सत्य नहीं है" पर क्लिक करें।
भार पुनर्गणित होते हैं (आप फ़ाइल में परिणाम देख सकते हैं):

१ १ १
१ ० ०
१ १ १
० ० १
१ १ १

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

१ २ १
1 0 -4
१ २ १
-4 0 1
१ १ ०

तो छह सही ढंग से निर्धारित किया जाता है।

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

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

सिम के लिए, मैं झुकता हूं, पढ़ने के लिए धन्यवाद।

डमी के लिए तंत्रिका नेटवर्क। भाग 2 - अवधारणात्मक

More articles: