Résoudre l’exercice de course de Reinforcement Learning avec le contrôle de Monte Carlo hors politique

Résoudre l'exercice de course RL avec Monte Carlo hors politique

Image générée par Midjourney avec un abonnement payant, qui respecte les conditions commerciales générales [1].

Introduction

Dans la section Contrôle Monte Carlo hors politique du livre Apprentissage par Renforcement : Une Introduction 2e édition (page 112), l’auteur nous a laissé avec un exercice intéressant : utiliser la méthode Monte Carlo hors politique avec pondération d’importance pour trouver le moyen le plus rapide de conduire sur les deux pistes. Cet exercice est complet car il nous demande de considérer et de construire presque tous les composants d’une tâche d’apprentissage par renforcement, tels que l’environnement, l’agent, la récompense, les actions, les conditions de terminaison et l’algorithme. Résoudre cet exercice est amusant et nous aide à acquérir une solide compréhension de l’interaction entre l’algorithme et l’environnement, de l’importance d’une définition correcte de la tâche épisodique et de l’impact de l’initialisation des valeurs sur le résultat de l’entraînement. Dans cet article, j’espère partager ma compréhension et ma solution de cet exercice avec tous ceux intéressés par l’apprentissage par renforcement.

Exigences de l’exercice

Comme mentionné précédemment, cet exercice nous demande de trouver une politique qui permet à une voiture de course de conduire de la ligne de départ à la ligne d’arrivée le plus rapidement possible sans sortir de la piste ou entrer dans du gravier. Après avoir lu attentivement les descriptions de l’exercice, j’ai répertorié quelques points clés essentiels pour accomplir cette tâche :

  • Représentation de la carte : les cartes dans ce contexte sont en réalité des matrices 2D avec (index_de_ligne, index_de_colonne) comme coordonnées. La valeur de chaque cellule représente l’état de cette cellule ; par exemple, nous pouvons utiliser 0 pour décrire du gravier, 1 pour la surface de la piste, 0.4 pour la région de départ et 0.8 pour la ligne d’arrivée. Toute index de ligne et de colonne en dehors de la matrice peut être considéré comme hors limite.
  • Représentation de la voiture : nous pouvons directement utiliser les coordonnées de la matrice pour représenter la position de la voiture ;
  • Vélocité et contrôle : l’espace de vélocité est discret et se compose de vitesses horizontales et verticales qui peuvent être représentées sous forme de tuple (vitesse_de_ligne, vitesse_de_colonne). La limite de vitesse sur les deux axes est (-5, 5) et est incrémentée de +1, 0 et -1 sur chaque axe à chaque étape ; par conséquent, il y a un total de 9 actions possibles à chaque étape. Littéralement, la vitesse ne peut pas être nulle sauf sur la ligne de départ, et la vitesse verticale, ou vitesse de ligne, ne peut pas être négative car nous ne voulons pas que notre voiture conduise en arrière vers la ligne de départ.
  • Récompense et épisode : la récompense pour chaque étape avant de traverser la ligne d’arrivée est -1. Lorsque la voiture sort de la piste, elle sera réinitialisée à l’une des cellules de départ. L’épisode se termine UNIQUEMENT lorsque la voiture traverse avec succès la ligne d’arrivée.
  • États de départ : nous choisissons aléatoirement une cellule de départ pour la voiture à partir de la ligne de départ ; la vitesse initiale de la voiture est (0, 0) selon la description de l’exercice.
  • Défi de zéro accélération : l’auteur propose un petit défi de zéro accélération selon lequel, à chaque étape de temps, avec une probabilité de 0.1, l’action n’aura pas d’effet et la voiture conservera sa vitesse précédente. Nous pouvons implémenter ce défi dans l’entraînement au lieu d’ajouter cette fonctionnalité à l’environnement.

La solution de l’exercice est divisée en deux articles ; dans cet article, nous nous concentrerons sur la création d’un environnement de piste de course. La structure des fichiers de cet exercice est la suivante :

|-- race_track_env|  |-- maps|  |  |-- build_tracks.py // ce fichier est utilisé pour générer des cartes de piste|  |  |-- track_a.npy // données de la piste a|  |  |-- track_b.npy // données de la piste b|  |-- race_track.py // environnement de piste de course|-- exercise_5_12_racetrack.py // la solution à cet exercice

Et les bibliothèques utilisées dans cette implémentation sont les suivantes :

python==3.9.16numpy==1.24.3matplotlib==3.7.1pygame==2.5.0

Construction des cartes de piste

