Introduction Au Reinforcement Learning - Partie 2

Dans mon précédent article, j'ai posé les fondations de l'apprentissage par renforcement. Nous y avons vu comment un agent, tel un écureuil malin, pouvait apprendre à naviguer dans un monde simple en utilisant des tables de valeurs (Q-tables). Cependant, nous avons également mis en lumière leur talon d'Achille : la "malédiction de la dimensionnalité". Face à un monde complexe comme un jeu vidéo ou la conduite d'une voiture, une table devient inutilisable.

Vous voilà au bord d'une révolution. Celle qui a propulsé le reinforcement learning sur le devant de la scène de l'intelligence artificielle. L'idée est géniale dans sa simplicité : remplacer la table rigide et limitée par un cerveau souple et puissant, un réseau de neurones profond. C'est la naissance du Deep Reinforcement Learning (DRL).

Cet article est votre guide pour comprendre cette transition. Nous partirons de l'algorithme qui a tout changé, le Deep Q-Network (DQN), pour ensuite explorer comment le domaine a su s'adapter pour maîtriser des actions continues et devenir plus stable et efficace que jamais.

Le Deep Q-Network (DQN)

Imaginez que vous ne vouliez plus seulement apprendre une grille de \(10\times10\), mais maîtriser un jeu comme Breakout ou Space Invaders, où l'état n'est plus une simple coordonnée, mais une image entière de \(84\times84\) pixels en couleurs. Le nombre d'états possibles est \(256^{(84\times84\times3)}\), un nombre si grand qu'il dépasse l'entendement. Une Q-table est non seulement inutilisable, elle est une absurdité conceptuelle.

Le Deep Q-Network (DQN), introduit en 2013 par DeepMind dans leur article fondateur "Playing Atari with Deep Reinforcement Learning", a résolu ce problème en mariant deux mondes : l'apprentissage par renforcement et l'apprentissage profond. La solution repose sur deux innovations majeures.

1. La Fonction d'Approximation : Un Réseau de Neurones à la place de la Table

Au lieu d'une table, DQN utilise un réseau de neurones convolutif (CNN), un type de réseau particulièrement doué pour comprendre les images. Ce réseau prend en entrée l'état (l'image du jeu) et sort en direct les valeurs Q pour chaque action possible (gauche, droite, tirer...).

2. L'Experience Replay : Apprendre du Passé pour Mieux Agir dans le Futur

Un agent qui apprend en ligne, pas à pas, est confronté à un problème insidieux : les expériences successives sont fortement corrélées. Si l'agent vient de se déplacer à droite, son prochain état sera probablement aussi un état où il est un peu plus à droite. Apprendre à partir de cette séquence continue, c'est comme essayer d'apprendre une nouvelle matière en ne lisant que la même page d'un livre encore et encore. On risque de sur-spécialiser notre apprentissage à une situation très récente et passagère.

DQN introduit une mémoire tampon, l'Experience Replay Buffer.

• À chaque étape, l'agent stocke sa transition \( (\text{état},\, \text{action},\, \text{récompense},\, \text{nouvel état},\, \text{terminé}) \) dans ce buffer. Le buffer a une taille finie (par exemple, 1 million d'expériences) et, lorsqu'il est plein, il commence à écraser les plus anciennes expériences.
• Pour s'entraîner, l'agent ne prend pas la dernière expérience. Au lieu de cela, il échantillonne au hasard un mini-lot (par exemple, 32 expériences) de son passé dans ce buffer.

C'est une révolution ! Cela brise la corrélation des données, un principe fondamental de l'apprentissage automatique. L'agent peut réapprendre de ses anciennes erreurs et succès, encore et encore. Une expérience rare mais cruciale (par exemple, perdre une vie) peut être ré-échantillonnée de nombreuses fois, s'assurant que l'agent en tire bien la leçon.

L'Algorithme DQN en Bref :

