डमी के लिए तंत्रिका नेटवर्क। कोहेनन नेटवर्क

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

इसलिए, हम काले रंग पर सफेद रंग में लिखे गए अंकों को पहचानेंगे, जैसे कि ये:


छवियां 45 से 45 पिक्सेल हैं, जिसका अर्थ है कि हमारे तंत्रिका नेटवर्क में 45 * 45 प्रविष्टियां होंगी।
सादगी के लिए, हम केवल 0 से 5 तक संख्याओं को पहचानते हैं, इसलिए हमारे पास प्रत्येक उत्तर के लिए 6 न्यूरॉन्स होंगे।

हमारे तंत्रिका नेटवर्क की संरचना:


न्यूरॉन के साथ नेटवर्क इनपुट के प्रत्येक कनेक्शन का अपना वजन होता है। एक आवेग, एक कनेक्शन से गुजर रहा है, बदलता है: आवेग = आवेग * कनेक्शन_वेट।
एक न्यूरॉन सभी इनपुटों से दालों को प्राप्त करता है और बस उन्हें रकम देता है। सबसे बड़ी कुल गति के साथ न्यूरॉन जीतता है। सब कुछ सरल है, हम इसे लागू कर रहे हैं!

नेटवर्क तत्वों का प्रतिनिधित्व करने वाली कक्षाएं (C #):
//
public class Input
{
//
public Link [] OutgoingLinks;
}

//
public class Link
{
//
public Neuron Neuron;
//
public double Weight;
}

public class Neuron
{
//
public Link [] IncomingLinks;
//
public double Power { get; set; }
}

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

KohonenNetwork वर्ग की स्थिति इनपुट [] सरणी और न्यूरॉन [] सरणी है:
public class KohonenNetwork
{
private readonly Input [] _inputs;
private readonly Neuron [] _neurons;
...
}

मान लीजिए हमारा नेटवर्क पहले से प्रशिक्षित है। फिर, यह पता लगाने के लिए कि चित्र में क्या दिखाया गया है, हम हैंडल विधि को कहते हैं, सब कुछ वहां गुणा, जोड़ और अधिकतम होगा:
//
public int Handle( int [] input)
{
for ( var i = 0; i < _inputs.Length; i++)
{
var inputNeuron = _inputs[i];
foreach ( var outgoingLink in inputNeuron.OutgoingLinks)
{
outgoingLink.Neuron.Power += outgoingLink.Weight * input[i];
}
}
var maxIndex = 0;
for ( var i = 1; i < _neurons.Length; i++)
{
if (_neurons[i].Power > _neurons[maxIndex].Power)
maxIndex = i;
}
// :
foreach ( var outputNeuron in _neurons)
{
outputNeuron.Power = 0;
}
return maxIndex;
}

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

प्रशिक्षण कनेक्शनों के भार में एक परिवर्तन है:
public void Study( int [] input, int correctAnswer)
{
var neuron = _neurons[correctAnswer];
for ( var i = 0; i < neuron.IncomingLinks.Length; i++)
{
var incomingLink = neuron.IncomingLinks[i];
incomingLink.Weight = incomingLink.Weight + 0.5 * (input[i] - incomingLink.Weight);
}
}

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

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