TD3: Apprentissage par renforcement profond

Télécharger l'archive td3.zip

Installation

Assurez vous d'avoir installé les dépendances suivantes :

pip install gymnasium[toy-text,classic-control] matplotlib torch

Hyperparamètres

Les algorithmes que nous allons implémenter (DQN et DDPG) reposent sur le choix de certains hyperparamètres. Voici une liste de valeurs indicatives que vous pouvez utiliser:

ParamètreDescriptionValeur
max_buffer_sizeTaille maximale du replay buffer. (les données les plus anciennes sont supprimées)1000000
learning_startsTaille du buffer à atteindre pour que l'entraînement ne commence1000
batch_sizeTaille des batchs d'entraînement512
gammaFacteur d'escompte \(\gamma\)0.99
update_frequencyFréquence de mise à jour de l'agent (en nombre d'actions)256
gradient_stepsNombre de pas de gradient (learn) effectués à chaque mise à jour de l'agent128
train_stepsNombre d'étapes d'entraînement100000
epsilonFacteur d'exploration \(\epsilon\)0.03

Afin d'encourager l'exploration au début de l'entraînement, il est courant de commencer avec une valeur plus élevée du paramètre \(\epsilon\), et de la diminier progressivement. On appel cela un programme (en anglais schedule) d'exploration. Voici un exemple:

def exploration_schedule(step):
    """
    L'exploration commence à 1 et diminue linéairement jusqu'à 0.03
    """
    return max(0.03, 1 - step / 10_000)

Algorithme DQN

Dans cette partie, nous allons faire fonctionner l'algorithme DQN. Ce dernier est adapté aux problèmes où l'espace d'état est continu et l'espace d'action discret. Nous testerons donc cet algorithme sur l'environnement CartPole-v1.

Compréhension

L'agent DQN est déjà implémenté dans dqn.py, parcourez son code. Vous aurez essentiellement besoin des fonctions:

  • load, save: pour charger et sauvegarder le modèle,
  • learn, pour entraîner le modèle. Cette fonction prend en paramètre une liste de transitions qui sont des tuples de la forme (state, action, reward, next_state, done).,
    • state et next_state sont des états de l'environnement (avant et après la transition),
    • action est l'action effectuée,
    • reward est la récompense reçue,
    • done est un booléen indiquant si l'épisode est terminé.
    • Ces données sont fournies par l'environnement, lors de l'appel à la méthode step.
  • predict, pour sélectionner une action à effectuer.

Boucle d'entraînement

En vous inspirant de la structure du TD2, écrivez un fichier learn.py qui:

  • Charge un environnement,
  • Crée un agent DQN,

Dans la boucle d'entraînement, qui se déroulera sur train_steps étapes (appel à step):

  • Sélectionne des actions à effectuer, en utilisant agent.predict, ou en sélectionnant une action aléatoire avec une probabilité \(\epsilon\),
  • Réinitialise l'environnement lorsque l'épisode est terminé,
  • Enregistre les transitions dans une liste (le replay buffer),
  • Si le buffer contient au moins learning_starts transitions, entraîne l'agent sur un batch de transitions tirées aléatoirement du replay buffer.
  • Sauvegarde l'agent.
  • Affiche le retour moyen sur les 10 derniers épisodes.

Vous pourrez alors tester votre entraînement avec DQN.

Visualisation

Écrivez désormais view.py, qui:

  • Charge un environnement en activant la visualisation (render_mode="human"),
  • Charge un agent DQN sauvegardé,

Dans une boucle infinie, on réalisera des épisodes de la manière suivante:

  • L'environnement est réinitialisé,
  • Les actions fournies par agent.predict sont exécutées,
  • Lorsque l'épisode se termine, on affichera le returns (la reward cumulée) de l'épisode.

Courbe d'apprentissage

À l'aide de live_plot.py, affichez la courbe d'apprentissage de votre agent DQN. Voici un exemple de courbe d'apprentissage:

Algorithme DDPG

Dans cette partie, nous allons faire fonctionner l'algorithme DDPG. Ce dernier supporte les espaces d'états et d'actions continus. Nous testerons donc cet algorithme sur l'environnement Pendulum-v1.

Compréhension

L'algorithme DDPG est déjà implémenté dans ddpg.py, parcourez son code.

Mise en place

Mettez à jour learn.py et view.py pour pouvoir utiliser l'algorithme DDPG. Vous pourrez par exemple utiliser argparse pour permettre à l'utilisateur de sélectionner l'environnement et l'algorithme à utiliser.

Test

Testez votre code sur l'environnement Pendulum-v1, voici un exemple de résultat: