L'algorithme DQN minimal

Deep Reinforcement Learning en Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Le DQN minimal

 

 

  • Première étape vers le DQN complet
  • Composants :
    • Boucle d'entraînement DRL générique
    • Un réseau Q
    • Principes du Q-learning
for episode in range(1000):
  state, info = env.reset()
  done = False
  while not done:
    # Action selection
    action = select_action(network, state)
    next_state, reward, terminated, truncated, _ = (
                                   env.step(action))
    done = terminated or truncated
    # Loss calculation
    loss = calculate_loss(network, state, action, 
                          next_state, reward, done)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    state = next_state
Deep Reinforcement Learning en Python

Sélection d'action dans le DQN minimal

 

def select_action(q_network, state):

    # Feed state to network to obtain Q-values

    q_values = q_network(state)

    # Obtain index of action with highest Q-value
    action = torch.argmax(q_values).item()

    return action
  • Politique : choisir l'action au plus grand Q-value
    • $ a_t = {\arg\max}_a Q(S_t, a) $
    • Ici : action 2, avec Q-value 0.12

 

 

Q-values: [-0.01, 0.08, 0.12, -0.07]

Action choisie : 2, avec Q-value 0.12
Deep Reinforcement Learning en Python

La fonction de perte du DQN minimal

 

  • La fonction valeur d'action satisfait l'équation de Bellman
  • Idée : minimiser l'écart entre les deux côtés, soit l'erreur TD (erreur de Bellman)
  • Utiliser l'erreur de Bellman au carré comme fonction de perte :

Perte DQN (erreur de Bellman au carré) : L(theta) = carré de l'erreur de Bellman

 

Équation de Bellman Q(S,A) = reward + discount * max(Q(S_next,A))

Erreur de Bellman Q(S,A) - (reward + discount * max(Q(S_next,A)))

Deep Reinforcement Learning en Python

La fonction de perte du DQN minimal

def calculate_loss(
      q_network, state, action,
      next_state, reward, done):

    q_values = q_network(state)

    current_state_q_value = q_values[action]

    next_state_q_value = q_network(next_state).max()

    target_q_value = reward +
                gamma * next_state_q_value * (1-done)

    loss = nn.MSELoss()(
              current_state_q_value, target_q_value)

    return loss
  • Q-value de l'état courant :

       $Q(s_t, a_t)$

  • Q-value de l'état suivant :

       $\max_a Q(s_{t+1}, a)$

  • Q-value cible :

       $r_{t+1} + \gamma \max_a Q(s_{t+1}, a)$

  • Perte DQN :

$$\left(Q(s_t, a_t) - (r_{t+1} + \gamma \max_a Q(s_{t+1}, a)\right)^2$$

Deep Reinforcement Learning en Python

Décrire les épisodes

describe_episode(episode, reward, episode_reward, step)

| Épisode    1 | Durée :   84 étapes | Retour : -871.38 | Échec |

| Épisode    2 | Durée :   53 étapes | Retour : -452.68 | Échec |

| Épisode    3 | Durée :   57 étapes | Retour : -414.22 | Échec |
| Épisode    4 | Durée :   54 étapes | Retour : -475.09 | Échec |

| Épisode    5 | Durée :   67 étapes | Retour : -532.31 | Échec |
| Épisode    6 | Durée :   53 étapes | Retour : -407.00 | Échec |
| Épisode    7 | Durée :   52 étapes | Retour : -380.45 | Échec |
| Épisode    8 | Durée :   55 étapes | Retour : -380.75 | Échec |
| Épisode    9 | Durée :   88 étapes | Retour : -688.68 | Échec |
| Épisode   10 | Durée :   76 étapes | Retour : -338.06 | Échec |
Deep Reinforcement Learning en Python

Passons à la pratique !

Deep Reinforcement Learning en Python

Preparing Video For Download...