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

Exploration बनाम exploitation

बहुत कम explore करेंगे तो सबसे अच्छा इनाम छूट जाएगा। बहुत ज़्यादा explore करेंगे तो हमेशा खराब खेलेंगे। Epsilon को धीरे-धीरे घटाना (decay करना) सीखें, और अलग-अलग कोशिशों (runs) की सही तरीके से तुलना करें।

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

स्पीड

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

60 सेकंड में

Exploration बनाम exploitation

1/4

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

आम के एक बगीचे में, गेट के ठीक पास अमरूद का एक छोटा पेड़ है, और बहुत दूर एक बड़ा आम का पेड़ है। अगर आप हमेशा उसी पहले पेड़ से फल तोड़ते रहेंगे जिससे आपको पहली बार फल मिला था, तो आप जिंदगी भर अमरूद ही खाते रहेंगे और आम तक कभी नहीं पहुँच पाएँगे। लेकिन अगर आप हर रोज़ यूँ ही भटकते रहेंगे, तो बहुत सारा समय बर्बाद होगा। समझदारी भरा प्लान: शुरुआत में खूब घूमें-फिरें, फिर एक जगह टिक जाएँ।

हर RL agent को इस तालमेल (trade-off) का सामना करना पड़ता है। Exploitation का मतलब है कि जो आपको पहले से पता है, उसी का इस्तेमाल करके अभी इनाम (reward) हासिल करना। Exploration का मतलब है कुछ ऐसा आज़माना जो शायद खराब हो, बस यह जानने के लिए कि क्या वह बेहतर है। आपको दोनों की ज़रूरत है।

Epsilon सेट करने के तीन तरीके

Schedule	सीखने के दौरान	अंतिम नतीजा
कभी explore न करना (epsilon = 0)	जो पहला इनाम मिलता है, उसी को लपक लेता है	अक्सर छोटे इनाम पर ही अटका रह जाता है
हमेशा बहुत ज़्यादा explore करना (epsilon = 1)	ज्यादातर समय तुक्केबाज़ी: पूरी ट्रेनिंग के दौरान कम इनाम	हो सकता है table अच्छी बन जाए, लेकिन agent पूरे समय खराब ही खेला
Decay: शुरुआत में ज़्यादा, आखिर में कम	शुरुआत में दूर-दूर तक explore करता है, फिर जो सीखा उसका इस्तेमाल करता है	अक्सर बड़ा इनाम ढूँढ़ लेता है और आखिर तक अच्छा खेलने लगता है

Epsilon decay

एक epsilon schedule ऐसा फ़ंक्शन होता है जो यह तय करता है कि हर episode में कौन सा epsilon इस्तेमाल करना है। इसके दो आम आकार होते हैं:

Python: two decay schedulespython

def linear(ep, n, start=1.0, end=0.05, frac=0.6):
    # falls in a straight line over the first 60% of episodes, then stays at 'end'
    t = min(1.0, ep / (frac * n))
    return start + (end - start) * t

def exponential(ep, n, start=1.0, end=0.05, rate=0.99):
    # multiplies by 'rate' every episode, but never goes below 'end'
    return max(end, start * rate ** ep)

n = 500
for ep in (0, 50, 100, 200, 300, 499):
    print(f"episode {ep:3}: linear {linear(ep, n):.3f}   exponential {exponential(ep, n):.3f}")

दोनों लगभग 1 से शुरू होते हैं (यानी लगभग पूरा exploration) और छोटे नंबर पर खत्म होते हैं (यानी ज़्यादातर सीखी हुई बातों का इस्तेमाल)। एक छोटा निचला स्तर (floor) बनाए रखना, जैसे 0.05, इसका मतलब है कि agent पूरी तरह से नई चीज़ें आज़माना कभी बंद नहीं करता।

छोटा इनाम एक जाल क्यों है

अमरूद पास है, इसलिए agent इसे जल्दी ढूँढ़ लेता है और इसकी Q value बढ़ जाती है। बहुत कम exploration होने पर, लालची (greedy) चुनाव हमेशा अमरूद की तरफ ही कदम बढ़ाता है। आम का इनाम कभी शुरुआत तक वापस पहुँच ही नहीं पाता, क्योंकि agent लगभग कभी उतनी दूर जाता ही नहीं। इसे local optimum कहते हैं: इतना अच्छा कि agent आगे ढूँढ़ना बंद कर दे, लेकिन सबसे अच्छा नहीं।

Runs की सही तरीके से तुलना करना

RL के नतीजे हमेशा एक जैसे नहीं होते: एक ही कोड अलग random seed के साथ बिल्कुल अलग तरीके से सीख सकता है। इसलिए कभी भी एक run देखकर किसी सेटिंग का फैसला न करें।

1
Seeds को तय (fix) रखें
हर सेटिंग को seeds की एक ही लिस्ट के साथ चलाएँ, जैसे 0 से 4 तक।
2
एक बार में एक ही चीज़ बदलें
अलग-अलग runs के बीच सिर्फ schedule बदलना चाहिए, नक्शा (map) या alpha नहीं।
3
दो चीज़ें नापें
आखिरी greedy नतीजा, और ट्रेनिंग के दौरान मिला औसत इनाम।
4
सभी runs की रिपोर्ट दें
"5 में से 4 seeds ने आम ढूँढ़ लिया" कहना ईमानदार तरीका है। सिर्फ सबसे अच्छा seed दिखाना गलत है।

