Introduction au Reinforcement Learning (apprentissage renforcé) avec AWS RoboMaker

Dans les environnements impliquant de la robotique il est souvent nécessaire de répondre à des activités constituées d’un enchaînement complexe de comportements. Par exemple, considérons un robot en charge de suivre un autre objet. Même si l’objectif du robot est simple (le robot doit s’approcher le plus possible de l’objet), il est difficile de créer la logique qui permet d’accomplir cette tâche. Le Reinforcement Learning (RL) “L’apprentissage renforcé” est une nouvelle technique de Machine Learning qui aide à développer des solutions à ce type de problème.

Ce post est une introduction au RL, il explique comment utiliser AWS RoboMaker pour développer une application qui apprend à un TurtleBot Waffle Pi à suivre un TurtleBot Burger (Robots programmables). L’exemple d’application utilisé dans ce post, objet tracker (suivi d’objet), utilise les librairies Intel Reinforcement Learning Coach et OpenAI’s Gym. Coach library est une plateforme de RL, facile à utiliser et écrite en Python. OpenAI’s Gym est un toolkit, “boîte à outils”, utilisé pour désigner et développer des agents RL pouvant prendre des décisions de manière autonome.

1. Reinforcement Learning

Dans le cadre du Reinforcement Learning, l’entraînement présente deux composants :

• Un agent qui détermine quelles actions le robot doit faire,
• L’environnement qui combine les actions avec les mouvements et les contraintes physiques du robot afin de déterminer l’état suivant du robot.

L’agent utilise un modèle Machine Learning afin de déterminer l’action à exécuter. Pour déterminer l’état actuel du robot, le modèle mappe les actions possibles afin ensuite de tenter de deviner la meilleure des actions possibles (dans Reinforcement Learning, cette étape est connue comme reward “récompense”). A l’état initial, le modèle n’a aucune connaissance des actions les plus pertinentes et les décisions prises sont généralement fausses. En revanche, au fur et à mesure que l’agent apprend à maximiser les récompenses, le modèle s’améliore et les actions prises deviennent de plus en plus précises. L’illustration suivante présente une synthèse de ce fonctionnement.

Dans l’exemple d’application de détection et suivi d’objet, le RL fonctionne de la manière suivante :

1. Le robot est dans son état initial, l’agent tente de déviner la meilleure action à prendre.,
2. L’environnement calcule le nouvel état et la récompense/reward associée. Le reward est transmit à l’agent et lui permet de savoir la pertinence de l’action prise précédemment,
3. L’agent et l’environnement interagissent ensemble, ils décident les actions à prendre et les états du robot. L’agent obtient des rewards (récompenses) pour les bonnes actions ou des punishments (punitions) pour les mauvaises actions,
4. Lorsque un cycle d’entraînement se termine, le robot a la totalité de rewards indiquant à quelle mesure il a réussi à réaliser sa tâche,
5. En prenant un grand nombre d’actions, l’agent apprend petit à petit quelles actions sont les meilleures (celles qui ont le plus grand reward), et favorise celles-ci lors de la prise de décision.

2. Développement d’une application RL avec AWS RoboMaker

Nous utilisons le code de l’application “Object Tracker” dont le code source se situe dans Github.

2.1 Entraînement du robot

Les principaux composants de l’application sont les suivants :

• Simulation workspace (Espace de travail de simulation) – cet espace de travail contient le code qui définit l’agent RL et l’environnement,
• Robot workspace (Espace de travail du robot) – Après avoir entrainé le modèle de RL, le robot workspace est créé et le modèle est déployé sur un vrai robot,
• Robot Operation System (ROS) – Plateforme permettant de développer des logiciels pour la robotique. ROS fournit des outils permettant d’interagir de manière simple avec la caméra et les moteurs du robot.
• Gazebo – Simulateur qui calcule le prochain état du robot en function de son état actuel et l’action à prendre. Gazebo simule aussi les images prises avec la camera du robot qui sont renvoyées à l’agent RL.
• Intel Coach Library – Plateforme Python RL utilisée pour entrainer le modèle qui conduit automatiquement le TurtleBot.
• Open AI Gym – Toolkit (Boîte à outils) utilisé pour développer et designer l’agent RL qui prend des décisions autonomes sur la rotation, contrôle de vitesse, etc…
• TensorFlow – Librairie de machine learning créé par Google qui stocke et entraine le modèle utilisé par l’agent pour prendre des décisions.

Dans votre environnement de développement, rendez vous dans le dossier simulation_ws. Le code dans l’espace de travail de simulation entraine le modèle RL. Le fichier python appelé single_machine_training_worker.py est le point d’entrée de l’application. Dans ce fichier, les variables d’environnement comme MARKOV_PRESET_FILE sont passées à l’application lors de l’exécution du code. L’application commence par créer un nouveau modèle TensorFlow et le stocke dans un compartiment Amazon Simple Storage Service (Amazon S3). S’il existe déjà un modèle entraîné dans le compartiment Amazon S3, l’application utilise ce modèle au lieu d’en créer un nouveau. De cette façon, il n’est pas nécessaire de repartir de zéro chaque fois que nous redémarrons un entraînement. Tous ces paramètres sont ensuite passés pour créer un objet Graph Manager. Le Graph Manager est responsable de l’entraînement du modèle. Enfin, l’entraîment commence lorsque la méthode d’amélioration du Graph Manager est appelée.