1. Initialiser le réseau de neurones \(Q\) (appelé "Online Network" et un réseau cible gelé \( \hat{Q} \) ("Target Network", avec les poids qui sont une copie de \(Q\)).
2. Initialiser un buffer de mémoire \(D\).
3. Pour chaque étape :
   1. Choisir une action avec une politique ε-greedy (exploration vs exploitation).
   2. Exécuter l'action et observer la récompense \(r\) et le nouvel état \(s'\).
   3. Stocker la transition \((s, a, r, s', done)\) dans le buffer \(D\).
   4. Échantillonner un mini-lot aléatoire de transitions depuis D.
   5. Calculer la "cible" \(y\) pour l'apprentissage en utilisant le Target Network pour stabiliser l'apprentissage : $$ y = \begin{cases} r & \text{si l'épisode est terminé} \\ r + \gamma \max_{a'} Q(s', a') & \text{sinon} \end{cases} $$
   6. Entraîner le Online Network sur ce mini-lot pour minimiser l'erreur quadratique moyenne (la loss) entre sa prédiction \(Q(s, a)\) et la cible \(y\) : $$ \text{Loss} = \mathbb{E} \left[ (y - Q(s, a))^2 \right] $$
   7. Tous les \(C\) pas (par exemple, 1000), copier les poids de \(Q\) vers \( \hat{Q} \) pour mettre à jour le réseau cible.

Le DQN : Une Révolution avec ses Limites

Le Deep Q-Network a été une véritable bombe. Pour la première fois, un agent pouvait apprendre directement à partir de pixels bruts, atteignant des performances surhumaines sur une multitude de jeux classiques d'Atari. Le grand mérite du DQN est d'avoir résolu le problème de la "malédiction de la dimensionnalité" en utilisant un réseau de neurones comme fonction d'approximation, et d'avoir introduit l'Experience Replay pour un apprentissage stable et efficace.

Cependant, le DQN n'était pas parfait. Loin de là. Les chercheurs ont rapidement identifié plusieurs faiblesses fondamentales :

• La limite des actions discrètes : C'est la plus grande limitation. Le DQN ne peut que choisir parmi un nombre fini d'actions (gauche, droite, tirer...). Il est totalement incapable de gérer des actions continues, comme "tourner le volant de 15.7 degrés" ou "accélérer avec une force de 0.8". Cette restriction le rend inutile pour de nombreux problèmes du monde réel comme la robotique ou le contrôle de véhicules.
• L'instabilité de l'apprentissage : Même avec ses innovations, l'entraînement du DQN pouvait être délicat. La "cible" qu'il cherchait à atteindre bougeait à chaque mise à jour, un peu comme un chien qui court après sa propre queue, ce qui pouvait rendre l'apprentissage chaotique.
• Le biais de surestimation : Le DQN avait tendance à être trop optimiste, à croire que la valeur des actions était meilleure qu'elle ne l'est en réalité.

La Famille DQN : Des Améliorations Successives

Face à ces défauts, la communauté de la recherche n'a pas abandonné le DQN. Elle l'a amélioré, créant toute une famille d'algorithmes de plus en plus performants, tous basés sur l'idée originale du DQN. Voici les plus célèbres, présentées sans jargon technique :

• Double DQN (DDQN) : Pour corriger le biais de l'ami trop optimiste, DDQN a introduit une astuce simple : dissocier le choix de l'action de son évaluation. Cela a permis de réduire drastiquement la surestimation et de rendre l'apprentissage plus fiable.
• Dueling DQN : Pour mieux comprendre une situation, cet algorithme a appris à répondre à deux questions : "Est-ce que cet état est globalement bon ?" (valeur de l'état) et "Quelle action est la meilleure *dans* cet état ?" (valeur d'avantage). Cela a permis à l'agent d'apprendre beaucoup plus efficacement.
• Prioritized Experience Replay (PER) : Au lieu de réviser ses expériences au hasard, l'agent avec PER devient un étudiant plus intelligent : il passe plus de temps à étudier les cas où il s'est le plus trompé (les expériences "surprenantes"), ce qui accélère son apprentissage.
• Rainbow DQN : Le summum. Imaginez que vous prenez toutes les meilleures améliorations ci-dessus et que vous les combinez en un seul algorithme surpuissant. C'est exactement ce qu'est Rainbow DQN, qui a dominé tous les précédents sur les jeux Atari.

Malgré toute cette ingéniosité, toute la famille DQN se heurte à un mur infranchissable : elle ne peut pas gérer les actions continues. Pour relever ce défi, il fallait une philosophie complètement différente. C'est là que commence l'histoire des méthodes de Policy Gradient.

Les Méthodes de Policy Gradient

Pour piloter un robot, contrôler un bras robotique ou conduire une voiture, il faut une approche capable de gérer des actions continues (par exemple, un angle de volant ou une force d'accélération). C'est précisément là qu'interviennent les méthodes de Policy Gradient.

Ces méthodes adoptent une philosophie radicalement différente de celle du value-based learning (comme DQN). Au lieu d'apprendre une fonction de valeur (Q) pour ensuite en déduire la meilleure action, elles apprennent directement à optimiser la politique (le réseau de neurones qui prend les décisions).

Apprentissage "On-Policy" : Apprendre sur le Tas

Une caractéristique essentielle des méthodes de Policy Gradient est leur nature "on-policy". Cela signifie qu'elles apprennent directement à partir des expériences générées par la politique actuelle. Contrairement à DQN, il n'y a pas de Experience Replay Buffer. L'agent collecte des trajectoires, les utilise pour mettre à jour sa politique, puis les jette. C'est un apprentissage plus direct, mais qui peut sembler moins efficient en termes de données.

La Fondation : L'Algorithme REINFORCE

L'algorithme le plus simple et le plus fondamental de cette famille est REINFORCE. Son principe est intuitif : il ajuste les poids \(θ\) du réseau de neurones de la politique \(π\) pour augmenter la probabilité des actions qui ont mené à de bonnes récompenses.

La mise à jour s'effectue via une montée de gradient (Gradient Ascent) sur un objectif de performance. La formule de mise à jour est :

Décortiquons cette formule :

• \(\nabla_\theta \log \pi_\theta(a_t|s_t)\) : C'est le "score" de la politique. Il indique la direction dans laquelle changer les poids \(θ\) pour rendre l'action \(a\) plus probable dans l'état \(s\).
• \(G_t\) : C'est le retour cumulé (la somme des récompenses futures escomptées) à partir de l'étape `t`.

En multipliant le score par le retour \(G_t\), on applique le principe du "carotte et du bâton" :

• Si \(G_t\) est élevé (une bonne séquence d'actions), on augmente la probabilité des actions qui y ont mené.
• Si \(G_t\) est faible (une mauvaise séquence), on diminue la probabilité des actions correspondantes.

Le Problème Majeur de REINFORCE : La Variance
Le problème de REINFORCE est sa variance énorme. Le signal \(G_t\) n'est connu qu'à la fin de l'épisode. Une seule récompense aléatoire à la fin d'une longue trajectoire peut fausser complètement le jugement sur toutes les actions qui l'ont précédée, rendant l'apprentissage très bruité et inefficace.

La Solution : L'Architecture Actor-Critic

Pour réduire cette variance, la solution a été d'introduire un Critic. L'architecture Actor-Critic combine le meilleur des deux mondes :

• L'Actor : C'est le réseau de neurones de la politique (comme dans REINFORCE) qui choisit les actions. Il est entraîné par montée de gradient.
• Le Critic : C'est un second réseau de neurones qui apprend une fonction de valeur, typiquement \(V(s)\) (la valeur d'un état). Il est entraîné par descente de gradient (comme un réseau de régression) pour minimiser l'erreur entre ses prédictions et les retours réels.

Le Critic fournit à l'Actor un signal beaucoup plus précis et moins bruité que le retour final \(G_t\). Il ne dit pas juste "c'était bien" ou "c'était mal", mais "c'était mieux/moins bien que prévu pour cette situation". Ce signal est appelé "Advantage" (avantage) :

L'avantage mesure à quel point une action est meilleure (ou pire) que la moyenne des actions possibles depuis cet état. La mise à jour de l'Actor devient alors beaucoup plus stable, en remplaçant \(G_t\) par l'avantage \(A(s,a)\) :

On ne récompense plus une action pour son résultat final, mais parce qu'elle a été meilleure que ce à quoi on s'attendait à cet instant.

Le Grand Avantage des Policy Gradients : Ils peuvent gérer nativement les espaces d'actions continues. Le réseau de neurones peut directement sortir une valeur (par exemple, entre -1 et 1 pour un volant) en utilisant des fonctions d'activation comme \(tanh\), ou une distribution de probabilités sur un intervalle continu.

Les Champions Modernes : A2C et PPO

Les méthodes Actor-Critic représentaient une avancée significative, mais des défis subsistaient. L'apprentissage "on-policy" est souvent inefficace en termes d'échantillonnage (chaque donnée n'est utilisée qu'une seule fois) et peut souffrir d'une variance élevée. De plus, la mise à jour de la politique elle-même restait un processus délicat, où une seule mauvaise étape pouvait déstabiliser tout l'entraînement. C'est pour répondre à ces problèmes que des algorithmes plus sophistiqués comme A2C et PPO ont été développés.

A2C : La Stabilité par la Parallélisation

Pour améliorer l'efficacité et la stabilité de l'apprentissage on-policy, la solution a été de paralléliser la collecte de données. L'algorithme A2C (Advantage Actor-Critic) est une version synchrone et stable de cette approche.

Le Principe des Multi-Workers :
Au lieu d'un seul agent interagissant avec un seul environnement, A2C déploie plusieurs agents, appelés "workers", qui fonctionnent en parallèle. Chaque worker possède une copie de la politique actuelle et interagit avec sa propre instance de l'environnement.

Le Processus d'Entraînement :

1. Collecte Parallèle : Tous les workers exécutent la politique simultanément pendant un nombre défini de pas (\(n\)-steps). Chaque worker collecte ainsi une petite trajectoire d'expériences \( (\text{état},\, \text{action},\, \text{récompense},\, \text{nouvel état}) \).
2. Agrégation des Données : À la fin de cette phase de collecte, toutes les trajectoires de tous les workers sont regroupées et envoyées à un agent central.
3. Calcul de l'Avantage : L'agent central utilise cet ensemble de données pour calculer les estimations d'avantage. Souvent, un mécanisme appelé GAE (Generalized Advantage Estimation) est utilisé. Le GAE est une technique sophistiquée qui calcule une estimation de l'avantage en faisant un compromis entre le biais (comme dans le TD(1)) et la variance (comme dans Monte Carlo), en pondérant les avantages à plusieurs pas dans le futur.
4. Mise à Jour Unique : Une seule mise à jour agrégée est effectuée sur les réseaux centraux (Actor et Critic) en utilisant toutes les données collectées.
5. Synchronisation : Les poids des réseaux mis à jour sont ensuite redistribués à tous les workers pour la prochaine phase de collecte.

Cette approche brise la corrélation des données, car les workers explorent des états différents de manière non séquentielle. Elle accélère considérablement la collecte d'expériences et réduit la variance de l'estimation du gradient, rendant l'entraînement global plus stable et rapide qu'un agent on-policy mono-thread.

PPO : La Robustesse par la Contrainte

Même avec une collecte de données améliorée grâce à A2C, le risque des "destructively large policy updates" (mises à jour destructrices de la politique) demeurait. L'objectif de la politique pouvait changer si radicalement d'une mise à jour à l'autre que les performances s'effondraient.

Proximal Policy Optimization (PPO) a été conçu pour résoudre ce problème fondamental en introduisant une contrainte directe sur la magnitude des mises à jour de la politique.

L'innovation centrale de PPO est sa fonction objectif "clippée". Au lieu de maximiser directement la performance attendue, PPO maximise un objectif substitut (surrogate objective) qui approxime la performance réelle tout en pénalisant les grands changements de politique.

Cette fonction objectif repose sur plusieurs éléments clés :

1. Le Ratio de Probabilité : $$ r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{old}}(a_t|s_t)} $$ Ce ratio mesure à quel point la nouvelle politique \(π_θ\) a changé par rapport à l'ancienne politique \( \pi_{\theta_{\mathrm{old}}} \) pour une action spécifique \(a_t\) qui a été prise. Un ratio de 1 signifie aucun changement, un ratio supérieur à 1 signifie que l'action est devenue plus probable, et inversement.
2. La Fonction "Clip" : $$ \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) $$ Cette fonction contraint le ratio \(r_t(θ)\) à rester dans un petit intervalle \([1-ε, 1+ε]\). Si le ratio dépasse cette borne, il est "coupé" (clipped) à la valeur la plus proche de la borne.
3. L'Objectif Final : $$ L^{CLIP}(\theta) = \mathbb{E}_t \left[ \min\left( r_t(\theta) \hat{A}_t, \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) \hat{A}_t \right) \right] $$ L'opérateur \(min()\) est crucial. Il crée une borne pour l'objectif.

