Deep Reinforcement Learning

L’apprentissage profond par renforcement (DRL) associe l’apprentissage par renforcement (RL), dans lequel un agent apprend par essais et erreurs à maximiser une récompense, à des réseaux neuronaux profonds qui représentent ce que l’agent apprend. L’apprentissage par renforcement classique stocke une valeur pour chaque état dans une table, ce qui est impossible lorsque l’état correspond à une image de caméra ou aux angles articulaires continus d’un robot. Un réseau neuronal associe plutôt des observations brutes et de grande dimension, comme des pixels, des balayages lidar ou du texte, à des valeurs ou à des probabilités d’action, et généralise à des états jamais observés. DQN, créé par DeepMind, a rendu cette approche célèbre en 2015 en apprenant à jouer à 49 jeux Atari 2600 à partir des seuls pixels de l’écran et du score, avec une seule architecture de réseau et un seul jeu d’hyperparamètres, atteignant un niveau comparable à celui d’un testeur humain professionnel de jeux vidéo.

Fonctionnement de l’apprentissage profond par renforcement#

L’agent suit toujours la boucle de l’apprentissage par renforcement, fondée sur un processus de décision markovien : observer un état, agir, recevoir une récompense et mettre à jour le modèle. La différence est qu’un réseau comptant des millions de paramètres représente désormais un ou plusieurs des éléments suivants :

• Fonction de valeur : Le réseau prédit le rendement attendu de chaque action, et l’agent choisit la plus élevée. Le réseau de DQN prenait en entrée les quatre dernières images du jeu, réduites à 84×84 pixels, afin de percevoir le mouvement.
• Politique : Le réseau produit une probabilité pour chaque action, ou la moyenne et la dispersion d’une action continue, comme un angle de braquage. Les méthodes de gradient de politique l’ajustent directement pour privilégier les actions ayant généré un rendement élevé.
• Acteur et critique : Un réseau acteur choisit les actions tandis qu’un réseau critique estime leurs valeurs afin d’indiquer à l’acteur dans quelle mesure chaque action a été meilleure que prévu, ce qui réduit le bruit de ses mises à jour.
• Modèle du monde : Les agents fondés sur un modèle, comme Dreamer, entraînent un réseau à prédire les observations et les récompenses futures, puis apprennent une politique dans ce simulateur appris.

Entraîner un réseau sur les données que l’agent génère lui-même est instable, car les images consécutives sont fortement corrélées et les cibles évoluent à mesure que le réseau change. DQN a résolu ce problème grâce à deux idées reprises par les algorithmes suivants : un tampon de rejeu d’expérience qui entraîne le modèle sur des mini-lots aléatoires de transitions passées, et un réseau cible distinct mis à jour uniquement à intervalles réguliers :

Les gradients de politique en code#

Les méthodes de gradient de politique se passent entièrement des tables de valeurs : elles échantillonnent des actions à partir du réseau, puis augmentent la probabilité des actions suivies d’un rendement élevé. Cet exemple PyTorch entraîne un petit réseau de politique avec REINFORCE, l’algorithme de gradient de politique d’origine, pour maintenir un bâton en équilibre sur un chariot en mouvement dans l’environnement CartPole de Gymnasium :

import gymnasium as gym
import torch
from torch import nn

torch.manual_seed(0)
env = gym.make("CartPole-v1")
policy = nn.Sequential(nn.Linear(4, 64), nn.ReLU(), nn.Linear(64, 2))  # cart and pole state -> logits for left/right
optimizer = torch.optim.Adam(policy.parameters(), lr=0.02)
lengths = []

for episode in range(500):
    obs, _ = env.reset(seed=episode)
    log_probs, rewards, done = [], [], False
    while not done:  # play one episode with the current policy, earning +1 per step the pole stays up
        dist = torch.distributions.Categorical(logits=policy(torch.as_tensor(obs)))
        action = dist.sample()
        obs, reward, terminated, truncated, _ = env.step(action.item())
        log_probs.append(dist.log_prob(action))
        rewards.append(reward)
        done = terminated or truncated
    # REINFORCE: raise the log-probability of actions followed by above-average discounted return
    returns = torch.tensor([sum(0.99**k * r for k, r in enumerate(rewards[t:])) for t in range(len(rewards))])
    loss = -(torch.stack(log_probs) * (returns - returns.mean()) / (returns.std() + 1e-8)).sum()
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    lengths.append(len(rewards))

print(f"Average episode length: first 20 = {sum(lengths[:20]) / 20:.0f}, last 20 = {sum(lengths[-20:]) / 20:.0f}")

