Double DQN

Deep Reinforcement Learning en Python

Timothée Carayol

Principal Machine Learning Engineer, Komment

Double Q-learning

Le Q-learning surestime les valeurs Q, ce qui nuit à l'efficacité de l'apprentissage
C'est dû au biais de maximisation
Le Double Q-learning supprime ce biais en dissociant le choix d'action et l'estimation de valeur

Deux tables Q (illustration tirée du cours Reinforcement Learning with Gymnasium using Python); le double Q-learning les utilise en alternance

L'idée derrière le DDQN

Partir d'un DQN complet (avec cibles Q figées)
Dans la cible TD du DQN :
- Sélection d'action : réseau cible
- Estimation de valeur : réseau cible
Dans la cible TD du DDQN :
- Sélection d'action : réseau en ligne
- Estimation de valeur : réseau cible
Pas exactement le double Q-learning (pas d'alternance de réseaux Q)
On obtient l'essentiel du gain, pour un changement minimal

Erreur de Bellman (DQN avec cibles Q figées) : Q_online(s_t, a_t) - (r_t+1 + gamma max(Q_target(s_t+1, a)))

Erreur de Bellman (DDQN avec cibles Q figées) : Q_online(s_t, a_t) - (r_t+1 + gamma Q_target(s_t+1, tilde a)) avec tilde a = argmax_a(Q_online(s_t+1, a))

Implémentation du Double DQN

DQN:

... # instantiate online and target networks
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()(q_values, target_q_values)
... # gradient descent
... # target network update

DDQN:

... # instantiate online and target networks
q_values = (online_network(states)
            .gather(1, actions).squeeze(1))

with torch.no_grad():






    target_q_values = (rewards + 
        gamma * next_q_values * (1 - dones))

loss = torch.nn.MSELoss()(q_values, target_q_values)
... # gradient descent
... # target network update

Implémentation du Double DQN

DQN:

... # instantiate online and target networks
q_values = (online_network(states)
            .gather(1, actions).squeeze(1))

with torch.no_grad():

    next_actions = (target_network(next_states)
       .argmax(1).unsqueeze(1))

    next_q_values = (target_network(next_states)
       .gather(1, next_actions).squeeze(1))

    target_q_values = (rewards + 
        gamma * next_q_values * (1 - dones))

loss = torch.nn.MSELoss()(q_values, target_q_values)
... # gradient descent
... # target network update

DDQN:

... # instantiate online and target networks
q_values = (online_network(states)
            .gather(1, actions).squeeze(1))

with torch.no_grad():

    next_actions = (online_network(next_states)
       .argmax(1).unsqueeze(1))

    next_q_values = (target_network(next_states)
       .gather(1, next_actions).squeeze(1))

    target_q_values = (rewards + 
        gamma * next_q_values * (1 - dones))

loss = torch.nn.MSELoss()(q_values, target_q_values)
... # gradient descent
... # target network update

Rendement du DDQN

Comparer le rendement de DDQN, DQN et des humains sur des jeux Atari
DDQN : scores supérieurs au DQN d'origine
Pas toujours vrai → essayez les deux

Diagramme à barres montrant que le DQN égale presque la performance humaine pour le jeu médian et dépasse l'humain en moyenne ; et que le DDQN surpasse à la fois l'humain et le DQN au médian et en moyenne.

¹ https://arxiv.org/abs/2303.11634

Passons à la pratique !

Deep Reinforcement Learning en Python