En apprentissage supervisé, on dispose de la bonne réponse pour chaque exemple. En apprentissage par renforcement, on ne dispose que d'un signal de récompense, souvent rare et différé, et les décisions influencent les situations futures. Ce module présente le cadre, les algorithmes qui comptent, et — point important — les raisons pour lesquelles il faut souvent y renoncer.

1. Le cadre : agent, environnement, récompense

Un agent observe un état, choisit une action, reçoit une récompense et se retrouve dans un nouvel état. La boucle recommence.

            action a_t
        ┌──────────────────►┐
   ┌────┴─────┐       ┌─────▼──────────┐
   │  AGENT   │       │ ENVIRONNEMENT  │
   └────▲─────┘       └─────┬──────────┘
        │                   │
        └───────────────────┘
      état s_{t+1}, récompense r_{t+1}

  Exemple (maintenance) : état = usure mesurée + heures de fonctionnement
                          actions = {ne rien faire, inspecter, remplacer}
                          récompense = -coût de l'action - coût d'une panne subie

Le formalisme est le processus de décision markovien \((\mathcal{S}, \mathcal{A}, P, R, \gamma)\), dont l'hypothèse centrale est la propriété de Markov : l'état contient toute l'information utile pour prédire la suite, le passé n'apporte rien de plus. Quand ce n'est pas le cas — un capteur ne voit qu'une partie du système —, on parle de POMDP, et l'on empile généralement les dernières observations pour reconstituer un état approché.

L'agent maximise le retour, somme actualisée des récompenses futures :

Le facteur \(\gamma\) joue deux rôles : il garantit la convergence de la somme, et il encode l'horizon temporel. Avec \(\gamma = 0{,}99\), l'horizon effectif est d'environ \(1/(1-\gamma) = 100\) pas ; avec \(\gamma = 0{,}9\), il tombe à 10. C'est un paramètre bien plus structurant qu'il n'y paraît : trop bas, l'agent devient myope et sacrifie l'avenir ; trop haut, l'apprentissage devient instable car les valeurs à estimer deviennent énormes.

2. Fonctions de valeur et équations de Bellman

Une politique \(\pi(a\mid s)\) donne la probabilité de choisir l'action \(a\) dans l'état \(s\) — c'est ce qu'on cherche. On lui associe deux fonctions de valeur :

