Apprentissage par renforcement avec Gymnasium : Guide pratique

Mise en place d'un gymnase

Gymnasium a besoin de versions spécifiques (et non des dernières versions) de divers programmes de dépendance tels que NumPy et PyTorch. Nous vous recommandons donc de créer un nouvel environnement Conda ou venv ou un nouvel ordinateur portable pour installer, utiliser Gymnasium et exécuter les programmes RL. 

Vous pouvez utiliser ce classeur DataLab pour suivre le tutoriel . suivre le tutoriel.

Installation d'un gymnase

Pour installer Gymnasium sur un serveur ou une machine locale, exécutez : 

$ pip install gymnasium 

Pour l'installer en utilisant un Notebook comme Colab de Google ou DataCamp's DataLab, utilisez :

!pip install gymnasium

La commande ci-dessus installe Gymnasium et les versions correctes des dépendances.

Exploration de l'environnement des gymnases

En novembre 2024, Gymnasium comprend plus de 60 environnements intégrés. Pour parcourir les environnements intégrés disponibles, utilisez la fonction gym.envs.registry.all(), comme illustré dans l'exemple ci-dessous :

import gymnasium as gym
for i in gym.envs.registry.keys():
	print(i)

Vous pouvez également consulter la page d'accueil du Gymnase. La colonne de droite du sitecontient des liens vers tous les environnements. La page web de chaque environnement contient des informations détaillées sur celui-ci, telles que les actions, les états, etc. 

Les environnements sont organisésen catégories telles que Classic Control, Box2D, etc. Vous trouverez ci-dessous une liste des environnements communs à chaque groupe :

• Contrôle classique: Il s'agit des environnements canoniques utilisés dans le développement de la LR ; ils constituent la base de nombreux exemples de manuels. Ils offrent le bon mélange de complexité et de simplicité pour tester et évaluer les nouveaux algorithmes RL. Les environnements de contrôle classiques du Gymnase sont les suivants 
• Acrobot
• Poteau de chariot
• Voiture de montagne discrète
• Mountain Car Continuous
• Pendule
• Box2D: Box2D est un moteur physique 2D pour les jeux. Les environnements basés sur ce moteur comprennent des jeux simples comme :
• Lander lunaire
• Course automobile
• Texte du jouet: Il s'agit d'environnements simples et de petite taille, souvent utilisés pour déboguer les algorithmes RL. Beaucoup de ces environnements sont basés sur le modèle du monde en petites grilles et sur des jeux de cartes simples. En voici quelques exemples : 
• Blackjack
• Taxi
• Lac gelé
• MuJoCo: Multi-Joint dynamics with Contact (MuJoCo) est un moteur physique open-source qui simule des environnements pour des applications telles que la robotique, la biomécanique, le ML, etc. Les environnements MuJoCo dans le Gymnase comprennent
• Fourmi
• Trémie
• Humanoïde
• Nageur
• Et plus encore

En plus des environnements intégrés, Gymnasium peut être utilisé avec de nombreux environnements externes en utilisant la même API. 

Dans ce tutoriel, nous utiliserons l'un des environnements classiques de contrôle. Pour importer un environnement spécifique, utilisez la commande .make() et donnez le nom de l'environnement en argument. Par exemple, pour créer un nouvel environnement basé sur CartPole (version 1), utilisez la commande ci-dessous : 

import gymnasium as gym
env = gym.make("CartPole-v1")

Comprendre les concepts de l'apprentissage par renforcement au gymnase

En bref, l'apprentissage par renforcement consiste à un agent (comme un robot) qui interagit avec son environnement. Une politique décide des actions de l'agent. En fonction des actions de l'agent, l'environnement donne une récompense (ou une pénalité) à chaque étape. L'agent utilise RL pour déterminer la politique optimale qui maximise les récompenses totales de l'agent. 

Composantes d'un environnement RL

Les éléments clés d'un environnement de LR sont les suivants : 

