योजना में तंत्रिका नेटवर्क

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


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


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



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

अब हम सीधे कार्यान्वयन के लिए पास होते हैं। योजना का उपयोग किया गया था, जो कि IMHO LISP की सबसे सुंदर और संक्षिप्त बोली है। कार्यान्वयन एमआईटी-स्कीम में लिखा गया था, लेकिन अन्य दुभाषियों पर समस्याओं के बिना काम करना चाहिए।

कार्यान्वयन में निम्न प्रकार की सूचियों का उपयोग किया जाता है:
(n lst) - न्यूरॉन। न्यूरॉन, के बजाय lst में synapse संकेतों के प्रवर्धन कारकों के साथ एक सूची है। उदाहरण के लिए: (n (1 2 4))।
(l lst) - परत। एक परत जिसमें न्यूरॉन्स होते हैं। इसके बजाय lst में न्यूरॉन्स की एक सूची होती है। 2 न्यूरॉन्स की परत का एक उदाहरण (l ((n (0.1 0.6 0.2)) (n (0.8 0.4 0.4)))
(lst) - एक साधारण सूची, सूची की शुरुआत में किसी भी चरित्र के बिना - एक साधारण तंत्रिका नेटवर्क। Lst में परतों की एक सूची होती है। उदाहरण के लिए:
((l ((n (0.1 0.6 0.2)) (n (0.5 0.1 0.7)) (n (0.8 0.4 0.4)))
(l ((n (0.3 0.8 0.9)) (n (0.4 0.9 0.1)) (n (0.9 0.9 0.9)))

कोड कुछ संक्षिप्ताक्षरों का उपयोग करता है:
; बाहर - न्यूरॉन आउटपुट - न्यूरॉन आउटपुट
; wh - वजन - बांड वजन
; Res - परिणाम - न्यूरॉन्स की पूरी परत की गणना का परिणाम
; akt - सक्रियण - न्यूरॉन सक्रियण का परिणाम
; n - न्यूरॉन
; एल - परत
; नेट - नेटवर्क
; mk - बनाना
; खरीद - प्रक्रिया

आइए एक न्यूरॉन बनाकर शुरू करें, जो उबाऊ है और दिलचस्प नहीं है:

(define (n-mk lst) ;make new neuron
(list 'n lst))

परत बनाने के लिए आगे बढ़ते हैं:

(define (l-mk-new input n lst) ;makes new layer
(let ( (lst1 (append lst (list (n-mk (lst-rand input))))) )
(if (= n 1) (l-mk lst1) (l-mk-new input (- n 1) lst1))))

इनपुट - इस परत में न्यूरॉन्स के इनपुट की संख्या
n परत में न्यूरॉन्स की संख्या है।
lst - तैयार न्यूरॉन्स की एक सूची।

इनपुट की संख्या को जानते हुए, हम lst-rand से इतने सारे यादृच्छिक संख्याओं का आदेश देते हैं, उन्हें n-mk के साथ पैक करते हैं और उन्हें lst1 में डालते हैं। जांचें कि क्या अधिक न्यूरॉन्स की आवश्यकता है, यदि यह अंतिम न्यूरॉन नहीं था, तो काउंटर को कम करें और ऑपरेशन को दोहराएं। यदि यह अंतिम न्यूरॉन है, तो उन्हें एल-एमके के साथ पैक करें।

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

(define (net-make lay)
(net-mk-new (car lay) (cdr lay) '()))

फ़ंक्शन सिंटैक्टिक चीनी है और कॉल को सरल बनाने के लिए बनाया गया है। वास्तव में, नेट-मेक-न्यू कहा जाएगा, जिसमें पहली परत पर प्रविष्टियों की संख्या के लिए बस एक अलग पैरामीटर है। L-mk-new फ़ंक्शन को परत बनाने और lst1 में जोड़ने के लिए पुनरावर्ती कहा जाता है।

(define (net-mk-new input n-lst lst)
(let ( (lst1 (lst-push-b (l-mk-new input (car n-lst) '()) lst)) )
(if (= (length n-lst) 1) lst1 (net-mk-new (car n-lst) (cdr n-lst) lst1))))

अब हमारे पास एक नया बनाया गया नेटवर्क है। आइए इसका उपयोग करने के लिए कार्यों से निपटते हैं। सक्रियण फ़ंक्शन का चयन किया गया था:

(define (n-akt x param) ;neuron activation function
(/ x (+ (abs x) param)))

उन लोगों के लिए जो लिस्प सिंटैक्स के लिए उपयोग नहीं किए जाते हैं, यह सिर्फ x / (| x | + p) है, जहां p वह पैरामीटर है जो फ़ंक्शन ग्राफ को तेज या चिकना बनाता है।

(define (n-proc neuron input) ;process single neuron
(n-akt (lst-sum (lst-mul (n-inp-lst neuron) input )) 4))

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

(define (l-proc l input) ;proceses a layer
(map (lambda(x)(n-proc x input)) (n-inp-lst l)))

इनपुट - पिछली परत के न्यूरॉन्स के आउटपुट,
एल - परत ही
n-inp-lst - किसी दिए गए लेयर के न्यूरॉन्स की एक सूची देता है।

हम एक स्तर ऊंचा उठेंगे और पूरे नेटवर्क का सक्रियण कार्य करेंगे।

(define (net-proc net input)
(let ( (l (l-proc (car net) input)) )
(if (= 1 (length net)) l
(net-proc (cdr net) l))))

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

निर्माण और नेटवर्क के प्रसंस्करण के साथ लगा। अब चलो अधिक दिलचस्प भाग - प्रशिक्षण पर चलते हैं। यहां हम ऊपर से नीचे तक जाते हैं। यानी नेटवर्क स्तर से निचले स्तर तक। नेटवर्क लर्निंग फंक्शन - नेट-स्टडी।

(define (net-study net lst spd) ;studys net for each example from the list smpl ((inp)(out))
(if (net-check-lst net lst) net
(net-study (net-study-lst net lst spd) lst spd)))

जहां नेट ही नेटवर्क है
lst उदाहरणों की एक सूची है
spd - सीखने की गति।
net-check-lst - lst से उदाहरणों के साथ नेटवर्क प्रतिक्रियाओं को मान्य करता है
net-study-lst - नेटवर्क प्रशिक्षण प्रदान करता है

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

(define (net-study-lst net lst spd)
(let ( (x (net-study1 net (caar lst) (cadar lst) spd)) )
(if (= 1 (length lst)) x
(net-study-lst x (cdr lst) spd))))

(define (net-study1 net inp need spd)
(net-study2 net (l-check inp) need spd))

यहाँ l-check जोड़ा गया है। फिलहाल, वे कुछ नहीं कर रहे हैं, लेकिन परीक्षण स्तर पर उन्होंने इसका उपयोग करते हुए संचरित मूल्यों को पकड़ लिया।

(define (net-study2 net inp need spd)
(let ( (x (net-study3 net inp need spd)))
(if (= (caar (lst-order-max need))(caar (lst-order-max (net-proc x inp))))
x
(net-study2 x inp need spd))))


नेट-स्टडी 2 वास्तव में अधिकतम आउटपुट संख्या के साथ पैटर्न में अधिकतम आउटपुट संख्या की तुलना करता है। यदि वे मेल खाते हैं, तो हम प्रशिक्षित नेटवर्क लौटाते हैं, यदि नहीं, तो हम प्रशिक्षण जारी रखते हैं।

(define (net-study3 net inp need spd)
(let ((err (net-spd*err spd (slice (net-err net inp need) 1 0)))
(wh (net-inp-wh net))
(out (slice (net-proc-res-out net inp) 0 -1)))
(net-mk-data (net-err+wh wh (map (lambda(xy)(lst-lst-mul xy)) out err)))))


नेटवर्क में सभी न्यूरॉन्स के आने वाले वजन की सूची
बाहर - नेटवर्क में सभी न्यूरॉन्स के आउटपुट की एक सूची है
गलत - प्रत्येक न्यूरॉन के लिए त्रुटि सूची
नेट-स्पड * इरेट - न्यूरॉन के वजन द्वारा त्रुटियों की सूची के साथ गति को गुणा करता है।
नेट-इर + व् - वेट्स की सूची में एक परिकलित त्रुटि जोड़ता है।
प्राप्त डेटा से नेट-मेक-डेटा एक नया नेटवर्क बनाता है।

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

जहाँ
Wij का वजन न्यूरॉन i से न्यूरॉन j तक होता है,
शी न्यूरॉन i का आउटपुट है,
R सीखने का चरण है,
Gj न्यूरॉन j के लिए त्रुटि मान है।

आउटपुट परत के लिए त्रुटि की गणना करते समय, फ़ंक्शन का उपयोग किया जाता है:

जहाँ
Dj न्यूरॉन j का वांछित आउटपुट है,
Yj न्यूरॉन j का वर्तमान आउटपुट है।

सभी पिछली परतों के लिए, फ़ंक्शन का उपयोग किया जाता है:

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

(define (net-err net inp need) ;networks error list for each neuron
(let ( (wh-lst (reverse (net-out-wh net)))
(err-lst (list (net-out-err net inp need)))
(out-lst (reverse (slice (net-proc-res-out net inp) 0 -1))))
(net-err2 out-lst err-lst wh-lst)))

(define (net-err2 out-lst err-lst wh-lst)
(let ( (err-lst1 (lst-push (l-err (car out-lst) (car err-lst) (first wh-lst)) err-lst)) )
(if (lst-if out-lst wh-lst) err-lst1 (net-err2 (cdr out-lst) err-lst1 (cdr wh-lst)))))

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

अब वास्तव में, यह सब कैसे काम करता है। उदाहरण सरल होगा, लेकिन यदि वांछित है तो अधिक जटिल चीजों को पहचाना जा सकता है। हमारे पास T, O, I, U अक्षर के लिए केवल चार सरल पैटर्न होंगे। हम उनकी मैपिंग की घोषणा करते हैं:

(परिभाषित टी '
१ १ १
० १ ०
0 1 0))

(डिफाइन ओ ’
१ १ १
१ ० १
1 1 1))

(मुझे परिभाषित करें ')
० १ ०
० १ ०
0 1 0))

(डिफाइन यू) (
१ ० १
१ ० १
1 1 1))

अब हम प्रशिक्षण के लिए एक फॉर्म तैयार करेंगे। प्रत्येक अक्षर 4 आउटपुट में से एक से मेल खाता है।

(परिभाषित पत्र)
(सूची ओ '(1 0 0 0))
(सूची t '(0 1 0 0))
(सूची I '(0 0 1 0))
(सूची यू '(0 0 0 1))))

अब एक नया नेटवर्क बनाएं जिसमें 9 इनपुट, 3 लेयर्स और 4 आउटपुट हों।

(परिभाषित परीक्षण (नेट-मेक ') (९ test ४))

आइए हमारे उदाहरण का उपयोग करके नेटवर्क को प्रशिक्षित करें। पत्र उदाहरणों की एक सूची है। 0.5 एक लर्निंग स्टेप है।

(टेस्ट 1 परिभाषित करें (नेट-स्टडी टेस्ट पत्र 0.5)

नतीजतन, हमारे पास एक नेटवर्क टेस्ट 1 है, जो हमारे पैटर्न को पहचानता है। इसका परीक्षण करें:

(नेट-प्रोक टेस्ट 1 ओ)

> (.3635487227069449 .32468771459315143 .20836372502023912 .3635026264793502)

इसे थोड़ा स्पष्ट करने के लिए, आप यह कर सकते हैं:

(नेट- proc-num टेस्ट 1 ओ)

> 0

यानी सबसे बड़ा आउटपुट मूल्य शून्य आउटपुट पर था। अन्य पैटर्न के लिए समान:

(net-proc-num test1 i)

> २

हम छवि को थोड़ा नुकसान पहुंचा सकते हैं और देख सकते हैं कि क्या यह मान्यता प्राप्त है:

(net-proc-num test1
'(
० १ ०
१ ० १
0 1 0))

> 0

(net-proc-num test1
'(
० ० १
० १ ०
0 1 0))

> 1

यहां तक ​​कि एक क्षतिग्रस्त छवि भी काफी अलग है। सच है, एक विवादास्पद स्थिति बनाई जा सकती है, उदाहरण के लिए, इस मामले में, नेटवर्क पैटर्न I के साथ पैटर्न टी को भ्रमित करेगा। आउटपुट बहुत करीब होगा।

(नेट-प्रोक टेस्ट १
'(
0 1 1
० १ ०
0 0 0))

> (.17387815810580473 .2731127800467817 .31253464734295566 -6.323399331678244e-3)

जैसा कि आप देख सकते हैं कि नेटवर्क 1 और 2 आउटपुट प्रदान करता है। यानी पैटर्न काफी समान हैं और नेटवर्क 2 पैटर्न को अधिक संभावना मानता है।

PS मुझे लगता है कि यह सब बहुत अराजक है, लेकिन शायद किसी को यह दिलचस्प लगेगा।

PSS एलआईएसपी-युग के लिए अलग अनुरोध। यह पहली बार है कि मैं सार्वजनिक रूप से अपनी योजना कोड पोस्ट कर रहा हूं, इसलिए मैं आलोचना का आभारी रहूंगा।

सूत्रों का कहना है:
1. oasis.peterlink.ru/~dap/nneng/nnlinks/nbdoc/bp_task.htm#learn - कार्यों और प्रेरणा के लिए
2. ru.wikipedia.org/wiki/Artific_Neural_Network - चित्र और कुछ जानकारी यहाँ से मिटा दी गई है
3. alife.narod.ru/lectures/neural/Neu_ch03.htm - यहां से एक तस्वीर ली
4. Iiklub.rf / neur-1.html

पास्टबिन पर पूर्ण स्रोत:

pastebin.com/erer2BnQ