Está en la página 1de 31

Introducción a OpenAI Gym

Jordi Casas Roma

0,5 créditos
CC-BY-SA • • Introducción a OpenAI Gym

Índice

Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1. OpenAI Gym . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1. OpenAI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2. Gym . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2. Estructura básica de un escenario de RL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10


2.1. Descripción del escenario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2. Esquema básico de funcionamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3. Ejemplos clásicos de RL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1. CartPole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2. FrozenLake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3. MountainCar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4. El API de OpenAI Gym . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19


4.1. Space . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2. Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.3. Wrappers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.4. Monitor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

5. Ejemplo básico con OpenAI Gym . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Bibliografía . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
CC-BY-SA • • 5 Introducción a OpenAI Gym

Introducción

El aprendizaje por refuerzo (reinforcement learning, RL) es el subcampo del apren-


dizaje automático relacionado con la toma de decisiones, que se centra en estudiar
cómo un agente puede aprender a alcanzar objetivos en un entorno complejo e in-
cierto. Aunque el avance de esta disciplina ha sido muy notable en los últimos años,
algunos de los principales problemas que pueden ralentizar el avance de este campo
son, por un lado, la necesidad de una colección grande y diversa de entornos y, por
otro lado, la falta de estandarización de entornos utilizados en publicaciones, que
dificulta la reproducibilidad y comparación de la investigación publicada.

En este módulo didáctico veremos una introducción a la librería OpenAI Gym, que
ha sido creada y publicada de forma abierta como un intento para solucionar ambos
problemas y empujar el avance del RL en toda la comunidad científica.

Iniciaremos el módulo didáctico revisando las principales características de Gym, así


como mencionando también los objetivos de OpenAI, la organización que ha creado
y mantiene esta librería y otros proyectos interesantes en el campo de la inteligencia
artificial (AI) y, en concreto, del aprendizaje por refuerzo.

A continuación, revisaremos brevemente las entidades principales que forman parte


de escenario de RL, así como su funcionamiento y estructura. Esto nos permitirá
identificar las partes clave de la API de Gym, que ocupará una parte importante
de este módulo didáctico. En concreto, veremos las principales clases implementa-
das en Gym e ilustraremos, mediante ejemplos de código en Python, como se puede
implementar de forma sencilla un escenario de RL para poder ejecutar y comparar
cualquier implementación de un agente.

Finalmente, en la último capítulo de este módulo, veremos la implementación de


un ejemplo sencillo empleando la librería Gym, que nos servirá para entender el
funcionamiento de esta herramienta y poder sentar las bases para el desarrollo de
ejemplos más complejos.
CC-BY-SA • • 6 Introducción a OpenAI Gym

Objetivos

En los materiales didácticos de este módulo encontraremos las herramientas indis-


pensables para asimilar los siguientes objetivos:

1. Conocer el objetivo y estructura de la librería Gym de OpenAI.

2. Entender la estructura básica de un escenario de aprendizaje por refuerzo, así


como sus principales entidades y relaciones entre ellas.

3. Conocer el funcionamiento de la API de Gym, incluyendo sus principales clases y


métodos.

4. Comprender el funcionamiento y estructura de código básico en Python empleando


la librería Gym.
CC-BY-SA • • 7 Introducción a OpenAI Gym

1. OpenAI Gym
.

El aprendizaje por refuerzo (reinforcement learning, RL) es el subcampo del apren-


dizaje automático relacionado con la toma de decisiones y el control motor. Estudia
cómo un agente puede aprender a alcanzar objetivos en un entorno complejo e in-
cierto. El estudio de estos modelos está despertando mucho interés recientemente,
básicamente por dos razones principales:

• En primer lugar, RL es muy general y abarca todos los problemas que implican
tomar una secuencia de decisiones, como por ejemplo: controlar los motores de
un robot para que pueda correr y saltar; tomar decisiones comerciales como la
gestión de precios e inventario; o jugar a videojuegos y/o juegos de mesa. RL
puede incluso aplicarse a problemas de aprendizaje supervisado con resultados
secuenciales o estructurados.

• En segundo lugar, los algoritmos de RL han comenzado a lograr buenos resultados


en muchos entornos difíciles. RL tiene una larga historia, pero hasta los recientes
avances en el aprendizaje profundo (deep learning, DL), requería mucha ingenie-
ría de problemas específicos. Los resultados de DeepMind en Atari1 o AlphaGo2
demuestran el potencial de este tipo de algoritmos de RL. En ambos casos se
emplearon algoritmos de RL basados en aprendizaje profundo que no hicieron de-
masiadas suposiciones sobre su entorno y, por lo tanto, pueden aplicarse en otros
entornos.

Sin embargo, la investigación en RL tiene algunos inconvenientes que pueden ralenti-


zar su avance, especialmente podemos identificar dos factores:

• La necesidad de mejores puntos de referencia. En el aprendizaje supervisado,


el progreso ha sido impulsado por grandes conjuntos de datos etiquetados, como
ImageNet3 . En RL, el equivalente más cercano sería una colección grande y diversa
de entornos. Sin embargo, las colecciones de código abierto existentes de entornos
de RL no tienen suficiente variedad y, a menudo, son difíciles de configurar y usar.

• Falta de estandarización de entornos utilizados en publicaciones. Las diferencias


sutiles en la definición del problema, como la función de recompensa o el conjunto
de acciones, pueden alterar drásticamente la dificultad de una tarea. Este problema
hace que sea difícil reproducir la investigación publicada y comparar los resultados
de diferentes trabajos.

1
https://deepmind.com/research/publications/playing-atari-deep-reinforcement-learning
2
https://deepmind.com/research/case-studies/alphago-the-story-so-far
3
http://www.image-net.org/
CC-BY-SA • • 8 Introducción a OpenAI Gym

OpenAI Gym ha sido creado y publicado como un intento para solucionar ambos
problemas, empujando de esta forma el avance del RL en toda la comunidad científica.

A modo de síntesis, podemos decir que en este módulo didáctico introduciremos los
conceptos básicos de OpenAI Gym, una biblioteca utilizada para proporcionar una
API abierta y uniforme para agentes y entornos de aprendizaje por refuerzo. Como
veremos a los largo de este texto, esta librería elimina la necesidad de escribir código
repetitivo y proporciona un entorno de evaluación comparativo (benchmarking) para
el desarrollo y evaluación de algoritmos de RL.

1.1. OpenAI

OpenAI es una compañía de investigación de inteligencia artificial (IA) sin ánimo


de lucro que tiene como objetivo promover y desarrollar inteligencia artificial para
beneficiar a la humanidad, en un sentido amplio.