• L'environnement : Le système, le monde ou le contexte extérieur. L'agent interagit avec l'environnement au cours d'une série de pas de temps. À chaque étape, en fonction de l'action de l'agent, l'environnement :
• Accorde une récompense (ou une pénalité) 
• Décide de l'état suivant 
• État: Une représentation mathématique de la configuration actuelle de l'environnement. 
• Par exemple, l'état d'un environnement pendulaire peut inclure la position et la vitesse angulaire du pendule à chaque pas de temps. 
• État du terminal : Un état qui ne conduit pas à de nouveaux/autres états. 
• Agent : L'algorithme qui observe l'environnement et entreprend diverses actions sur la base de cette observation. L'objectif de l'agent est de maximiser ses récompenses. 
• Par exemple, l'agent décide de la force et de la direction à donner au pendule.  
• Observation : Représentation mathématique de la vue de l'agent sur l'environnement, acquise, par exemple, à l'aide de capteurs. 
• Action : Décision prise par l'agent avant de passer à l'étape suivante. L'action affecte l'état suivant de l'environnement et rapporte une récompense à l'agent. 
• Récompense : Le retour d'information de l'environnement vers l'agent. Elle peut être positive ou négative, en fonction de l'action et de l'état de l'environnement. 
• Retourner : Le rendement cumulé attendu sur les futurs pas de temps. Les récompenses des étapes futures peuvent être actualisées à l'aide d'un facteur d'actualisation. 
• Politique : La stratégie de l'agent quant à l'action à entreprendre dans les différents états. Il est généralement représenté par une matrice de probabilité, P, qui associe les états aux actions.
• Étant donné un ensemble fini de m états possibles et de n actions possibles, l'élément Pmn de la matrice représente la probabilité d'entreprendre l'action an dans l'état sm.
• Épisode : Série de pas de temps entre l'état initial (aléatoire) et l'état final de l'agent.

Espace d'observation et espace d'action

L'observation est l'information que l'agent recueille sur l'environnement. Un agent, par exemple un robot, peut collecter des informations environnementales à l'aide de capteurs. Idéalement, l'agent devrait pouvoir observer l'état complet, qui décrit tous les aspects de l'environnement. Dans la pratique, l'agent utilise ses observations comme une approximation de l'état. Ce sont donc les observations qui décident des actions de l'agent. 

Un espace est analogue à un ensemble thématique ma. L'espace des éléments X comprend toutes les instances possibles de X. L'espace X définit également la structure (syntaxe et format) de tous les éléments de type X. Chaque environnement Gymnasium possède deux espaces, l'espace d'action, action_space, et l'espace d'observation, observation_space. Les espaces d'action et d'observation dérivent tous deux de la superclasse parentale gymnasium.spaces.Space.

Espace d'observation 

L'espace d'observation est l'espace qui comprend toutes les observations possibles. Il définit également le format dans lequel les observations sont stockées. L'espace d'observation est généralement représenté comme un objet de donnéespe Box. Il s'agit d'un tableau nd qui décrit les paramètres des observations. La boîte spécifie les limites de chaque dimension. Vous pouvez visualiser l'espace d'observation d'un environnement à l'aide de la méthode observation_space:

print("observation space: ", env.observation_space)

Dans le cas de l' environnement CartPole-v1, la sortie ressemble à l'exemple ci-dessous :

observation space:  Box([-4.8 -inf -0.41887903 -inf], [4.8 inf 0.41887903 inf], (4,), float32)

Dans cet exemple, l'espace d'observation CartPole-v1 a 4 dimensions. Les 4 éléments du tableau d'observation sont les suivants

• La position du chariot - varie entre -4,8 et +4,8
• Vitesse du chariot - se situe entre - à +
• L'angle du pôle - varie entre -0,4189 et +0,4189
• Vitesse angulaire du pôle - varie entre - à +

Pour voir un exemple de tableau d'observation individuel, utilisez la commande .reset() .

observation, info = env.reset()
print("observation: ", observation)

Dans le cas de l' environnement CartPole-v1, la sortie ressemble à l'exemple ci-dessous :

[ 0.03481963 -0.0277232   0.01703267 -0.04870504]                                                                                                       

Les quatre éléments de ce tableau correspondent aux quatre quantités observées (position du chariot, vitesse du chariot, angle du pôle, vitesse angulaire du pôle), comme expliqué précédemment. 

Espace d'action

L'espace d'action comprend toutes les actions possibles que l'agent peut entreprendre. L'espace d'action définit également le format dans lequel les actions sont représentées. Vous pouvez visualiser l'espace d'action d'un environnement à l'aide de la méthode action_space:

print("action space: ", env.action_space)

Dans le cas de l' environnement CartPole-v1, la sortie ressemble à l'exemple ci-dessous :

action space:  Discrete(2)

