AWS RoboMaker para reinforcement learning

La robótica a menudo implica entrenar secuencias complejas de comportamientos. Por ejemplo, considere un robot diseñado para seguir o rastrear otro objeto.

Aunque el objetivo es fácil de describir (cuanto más cerca está el robot del objeto, mejor). Crear la lógica que cumple la tarea es mucho más difícil.

El aprendizaje por refuerzo (RL). Una técnica de aprendizaje automático emergente, puede ayudar a desarrollar soluciones para exactamente este tipo de problemas.

Esta publicación es una introducción a RL y explica cómo usamos AWS RoboMaker para desarrollar una aplicación que entrena un TurtleBot Waffle Pi para rastrear y moverse hacia una hamburguesa TurtleBot.

La aplicación de muestra de AWS RoboMaker, el rastreador de objetos. Utiliza el Intel Reinforcement Learning Coach y las bibliotecas de OpenAI Gym.

La Coach library es un framework RL fácil de usar escrito en Python. Se usó para entrenar el modelo que utiliza el TurtleBot para la conducción autónoma. OpenAI’s Gym es un conjunto de herramientas que se usó para desarrollar y diseñar agentes RL que toman decisiones autónomas.

Si desea probar el uso de la aplicación de seguimiento de objetos de muestra, consulte Cómo entrenar un robot usando aprendizaje por refuerzo .

Descripción general de RL

En RL, la capacitación tiene dos componentes:

• Un agente, que decide qué acciones debe realizar el robot
• El entorno, que combina la acción con la dinámica del robot y la física del mundo para determinar el próximo estado del robot

En pocas palabras, el agente usa un modelo para decidir una acción.

Para el estado actual del robot, el modelo mapea posibles acciones para adivinar qué tan buena podría ser cada acción (en el aprendizaje de refuerzo, esto se conoce como una recompensa).

Inicialmente, el modelo no tiene idea de qué acciones son mejores y sus suposiciones suelen ser erróneas. A medida que el agente aprende a maximizar las recompensas potenciales que puede recibir.

El modelo mejora y sus suposiciones sobre qué acciones son buenas pueden mejorar. El siguiente gráfico muestra cómo funciona esto.

En la aplicación de seguimiento de objetos de muestra, RL funciona así:

1. Con el robot en una posición inicial, el agente adivina la mejor acción a tomar. [19659009] El entorno calcula el nuevo estado y una recompensa. La recompensa permite al agente saber qué tan buena fue su última acción.
2. El agente y el entorno interactúan, decidiendo sobre nuevas acciones y calculando nuevos estados. El agente acumula recompensas por sus buenas acciones y los castigos por sus malas acciones.
3. Cuando termina una ronda de entrenamiento, el robot tiene una recompensa total que le dice qué tan bien se desempeñó en general.
4. Al tomar muchas acciones, el agente aprende lentamente qué acciones son mejores (tiene una mayor recompensa) y las favorece cuando toma decisiones.

Creación de una aplicación de RL con AWS RoboMaker

Ahora, veamos el código fuente del objeto de seguimiento para ver cómo se implementa la aplicación . Recomendamos mirar el código mientras lees. Si aún no ha ejecutado la aplicación de ejemplo, puede descargar el código desde Github repo .

Capacitar al robot

La aplicación tiene los siguientes componentes principales:

• Espacio de trabajo de simulación: Este el espacio de trabajo contiene el código que define el agente y el entorno de RL.
• Espacio de trabajo del robot: después de entrenar el modelo RL, el espacio de trabajo del robot se construye y el modelo se implementa en un robot real.
• Sistema de operación del robot (ROS) – El marco de desarrollo para aplicaciones de robot. ROS proporciona una abstracción simple para interactuar con la cámara y los motores del robot.
• Gazebo – Un simulador que toma el estado y la acción del robot y calcula su próximo estado. Gazebo también simula las imágenes de la cámara que se transmiten al agente de RL.
• Biblioteca Intel Coach – Un marco de Python RL que se usó para entrenar el modelo que utiliza el TurtleBot para conducir.
• Open AI Gym – Un juego de herramientas utilizado para desarrollar y diseñar el agente de RL que toma decisiones autónomas sobre giros, control de velocidad, etc.
• TensorFlow – Una biblioteca de aprendizaje de máquina escrita por Google que almacena y entrena el modelo que el agente usa para tomar decisiones.