Le fichier object_tracker.py contient les hyperparamètres de configuration de l’environnement RL. L’application utilise une stratégie d’apprentissage appelée ClipPedPPO (Proximal Policy Optimization). PPO est un algorithme recommandé par Open AI comme un bon point de départ pour faire du RL. Il a moins de paramètres que les autres algorithmes RL et de bonnes performances globales. OpenAI Gym est configuré dans ce fichier avec la personnalisation RoboMaker-ObjectTraker-v0 :

env_params = GymVectorEnvironment()
…
env_params.level = 'RoboMaker-ObjectTracker-v0'

La classe TurtleBot3ObjectTrackerAndFollowerDiscreteEnv contient d’autres éléments nécessaires pour l’exécution de l’apprentissage par renforcement, telles que des instructions sur la façon de réinitialiser l’environnement lorsque le robot termine un cycle d’entraînement, la fonction de reward et l’ensemble des actions que le robot peut faire.

L’application utilise également une image capturée par la caméra comme état du robot. Afin d’obtenir une performance optimale, le monde réel doit être aussi similaire que possible au monde simulé dans Gazebo. Par exemple, le monde simulé actuel est gris foncé. Lorsque le modèle est déployé sur un TurtleBot Waffle Pi, il doit se déplacer dans un environnement similaire. A cet effet, lors de la capture des informations pour l’entraînement du modèle, nous pouvons prendre des photos des murs de la pièce où le TurtleBot Waffle Pi va se déplacer et les importer comme de textures pour simuler autant que possible le monde réel.

Dans cette application, le Waffle Pi utilise sa caméra pour se déplacer. Pour chaque action qu’il fait, il prend une image correspond à son état actuel. Le code correspondant à cette étape est défini dans la méthode infer_reward_state(self) de la classe TurtleBot3ObjectTrackerAndFollowerEnv.

image = Image.frombytes('RGB', (self.image.width, self.image.height),
                                self.image.data,'raw', 'BGR', 0, 1)
image = image.resize(TRAINING_IMAGE_SIZE)
state = np.array(image)

Le but est alors que le TurtleBot Waffle Pi puisse attendre le TurtleBot Burger stationnaire. Pour chaque déplacement correct que le TurtleBot Waffle PI fait vers le TurtleBot Burger stationnaire, il reçoit une recompense/reward. Le code qui calcule le reward est définie dans la méthode infer_reward_state(self) de la classe TurtleBot3ObjectTrackerAndFollowerEnv. Si la distance actuelle entre les TurtleBots est inférieure à celle de l’état précédent, le TurtleBot Waffle Pi se rapproche du TurtleBot Burger stationnaire, donc il obtient un reward. Plus le TurtleBot Waffle Pi se rapproche du but, plus le reward est important. Si la distance est supérieure à 5 mètres, le TurtleBot Waffle Pi est trop loin du TurtleBot Burger stationnaire, et l’agent termine le cycle et commence un nouveau.

distance_of_turtlebot = math.sqrt((x - self.burger_x) * (x - self.burger_x) + (y - self.burger_y) * (y - self.burger_y))

…
if distance_of_turtlebot < self.last_distance_of_turtlebot:
            self.last_distance_of_turtlebot = distance_of_turtlebot
            reward = REWARD_CONSTANT / (distance_of_turtlebot * distance_of_turtlebot)if distance_of_turtlebot < 0.2:
                done = True 
       if distance_of_turtlebot > 5:
            done = True

# Convert discrete to continuous
if action == 0:  # move left
      steering = 0.6
      throttle = 0.1
elif action == 1:  # move right
      steering = -0.6
      throttle = 0.1
elif action == 2:  # straight
      steering = 0
      throttle = 0.1
elif action == 3:  # move left
      steering = 0.3
      throttle = 0.1
elif action == 4:  # move right
      steering = -0.3
      throttle = 0.1

self.graph = self.load_graph()
self.session = tf.Session(graph=self.graph, config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True))

<launch>
…
    <node name="agent" pkg="object_tracker_simulation" type="run_local_rl_agent.sh" output="screen" required="true"/></launch>

#!/usr/bin/env bash
…

python3 -m markov.single_machine_training_worker

"type": "simulation","cfg": {"simulationApp": {"name": "RoboMakerObjectTrackerSimulation",
          …
          "launchConfig": {"packageName": "object_tracker_simulation","launchFile": "local_training.launch","environmentVariables": {"MARKOV_PRESET_FILE": "object_tracker.py","MODEL_S3_BUCKET": "<bucket name of your trained model>","MODEL_S3_PREFIX": "model-store","ROS_AWS_REGION": "<the AWS Region of your S3 model bucket>"}},

A propos des auteurs:

• Tristan Li, Solution Architect AWS,
• Wayne Davis, Solution Architect AWS
• Robert Meagher, Software development engineer pour le service AWS RoboMaker
• Traduit de l’anglais par Felix Guglielmi Miguel, Solutions Architect accompagnant ses clients français dans leur adoption du Cloud AWS, LinkedIn.

Source