Introducere în învățarea profundă prin recompensă

Deep Reinforcement Learning în Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

De ce învățare profundă prin recompensă

RL tradițional este potrivit pentru sarcini cu dimensiuni reduse

Multe aplicații au spații de stări și/sau acțiuni de mare dimensiune

Un agent care explorează mediul Frozen Lake

Un agent jucând jocul clasic Space Invaders

Ingredientele DRL

Concepte de învățare prin recompensă
Învățare profundă și PyTorch

DRL combină aceste concepte cu rețele neuronale adânci

Ilustrație pixel art a unui bucătar care amestecă ingrediente

Cadrul RL

Pasul t:

O casetă mare cu două casete mai mici în interior, etichetate „Agent" și „Mediu"

Cadrul RL

Pasul t:
- Agentul observă starea $s_t$

O săgeată roșie cu eticheta Stare s_t merge de la mediu la agent.

Cadrul RL

Pasul t:
- Agentul observă starea $s_t$
- Agentul execută acțiunea $a_t$

O săgeată roșie cu eticheta acțiune a_t merge de la agent la mediu. Săgeata stării este acum neagră.

Cadrul RL

Pasul t:
- Agentul observă starea $s_t$
- Agentul execută acțiunea $a_t$
Pasul t+1:
- Mediul oferă recompensa $r_t$
- Starea evoluează la $s_{t+1}$

Săgeata stării s_t își actualizează eticheta la starea s_t+1 și este din nou roșie. O nouă săgeată roșie cu eticheta recompensă r_t+1 merge de la mediu la agent. Săgeata acțiunii este acum neagră.

Cadrul RL

Pasul t:
- Agentul observă starea $s_t$
- Agentul execută acțiunea $a_t$
Pasul t+1:
- Mediul oferă recompensa $r_t$
- Starea evoluează la $s_{t+1}$
Se repetă până la finalizarea episodului

Aceeași imagine ca pe diapozitivul anterior, dar toate săgețile sunt negre.

Politica $\pi(s_t)$

Mapare de la stare la acțiune, care descrie comportamentul agentului în starea $s_t$

Deterministă:
- Returnează acțiunea selectată
Stocastică:
- Returnează o distribuție peste acțiuni
- Politica este o distribuție de probabilitate peste acțiunile posibile

Traiectorie și randamentul episodului

Traiectoria tau: secvența tuturor stărilor și acțiunilor dintr-un episod; tau = ((s0, a0), (s1, a1), ... (sT, aT))

Randamentul episodului Rtau: recompensele totale (actualizate) acumulate de-a lungul traiectoriei tau. Rtau = suma peste t a lui gamma la puterea t înmulțit cu r_t

Configurarea mediului

env = gym.make("ALE/SpaceInvaders-v5")

# Define neural network architecture
class Network(nn.Module):
    def __init__(self, dim_inputs, dim_outputs):
        super(Network, self).__init__()
        self.linear = nn.Linear(dim_inputs, dim_outputs)
    def forward(self, x):
        return self.linear(x)

# Instantiate network
network = Network(dim_inputs, dim_outputs)

# Instantiate optimizer
optimizer = optim.Adam(network.parameters(), lr=0.0001)

Bucla de bază

for episode in range(1000):
  state, info = env.reset()
  done = False

  while not done:

    action = select_action(network, state)

    next_state, reward, terminated, truncated, _ = (
                                     env.step(action))
    done = terminated or truncated


    loss = calculate_loss(network, state, action, 
          next_state, reward, done)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()


    state = next_state

Bucla externă: iterare prin episoade
Bucla internă: iterare prin pași
- Selectarea unei acțiuni
- Observarea noii stări și a recompensei
- Calcularea pierderii și actualizarea rețelei
- Actualizarea stării
(Pierdere?)

Urmează

DRL este puternic!
Abordări bazate pe valoare și pe politică
DQN și îmbunătățiri
Metode de gradient de politică

Un cursant Datacamp care se scufundă în mare pentru a descoperi secretele învățării profunde prin recompensă

Să exersăm!

Deep Reinforcement Learning în Python