Le Blog Amazon Web Services

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.

Pour en savoir plus sur l’exemple d’application object tracker, veuillez suivre le workshop How to train a robot using reinforcement learning.

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

Nous pouvons optimiser la logique du code calculant le reward pour que l’entrainement de l’agent soit plus rapide et précis. Par exemple, nous pouvons essayer de donner un reward négatif si le TurtleBot Waffle Pi s’éloigne du TurtleBot stationnaire. Nous pouvons également essayer d’utiliser des techniques de computer vision, telles que la détection d’objets, pour trouver le TurtleBot stationnaire, puis calculer la distance entre les deux TurtleBots.

Les actions que le robot peut prendre sont définies dans la classe TurtleBot3ObjectTrackerAndFollowerDiscreteEnv vers la fin du fichier object_tracker_env.py. Les actions sont représentées par un nombre oscillant entre 0 à 4, chaque action est une commande de direction et d’accélération du TurtleBot. Par exemple, lorsque l’action est 0, le TurtleBot doit tourner à gauche à une vitesse de 0,1 mètre par seconde.

# 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

2.2 Utilisation du modèle entrainé

Le code permet l’entrainement d’un modèle TensorFlow. Lors du déploiement du modèle sur TurtleBot Waffle Pi, nous devons télécharger le modèle stocké dans Amazon S3 et le transférer sur le Waffle Pi. L’espace de travail robot_ws est utilisé pour déployer le modèle sur Waffle Pi. Le fichier Python download_model dans l’espace du travail robot_ws télécharge le modèle entrainé depuis Amazon S3. Le code du fichier Python inference_worker charge le modèle dans une session TensorFlow et demande au Waffle Pi d’agir (accélérer, tourner) en fonction des images renvoyées par sa caméra.

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

2.3 Exécution de l’application

ROS utilise des fichiers de lancement pour démarrer l’application. Le fichier local_training.launch contient des détails sur les nœuds (processus) que nous souhaitons lancer lors du démarrage. L’élément node (nœud) ci-dessous indique au runtime ROS de lancer le script shell run_local_rl_agent.sh au démarrage.

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

Dans le script run_local_rl_agent.sh, ROS exécute le script Python single_machine_training_worker.

#!/usr/bin/env bash
…

python3 -m markov.single_machine_training_worker

Le fichier roboMakerSettings.json est spécifique à AWS Robomaker. Il définit les ressources AWS et les règles à utiliser pour démarrer l’application. Par exemple, il définit le fichier pour le LaunchFile parameter dans la configuration de simulation que la plateforme ROS lance à l’exécution.

Les variables d’environnement peuvent être passées dans ce fichier de configuration. Par exemple, nous pouvons passer la variable d’environnement MARKOV_PRESET_FILE qui indique où le code de l’application principale est localisé. L’application principale est chargée au moment de l’exécution en utilisant cette variable. Le fichier roboMakerSettings.json permet aussi de créer, regrouper et exécuter automatiquement des tâches de simulation. Cette fonctionnalité nous évite d’effectuer ces étapes manuellement lorsque nous devons faire une modification.

"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>"}},

3. Synthèse & Conclusion

Nous espérons que ce blog vous a aider à appréhender comment le reninforcement learning fonctionne et comment l’appliquer au contexte de la robotique au travers de l’exemple du project ‘Object Tracker’. Nous avons parcouru les grandes étapes permettant de développer et de déployer facilement des techniques de machine learning, telles que RL, dans AWS Robomaker. Pour en savoir plus sur l’exemple d’application object tracker, veuillez vous reporter au workshop How to train a robot using reinforcement learning.

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