Cette astuce mathématique force l'algorithme à faire des mises à jour de politique petites et prudentes. Il ignore les changements qui seraient trop importants, même s'ils semblent prometteurs sur le lot de données actuel. Cette robustesse intrinsèque est ce qui a fait de PPO l'algorithme de choix par défaut pour une vaste gamme de problèmes, y compris des applications complexes comme l'alignement des LLM, où la stabilité est primordiale.

Aligner les LLMs avec le RLHF

Et maintenant, comment un algorithme conçu pour contrôler un robot finit-il par enseigner la politesse à un modèle de langage ? C'est là que l'histoire devient fascinante.

Un LLM, comme GPT, peut être vu comme un agent de RL.

• L'état (State) : C'est la conversation, le prompt que vous lui donnez.
• L'action (Action) : C'est le prochain mot (ou "token") qu'il génère.
• La politique (Policy) : C'est le réseau de neurones du LLM lui-même, qui calcule les probabilités de chaque mot suivant.

Le problème est : comment définir une récompense ? Est-ce que la réponse "Le ciel est bleu" vaut +10 ou +5 ? C'est impossible à modéliser avec une simple fonction. C'est là qu'intervient le Reinforcement Learning from Human Feedback (RLHF), la technique qui a rendu des modèles comme ChatGPT si utiles.

