Published by et

Il y a 6 mois -

Temps de lecture 11 minutes

Reinforcement learning, les outils : RL Coach

 

Introduction

Le reinforcement learning (apprentissage par renforcement) est une méthode d’apprentissage machine permettant de réaliser des tâches complexes de façon autonome. Ces algorithmes ont un fort potentiel mais s’avèrent parfois très longs à construire et paramétrer. Avant de démarrer un projet utilisant des algorithmes de reinforcement learning, il est donc utile de s’entourer d’outils efficaces.

RL coach fait partie des outils qui vous permettront de gagner du temps de développement pour l’implémentation de solutions de reinforcement learning dans vos projets. Ce framework Python propose un ensemble d’algorithmes et des fonctionnalités permettant de les entraîner sur des environnements classiques ou personnalisés. GYM peut être est utilisé comme framework pour empaqueter les environnements d’apprentissage, ce qui est pratique car il est largement répandu et bien documenté.

Le framework RL coach, propriété de Intel AI Lab, est relativement mature (version 1.0.0 délivrée à l’été 2019) et utilisé par des acteurs importants de la data comme AWS avec son projet pédagogique de mini-voiture autonome DeepRacer. Dans cet article nous présenterons les principaux concepts du framework et nous détaillerons le code nécessaire pour lancer un apprentissage de deep reinforcement learning grâce à RL coach.

Pour plus de détails sur le fonctionnement du deep reinforcement learning vous pouvez lire un article d’introduction et un article plus approfondi sur ce sujet.

 

RL coach, les mécanismes du framework

Dans sa forme la plus simple, RL coach facilite la réalisation d’expériences de reinforcement learning et permet d’entraîner un agent sur un environnement. L’agent est un algorithme de reinforcement learning et l’environnement est la représentation du problème. L’environnement change d’état après chaque action soumise par l’agent, par exemple aux échecs, lorsqu’un joueur (agent) déplace une pièce, l’environnement (le plateau de jeu) change d’état (disposition des pièces). L’objectif de cet entraînement est d’apprendre à l’agent, interagissant avec l’environnement, à choisir des actions maximisant des récompenses quantitatives.

Schéma issu de la documentation RL coach

Schéma issu de la documentation RL coach

Pour coordonner cet ensemble, RL coach dispose de plusieurs APIs :

  • Agent, ensemble d’algorithmes et paramètres associés ;
  • Environment, interface permettant de plugger la représentation de notre problème sous forme d’environnement ;
  • GraphManager, pièce maîtresse permettant d’assembler les agents et les environnements ;
  • Preset, design pattern pour simplifier la reproductibilité des expériences.

Pour mieux comprendre les fonctionnalités de chacune de ces APIs, la suite de l’article les détaillera une par une en commençant par les Agents.

Agent, les algorithmes de Reinforcement Learning

L’agent est un composant du framework RL coach qui comporte plusieurs éléments clefs :

  • des fonctions de base, notamment lui permettant d’agir dans l’environnement dans lequel il est placé ;
  • un algorithme d’apprentissage ;
  • une politique d’action qui évolue au cours du temps.

Il existe une classe de paramètres pour chaque algorithme prédéfini dans la librairie, par exemple pour instancier un agent avec comme algorithme un Deep Q Network (DQN) on utilise la classe DQNAgentParameters. Cet objet est ensuite passé en paramètre du GraphManager.

Les paramètres d’apprentissage de l’agent peuvent être ajustés avant de l’intégrer au GraphManager. Ils dépendent de l’algorithme qui est utilisé, mais dans la plupart des cas on peut a minima faire varier le taux d’apprentissage, l’évolution du paramètre d’exploration et le facteur de discount.

Il existe de nombreux algorithmes disponibles dans la librairie :

Schéma issu de la documentation RL coach

Exemple de configuration d’un agent de type DQN

# Algorithme DQN
from rl_coach.agents.dqn_agent import DQNAgentParameters
from rl_coach.schedules import LinearSchedule


agent_params = DQNAgentParameters()
# Taux d’apprentissage de 25x10-5
agent_params.network_wrappers['main'].learning_rate = 0.00025
# Discount
agent_params.algorithm.discount = 0.99
# Politique d'exploration
agent_params.exploration.epsilon_schedule = LinearSchedule(1, 0.01, 1000000)

Pour la liste exhaustive des agents disponibles et de leurs paramètres : Agents

Environnement, encapsuler sa problématique

L’API Environment de RL coach facilite l’intégration du problème avec le framework qui peut prendre la forme :

  • d’un simulateur ;
  • d’une API Rest, renvoyant vers un problème réel ;
  • ou de tout autre composant pouvant représenter le problème.

D’emblée, RL coach propose un ensemble d’environnements pré intégrés, ainsi qu’une interface pour se plugger à des environnements GYM.

