Metode Monte Carlo

Reinforcement Learning cu Gymnasium în Python

Fouad Trad

Machine Learning Engineer

Recapitulare: învățare bazată pe model

 

  • Se bazează pe cunoașterea dinamicii mediului
  • Fără interacțiune cu mediul

Imagine care arată diagramele algoritmilor de iterare a politicii și iterare a valorii, prezentați în videoclipul anterior.

Reinforcement Learning cu Gymnasium în Python

Învățare fără model

 

  • Nu se bazează pe cunoașterea dinamicii mediului
  • Agentul interacționează cu mediul
  • Învață politica prin încercare și eroare
  • Mai potrivit pentru aplicații din lumea reală

Imagine cu un robot care interacționează cu un mediu de șah.

Reinforcement Learning cu Gymnasium în Python

Metode Monte Carlo

  • Tehnici fără model
  • Estimează valorile Q pe baza episoadelor

Imagine care arată structura unui episod colectat, cuprinzând stări, acțiuni, recompense și retururi.

Reinforcement Learning cu Gymnasium în Python

Metode Monte Carlo

  • Tehnici fără model
  • Estimează valorile Q pe baza episoadelor

Imagine care arată al doilea pas al estimării valorilor Q și cum arată un tabel Q, cu un număr de rânduri egal cu numărul de stări și un număr de coloane egal cu numărul de acțiuni.

Reinforcement Learning cu Gymnasium în Python

Metode Monte Carlo

  • Tehnici fără model
  • Estimează valorile Q pe baza episoadelor

Imagine care arată pasul final al derivării politicii optime, care mapează fiecare stare la acțiunea optimă.

  • Două metode: prima vizită, fiecare vizită
Reinforcement Learning cu Gymnasium în Python

Lume grilă personalizată

Imagine cu lumea grilă personalizată cu 6 stări, 2 rânduri și 3 coloane, numerotate de la stânga sus (0) la dreapta jos (5). Agentul este în starea 3, un munte în starea 4, iar obiectivul în starea 5.png

Reinforcement Learning cu Gymnasium în Python

Colectarea a două episoade

Imagine care arată primul episod colectat în termeni de stări, acțiuni, recompense și retururi.

Imagine care arată al doilea episod colectat în termeni de stări, acțiuni, recompense și retururi.

Reinforcement Learning cu Gymnasium în Python

Estimarea valorilor Q

Imagine care arată stările, acțiunile, recompensele și retururile colectate pentru cele două episoade.

  • Tabel Q: tabel pentru valorile Q

Imagine care arată un tabel Q gol ce urmează să fie completat.

Reinforcement Learning cu Gymnasium în Python

Q(4, stânga), Q(4, sus) și Q(1, jos)

Imagine care arată stările, acțiunile, recompensele și retururile colectate pentru cele două episoade, cu (4, stânga), (4, sus) și (1, jos) evidențiate.

  • (s,a) apare o dată -> completat cu returul

Tabel Q cu valorile pentru (4, stânga), (4, sus) și (1, jos) completate.

Reinforcement Learning cu Gymnasium în Python

Q(4, dreapta)

Imagine care arată stările, acțiunile, recompensele și retururile colectate pentru cele două episoade, cu (4, dreapta) evidențiat în ambele episoade.

  • (s,a) apare o dată per episod -> medie

Tabel Q cu valoarea pentru (4, dreapta) completată prin media retururilor din ambele episoade.

Reinforcement Learning cu Gymnasium în Python

Q(3, dreapta) - Monte Carlo prima vizită

Imagine care arată stările, acțiunile, recompensele și retururile colectate pentru cele două episoade, cu (3, dreapta) evidențiat doar pentru prima apariție din fiecare episod.

  • Media primei vizite la (s,a) în cadrul episoadelor

Tabel Q cu valoarea pentru (3, dreapta) completată prin media retururilor din rândurile evidențiate (primele apariții ale lui (3, dreapta)).

Reinforcement Learning cu Gymnasium în Python

Q(3, dreapta) - Monte Carlo fiecare vizită

Imagine care arată stările, acțiunile, recompensele și retururile colectate pentru cele două episoade, cu (3, dreapta) evidențiat pentru fiecare apariție din ambele episoade.

  • Media fiecărei vizite la (s,a) în cadrul episoadelor

Tabel Q cu valoarea pentru (3, dreapta) completată prin media retururilor din rândurile evidențiate (fiecare apariție a lui (3, dreapta)).

Reinforcement Learning cu Gymnasium în Python

Generarea unui episod

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 cu Gymnasium în Python

Monte Carlo prima vizită

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 cu Gymnasium în Python

Monte Carlo fiecare vizită

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 cu Gymnasium în Python

Obținerea politicii optime

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

Totul împreună

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}

Imagine care arată politica optimă cu acțiunea optimă pentru fiecare stare sub formă de săgeți.

Reinforcement Learning cu Gymnasium în Python

Să exersăm!

Reinforcement Learning cu Gymnasium în Python

Preparing Video For Download...