OpenAI ofrece multitud de recursos relacionados con RL. A continuación veremos, OpenAI
brevemente, algunos de los más destacados:
OpenAI es un laboratorio de
investigación con sede en San
Francisco, California, cuya
• Spinning Up in Deep RL4 es un recurso educativo abierto diseñado para permi-
misión es “garantizar que la
tir que cualquier persona pueda formarse en el campo del aprendizaje por refuerzo inteligencia artificial beneficie
a toda la humanidad”. Fue
profundo (Deep Reinforcement Learning, Deep RL). Es decir, este recurso se cen- fundada en octubre de 2015
tra en el uso de modelos de aprendizaje profundo (deep learning) para resolver por Musk, Altman y otros
inversores que anunciaron la
problemas relacionados con RL. formación de la organización.
El 27 de abril de 2016,
OpenAI lanzó una versión
• Gym5 es una librería o biblioteca de herramientas para desarrollar y comparar beta pública de Gym.
algoritmos de aprendizaje por refuerzo. El objetivo es facilitar la configuración de
varios entornos para problemas de RL y, además, facilitar entornos “estándares” Recursos de OpenAI
para la comparación de modelos.
Los diferentes recursos de
OpenAI se pueden consultar
• Microscope6 es una colección de visualizaciones de cada capa y neurona significa- en:
https://openai.com/resources/
tiva de los principales modelos de redes neuronales convolucionales (Convolutional
Neural Networks, CNN), tales como AlexNet, Inception, VGG o ResNet.

• Baselines7 ofrece una muestra de implementaciones de algoritmos de aprendizaje


por refuerzo que ofrecen un alto rendimiento y calidad.

Más allá de los recursos comentados, OpenAI ofrece multitud de herramientas y algo-
ritmos relacionados con el aprendizaje por refuerzo o, en general, con la inteligencia
artificial y el aprendizaje profundo.

4
https://spinningup.openai.com/
5
http://gym.openai.com/
6
https://microscope.openai.com/
7
https://github.com/openai/baselines
CC-BY-SA • • 9 Introducción a OpenAI Gym

1.2. Gym

Como hemos comentado anteriormente, Gym es una librería o biblioteca de herra-


mientas para desarrollar, evaluar y comparar algoritmos de aprendizaje por refuerzo.
En esencia, Gym nos proporciona las clases bases para implementar un entorno de
RL, así como multitud de entornos “clásicos” o “estándares” donde el entorno ya está
implementado y sólo hace falta implementar el agente para poder desarrollar, evaluar
y comparar su comportamiento y su grado de calidad.

Gym ofrece multitud de entornos ya implementados para poder testear la calidad de Entornos de Gym
un agente, entre los que podemos destacar los siguientes grupos:
La enumeración exhaustiva
de todos los entornos queda
fuera del alcance de este tex-
• Atari agrupa varios de los juegos clásicos de Atari 2600, donde el objetivo es
to, pero se puede consultar en:
alcanzar la máxima puntuación posible. Entre la multitud de juegos disponibles, http://gym.openai.com/envs/

podemos destacar Air Raid, Alien, Battle Zone, Pong o Space Invaders.

• Box2D agrupa varios problemas de tareas de control continuo en un simulador


2D, como por ejemplo entrenar a un robot bípedo para caminar (BipedalWalker)
o a un coche para correr sin salirse de la pista (CarRacing).

• Classic control, que agrupa varios problemas de la teoría de la literatura clásica


de RL, como por ejemplo entrenar al agente para que sea capaz de equilibrar
un poste en un carro (CartPole) o subir una colina mediante control continuo
(MountainCarContinuous).

• Robotics, que engloba tareas simuladas basadas en objetivos para los robots
Fetch y ShadowHand.

Esta librería no hace suposiciones sobre la estructura del agente a implementar y es


compatible con cualquier biblioteca de cómputo numérico, como por ejemplo Tensor-
Flow8 , Theano9 o PyTorch10 . Los entornos de Gym ofrecen una interfaz compartida
que permite escribir algoritmos generales.

Para la instalación de Gym sólo se requiere el uso de Python 3.5 o superior. Gym
puede ser instalado a partir del código fuente11 o empleando el gestor pip de la forma
habitual:
1 pip install gym

8
https://www.tensorflow.org/
9
http://deeplearning.net/software/theano/
10
https://pytorch.org/
11
https://github.com/openai/gym
CC-BY-SA • • 10 Introducción a OpenAI Gym

2. Estructura básica de un escenario de RL


.

En este capítulo procederemos a revisar la estructura básica de un escenario de apren-


dizaje por refuerzo. En primer lugar, enumeraremos las entidades principales que in-
tervienen en un problema RL, presentando sus características básicas y un esquema de
comunicación entre ellas. A continuación, con la finalidad de clarificar y ejemplificar
este esquema básico, proporcionaremos un pseudocódigo de ejemplo que nos permita
entender mejor como se implementa un problema en entornos de RL.

2.1. Descripción del escenario

En un entorno de aprendizaje por refuerzo se presentan dos entidades principales:

• El agente es una entidad que desempeña un papel activo en el entorno, toman-


do decisiones sobre las acciones que ejecutará en el entorno. Desde el punto de
visto más pragmático, el agente es una aplicación (fragmento de código) que im-
plementa una determinada política para ejecutar ciertas acciones en el entorno.
Básicamente, esta política decide qué acción se requiere en cada momento a partir
de las observaciones proporcionadas por el entorno.

• El entorno es un modelo externo al agente que tiene la responsabilidad de propor-


cionar observaciones y recompensas a las acciones del agente. El entorno cambia
su estado en función de las acciones del agente.

La comunicación entre ambas entidades se detalla en la Figura 1, donde podemos


ver que para cada acción (At ) que realiza el agente en el instante de tiempo t, en
entorno actualiza su estado y devuelve la recompensa asociada a la acción (Rt+1 ) y
la observación asociada al nueva estado (Ot+1 ), ambos derivados a partir de ejecutar
la acción At en la configuración del entorno en el instante t.

Figura 1. Esquema básico de interacción entre el agente y el entorno.


At

Ot+1

Rt+1
Agente Entorno
CC-BY-SA • • 11 Introducción a OpenAI Gym

2.2. Esquema básico de funcionamiento

A continuación, detallaremos el funcionamiento de ambas entidades, presentado su


funcionamiento a alto nivel y el correspondiente pseudocódigo que nos permitirá en-
tender mejor su funcionamiento.

El siguiente pseudocódigo muestra el bloque principal de código, donde se inicializan


las clases correspondientes al entorno (Environment) i al agente (Agent). Una vez
inicializadas las clases, el agente itera indefinidamente mediante el método step()
hasta que el episodio finaliza.
1 if __name__ == " __main__ " :
2 env = Environment ()
3 agent = Agent ()
4
5 while not env . is_done () :
6 agent . step ( env )
7
8 print ( " Total reward got : {} " . format ( agent . total_reward ) )