En el entorno de desarrollo, vaya a la carpeta simulation_ws . El código en el espacio de trabajo de simulación entrena el modelo RL. El archivo de Python llamado single_machine_training_worker.py es el punto de entrada de la aplicación.

En este archivo, las variables de entorno, como MARKOV_PRESET_FILE se pasan a la aplicación para que se ejecute. La aplicación comienza creando un nuevo modelo TensorFlow y almacenándolo en un depósito de Amazon Simple Storage Service (Amazon S3).

Si ya hay un modelo capacitado en Amazon S3, la aplicación usa ese modelo en su lugar. De esa manera, no tiene que comenzar desde cero cada vez que reinicie el entrenamiento.

Todos estos parámetros se pasan para crear un objeto de administrador de gráficos. El administrador de gráficos es responsable de entrenar el modelo. Finalmente, el entrenamiento comienza cuando se llama al método de mejora del objeto del administrador de gráficos.

El archivo object_tracker.py contiene los hiperparámetros para configurar el entorno RL. La aplicación utiliza una estrategia de aprendizaje conocida como ClippedPPO (Proximal Policy Optimization).

PPO es un algoritmo recomendado por Open AI como un buen punto de partida para RL. Tiene menos parámetros para ajustar que otros algoritmos de RL, pero aún así proporciona un buen rendimiento general. OpenAI Gym también se configura en este archivo con el nivel personalizado RoboMaker-ObjectTraker-v0 como sigue:

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

La clase TurtleBot3ObjectTrackerAndFollowerDiscreteEnv contiene los otros elementos necesarios para realizar el RL, como instrucciones sobre cómo restablecer el entorno cuando el robot completa una ronda de entrenamiento, la función de recompensa y el conjunto de acciones que puede realizar el robot.

Es posible que haya notado que la aplicación utiliza una imagen capturada por la cámara como estado. Por esta razón, el mundo real debe ser lo más parecido posible al mundo simulado en Gazebo para un rendimiento óptimo. Por ejemplo, el mundo actual simulado es gris oscuro.

Cuando el modelo entrenado se implementa en un TurtleBot Waffle Pi físico, debería funcionar en un entorno similar. Si desea entrenarse en un entorno de simulación más cercano al mundo real, como su habitación, puede agregar más detalles.

Por ejemplo, puedes tomar fotos de las paredes de tu habitación e importarlas como texturas para que coincidan con el mundo real tanto como sea posible.

En esta aplicación, el Waffle Pi usa su cámara para moverse. Por cada acción que realiza, toma una imagen de su cámara como el estado actual de todas las acciones que realiza. El código se define en el método infer_reward_state (self) de la clase TurtleBot3ObjectTrackerAndFollowerEnv .

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

Recuerde que el objetivo es que el TurtleBot Waffle Pi llegue a la hamburguesa TurtleBot estacionaria.

Por cada paso correcto que tome el TurtleBot Waffle Pi hacia el TurtleBot Burger estacionario, debería recibir una gran recompensa. El código de cálculo de recompensa se define en el método infer_reward_state (self) de la clase TurtleBot3ObjectTrackerAndFollowerEnv .

Si la distancia actual entre los TurtleBots es menor que en el último estado, el TurtleBot Waffle Pi se está acercando al TurtleBot Burger estacionario.

Por lo que obtiene una recompensa. Cuanto más se acerque el TurtleBot Waffle Pi a la meta, mayor será la recompensa. Si la distancia es mayor a 5 metros, el TurtleBot Waffle Pi está demasiado lejos del TurtleBot Burger estacionario, y el agente termina el episodio y comienza uno nuevo.

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

...

si 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)
            si distance_of_turtlebot < 0.2: done = True if distance_of_turtlebot > 5:
            done = Verdadero 

Puede intentar optimizar la lógica del código de la función de recompensa para que el agente pueda entrenar más rápido y con mayor precisión.