Comme pour les agents, l’environnement se déclare via des classes de Parameters. Pour créer un environnement GYM, il faut utiliser la classe GymEnvironmentParameters qui sera ensuite passée en paramètre du GraphManager.

Exemple de configuration d’un environnement GYM

from rl_coach.environments.gym_environment import GymEnvironmentParameters


# Soit utiliser un environnement GYM pré-enregistré via register
env_params = GymEnvironmentParameters(level='MyGymEnv-v0')
# Soit renseigner un chemin vers l'environnement 
#env_params = GymEnvironmentParameters(level='mypackage.MyGymEnv')
# Pour passer des paramètres supplémentaires lors de l'instanciation de l'environnement GYM
#env_params.additional_simulator_parameters = {}

GraphManager, orchestrer son entraînement

Le GraphManager contient l’ensemble des agents et environnements d’une expérience donnée et gère leurs boucles d’apprentissage.

Dans le cas le plus simple, un graphe est constitué d’un agent et d’un environnement. Mais il est possible de créer des graphes complexes, comme dans le cadre de Hierachical Reinforcement Learning (HRL).

Pour répondre à ces différents besoins, RL coach propose des graphes pré conçus :

  • BasicRLGraphManager, pour faire un apprentissage entre un agent et un environnement ;
  • BatchRLGraphManager, pour réaliser un apprentissage par batch sans environnement ;
  • HRLGraphManager, un graphe de Hierachical Reinforcement Learning.

Si ces classes ne sont pas adaptées au problème considéré, il est possible de créer un GraphManager personnalisé.

Pour créer son graphe, le GraphManager se repose sur des LevelManager. Chaque LevelManager est composé d’un ou plusieurs agents qui interagissent avec un environnement. Cet environnement est :

  • soit un environnement comme exposé précédemment ;
  • soit un autre LevelManager.

Dans le cas de graphes simples, un seul LevelManager est utilisé avec un agent et un environnement, mais dans des cas plus complexes, les LevelManager sont empilés et chaque agent du LevelManager précédent interagit avec le LevelManager suivant jusqu’à arriver à la couche finale qui comprend l’environnement.

Une fois le graphe créé, celui-ci va enchaîner 3 étapes clés pour améliorer l’agent.

  • Heatup, l’agent va agir sur l’environnement de façon aléatoire afin de commencer à remplir sa mémoire. Sans cette étape, l’agent n’ayant pas de données, celui-ci ne pourra pas s’entraîner.
  • Train and act, au cours de cette étape, l’agent va explorer l’environnement à travers diverses actions, et apprendra de ses erreurs grâce aux retours de l’environnement sous forme de reward (récompenses numériques, par exemple le score lors d’une partie de Space Invaders).
  • Evaluate, cette étape consiste à évaluer l’apprentissage de l’agent, elle est déclenchée à intervalles réguliers et permet de suivre l’efficacité de l’entraînement.

Schéma issu de la documentation RL coach

La durée de chacune de ces étapes se configure à travers la classe ScheduleParameters. Ces durées peuvent être exprimées en épisodes ou bien en steps avant d’être passées au GraphManager.

L’entraînement d’un agent est décomposé en épisodes. Chaque épisode représente une expérience complète qui prend fin pour l’une des trois raisons suivantes : un
time-out a été atteint, l’agent a perdu, l’agent a achevé la tâche assignée.

Par exemple un épisode peut être :

  • une partie d’un jeu (échecs, jeu vidéo, etc.) qui prend fin lorsque l’agent gagne ou perd ;
  • une tentative de sortie d’un labyrinthe qui prend fin lorsque l’agent sort ou lorsqu’il a passé trop de temps à essayer de sortir ;
  • etc.

https://blog.engineering.publicissapient.fr/2020/02/12/reinforcement-learning-introduction/

Exemple de configuration d’un cycle d’apprentissage

from rl_coach.graph_managers.graph_manager import ScheduleParameters
from rl_coach.core_types import EnvironmentSteps, EnvironmentEpisodes


schedule_params = ScheduleParameters()
# 500 000 steps d'améliorations
schedule_params.improve_steps = EnvironmentSteps(500000)
# Incluant 50 000 steps de préparation
schedule_params.heatup_steps = EnvironmentSteps(50000)
# Toutes les 250 000 steps, une évaluation est déclenchée
schedule_params.steps_between_evaluation_periods = EnvironmentSteps(250000)
# Chaque évaluation a une durée de 135 000 steps
schedule_params.evaluation_steps = EnvironmentSteps(135000)
# Ou bien on peut également définir la durée en épisodes
#schedule_params.evaluation_steps = EnvironmentEpisodes(100)

Pour instancier un GraphManager on utilise les objets définis précédemment (agent, environment & schedule) que l’on passe à la classe représentant notre GraphManager.

Exemple de création d’un BasicRLGraphManager

from rl_coach.graph_managers.basic_rl_graph_manager import BasicRLGraphManager


