Apprentissage par renforcement

L'apprentissage par renforcement (Reinforcement Learning, RL) est un paradigme où un agent apprend à prendre des décisions en interagissant avec un environnement et en recevant des récompenses.

Principe

┌─────────────────────────────────────────────────────────┐
│            APPRENTISSAGE PAR RENFORCEMENT                │
├─────────────────────────────────────────────────────────┤
│                                                          │
│                      ┌───────────┐                      │
│           Action     │           │    Récompense        │
│      ┌──────────────→│ENVIRONNEMENT├──────────────┐     │
│      │               │           │                │     │
│      │               └─────┬─────┘                │     │
│      │                     │                      │     │
│      │              Nouvel état                   │     │
│      │                     ↓                      ↓     │
│   ┌──┴─────────────────────────────────────────────┐    │
│   │                    AGENT                        │    │
│   │  Objectif : maximiser les récompenses futures  │    │
│   └─────────────────────────────────────────────────┘    │
│                                                          │
└─────────────────────────────────────────────────────────┘

Contrairement au supervisé, il n'y a pas de "bonne réponse". L'agent découvre par essai-erreur les actions qui maximisent les récompenses.

Concepts fondamentaux

Vocabulaire essentiel

Terme	Description	Exemple (jeu vidéo)
Agent	L'entité qui apprend	Le joueur
Environnement	Le monde avec lequel l'agent interagit	Le jeu
État (s)	Situation actuelle	Position, score, vies
Action (a)	Choix possible de l'agent	Gauche, droite, sauter
Récompense (r)	Feedback immédiat	+10 points, -1 vie
Politique (π)	Stratégie de l'agent	"Si ennemi proche → tirer"

Le cycle RL

t=0: État s₀ → Agent choisit action a₀ → Récompense r₀, nouvel état s₁
t=1: État s₁ → Agent choisit action a₁ → Récompense r₁, nouvel état s₂
...

Récompense cumulée

L'objectif est de maximiser la récompense totale future :

G = r₀ + γr₁ + γ²r₂ + γ³r₃ + ...

Où γ (gamma) est le facteur d'actualisation (0 < γ < 1) :

γ proche de 0 : priorité aux récompenses immédiates
γ proche de 1 : vision long terme

Le dilemme exploration/exploitation

L'agent doit équilibrer :

Exploitation : utiliser ce qu'il sait pour maximiser les récompenses
Exploration : essayer de nouvelles actions pour découvrir de meilleures stratégies

Restaurant préféré (exploitation) vs nouveau restaurant (exploration) ?

Toujours exploiter = rater de meilleures options
Toujours explorer = ne jamais profiter de ce qu'on sait

Stratégie ε-greedy

if random.random() < epsilon:
    action = random_action()  # Explorer
else:
    action = best_known_action()  # Exploiter

ε diminue généralement au cours de l'apprentissage.

Algorithmes fondamentaux

Q-Learning

Apprend une table Q(s, a) qui estime la valeur de chaque action dans chaque état.

            Actions
              a₁    a₂    a₃
États   s₁  [ 0.5   0.8   0.2 ]
        s₂  [ 0.3   0.1   0.9 ]  ← Q-Table
        s₃  [ 0.7   0.6   0.4 ]

Règle de mise à jour :

Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]

import numpy as np

# Initialisation
Q = np.zeros((n_states, n_actions))
alpha = 0.1  # Taux d'apprentissage
gamma = 0.99  # Facteur d'actualisation
epsilon = 0.1  # Exploration

for episode in range(n_episodes):
    state = env.reset()
    done = False

    while not done:
        # ε-greedy
        if np.random.random() < epsilon:
            action = np.random.randint(n_actions)
        else:
            action = np.argmax(Q[state])

        # Exécuter l'action
        next_state, reward, done, _ = env.step(action)

        # Mise à jour Q
        Q[state, action] += alpha * (
            reward + gamma * np.max(Q[next_state]) - Q[state, action]
        )

        state = next_state

SARSA

Similaire à Q-Learning mais utilise l'action réellement choisie (on-policy).

Q(s,a) ← Q(s,a) + α[r + γ Q(s',a') - Q(s,a)]
                         ↑
                   Action choisie, pas max

Deep Q-Network (DQN)

Remplace la Q-Table par un réseau de neurones pour gérer des espaces d'états continus/grands.

État (pixels) → CNN → Q-values pour chaque action
    [Image]    →      [Q(gauche), Q(droite), Q(sauter)]

Innovations clés :

Experience Replay : stocker et rejouer des expériences passées
Target Network : réseau cible séparé pour stabiliser l'apprentissage

