सरलतम तंत्रिका नेटवर्क और इसके चरण-दर-चरण कार्यान्वयन के साथ परिचित होना

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

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




Habré पर मशीन सीखने और तंत्रिका नेटवर्क पर सिद्धांत पर्याप्त हैं। लेकिन अगर किसी को इसकी आवश्यकता है, तो मैं लेख के अंत में कुछ लिंक छोड़ दूंगा। और अब, हम सीधे कोड लिखना शुरू करेंगे, और हम पायथन में लिखेंगे, मैं कोड लिखते समय बृहस्पति-नोटबुक का उपयोग करने की सलाह देता हूं

चरण 1. नेटवर्क प्रारंभ

सबसे पहले, निश्चित रूप से, हमें अपने नेटवर्क के सभी सक्रिय घटकों को इनिशियलाइज़ करना होगा

# numpy —    Python,        import numpy #  scipy.special , -scipy    , ,  ,      ,       ,   - " " import scipy.special #,      import matplotlib.pyplot #     class neuralNetwork: #     def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate): #     ,   ,   ,  ) #     ,  ,   self.inodes = inputnodes self.hnodes = hiddennodes self.onodes = outputnodes #    , wih -       ,    who-       self.wih = numpy.random.rand(self.hnodes, self.inodes) self.who = numpy.random.rand(self.onodes, self.hnodes) #   -  ,  ,  ,    ,     ,     ,  ,  ,   self.lr = learningrate #  -   self.activation_function = lambda x: scipy.special.expit(x) 

अवग्रह

यह फ़ंक्शन निरंतर फ़ंक्शंस के वर्ग से संबंधित है, इनपुट पर एक मनमाना वास्तविक (यानी, जरूरी नहीं कि एक पूर्णांक) संख्या लेता है, और आउटपुट पर 0 से 1 तक की सीमा में एक वास्तविक संख्या देता है ।

विशेष रूप से, बड़े (मोडुलो) नकारात्मक संख्या शून्य में बदल जाती है , और बड़ी सकारात्मक संख्या एक में बदल जाती है ।

इसका उत्पादन अच्छी तरह से न्यूरॉन सक्रियण के स्तर के रूप में व्याख्या किया गया है : सक्रियण की अनुपस्थिति (0) से पूरी तरह से संतृप्त सक्रियण (1) तक।

सूत्र द्वारा सूत्र को व्यक्त किया गया है:



नीचे दिए गए आंकड़े के अनुसार सिग्मॉइड फ़ंक्शन का ग्राफ:



सिग्मोइड फ़ंक्शन है:

• निरंतर;
• नीरसता बढ़ रही है;
• विभेदक।

इस कोड में, सिग्मॉइड मौजूद है, जैसा कि आप देख सकते हैं, नाम के तहत बाहर निकलें (x)

तंत्रिका नेटवर्क में एक नोड कैसे दिखता है, इसके बारे में थोड़ा

चित्र सबसे अधिक नोड दिखाता है, केवल इसे आम तौर पर एक सर्कल के रूप में प्रस्तुत किया जाता है, न कि एक आयत। जैसा कि हम देखते हैं, एक आयत (अच्छी तरह से, या एक वृत्त) के अंदर - यह सब सार है, 2 कार्य हैं:

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

दूसरा फ़ंक्शन एक पैरामीटर के रूप में समान मान लेता है जो पहले फ़ंक्शन को सारांशित करता है, और इस दूसरे फ़ंक्शन को सक्रियण फ़ंक्शन कहा जाता है। हमारे मामले में, एक सिग्मोइड

हम जारी रखते हैं :

भाग 2. तंत्रिका नेटवर्क प्रशिक्षण

 def train(self, inputs_list, targets_list): #       inputs = numpy.array(inputs_list, ndmin=2).T #     input targets = numpy.array(targets_list, ndmin=2).T #  targets #      hidden_inputs = numpy.dot(self.wih, inputs) #  ,       .    ,       hidden_inputs (1 ),        -   (2 ) hidden_outputs = self.activation_function(hidden_inputs) #    ()  final_inputs = numpy.dot(self.who, hidden_outputs) #  ,     final_outputs = self.activation_function(final_inputs) #   ( - ) output_errors = targets - final_outputs #      ,    <b>  </b>,   <b>       </b>(      ) hidden_errors = numpy.dot(self.who.T, output_errors) #        ( ,      ) self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs)) #       (       ) self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs)) 

और अब हम अंत के निकट हैं

भाग 3. तंत्रिका नेटवर्क की पूछताछ

 #  ,      def query(self, inputs_list): #         inputs = numpy.array(inputs_list, ndmin=2).T #      hidden_inputs = numpy.dot(self.wih, inputs) #  ,     hidden_outputs = self.activation_function(hidden_inputs) #      final_inputs = numpy.dot(self.who, hidden_outputs) #     ,     final_outputs = self.activation_function(final_inputs) return final_outputs 

हम इसे अंत तक लाते हैं

 #     ,  ,  (  <b></b>-    , ,   input_nodes = 3 hidden_nodes = 3 output_nodes = 3 #    -   , ... 0.3! learning_rate = 0.3 #   (n    neuralNetwork ,      __init__ ,        n = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate) 

पुनश्च

ऊपर एक तंत्रिका नेटवर्क का कम्प्यूटेशनल रूप से सबसे सरल मॉडल प्रस्तुत किया गया था। लेकिन कोई विशिष्ट आवेदन नहीं दिखाया गया था।

यदि आप चाहें, तो आप एमएनआईएसटीटी कोड में हस्तलिखित पाठ को पहचानने की क्षमता जोड़कर आगे बढ़ सकते हैं, इसके लिए आप पूरी तरह से पता कर सकते हैं (और बस मज़े करें) इस ज्यूपिटर फ़ाइल के साथ , मेरा काम कोड प्रदर्शित करना था और यदि संभव हो तो, नेटवर्क पर और इसके लिए चबाना क्या जवाब देता है

पी पी एस

नीचे आपको उपयोगी लिंक मिलेंगे:

1. गितुब तारिक से लिंक ->
२.हिस पुस्तक ->
3.Machine Learning Theory ->
4.Machine Learning Theory ->
5.Machine Learning Theory ->