El código asociado al agente se muestra en el siguiente fragmento, donde podemos


ver el método de inicialización de la clase (__init__) y el método step(). En el
proceso de inicialización se instancian las variables y propiedades de la clase, como
es habitual. Por otro lado, el método step() realiza varias acciones relevantes que
pasamos a comentar:

1) Obtiene el valor de la observación del estado actual, que nos lo proporciona en


entorno.

2) Obtiene los valores de acciones posibles, que también nos lo proporciona en en-
torno.

3) A continuación, con la información anterior, el agente debe seleccionar la acción


que quiere realizar. En este punto es donde el agente implementa el método selec-
cionado para escoger la acción a realizar entre el conjunto de acciones posibles (este
conjunto puede ser limitado o ilimitado, dependiendo de las características del en-
torno).

4) Finalmente, comunica la acción al entorno, el cual le devuelve la recompensa


asociada.

Es importante destacar que estas son las acciones que deberá realizar el agente, pero
el orden y la agrupación de éstas puede diferir según la librería o implementación
empleada para desarrollar el entorno de RL.
1 class Agent :
2 def __init__ ( self ) :
3 Inicialización del agente
4 self . total_reward = 0.0
5
6 def step ( self , env : Environment ) :
7 current_obs = env . get_ ob se rv ation ()
8 actions = env . get_actions ()
9 action = Seleccionar la acción deseada .
10 reward = env . action ( action )
11 self . total_reward += reward
CC-BY-SA • • 12 Introducción a OpenAI Gym

Por su parte, el código del entorno se puede ver a continuación. En este caso, ve-
mos que el entorno debe proveer varios métodos para informar de las observaciones
actuales, las acciones posibles, el estado del episodio (si ha finalizado o no) y el mé-
todo action(), que aplica una determinada acción en el entorno y lo actualiza en
consecuencia, proporcionando la recompensa indicada.
1 class Environment :
2 def __init__ ( self ) :
3 Inicialización del entorno
4
5 def ge t_o bs erva t ion ( self ) :
6 Devuelve los valores de observación del estado actual
7
8 def get_actions ( self ) :
9 Devuelve la lista de acciones posibles
10
11 def is_done ( self ) :
12 Devuelve un booleano indicando si ha terminado el episodio
13
14 def action ( self , action ) :
15 Aplica la acción indicada en el entorno
16 Devuelve la recompensa asociada

Es importante destacar que la función de este pseudocódigo es entender los pasos


básicos y mínimos asociados a un entorno de RL, pero que diferentes implementaciones
pueden diferir en el número y nombre de clases, así como en los métodos y propiedades
indicados.
CC-BY-SA • • 13 Introducción a OpenAI Gym

3. Ejemplos clásicos de RL
.

En este capítulo revisaremos, brevemente, algunos ejemplos clásicos de problemas de Wiki de OpenAI Gym

RL que están incluidos en Gym. Esta lista no es exhaustiva, y sólo presenta algunos
La Wiki de OpenAI Gym nos
ejemplos básicos que serán utilizados a lo largo de este módulo didáctico. La enu- proporciona información
detallada del funcionamiento
meración exhaustiva y actualizada de entornos, como ya hemos comentado, se puede
de cada uno de los entornos
consultar en la página web de Gym1 . disponibles. La Wiki puede
consultarse aquí:
https://github.com/openai/gym/wiki

3.1. CartPole

El problema de “CartPole”, también conocido como el péndulo invertido, se define Bibliografia complementaria

como un poste que está unido por una articulación no accionada a un carro, que se
Este problema fue descrito
mueve a lo largo de una pista sin fricción. El poste comienza en posición vertical, y por A. G. Barto, R. S. Sutton
and C. W. Anderson,
el objetivo es evitar que se caiga aumentando y/o reduciendo la velocidad del carro.
“Neuronlike adaptive
El sistema se controla aplicando una fuerza de +1 o -1 al carro. Se proporciona elements that can solve
difficult learning control
una recompensa de +1 por cada paso de tiempo que el poste permanece en posición problems”, in IEEE
vertical y el episodio termina cuando el poste se cae (se considera que cae cuando está Transactions on Systems,
Man, and Cybernetics, vol.
a más de 15 grados de la vertical) o el carro se sale de la pista (es decir, se mueve a SMC-13, no. 5, pp. 834-846,
más de 2.4 unidades del centro de la pista). Sept.-Oct. 1983, doi:
10.1109/TSMC.1983.6313077

Figura 2. Ejemplo del entorno CartPole.

La información básica de este entorno se puede encontrar en:

Tabla 1. Información básica del entorno CartPole.


Descripción Enlace
Información https://gym.openai.com/envs/CartPole-v0/
Wiki https://github.com/openai/gym/wiki/CartPole-v0
Código fuente https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py

A continuación detallamos los parámetros de este entorno.

1
http://gym.openai.com/envs/ o https://github.com/openai/gym/wiki/Environments
CC-BY-SA • • 14 Introducción a OpenAI Gym

Observaciones

Las observaciones proporcionan la siguiente información:

Tabla 2. Información contenida en una observación del entorno CartPole.


Número Observación Mín. Máx.
0 Posición del carro -2.4 2.4
1 Velocidad del carro −∞ +∞
2 Ángulo del poste ≈ −48,1◦ ≈ +48,1◦
3 Velocidad del poste en la punta −∞ +∞

Acciones

Las acciones permitidas en el entorno son las siguientes:

Tabla 3. Acciones válidas en el entorno CartPole.


Número Acción
0 Empujar el carro hacia la izquierda
1 Empujar el carro hacia la derecha

Es importante notar que la cantidad que la velocidad que se reduce o aumenta no es


fija, ya que depende del ángulo al que apunta el poste.

Recompensa

La recompensa es 1 por cada paso dado, incluyendo el paso final.

Estado inicial

Todas las observaciones tienen asignado un valor aleatorio uniforme entre ±0,05.

Finalización del episodio

Las condiciones de finalización son las siguientes:

• El ángulo del poste es mayor que ±12◦ .

• La posición del carro es superior a ±2,4. Es decir, el centro del carro llega al borde
de la pantalla, considerando que ha salido del rango válido.

• La duración del episodio es superior a 200.

Los requerimientos para considerar el problema como superado son:


CC-BY-SA • • 15 Introducción a OpenAI Gym

• La recompensa promedio es mayor o igual a 195.0 en 100 episodios consecutivos.

3.2. FrozenLake

El problema de “FrozenLake” consiste en controlar el movimiento de un personaje