Le code affiche first 20 = 14, last 20 = 500 : le réseau non entraîné fait tomber le bâton en une quinzaine d’étapes, tandis qu’après 500 épisodes, il le maintient en équilibre pendant les 500 étapes autorisées de chaque épisode. Avec d’autres graines aléatoires, le même script peut stagner ou s’effondrer en cours d’entraînement. C’est cette forte variance que les critiques et les mises à jour par écrêtage de l’optimisation proximale de politique (PPO) ont été conçus pour réduire. Des bibliothèques comme Stable-Baselines3 proposent des implémentations testées de PPO, DQN et de l’acteur-critique souple (SAC).

Applications marquantes#

• Jeux : Après Atari, des agents d’apprentissage profond par renforcement ont battu des champions du monde au go avec AlphaGo et atteint le niveau grand maître dans StarCraft II avec AlphaStar, en combinant l’apprentissage à partir de parties humaines et le jeu par auto-apprentissage avec apprentissage par renforcement.
• Courses de drones : Le drone Swift de l’Université de Zurich, entraîné par apprentissage profond par renforcement en simulation puis affiné avec des données de vol réelles, a remporté plusieurs courses en duel contre chacun de trois pilotes champions en 2023 et établi le meilleur temps de course jamais enregistré.
• Énergie de fusion : DeepMind et le Swiss Plasma Center de l’EPFL ont utilisé une politique d’apprentissage profond par renforcement pour contrôler les bobines magnétiques d’un tokamak et façonner le plasma selon plusieurs configurations, dont deux « gouttelettes » de plasma distinctes simultanément.
• Robotique : Des robots marcheurs apprennent à parcourir des terrains accidentés grâce à des politiques entraînées sur des milliers de robots simulés, avec randomisation du frottement et de la masse afin que la politique puisse s’adapter au matériel réel.
• Modèles de langage : L’affinage par apprentissage par renforcement de politiques de Transformer, à l’aide de récompenses fondées sur des préférences ou vérifiées automatiquement, a donné naissance aux assistants conversationnels et aux modèles de raisonnement actuels.

La perception comme observation#

Le réseau neuronal convolutif de DQN devait apprendre à voir uniquement grâce aux récompenses, à partir de 84×84×4 = 28,224 valeurs de pixel par étape. De nombreux systèmes robotiques et de conduite fournissent plutôt à la politique la sortie d'un modèle de vision par ordinateur pré-entraîné, ce qui réduit la taille de l'observation et permet à l'algorithme RL de consacrer ses échantillons à la prise de décision. Ultralytics YOLO26 en mode suivi transforme chaque image de la caméra en une classe, une boîte et un identifiant persistant pour chaque objet. Il produit ainsi un état centré sur les objets, à partir duquel une politique peut aussi lire le mouvement de chaque objet d'une image à l'autre.

Défis#

L'apprentissage par renforcement profond (Deep RL) est gourmand en données : DQN a été entraîné sur 50 millions d'images par jeu, soit environ 38 jours de jeu. C'est pourquoi la plupart des politiques robotiques sont entraînées en simulation, puis transférées sur le matériel. La physique simulée ne correspond jamais exactement à la réalité ; les ingénieurs randomisent donc les frottements, les masses, l'éclairage et les textures grâce à la randomisation de domaine et ajoutent des données synthétiques pour les situations rares. Les résultats varient aussi selon les graines aléatoires, les hyperparamètres et les détails d'implémentation ; ce problème de reproductibilité est décrit dans Deep Reinforcement Learning That Matters. Un optimiseur performant trouve aussi des failles dans toute récompense imparfaite : cet échec est connu sous le nom de piratage de récompense. Par exemple, un agent de course de bateaux a appris à tourner en rond indéfiniment pour accumuler des points plutôt qu'à terminer la course.

Apprentissage par renforcement profond et notions connexes#

• Apprentissage par renforcement : le domaine général. L'apprentissage par renforcement tabulaire convient aux petits problèmes, et l'apprentissage par renforcement profond est un apprentissage par renforcement qui utilise des réseaux neuronaux comme approximateurs de fonction.
• Apprentissage profond : l'apprentissage profond classique s'effectue sur un jeu de données fixe et étiqueté. Dans l'apprentissage par renforcement profond, les actions de l'agent génèrent les données, et le signal d'entraînement est une récompense différée plutôt qu'une étiquette.
• Apprentissage par renforcement à partir de retours humains (RLHF) : méthode d'apprentissage par renforcement profond dans laquelle un modèle de récompense entraîné à partir de comparaisons de préférences humaines remplace une récompense définie manuellement ; elle sert à aligner les modèles de langage.
• Commande prédictive par modèle : le MPC résout une nouvelle optimisation sur un modèle explicite à chaque étape de commande, tandis qu'une politique d'apprentissage par renforcement profond entraînée choisit chaque action en une seule passe avant de son réseau.