Monte Carlo-methoden

Reinforcement Learning met Gymnasium in Python

Fouad Trad

Machine Learning Engineer

Herhaling: modelgebaseerd leren

 

  • Gebruikt kennis van omgevingsdynamiek
  • Geen interactie met de omgeving

Afbeelding van de schema's van policy-iteratie en value-iteratie, gezien in de vorige video.

Reinforcement Learning met Gymnasium in Python

Modelvrij leren

 

  • Vertrouwt niet op kennis van omgevingsdynamiek
  • Agent interageert met de omgeving
  • Leert beleid via trial-and-error
  • Geschikter voor echte toepassingen

Afbeelding van een robot die met een schaakomgeving interageert.

Reinforcement Learning met Gymnasium in Python

Monte Carlo-methoden

  • Modelvrije technieken
  • Schat Q-waarden op basis van episodes

Afbeelding van het skelet van een verzamelde episode: states, acties, beloningen en returns.

Reinforcement Learning met Gymnasium in Python

Monte Carlo-methoden

  • Modelvrije technieken
  • Schat Q-waarden op basis van episodes

Afbeelding van stap twee: Q-waarden schatten en vorm van een Q-tabel (rijen = states, kolommen = acties).

Reinforcement Learning met Gymnasium in Python

Monte Carlo-methoden

  • Modelvrije technieken
  • Schat Q-waarden op basis van episodes

Afbeelding van de laatste stap om het optimale beleid af te leiden: elk state mappen naar de optimale actie.

  • Twee varianten: first-visit, every-visit
Reinforcement Learning met Gymnasium in Python

Aangepaste gridworld

Afbeelding van de custom gridworld met 6 states (2 rijen, 3 kolommen), genummerd van linksboven (0) tot rechtsonder (5). De agent staat in state 3, er is een berg in state 4, en het doel is state 5.png

Reinforcement Learning met Gymnasium in Python

Twee episodes verzamelen

Afbeelding van de eerste episode met states, acties, beloningen en returns.

Afbeelding van de tweede episode met states, acties, beloningen en returns.

Reinforcement Learning met Gymnasium in Python

Q-waarden schatten

Afbeelding van de states, acties, beloningen en returns van beide episodes.

  • Q-tabel: tabel met Q-waarden

Afbeelding van een lege Q-tabel die we moeten invullen.

Reinforcement Learning met Gymnasium in Python

Q(4, left), Q(4, up) en Q(1, down)

Afbeelding van de states, acties, beloningen en returns van beide episodes met (4, left), (4, up) en (1, down) gemarkeerd.

  • (s,a) komt één keer voor -> vul in met return

Q-tabel met de waarden van (4, left), (4, up) en (1, down) ingevuld.

Reinforcement Learning met Gymnasium in Python

Q(4, right)

Afbeelding van de states, acties, beloningen en returns van beide episodes met (4, right) in beide episodes gemarkeerd

  • (s,a) komt per episode één keer voor -> neem het gemiddelde

Q-tabel met de waarde van (4, right) ingevuld als het gemiddelde van de returns uit beide episodes.

Reinforcement Learning met Gymnasium in Python

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

Afbeelding van de states, acties, beloningen en returns van beide episodes met (3, right) gemarkeerd alleen bij de eerste keer in beide episodes

  • Neem het gemiddelde van de eerste visit van (s,a) per episode

Q-tabel met de waarde van (3, right) als gemiddelde van de returns uit de gemarkeerde rijen (de eerste voorkomen van (3, right)).

Reinforcement Learning met Gymnasium in Python

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

Afbeelding van de states, acties, beloningen en returns van beide episodes met (3, right) elke keer gemarkeerd

  • Neem het gemiddelde over elke visit van (s,a) per episode

Q-tabel met de waarde van (3, right) als gemiddelde van de returns uit de gemarkeerde rijen (elke keer dat (3, right) voorkomt).

Reinforcement Learning met Gymnasium in Python

Een episode genereren

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
Reinforcement Learning met Gymnasium in Python

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
Reinforcement Learning met Gymnasium in Python

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
Reinforcement Learning met Gymnasium in Python

Het optimale beleid ophalen

def get_policy():
    policy = {state: np.argmax(Q[state]) for state in range(num_states)}    
    return policy
Reinforcement Learning met Gymnasium in Python

Alles samenvoegen

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}

Afbeelding van het optimale beleid met de optimale actie per state als pijlen.

Reinforcement Learning met Gymnasium in Python

Laten we oefenen!

Reinforcement Learning met Gymnasium in Python

Preparing Video For Download...