Python में रीइन्फ़ोर्समेंट लर्निंग: value iteration और Q-learning

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

रीइन्फ़ोर्समेंट लर्निंग में एक एजेंट किसी माहौल में काम करता है और इनाम पाता है। वह सीखता है कि हर स्थिति या कार्य कितना अच्छा है, ताकि समय के साथ सबसे ज़्यादा इनाम देने वाले कार्य चुन सके।

एक एजेंट को लक्ष्य तक पहुँचना सिखाएँ: value iteration से स्थितियों के मान निकालें, फिर Q-learning से आज़माकर और गलती करके उन्हें सीखें।

मुख्य बातें

डिस्काउंट फ़ैक्टर γ जल्दी मिलने वाले इनाम को ज़्यादा कीमती बनाता है।
value iteration को माहौल का मॉडल चाहिए; Q-learning अनुभव से सीखता है।
Q(s, a) स्थिति s में कार्य a करने पर मिलने वाला अपेक्षित कुल इनाम है।
एजेंट लक्ष्य तक पहुँचे, इसके लिए खोज (यहाँ 20% बेतरतीब चालें) ज़रूरी है।

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

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

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

बाईं ओर चलाएँ दबाएँ ताकि लक्ष्य से मान पूरे ग्रिड में फैलें। दाईं ओर एजेंट को आज़माकर और गलती करके वही रास्ता सीखते देखें।

उदाहरण कोड

कोड चलाएँ →

main.py

import random

# A corridor of 5 cells: start in cell 0, reward +10 for reaching cell 4.
N, GOAL, GAMMA = 5, 4, 0.9

# Value iteration: a cell is worth its reward plus the discounted best neighbour.
values = [0.0] * N
for _ in range(50):
    values = [0.0 if s == GOAL else max((10 if n == GOAL else 0) + GAMMA * values[n]
              for n in (max(0, s - 1), min(N - 1, s + 1))) for s in range(N)]
print("state values:", [round(v, 2) for v in values])

# Q-learning learns the same thing from trial and error.
random.seed(0)
Q = [[0.0, 0.0] for _ in range(N)]   # actions: 0 = left, 1 = right
for episode in range(200):
    s = 0
    while s != GOAL:
        a = random.randrange(2) if random.random() < 0.2 else Q[s].index(max(Q[s]))
        n = max(0, s - 1) if a == 0 else min(N - 1, s + 1)
        reward = 10 if n == GOAL else 0
        target = reward + (0 if n == GOAL else GAMMA * max(Q[n]))
        Q[s][a] += 0.5 * (target - Q[s][a])   # move the estimate toward the target
        s = n
print("best action per cell:", ["right" if q[1] >= q[0] else "left" for q in Q[:GOAL]])
print("Q(0, right):", round(Q[0][1], 2))

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

state values: [7.29, 8.1, 9.0, 10.0, 0.0]
best action per cell: ['right', 'right', 'right', 'right']
Q(0, right): 7.29

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

value iteration बेलमैन अपडेट दोहराता है, जिसमें किसी खाने का मान सबसे अच्छा इनाम और अगले खाने का डिस्काउंट किया हुआ मान है; लक्ष्य से दूर जाने पर यह 10, 9, 8.1 और 7.29 देता है। Q-learning को नियम नहीं पता। हर कदम के बाद वह अपने अनुमान को reward + γ·max Q(next) की ओर खिसकाता है और सीख जाता है कि हमेशा दाईं ओर जाना है।

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

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

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

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

Python IDE में चलाएँ →

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

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

सभी चैलेंज