Algorithme DQN complet

Deep Reinforcement Learning en Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

L'algorithme DQN

 

 

  • Nous avons étudié DQN avec Experience Replay
  • Proche du DQN publié en 2015
  • Il manque encore deux éléments :
    • Epsilon-greediness → plus d'exploration
    • Q-cibles figées → apprentissage plus stable

Une aventurière se tient debout, la lettre grecque epsilon à ses côtés

La lettre majuscule Q, gelée dans un bloc de glace

Deep Reinforcement Learning en Python

Epsilon-greediness dans l'algorithme DQN

  • Implémenter l'epsilon-greediness décroissant dans select_action()
def select_action(q_values, step, start, end, decay):

    # Calculate the threshold value for this step
    epsilon = (
        end + (start-end) * math.exp(-step / decay))

    # Draw a random number between 0 and 1
    sample = random.random()

    if sample < epsilon:
        # Return a random action index
        return random.choice(range(len(q_values)))

    # Return the action index with highest Q-value
    return torch.argmax(q_values).item()
  • $\varepsilon = end + (start-end) \cdot e^{-\frac{step}{decay}}$
  • Effectuer une action au hasard avec la probabilité $\varepsilon$
  • Prendre l'action à plus forte valeur avec la probabilité $1 - \varepsilon$

Un graphique montrant la décroissance d'epsilon pour différentes valeurs du paramètre de décroissance.

Deep Reinforcement Learning en Python

Q-cibles figées

 

  • Dans l'erreur de Bellman :
    • Réseau Q dans le calcul de la valeur Q et de la cible TD
    • Instabilité due à une cible qui bouge

 

  • Introduire un réseau cible pour stabiliser la cible

 

L'erreur de Bellman : (r_t+1 + gamma max(Q(s_t+1, a))) - Q(s_t, a_t)

(r_t+1 + gamma max(Q_target(s_t+1, a))) - Q_online(s_t, a_t)

Deep Reinforcement Learning en Python

Implémenter des Q-cibles figées

online_network = QNetwork(state_size, action_size)
target_network = QNetwork(state_size, action_size)

target_network.load_state_dict(
                       online_network.state_dict())


def update_target_network(
                 target_network, online_network, tau):

  target_net_state_dict = target_network.state_dict()
  online_net_state_dict = online_network.state_dict()
  for key in online_net_state_dict:

    target_net_state_dict[key] = (
         online_net_state_dict[key] * tau + 
         target_net_state_dict[key] * (1 - tau))

    target_network.load_state_dict(
                          target_net_state_dict)

  return None
  • Au départ : Online Network = Target Network
  • Le « state dict » d'un réseau contient tous les poids : représentation d'un dictionnaire d'état de réseau, avec des entrées pour fc1.weight, fc1.bias et fc2.weight ; la valeur de chaque entrée est un tenseur.
  • À chaque pas, chaque poids du Target Network se rapproche un peu de l'Online Network
Deep Reinforcement Learning en Python

Calcul de la perte avec Q-cibles figées

# In the inner loop, after action selection
if len(replay_buffer) >= batch_size:
  states, actions, rewards, next_states, dones = 
      replay_buffer.sample(64)

  q_values = (online_network(states)
            .gather(1, actions).squeeze(1))

  with torch.no_grad():

    next_q_values = (
        target_network(next_states).amax(1))
    target_q_values = (
        rewards + gamma * next_q_values * (1 - dones))

  loss = torch.nn.MSELoss()(target_q_values, q_values)
  optimizer.zero_grad()
  loss.backward()
  optimizer.step()

  update_target_network(
               target_network, online_network, tau)

 

  • Les Q-values utilisent online_network
  • Les Q-cibles utilisent target_network
  • Utiliser torch.no_grad() pour désactiver le suivi des gradients pour les Q-cibles
  • Utiliser encore l'erreur quadratique moyenne de Bellman pour la perte
  • Utiliser update_target_network() pour mettre à jour lentement target_network
Deep Reinforcement Learning en Python

Passons à la pratique !

Deep Reinforcement Learning en Python

Preparing Video For Download...