Dans le cas de l'environnement CartPole-v1, l'espace d'action est discret. L'agent peut effectuer deux actions au total :

• 0: Poussez le chariot vers la gauche
• 1: Poussez le chariot vers la droite

Créez votre premier agent RL avec Gymnasium

Dans les sections précédentes, nous avons exploré les concepts de base de RL et de Gymnasium. Cette section vous montre comment utiliser Gymnasium pour créer un agent RL. 

Création et réinitialisation de l'environnement

La première étape consiste à créer une instance de l'environnement. Pour créer de nouveaux environnements, utilisez la méthode .make(). 

env = gym.make('CartPole-v1')

Les interactions de l'agent modifient l'état de l'environnement. La méthode .reset() réinitialise l'environnement à un état initial. Par défaut, l'environnement est initialisé à un état aléatoire. Vous pouvez utiliser un paramètre SEED avec la méthode .reset() pour initialiser l'environnement dans le même état à chaque fois que le programme est exécuté. Le code ci-dessous montre comment procéder :

SEED = 1111
env.reset(seed=SEED)

L'échantillonnage des actions est également aléatoire. Pour contrôler ce caractère aléatoire et obtenir un parcours d'entraînement entièrement reproductible, nous pouvons ensemencer les générateurs aléatoires de NumPy et PyTorch :

np.random.seed(SEED)
torch.manual_seed(SEED)

Actions aléatoires ou intelligentes

À chaque étape d'un processus de Markov, l'agent peut choisir au hasard une action et explorer l'environnement jusqu'à ce qu'il arrive à un état final. En choisissant des actions au hasard : 

• L'atteinte de l'état terminal peut prendre beaucoup de temps.
• Les récompenses cumulées sont bien inférieures à ce qu'elles auraient pu être.

Former l'agent à optimiser la sélection des actions sur la base des expériences précédentes (d'interaction avec l'environnement) est plus efficace pour maximiser les récompenses à long terme. 

L'agent non formé commence par des actions aléatoires basées sur une politique initialisée de manière aléatoire. Cette politique est généralement représentée par un réseau neuronal. Au cours de la formation, l'agent apprend la politique optimale qui maximise les récompenses. En RL, le processus de formation est également appelé optimisation de la politique. 

Il existe plusieurs méthodes d'optimisation des politiques. Les équations de Bellman décrivent comment calculer la valeur des politiques de RL et déterminer la politique optimale. Dans ce tutoriel, nous utiliserons une technique simple appelée " policy gradients". Il existe d'autres méthodes, telles que l'optimisation de la politique proximale (PPO). 

Mise en œuvre d'un agent de gradient de politique simple

Pour construire un agent RL qui utilise les gradients de politique, nous créons un réseau neuronal pour mettre en œuvre la politique, nous écrivons des fonctions pour calculer les rendements et les pertes à partir des récompenses progressives et des probabilités d'action, et nous mettons à jour la politique de manière itérative à l'aide de techniques de rétropropagation standard. 

Mise en place du réseau politique

Nous utilisons un réseau neuronal pour mettre en œuvre la politique. Parce que CartPole-v1 est un environnement simple, nous utilisons un réseau neuronal avec :

• Dimensions d'entrée égales à la dimensionnalité de l'espace d'observation de l'environnement. 
• Une seule couche cachée avec 64 neurones. 
• Dimensions de sortie égales à la dimensionnalité de l'espace d'action de l'environnement.

La fonction du réseau politique est donc de faire correspondre les états observés à des actions. À partir d'une observation d'entrée, il prédit la bonne action. Le code ci-dessous met en œuvre le réseau de politiques :

class PolicyNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)
    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout(x)
        x = F.relu(x)
        x = self.layer2(x)
        return x

La collecte de récompenses et le passage à l'acte

Comme nous l'avons mentionné, à chaque étape du processus de Markov, l'environnement attribue une récompense en fonction de l'action et de l'état de l'agent. L'objectif de RL est de maximiser le rendement total. 

