Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Apprentissage par renforcement et par imitation

Le Deep Q-Network (DQN) : mémoire de rejeu, réseau cible et double DQN sur CartPole

Le Q-learning avec un réseau de neurones : la triade mortelle, la mémoire de rejeu, le réseau cible, la surestimation du maximum démontrée et le double DQN, vraie fin et limite de temps, code PyTorch qui atteint 500 sur CartPole.

https://www.electronics-engineering.com/fr/deep-q-network-dqn-memoire-de-rejeu-reseau-cible-double-dqn/

Pas encore de vote : soyez le premier à noter cette page.

Un tableau Q(s, a) fonctionne tant que les états sont peu nombreux. CartPole a quatre variables continues, un jeu vidéo Atari a des images de 210×160 pixels : les états sont infinis ou astronomiquement nombreux. En 2015, DeepMind a montré qu’un réseau de neurones convolutif, entraîné avec le Q-learning et deux astuces, apprend à jouer à 49 jeux Atari en partant seulement des pixels, en dépassant le niveau humain dans beaucoup. C’est le Deep Q-Network (DQN). Cette leçon explique pourquoi le Q-learning avec un réseau de neurones est instable, comment la mémoire de rejeu et le réseau cible le stabilisent, pourquoi le maximum surestime les valeurs (et le remède, le double DQN), et l’applique à CartPole avec un code qui atteint le score maximal.

Du Q-learning tabulaire au réseau

