Reinforcement learning प्लेग्राउंडमध्यमपाठ 2916 मिनट का पाठ

Q-learning कदम-दर-कदम

चट्टानों और जालों (traps) के साथ खजाने की खोज। लाइन-दर-लाइन Q-learning अपडेट बनाएं, देखें कि यह रिवॉर्ड को पीछे की ओर कैसे पहुंचाता है, और समझें कि आपके एजेंट ने कौन सा नक्शा सीखा है।

✦ ट्यूटर से पूछें 🧪 लैब · 30 min 📝 पाठ का टेस्ट

स्पीड

पाठ वीडियो में

60 सेकंड में

Q-learning कदम-दर-कदम

चट्टानों और जालों (traps) के साथ खजाने की खोज। लाइन-दर-लाइन Q-learning अपडेट बनाएं, देखें कि यह रिवॉर्ड को पीछे की ओर कैसे पहुंचाता है, और समझें कि आपके एजेंट ने कौन सा नक्शा सीखा…

1/4

आसान शब्दों में

कल्पना कीजिए खजाने की एक ऐसी खोज की जहाँ आपको इनाम केवल बिल्कुल अंत में मिलता है। पहली बार में, आप इधर-उधर भटकते हैं। लेकिन अगली बार आपको याद रहता है: "खजाने के ठीक बगल वाला डिब्बा बहुत बढ़िया था", फिर "उसके बगल वाला डिब्बा भी अच्छा था"। धीरे-धीरे यह अच्छा अहसास खजाने से लेकर शुरुआत तक पीछे की ओर फैलता जाता है, ठीक ब्रेड के टुकड़ों (breadcrumbs) के निशान की तरह।

एक bandit में केवल एक स्टेट (state) होती है। एक असली खेल में बहुत सारी स्टेट्स होती हैं, और हो सकता है कि अभी की गई अच्छी चाल का फायदा काफी बाद में मिले। Q-learning इसे संभालती है। यह एक टेबल Q[state][action] रखती है: यह एजेंट का अनुमान होता है कि अगर वह उस स्टेट में वह एक्शन लेता है और उसके बाद अच्छी तरह खेलता है, तो उसे कुल कितना डिस्काउंटेड रिवॉर्ड मिलेगा।

अगर आपने Simulation and sim-to-real वाला पाठ पढ़ा है, तो आपने एक लाइन में अपडेट और एक छोटा ग्रिड रोबोट देखा होगा। यहाँ हम थोड़ा रुककर, अपडेट को टुकड़ों में समझेंगे, और देखेंगे कि टेबल क्या सीखती है।

अपडेट, एक समय में एक टुकड़ा

1
कार्रवाई करें (Act)
स्टेट s में, एक्शन a लें। रिवॉर्ड r और अगली स्टेट s2 देखें।
2
एक टारगेट बनाएं (Build a target)
अगर खेल खत्म हो गया, तो target = r. वरना target = r + gamma x (s2 में सबसे अच्छा Q)।
3
हैरानी को मापें (Measure the surprise)
error = target - Q[s][a]. पॉजिटिव का मतलब है "जितना मैंने सोचा था, उससे बेहतर"।
4
हल्का सा खिसकाएं (Nudge)
Q[s][a] = Q[s][a] + alpha x error. Alpha (0 से 1) लर्निंग रेट है: यानी खिसकाव कितना बड़ा होगा।
5
आगे बढ़ें (Move on)
s = s2 करें और जब तक एपिसोड खत्म न हो, इसे दोहराएं।

One update, with numberspython

alpha, gamma = 0.5, 0.9
Q_here = 0.0              # Q[s][a]: what we believed before
reward = -1.0             # one step cost us a point
best_next = 5.0           # the best Q in the next state, s2

target = reward + gamma * best_next      # -1 + 0.9 * 5 = 3.5
error = target - Q_here                  # 3.5: better than we thought!
Q_here = Q_here + alpha * error          # 0 + 0.5 * 3.5 = 1.75
print("target", target, "error", error, "new Q", Q_here)

मुख्य विचार 'टारगेट' ही है। यह खेल खत्म होने का इंतज़ार करने के बजाय अगली स्टेट के बारे में एजेंट के खुद के मौजूदा अंदाज़े (best_next) का इस्तेमाल करता है। अपने ही अगले अंदाज़े से सीखने को temporal-difference (TD) learning कहा जाता है। यही वजह है कि खजाने का रिवॉर्ड हर बार जाने पर एक-एक डिब्बा पीछे की तरफ फैलता जाता है।