Nous pouvons représenter les cartes de piste sous forme de matrices 2D avec différentes valeurs indiquant les états de la piste. Je veux être fidèle à l’exercice, donc j’essaie de construire les mêmes cartes montrées dans le livre en assignant les valeurs de la matrice manuellement. Les cartes seront enregistrées sous forme de fichiers .npy séparés afin que l’environnement puisse lire le fichier lors de l’entraînement au lieu de les générer à l’exécution.

Les deux cartes ressemblent comme suit; les cellules claires sont du gravier, les cellules sombres sont des surfaces de piste, les cellules verdâtres représentent la ligne d’arrivée et les cellules bleu clair représentent la ligne de départ.

Figure 1 cartes de pistes avec la représentation de matrice 2D. Source: Image par l'auteur

Construction d’un environnement de type Gym

Avec les cartes de pistes prêtes, nous passons maintenant à la création d’un environnement de type Gym avec lequel l’algorithme peut interagir. Le gymnase, anciennement le gymnase OpenAI et appartenant maintenant à la Fondation Farama, fournit une interface simple pour tester les algorithmes RL ; nous utiliserons le package gymnasium pour créer l’environnement de course. Notre environnement comprendra les composants/caractéristiques suivants :

  • env.nS : la forme de l’espace d’observation, qui est (num_rows, num_cols, row_speed, col_speed) dans cet exemple. Le nombre de lignes et de colonnes varie entre les cartes, mais les espaces de vitesse sont constants d’une piste à l’autre. Pour la vitesse de ligne, comme nous ne voulons pas que la voiture revienne à la ligne de départ, les observations de vitesse de ligne sont constituées de [-4, -3, -2, -1, 0] (valeur négative car nous nous attendons à ce que la voiture monte dans la carte), cinq espaces au total ; la vitesse de colonne n’a pas de limite, donc les observations vont de -4 à 4, neuf espaces au total. Par conséquent, la forme de l’espace d’observation dans l’exemple de la piste de course est (num_rows, num_cols, 5, 9).
  • env.nA : le nombre d’actions possibles. Il y a 9 actions possibles dans notre implémentation ; nous créerons également un dictionnaire dans la classe de l’environnement pour mapper l’action entière à la représentation en tuple (row_speed, col_speed) pour contrôler l’agent.
  • env.reset() : la fonction qui ramène la voiture à l’une des cellules de départ lorsque l’épisode se termine ou que la voiture sort de la piste ;
  • env.step(action) : la fonction step permet à l’algorithme d’interagir avec l’environnement en prenant une action et en renvoyant un tuple de (next_state, reward, is_terminated, is_truncated).
  • Fonctions de vérification de l’état : il y a deux fonctions privées qui aident à vérifier si la voiture a quitté la piste ou a franchi la ligne d’arrivée ;
  • Fonctions de rendu : la fonction de rendu est essentielle pour l’environnement personnalisé de mon point de vue ; je vérifie toujours si l’environnement a été correctement construit en rendant l’espace de jeu et les comportements de l’agent, ce qui est plus simple que de simplement regarder les informations de journalisation.

Avec ces caractéristiques à l’esprit, nous pouvons commencer à construire l’environnement de la piste de course.

Vérification de l’environnement

Jusqu’à présent, avec tout ce dont nous avons besoin pour l’environnement de la piste de course prêt, nous pouvons tester/vérifier notre configuration d’environnement.

Tout d’abord, nous rendons le jeu pour vérifier si chaque composant fonctionne correctement :

Figure 2 Les agents conduisant sur les deux pistes avec une politique aléatoire. Source : Gif par l’auteur

Ensuite, nous désactivons l’option de rendu pour que l’environnement s’exécute en arrière-plan afin de vérifier si la trajectoire se termine correctement :

// Piste a|   Observation   | récompense | Terminé | Récompense totale ||  (1, 16, 0, 3)  |    -1    |   Vrai   |     -4984      ||  (2, 16, 0, 2)  |    -1    |   Vrai   |    -23376     ||  (3, 16, 0, 3)  |    -1    |   Vrai   |    -14101     ||  (1, 16, 0, 3)  |    -1    |   Vrai   |    -46467     || Piste b|   Observation    | récompense | Terminé | Récompense totale ||  (1, 31, -2, 2)  |    -1    |   Vrai   |     -3567      ||  (0, 31, -4, 4)  |    -1    |   Vrai   |     -682       ||  (2, 31, -2, 1)  |    -1    |   Vrai   |    -1387      ||  (3, 31, -1, 3)  |    -1    |   Vrai   |    -2336      |

