Apprendre à un robot à atterrir un drone sans lui programmer chaque mouvement, c’est exactement l’objectif que j’ai poursuivi. J’ai passé des semaines à concevoir un simulateur virtuel où un drone doit apprendre à atterrir sur une plateforme non pas par des instructions prédéfinies, mais par essais et erreurs — comme un enfant apprend à faire du vélo. Ce processus repose sur l’apprentissage par renforcement (Reinforcement Learning, RL), une approche fondamentalement différente de l’apprentissage supervisé. Au lieu de montrer des milliers d’exemples d’atterrissages parfaits, on fournit à l’IA des retours : « C’était pas mal, mais essaie d’être plus doux la prochaine fois » ou « Oups, tu as percuté — probablement pas une bonne idée ». À force de répétitions, l’IA découvre elle-même ce qui fonctionne et ce qui ne fonctionne pas. Dans cet article, je partage mon parcours, du fondamental au système fonctionnel qui enseigne (presque) correctement à un drone à atterrir. Vous découvrirez mes succès, mes échecs, et les comportements bizarres que j’ai dû déboguer. L’essentiel repose sur un cadre théorique clair : l’agent (le drone) interagit avec un environnement (le simulateur), observe un état (position, vitesse, orientation), choisit une action (activer un propulseur), et reçoit une récompense (ou pénalité) en fonction de son comportement. L’objectif est de maximiser la récompense cumulée au fil du temps. Pour illustrer ce concept, j’ai développé un jeu nommé Delivery Drone, disponible sur GitHub. Le drone doit atterrir sur une plateforme en respectant trois critères : être proche horizontalement (|dx| < 0,0625), avoir une vitesse faible (< 0,3), et être bien orienté (angle < 20°). L’état du drone est décrit par 15 variables continues (position, vitesse, angle, distance à la plateforme, etc.), normalisées entre -1 et 1 pour stabiliser l’entraînement. La politique (policy) — c’est-à-dire la stratégie de décision — est modélisée par un réseau de neurones profond. Il prend l’état comme entrée et produit une probabilité pour chaque propulseur (principale, gauche, droite), chacune étant échantillonnée selon une loi de Bernoulli. Ainsi, l’action est une combinaison de décisions indépendantes, ce qui simplifie l’optimisation. Le défi majeur ? La fonction de récompense. Elle doit guider l’agent sans le pousser à exploiter des failles. Par exemple, si on récompense trop fortement la stabilité près de la plateforme, l’agent apprend à simplement planer indéfiniment pour accumuler des points — un cas classique de reward hacking. J’ai dû passer des heures à ajuster des paramètres magiques (comme 0,065, 4,5 ou 4,0) et à réfléchir à des fonctions de récompense non linéaires (ex : inverse quadratique, sigmoïde) pour éviter ces pièges. J’ai adopté une stratégie d’apprentissage par gradient de politique (REINFORCE), avec une amélioration clé : l’avantage (advantage). Plutôt que d’optimiser la récompense brute, on compare chaque action à la performance moyenne, ce qui réduit le bruit dans les gradients. J’ai entraîné le modèle sur plusieurs épisodes simultanés (batch), ce qui donne une estimation plus stable de la performance. Malgré ces efforts, un problème persistant subsiste : le drone apprend à descendre vers la plateforme, puis à planer juste en dessous, évitant ainsi le risque de crash (pénalité de -200) au prix d’une pénalité plus faible (environ -600 sur toute la partie). Pourquoi ? Parce que la récompense actuelle ne dépend que de l’état courant, pas de la transition. Le drone ne sait pas qu’il est en train de manquer l’atterrissage. Il voit seulement qu’il est « en dessous » et que la récompense ne baisse pas brutalement. La solution ? Passer à des récompenses basées sur les transitions d’état (r(s, a, s’)) plutôt que sur l’état seul. Cela permettrait de récompenser explicitement le passage de « juste au-dessus » à « en contact avec la plateforme ». Dans mon prochain article, je testerai des méthodes comme l’Actor-Critic pour intégrer cette temporalité et corriger ces exploits. En résumé, l’apprentissage par renforcement est puissant, mais délicat. Il demande une conception minutieuse de la récompense, une bonne gestion du bruit, et une compréhension fine du comportement émergent. Ce projet m’a appris que l’IA ne triche pas — elle fait exactement ce qu’on lui demande, même si ce n’est pas ce qu’on voulait. Et c’est là que réside toute la beauté et la complexité de ce domaine. Pour les experts : ce travail s’inscrit dans la lignée des méthodes de gradient de politique (Williams, 1992), du REINFORCE avec avantage (Schulman et al., 2015), et de la théorie de Sutton & Barto (2018). Le code est ouvert sur GitHub, et les résultats sont visibles dans des notebooks interactifs. L’expérience montre que même une politique simple peut apprendre des comportements complexes, à condition de bien définir les objectifs.