Entraînement d'agents par Renforcement : du Q-Learning au pilotage autonome d'un atterrisseur lunaire

Python, Reinforcement Learning, PyTorch, Stable-Baselines3, Gymnasium, DQN, PPO, FastAPI, Streamlit

Entraînement d'Agents RL : du Q-Learning au Pilotage Autonome d'un Atterrisseur Lunaire

Présentation

Ce projet met en œuvre une progression complète en apprentissage par renforcement, des fondamentaux théoriques jusqu'au déploiement d'un agent autonome complet. Point de départ : la boucle observation → action → récompense sur un environnement simple. Point d'arrivée : le pilote automatique du module d'atterrissage lunaire "Eagle-1" pour AstroDynamics, exposé via une API, visualisé dans une interface graphique et suivi par un tableau de bord de performance.

Le projet applique les bonnes pratiques du Reinforcement Learning afin de construire, du zéro jusqu'à la production, une chaîne complète d'entraînement, d'optimisation et de mise à disposition d'un agent intelligent.

Objectifs

• Comprendre et manipuler le cycle fondamental observation-action-récompense d'un environnement RL.
• Implémenter un algorithme de Q-Learning de zéro (Q-table) et évaluer sa performance.
• Remplacer la Q-table par un réseau de neurones (DQN), manuellement puis via une librairie de référence.
• Entraîner, optimiser et évaluer un agent capable de résoudre un problème de contrôle continu/discret (atterrissage lunaire).
• Exposer l'agent entraîné via une API, une interface de visualisation et un tableau de bord de suivi.

Compétences démontrées

Fondamentaux du Reinforcement Learning

• Prise en main de Gymnasium : exploration des espaces d'observation (continus, Box) et d'action (discrets, Discrete).
• Implémentation d'une boucle agent-environnement avec politique aléatoire, sur plusieurs épisodes, avec calcul de la récompense cumulée.

Q-Learning "from scratch"

• Construction et initialisation d'une Q-table adaptée dynamiquement aux dimensions de l'environnement (FrozenLake-v1).
• Implémentation de la stratégie d'exploration/exploitation epsilon-greedy avec décroissance d'epsilon.
• Codage de la règle de mise à jour de Bellman et entraînement sur plusieurs milliers d'épisodes.
• Évaluation rigoureuse de l'agent entraîné (politique gloutonne pure) et calcul du taux de réussite sur un jeu d'épisodes dédié.

Deep Q-Network (DQN)

• Implémentation manuelle en PyTorch d'un réseau de neurones (DQN) et d'un ReplayBuffer (basé sur collections.deque) pour l'experience replay.
• Analyse et prise en main d'une boucle d'entraînement DQN complexe : sélection d'action, calcul des Q-values, target network, calcul de la loss et étape d'optimisation.
• Réentraînement du même problème avec Stable-Baselines3 pour comparer l'approche bas niveau et l'approche outillée (model.learn, evaluate_policy, sauvegarde du modèle).

Entraînement et optimisation d'un agent de contrôle (LunarLander)

• Sélection d'un algorithme adapté à la nature de l'espace d'action (PPO pour le contrôle continu, DQN pour le discret).
• Établissement d'une performance de référence avant toute optimisation, pour cadrer l'effort d'expérimentation.
• Tuning d'hyperparamètres en isolant une variable à la fois (learning rate, gamma, n_steps), suivi via TensorBoard.
• Validation de la robustesse du résultat (récompense moyenne stable, écart-type faible) plutôt qu'un score obtenu par chance, jusqu'à dépasser le seuil de réussite de 200 points.

Mise à disposition de l'agent (MLOps léger)

• Développement d'une API (FastAPI) exposant un endpoint d'inférence acceptant un état et renvoyant une action, avec toute la logique RL côté backend.
• Développement d'une interface graphique (Streamlit / Gradio) visualisant une partie jouée par l'agent.
• Construction d'un tableau de bord interactif de suivi des performances (récompense moyenne, écart-type, décisions par contexte).
• Production d'un notebook documenté de bout en bout et d'une vidéo de démonstration du pilote automatique.

Architecture

        Environnement Gymnasium
    (CartPole / FrozenLake / LunarLander)
                    │
                    ▼
        Politique aléatoire (baseline)
                    │
                    ▼
     Q-Learning (Q-table, Bellman, ε-greedy)
                    │
                    ▼
   DQN manuel (PyTorch, ReplayBuffer,
        Policy Net / Target Net)
                    │
                    ▼
      DQN / PPO via Stable-Baselines3
      (entraînement, tuning, TensorBoard)
                    │
                    ▼
       Agent optimisé (récompense >200)
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
      API        GUI       Dashboard
   (FastAPI)  (Streamlit/    (suivi des
              Gradio)        performances)

Stack technique

Reinforcement Learning

• Gymnasium (CartPole-v1, FrozenLake-v1, LunarLander-v3)
• Stable-Baselines3 (DQN, PPO)
• PyTorch (implémentation manuelle du DQN)

Suivi & optimisation

• TensorBoard
• NumPy

Déploiement & visualisation

• FastAPI
• Streamlit / Gradio
• Looker Studio

Livrables

• Notebook Google Colab (.ipynb) documenté
• Vidéo de démonstration (.mp4)
• Code source API et GUI
• Modèle entraîné sauvegardé (.zip)

Bonnes pratiques appliquées

• Établissement systématique d'une performance de référence avant optimisation
• Isolation d'un hyperparamètre à la fois pour interpréter son effet
• Séparation stricte de la phase d'entraînement et de la phase d'évaluation (politique gloutonne pure, aucune mise à jour du modèle)
• Validation de la stabilité du score (moyenne + écart-type) plutôt qu'un résultat isolé
• Séparation claire des responsabilités : logique RL côté backend, visualisation côté frontend
• Documentation systématique de chaque expérience (paramètres modifiés, résultats obtenus)

Résultats

À l'issue de ce projet, le pipeline permet de :

• comprendre et implémenter les mécanismes fondamentaux du RL (Q-learning, DQN) sans dépendance à une librairie haut niveau ;
• entraîner un agent PPO/DQN dépassant durablement le seuil de réussite fixé (récompense moyenne > 200 sur LunarLander-v3) ;
• comparer objectivement une implémentation manuelle et une implémentation outillée (Stable-Baselines3) ;
• exposer l'agent entraîné via une API et une interface de visualisation utilisables par un tiers ;
• suivre en continu les performances de l'agent via un tableau de bord dédié.

Compétences acquises

• Fondamentaux du Reinforcement Learning (Gymnasium, cycle observation-action-récompense)
• Q-Learning et construction de Q-table
• Deep Q-Network : implémentation manuelle (PyTorch) et via Stable-Baselines3
• Choix d'algorithme selon la nature de l'espace d'action (PPO vs DQN)
• Tuning d'hyperparamètres et suivi d'expériences (TensorBoard)
• Développement d'API d'inférence (FastAPI)
• Construction d'interfaces de visualisation et de tableaux de bord (Streamlit, Gradio, Looker Studio)