Le tableau est remplacé par une fonction Q_\theta(s, a) de paramètres \theta (les poids d’un réseau) : l’état en entrée, une valeur par action en sortie. La mise à jour du Q-learning devient un pas de descente de gradient sur la fonction de perte

    \[ L(\theta) = \Big(\underbrace{r + \gamma\max_{a'}Q_{\bar\theta}(s', a')}_{y,\ \text{target}} - Q_\theta(s, a)\Big)^2 \]

où la cible y est traitée comme une constante (on ne dérive pas par rapport à elle). Cela paraît simple, mais assemblé naïvement, cela diverge souvent.

Pourquoi cela diverge : la triade mortelle

Sutton et Barto appellent triade mortelle la combinaison de trois ingrédients qui, ensemble, peuvent faire diverger l’apprentissage même dans des problèmes simples :

  • l’approximation de fonction : changer \theta pour corriger Q(s, a) change aussi les valeurs d’états semblables qu’on ne voulait pas toucher ;
  • le bootstrap : la cible contient l’estimation elle-même Q(s', \cdot), donc une erreur se propage et s’auto-alimente ;
  • l’hors-politique : on apprend la politique gloutonne à partir de données recueillies avec une autre politique (celle qui explore).

Le Q-learning profond a les trois. À cela s’ajoute un problème statistique : les pas consécutifs d’un épisode sont fortement corrélés (l’état au pas t + 1 est presque égal à celui du pas t), alors que la descente de gradient suppose des exemples indépendants.

Les deux astuces du DQN

Mémoire de rejeu. Chaque transition (s, a, r, s', \text{done}) est stockée dans un tampon de quelques dizaines de milliers d’éléments ; à chaque pas d’entraînement, on tire un mini-lot au hasard. Cela brise les corrélations, réutilise chaque expérience de nombreuses fois (ce qui est légitime parce que le Q-learning est hors-politique) et moyenne sur de nombreuses situations différentes.

Réseau cible. La cible y est calculée avec une copie des poids, \bar\theta, mise à jour seulement tous les quelques centaines ou milliers de pas (\bar\theta \leftarrow \theta). Entre deux copies, le problème devient une régression supervisée avec des cibles fixes, et le réseau ne « court pas après sa propre queue ».

Le schéma du DQN
L’agent agit dans l’environnement avec une politique epsilon-gloutonne fondée sur le réseau Q ; les transitions vont dans la mémoire de rejeu, d’où l’on tire des mini-lots aléatoires. La perte compare Q theta à la cible calculée par le réseau cible, une copie retardée des poids.

Surestimation du maximum et double DQN

Théorème. Si les estimations \hat Q(s', a') sont non biaisées mais bruitées, \mathbb E[\hat Q(s', a')] = Q(s', a'), alors le maximum est surestimé : \mathbb E[\max_{a'}\hat Q(s', a')] \ge \max_{a'}Q(s', a').

Démonstration. Pour tout a', \max_b\hat Q(s', b) \ge \hat Q(s', a') ; en prenant la moyenne, \mathbb E[\max_b\hat Q] \ge \mathbb E[\hat Q(s', a')] = Q(s', a'), et cela vaut pour tout a', donc aussi pour celui qui maximise Q. ∎

Le bruit est « sélectionné » : l’action qui paraît la meilleure est souvent celle qui est estimée trop haut. La surestimation s’accumule par le bootstrap. Le double DQN (van Hasselt, 2016) sépare le choix de l’évaluation : le réseau en ligne choisit l’action, le réseau cible l’évalue,

    \[ y = r + \gamma\,Q_{\bar\theta}\big(s',\ \arg\max_{a'}Q_\theta(s', a')\big) \]

Les erreurs des deux réseaux sont largement indépendantes, et la surestimation est fortement réduite.

Vraie fin et limite de temps. Si l’épisode se termine parce que le bâton est tombé, il n’y a plus de récompense et la cible est juste r. Si en revanche il se termine parce que le temps est écoulé (500 pas dans CartPole), l’état n’est pas terminal : la cible doit encore inclure \gamma\max Q(s', \cdot). Confondre les deux cas est l’une des erreurs les plus courantes ; Gymnasium les distingue avec les deux valeurs terminated et truncated.

Le code sur CartPole

import random, collections
import numpy as np
import torch, torch.nn as nn
import gymnasium

torch.manual_seed(0); random.seed(0); np.random.seed(0)
env = gymnasium.make("CartPole-v1")

def network():
    return nn.Sequential(nn.Linear(4, 128), nn.ReLU(), nn.Linear(128, 128), nn.ReLU(), nn.Linear(128, 2))
q, q_target = network(), network()
q_target.load_state_dict(q.state_dict())
opt = torch.optim.Adam(q.parameters(), lr=2.5e-4)
memory = collections.deque(maxlen=10000)                      # replay memory
STEPS, BATCH, GAMMA, COPY, EVERY, START = 200000, 128, 0.99, 500, 10, 10000

o, _ = env.reset(seed=0)
env.action_space.seed(0)
for t in range(STEPS):
    eps = max(0.05, 1 - 0.95 * t / 100000)                   # decreasing exploration
    if random.random() < eps:
        a = env.action_space.sample()
    else:
        with torch.no_grad():
            a = int(q(torch.tensor(o, dtype=torch.float32)).argmax())
    o2, r, terminated, truncated, _ = env.step(a)
    memory.append((o, a, r, o2, float(terminated)))           # only a true end zeroes the future
    o = o2
    if terminated or truncated:
        o, _ = env.reset()
    if t >= START and t % EVERY == 0:
        b = random.sample(memory, BATCH)
        O, A, R, O2, D = (torch.tensor(np.array(x), dtype=torch.float32) for x in zip(*b))
        with torch.no_grad():                                 # double DQN
            a2 = q(O2).argmax(1, keepdim=True)
            y = R + GAMMA * (1 - D) * q_target(O2).gather(1, a2).squeeze(1)
        estimate = q(O).gather(1, A.long().unsqueeze(1)).squeeze(1)
        loss = nn.functional.mse_loss(estimate, y)
        opt.zero_grad(); loss.backward(); opt.step()
    if t % COPY == 0:
        q_target.load_state_dict(q.state_dict())            # target network update

# greedy evaluation over 20 episodes
scores = []
for e in range(20):
    o, _ = env.reset(seed=1000 + e)
    tot, done = 0.0, False
    while not done:
        with torch.no_grad():
            o, r, te, tr, _ = env.step(int(q(torch.tensor(o, dtype=torch.float32)).argmax()))
        tot += r; done = te or tr
    scores.append(tot)
print("evaluation:", np.mean(scores))

Les hyperparamètres sont ceux de la bibliothèque pédagogique CleanRL. Pendant l’entraînement, le retour moyen passe de 62 (après 40 000 pas) à 353, 370, 468 et 500 ; l’évaluation gloutonne finale est de 500 sur 20 épisodes, le maximum possible. Sur un processeur ordinaire, cela prend moins d’une minute.

Apprentissage du DQN sur CartPole
Le retour moyen des 20 derniers épisodes passe d’environ 60 après 40 mille pas au maximum de 500 à 200 mille pas ; la ligne grise pointillée est le score maximal.

Au-delà du DQN

Le DQN fonctionne avec peu d’actions discrètes (il doit calculer le maximum sur toutes). Pour des actions continues, comme les couples d’un robot ou le braquage d’une voiture, on utilise des méthodes acteur-critique (DDPG, TD3, SAC), qui apprennent aussi une politique, ainsi que les méthodes de gradient de politique de la leçon suivante. Les variantes du DQN pour les jeux (Rainbow) ajoutent le rejeu prioritaire, les réseaux « dueling », les retours à plusieurs pas et les distributions de retour ; le principe reste celui décrit ici.

S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x