• Le rendement à chaque étape est la somme cumulée des récompenses obtenues depuis le début jusqu'à cette étape. 
• Le rendement total de chaque épisode est obtenu en cumulant toutes les récompenses progressives de cet épisode. Ainsi, le rendement total est le rendement au dernier pas de temps (lorsque l'agent atteint un état terminal). 

Dans la pratique, il est courant d'accumuler des récompenses : 

• Ajustez les bénéfices futurs à l'aide d'un facteur d'actualisation. 
• Normaliser le tableau des retours progressifs afin d'assurer une formation régulière et stable. 

Le code ci-dessous montre comment procéder : 

def calculate_stepwise_returns(rewards, discount_factor):
    returns = []
    R = 0
    for r in reversed(rewards):
        R = r + R * discount_factor
        returns.insert(0, R)
    returns = torch.tensor(returns)
    normalized_returns = (returns - returns.mean()) / returns.std()
    return normalized_returns

Le passage en avant consiste à faire fonctionner l'agent sur la base de la politique actuelle jusqu'à ce qu'il atteigne un état terminal et à collecter les récompenses progressives et les probabilités d'action. Les étapes ci-dessous expliquent comment mettre en œuvre la passe en avant : 

• Réinitialiser l'environnement à un état initial. 
• Initialiser les tampons pour stocker les probabilités d'action, les récompenses et le rendement cumulé.
• Utilisez la fonction .step() pour exécuter itérativement l'agent dans l'environnement jusqu'à ce qu'il se termine :
• Obtenir l'observation de l'état de l'environnement.
• Obtenez l'action prévue par la politique en fonction de l'observation.
• Utilisez la fonction Softmax pour estimer la probabilité d'entreprendre l'action prédite.
• Simulez une distribution de probabilité catégorielle basée sur ces probabilités estimées.
• Échantillonnez cette distribution pour obtenir l'action de l'agent.
• Estimez la probabilité logarithmique de l'action échantillonnée à partir de la distribution simulée. 
• Ajoutez le logarithme de la probabilité des actions et les récompenses de chaque étape à leurs tampons respectifs. 
• Estimez les valeurs normalisées et actualisées des rendements à chaque étape en fonction des récompenses. 

def forward_pass(env, policy, discount_factor):
    log_prob_actions = []
    rewards = []
    done = False
    episode_return = 0
    policy.train()
    observation, info = env.reset()
    while not done:
        observation = torch.FloatTensor(observation).unsqueeze(0)
        action_pred = policy(observation)
        action_prob = F.softmax(action_pred, dim = -1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)
        observation, reward, terminated, truncated, info = env.step(action.item())
        done = terminated or truncated
        log_prob_actions.append(log_prob_action)
        rewards.append(reward)
        episode_return += reward
    log_prob_actions = torch.cat(log_prob_actions)
    stepwise_returns = calculate_stepwise_returns(rewards, discount_factor)
    return episode_return, stepwise_returns, log_prob_actions

Mise à jour de la politique en fonction des récompenses

La perte représente la quantité sur laquelle nous appliquons la descente de gradient. L'objectif du RL est de maximiser les rendements. Nous utilisons donc la valeur du rendement attendu comme approximation de la perte. La valeur du rendement attendu est calculée comme le produit des rendements attendus par étapes et de la probabilité logarithmique des actions par étapes. Le code ci-dessous calcule la perte :

def calculate_loss(stepwise_returns, log_prob_actions):
    loss = -(stepwise_returns * log_prob_actions).sum()
    return loss

Pour mettre à jour la politique, vous exécutez la rétropropagation par rapport à la fonction de perte. La méthode update_policy() ci-dessous invoque la méthode calculate_loss(). Il exécute ensuite la rétropropagation sur cette perte pour mettre à jour les paramètres de la politique, c'est-à-dire les poids du modèle du réseau de la politique.

def update_policy(stepwise_returns, log_prob_actions, optimizer):
    stepwise_returns = stepwise_returns.detach()
    loss = calculate_loss(stepwise_returns, log_prob_actions)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    return loss.item()

La mise à jour de la politique en fonction du gradient des rendements est appelée méthode du gradient de la politique. 

Formation à la politique

Nous disposons désormais de tous les éléments nécessaires à la formation et à l'évaluation de la politique. Nous mettons en œuvre la boucle de formation comme expliqué dans les étapes suivantes :  

Avant de commencer, nous déclarons les hyperparamètres, nous instancions une politique et nous créons un optimiseur :

• Déclarez les hyperparamètres en tant que constantes Python :
• MAX_EPOCHS est le nombre maximum d'itérations que nous sommes prêts à exécuter pour former la politique. 
• DISCOUNT_FACTOR décide de l'importance relative des récompenses des étapes futures. Un facteur d'actualisation de 1 signifie que toutes les récompenses ont la même importance, tandis qu'une valeur de 0 signifie que seule la récompense du pas de temps actuel est importante. 
• N_TRIALS est le nombre d'épisodes sur lesquels nous calculons la moyenne des rendements pour évaluer la performance de l'agent. Nous considérons que l'apprentissage est réussi si le rendement moyen sur N_TRIALS épisodes est supérieur au seuil.
• REWARD_THRESHOLD: Si la politique permet d'obtenir un rendement supérieur au seuil, elle est considérée comme réussie. 
• DROPOUT décide de la fraction des poids qui doit être mise à zéro de manière aléatoire. La fonction d'exclusion met aléatoirement à zéro une fraction des poids du modèle. Cela réduit la dépendance à l'égard de neurones spécifiques et empêche l'ajustement excessif, ce qui rend le réseau plus robuste.
• LEARNING_RATE décide de l'ampleur de la modification des paramètres de la politique à chaque étape. La mise à jour des paramètres à chaque itération est le produit du gradient et du taux d'apprentissage. 
• Définissez la politique comme une instance de la classe PolicyNetwork (mise en œuvre précédemment). 
• Créez un optimiseur en utilisant l'algorithme d'Adam et le taux d'apprentissage. 

Pour former la politique, nous exécutons itérativement les étapes de formation jusqu'à ce que le rendement moyen (sur N_TRIALS ) soit supérieur au seuil de récompense:

• Pour chaque épisode, exécutez une fois la passe avant. Recueillez la probabilité logarithmique des actions, les rendements progressifs et le rendement total de cet épisode. Accumulez les retours épisodiques dans un tableau. 
• Calculez la perte en utilisant les logarithmes des probabilités et les rendements progressifs. Exécutez la rétro-propagation sur la perte. Utilisez l'optimiseur pour mettre à jour les paramètres de la politique. 
• Vérifiez si le rendement moyen sur N_TRIALS dépasse le seuil de récompense.

Le code ci-dessous met en œuvre ces étapes :

def main(): 
    MAX_EPOCHS = 500
    DISCOUNT_FACTOR = 0.99
    N_TRIALS = 25
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    INPUT_DIM = env.observation_space.shape[0]
    HIDDEN_DIM = 128
    OUTPUT_DIM = env.action_space.n
    DROPOUT = 0.5
    episode_returns = []
    policy = PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)
    LEARNING_RATE = 0.01
    optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)
    for episode in range(1, MAX_EPOCHS+1):
        episode_return, stepwise_returns, log_prob_actions = forward_pass(env, policy, DISCOUNT_FACTOR)
        _ = update_policy(stepwise_returns, log_prob_actions, optimizer)
        episode_returns.append(episode_return)
        mean_episode_return = np.mean(episode_returns[-N_TRIALS:])
        if episode % PRINT_INTERVAL == 0:
            print(f'| Episode: {episode:3} | Mean Rewards: {mean_episode_return:5.1f} |')
        if mean_episode_return >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break