sobre un lago de hielo representado por una cuadrícula de n × n, donde algunas
porciones de la cuadrícula son transitables, y otras producen que el agente caiga al
agua. El objetivo de este juego es pasar del estado inicial (S) al estado objetivo (G)
caminando solo sobre fichas congeladas (F ) y evitar los agujeros (H). Sin embargo,
el hielo es resbaladizo, por lo que no siempre se moverá en la dirección deseada (es
decir, se trata de un entorno estocástico).

Figura 3. Ejemplo del entorno FrozenLake en una cuadrícula de 4 × 4.

S F F F

F H F H

F F F H

H F F G

La información básica de este entorno se puede encontrar en:

Tabla 4. Información básica del entorno FrozenLake.


Descripción Enlace
Información https://gym.openai.com/envs/FrozenLake-v0/
Wiki https://github.com/openai/gym/wiki/FrozenLake-v0
Código fuente https://github.com/openai/gym/tree/master/gym/envs/toy_text/frozen_lake.py

A continuación detallamos los parámetros de este entorno.

Observaciones

Las observaciones proporcionan la siguiente información:

Tabla 5. Información contenida en una observación del entorno FrozenLake.


Número Observación Mín. Máx.
0 Posición del agente en el tablero 0 15 (en el tablero de 4 × 4)

La posición del agente se indica contando de izquierda a derecha y de arriba a abajo.


CC-BY-SA • • 16 Introducción a OpenAI Gym

Acciones

Las acciones permitidas en el entorno son las siguientes:

Tabla 6. Acciones válidas en el entorno FrozenLake.


Número Acción
0 Mover hacia la izquierda
1 Mover hacia abajo
2 Mover hacia la derecha
3 Mover hacia arriba

Recompensa

La recompensa es 0 por cada paso dado, 0 por caer en el hoyo, 1 por alcanzar la meta
final.

Estado inicial

El estado inicial está en la esquina superior izquierda, indicada como S en la Figura


3.

Finalización del episodio

Las condiciones de finalización son las siguientes:

• Llegar a la posición objetivo, indicada como G en la Figura 3.

• Caer en alguno de los agujeros del tablero.

Los requerimientos para considerar el problema como superado son:

• Alcanzar el estado objetivo sin caer en ningún agujero en más de 100 episodios
consecutivos.

3.3. MountainCar

En el problema “MountainCar” se trata de dirigir un vehículo que está en una pista Bibliografia complementaria

unidimensional, posicionada entre dos montañas. El objetivo es subir la montaña de


Este problema fue descrito en
la derecha. Sin embargo, el motor del vehículo no es lo suficientemente potente como la tesis doctoral de Moore, A.
W. (1990). “Efficient
para subir la montaña y, por lo tanto, la única forma de tener éxito es conducir de
memory-based learning for
un lado a otro para generar impulso y lograr subir la montaña situada a la derecha robot control”. Cambridge,
England: University of
del entorno. Cambridge Computer
Laboratory.
CC-BY-SA • • 17 Introducción a OpenAI Gym

Figura 4. Ejemplo del entorno en el problema “MountainCar”.

La información básica de este entorno se puede encontrar en:

Tabla 7. Información básica del entorno MountainCar.


Descripción Enlace
Información https://gym.openai.com/envs/MountainCar-v0/
Wiki https://github.com/openai/gym/wiki/MountainCar-v0
Código fuente https://github.com/openai/gym/tree/master/gym/envs/classic_control/mountain_car.py

A continuación detallamos los parámetros de este entorno.

Observaciones

Las observaciones proporcionan la siguiente información:

Tabla 8. Información contenida en una observación del entorno MountainCar.


Número Observación Mín. Máx.
0 Velocidad del vehículo -0.07 0.07

Acciones

Las acciones permitidas en el entorno son las siguientes:

Tabla 9. Acciones válidas en el entorno MountainCar.


Número Acción
0 Empujar a la izquierda
1 No empujar
2 Empujar a la derecha

Recompensa

La recompensa es -1 para cada paso de tiempo, hasta alcanzar la posición meta


(posición igual a 0.5).
CC-BY-SA • • 18 Introducción a OpenAI Gym

Estado inicial

Posición aleatoria entre -0.6 y -0.4, sin velocidad ni aceleración.

Finalización del episodio

Las condiciones de finalización son las siguientes:

• Alcanzar la posición de meta (posición igual a 0.5).

• Alcanzar 200 iteraciones.

Los requerimientos para considerar el problema como superado son:

• Obtener una recompensa promedio de -110.0 en 100 episodios consecutivos.


CC-BY-SA • • 19 Introducción a OpenAI Gym

4. El API de OpenAI Gym


.

Como ya hemos comentado, Gym es una biblioteca para desarrollar y comparar algo-
ritmos de aprendizaje por refuerzo. Gym no hace suposiciones sobre la estructura del
agente que se desea implementar, y es compatible con cualquier biblioteca de cómputo
numérico, como TensorFlow, Theano o PyTorch.

Gym ofrece una colección de entornos de prueba que pueden ser usados para entrenar,
evaluar y comparar algoritmos de aprendizaje por refuerzo. Estos entornos tienen una
interfaz compartida que permite desarrollar algoritmos generales.

A continuación revisaremos las principales clases que aporta la API de Gym, junto
con los métodos básicos para poder trabajar en diferentes entornos de RL.

4.1. Space

La clase Space permite definir cómo serán las acciones y recompensas, definiendo
el tipo y rango de valores permitidos. Como se puede ver en la Figura 5, existen
múltiples subclases que realizan la implementación de la clase abstracta Space.

Figura 5. Jerárquia de la clase Space.


Space
sample()
contains()

Box Discrete Tuple


low n spaces
high
shape

La clase abstracta básica Space incluye dos métodos relevantes:

• sample(), que devuelve una muestra aleatoria del espacio.

• contains(x), que comprueba si el argumento x pertenece al dominio del espacio.

Ambos métodos son abstractos y se vuelven a implementar en cada una de sus sub-
clases.
CC-BY-SA • • 20 Introducción a OpenAI Gym

La clase Discrete representa un conjunto de elementos mutuamente excluyentes,


numerados de 0 a n − 1. Su único atributo (n) es un recuento de los elementos que
describe.

Movimiento en un tablero de ajedrez. Por ejemplo, Discrete(n=4) se puede usar


para definir un espacio de acción que represente el movimiento en cuatro direcciones,
donde el valor 0 indica mover hacia la izquierda, 1 mover hacia la derecha, 2 hacia arriba
y, finalmente, 3 indica desplazar hacia abajo.

La clase Box representa un tensor n-dimensional de números racionales con el intervalo