Algorithme de contrôle Monte Carlo hors politique

Avec l’environnement prêt, nous pouvons nous préparer à implémenter l’algorithme de contrôle MC hors politique avec l’algorithme d’échantillonnage d’importance pondéré, comme montré ci-dessous :

Figure 3 Algorithme de contrôle Monte Carlo hors politique. Source : Algorithme écrit en LaTeX par l'auteur.

Les méthodes de Monte Carlo résolvent le problème de l’apprentissage par renforcement en moyennant les rendements d’échantillon. Lors de l’entraînement, la méthode génère une trajectoire basée sur une politique donnée et apprend à partir de la fin de chaque épisode. La différence entre l’apprentissage sur politique et l’apprentissage hors politique est que les méthodes sur politique utilisent une politique pour prendre des décisions et des améliorations, tandis que les méthodes hors politique utilisent des politiques distinctes pour générer les données et améliorer la politique. Selon l’auteur du livre, presque toutes les méthodes hors politique utilisent l’échantillonnage d’importance pour estimer les valeurs attendues sous une distribution donnée des échantillons d’une autre distribution. [2]

Les prochaines sections expliqueront les astuces de la politique souple et de l’échantillonnage d’importance pondéré apparaissant dans l’algorithme ci-dessus, ainsi que l’importance cruciale d’une initialisation appropriée des valeurs pour cette tâche.

Politique cible et politique comportementale

La méthode hors politique de cet algorithme utilise deux politiques :

  • Politique cible : la politique sur laquelle on apprend. Dans cet algorithme, la politique cible est gourmande et déterministe, ce qui signifie que la probabilité de l’action gourmande A au temps t est de 1.0, avec une probabilité de 0.0 pour toutes les autres actions. La politique cible suit l’itération de politique généralisée (GPI) qui s’améliore après chaque étape.
  • Politique comportementale : la politique utilisée pour générer le comportement. La politique comportementale dans cet algorithme est définie comme une politique souple, ce qui signifie que toutes les actions dans un état donné ont une probabilité non nulle. Nous utiliserons la politique ε-greedy comme politique comportementale ici.

Dans une politique souple, la probabilité d’une action est :

Nous devons également renvoyer cette probabilité lors de la génération d’actions à des fins d’échantillonnage d’importance. Le code de la politique comportementale est le suivant :

Échantillonnage d’importance pondéré

Nous estimons la probabilité relative de la trajectoire générée par la politique cible par rapport à la trajectoire de la politique comportementale, et l’équation pour cette probabilité est :

La fonction de valeur pour l’échantillonnage d’importance pondéré est :

Nous pouvons reformuler l’équation pour l’adapter à la tâche épisodique avec la forme des mises à jour progressives :

Il existe de nombreux exemples excellents sur la façon de dériver l’équation ci-dessus, nous ne prendrons donc pas le temps de le dériver à nouveau ici. Mais je tiens également à expliquer les astuces intéressantes concernant les dernières lignes de l’algorithme :

Figure 4 L'astuce dans l'algorithme de contrôle Monte Carlo hors politique. Source : Image de l'auteur

L’astuce repose sur le fait que la politique cible ici est déterministe. Si l’action prise à un pas de temps diffère de celle provenant de la politique cible, alors la probabilité de cette action par rapport à la politique cible est de 0.0; ainsi, toutes les étapes suivantes n’actualisent plus la fonction valeur état-action de la trajectoire. Au contraire, si l’action à ce pas de temps est la même que la politique cible, alors la probabilité est de 1.0, et la mise à jour de la valeur de l’action continue.

Initialisation des poids

L’initialisation adéquate des poids joue un rôle important dans la résolution réussie de cet exercice. Commençons par examiner les récompenses sur les deux pistes à partir d’une politique aléatoire :

// Piste a|   Observation   | récompense | Terminé | Récompense totale ||  (1, 16, 0, 3)  |   -1   |    Vrai    |    -4984     ||  (2, 16, 0, 2)  |   -1   |    Vrai    |    -23376    ||  (3, 16, 0, 3)  |   -1   |    Vrai    |    -14101    ||  (1, 16, 0, 3)  |   -1   |    Vrai    |    -46467    |// Piste b|   Observation    | récompense | Terminé | Récompense totale ||  (1, 31, -2, 2)  |   -1   |    Vrai    |     -3567    ||  (0, 31, -4, 4)  |   -1   |    Vrai    |     -682     ||  (2, 31, -2, 1)  |   -1   |    Vrai    |     -1387    ||  (3, 31, -1, 3)  |   -1   |    Vrai    |     -2336    |

