CodeUtility
कोडिंग को डेवलपर्स के लिए आसान बनाना।!
Python में AI की अवधारणाएँ

Python में फ़ॉरवर्ड प्रोपेगेशन और लॉस फ़ंक्शन

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

आसान शब्दों में अवधारणा

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

एक छोटे न्यूरल नेटवर्क में इनपुट को लेयर दर लेयर आगे भेजें, फिर स्क्वेयर्ड एरर और क्रॉस-एंट्रॉपी से गलती मापें।

मुख्य बातें

  • Dense लेयर हर इनपुट को लेयर के हर न्यूरॉन से जोड़ती है।
  • एक लेयर का आउटपुट अगली लेयर का इनपुट होता है।
  • लॉस एक ही संख्या है, और यह जितनी कम हो, अनुमान उतने बेहतर।
  • संख्याओं के लिए स्क्वेयर्ड एरर और प्रायिकता व क्लास के लिए क्रॉस-एंट्रॉपी इस्तेमाल करें।

इसका उपयोग कब करें?

  • समझें कि न्यूरल नेटवर्क और AI लाइब्रेरी के अंदर क्या होता है।
  • संबंधित चुनौतियों में खुद लागू करने से पहले विचार को समझें।
  • मशीन लर्निंग कोर्स, इंटरव्यू और प्रोजेक्ट की तैयारी करें।

इसे काम करते देखें

इनपुट और लक्ष्य बदलें। हिडन लेयर से गुज़रते मानों को देखें और जानें कि दोनों लॉस अनुमान पर कैसी प्रतिक्रिया देते हैं।

उदाहरण कोड

कोड चलाएँ →
main.py
import math

def dense(inputs, weights, biases, activation):
    # Each row of weights belongs to one neuron in the layer.
    return [activation(sum(x * w for x, w in zip(inputs, row)) + b) for row, b in zip(weights, biases)]

relu = lambda z: max(0.0, z)
sigmoid = lambda z: 1 / (1 + math.exp(-z))

x = [1.0, 2.0]
hidden = dense(x, [[0.5, -0.2], [0.3, 0.8]], [0.0, -0.5], relu)
output = dense(hidden, [[1.0, -1.0]], [0.2], sigmoid)
print("hidden layer:", [round(h, 3) for h in hidden])
print("prediction:", round(output[0], 3))

# A loss function measures how wrong the prediction is.
target = 1.0
mse = (output[0] - target) ** 2
bce = -(target * math.log(output[0]) + (1 - target) * math.log(1 - output[0]))
print("squared error:", round(mse, 3))
print("cross-entropy:", round(bce, 3))

अपेक्षित आउटपुट

hidden layer: [0.1, 1.4]
prediction: 0.25
squared error: 0.563
cross-entropy: 1.387

यह कैसे काम करता है

dense() एक लेयर की गणना करता है, जहाँ वेट की हर पंक्ति एक न्यूरॉन है। हिडन लेयर ReLU और आउटपुट लेयर प्रायिकता देने के लिए sigmoid इस्तेमाल करती है। स्क्वेयर्ड एरर और क्रॉस-एंट्रॉपी दोनों अनुमान 0.25 और लक्ष्य 1.0 के बीच का अंतर मापते हैं; ट्रेनिंग इन्हें छोटा करने की कोशिश करती है।

मान बदलें और Python इंस्टॉल किए बिना CodeUtility ऑनलाइन Python कंपाइलर में प्रोग्राम चलाएँ।

अभ्यास के कार्य

बड़े dataset पर जाने से पहले input बदलें और edge cases की जाँच करें।

  1. इनपुट या वेट बदलें और रन करने से पहले आउटपुट का अनुमान लगाएँ।
  2. हर गणना चरण को देखने के लिए बीच के मान प्रिंट करें।
  3. नीचे दी गई चुनौतियाँ हल करके विचार को खुद लागू करें।
Python IDE में चलाएँ →

चैलेंज से अभ्यास करें

इस पाठ में सीखी बात से एक असली समस्या हल करें। हर चैलेंज ब्राउज़र में चलता है, तुरंत टेस्ट और AI रिव्यू के साथ।

सभी चैलेंज