नोट

Random कदमों से भी बेहतर तरीके हैं explore करने के: बहुत कम देखी गई जगहों (states) पर जाने पर बोनस देना, अनजाने कदमों को लेकर उम्मीद रखना, या agent को हैरान करने वाली चीज़ों के लिए इनाम देना (इसे कभी-कभी curiosity कहते हैं)। ये बड़े गेम्स में बहुत काम आते हैं जहाँ यूँ ही भटकने से इनाम लगभग कभी नहीं मिलता। लेकिन तालमेल यहाँ भी वही रहता है।

असली उदाहरण

अर्जुन एक कोचिंग सेंटर चुनता है। वह उस पहले सेंटर में दाखिला ले सकता है जिसका ज़िक्र उसके दोस्त ने किया (exploit)। या फिर वह पहले कई सेंटरों में मुफ़्त डेमो क्लास ले सकता है (explore)। वह पहले हफ्ते में तीन डेमो आज़माता है, फिर एक को चुन लेता है। असल जिंदगी में यही epsilon decay है।

इसे आज़माएँ। लैब में, आम के पेड़ को एक कदम और दूर कर दें। कौन से schedules अब भी इसे ढूँढ़ पाते हैं? इसे फिर से ढूँढ़ने के लिए आपको अपने schedule में क्या बदलना होगा?

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

लैब

एक ऐसा epsilon decay schedule जो दूर वाले आम के पेड़ को ढूँढ़ ले और अच्छा खेले, और पाँच seeds पर निष्पक्ष तुलना से साबित हो।

~30 min

समस्या

बगीचे का एक रास्ता: अमरूद का पेड़ G (+1, episode खत्म) शुरुआत S से 2 कदम बाईं तरफ है, और आम का पेड़ M (+10, episode खत्म) 6 कदम दाईं तरफ है। Q-learning agent तैयार है। आपको exploration schedule लिखना है।

Run दबाएँ। तुलना में "never explore", "always 0.3" और "always 1.0" दिखते हैं। ध्यान दें कि हर एक किस पेड़ पर जाकर रुकता है, और ट्रेनिंग के दौरान औसत इनाम क्या रहता है।
epsilon_at(episode, n_episodes) लिखें: 1.0 के करीब से शुरू करें, जैसे-जैसे episodes बीतें इसे घटाते जाएँ, इसे कभी बढ़ाएँ नहीं, और 0.1 या उससे कम पर खत्म करें।
फिर से चलाएँ। आपका schedule ज़्यादातर seeds पर आम को ढूँढ़ लेना चाहिए और "always 1.0" के मुकाबले ट्रेनिंग में ज़्यादा औसत इनाम कमाना चाहिए।
Check दबाएँ।
जो नंबर आपने देखे, उनका इस्तेमाल करके चारों schedules की तुलना करते हुए तीन वाक्य लिखें।

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

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

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

import random

# G = guava (+1), M = mango (+10). Both end the episode. Start at S.
PATH = "G.S.....M"
START, N = PATH.index("S"), len(PATH)
LEFT, RIGHT = 0, 1

def step(pos, a):
    pos = max(0, min(N - 1, pos + (-1 if a == LEFT else 1)))
    if PATH[pos] == "G":
        return pos, 1.0, True
    if PATH[pos] == "M":
        return pos, 10.0, True
    return pos, 0.0, False

def epsilon_at(episode, n_episodes):
    # TODO: start close to 1.0, fall as episodes pass, end at 0.1 or less.
    return 0.0

def train(schedule, n_episodes=500, alpha=0.5, gamma=0.9, seed=0):
    rng = random.Random(seed)
    Q = [[0.0, 0.0] for _ in range(N)]
    rewards = []
    for ep in range(n_episodes):
        eps = schedule(ep, n_episodes)
        s, total = START, 0.0
        for _ in range(50):
            if rng.random() < eps:
                a = rng.randrange(2)
            else:
                a = max(range(2), key=lambda i: Q[s][i])     # ties go LEFT
            s2, r, done = step(s, a)
            target = r if done else r + gamma * max(Q[s2])
            Q[s][a] += alpha * (target - Q[s][a])
            s, total = s2, total + r
            if done:
                break
        rewards.append(total)
    return Q, rewards

def greedy_end(Q):
    s = START
    for _ in range(50):
        s, r, done = step(s, max(range(2), key=lambda i: Q[s][i]))
        if done:
            return PATH[s]
    return "nowhere"

schedules = {
    "never explore": lambda e, n: 0.0,
    "always 0.3":    lambda e, n: 0.3,
    "always 1.0":    lambda e, n: 1.0,
    "yours":         epsilon_at,
}
for name, sched in schedules.items():
    ends, avgs = [], []
    for seed in range(5):
        Q, rewards = train(sched, seed=seed)
        ends.append(greedy_end(Q))
        avgs.append(sum(rewards) / len(rewards))
    print(f"{name:14} ends at {''.join(ends)}   average training reward {sum(avgs) / 5:.2f}")