Le processus se déroule en deux temps :

1. Entraîner un Modèle de Récompense : On demande à des humains de comparer deux réponses du LLM à un même prompt et de dire laquelle est la meilleure (plus utile, plus honnête, moins nocive, etc.). Avec des milliers de ces comparaisons, on entraîne un autre modèle de langage, appelé Modèle de Récompense. Le seul but de ce modèle est de noter une réponse sur une échelle, en imitant les préférences humaines.
2. Affiner le LLM avec PPO : On utilise ensuite PPO pour affiner notre LLM initial.
   • L'Actor est le LLM que nous voulons aligner.
   • L'Environnement est l'interaction avec l'utilisateur.
   • La Récompense est donnée par notre Modèle de Récompense fraîchement entraîné !

PPO va alors générer des réponses, les faire noter par le modèle de récompense, et ajuster ses propres poids pour maximiser cette note. Grâce à sa nature prudente, il améliore le LLM sans le "casser", en l'orientant progressivement vers des comportements que les humains jugent désirables. C'est ainsi que l'on apprend à une IA à être plus qu'un simple prédicteur de mots, mais un assistant utile et sûr.

Conclusion

Notre voyage théorique touche à sa fin. Vous avez maintenant une compréhension complète de l'écosystème du Deep Reinforcement Learning :

• DQN pour les problèmes à actions discrètes où l'efficacité d'échantillonnage est reine.
• A2C comme une base solide pour l'apprentissage on-policy parallélisé.
• PPO comme l'algorithme de référence, robuste et polyvalent, qui alimente certaines des applications IA les plus critiques d'aujourd'hui.

Plus important encore, vous comprenez la philosophie derrière ces outils : le dilemme exploration-exploitation, le compromis biais-variance, et l'importance de la stabilité.

Liens Utiles

Pour approfondir vos connaissances et explorer des outils avancés, voici quelques ressources :

• Hors Série - Deep Reinforcement Learning (Playlist)
• Deep Reinforcement Learning Course de HuggingFace
• Reinforcement Learning: Tutoriel DLI25