Apprentissage par renforcement : des agents qui apprennent en agissant

L'apprentissage par renforcement (RL) entraîne des agents à prendre des décisions séquentielles en maximisant la récompense cumulée par essai-erreur. Contrairement à l'apprentissage supervisé, le RL n'a pas de jeu de données étiqueté — l'agent apprend des conséquences de ses propres actions dans un environnement.

Le cadre RL

Un système RL a quatre composants :

• Agent : l'apprenant et décideur
• Environnement : tout ce avec quoi l'agent interagit
• État ($s$) : la situation actuelle
• Action ($a$) : ce que l'agent peut faire
• Récompense ($r$) : signal de retour scalaire

L'objectif de l'agent est d'apprendre une politique $\pi(a|s)$ qui maximise la récompense cumulée actualisée espérée :

$G_t = \sum_{k=0}^{\infty} \gamma^k r_{t+k+1}$

où $\gamma \in [0, 1)$ est le facteur d'actualisation équilibrant récompenses immédiates et futures.

Taxonomie des algorithmes

Deep Q-Networks (DQN)

DQN (Mnih et al., 2015) a été la percée qui a rendu le deep RL pratique. Deux innovations clés :

Replay d'expérience : stocker les transitions $(s, a, r, s')$ dans un buffer et échantillonner des mini-batchs aléatoires pour l'entraînement. Casse la corrélation temporelle et améliore l'efficacité des données.

Réseau cible : maintenir une copie lentement mise à jour du réseau Q pour calculer les cibles. Empêche le problème de cible mouvante où le réseau poursuit ses propres prédictions.

import torch
import torch.nn as nn
from collections import deque
import random

class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 128),
            nn.ReLU(),
            nn.Linear(128, action_dim)
        )

    def forward(self, x):
        return self.net(x)

# Boucle d'entraînement (simplifiée)
replay_buffer = deque(maxlen=100_000)
q_net = DQN(state_dim=4, action_dim=2)
target_net = DQN(state_dim=4, action_dim=2)
target_net.load_state_dict(q_net.state_dict())
optimizer = torch.optim.Adam(q_net.parameters(), lr=1e-3)

def update(batch_size=64, gamma=0.99):
    batch = random.sample(replay_buffer, batch_size)
    states, actions, rewards, next_states, dones = zip(*batch)

    q_values = q_net(states).gather(1, actions)
    with torch.no_grad():
        next_q = target_net(next_states).max(1)[0]
        targets = rewards + gamma * next_q * (1 - dones)

    loss = nn.functional.mse_loss(q_values.squeeze(), targets)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

PPO : le standard de l'industrie

Proximal Policy Optimization (PPO) est l'algorithme RL le plus utilisé en pratique — propulsant le RLHF pour les LLM, la robotique chez OpenAI et l'IA de jeu. Son succès vient de sa simplicité et stabilité :

• Collecte des trajectoires avec la politique actuelle
• Optimise un objectif surrogate clippé qui empêche les grandes mises à jour de politique
• Pas de replay buffer nécessaire (on-policy), mais moins efficace en échantillons

L'objectif clippé :

$L^{CLIP}(\theta) = \mathbb{E}\left[\min\left(r_t(\theta) \hat{A}_t, \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) \hat{A}_t\right)\right]$

où $r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{old}}(a_t|s_t)}$ est le ratio de probabilité et $\hat{A}_t$ est l'estimation de l'avantage.

Résultats marquants

Défis

Façonnage de récompense : concevoir des fonctions de récompense est difficile. Les récompenses éparses (uniquement au but) rendent l'exploration difficile. Les récompenses denses risquent le reward hacking — l'agent trouve des raccourcis qui maximisent la récompense sans résoudre la tâche visée.

Efficacité d'échantillonnage : le RL sans modèle nécessite souvent des millions d'interactions avec l'environnement. Les méthodes basées modèle et le RL offline (apprentissage à partir de données enregistrées) y remédient mais ajoutent de la complexité.

Transfert simulation-réel : les politiques entraînées en simulation échouent souvent dans le monde réel à cause du fossé de réalité. La randomisation de domaine et l'identification de système aident à le combler.

Multi-agent : quand plusieurs agents apprennent simultanément, l'environnement devient non stationnaire du point de vue de chaque agent. Les garanties de convergence ne tiennent plus.