आउटपुट

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

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

epsilon_at की शुरुआत 1 के करीब होती है, यह कभी बढ़ता नहीं है, और 0.1 या उससे कम पर खत्म होता है
आपका schedule 5 में से कम से कम 4 seeds पर आम ढूँढ़ लेता है
इसका औसत ट्रेनिंग इनाम साफ़ तौर पर "always 1.0" से बेहतर है
तुलना में सभी पाँचों seeds के नंबरों का इस्तेमाल किया गया है, सिर्फ सबसे अच्छे वाले का नहीं

कठिन सवाल

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

Q1"Always 1.0" भी आखिर में आम तक पहुँच जाता है। तो फिर यह आपके schedule से खराब क्यों है?दिखाएं

क्योंकि यह पूरे 500 episodes तक बिना सोचे-समझे (random) खेलता रहता है। Q-learning off-policy होती है, इसलिए table फिर भी सबसे अच्छा रास्ता सीख लेती है, और आखिर में greedy रास्ता सही निकलता है। लेकिन ट्रेनिंग के दौरान agent अक्सर अमरूद की तरफ चला गया या भटकता रहा, इसलिए उसका औसत इनाम कम रहा। अगर कोई agent काम करते-करते सीख रहा हो (जैसे काम करता हुआ कोई रोबोट, या असली यूज़र्स वाला कोई ऐप), तो सीखने के दौरान ऐसा खराब बर्ताव भारी पड़ सकता है।

Q2"Always 0.3" यहाँ नाकाम क्यों हो जाता है, जबकि यह 30% समय explore करता है?दिखाएं

तुक्के से आम तक पहुँचने के लिए agent को शुरुआत से छह बार दाईं तरफ जाना होगा। जब greedy फैसला बाईं तरफ का इशारा कर रहा हो, तो दाईं तरफ के हर कदम के लिए एक random चाल की ज़रूरत होगी (संभावना 0.3 x 0.5 = 0.15), और लगातार छह बार ऐसा होना नामुमकिन सा है। इसलिए आम लगभग कभी नहीं मिलता। हर कदम पर random exploration दूर के इनामों तक पहुँचने में कमज़ोर साबित होता है, इसीलिए बड़े गेम्स में ज़्यादा समझदारी भरे exploration या फिर लगभग 1 से शुरू होने वाले schedule की ज़रूरत होती है।

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

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

क्या कोई एक सबसे अच्छा epsilon schedule होता है?

नहीं। यह गेम पर, episodes की संख्या पर और इस बात पर निर्भर करता है कि अच्छे इनाम कितनी दूर हैं। इसीलिए आप अपनी समस्या पर कई seeds के साथ schedules की तुलना करते हैं।

ट्रेनिंग के दौरान epsilon को हमेशा 1 पर क्यों न रखें और greedy policy का इस्तेमाल सिर्फ आखिर में ही क्यों न करें?

किसी बहुत छोटे गेम के लिए यह काम कर सकता है, क्योंकि Q-learning बिना सोचे-समझे (random) खेलने से भी सीख जाती है। लेकिन बड़े गेम्स में, random खेलने से agent शायद ही कभी दिलचस्प हिस्सों तक पहुँच पाए, इसलिए agent को गेम में गहराई तक जाने के लिए सीखी हुई बातों का इस्तेमाल करना ही पड़ता है। और अगर सीखना तब हो रहा हो जब agent का असल में इस्तेमाल किया जा रहा है, तो random खेलने का भारी नुकसान हो सकता है।

Random seed क्या होता है और यह क्यों ज़रूरी है?

एक seed "random" नंबरों के क्रम को तय कर देता है, ताकि किसी run को बिल्कुल वैसे ही दोबारा दोहराया जा सके। अलग-अलग seeds से अलग-अलग किस्मत मिलती है। कई seeds पर टेस्ट करने से पता चलता है कि नतीजा वाकई सही है या सिर्फ तुक्के से मिला है।

क्या गेम्स के बाहर भी exploration मायने रखता है?

हाँ। एक recommendation system जो सिर्फ वही दिखाता है जो पहले से पसंद किया जा रहा है, वह शायद कभी नए आइटम्स के बारे में जान ही नहीं पाएगा। एक रोबोट जो कभी पकड़ने का नया तरीका आज़माता ही नहीं, उसे कभी बेहतर तरीका नहीं मिलेगा। लेकिन असल दुनिया में exploration को सुरक्षित सीमाओं के अंदर ही रहना चाहिए।

पाठ का टेस्ट

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

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

Exploration बनाम exploitation

Exploration बनाम exploitation

Epsilon सेट करने के तीन तरीके

Epsilon decay

छोटा इनाम एक जाल क्यों है

Runs की सही तरीके से तुलना करना

Seeds को तय (fix) रखें

एक बार में एक ही चीज़ बदलें

दो चीज़ें नापें

सभी runs की रिपोर्ट दें

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

समस्या

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

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

कठिन सवाल

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