पायथन में एक एकल न्यूरॉन तंत्रिका नेटवर्क

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

आइए समझते हैं कि यह क्या है और यह कैसे काम करता है?

इस नेटवर्क के विभिन्न घटक हैं। वे इस प्रकार हैं -

एक इनपुट परत, x
छिपी परतों की मनमानी मात्रा
एक आउटपुट परत, ŷ
प्रत्येक परत के बीच भार और पूर्वाग्रह का एक सेट जिसे डब्ल्यू और बी द्वारा परिभाषित किया गया है
अगला प्रत्येक छिपी परत के लिए सक्रियण फ़ंक्शन का विकल्प है, σ.

इस आरेख में 2-लेयर न्यूरल नेटवर्क प्रस्तुत किया गया है (न्यूरल नेटवर्क में परतों की संख्या की गणना करते समय इनपुट परत को आमतौर पर बाहर रखा जाता है)

पायथन में एक एकल न्यूरॉन तंत्रिका नेटवर्क

इस ग्राफ में, वृत्त न्यूरॉन्स का प्रतिनिधित्व कर रहे हैं और रेखाएं सिनैप्स का प्रतिनिधित्व कर रही हैं। सिनैप्स का उपयोग इनपुट और वज़न को गुणा करने के लिए किया जाता है। हम वजन को न्यूरॉन्स के बीच संबंध की "ताकत" मानते हैं। भार तंत्रिका नेटवर्क के आउटपुट को परिभाषित करते हैं।

एक साधारण फीड फॉरवर्ड न्यूरल नेटवर्क कैसे काम करता है, इसका संक्षिप्त विवरण यहां दिया गया है -

जब हम फीड फॉरवर्ड न्यूरल नेटवर्क का उपयोग करते हैं, तो हमें कुछ चरणों का पालन करना पड़ता है।

पहले मैट्रिक्स के रूप में इनपुट लें (संख्याओं की 2D सरणी)
अगला एक सेट वज़न से इनपुट को गुणा करता है।
अगला सक्रियण फ़ंक्शन लागू करता है।
एक आउटपुट लौटाएं।
अगली त्रुटि की गणना की जाती है, यह डेटा से वांछित आउटपुट और अनुमानित आउटपुट के बीच का अंतर है।
और वजन त्रुटि के अनुसार थोड़ा सा बदल जाता है।
प्रशिक्षित करने के लिए, इस प्रक्रिया को 1,000+ बार दोहराया जाता है और जितना अधिक डेटा प्रशिक्षित किया जाता है, हमारे आउटपुट उतने ही सटीक होंगे।

घंटे का अध्ययन, घंटे की नींद (इनपुट) टेस्ट स्कोर (आउटपुट)

उदाहरण कोड

from numpy import exp, array, random, dot, tanh
class my_network():
   def __init__(self):
      random.seed(1)
      # 3x1 Weight matrix
      self.weight_matrix = 2 * random.random((3, 1)) - 1
      defmy_tanh(self, x):
      return tanh(x)
      defmy_tanh_derivative(self, x):
   return 1.0 - tanh(x) ** 2
      # forward propagation
      defmy_forward_propagation(self, inputs):
   return self.my_tanh(dot(inputs, self.weight_matrix))
      # training the neural network.
      deftrain(self, train_inputs, train_outputs,
      num_train_iterations):
   for iteration in range(num_train_iterations):
      output = self.my_forward_propagation(train_inputs)
      # Calculate the error in the output.
      error = train_outputs - output
      adjustment = dot(train_inputs.T, error *self.my_tanh_derivative(output))
      # Adjust the weight matrix
      self.weight_matrix += adjustment
      # Driver Code
   if __name__ == "__main__":
      my_neural = my_network()
      print ('Random weights when training has started')
   print (my_neural.weight_matrix)
      train_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
      train_outputs = array([[0, 1, 1, 0]]).T
      my_neural.train(train_inputs, train_outputs, 10000)
   print ('Displaying new weights after training')
      print (my_neural.weight_matrix)
         # Test the neural network with a new situation.
         print ("Testing network on new examples ->")
print (my_neural.my_forward_propagation(array([1, 0, 0])))

आउटपुट

Random weights when training has started
[[-0.16595599]
[ 0.44064899]
[-0.99977125]]
Displaying new weights after training
[[5.39428067]
[0.19482422]
[0.34317086]]
Testing network on new examples ->
[0.99995873]