La récompense à chaque étape de temps avant de franchir la ligne d’arrivée est -1. Au début de l’entraînement, la récompense sera fortement négative ; si nous initialisons une valeur d’état-action à 0 ou à des valeurs aléatoires provenant d’une distribution normale, disons, avec une moyenne de 0 et une variance de 1, la valeur pourrait alors être considérée comme trop optimiste, ce qui pourrait prendre très longtemps pour que le programme trouve une politique optimale.

Après plusieurs tests, j’ai trouvé qu’une distribution normale avec une moyenne de -500 et une variance de 1 pourrait être des valeurs efficaces pour une convergence plus rapide ; vous êtes encouragé à essayer d’autres valeurs et vous pouvez certainement trouver une meilleure valeur initiale que celle-ci.

Résolution du problème

Avec toutes les réflexions mentionnées ci-dessus, nous pouvons programmer la fonction de contrôle Monte Carlo hors politique et l’utiliser pour résoudre l’exercice de la piste de course. Nous ajouterons également le défi de l’accélération nulle mentionné dans la description de l’exercice.

Ensuite, nous entraînons les politiques pendant 1 000 000 d’épisodes sans/avec le défi de l’accélération nulle sur les deux pistes et les évaluons avec le code suivant :

En traçant l’enregistrement de l’entraînement, nous constatons que la politique converge vers le 10 000e épisode sur les deux pistes sans tenir compte de l’accélération nulle ; l’ajout de l’accélération nulle rend la convergence plus lente et instable avant le 100 000e épisode, mais elle converge toujours par la suite.

Figure 5 Historique des récompenses d'entraînement de la piste A. Source : Image par l'auteur
Figure 6 Historique des récompenses d'entraînement de la piste B. Source : Image par l'auteur

Résultats

Enfin, nous pouvons demander aux agents de jouer au jeu avec les politiques entraînées, et nous pouvons également tracer les trajectoires possibles pour vérifier davantage la justesse des politiques.

Figure 7 Agents conduisant sur les deux pistes en fonction des politiques entraînées. Source : Gif par l’auteur

Trajets d’exemple pour la piste a :

Figure 8 Trajectoires optimales d'exemple pour la piste A. Source : Image par l'auteur

Trajets d’exemple pour la piste b :

Figure 9 Trajectoires optimales d'exemple pour la piste B. Source : Image par l'auteur

Jusqu’à présent, nous avons résolu l’exercice de la piste de course. Cette implémentation pourrait encore présenter quelques problèmes, et vous êtes invités à les signaler et à discuter d’une meilleure solution dans les commentaires. Merci de votre lecture !

Référence

[1] Conditions d’utilisation de Midjourney : https://docs.midjourney.com/docs/terms-of-service

[2] Sutton, Richard S., et Andrew G. Barto. Apprentissage par renforcement : Une introduction. MIT Press, 2018.

Mon dépôt GitHub de cet exercice : [Lien] ; veuillez consulter la section “exercice”.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

Actualités sur l'IA

Microsoft et OpenAI s'affrontent sur l'intégration de l'IA.

Dans un affrontement de titans de l’IA, Microsoft et OpenAI se retrouvent en désaccord sur l’intégration ...

AI

Découvrez Lamini AI un moteur LLM révolutionnaire permettant aux développeurs de former facilement des modèles de langage de niveau ChatGPT.

Enseigner LLM à partir de zéro est un défi en raison du temps considérable nécessaire pour comprendre pourquoi les mo...

AI

Google IA présente MetNet-3 Révolutionner les prévisions météorologiques avec des modèles de réseau de neurones complets.

La prévision météorologique est à la fois complexe et cruciale dans la recherche météorologique, car les prédictions ...

AI

Avancée dans les simulations informatiques de Monte Carlo

Un nouvel algorithme utilise les simulations informatiques de Monte Carlo de manière plus efficace pour explorer les ...

AI

Signalez le contenu nocif à l'aide de la détection de toxicité d'Amazon Comprehend

Les communautés en ligne stimulent la participation des utilisateurs dans des industries telles que les jeux vidéo, l...

AI

Qu'est-ce que l'hyperpersonnalisation de l'IA ? Avantages, études de cas et préoccupations éthiques

Explorez le concept de l'hyper-personnalisation de l'IA, ses mécanismes et études de cas. Découvrez ses avantages et ...