[low, high]. Esta clase es ampliamente utilizada, ya que permite representar una
gran cantidad y variedad de información de muy diferente índole.

Pedal de aceleración. Por ejemplo, un pedal acelerador se puede representar mediante


un solo valor entre 0.0 y 1.0, que indique el porcentaje activo del acelerador. Esto podría
estar codificado mediante Box(low=0.0, high=1.0, shape=(1,), dtype=np.float32)

El argumento shape indica que se trata de una tupla de longitud 1 con un solo valor, lo
que nos da un tensor unidimensional con un solo valor. El rango de este valor se determina
mediante los valores low y high. El parámetro dtype especifica el tipo de la variable, que
en este caso concreto se trata de un flotante NumPy de 32 bits.

Juegos de Atari. Supongamos ahora que queremos representar una observación de una
pantalla de juego de Atari, que es una imagen de tamaño 210×160 en RGB (rojo, verde y
azul) empleando un byte para codificar cada color, es decir, 256 posibles valores. Podemos
representar esta información mediante la siguiente codificación: Box(low=0, high=255,
shape=(210, 160, 3), dtype=np.uint8).

En este caso, el argumento shape es una tupla de tres elementos: la primera dimensión es
la altura de la imagen, la segunda es el ancho y la tercera corresponde a los tres canales
de color (rojo, verde y azul), empleando un byte para representar cada color. Entonces,
en total, cada observación es un tensor tridimensional con 100.800 bytes.

Finalmente, la clase Tuple nos permite combinar varias instancias de clase Space
para crear espacios de acción y observación de complejidad variable y un alto grado
de adaptación a cualquier entorno.

Conducción de un vehículo. Por ejemplo, supongamos que queremos crear una espe-
cificación del espacio de acción para un vehículo. El vehículo tiene varios controles que se
pueden cambiar en cada instante de tiempo, incluyendo el ángulo del volante, la posición
del pedal del freno y la posición del pedal del acelerador. Estos tres controles se pueden
especificar mediante tres valores flotantes en una sola instancia de Box. Además de estos
controles esenciales, el vehículo requiere controles discretos adicionales, como el intermi-
tente para señalar la intención de giro (que podría estar apagada, derecha o izquierda) o
la bocina (encendida o apagada).

Para combinar todo esto en una clase de especificación de espacio de acción, pode-
mos crear Tuple(spaces=(Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32),
Discrete(n=3), Discrete(n=2))).

Hay otras subclases de Space definidas en Gym, pero las tres que hemos mencio-
nado son las más habituales y útiles. Todas las subclases implementan los métodos
sample() y contains(). La función sample() devuelve una muestra aleatoria, que
puede ser útil para espacios de acción, cuando necesitamos elegir una acción aleatoria.
El método contains() verifica que los argumentos dados cumplan con los parámetros
indicados, y se usa en los componentes internos de Gym para verificar la consistencia
de las acciones de un agente.
CC-BY-SA • • 21 Introducción a OpenAI Gym

4.2. Environment

El objetivo principal de Gym es proporcionar una gran colección de entornos con una
interfaz común para permitir evaluar y comparar distintas implementaciones. Por lo
tanto, la clase que implementa un entorno es, sin duda, la clase principal de esta API.

El entorno está representado en Gym por la clase Env, que tiene los siguientes miem-
bros:

• action_space: proporciona una especificación para las acciones permitidas en el


entorno, mediante la clase Space.

• observation_space: especifica las observaciones proporcionadas por el entorno,


también mediante la clase Space.

• reset(): este método restablece el entorno a su estado inicial, devolviendo el


vector de observación inicial.

• step(): este método permite ejecutar una determinada acción y devuelve infor-
mación sobre el resultado de ésta, es decir, la siguiente observación, la recompensa
y el indicador de final del episodio.

• render(): este método nos permite obtener la observación en una forma amigable
para los humanos, generalmente en forma de imagen o vídeo del estado del entorno.

El método reset() no tiene argumentos. Simplemente, indica a un entorno que res-


tablezca su estado inicial y obtiene la observación inicial. Es importante remarcar que
se debe llamar a este método después de la creación del entorno.

El método step() es el método central en la funcionalidad del entorno. Cuando se


llama a este método se realizan varias acciones. En concreto:

1) Decirle al entorno qué acción ejecutaremos en el siguiente paso.

2) Obtener la nueva observación del entorno después de esta acción.

3) Obtener la recompensa generada con la acción.

4) Obtener un booleano indicando si el episodio ha terminado.

El método tiene un único parámetro principal, que es la acción que el agente desea
realizar. A partir de la llamada, el método devuelve una tupla de cuatro elementos
con los siguientes tipos y significados:

1) observation: vector NumPy o una matriz con los datos de la siguiente observa-
ción.
CC-BY-SA • • 22 Introducción a OpenAI Gym

2) reward: valor de la recompensa, generalmente como un valor decimal (flotante).

3) done: indicador booleano, donde el valor “verdadero” indica que el episodio ha


terminado.

4) info: información adicional sobre el entorno. En general, se suele ignorar este


valor, aunque puede aportar información interesante en determinados casos.

Como hemos visto en los ejemplos anteriores, el código de un agente se ejecuta en una
iteración que incluye la llamada al método step() indicando la acción a realizar, hasta
que el indicador de episodio finalizado se activa (done == True). Entonces podemos
llamar al método reset() para iniciar un nuevo episodio.

Para instanciar la clase Env se debe emplear la función make() de la API de Gym.
Esta función tiene un único argumento que se debe indicar: el nombre del entorno
que se desea crear, que presenta la forma EnvironmentName-vN, donde N es el número
utilizado para distinguir entre diferentes versiones del mismo entorno (cuando, por
ejemplo, se corrigen algunos errores o se realizan otros cambios importantes).

Por ejemplo, para crear el entorno “CartPole-v0” se debe ejecutar el siguiente código:
1 import gym
2 env = gym . make ( ’ CartPole - v0 ’)