Enfin, invoquez la fonction main() pour former la politique :

main()

UUtilisez ce classeur DataLab pour exécuter directement l'algorithme ci-dessus et résoudre l'environnement CartPole à l'aide du RL.l'algorithme ci-dessus et résoudre l'environnement CartPole à l'aide de RL.

Techniques avancées de gymnastique

Après avoir montré comment mettre en œuvre un algorithme de NR, nous allons maintenant aborder certaines techniques avancées couramment utilisées dans la pratique. 

Utilisation d'architectures préétablies

La mise en œuvre d'algorithmes RL à partir de zéro est un processus long et difficile, en particulier pour les environnements complexes et les politiques de pointe. 

Une alternative plus pratique consiste à utiliser un logicielcomme Stable Baselines3. Il est livré avec des implémentations testées et éprouvées des algorithmes RL. Il comprend des agents préformés, des scripts de formation, des outils d'évaluation et des modules permettant de tracer des graphiques et d'enregistrer des vidéos. 

Ray RLib est un autre outil populaire pour RL. RLib est conçu comme une solution évolutive, facilitant la mise en œuvre d'algorithmes RL sur des systèmes multi-GPU. Il prend également en charge le RL multi-agents, ce qui ouvre de nouvelles possibilités :

• Apprentissage multi-agents indépendant: Chaque agent traite les autres agents comme faisant partie de l'environnement.
• Formation collaborative multi-agents: Un groupe d'agents partage la même politique et les mêmes fonctions de valeur et apprend en parallèle de l'expérience des autres. 
• Formation contradictoire: Les agents (ou groupes d'agents) s'affrontent dans des environnements compétitifs de type jeu. 

Avec RLib et Stable Baselines3, vous pouvez importer et utiliser les environnements d'OpenAI Gymnasium. 

Environnements personnalisés

Les environnements fournis avec Gymnasium sont le bon choix pour tester de nouvelles stratégies de RL et des politiques de formation. Cependant, pour la plupart des applications pratiques, vous devez créer et utiliser un environnement qui reflète fidèlement le problème que vous souhaitez résoudre. Vous pouvez utiliser Gymnasium pour créer un environnement personnalisé. L'avantage d'utiliser des environnements Gymnasium personnalisés est que de nombreux outils externes tels que RLib et Stable Baselines3 sont déjà configurés pour fonctionner avec la structure API Gymnasium. 

Pour créer un environnement personnalisé dans Gymnasium, vous devez définir : 

• L'espace d'observation.
• Les conditions terminales.
• L'ensemble des actions que l'agent peut choisir.
• Comment initialiser l'environnement (lorsque la fonction reset() est appelée).
• Comment l'environnement décide de l'état suivant en fonction des actions de l'agent (lorsque la fonction step() est appelée).

Pour en savoir plus, suivez le guideGymnasium sur la création d'environnements personnalisés. 

Bonnes pratiques pour l'utilisation du gymnase

Expérimentez différents environnements

Le code de ce tutoriel montre comment implémenter l'algorithme du gradient de politique dans l'environnement CartPole. Il s'agit d'un environnement simple avec un espace d'action discret. Pour mieux comprendre RL, nous vous conseillons d'appliquer le même algorithme de gradient de politique (et d'autres algorithmes, comme PPO) dans d 'autres environnements.

Par exemple, l'environnement Pendulum possède un espace d'action continu. Il consiste en une entrée unique représentée par une variable continue - le couple (ampleur et direction) appliqué au pendule dans un état donné. Ce couple peut prendre n'importe quelle valeur entre -2 et +2.

L'expérimentation de différents algorithmes dans divers environnements vous aide à mieux comprendre les différents types de solutions de NR et leurs défis. 

Suivre les progrès de la formation

Les environnements RL sont souvent constitués de robots, de pendules, de voitures de montagne, de jeux vidéo, etc. La visualisation des actions de l'agent dans l'environnement permet une meilleure compréhension intuitive des performances de la politique. 

Dans Gymnasium, la méthode env.render() permet de visualiser les interactions de l'agent avec l'environnement. Il affiche graphiquement l'état actuel de l'environnement - écrans de jeu, position du pendule ou de la perche du chariot, etc. Le retour visuel des actions de l'agent et des réponses de l'environnement permet de contrôler les performances de l'agent et ses progrès tout au long du processus de formation. 

Il existe quatre modes de rendu : "human", "rgb_array", "ansi" et "rgb_array_list". Pour visualiser la performance de l'agent, utilisez le mode de rendu "humain". Le mode de rendu est spécifié lors de l'initialisation de l'environnement. Par exemple :

env = gym.make(‘CartPole-v1’, render_mode=’human’)

Pour effectuer le rendu, faites intervenir la méthode .render() après chaque action effectuée par l'agent (en appelant la méthode .step() ). Le pseudo-code ci-dessous illustre comment procéder :

while not done:
    …
   step, reward, terminated, truncated, info = env.step(action.item())
   env.render()
    …

Dépannage des erreurs courantes

Gymnasium facilite l'interface avec des environnements RL complexes. Cependant, il s'agit d'un logiciel mis à jour en permanence et comportant de nombreuses dépendances. Il est donc essentiel de faire attention à quelques types d'erreurs courantes.

Inadéquation des versions

• Inadéquation de la version du gymnase : Le progiciel Farama's Gymnasium a été dérivé de OpenAI's Gym à partir de la version 0.26.2. Il y a eu quelques changements entre les anciennes versions de Gymnasium et les nouvelles. De nombreuses implémentations accessibles au public sont basées sur les anciennes versions de Gym et peuvent ne pas fonctionner directement avec la dernière version. Dans ce cas, il est nécessaire de revenir à une version antérieure ou d'adapter le code pour qu'il fonctionne avec la nouvelle version. 
• Erreur de version de l'environnement : De nombreux environnements de gymnase ont des versions différentes. Par exemple, il existe deux environnements CartPole - CartPole-v1 et CartPole-v0. Bien que le comportement de l'environnement soit le même dans les deux versions, certains paramètres, comme la durée de l'épisode, le seuil de récompense, etc. peuvent être différents. Une politique formée sur une version peut ne pas fonctionner aussi bien sur une autre version du même environnement. Vous devez mettre à jour les paramètres d'apprentissage et réapprendre la politique pour chaque version de l'environnement. 
• Non concordance de la version des dépendances : Gymnasium s'appuie sur des dépendances telles que NumPy et PyTorch. En décembre 2024, les dernières versions de ces dépendances sont numpy 2.1.3 et torch 2.5.1. Cependant, Gymnasium fonctionne mieux avec torch 1.13.0 et numpy 1.23.3. Vous pouvez rencontrer des problèmes si vous installez Gymnasium dans un environnement où ces dépendances sont pré-installées. Nous vous recommandons d'installer et de travailler avec Gymnasium dans un nouvel environnement Conda. 

Problèmes de convergence

• Hyperparamètres : Comme d'autres algorithmes d'apprentissage automatique, les politiques RL sont sensibles aux hyperparamètres tels que le taux d'apprentissage, le facteur d'actualisation, etc. Nous vous recommandons d'expérimenter et de régler les hyperparamètres manuellement ou d'utiliser des techniques automatisées telles que la recherche par grille et la recherche aléatoire. 
• Exploration ou exploitation : Pour certaines catégories de politiques (telles que l'OPP), l'agent adopte une stratégie à deux volets : il explore l'environnement pour découvrir de nouveaux chemins et adopte une approche gourmande pour maximiser les récompenses sur la base des chemins connus jusqu'à présent. S'il explore trop, la politique ne converge pas. Inversement, il n'essaie jamais le chemin optimal s'il n'explore pas suffisamment. Il est donc essentiel de trouver le bon équilibre entre l'exploration et l'exploitation. Il est également courant de donner la priorité à l'exploration dans les premiers épisodes et à l'exploitation dans les derniers au cours de la formation. 

Instabilité de la formation

• Des taux d'apprentissage élevés : Si le taux d'apprentissage est trop élevé, les paramètres de la politique subissent d'importantes mises à jour à chaque étape. Cela pourrait potentiellement conduire à ne pas obtenir l'ensemble optimal de valeurs. Une solution courante consiste à diminuer progressivement le taux d'apprentissage, ce qui garantit des mises à jour plus petites et plus stables au fur et à mesure que l'apprentissage converge. 
• Exploration excessive : Une trop grande part de hasard (entropie) dans la sélection des actions empêche la convergence et entraîne d'importantes variations de la fonction de perte entre les étapes suivantes. Pour obtenir un processus de formation stable et convergent, équilibrez l'exploration et l'exploitation. 
• Mauvais choix d'algorithme : Des algorithmes simples tels que le gradient de politique peuvent conduire à une formation instable dans des environnements complexes avec de grands espaces d'action et d'état. Dans ce cas, nous vous recommandons d'utiliser des algorithmes plus robustes tels que PPO et Trust Region Policy Optimization (TRPO). Ces algorithmes évitent les mises à jour importantes de la politique à chaque étape et peuvent être plus stables.
• Au hasard : Les algorithmes RL sont notoirement sensibles aux états initiaux et au caractère aléatoire inhérent à la sélection des actions. Lorsqu'un cycle de formation est instable, il peut parfois être stabilisé en utilisant une autre graine aléatoire ou en réinitialisant la politique.

Conclusion

Dans ce tutoriel, nous avons exploré les principes de base du RL, discuté de Gymnasium en tant que progiciel avec une API propre pour interfacer avec divers environnements RL, et montré comment écrire un programme Python pour implémenter un algorithme RL simple et l'appliquer dans un environnement Gymnasium.

Après avoir compris les bases de ce tutoriel, je vous recommande d'utiliser les environnements Gymnasium pour appliquer les concepts de RL à la résolution de problèmes pratiques tels que l'optimisation des itinéraires de taxis et les simulations de transactions boursières.