Metody Monte Carlo

Uczenie przez wzmacnianie z Gymnasium w Pythonie

Fouad Trad

Machine Learning Engineer

Podsumowanie: uczenie oparte na modelu

Opierają się na znajomości dynamiki środowiska
Brak interakcji ze środowiskiem

Obraz przedstawiający schematy algorytmów iteracji polityki i iteracji wartości, omówionych w poprzednim filmie.

Uczenie bezmodelowe

Nie wymaga znajomości dynamiki środowiska
Agent wchodzi w interakcję ze środowiskiem
Uczy się polityki metodą prób i błędów
Lepiej nadaje się do zastosowań rzeczywistych

Obraz robota wchodzącego w interakcję ze środowiskiem szachowym.

Metody Monte Carlo

Techniki bezmodelowe
Szacowanie wartości Q na podstawie epizodów

Obraz przedstawiający szkielet zebranego epizodu złożonego ze stanów, akcji, nagród i zwrotów.

Metody Monte Carlo

Techniki bezmodelowe
Szacowanie wartości Q na podstawie epizodów

Obraz przedstawiający drugi krok szacowania wartości Q i wygląd tabeli Q, z liczbą wierszy równą liczbie stanów i liczbą kolumn równą liczbie akcji.

Metody Monte Carlo

Techniki bezmodelowe
Szacowanie wartości Q na podstawie epizodów

Obraz przedstawiający końcowy krok wyznaczania optymalnej polityki, mapującej każdy stan na optymalną akcję.

Dwie metody: first-visit, every-visit

Niestandardowy świat siatki

Obraz przedstawiający niestandardowy świat siatki z 6 stanami, 2 wierszami i 3 kolumnami, numerowanymi od lewego górnego rogu (0) do prawego dolnego (5). Agent jest w stanie 3, góra w stanie 4, a cel w stanie 5.

Zbieranie dwóch epizodów

Obraz przedstawiający pierwszy zebrany epizod w postaci stanów, akcji, nagród i zwrotów.

Obraz przedstawiający drugi zebrany epizod w postaci stanów, akcji, nagród i zwrotów.

Szacowanie wartości Q

Obraz przedstawiający stany, akcje, nagrody i zwroty zebrane dla dwóch epizodów.

Tabela Q: tabela wartości Q

Obraz przedstawiający pustą tabelę Q do wypełnienia.

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

Obraz przedstawiający stany, akcje, nagrody i zwroty dla dwóch epizodów z wyróżnionymi (4, left), (4, up) i (1, down).

(s,a) występuje raz -> wypełnij zwrotem

Tabela Q z wypełnionymi wartościami (4, left), (4, up) i (1, down).

Q(4, right)

Obraz przedstawiający stany, akcje, nagrody i zwroty dla dwóch epizodów z wyróżnionym (4, right) w obu epizodach.

(s,a) raz na epizod -> uśrednianie

Tabela Q z wartością (4, right) obliczoną jako średnia zwrotów z obu epizodów.

Q(3, right) – Monte Carlo pierwszej wizyty

Obraz przedstawiający stany, akcje, nagrody i zwroty dla dwóch epizodów z wyróżnionym (3, right) tylko przy pierwszym wystąpieniu w obu epizodach.

Uśrednianie pierwszej wizyty w (s,a) w obrębie epizodów

Tabela Q z wartością (3, right) obliczoną jako średnia zwrotów z wyróżnionych wierszy (pierwsze wystąpienia (3, right)).

Q(3, right) – Monte Carlo każdej wizyty

Obraz przedstawiający stany, akcje, nagrody i zwroty dla dwóch epizodów z wyróżnionym (3, right) przy każdym wystąpieniu w obu epizodach.

Uśrednianie każdej wizyty w (s,a) w obrębie epizodów

Tabela Q z wartością (3, right) obliczoną jako średnia zwrotów z wyróżnionych wierszy (każde wystąpienie (3, right)).

Generowanie epizodu

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

Monte Carlo pierwszej wizyty

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

Monte Carlo każdej wizyty

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

Wyznaczanie optymalnej polityki

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

Łącząc wszystko razem

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}

Obraz przedstawiający optymalną politykę z optymalną akcją w każdym stanie w postaci strzałek.

Czas na ćwiczenia!

Uczenie przez wzmacnianie z Gymnasium w Pythonie