Python में न्यूरल नेटवर्क ऑप्टिमाइज़र: SGD, Momentum और Adam

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

ऑप्टिमाइज़र वह नियम है जो ग्रेडिएंट को वेट अपडेट में बदलता है। सामान्य ग्रेडिएंट डिसेंट सिर्फ़ मौजूदा ग्रेडिएंट इस्तेमाल करता है; momentum पिछली दिशाएँ याद रखता है, और Adam हर वेट के लिए कदम का आकार भी बदलता है।

एक ही फ़ंक्शन को कदम दर कदम न्यूनतम करते हुए सामान्य ग्रेडिएंट डिसेंट, momentum और Adam की तुलना करें।

मुख्य बातें

Momentum एक वेग बनाए रखता है, इसलिए समतल हिस्सों और छोटे उभारों को पार कर जाता है।
Adam ग्रेडिएंट और ग्रेडिएंट के वर्ग के चलते औसत रखता है।
बायस सुधार (1 − βᵗ से भाग देना) शुरुआती कदमों में उन औसतों को ठीक करता है।
अच्छा वेट इनिशियलाइज़ेशन और मिनी-बैच भी ट्रेनिंग को तेज़ और स्थिर बनाते हैं।

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

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

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

चलाएँ दबाएँ और तीन ऑप्टिमाइज़र एक ही ऊबड़-खाबड़ घाटी में नीचे की ओर दौड़ लगाएँगे। momentum को आगे निकलते देखने के लिए बड़ा learning rate आज़माएँ।

उदाहरण कोड

कोड चलाएँ →

main.py

import math

# Minimise f(x) = (x - 3)² with three optimizers. The gradient is 2(x - 3).
grad = lambda x: 2 * (x - 3)

def sgd(steps, lr=0.1):
    x = 0.0
    for _ in range(steps):
        x -= lr * grad(x)
    return x

def momentum(steps, lr=0.1, beta=0.9):
    x, v = 0.0, 0.0
    for _ in range(steps):
        v = beta * v + grad(x)        # remember the direction we were going
        x -= lr * v
    return x

def adam(steps, lr=0.3, b1=0.9, b2=0.999, eps=1e-8):
    x, m, v = 0.0, 0.0, 0.0
    for t in range(1, steps + 1):
        g = grad(x)
        m = b1 * m + (1 - b1) * g     # running mean of gradients
        v = b2 * v + (1 - b2) * g * g # running mean of squared gradients
        m_hat, v_hat = m / (1 - b1 ** t), v / (1 - b2 ** t)
        x -= lr * m_hat / (math.sqrt(v_hat) + eps)
    return x

for steps in (5, 20, 50):
    print(f"{steps:>2} steps  sgd={sgd(steps):.3f}  momentum={momentum(steps):.3f}  adam={adam(steps):.3f}")

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

5 steps  sgd=2.017  momentum=4.741  adam=1.476
20 steps  sgd=2.965  momentum=4.048  adam=3.813
50 steps  sgd=3.000  momentum=3.091  adam=3.014

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

तीनों (x − 3)² को न्यूनतम करते हैं, जिसका सबसे निचला बिंदु x = 3 है। SGD लगातार बढ़ता है, momentum रफ़्तार पकड़कर आगे निकल जाता है और फिर स्थिर होता है, और Adam हर कदम को ग्रेडिएंट और उसके वर्ग के चलते औसत से छोटा-बड़ा करता है। 50 कदमों के बाद तीनों 3 के करीब होते हैं।

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

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

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

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

Python IDE में चलाएँ →

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

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

सभी चैलेंज