सावधान रहें

एक आम गड़बड़ी (bug): जब एपिसोड खत्म हो जाता है, तो कोई अगली स्टेट नहीं होती। तब टारगेट सिर्फ़ रिवॉर्ड ही होना चाहिए। अगर आप खजाने वाले डिब्बे के लिए gamma * max(Q[s2]) जोड़ देते हैं, तो एजेंट को लगता है कि खेल खत्म होने के बाद भी जारी है।

Q-learning खोज (exploring) से क्यों सीख सकती है

टारगेट अगली स्टेट में सबसे अच्छे एक्शन का इस्तेमाल करता है, भले ही एजेंट असल में वहाँ कुछ नया खोजने के लिए कोई रैंडम कदम उठा ले। इसलिए Q-learning अच्छी तरह खेलने की वैल्यू सीखती है, भले ही उसका बर्ताव कुछ हद तक रैंडम हो। इसे off-policy लर्निंग कहा जाता है। यही वजह है कि एजेंट epsilon-greedy के साथ रास्ते तलाश (explore) भी सकता है और फिर भी सबसे अच्छा रास्ता सीख सकता है।

टेबल को पढ़ना

ट्रेनिंग के बाद, एजेंट की greedy policy होती है: हर स्टेट में सबसे ज़्यादा Q वाला एक्शन चुनें। आप इसे नक्शे पर तीरों के रूप में बना सकते हैं। लैब बिल्कुल यही प्रिंट करती है, ताकि आप देख सकें कि एजेंट ने कौन सा रास्ता सीखा है।

सेटिंग	यह क्या नियंत्रित करती है	अगर बहुत कम हो	अगर बहुत ज़्यादा हो
alpha (लर्निंग रेट)	हर अपडेट Q को कितना आगे बढ़ाता है	सीखना बहुत धीमा हो जाता है	हर अच्छी या बुरी चाल के साथ अंदाज़े बहुत तेज़ी से ऊपर-नीचे उछलते हैं
gamma (डिस्काउंट)	बाद में मिलने वाले रिवॉर्ड की कितनी अहमियत है	एजेंट सिर्फ़ पास की सोचता है और शायद दूर के खजाने को अहमियत न दे	वैल्यूज़ बहुत बड़ी हो जाती हैं और सीखना धीमा हो सकता है
epsilon (खोज / exploring)	कितनी बार रैंडम काम करना है	हो सकता है खजाना कभी मिले ही नहीं	सीखते समय बार-बार जालों में गिरता रहेगा
episodes	अभ्यास के लिए कितने खेल खेलने हैं	वैल्यूज़ अभी शुरुआत तक पीछे नहीं फैल पाई हैं	समय की बर्बादी, लेकिन छोटे खेल में कोई नुकसान नहीं

नोट

टेबल तब काम करती है जब स्टेट्स कम हों: यहाँ, केवल 30 डिब्बे हैं। शतरंज के खेल में, या किसी रोबोट के कैमरे की तस्वीर में, किसी भी टेबल के लिए बहुत ज़्यादा स्टेट्स होती हैं। तब स्टेट से Q का अनुमान लगाने के लिए एक न्यूरल नेटवर्क को ट्रेन किया जाता है। इसे deep Q-learning कहते हैं। अपडेट का तरीका वही रहता है; बस टेबल की जगह नेटवर्क आ जाता है।

यह आज़माएं। लैब पूरी करने के बाद, gamma = 0.1 सेट करें और फिर से ट्रेन करें। Q[START] प्रिंट करें। शुरुआत के पास के नंबर इतने छोटे क्यों हैं, और क्या एजेंट को अब भी खजाना मिल पाता है?

और देखें और पढ़ें

लैब

एक Q-learning एजेंट जो चट्टानों और जालों वाले 6 x 5 के नक्शे पर खजाने तक जाने का एक सुरक्षित, छोटा रास्ता सीखता है।

~30 min

समस्या

नक्शे में एक शुरुआत S, एक खजाना T (+10), जाल X (-10, गेम ओवर) और चट्टानें # हैं जहाँ आप नहीं जा सकते। हर चाल की लागत -1 है। ट्रेनिंग लूप, नक्शा और epsilon-greedy चुनाव तैयार हैं। बस सीखने वाला हिस्सा गायब है।