\(V\) évalue un état (« à quel point est-il bon d'être ici ? »), \(Q\) évalue un couple état-action (« à quel point est-il bon de faire ceci, ici ? »). La différence est décisive : \(Q\) permet de choisir directement, en prenant l'action de plus grande valeur, sans avoir besoin de connaître le modèle de transition.

La récursivité du retour donne l'équation de Bellman, et sa version optimale :

Elle se lit simplement : la valeur d'une action, c'est la récompense immédiate plus la valeur actualisée du meilleur coup suivant. C'est un point fixe d'un opérateur contractant de facteur \(\gamma\) : itérer l'opérateur rapproche donc nécessairement de \(Q^\star\), et la politique optimale s'en déduit par \(\pi^\star(s) = \arg\max_a Q^\star(s,a)\). Tout le RL par valeurs consiste à approcher ce point fixe à partir d'échantillons plutôt qu'avec la connaissance du modèle.

3. Exploration et exploitation

Le dilemme apparaît déjà dans le cas le plus simple, le bandit manchot : plusieurs leviers de récompense moyenne inconnue, et un budget de tirages. Exploiter le meilleur levier connu, c'est risquer de passer à côté d'un meilleur jamais essayé ; explorer, c'est payer des tirages sous-optimaux.

ε-greedy          action aléatoire avec probabilité ε, sinon la meilleure connue.
                  Simple ; on fait décroître ε au fil de l'apprentissage (de 1 à 0,05).
Boltzmann         probabilité ∝ exp(Q/τ) : explore proportionnellement à la qualité,
                  au lieu de tirer uniformément parmi les mauvaises actions.
UCB               Q(a) + c·√(ln t / N(a)) : bonus d'optimisme pour les actions peu
                  testées. Même intuition qu'en optimisation bayésienne (module 19).
Thompson          tirage dans le postérieur sur les récompenses (module 10).
                  Très efficace en bandits, et naturellement parallélisable.
Bonus intrinsèque récompense de curiosité (erreur de prédiction, nouveauté de l'état)
                  pour les environnements à récompense extrêmement rare.

4. Q-learning et SARSA

Quand les états et actions sont peu nombreux, \(Q\) tient dans un tableau. Trois familles pour l'estimer : la programmation dynamique (exacte, mais exige de connaître \(P\) et \(R\) — rarement le cas) ; Monte-Carlo (attendre la fin de l'épisode et moyenner les retours observés — sans biais, mais de forte variance et inapplicable aux tâches continues) ; et les différences temporelles (TD), qui sont la grande idée du domaine.

TD met à jour immédiatement, à partir de l'estimation courante de l'état suivant, sans attendre la fin de l'épisode. C'est du bootstrapping : on apprend une estimation à partir d'une autre estimation — ce qui semble circulaire, mais converge bel et bien, puisque la récompense observée injecte à chaque pas une information réelle.

import numpy as np

Q = np.zeros((n_etats, n_actions))
alpha, gamma, eps = 0.1, 0.99, 1.0

for episode in range(5_000):
    s, _ = env.reset()
    termine = False
    while not termine:
        # ε-greedy : explorer ou exploiter
        a = env.action_space.sample() if np.random.rand() < eps else int(Q[s].argmax())

        s2, r, termine, tronque, _ = env.step(a)

        cible = r + gamma * Q[s2].max() * (not termine)   # 0 si l'épisode est fini
        Q[s, a] += alpha * (cible - Q[s, a])              # l'erreur TD
        s = s2
        termine = termine or tronque

    eps = max(0.05, eps * 0.999)     # on explore de moins en moins

politique = Q.argmax(axis=1)         # la politique gloutonne finale

Sa particularité : le \(\max\) fait apprendre la valeur de la politique optimale, alors même que l'agent se comporte selon une politique exploratrice. C'est un algorithme off-policy, ce qui permet de réutiliser des données anciennes ou produites par un autre agent. SARSA remplace \(\max_{a'}Q(s',a')\) par \(Q(s',a')\) où \(a'\) est l'action réellement choisie : il apprend la valeur de la politique suivie, exploration comprise (on-policy), ce qui le rend plus prudent près des états dangereux.

L'exemple canonique est celui de la falaise : un chemin court longe un précipice, un chemin long en reste éloigné. Q-learning apprend le chemin optimal — le bord — et tombe régulièrement pendant l'apprentissage à cause de l'exploration ; SARSA, qui intègre le risque de l'exploration dans ses valeurs, préfère le chemin sûr. Aucun des deux n'a tort : ils répondent à des questions différentes.

5. Deep RL : DQN

Dès que l'espace d'états devient grand ou continu (des pixels), le tableau est remplacé par un réseau \(Q_\theta(s,a)\). Cette substitution casse les garanties de convergence — on combine approximation de fonction, bootstrapping et apprentissage off-policy, ce que la littérature appelle la « triade mortelle » — et trois mécanismes ont été nécessaires pour stabiliser l'entraînement :

• Replay buffer — stocker les transitions et en tirer des mini-lots au hasard. Cela casse la corrélation temporelle des échantillons successifs (qui violerait l'hypothèse i.i.d. du gradient stochastique) et réutilise chaque expérience plusieurs fois, ce qui améliore l'efficacité en données.
• Réseau cible — la cible \(r + \gamma\max_{a'}Q_{\theta^-}(s',a')\) est calculée avec une copie figée \(\theta^-\), mise à jour périodiquement. Sans cela, on poursuit une cible qui bouge à chaque pas — comme viser une cible fixée à son propre fusil — et l'entraînement diverge.
• Double DQN — l'opérateur \(\max\) surestime systématiquement les valeurs, parce que le maximum d'estimateurs bruités est biaisé vers le haut. On dissocie donc le choix de l'action (réseau courant) et son évaluation (réseau cible).

Autres raffinements utiles : dueling (séparer valeur d'état et avantage de l'action), prioritized replay (rejouer davantage les transitions à forte erreur TD) et n-step returns. DQN et ses variantes ne traitent que les actions discrètes — pour un contrôle continu, il faut passer aux méthodes de politique.

6. Gradient de politique : REINFORCE, PPO

Plutôt que d'estimer des valeurs pour en déduire une politique, on paramètre directement \(\pi_\theta(a\mid s)\) et on monte le gradient de la performance. Le théorème du gradient de politique donne une forme remarquablement simple :

La lecture est intuitive : on augmente la probabilité des actions dont l'avantage \(A = Q - V\) est positif — celles qui font mieux que la moyenne de l'état — et on diminue celle des autres. Le terme \(\nabla \log \pi\) indique dans quelle direction modifier les paramètres pour rendre l'action plus probable ; l'avantage donne le signe et l'ampleur.

La fonction \(V\) joue ici le rôle de baseline : la soustraire ne change pas l'espérance du gradient mais réduit fortement sa variance. Sans elle, toutes les actions d'un épisode réussi seraient renforcées, y compris les mauvaises ; avec elle, seules celles qui ont fait mieux que prévu le sont. C'est ce qui rend la méthode utilisable en pratique.

REINFORCE est la version brute (avantage estimé par le retour Monte-Carlo) : correcte mais très bruitée. Les méthodes acteur-critique ajoutent un second réseau, le critique, qui estime \(V\) et fournit un avantage à faible variance (A2C, A3C, puis GAE pour un compromis biais-variance réglable).

PPO est devenu le défaut pratique. Son idée : réutiliser plusieurs fois un même lot de trajectoires pour faire plusieurs pas de gradient — ce qui améliore beaucoup l'efficacité en données — tout en empêchant la politique de trop s'éloigner de celle qui a produit ces données, sans quoi les gradients calculés ne veulent plus rien dire. En notant \(\rho = \pi_\theta(a|s)/\pi_{\text{old}}(a|s)\) :

L'écrêtage annule le gain marginal dès que le rapport sort de la bande \([1-\epsilon, 1+\epsilon]\) (typiquement \(\epsilon = 0{,}2\)) : au-delà, pousser davantage n'apporte plus rien à l'objectif, donc le gradient s'annule et le pas reste borné. C'est simple, robuste, et c'est l'algorithme utilisé pour l'alignement des LLM par retour humain (module 22).

Algorithme   Actions      On/Off-policy   Points forts
────────────────────────────────────────────────────────────────────────────────
Q-learning   discrètes    off             tabulaire, fondation théorique
DQN          discrètes    off             pixels, jeux Atari, efficace en données
REINFORCE    les deux     on              simple, mais forte variance
A2C / A3C    les deux     on              acteur-critique, bon compromis
PPO          les deux     on              LE défaut : robuste, peu de réglage
SAC          continues    off             entropie maximale, très efficace en données :
                                          le choix pour la robotique et le contrôle
TD3          continues    off             DDPG corrigé de la surestimation

import gymnasium as gym
from stable_baselines3 import PPO
from stable_baselines3.common.env_util import make_vec_env
from stable_baselines3.common.evaluation import evaluate_policy

# 8 environnements en parallèle : le goulot est la SIMULATION, pas le réseau
env = make_vec_env("LunarLander-v3", n_envs=8)

modele = PPO("MlpPolicy", env, learning_rate=3e-4, n_steps=1024,
             batch_size=256, gamma=0.999, verbose=0, seed=0)
modele.learn(total_timesteps=1_000_000)

# évaluer sur PLUSIEURS graines : la variance en RL est notoirement élevée
for graine in range(5):
    moy, ecart = evaluate_policy(modele, gym.make("LunarLander-v3"),
                                 n_eval_episodes=30)
    print(f"graine {graine}: {moy:.1f} ± {ecart:.1f}")

7. Model-based, offline RL, RLHF

• Model-based — apprendre un modèle de la dynamique \(P(s'\mid s,a)\) et planifier dedans (Dyna, MuZero, MPC). Gain considérable en nombre d'interactions réelles, au prix des erreurs du modèle, que la planification a tendance à exploiter : l'agent trouve les failles du simulateur appris plutôt que la bonne stratégie.
• Offline RL — apprendre uniquement à partir d'un jeu de données fixe, sans interagir. C'est le seul cadre réaliste en santé, en finance ou en industrie, où l'exploration est interdite. La difficulté est le décalage de distribution : l'agent surestime des actions jamais observées, puisque rien ne le contredit. Les algorithmes dédiés (CQL, IQL) contraignent la politique à rester près des données.
• RLHF — l'alignement des LLM : on entraîne un modèle de récompense sur des préférences humaines (« cette réponse est meilleure que celle-là »), puis on optimise le modèle de langage par PPO contre cette récompense, avec une pénalité KL pour ne pas trop s'éloigner du modèle initial. Les variantes récentes (DPO, GRPO) court-circuitent en partie cette boucle (module 22).
• Sim2real — entraîner en simulation puis transférer au réel. La randomisation de domaine (module 13) force une politique robuste au décalage entre simulateur et monde réel.

8. En pratique, et pourquoi c'est difficile

Jeux et simulation       Atari, Go, StarCraft — l'environnement est gratuit et parfait
Robotique / contrôle     locomotion, manipulation, drones (avec sim2real)
Systèmes opérés          refroidissement de datacenter, gestion d'énergie, trafic réseau
Recommandation           optimisation d'engagement à long terme (via bandits, module 24)
Alignement de LLM        RLHF, raisonnement par récompense vérifiable
Gestion de portefeuille  allocation séquentielle sous contrainte de risque

What this module covers

• The MDP framework, discounted returns, and the four things that genuinely separate RL from supervised learning.
• Value functions and Bellman equations as a contraction fixed point.
• Exploration strategies: ε-greedy, Boltzmann, UCB, Thompson sampling, intrinsic curiosity.
• Temporal-difference learning, Q-learning vs SARSA, and what off-policy vs on-policy changes in behaviour.
• Deep Q-Networks: why function approximation breaks convergence, and the three fixes (replay buffer, target network, double estimation).
• Policy gradients: the policy gradient theorem, advantage baselines, actor-critic methods, and PPO's clipped objective.
• Model-based RL, offline RL and distribution shift, RLHF for language models, and sim2real transfer.
• Where RL is actually used, an unvarnished list of its difficulties (sample efficiency, reward hacking, variance, safety), and the question to ask before starting: would a contextual bandit, imitation learning or classical optimal control do the job?

Course outline

1. Modern Python: typing, decorators, iterators and tooling
2. Concurrency in Python: the GIL, threads, processes, asyncio
3. Numerical toolbox: NumPy, pandas, polars, Dask
4. SQL and databases
5. Docker, Compose and Kubernetes
6. Serving a model: FastAPI, Pydantic, Jinja
7. Data engineering: formats, pipelines and streams
8. Math for ML: optimisation, linear algebra, SVD and PCA
9. Inferential statistics: estimate, test, decide
10. Probability, Bayesian inference and uncertainty quantification
11. Causal inference: measuring the effect of an action
12. Data science in practice: from problem to dataset
13. Learning with few labels
14. Classical machine learning
15. Learning theory: why generalisation happens
16. Deep learning
17. Time series, signals and time-to-event data
18. Non-tabular data: text, images, audio, graphs
19. Gaussian processes and Bayesian optimisation
20. Reinforcement learning
21. Machine learning for simulation and engineering
22. LLMs, embeddings, RAG and adaptation
23. Search, ranking and recommendation
24. From scores to decisions
25. Scaling up: GPUs, distributed training, performance
26. MLOps: taking a model to production
27. Fairness, robustness, privacy and security
28. End-to-end project: property listings, from scraping to price prediction