Python में ग्रेडिएंट डिसेंट और बैकप्रोपेगेशन

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

ट्रेनिंग का मतलब है लॉस घटाने के लिए वेट को बदलना। ग्रेडिएंट बताता है कि किस दिशा में लॉस बढ़ता है, इसलिए ग्रेडिएंट डिसेंट उलटी दिशा में छोटे कदम लेता है। बैकप्रोपेगेशन चेन रूल से हर वेट का ग्रेडिएंट निकालता है।

ग्रेडिएंट डिसेंट से एक न्यूरॉन ट्रेन करें: चेन रूल से पता करें कि हर वेट लॉस पर कैसा असर डालता है, फिर ढलान पर नीचे कदम बढ़ाएँ।

मुख्य बातें

ग्रेडिएंट हर वेट के हिसाब से लॉस का ढलान है।
लर्निंग रेट कदम का आकार तय करता है: बहुत बड़ा हो तो आगे निकल जाता है, बहुत छोटा हो तो धीमा।
बैकप्रोपेगेशन आउटपुट से पहली लेयर तक पीछे की ओर चेन रूल लागू करता है।
एक epoch पूरे ट्रेनिंग डेटा पर एक बार चलना है।

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

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

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

ट्रेनिंग के लिए चलाएँ दबाएँ। रेखा बिंदुओं के पास आती है, जबकि नारंगी रास्ता लॉस के भू-दृश्य पर नीचे उतरकर सबसे निचले बिंदु तक जाता है।

उदाहरण कोड

कोड चलाएँ →

main.py

# Train one neuron y = w * x + b to fit points on the line y = 2x + 1.
data = [(0, 1), (1, 3), (2, 5), (3, 7)]
w, b = 0.0, 0.0
learning_rate = 0.05

for epoch in range(1, 201):
    grad_w = grad_b = 0.0
    for x, y in data:
        error = (w * x + b) - y          # prediction minus target
        # Chain rule: d(error²)/dw = 2 * error * x, d(error²)/db = 2 * error
        grad_w += 2 * error * x
        grad_b += 2 * error
    # Step against the gradient to make the loss smaller.
    w -= learning_rate * grad_w / len(data)
    b -= learning_rate * grad_b / len(data)
    if epoch in (1, 10, 50, 200):
        loss = sum(((w * x + b) - y) ** 2 for x, y in data) / len(data)
        print(f"epoch {epoch:>3}: w={w:.3f} b={b:.3f} loss={loss:.4f}")

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

epoch   1: w=0.850 b=0.400 loss=7.0587
epoch  10: w=2.009 b=0.958 loss=0.0009
epoch  50: w=2.005 b=0.989 loss=0.0000
epoch 200: w=2.000 b=1.000 loss=0.0000

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

हर बिंदु के लिए एरर अनुमान में से लक्ष्य घटाने पर मिलता है। चेन रूल से स्क्वेयर्ड एरर का ग्रेडिएंट w के लिए 2·error·x और b के लिए 2·error है। पूरे डेटा का औसत लेकर ग्रेडिएंट के उलटे कदम लेने पर w और b, 2 और 1 के पास पहुँचते हैं, और लॉस लगभग 0 हो जाता है।

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

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

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

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

Python IDE में चलाएँ →

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

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

सभी चैलेंज