Run दबाएं। q_update कुछ नहीं करता, इसलिए Q टेबल शून्य पर ही रहती है और सीखा गया रास्ता कहीं नहीं जाता।
q_update लिखें: टारगेट बनाएं (अगर done है तो सिर्फ़ r, नहीं तो r + gamma * max(Q[s2])), फिर Q[s][a] को एरर के alpha गुना जितना उसकी तरफ खिसकाएं।
फिर से रन करें। तीरों वाला नक्शा और रास्ता देखें। क्या यह किसी X को छुए बिना T तक पहुँचता है?
Check दबाएं। (यह मूल नक्शे का उपयोग करता है, इसलिए आप बाद में आज़ादी से प्रयोग कर सकते हैं।)
प्रयोग: केवल 20 एपिसोड के साथ ट्रेन करें; फिर gamma = 0.1 के साथ। लिखें कि क्या बदला और क्यों।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

रन करने के लिए Ctrl + Enter दबाएं

import random

# S start, T treasure (+10), X trap (-10), # rock. Every move costs -1.
MAP = [
    "S...#",
    ".#X..",
    "...#.",
    "#X...",
    "...X.",
    "#..#T",
]
ROWS, COLS = len(MAP), len(MAP[0])
ACTIONS = [(-1, 0), (1, 0), (0, -1), (0, 1)]    # up, down, left, right
ARROWS = "^v<>"
START = (0, 0)

def step(state, a):
    r, c = state
    nr, nc = r + ACTIONS[a][0], c + ACTIONS[a][1]
    if not (0 <= nr < ROWS and 0 <= nc < COLS) or MAP[nr][nc] == "#":
        nr, nc = r, c                         # bumped a rock or the edge: stay
    cell = MAP[nr][nc]
    if cell == "T":
        return (nr, nc), 10.0, True
    if cell == "X":
        return (nr, nc), -10.0, True
    return (nr, nc), -1.0, False

def q_update(Q, s, a, r, s2, done, alpha, gamma):
    # TODO: target = r if done, else r + gamma * max(Q[s2])
    #       then move Q[s][a] toward the target by alpha * (target - Q[s][a])
    pass

def train(episodes=500, alpha=0.5, gamma=0.9, epsilon=0.2, seed=0):
    rng = random.Random(seed)
    Q = {(r, c): [0.0] * 4 for r in range(ROWS) for c in range(COLS)}
    for _ in range(episodes):
        s = START
        for _ in range(100):
            if rng.random() < epsilon:
                a = rng.randrange(4)
            else:
                a = max(range(4), key=lambda i: (Q[s][i], rng.random()))  # random tie-break
            s2, r, done = step(s, a)
            q_update(Q, s, a, r, s2, done, alpha, gamma)
            s = s2
            if done:
                break
    return Q

def greedy_path(Q, max_steps=30):
    s, path = START, [START]
    for _ in range(max_steps):
        s, r, done = step(s, max(range(4), key=lambda i: Q[s][i]))
        path.append(s)
        if done:
            break
    return path

Q = train()
for r in range(ROWS):
    print(" ".join(MAP[r][c] if MAP[r][c] in "#XT" else ARROWS[max(range(4), key=lambda i: Q[(r, c)][i])]
                   for c in range(COLS)))
path = greedy_path(Q)
end = MAP[path[-1][0]][path[-1][1]]
print("Route ends on", repr(end), "after", len(path) - 1, "moves")
print("Q at start (up, down, left, right):", [round(q, 2) for q in Q[START]])

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

done के True होने पर q_update टारगेट के रूप में केवल रिवॉर्ड का उपयोग करता है
वरना टारगेट में अगली स्टेट के सबसे अच्छे Q का gamma गुना जुड़ता है, और Q एरर के alpha गुना से बदलता है
तीरों वाला नक्शा 9 चालों में जालों के चारों ओर से S से T तक ले जाता है
प्रयोग समझाते हैं कि रिवॉर्ड के वापस फैलने के लिए 20 एपिसोड बहुत कम हैं, और gamma 0.1 दूर के रिवॉर्ड को लगभग अदृश्य बना देता है

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1खजाने का सबसे छोटा रास्ता ठीक एक जाल के बगल से होकर गुजरता है। Q-learning वही रास्ता चुनती है। एक असली रोबोट थोड़े लंबे रास्ते को प्राथमिकता क्यों दे सकता है?दिखाएं