graph_manager = BasicRLGraphManager(agent_params=agent_params, 
									env_params=env_params,
                                    schedule_params=schedule_params)

Presets, reproduire ses expériences

Un Preset n’est pas une ressource du framework, mais un design pattern ayant pour objectif de regrouper la définition d’une expérience et de ses paramètres dans un même script python pour ainsi simplifier la reproductibilité de celle-ci.

RL coach inclut plusieurs presets pré définis qu’il suffit de lancer via une ligne de commande pour réaliser un entraînement et obtenir vos premiers résultats.

Par exemple la ligne de commande suivante permet de réaliser et afficher un entraînement du jeu Atari Breakout.

# -p, choix du preset à entraîner
# -lvl, choix du niveau
# -r, affichage le rendu (par exemple: la vidéo du jeu)
coach -p Atari_DQN -lvl breakout -r

 

Pour créer son propre preset, il faut créer un script python reprenant l’ensemble des éléments présentés au cours de l’article (les paramètres de l’agent, de l’environnement et du graphe) correspondant à votre expérience et se terminant par la création du GraphManager assigné à la variable graph_manager.

mypreset.py
from rl_coach.agents.ddqn_agent import DDQNAgentParameters
from rl_coach.core_types import EnvironmentSteps
from rl_coach.environments.gym_environment import Atari
from rl_coach.graph_managers.basic_rl_graph_manager import BasicRLGraphManager
from rl_coach.graph_managers.graph_manager import ScheduleParameters


#########
# Agent #
#########
agent_params = DDQNAgentParameters()
agent_params.network_wrappers['main'].learning_rate = 0.00025

###############
# Environment #
###############
env_params = Atari(level='Breakout-v0')

####################
# Graph Scheduling #
####################
schedule_params = ScheduleParameters()
schedule_params.improve_steps = EnvironmentSteps(500000)
schedule_params.heatup_steps = EnvironmentSteps(50000)
schedule_params.steps_between_evaluation_periods = EnvironmentSteps(250000)
schedule_params.evaluation_steps = EnvironmentSteps(135000)

########################
# Create Graph Manager #
########################
# BasicRLGraphManager, créé un uniquement LevelManager entre l'Agent et l'Environnement
graph_manager = BasicRLGraphManager(agent_params=agent_params, 
									env_params=env_params,
                                    schedule_params=schedule_params)

 

Pour exécuter ce preset, il est possible de le faire en ligne de commande

# -e, nom de l'expérience
# -ep, chemin de sauvegarde des logs et checkpoints de votre exécution
# RL coach va créer un dossier ./<ep>/<e>/<start_date> pour sauvegarder les informations de l'exécution
# -s, temps en secondes entre chaque checkpoints
# coach --help, pour la liste détaillée des options
coach -p ./mypreset.py -e mypreset -ep ./experiments/ -s 120

 

Mais il est également possible de l’exécuter depuis du code.

from rl_coach.base_parameters import TaskParameters
from rl_coach import logger
from mypreset import graph_manager


###################
# Task parameters #
###################
experiment_path = logger.get_experiment_path('mypreset', './experiments/')
task_parameters = TaskParameters(experiment_path=experiment_path, checkpoint_save_secs=120)
graph_manager.create_graph(task_parameters)

# On lance l'entrainement
graph_manager.improve()

Récupérer les données d’entraînement

Les données d’entraînement sont enregistrées dans le dossier passé en paramètre du TaskParameters, elles prennent la forme d’un fichier csv qui peut être récupéré ensuite, par exemple dans un notebook, pour procéder à des analyses de l’évolution de l’apprentissage et des performances de l’agent.

Conclusion

Nous avons vu comment implémenter rapidement une solution de reinforcement learning grâce à RL coach. L’utilisation de cet outil ne réduit pas le temps de développement d’un simulateur ou de l’API interface de notre problème réel. Il faut également prévoir du temps pour le tuning des paramètres et le choix de l’algorithme pertinent pour réaliser la tâche à laquelle on s’attaque. En revanche, ce framework nous a permis de gagner un temps précieux de développement des algorithmes et d’organisation des entraînements.

RL coach dispose de nombreuses fonctionnalités plus avancées, qui ne sont pas exposées dans cet article, permettant par exemple de faire des entraînements en batch (sans simulateur), réaliser des tâches complexes grâce au Hierachical Reinforcement Learning (HRL), de faire du scaling horizontal ou encore de l’imitation learning. RL coach dispose également de fonctionnalités très appréciées, telles que la visualisation des résultats, validation des presets, etc.

Si vous êtes curieux, n’hésitez pas à lire la documentation RL coach. Il vous faudra probablement plonger dans le code (repository github), car la documentation de RL coach n’est pas (encore ?) très riche.

Published by et

Commentaire

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nous recrutons

Être un Sapient, c'est faire partie d'un groupe de passionnés ; C'est l'opportunité de travailler et de partager avec des pairs parmi les plus talentueux.