Para enumerar los entornos disponibles en una instalación de Gym se puede acceder
a la lista completa a partir de gym.envs.registry de la siguiente forma:
1 from gym import envs
2 print ( envs . registry . all () )
3 > [ EnvSpec ( DoubleDunk - v0 ) , EnvSpec ( InvertedDoublePendulum - v0 ) , EnvSpec ( BeamRider - v0 ) ,
EnvSpec ( Phoenix - ram - v0 ) , EnvSpec ( Asterix - v0 ) , EnvSpec ( TimePilot - v0 ) , EnvSpec ( Alien -
v0 ) , EnvSpec ( Robotank - ram - v0 ) , EnvSpec ( CartPole - v0 ) , EnvSpec ( Berzerk - v0 ) , EnvSpec (
Berzerk - ram - v0 ) , EnvSpec ( Gopher - ram - v0 ) , ...

Ejemplo del entorno CartPole. A continuación veremos un ejemplo simple que nos
permitirá entender los conceptos introducidos en esta sección. El siguiente código nos
permite crear un entorno basado en CartPole-v0 y ver el tipo y rango de datos que se
emplea. En primer lugar, importamos la librería y cargamos el entorno (líneas 1 y 2).
Para inicializar el entorno ejecutamos el método reset(). Además de iniciar el entorno,
éste nos devuelve una observación en forma de array de cuatro valores decimales, que
contiene información sobre la coordenada x del centro de masa del palo, su velocidad, su
ángulo con la plataforma y su velocidad angular.
1 >>> import gym
2 >>> e = gym . make ( ’ CartPole - v0 ’)
3 >>> e . reset ()
4 array ([0.02435837 , -0.00828909 , -0.01874128 , -0.04975044])
5 >>> e . action_space
6 Discrete (2)
7 >>> e . action_space . sample ()
8 1
9 >>> e . o b s e rv a ti o n_s p ac e
10 Box (4 ,)
11 >>> e . o b s e rv a ti o n_s p ac e . sample ()
12 array ([ -2.7316299 e -01 , -2.5477804 e +38 , 4.0203831 e -01 , 1.1989651 e +35] , dtype =
float32 )
13 >>> e . step (0)
14 ( array ([ 0.02419259 , -0.20313736 , -0.01973629 , 0.23696103]) , 1.0 , False , {})
15
CC-BY-SA • • 23 Introducción a OpenAI Gym

En las líneas 5 y 6 vemos que el tipo de las acciones permitidas es Discrete(n=2), lo


que indica que las acciones deberán contener el valor 0 o 1, donde 0 significa empu-
jar la plataforma hacia la izquierda y 1 significa empujar hacia la derecha. El método
action_space.sample() nos devuelve ejemplos aleatorios del espacio de acciones válidos
en este entorno.

El espacio de observaciones se puede ver en las líneas 9 y 10. En este caso vemos que se
trata de un vector de cuatro posiciones en el rango (−∞, ∞). A continuación, vemos un
ejemplo aleatorio facilitado por el método observation_space.sample().

Finalmente, en el línea 13 indicamos la acción que realizará el agente. La respuesta del


entorno incluye, como hemos indicado anteriormente, cuatro valores:

1) Un vector de cuatro posiciones con el resultado de la nueva observación del entorno.


2) La recompensa, que en este caso es 1.0.
3) El indicador de final de episodio (done), que en este caso es False.
4) Información extra del entorno, que en este caso no contiene información.

4.3. Wrappers

Los wrappers permiten ampliar la funcionalidad del entorno, como por ejemplo mo-
dificando las observaciones o recompensas que se usarán para alimentar al agente.
Es común en problemas de RL procesar previamente las observaciones con el fin de
facilitar el aprendizaje de los agentes. Por ejemplo, cuando se usan entradas basadas
en imágenes es habitual emplear un rango de valores [0,1] en lugar de [0,255], que son
los valores estándares en imágenes RGB.

Otro ejemplo habitual se produce cuando deseamos acumular las observaciones que
nos proporciona el entorno en algún búfer o similar, con el objetivo de proporcionar
al agente las n últimas observaciones para que éste pueda decidir la mejor acción
a ejecutar. Este es un escenario común para los juegos de computadora dinámicos,
donde un solo frame no es suficiente para obtener la información completa sobre
el estado del juego (por ejemplo, no se puede apreciar la dirección y velocidad del
movimiento de las entidades presentes).

Figura 6. Jerárquia de la clase Wrapper.


Env

Wrapper

ObservationWrapper ActionWrapper RewardWrapper


observation(obs) action(act) reward(rew)

La generalización de este tipo de comportamiento se consigue mediante el esquema


CC-BY-SA • • 24 Introducción a OpenAI Gym

de herencia que se muestra en la Figura 6. La clase Wrapper hereda de la clase Env,


que es la encargada de definir los entornos según la API de Gym. La implementación
de la clase Wrapper requiere definir un método __init__ que acepte el entorno como
parámetro.

A continuación presentamos un código de ejemplo que nos muestra como crear una
nueva clase, en este caso con nombre “BasicWrapper”, y como extender las funciona-
lidades básicas de la clase Wrapper.
1 class BasicWrapper ( gym . Wrapper ) :
2 def __init__ ( self , env ) :
3 super () . __init__ ( env )
4 self . env = env
5
6 def step ( self , action ) :
7 next_state , reward , done , info = self . env . step ( action )
8 # aplicar las modificaciones deseadas
9 return next_state , reward , done , info

Y la nueva clase BasicWrapper se instancia de la siguiente forma:


1 env = BasicWrapper ( gym . make ( " EnvironmentName - vN " ) )

Se pueden modificar aspectos específicos del entorno utilizando las subclases de Wrapper,
que permiten sobrescribir la forma en que el entorno procesa las observaciones, las
recompensas y las acciones.

Las siguientes clases proporcionan esta funcionalidad:

• ObservationWrapper se utiliza para modificar las observaciones devueltas por el


entorno.

• RewardWrapper se emplea para modificar las recompensas devueltas por el entorno.

• ActionWrapper permite modificar las acciones enviadas al entorno.

Modificando el tipo de las observaciones en FrozenLake. En el entorno FrozenLa-


ke, los movimientos del agente se caracterizan como el tipo Discrete(n=4), entendiendo
que el agente puede moverse en las cuatro direcciones básicas (arriba, abajo, izquierda
y derecha). Las observaciones se representan mediante el tipo Discrete(n=16), donde
cada valor entre 0 y 15 representa la posición del agente en una de las 16 celdas de la
cuadrícula, en el caso de un tablero de 4 × 4.

A continuación presentamos un ejemplo básico de código para ejecutar este entorno de


forma aleatoria.
1 import gym
2
3 env = gym . make ( " FrozenLake - v0 " )
4 obs , done = env . reset () , False
5
6 while not done :
7 act = env . action_space . sample ()
8 obs , rew , done , _ = env . step ( act )
9 print ( obs )
10
11 print ( " Episode finished ! " )
12

Y una posible salida asociada a este ejemplo se muestra a continuación (dado el carácter
estocástico de este ejemplo, cada ejecución puede presentar resultados diferentes):
CC-BY-SA • • 25 Introducción a OpenAI Gym

1 1
2 1
3 2
4 6
5 5
6 Episode finished !
7

