Stable-Baselines est une bibliothèque de pointe qui fournit des implémentations robustes d'algorithmes d'apprentissage par renforcement. Conçue comme une évolution d'OpenAI Baselines, elle offre une interface unifiée et conviviale pour entraîner, évaluer et déployer des agents intelligents. Ce guide pratique explore son utilisation pour des projets concrets.

Avantages clés par rapport à l'original

Cette bibliothèque se distingue par sa fiabilité et ses fonctionnalités étendues. Elle propose une API cohérente entre les différents algorithmes, une intégration native de TensorBoard pour le suivi, et permet une grande personnalisation des architectures de réseaux neuronaux. Le code respecte les normes PEP8 et s'adapte parfaitement aux environnements de notebook interactifs.

Installation et prérequis

L'installation requiert Python 3.5+ et une version compatible de TensorFlow (entre 1.8 et 1.14). Sur les systèmes basés sur Debian, installez d'abord les dépendances système :

sudo apt-get install cmake libopenmpi-dev python3-dev zlib1g-dev

Pour obtenir la version complète avec support MPI, exécutez :

pip install stable-baselines[mpi]

Une version plus légère sans MPI est également disponible via pip install stable-baselines.

Panorama des algorithmes supportés

La bibliothèque implémente plusieurs méthodes de l'état de l'art, chacune adaptée à des problèmes spécifiques. Voici un résumé de leurs capacités fondamentales :

Démarrage rapide avec CartPole

Voici un exemple complet qui initialise un environnement, configure et entraîne un agent PPO2, puis le teste visuellement.

import gymnasium as gym
from stable_baselines3 import PPO
from stable_baselines3.common.policies import MlpPolicy
from stable_baselines3.common.vec_env import DummyVecEnv

# Préparation de l'environnement vectorisé
mon_env = gym.make('CartPole-v1')
vec_env = DummyVecEnv([lambda: mon_env])

# Instanciation du modèle avec politique MLP
algo = PPO(MlpPolicy, vec_env, verbose=1)

# Boucle d'apprentissage
algo.learn(total_timesteps=15000)

# Phase de test
observation = vec_env.reset()
for epis in range(500):
    action_pred, _ = algo.predict(observation)
    observation, _, done, _ = vec_env.step(action_pred)
    if done:
        observation = vec_env.reset()

Pour une expérimentation encore plus rapide, une syntaxe condensée permet de lancer l'entraînement en une seule ligne :

from stable_baselines3 import PPO
modele_rapide = PPO('MlpPolicy', 'CartPole-v1').learn(10000)

Personnalisation des architectures et des callbacks

Créez des politiques sur mesure en définissant votre propre architecture de réseau neuronal :

from stable_baselines3.common.policies import ActorCriticPolicy
from stable_baselines3 import A2C

class PolitiquePersonnalisee(ActorCriticPolicy):
    def __init__(self, *args, **kwargs):
        super().__init__(
            *args, **kwargs,
            net_arch=[dict(pi=[256, 128], vf=[256, 128])],
            activation_fn=torch.nn.ReLU
        )

agent_custom = A2C(PolitiquePersonnalisee, 'LunarLander-v2', verbose=1)
agent_custom.learn(total_timesteps=50000)

Utilisez des callbacks pour contrôler et observer le processus d'entraînement en détail :

from stable_baselines3.common.callbacks import CheckpointCallback, EvalCallback

# Sauvegarde périodique du modèle
callback_checkpoint = CheckpointCallback(save_freq=1000, save_path='./logs_checkpoints/')

# Évaluation sur un environnement séparé
callback_eval = EvalCallback(eval_env, best_model_save_path='./modele_optimal/',
                             log_path='./resultats_eval/', eval_freq=2000)

algo_apprentissage = PPO('MlpPolicy', env)
algo_apprentissage.learn(total_timesteps=30000, callback=[callback_checkpoint, callback_eval])

Persistance et déploiement des modèles

Sauvegardez et rechargez facilement vos modèles pour la production ou la reprise d'entraînement :

# Sauvegarde du modèle complet
algo.save("mon_agent_ppo_final")

# Chargement ultérieur pour inférence
agent_charge = PPO.load("mon_agent_ppo_final")

def prédire_mouvement(etat_courant):
    mouvement, _ = agent_charge.predict(etat_courant, deterministic=True)
    return mouvement

Activez la journalisation TensorBoard pour une analyse visuelle avancée des métriques d'entraînement :

algo_tb = PPO('MlpPolicy', env, tensorboard_log="./expérimentations_tensorboard/")
algo_tb.learn(total_timesteps=20000, tb_log_name="experience_001")

Optimisation des performances

Pour accélérer l'entraînement sur des environnements complexes, exploitez la vectorisation multi-processus :

from stable_baselines3.common.vec_env import SubprocVecEnv

def construire_env(identifiant, rang):
    def _initialiser():
        env_inst = gym.make(identifiant)
        return env_inst
    return _initialiser

# Création de 4 environnements parallèles
env_parallele = SubprocVecEnv([construire_env('BreakoutNoFrameskip-v4', i) for i in range(4)])

Pour les algorithmes hors politique comme DQN, configurez la mémoire de rejeu avec priorité :

from stable_baselines3 import DQN

modele_prioritaire = DQN(
    'MlpPolicy',
    env,
    learning_rate=1e-4,
    buffer_size=100000,
    learning_starts=1000,
    batch_size=64,
    prioritized_replay=True,
    prioritized_replay_alpha=0.7
)

Résolution des problèmes courants

Face à un apprentissage instable, appliquez une contrainte sur la norme des gradients :

modele_stable = PPO('MlpPolicy', env, max_grad_norm=0.5, clip_range=0.2)

Pour combattre le surapprentissage, augmentez les coefficients de régularisation dans la fonction de perte :

modele_régularisé = PPO('MlpPolicy', env, ent_coef=0.03, vf_coef=0.6)

Ces ajustements de hyperparamètres constituent souvent la clé pour obtenir un comportement d'agent stable et performant.