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

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

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

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

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

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

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

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

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

• सबसे पहले इनपुट को मैट्रिक्स के रूप में लें (संख्याओं का 2D ऐरे)

• अगला है इनपुट को वेट्स के एक सेट से गुणा करना।

• अगला एक एक्टिवेशन फंक्शन लागू करना।

• एक आउटपुट लौटाएं।

• अगला एरर की गणना करें, यह डेटा से वांछित आउटपुट और प्रेडिक्टेड आउटपुट के बीच का अंतर है।

• और वेट्स को एरर के अनुसार थोड़ा बदल दिया जाता है।

• ट्रेन करने के लिए, इस प्रक्रिया को 1,000+ बार दोहराया जाता है और जितना अधिक डेटा ट्रेन किया जाता है, हमारे आउटपुट उतने ही सटीक होंगे।

पढ़ाई के घंटे, सोने के घंटे (इनपुट) - टेस्ट स्कोर (आउटपुट)

2, 992
1, 586
3, 689
4, 8?

उदाहरण कोड

from numpy import exp, array, random, dot, tanh

class my_network():
    def __init__(self):
        random.seed(1)
        # 3x1 वेट मैट्रिक्स
        self.weight_matrix = 2 * random.random((3, 1)) - 1
    
    def my_tanh(self, x):
        return tanh(x)
    
    def my_tanh_derivative(self, x):
        return 1.0 - tanh(x) ** 2
    
    # फॉरवर्ड प्रोपेगेशन
    def my_forward_propagation(self, inputs):
        return self.my_tanh(dot(inputs, self.weight_matrix))
    
    # न्यूरल नेटवर्क को ट्रेन करना
    def train(self, train_inputs, train_outputs, num_train_iterations):
        for iteration in range(num_train_iterations):
            output = self.my_forward_propagation(train_inputs)
            # आउटपुट में एरर की गणना करें
            error = train_outputs - output
            adjustment = dot(train_inputs.T, error * self.my_tanh_derivative(output))
            # वेट मैट्रिक्स को एडजस्ट करें
            self.weight_matrix += adjustment

# ड्राइवर कोड
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)
    
    # नई स्थिति के साथ न्यूरल नेटवर्क का परीक्षण करें
    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]