Ahora supongamos que queremos implementar un agente que necesita procesar las ob-
servaciones como un vector de posiciones, donde una única posición del vector de 16
posiciones debe coger el valor de 1 y el resto debe permanecer a 0. Para conseguir es-
te comportamiento, definimos un wrapper que toma el entorno espacio de observación
Discrete(n=16) y genera un nuevo entorno con una codificación one-hot 1 de los estados,
para ser usado, por ejemplo, en redes neuronales.
1 import gym
2 import numpy as np
3
4 class D i s c r e t e T o B o x W r a p p e r ( gym . Ob s er v at io n Wr a pp e r ) :
5 def __init__ ( self , env ) :
6 super () . __init__ ( env )
7 self . n = self . o bse r va tio n_ s pac e . n
8 self . o b s e r v at io n _sp a ce = gym . spaces . Box (0 , 1 , ( self .n ,) )
9
10 def observation ( self , obs ) :
11 new_obs = np . zeros ( self . n )
12 new_obs [ obs ] = 1
13 return new_obs
14
15 env = D i s c r e t e T o B o x W r a p p e r ( gym . make ( " FrozenLake - v0 " ) )
16
17 obs , done = env . reset () , False
18 while not done :
19 act = env . action_space . sample ()
20 obs , rew , done , _ = env . step ( act )
21 print ( obs )
22
23 print ( " Episode finished ! " )
24

En este ejemplo hemos definido la clase DiscreteToBoxWrapper a partir de la clase


ObservationWrapper donde sobrescribimos la configuración del espacio de observaciones,
asignando el tipo Box(low=0, high=1, shape=(16,)). Inicializamos el entorno a partir
del wrapper creado. La siguiente parte del código no presenta ninguna modificación, ya
que el wrapper implementa los cambios de forma “transparente” y no se requiere modificar
el código del bloque principal.

4.4. Monitor

La clase Monitor permite exportar información sobre el rendimiento del agente en un


archivo, incluyendo una grabación de video opcional del agente interactuando con el
entorno.

Para poder emplear la clase Monitor se requiere que la utilidad FFmpeg2 esté presente FFmpeg

en el sistema donde se ejecuta el código. Esta utilidad permite convertir las observa-
FFmpeg es una colección de
ciones capturadas en cada instante de tiempo a un archivo de video. La instalación software libre que puede
grabar, convertir
de esta utilidad, que depende del tipo y versión de sistema operativo, queda fuera del
(transcodificar) y realizar
alcance de este texto. streaming de audio y vídeo.
FFmpeg está desarrollado en
GNU/Linux, pero puede ser
El siguiente código muestra como añadir una exportación en formato de vídeo para compilado en la mayoría de
los sistemas operativos,
poder ver como se ha desarrollado el agente en un entorno específico, en este caso incluyendo Windows.

1
https://es.wikipedia.org/wiki/One-hot
2
https://www.ffmpeg.org/
CC-BY-SA • • 26 Introducción a OpenAI Gym

concreto en “MountainCar”.
1 import gym
2
3 if __name__ == " __main__ " :
4 env = gym . make ( " MountainCar - v0 " )
5 env = gym . wrappers . Monitor ( env , " recording " , force = True )
6
7 total_reward , total_steps , done = 0.0 , 0 , False
8 obs = env . reset ()
9
10 while not done :
11 action = env . action_space . sample ()
12 obs , reward , done , _ = env . step ( action )
13 total_reward += reward
14 total_steps += 1
15
16 print ( " Episode done in {} steps , total reward {} " . format ( total_steps , total_reward ) )
17 env . close ()
18 env . env . close ()

Como se puede ver en el código anterior, la inicialización del monitor se realiza me-
diante una llamada a la clase gym.wrappers.Monitor, que recibe como parámetros el
entorno creado, el directorio donde almacenará el video y los ficheros de exportación
y, finalmente, el parámetro force=True que indica que se desea sobrescribir el direc-
torio en caso de que ya exista. Como se puede apreciar, el monitor funciona como un
wrapper más de la API de Gym.

Figura 7. Ejemplo del desarrollo del agente en el problema “MountainCar”.

La Figura 7 muestra un frame del video generado, donde podemos ver la interacción
del agente con el entorno durante todo el episodio.
CC-BY-SA • • 27 Introducción a OpenAI Gym

5. Ejemplo básico con OpenAI Gym


.

El objetivo de este ejemplo no es la implementación de un agente que pueda solucionar


un determinado problema, sino simplemente proporcionar un código de ejemplo que
pueda servir de base para desarrollar e implementar el código de un agente propio
empleando la librería Gym.

Para desarrollar este ejemplo emplearemos el entorno CartPole, dado que es relativa-
mente sencillo pero nos permite mostrar los conceptos que queremos ilustrar mediante
este ejemplo.

El entorno CartPole1 de Gym, como hemos visto en la sección 3.1, se basa en controlar
una plataforma con un poste conectado por su parte inferior, donde el truco es que
este poste tiende a caer hacia la derecha o hacia la izquierda y debe ser equilibrarlo
moviendo la plataforma hacia la derecha o hacia la izquierda en cada paso con el fin
de mantener el poste en posición vertical.

A continuación, presentamos el ejemplo de código que pasaremos a discutir seguida-


mente:
1 import gym
2 import numpy as np
3
4 env = gym . make ( ’ CartPole - v0 ’)
5 print ( " Action space is {} " . format ( env . action_space ) )
6 print ( " Observation space is {} " . format ( env . ob ser vat ion _sp ace ) )
7 print ( " Reward range is {} " . format ( env . reward_range ) )
8
9 # Environment reset
10 obs = env . reset ()
11 t , total_reward , done = 0 , 0 , False
12
13 while not done :
14 # Render the environment
15 env . render ()
16
17 # Get random action
18 action = env . action_space . sample ()
19
20 # Execute action and get response
21 new_obs , reward , done , info = env . step ( action )
22 print ( " Obs : {} -> Action : {} and reward : {} " . format ( np . round ( obs , 3) , action , reward ) )
23
24 obs = new_obs
25 total_reward += reward
26 t += 1
27
28 print ( " Episode finished after {} timesteps and reward was {} " . format ( t +1 , total_reward ) )
29 env . close ()

A continuación mostramos el resultado de la ejecución del código anterior. Es impor-


tante notar que cada ejecución mostrará unos resultados ligeramente diferentes, dado

1
https://gym.openai.com/envs/CartPole-v0/
CC-BY-SA • • 28 Introducción a OpenAI Gym