Q-learning बिल्कुल परफेक्ट खेलने की वैल्यू सीखती है। असल ज़िंदगी में, रोबोट की चालें फिसल सकती हैं, या वह अभी भी कुछ नया खोज सकता है, और जाल के बगल में एक फिसलन की कीमत -10 होती है। जब एक्शन पूरी तरह भरोसेमंद न हों, तो जाल से दूर एक लंबा रास्ता ज़्यादा सुरक्षित होता है। SARSA, या ट्रेनिंग में रैंडम फिसलन जोड़ना, आमतौर पर वह सुरक्षित रास्ता सीखता है। असली रोबोटों के लिए, सीखी गई पॉलिसी के बाहर भी सुरक्षा सीमाएं लागू की जानी चाहिए।

Q2ट्रेनिंग के बाद, शुरुआत में सबसे अच्छी Q वैल्यू लगभग -1.4 होती है। क्या आप उस नंबर को समझा सकते हैं?दिखाएं

सबसे अच्छे रास्ते में 9 चालें लगती हैं: -1 लागत वाली आठ चालें और आखिर में एक +10। gamma = 0.9 के साथ discounted return है -1 - 0.9 - 0.81 - ... (आठ पद) + 0.9^8 x 10। आठों लागतें मिलकर लगभग -5.70 हो जाती हैं और इनाम का मूल्य लगभग 4.30 है, इसलिए कुल लगभग -1.4 आता है। अगर आपका नंबर थोड़ा अलग आ रहा है, तो हो सकता है कि वैल्यूज़ अभी पूरी तरह स्थिर न हुई हों। इसे खुद हाथ से हल करके देखना यह जांचने का एक बढ़िया तरीका है कि आपका अपडेट सही है।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

इसे Q क्यों कहा जाता है?

यह मूल रिसर्च से आया है, जहाँ Q का मतलब किसी स्टेट में किसी एक्शन की "क्वालिटी" (quality) था। लोग आज भी इसी अक्षर का इस्तेमाल करते हैं।

क्या Q-learning हमेशा सबसे अच्छा रास्ता खोज लेती है?

इस जैसे छोटे खेल में, पर्याप्त खोज (exploring), पर्याप्त एपिसोड और समझदारी भरे लर्निंग रेट के साथ, यह भरोसेमंद तरीके से रास्ता खोज लेती है। इसके सिद्धांत में कुछ शर्तें हैं, जैसे हर स्टेट में हर एक्शन को बार-बार आज़माना। बहुत कम एपिसोड या बहुत कम खोज के साथ, यह किसी बदतर रास्ते पर ही अटक सकती है।

सभी Q वैल्यूज़ शून्य से क्यों शुरू होती हैं?

शून्य एक आसान और निष्पक्ष अंदाज़ा है। कुछ लोग शुरुआत में ही खोजने को बढ़ावा देने के लिए वैल्यूज़ को ऊँचा रखते हैं, जैसे कि bandit वाले पाठ में आशावादी ट्रिक (optimistic trick)। हर कदम पर -1 की लागत के साथ, शून्य पहले से ही थोड़ा आशावादी है, जिससे मदद मिलती है।

Q-learning और SARSA में क्या अंतर है?

SARSA इसका एक करीबी रिश्तेदार है। इसका टारगेट सबसे अच्छे एक्शन के बजाय उस एक्शन का इस्तेमाल करता है जो एजेंट असल में अगला कदम उठाता है (जिसमें रैंडम खोज वाले कदम भी शामिल हैं)। इसलिए SARSA उस तरीके की वैल्यू सीखता है जैसा वह वास्तव में बर्ताव करता है, और जालों के पास यह अक्सर एक सुरक्षित रास्ता सीखता है जो उनसे दूर रहता है।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें

Q-learning कदम-दर-कदम

Q-learning कदम-दर-कदम

अपडेट, एक समय में एक टुकड़ा

कार्रवाई करें (Act)

एक टारगेट बनाएं (Build a target)

हैरानी को मापें (Measure the surprise)

हल्का सा खिसकाएं (Nudge)

आगे बढ़ें (Move on)

Q-learning खोज (exploring) से क्यों सीख सकती है

टेबल को पढ़ना

और देखें और पढ़ें

समस्या

प्रैक्टिस लैब

आपका काम तब पूरा होगा जब

कठिन सवाल

अक्सर पूछे जाने वाले सवाल