Monte Carlo methods

Python में Gymnasium के साथ Reinforcement Learning

Fouad Trad

Machine Learning Engineer

रीकैप: मॉडल-आधारित लर्निंग

 

  • पर्यावरण डायनेमिक्स के ज्ञान पर निर्भर
  • पर्यावरण से कोई इंटरैक्शन नहीं

पिछले वीडियो में देखे गए policy iteration और value iteration एल्गोरिदम के डायग्राम।

Python में Gymnasium के साथ Reinforcement Learning

Model-free लर्निंग

 

  • पर्यावरण डायनेमिक्स के ज्ञान पर निर्भर नहीं
  • एजेंट पर्यावरण से इंटरैक्ट करता है
  • ट्रायल-एंड-एरर से पॉलिसी सीखता है
  • वास्तविक-world ऐप्लिकेशंस के लिए अधिक उपयुक्त

एक रोबोट जो शतरंज वाले पर्यावरण से इंटरैक्ट कर रहा है।

Python में Gymnasium के साथ Reinforcement Learning

Monte Carlo methods

  • Model-free तकनीकें
  • एपिसोड्स के आधार पर Q-values का अनुमान

कलेक्टेड एपिसोड का ढांचा: states, actions, rewards, और returns।

Python में Gymnasium के साथ Reinforcement Learning

Monte Carlo methods

  • Model-free तकनीकें
  • एपिसोड्स के आधार पर Q-values का अनुमान

Q-values का अनुमान लगाने का दूसरा चरण और Q-table का रूप: पंक्तियाँ = states, कॉलम = actions।

Python में Gymnasium के साथ Reinforcement Learning

Monte Carlo methods

  • Model-free तकनीकें
  • एपिसोड्स के आधार पर Q-values का अनुमान

ऑप्टिमल पॉलिसी निकालने का अंतिम चरण: हर state को ऑप्टिमल action से मैप करना।

  • दो तरीके: first-visit, every-visit
Python में Gymnasium के साथ Reinforcement Learning

कस्टम ग्रिड वर्ल्ड

कस्टम ग्रिड वर्ल्ड: 6 states, 2 पंक्तियाँ और 3 कॉलम, ऊपर-बाएँ (0) से नीचे-दाएँ (5) तक नंबरिंग। एजेंट state 3 में है, पर्वत state 4 में, और लक्ष्य state 5 में।

Python में Gymnasium के साथ Reinforcement Learning

दो एपिसोड इकट्ठा करना

पहला एपिसोड: states, actions, rewards, और returns।

दूसरा एपिसोड: states, actions, rewards, और returns।

Python में Gymnasium के साथ Reinforcement Learning

Q-values का अनुमान लगाना

दोनों एपिसोड के states, actions, rewards, और returns।

  • Q-table: Q-values की तालिका

एक खाली Q-table जिसे हमें भरना है।

Python में Gymnasium के साथ Reinforcement Learning

Q(4, left), Q(4, up), और Q(1, down)

दोनों एपिसोड के states, actions, rewards, और returns, जहाँ (4, left), (4, up), और (1, down) हाइलाइट हैं।

  • (s,a) एक बार आता है -> उसी return से भरें

Q-table जिसमें (4, left), (4, up), और (1, down) के मान भरे हैं।

Python में Gymnasium के साथ Reinforcement Learning

Q(4, right)

दोनों एपिसोड में (4, right) हाइलाइट के साथ states, actions, rewards, और returns।

  • (s,a) हर एपिसोड में एक बार आता है -> औसत लें

Q-table जिसमें (4, right) का मान दोनों एपिसोड के returns के औसत से भरा है।

Python में Gymnasium के साथ Reinforcement Learning

Q(3, right) - first-visit Monte Carlo

दोनों एपिसोड में (3, right) की केवल पहली बार की घटनाओं को हाइलाइट किया गया है, साथ में states, actions, rewards, और returns।

  • एपिसोड्स में (s,a) की पहली विज़िट्स का औसत लें

Q-table जिसमें (3, right) का मान हाइलाइट पंक्तियों (पहली घटनाएँ) के returns के औसत से भरा है।

Python में Gymnasium के साथ Reinforcement Learning

Q(3, right) - every-visit Monte Carlo

दोनों एपिसोड में (3, right) की हर घटना को हाइलाइट किया गया है, साथ में states, actions, rewards, और returns।

  • एपिसोड्स में (s,a) की हर विज़िट का औसत लें

Q-table जिसमें (3, right) का मान हाइलाइट पंक्तियों (हर घटना) के returns के औसत से भरा है।

Python में Gymnasium के साथ Reinforcement Learning

एक एपिसोड जनरेट करना

def generate_episode():
    episode = []
    state, info = env.reset()

    terminated = False
    while not terminated:
        action = env.action_space.sample()

        next_state, reward, terminated, truncated, info = env.step(action)

        episode.append((state, action, reward))
        state = next_state

    return episode
Python में Gymnasium के साथ Reinforcement Learning

First-visit Monte Carlo

def first_visit_mc(num_episodes):
    Q = np.zeros((num_states, num_actions))
    returns_sum = np.zeros((num_states, num_actions))
    returns_count = np.zeros((num_states, num_actions))


    for i in range(num_episodes):
        episode = generate_episode()
        visited_states_actions = set()

        for j, (state, action, reward) in enumerate(episode):

            if (state, action) not in visited_states:

                returns_sum[state, action] += sum([x[2] for x in episode[j:]])

                returns_count[state, action] += 1
                visited_states_actions.add((state, action))


    nonzero_counts = returns_count != 0

    Q[nonzero_counts] = returns_sum[nonzero_counts] / returns_count[nonzero_counts]
    return Q
Python में Gymnasium के साथ Reinforcement Learning

Every-visit Monte Carlo

def every_visit_mc(num_episodes):
    Q = np.zeros((num_states, num_actions))
    returns_sum = np.zeros((num_states, num_actions))
    returns_count = np.zeros((num_states, num_actions))    

    for i in range(num_episodes):
        episode = generate_episode()  

        for j, (state, action, reward) in enumerate(episode):

            returns_sum[state, action] += sum([x[2] for x in episode[j:]])
            returns_count[state, action] += 1


    nonzero_counts = returns_count != 0
    Q[nonzero_counts] = returns_sum[nonzero_counts] / returns_count[nonzero_counts]
    return Q
Python में Gymnasium के साथ Reinforcement Learning

ऑप्टिमल पॉलिसी प्राप्त करना

def get_policy():
    policy = {state: np.argmax(Q[state]) for state in range(num_states)}    
    return policy
Python में Gymnasium के साथ Reinforcement Learning

सब कुछ एक साथ रखना

Q = first_visit_mc(1000)

policy_first_visit = get_policy()

print("First-visit policy: \n", policy_first_visit)

Q = every_visit_mc(1000)

policy_every_visit = get_policy()

print("Every-visit policy: \n", policy_every_visit)

First-visit policy:
{0: 2, 1: 2, 2: 1, 
 3: 2, 4: 2, 5: 0}

Every-visit policy:
{0: 2, 1: 2, 2: 1, 
 3: 2, 4: 2, 5: 0}

हर state के लिए लेने योग्य ऑप्टिमल action को तीरों के रूप में दिखाती ऑप्टिमल पॉलिसी।

Python में Gymnasium के साथ Reinforcement Learning

अभ्यास करते हैं!

Python में Gymnasium के साथ Reinforcement Learning

Preparing Video For Download...