que las acciones son aleatorias y, por lo tanto, el número de iteraciones y recompensa
total pueden diferir en cada ejecución.
1 Action space is Discrete (2)
2 Observation space is Box (4 ,)
3 Reward range is ( - inf , inf )
4 Observation : [ 0.007 -0.049 0.047 -0.014] -> Action : 1 and reward : 1.0
5 Observation : [ 0.006 0.145 0.047 -0.292] -> Action : 0 and reward : 1.0
6 Observation : [ 0.009 -0.051 0.041 0.015] -> Action : 0 and reward : 1.0
7 Observation : [ 0.008 -0.246 0.041 0.321] -> Action : 1 and reward : 1.0
8 Observation : [ 0.003 -0.052 0.048 0.041] -> Action : 0 and reward : 1.0
9 Observation : [ 0.002 -0.248 0.048 0.348] -> Action : 0 and reward : 1.0
10 Observation : [ -0.003 -0.443 0.055 0.656] -> Action : 0 and reward : 1.0
11 Observation : [ -0.012 -0.639 0.069 0.966] -> Action : 0 and reward : 1.0
12 Observation : [ -0.024 -0.835 0.088 1.279] -> Action : 1 and reward : 1.0
13 Observation : [ -0.041 -0.641 0.113 1.015] -> Action : 0 and reward : 1.0
14 Observation : [ -0.054 -0.838 0.134 1.341] -> Action : 1 and reward : 1.0
15 Observation : [ -0.071 -0.644 0.161 1.093] -> Action : 0 and reward : 1.0
16 Observation : [ -0.084 -0.841 0.182 1.432] -> Action : 1 and reward : 1.0
17 Episode finished after 14 timesteps and total reward was 13.0

En la línea 4 creamos el entorno mediante la función gym.make(), indicando que en


este caso queremos instanciar el problema CartPole en su versión 0.

A continuación mostramos por pantalla algunos valores importantes que son depen-
dientes del entorno que hemos seleccionado:

• Rango de acciones válidas, que podemos obtener a partir de la propiedad action_space.


En este caso, nos indica que se trata de Discrete(n=2), es decir, que las acciones
pueden coger el valor 0 o 1.

• Espacio de observaciones, es decir, qué tipo de datos nos devuelve el entorno


después de aplicar cada una de las acciones. En este caso, vemos que nos indica
que se trata de de un vector unidimensional de cuatro valores, expresado mediante
la clase Box(4,).

• Rango de valores posibles para la recompensa (reward ), que vemos que se trata
de un valor numérico en el rango (−∞, ∞).

Después de crear el entorno, debemos inicializarlo mediante la función reset() para


que nos proporcione una primera observación del estado actual del entorno.

A partir de este punto iniciamos un bloque de iteraciones que finaliza cuando el en-
torno nos indica que ha finalizado el episodio (done==True). Dentro de este bloque
realizamos un conjunto de operaciones que definen la secuencia de acciones y respues-
tas del entorno:

• Tenemos la posibilidad de visualizar el estado actual del entorno, mediante la


función render().

• Escogemos una acción a realizar por parte del agente. En este caso concreto,
escogemos una acción aleatoria dentro del espacio de acciones válidas para este
entorno, mediante la función sample(). En general, debemos aplicar el modelo
deseado para que nos genere la acción más apropiada para cada estado concreto.
CC-BY-SA • • 29 Introducción a OpenAI Gym

• A continuación, indicamos la acción a realizar por parte del agente, a partir de la


función step() del entorno. El entorno nos devuelve la respuesta a la acción reali-
zada, que al igual que la primera observación devuelta después de la inicialización,
está compuesta de cuatro variables:

1) Una nueva observación del estado del entorno después de aplicar la acción del
agente.

2) El valor de la recompensa asociado a la acción que el agente ha realizado.

3) Un valor booleano indicando si ha finalizado el episodio.

4) Información adicional del estado.

Finalmente, se calcula la recompensa total (como la suma de las recompensas par-


ciales) y se cierra en entorno mediante la función close(), dando por terminado el
episodio y el ejemplo.
CC-BY-SA • • 30 Introducción a OpenAI Gym

Resumen

En este módulo hemos visto una introducción a la librería Gym, que ha sido creada
y es mantenida por la entidad OpenAI con el objetivo de empujar el avance del
aprendizaje por refuerzo (RL) en la comunidad científica.

Hemos iniciado este módulo viendo las principales características de Gym, así como
los objetivos y otros proyectos de interés de OpenAI. Como hemos visto, Gym ofrece
una gran cantidad de entornos muy variados donde poder probar nuestras implemen-
taciones de agentes para evaluar el grado de consecución y poder comparalos con
otras implementaciones, propias o de terceros.

A continuación, hemos revisado el esquema básico de un entorno de RL, donde es


importante entender la estructura del agente y el entorno, así como el flujo de infor-
mación y comunicación entre ambos. Como hemos visto, la clase principal de Gym es
la clase que implementa el entorno (Env) y que ofrece las observaciones, recompensas
y demás información al agente a partir de sus acciones y de la situación actual del
entorno específico en el que se está actuando.

Además, hemos visto algunas clases importantes que nos permiten implementar un
código más limpio, encapsulado y reusable, como son los wrappers implementados en
Gym.

Finalmente, hemos comentado el código completo de implementación de un ejemplo


sencillo empleando la librería Gym. El objetivo de esto ejemplo no es la implementa-
ción de un agente que pueda solucionar un determinado problema, sino simplemente
proporcionar un código de ejemplo que pueda servir de base para desarrollar e imple-
mentar el código de un agente propio empleando la librería Gym.
CC-BY-SA • • 31 Introducción a OpenAI Gym

Glosario

OpenAI OpenAI es un laboratorio de investigación con sede en San Francisco, Ca-


lifornia, cuya misión es “garantizar que la inteligencia artificial beneficie a toda la
humanidad”. Fue fundada en octubre de 2015 por Musk, Altman y otros inversores
que anunciaron la formación de la organización. El 27 de abril de 2016, OpenAI lanzó
una versión beta pública de Gym.

FFmpeg FFmpeg es una colección de software libre que puede grabar, convertir
(transcodificar) y realizar streaming de audio y vídeo. FFmpeg está desarrollado en
GNU/Linux, pero puede ser compilado en la mayoría de los sistemas operativos,
incluyendo Windows.
CC-BY-SA • • 32 Introducción a OpenAI Gym

Bibliografía

Maxim Lapan (2020). Deep Reinforcement Learning Hands-On (Second Edition). Packt
Publishing. ISBN: 9781838826994

Richard S. Sutton and Andrew G. Barto (2018). Reinforcement Learning: An Intro-


duction (Second Edition). MIT Press, Cambridge, MA, 2018

OpenAI. Gym. Accesible en http://gym.openai.com/ [Accedido en 13 de mayo de 2020]

OpenAI. OpenAI Spinning Up. Accesible en https://spinningup.openai.com/en/latest/


[Accedido en 13 de mayo de 2020]

También podría gustarte