import torch
import torch.nn as nn

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)

Méthodes Policy Gradient

Au lieu d'estimer les valeurs, on optimise directement la politique.

REINFORCE

# Politique = réseau de neurones qui sort des probabilités d'actions
# On maximise : E[∑ log π(a|s) × R]

def train_episode(policy, optimizer):
    states, actions, rewards = run_episode(policy)

    # Calculer les returns
    returns = compute_returns(rewards, gamma)

    # Mise à jour
    loss = 0
    for s, a, G in zip(states, actions, returns):
        log_prob = torch.log(policy(s)[a])
        loss -= log_prob * G

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

Actor-Critic

Combine policy gradient (Actor) et estimation de valeur (Critic).

       ┌─────────────────────────────────┐
       │           ACTOR-CRITIC           │
       ├─────────────────────────────────┤
       │                                  │
       │   État → Actor → Action          │
       │     ↓                            │
       │   État → Critic → Valeur V(s)    │
       │                                  │
       │   Actor apprend la politique     │
       │   Critic estime la valeur        │
       │                                  │
       └─────────────────────────────────┘

PPO (Proximal Policy Optimization)

Algorithme moderne très utilisé. Limite les mises à jour pour stabiliser l'apprentissage.

# Utilisé par OpenAI, très stable
from stable_baselines3 import PPO

model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=100000)

Applications emblématiques

Jeux

Système	Jeu	Année	Exploit
Deep Blue	Échecs	1997	Bat Kasparov
AlphaGo	Go	2016	Bat Lee Sedol
AlphaStar	StarCraft II	2019	Niveau Grand Master
OpenAI Five	Dota 2	2019	Bat champions du monde

Robotique

Robot → Apprend à marcher par essai-erreur
      → Récompense positive si avance
      → Récompense négative si tombe

Autres applications

Trading algorithmique : maximiser les profits
Conduite autonome : navigation sécurisée
Gestion de ressources : datacenters, réseaux électriques
Jeux vidéo : NPCs adaptatifs
RLHF : entraînement des LLM (ChatGPT)

RLHF : RL pour les LLM

Le Reinforcement Learning from Human Feedback utilise le RL pour aligner les LLM avec les préférences humaines.

1. Pré-entraînement du LLM (supervisé)
2. Collecte de préférences humaines
3. Entraînement d'un modèle de récompense
4. Fine-tuning avec PPO

Prompt → LLM → Réponse → Humain note → Récompense
                              ↓
                    Modèle de récompense

C'est grâce au RLHF que ChatGPT et Claude sont "alignés" : utiles, honnêtes et inoffensifs.

Environnements d'apprentissage

OpenAI Gym / Gymnasium

import gymnasium as gym

env = gym.make("CartPole-v1")
state, info = env.reset()

for _ in range(1000):
    action = env.action_space.sample()  # Action aléatoire
    state, reward, terminated, truncated, info = env.step(action)

    if terminated or truncated:
        state, info = env.reset()

env.close()

Environnements populaires

Environnement	Type	Difficulté
CartPole	Équilibre	Débutant
MountainCar	Contrôle	Intermédiaire
LunarLander	Navigation	Intermédiaire
Atari Games	Vision	Avancé
MuJoCo	Robotique	Avancé

Défis du RL

Récompenses éparses

Si la récompense n'arrive qu'à la fin (ex: victoire/défaite), l'apprentissage est difficile.

Solutions :

Reward shaping : récompenses intermédiaires
Curiosity-driven : récompenser l'exploration
Hierarchical RL : décomposer en sous-objectifs

Instabilité

L'apprentissage RL peut être instable et difficile à reproduire.

Solutions :

Moyenner sur plusieurs seeds
Utiliser des algorithmes stables (PPO)
Normaliser les observations et récompenses

Sim-to-Real

Les politiques apprises en simulation ne fonctionnent pas toujours dans le monde réel.

Solutions :

Domain randomization : varier les paramètres de simulation
Sim-to-real transfer : fine-tuning sur données réelles

Résumé

RL = Agent apprend par essai-erreur à maximiser les récompenses

Algorithmes :
├── Value-based (Q-Learning, DQN)
│   └── Apprendre Q(s,a) puis agir selon argmax
├── Policy-based (REINFORCE, PPO)
│   └── Optimiser directement la politique π(a|s)
└── Actor-Critic (A2C, A3C, SAC)
    └── Combiner les deux approches

Applications : jeux, robotique, trading, RLHF pour LLM

Apprentissage par renforcement

On this page