Por ejemplo, puede intentar dar una recompensa negativa si el Waffle Pi se aleja del TurtleBot estacionario en comparación con su último estado.

También puede intentar utilizar técnicas de visión artificial, como la detección de objetos, para encontrar el TurtleBot estacionario y luego calcular la distancia para una mayor optimización.

Las acciones que puede realizar el robot se definen en el TurtleBot3ObjectTrackerAndFollowerDiscreteEnv clase al final del archivo object_tracker_env.py . Las acciones están etiquetadas de 0 a 4, y cada acción es un comando de dirección y aceleración para el TurtleBot. Por ejemplo, cuando la acción es 0, TurtleBot debe girar a la izquierda a una velocidad de 0,1 metros por segundo.

 # Convertir discreta a continua
Si acción == 0: # mover a la izquierda
      dirección = 0.6
      acelerador = 0.1
elif action == 1: # mover a la derecha
      dirección = -0.6
      acelerador = 0.1
elif action == 2: # straight
      dirección = 0
      acelerador = 0.1
acción elif == 3: # mover a la izquierda
      dirección = 0.3
      acelerador = 0.1
elif action == 4: # mover a la derecha
      dirección = -0.3
      acelerador = 0.1 

Usando el modelo entrenado

Recuerde que el código entrena al modelo en TensorFlow. Cuando se implementa en TurtleBot Waffle Pi, debe poder descargar el modelo TensorFlow almacenado en Amazon S3 y cargarlo en el Waffle Pi. El espacio de trabajo robot_ws se usa para implementar el modelo en el Waffle Pi. El archivo download_model de Python en el espacio de trabajo robot_ws descarga el modelo entrenado desde Amazon S3. El código en el inference_worker El archivo de Python carga el modelo en una sesión de TensorFlow e indica al Waffle Pi que realice acciones (dirección, aceleración) en función de las imágenes suministradas desde su cámara.

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

AWS RoboMaker: Ejecutando la aplicación

ROS usa los archivos de inicio para iniciar aplicaciones. El archivo local_training.launch contiene detalles sobre todos los nodos (procesos) que desea iniciar al iniciar la aplicación. El elemento de nodo le indica al tiempo de ejecución de ROS que inicie el script de shell run_local_rl_agent.sh en el inicio.

 
...

    
 

En el script run_local_rl_agent.sh, ROS ejecuta el script de python single_machine_training_worker.

 #! / Usr / bin / env bash
...

python3 -m markov.single_machine_training_worker 

El archivo roboMakerSettings.json es específico de AWS RoboMaker. Define qué recursos y reglas de AWS usar para iniciar la aplicación. Por ejemplo, el archivo especificado para el parámetro launchFile en la configuración de simulación que el marco de ROS inicia en tiempo de ejecución.

Las variables de entorno se pueden pasar en el archivo de configuración. Por ejemplo, la variable de entorno MARKOV_PRESET_FILE es donde reside el código principal de la aplicación.

La aplicación se carga en tiempo de ejecución utilizando esta variable. Una característica útil del archivo roboMakerSettings.json es que le permite crear y configurar flujos de trabajo para compilar, agrupar y ejecutar automáticamente un trabajo de simulación para la aplicación. Esto evita que realice los pasos manualmente cuando necesita realizar un cambio.

 "tipo": "simulación",
      "cfg": {
        "simulationApp": {
          "nombre": "RoboMakerObjectTrackerSimulation",
          ...
          "launchConfig": {
            "packageName": "object_tracker_simulation",
            "launchFile": "local_training.launch",
            "Variables de entorno": {
              "MARKOV_PRESET_FILE": "object_tracker.py",
              "MODEL_S3_BUCKET": "",
              "MODEL_S3_PREFIX": "model-store",
              "ROS_AWS_REGION": ""
            }
          }

Resumen

Esperamos que este blog le ayude a comprender cómo funciona la aplicación de seguimiento de objetos de muestra y lo fácil que es desarrollar e implementar técnicas complejas de aprendizaje automático, como RL, en AWS RoboMaker. Si desea probar el uso de la aplicación de seguimiento de objetos de muestra, consulte Cómo entrenar a un robot mediante el aprendizaje reforzado .