डमी के लिए तंत्रिका नेटवर्क। शुरुआत

ऐसा हुआ कि विश्वविद्यालय में तंत्रिका नेटवर्क का विषय मेरी विशेषता से सफलतापूर्वक पारित हो गया, मेरे हिस्से में भारी रुचि के बावजूद। आत्म-शिक्षा के प्रयासों को कई बार अज्ञानतावश भौंकने से विज्ञान की गढ़ की अविनाशी दीवारों के खिलाफ "अस्पष्ट रूप में" एक तस्वीर के साथ "शब्दों" और विश्वविद्यालय की पाठ्यपुस्तकों की सूखी भाषा के भ्रमित स्पष्टीकरण के कारण तोड़ दिया गया।

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

रुचि कृपया बिल्ली के नीचे।

लक्ष्यों

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

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


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

आउटपुट सिग्नल इनपुट के ढेर से कैसे बनता है - न्यूरॉन के आंतरिक एल्गोरिथ्म को निर्धारित करता है।

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

टमाटर को उड़ते हुए, मैंने कहा कि हम डेल्फी में लिखेंगे (इस लेख को लिखने के समय)। यदि आवश्यक हो, तो मैं उदाहरण को अन्य भाषाओं में अनुवाद करने में मदद करूंगा।

मैं आपको कोड की गुणवत्ता को हल्के में लेने के लिए भी कहता हूं - कार्यक्रम एक घंटे में लिखा गया था, बस विषय से निपटने के लिए, गंभीर कार्यों के लिए ऐसा कोड शायद ही लागू हो।

तो, कार्य के आधार पर - कितने निकास विकल्प हो सकते हैं? यह सही है, जितने अक्षर हम निर्धारित कर पाएंगे। वर्णमाला में उनमें से केवल 33 हैं, और हम वहां रुकेंगे।

अगला, हम इनपुट डेटा पर निर्णय लेते हैं। बहुत अधिक परेशान न करने के लिए, हम एक बिटमैप छवि के रूप में इनपुट को 30x30 बिटमैप भेजेंगे:


नतीजतन, आपको 33 न्यूरॉन्स बनाने की आवश्यकता है, जिनमें से प्रत्येक में 30x30 = 900 इनपुट होंगे।
आइए हमारे न्यूरॉन के लिए एक क्लास बनाएं:

type Neuron = class name: string; //    – ,     input: array[0..29,0..29] of integer; //    3030 output:integer; //    ,   memory:array[0..29,0..29] of integer; //         end; 

अक्षरों की संख्या के अनुसार, न्यूरॉन्स की एक सरणी बनाएं:

 For i:=0 to 32 do begin neuro_web[i]:=Neuron.Create; neuro_web[i].output:=0; //    neuro_web[i].name:=chr(Ord('A')+i); //      end; 

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



जैसा कि आप देख सकते हैं, सबसे संतृप्त क्षेत्र सबसे आम पिक्सल के अनुरूप हैं।
जब यह बनाया जाता है तो हम "मेमोरी" को प्रत्येक न्यूरॉन में लोड करेंगे:

 p:=TBitmap.Create; p.LoadFromFile(ExtractFilePath(Application.ExeName)+'\res\'+ neuro_web[i].name+'.bmp') 

अप्रशिक्षित कार्यक्रम की शुरुआत में, प्रत्येक न्यूरॉन की स्मृति 30x30 एक सफेद स्पॉट होगी।

न्यूरॉन को निम्नानुसार पहचाना जाएगा:

- 1 पहला पिक्सेल लें
- इसकी तुलना मेमोरी में 1 मी पिक्सेल से करें (मूल्य 0..255 है)
- एक निश्चित सीमा के साथ अंतर की तुलना करें
- यदि अंतर सीमा से कम है, तो हम मानते हैं कि इस बिंदु पर अक्षर स्मृति में एक के समान है, न्यूरॉन के वजन में +1 जोड़ें।

और इसलिए सभी पिक्सेल पर।

एक न्यूरॉन का वजन एक निश्चित संख्या (सिद्धांत में, 900 तक) है, जो स्मृति में संग्रहीत के साथ संसाधित जानकारी की समानता की डिग्री से निर्धारित होता है।
मान्यता के अंत में, हमारे पास न्यूरॉन्स का एक सेट होगा, जिनमें से प्रत्येक का मानना ​​है कि यह कुछ प्रतिशत तक सही है। ये प्रतिशत न्यूरॉन का वजन हैं। अधिक वजन, अधिक संभावना है कि यह विशेष न्यूरॉन सही है।

अब हम प्रोग्राम को एक मनमानी छवि खिलाएंगे और इसके माध्यम से प्रत्येक न्यूरॉन को चलाएंगे:

 for x:=0 to 29 do for y:=0 to 29 do begin n:=neuro_web[i].memory[x,y]; m:=neuro_web[i].input[x,y]; if ((abs(mn)<120)) then //    if m<250 then neuro_web[i].weight:=neuro_web[i].weight+1; //  ,     ,        if m<>0 then begin if m<250 then n:=round((n+(n+m)/2)/2); neuro_web[i].memory[x,y]:=n; end else if n<>0 then if m<250 then n:=round((n+(n+m)/2)/2); neuro_web[i].memory[x,y]:=n; end; 

जैसे ही अंतिम न्यूरॉन के लिए चक्र समाप्त हो जाता है, हम अधिक वजन वाले सभी को चुनेंगे:

 if neuro_web[i].weight>max then begin max:=neuro_web[i].weight; max_n:=i; end; 

यह इस max_n मान के साथ है कि कार्यक्रम हमें बताएगा कि, इसकी राय में, हमने उसे उसके पास खिसका दिया।
सबसे पहले, यह हमेशा सच नहीं होगा, इसलिए आपको एक लर्निंग एल्गोरिदम बनाने की आवश्यकता है।

 s:=InputBox('Enter the letter', ' ,    '+neuro_web[max_n].name, neuro_web[max_n].name); for i:=0 to 32 do begin //   if neuro_web[i].name=s then begin //     for x:=0 to 29 do begin for y:=0 to 29 do begin p.Canvas.Pixels[x,y]:=RGB(neuro_web[i].memory[x,y],neuro_web[i].memory[x,y], neuro_web[i].memory[x,y]); //     end; end; p.SaveToFile(ExtractFilePath(Application.ExeName)+'\res\'+ neuro_web[i].name+'.bmp'); 

मेमोरी अपडेट स्वयं इस तरह किया जाएगा:

 n:=round(n+(n+m)/2); 

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

जी अक्षर के लिए कुछ पुनरावृत्तियाँ इस प्रकार हैं:



इस पर हमारा कार्यक्रम तैयार है।

ट्रेनिंग

चलो प्रशिक्षण शुरू करते हैं।
हम अक्षरों की छवियों को खोलते हैं और धैर्य से कार्यक्रम की त्रुटियों की ओर इशारा करते हैं:



थोड़ी देर के बाद, कार्यक्रम उन अक्षरों को भी निर्धारित करना शुरू कर देगा जो इससे पहले परिचित नहीं हैं:

निष्कर्ष

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

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

आप यहां स्रोत के साथ कार्यक्रम को डाउनलोड करके हमारी ताजा जन्मी बुद्धि का मजाक उड़ा सकते हैं ।

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

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