InteligenciaArtificial paraVideojuegoscon DeepReinforcement … · 2020. 6. 27. · En segundo lugar, a nivel personal, en diferentes asignaturas del grado he obtenido conocimiento

Escuela

Politécnica

Superior

Inteligencia Artificialpara Videojuegos conDeep ReinforcementLearning

Grado en Ingeniería Multimedia

Trabajo Fin de Grado

Autor:Álvaro Molina GarcíaTutor/es:José García RodríguezPablo Martínez González

Mayo 2020

Inteligencia Artificial para Videojuegoscon Deep Reinforcement Learning

AutorÁlvaro Molina García

Tutor/esJosé García Rodríguez

Departamento de Tecnología Informática y ComputaciónPablo Martínez González

Departamento de Tecnología Informática y Computación

Grado en Ingeniería Multimedia

Escuela

Politécnica

Superior

ALICANTE, Mayo 2020

AbstractIn this project, we propose a connection mechanism between a virtual environment and aPython program using the client-server model. Hence, we have created a plugin in UnrealEngine (UE) which act as the server and it communicates with the external program. It’sthanks to it that we are able to modify the scene and obtain information from it usingpredefined commands.

This feature has been added to UnrealROX 1, a project that allow us to control a hu-manoid robot using Realidad Virtual (RV) hardware. It record our movements, then theyare reproduced and finally we obtain images to create photorealistic synthetic data to trainneural networks.

With the developed funcionalities, we can obtain these images in real time while we modifythe scene in command mode, allowing us to use this environment to develop Deep Reinforce-ment Learning (DRL) strategies. In this paradigm we need an agent that executes actions inthe scene and it receives a reward depending on the desired objective.

To test this, we have created an environment with obstacles where a network created withPytorch is able to learn how to control an agent to move to a location without collide withthe obstacles. To achieve that it receives an image of the current state of the environmentand the reward of the previous movement. This image can be an aerial view of the situationor a first person one, depending of the version.

1https://github.com/3dperceptionlab/unrealrox

v

ResumenEn este proyecto, proponemos un mecanismo de conexión de un entorno virtual con unprograma en Python en forma de cliente-servidor. Para ello, hemos creado un plugin en UEque ejerce la función de servidor y con el cual se comunica el programa externo. Graciasa esto podemos modificar la escena y obtener información de esta mediante unos comandosdefinidos.

Esta funcionalidad se ha integrado en el proyecto UnrealROX 1, en el cual podemos con-trolar un robot humanoide usando hardware de RV. En él, nuestros movimientos se graban,posteriormente se reproducen y se obtienen imágenes con la finalidad de crear datos sintéticosfotorrealistas para entrenar redes neuronales.

Con los cambios desarrollados, podemos obtener las imágenes en tiempo real mientras mod-ificamos la escena en modo comando, lo que nos permite utilizar el entorno para desarrollarestrategias de DRL. En este paradigma necesitamos a un agente que realice acciones en unaescena y reciba una recompensa según la finalidad deseada. A partir de estas recompensas,la red puede realizar mejores acciones.

Para ponerlo a prueba, hemos creado un entorno con obstáculos, donde una red creadausando Pytorch es capaz de aprender a controlar a un agente hasta un punto específico sincolisionar con ellos. Para conseguirlo, recibe una imagen del entorno en el estado actual yla recompensa del movimiento anterior. Esta imagen puede ser una vista aérea o primerapersona según la versión.

1https://github.com/3dperceptionlab/unrealrox

vii

Agradecimientos

Este proyecto no habría sido posible sin mi tutor, José García, por haber propuesto este temay por su ayuda durante este año. También quiero dar las gracias, por el apoyo y los consejos,a los miembros del Departamento de Tecnología Informática y Computación, en particulara Pablo Martínez , John Castro, Sergiu Ovidiu y Albert García. Tampoco puedo olvidarmede la compañía y ayuda de Daniel Allhoff; ya que hemos vivido esta aventura juntos y noshemos ayudado mutuamente.

Por último, quiero agradecer a mis amigos y familia por su ánimo e interés durante esteproceso. Dedico este trabajo a todos y cada uno de ellos.

ix

El genio se compone del dos por ciento de talentoy del noventa y ocho por ciento de perseverante aplicación.

Ludwig van Beethoven.

xi

Índice general

Abstract v

Resumen vii

Agradecimientos ix

Lista de Acrónimos y Abreviaturas xxi

1 Introducción 11.1 Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Propuesta y Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Planificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4 Estructura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Estado del Arte 52.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2 Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.3 Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.3.1 Perceptrón . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.3.2 Redes neuronales profundas . . . . . . . . . . . . . . . . . . . . . . . . 72.3.3 Convoluciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.3.4 Recurrencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.4 Reinforcement Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.4.1 Q-learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.5 Aplicaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3 Materiales 213.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.2 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.2.1 Unreal Engine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.2.2 Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.2.3 Docker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.2.4 Jupyter Notebook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.2.5 Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.2.5.1 Tensorflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.2.5.2 Keras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.2.5.3 Pytorch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.3 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

xiii

xiv Índice general

4 Extensión de UnrealROX para RL 274.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.2 UnrealROX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.3 Conexión Cliente-Servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.4 Comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

5 Pruebas de Deep Reinforcement Learning 335.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.2 Descripción del cliente y el entorno . . . . . . . . . . . . . . . . . . . . . . . . 335.3 Pruebas con vista cenital . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365.4 Pruebas en primera persona . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

6 Conclusiones 416.1 Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416.2 Trabajo futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

Bibliografía 43

Lista de Figuras

1.1 Diagrama Gantt del proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2.1 Estructura de un perceptrón . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2 Esquema de una red neuronal profunda, que cuenta con tres capas ocultas

entre la capa de entrada y la de salida. Imagen obtenida de http://uc-r.github.io/feedforward_DNN . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.3 Convolución estrecha y ancha. Ambas con filtro de tamaño m = 5. . . . . . . 92.4 Ejemplo de convolución 2D con una entrada de 4x4, un filtro de 3x3 y una

salida de 2x2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.5 Max Pooling y Average Pooling en matrices 4x4 con un tamaño de región de 2x2 102.6 Estructura básica de una red neuronal recurrente . . . . . . . . . . . . . . . . 112.7 Estructura interna de una célula Long Short Term Memory (LSTM) . . . . . 122.8 Esquema de reinforcement learning . . . . . . . . . . . . . . . . . . . . . . . . 132.9 Ejemplo simple de Q-learning . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.10 Imágenes de Breakout y Space Invaders, juegos usados en el artículo ”Playing

Atari with Deep Reinforcement Learning” . . . . . . . . . . . . . . . . . . . . 152.11 Imagen del juego Starcraft II . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.12 Esquema de la red neuronal empleada en VizDoom, obtenida de [15] . . . . . 162.13 Imagen del juego TORCS siendo controlado por el algoritmo FIGAR extraída

de https://www.youtube.com/watch?v=dX8J-sF-WX4 . . . . . . . . . . . . . 172.14 Frames de los juegos Superman (derecha) y Wait For BreakFast (izquierda) . 172.15 Comparación del rendimiento de Agent57 con la media humana y otros agentes.

Obtenida de https://deepmind.com/blog/article/Agent57-Outperforming-the-human-Atari-benchmark . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4.1 Imagen de UnrealROX en la que el agente está agarrando una fruta con la mano 284.2 Resultado del comando object_list, que muestra el identificador de todos los

actores de la escena que pueden ser movidos en la escena actual. . . . . . . . 30

5.1 Captura del entorno que está formado por las paredes y los obstáculos de colorazul, del agente que controlamos de rojo y el destino de verde. Además se hanañadido unas lineas amarillas para delimitar la zona en la que puede aparecercada uno de estos elementos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5.2 Primera prueba en vista cenital en azul. En rojo podemos ver una repeticiónde la misma prueba para comprobar si se obtienen siempre mejores resultadosque en la Figura 5.3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

xv

xvi Lista de Figuras

5.3 En azul se muestran los resultados de la segunda prueba. En ella se aumentala cantidad de intentos y se modifica el valor de ϵ-greedy para que alcance suvalor más bajo en 5000 intentos. En rojo podemos ver la tercera prueba, enla que se pone un límite de 300 movimientos a cada intento, contando comoderrota si se supera ese número. . . . . . . . . . . . . . . . . . . . . . . . . . . 38

5.4 Vista en primera persona del agente, utilizada como entrada para la red neu-ronal en estas pruebas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5.5 Pruebas en primera persona. La diferencia entre ellas es que en la azul, losgiros que realiza el agente son de 90º, mientras que en la roja son de 15º, paradar mayor libertad de movimiento. . . . . . . . . . . . . . . . . . . . . . . . . 40

Lista de Tablas3.1 Especificaciones hardware de mi ordenador personal . . . . . . . . . . . . . . 253.2 Especificaciones hardware de Asimov . . . . . . . . . . . . . . . . . . . . . . . 26

xvii

Lista de Códigos5.1 Creación de la red neuronal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.2 Bucle de aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345.3 Refuerzo del entorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

xix

Lista de Acrónimos y Abreviaturas

ALE Arcade Learning Environment.API Application Programming Interface.CNN Convolutional Neural Network.CPU Central Processing Unit.DL Deep Learning.DRL Deep Reinforcement Learning.DTIC Departamento de Tecnología Informática y Com-

putación.GPU Graphics Processing Unit.GVGAI General Video Game AI.IA Inteligencia Artificial.LSTM Long Short Term Memory.ML Machine Learning.PDM Proceso de Decisión de Markov.RL Reinforcement Learning.RNN Recurrent Neural Network.RV Realidad Virtual.TCP Transmission Control Protocol.TFG Trabajo Final de Grado.UE Unreal Engine.

xxi

1 Introducción

En este proyecto hemos explorado el campo del DRL y su aplicación en los videojuegos. Paraello hemos investigado diversas formas en las que se han utilizado técnicas de Deep Learning(DL) en entornos virtuales. Además, se ha implementado una arquitectura cliente-servidorque permite la interacción de un programa externo, mediante funciones de Python, con unaescena virtual tridimensional ejecutándose en el motor gráfico de videojuegos Unreal Engine.Dicha funcionalidad ha sido incorporada a la herramienta UnrealROX, desarrollada por com-ponentes del grupo 3DPLab del Departamento de Tecnología Informática y Computación(DTIC) en la Universidad de Alicante. Hemos usado esta herramienta para realizar prue-bas en las que un agente que se mueve en un entorno virtual debe aprender a conseguir unobjetivo, contando únicamente con la información obtenida por su vista y el refuerzo que elentorno ejerce sobre él tras llevar a cabo cualquier acción.

1.1 Motivación

En primer lugar, este proyecto surge de la colaboración con miembros del grupo 3DPLab delDTIC, que se centran en la investigación en técnicas de Aprendizaje automático, Visión porcomputador y Computación paralela sobre procesadores gráficos, entre otros. Esta colabo-ración ha servido principalmente para ampliar las funcionalidades del proyecto UnrealROX,permitiendo utilizar sus funciones desde un programa externo en tiempo real.

En segundo lugar, a nivel personal, en diferentes asignaturas del grado he obtenido conocimientobásico de Inteligencia Artificial (IA) aplicado a los videojuegos, pero nunca había profun-dizado en ninguna forma de aprendizaje automático. Después de investigar, y de observartécnicas actuales y los grandes resultados que podían llegar a conseguir, decidí que queríaaprender sobre este campo, acotándolo finalmente al DRL.

1.2 Propuesta y Objetivos

El principal propósito de este proyecto es conseguir que un agente aprenda a realizar unatarea de manera autónoma en un entorno desconocido. Por esta razón, vamos a estudiar lasdistintas técnicas basadas en DL aplicadas a problemas similares. Para ser capaz de aprender,será obligatorio que se reciba algún tipo de retroalimentación cada vez que realice una acción,por tanto, es esencial crear una función que evalúe la eficiencia de las decisiones tomadas.También vamos a necesitar almacenar esa información, para, posteriormente, poder elegir lasolución más eficiente.

Vamos a desarrollar un entorno de trabajo en el que poder controlar las acciones del agentey obtener información de la escena desde un programa externo. Para ello partimos de Un-realROX, una herramienta creada sobre UE para extraer datos sintéticos de gran precisión

1

2 Introducción

y variedad a partir de una simulación que se ejecute en el motor gráfico. Estos datos, prin-cipalmente imágenes, son útiles para entrenar redes neuronales, para las cuales no siemprese pueden obtener suficientes datos etiquetados del mundo real, por lo que la generaciónsintética cobra importancia. El principal cambio que se va a introducir en la herramientacon este proyecto es, crear un servidor que permita la comunicación con un programa ex-terno. Además, se habilitarán unos comandos que permitirán al cliente modificar el entornovirtual de diversas formas, mover al agente y obtener información de la escena en tiempo deejecución.

1.3 PlanificaciónEl proyecto definido se va a llevar a cabo en 7 meses, comenzando a principios de noviembre yterminando el 25 de mayo, contando con la colaboración con miembros del 3DPLab del DTICde la Universidad de Alicante. Las diferentes partes del desarrollo del proyecto se puedenobservar en la Figura 1.1.

En ella podemos observar como las tareas están divididas en tres grupos. En el primero deellos se encuentra la etapa de aprendizaje, tanto de los distintos conceptos teóricos, como delmanejo de las herramientas que se van a utilizar. Estas tareas se van a llevar a cabo duranteel primer mes y medio, ya que es necesario adquirir estos conocimientos antes de progresarcon las demás tareas.

Figura 1.1: Diagrama Gantt del proyecto

El siguiente grupo está formado por las tareas relacionadas a la programación y experi-mentación. Se encuentra dividida en dos partes, en el primero se va a crear el entorno detrabajo que vamos a utilizar y probarlo realizando un caso de ejemplo básico. En la segundaparte se mejora tanto el entorno de trabajo con nuevos comandos, como los experimentos, yaque contamos con la experiencia anterior. Empieza a mitad de diciembre y termina el 21 demarzo, aunque hay un intervalo de casi un mes entre ambas partes.

Por último se encuentra la redacción de este documento y los distintos capítulos que lo

1.4. Estructura 3

componen. Esta parte va a comenzar a principios de febrero y continuará hasta el final delproyecto.

1.4 EstructuraLa estructura de este documento es la siguiente: En el presente Capítulo 1 se hace unaintroducción del proyecto, la motivación de este, los objetivos que se quieren conseguir ycomo se van a alcanzar. Seguidamente, el Capítulo 2 describe los conceptos subyacentesal proyecto, y de qué forma se han utilizado técnicas de IA y DL en videojuegos y otrosproyectos similares durante los últimos años. En el Capítulo 3 se encuentra una descripcióndel hardware y software utilizados para la realización de los experimentos. A continuación,el Capítulo 4 explica la parte relativa a la extensión desarrollada para UnrealROX, y sedescriben los comandos que permiten la interacción con la escena virtual. En el Capítulo 5se describen las pruebas que se han llevado a cabo haciendo uso de técnicas de DRL, y sepresentan y analizan los resultados obtenidos. Por último, en el Capítulo 6 se extraen lasconclusiones del trabajo realizado y se presentan futuras lineas de investigación relacionadas.

2 Estado del Arte

2.1 IntroducciónEn los siguientes apartados vamos a describir y mostrar ejemplos de DRL, que podemosdefinir como la integración de aprendizaje profundo o Deep Learning DL y aprendizaje porrefuerzo o Reinforcement Learning (RL), las cuales han sido seleccionadas como una de las10 tecnologías emergentes en el 2013 y 2017, respectivamente, por la revista MIT TechnologyReview 1. Estas tecnologías juntas forman un marco de trabajo en el que podemos definirun objetivo usando aprendizaje por refuerzo mientras que con las redes neuronales contamoscon un mecanismo para aprender a llegar a ese objetivo a partir de los datos de entrada.

Así pues, vamos a comenzar explicando los fundamentos del aprendizaje automático ocomo es habitualmente denominado ”Machine Learning”. Posteriormente, explicaremos lascaracterísticas del DL y sus diferentes tipos. A continuación, desarrollaremos las propiedadescaracterísticas del RL. Y, en último lugar, distintas aplicaciones de DRL en el mundo de losvideojuegos.

2.2 Machine LearningMachine Learning (ML) es una rama de la IA basada en la idea de que los sistemas puedenaprender de los datos. Generalmente se busca que a partir de unas muestras de datos secree un modelo o programa sin tener que escribirlo específicamente. Esos modelos generadostienen que ser capaces de generalizar comportamientos para un conjunto más amplio de datosque los que han recibido.

Es una alternativa al enfoque ingenieril tradicional ya que normalmente se empieza adquiriendoconocimiento sobre el problema y se crea un modelo matemático que lo representa. Basadoen ese modelo se crean un algoritmo optimizado que ofrece una garantía de rendimientoasumiendo que el modelo representa de forma precisa la realidad [33].

Sin embargo, en su forma más básica, el enfoque de ML sustituye el paso de adquirirconocimiento con la tarea de recolectar un gran numero de ejemplos del comportamientodeseado, lo cual suele ser un tarea más fácil. Los ejemplos encontrados se introducen en unalgoritmo de aprendizaje que produce un programa capaz de llevar a cabo la tarea deseada.Además del ejemplo básico descrito anteriormente, las herramientas de ML pueden integrarel conocimiento sobre el problema en el proceso de aprendizaje, lo cual es en muchos casos laclave del éxito como en el procesamiento de imágenes.

Los algoritmos se dividen principalmente en tres tipos:

• Supervisado: el conjunto de datos de entrenamiento consiste en pares de entradas y lasalida esperada, siendo el objetivo aprender un mapeo entre las entradas y las salidas.

1https://www.technologyreview.com/

5

6 Estado del Arte

La salida de la función puede ser un valor numérico para problemas de regresión o laetiqueta de una clase para clasificar.

• No supervisados: el conjunto de datos de entrenamiento consiste en entradas sin unasalida deseada. Normalmente, sirve para descubrir propiedades desconocidas del mecan-ismo que genera los datos y separar estos datos en grupos que comparten alguna car-acterística similar.

• Con refuerzo: se encuentra entre en aprendizaje supervisado y el no supervisado. Existeuna especie de supervisión, pero no es tan explícita como en el supervisado porque nose provee una salida deseada. En este caso el algoritmo recibe retroalimentación delentorno después de seleccionar una salida a la entrada actual. Esa información recibidaindica el grado en que la salida cumple con los objetivos deseados. Se hablara enprofundidad de este tipo en la Sección 2.4.

2.3 Deep LearningDL es un campo derivado de ML inspirado en la estructura y funcionamiento del cerebro.Para ello se utilizan redes neuronales artificiales, que cuentan con una estructura de grafoy son capaces de, dada una entrada, aprender la correspondiente salida y generalizar eseconocimiento a una nueva entrada nunca vista anteriormente [29]. Estas redes están com-puestas por múltiples capas de neuronas que se encargan de realizar cálculos matemáticos.En cada capa, excepto en la primera, calculamos la entrada a cada unidad como la sumaponderada de las unidades de la capa anterior, entonces se le aplica una transformación nolineal o función de activación a la entrada para obtener una nueva representación [18].

La primera red neuronal de la que se tiene constancia fue creada por Warren McCullochy Walter Pitts en el año 1943 [21], que consta de la suma de las entradas multiplicadas porunos pesos escogidos de forma aleatoria. La entrada se compara con un patrón preestablecidoque determina la salida de la red, si la suma de las entradas multiplicadas por los pesos esmenor que dicho patrón, la salida es cero, en caso contrario es 1.

2.3.1 PerceptrónEstas unidades mencionadas anteriormente son conocidas como perceptrones, una estructurapropuesta por Frank Rosenblat [28] como una forma de representar una neurona binariaartificial con el fin de ser usada en tareas de clasificación lineal.

En la Figura 2.1 podemos observar la estructura de un perceptrón con varias entradas. Sepueden observar los distintos componentes que lo conforman: (1) Entradas, son los valoresnuméricos que recibe el perceptrón para predecir la salida; puede haber un gran número deentradas, pero debe ser siempre el mismo número durante la ejecución. (2) Pesos, tienenun valor aleatorio inicializado al comienzo que se multiplica por la entrada que recibe. Enalgunas ocasiones se le suma un parámetro fijo, denominado bias, para tener mayor controlsobre la salida. (3) El sumatorio de los resultados obtenidos en el paso anterior, que esconsiderado la salida de este. Aunque este valor se puede ver modificado por (4) la funciónde activación, que se encarga de dar una salida en un rango. Algunos tipos de funcionesde activación son: sigmoide que transforma los valores en un rango de (0,1), la tangente

2.3. Deep Learning 7

hiperbólica entre (-1,1), relu que transforma los valores negativos a 0 y softmax que generala salida en forma de probabilidades que suman 1.

Figura 2.1: Estructura de un perceptrón

Mediante diversas investigaciones se pudo demostrar que el perceptrón era capaz de clasi-ficar patrones de forma correcta y responder de manera coherente a patrones aleatorios. Perose veía afectada su precisión a medida que aumentaba la cantidad de patrones que tiene queaprender. En 1969 se publicó Perceptrons: An introduction to Computational Geometry[20], en el que se presentaba un extenso y detallado análisis del perceptrón, gracias al cualgano gran popularidad. Así mismo, descubrió la mayor restricción que existe para este tipode redes, su incapacidad para solucionar problemas que no sean linealmente separables. Apesar de esta limitación, sigue siendo actualmente muy importante ya que sirve como basepara otros modelos de redes neuronales como las redes multicapa.

2.3.2 Redes neuronales profundas

El siguiente paso después de introducir los perceptrones, son las redes neuronales multicapa(Figura 2.2), también conocidas como perceptrones multicapa. Estas capas se dividen en 3tipos: (1) capa de entrada, que gestiona la información que recibe la red; (2) capas ocultas,donde se realizan distintos cálculos matemáticos con los datos procedentes de la capa deentrada (en la mencionada figura podemos ver que se tienen tres capas ocultas, el adjetivo deprofundas para estas redes se debe a que fácilmente se pueden llegar a tener un número altode capas ocultas, como pueden ser más de 100 capas [34], o incluso con más de 1000 [9]); (3)la capa de salida, de la cual obtenemos la información procesada. Esta capa puede tener unaúnica salida, que puede ser el valor predicho, o puede haber varias salidas cuando se tratade un problema de clasificación, caso en el que cada salida indica la probabilidad de que setrate de esa opción.

Cada neurona recibe una entrada de todas las neuronas de la capa anterior y produce unaúnica salida que servirá como entrada a la siguiente capa de la red, es por eso importanteque la forma de entrada y la salida de una capa corresponda con la salida esperada y entradade las capas adyacentes, permitiendo así realizar multiplicaciones de matrices. También hay

8 Estado del Arte

que destacar que entre las neuronas de una misma capa no existe relación o comunicación,como se puede observar en la figura 2.2.

Figura 2.2: Esquema de una red neuronal profunda, que cuenta con tres capas ocultas entre la capade entrada y la de salida. Imagen obtenida de http://uc-r.github.io/feedforward_DNN

2.3.3 ConvolucionesComo hemos dicho anteriormente, en las redes neuronales artificiales cada capa recibe comoentrada todas las salidas de la capa anterior. Esta característica genera un problema, cuandolos datos están relacionados espacialmente, esta relación se pierde. Un ejemplo de esto seríauna imagen, en la que cada píxel tiene una posición respecto a los demás. Para resolvereste problema podemos usar Convolutional Neural Network (CNN), que son un tipo de redesneuronales que reemplazan las multiplicaciones de matrices con convoluciones en, al menos,una capa [16].

Una convolución de una dimensión es una operación entre un vector de pesos m, tambiénconocido como el filtro de la convolución y un vector de entrada s, que es el que se quieremodificar. La idea es producir una tercera función cuyo valor exprese como s es modificadopor m. Para ello es necesario hacer el producto escalar del vector m con cada parte del vectors para obtener otro nuevo vector c:

cj = mtsj−m+1:j

Esta ecuación da lugar a dos tipos de convoluciones dependiendo del rango del índice j.La convolución estrecha requiere que s ≥ m y produce un vector c ∈ Rs−m+1 con j oscilandode m a s. El tipo ancho no tiene ningún requerimiento de m o s y produce una secuenciac ∈ Rs+m−1, en este caso los valores de entrada si donde i < 1 o i < s se toman como 0. Elresultado de la forma estrecha parte del resultado de la forma ancha como se puede observaren la figura 2.3.

Las convoluciones de una dimensión son utilizadas, por ejemplo en el ámbito del lenguaje,ya que las palabras están relacionadas con sus adyacentes, podemos encontrar ejemplos en losque se utilizan para analizar y crear nuevas frases [14] o unir distintas oraciones [11]. Pero,normalmente, se habla de convoluciones en 2 dimensiones para el tratamiento de imágenes.


Figura 2.3: Convolución estrecha y ancha. Ambas con filtro de tamaño m = 5.

En estos caso se repite la misma operación pero con matrices. En la figura 2.4 podemos verun ejemplo de una convolución 2D. En ella observamos como se multiplica una parte de lamatriz de entrada por el filtro y el resultado de esa multiplicación se añade a la nueva matrizde salida en la posición correspondiente. Se empieza a multiplicar por las posiciones de laparte superior izquierda del mismo tamaño del filtro, posteriormente, se repite el procesocogiendo las siguientes posiciones.

Figura 2.4: Ejemplo de convolución 2D con una entrada de 4x4, un filtro de 3x3 y una salida de 2x2.

Además de la operación de convolución, una CNN se caracteriza por dos elementos im-portantes: la conectividad local, compartir peso y reducción o pooling. Normalmente, en lasredes neuronales cada neurona de una capa recibe la entrada de todas las neuronas de lacapa anterior, teniendo el problema de no conservar la relación espacial de los valores. Eneste caso, una neurona está conectada solamente a un pequeño numero de neuronas espacial-mente cercanas, teniendo el mismo tamaño que el filtro de la convolución. Gracias a esto, laestructura espacial de la entrada se mantiene a través de las distintas capas de la red.

En las capas totalmente conectadas, cada neurona de una capa oculta tendría un biaspropio y cada conexión con la siguiente capa aprendería un peso distinto. En CNN se cambiaesto para que el mismo peso y bias sea usado por cada neurona de la capa. Esto reducedrásticamente el número de parámetros. Así mismo, esto conlleva que todas las neuronas dela red detecten la misma característica, porque usan el mismo filtro, pero cada una lo haráen una zona de la entrada distinta.

Además de las capas de convolución, las CNN también contienen capas de reducción opooling que se encuentran siempre después de una capa de convolución. Estas capas sirvenpara simplificar los resultados de la capa anterior. El concepto de estas capas es que una vezencontrada una característica en las capas anteriores, su localización en el mapa no es tanimportante como su localización relativa a otras características. Esta simplificación hace quese reduzca el número de parámetros y decrementa el coste computacional de la red [7].

10 Estado del Arte

Hay distintas operaciones de pooling, la más común es max-pooling. En este caso, cadaregión da como resultado el máximo valor de las neuronas contenidas. Otra de las másutilizadas es average pooling, en la que el resultado es la media de los valores de la región,Figura 2.5.

Figura 2.5: Max Pooling y Average Pooling en matrices 4x4 con un tamaño de región de 2x2

2.3.4 RecurrenciaLas redes que hemos visto hasta ahora, reciben una entrada y generan una salida, sin tenermás información en cuenta y son conocidas como redes neuronales prealimentadas. Estoes muy diferente a como funciona un cerebro y pensamos los humanos, que era uno de losmotivos por lo que surgían las redes neuronales. Ya que nosotros, al pensar, tenemos unosconocimientos previos almacenados en nuestra memoria, que nos aportan más información ala hora de tomar una decisión. Para resolver este problema surgieron las redes neuronalesrecurrentes (Recurrent Neural Network (RNN), en inglés).

RNN son un tipo de red neuronal que se usan especialmente para una serie de datostemporales, donde el estado oculto actual Ht puede depender no solo de la observación actualXt, sino también de otros estados anteriores Ht−1. Por ello podemos representar Ht como:

Ht = f(Ht−1, Xt)

donde f es un mapeo no lineal [5]. En este tipo de redes, en lugar de tener una solaentrada y salida, que es lo más normal en las redes prealimentadas, tenemos dos tipos deelementos: la entrada de la red y el estado oculto anterior de la red. Debido a ello, tambiénproduce una salida adicional, el estado oculto de la red, para ser usado como entrada en lasiguiente iteración. Este estado oculto actúa como una memoria y se encarga de incorporarinformación de las anteriores entradas y salidas a la predicción actual de la red.

En la Figura 2.6 podemos ver como en cada ocasión se recibe el estado oculto anterior,lo cual es un problema para la primera iteración, pues este estado anterior no existe. Lasolución habitual es la generación de un estado inicial aleatorio.

Pero este tipo de redes tienen un problema de desvanecimiento de gradiente. Debido a


Figura 2.6: Estructura básica de una red neuronal recurrente

que las RNN necesitan propagar hacia atrás los gradientes sobre una secuencia larga, el valordel gradiente se reducirá tras cada iteración, y finalmente desaparece después de unos pocospasos. Por lo tanto, los estados lejanos al tiempo actual no contribuyen a la computación delos parámetros del gradiente.

Para poder resolver este problema se propuso la LSTM [10] que extiende las RNN condos principales ventajas: introduce la célula de información y maneja las secuencias largasmejor. Esta célula es un tipo especial de nodo recurrente que se encarga de seleccionar queentradas debe recordar y olvidar la red. Para ello, divide el estado oculto tradicional de lasRNN en dos estados diferentes, una memoria a largo plazo y otra a corto plazo. Las LSTMestán organizadas en forma de cadena que está formada por cuatro capas interactivas conuna forma única de comunicación [17]. Esta estructura se puede ver en la figura 2.7, en ellapodemos ver como dos estados son transferidos a la siguiente célula, el oculto y el de la célula.Este último es esencial para que los datos fluyan largos periodos sin grandes cambios, aunquepueden sufrir alguna transformación lineal. Los datos pueden ser añadidos o retirados de ellamediante las capas sigmoide.

El primer paso es identificar la información que no es importante y será omitida en esepaso. En él recibimos la salida de la ultima unidad LSTM (ht−1) y la entrada actual (Xt).Entonces, la función sigmoide determina que parte eliminar. Esta parte corresponde en laFigura 2.7 con el primer sigmoide de la izquierda. Matemáticamente es representada comoft un vector que da valores en un rango entre 0 y 1, correspondiente a cada número en elestado de la célula Ct−1.

El siguiente paso tiene dos partes: (1) decidir si la información de la nueva entrada Xt esguardada, esto se vuelve a hacer en la capa sigmoide y (2) decidir el nivel de importanciadándole valor a los valores que han pasado el paso anterior, esto se hace con la función tahn.Posteriormente estos valores se multiplican y sirve para actualizar el estado de la célula. Estanueva memoria es añadida a la antigua Ct−1 dando lugar a Ct.

En el paso final, los valores de salida ht están basados en la salida del estado de la célulaOt, pero es una versión filtrada. En primer lugar, una capa sigmoide decide que partes delestado llegan a la salida. Después, la salida del sigmoide Ot es multiplicada por nuevos valorescreados por la capa tanh del estado de la célula Ct con un valores entre -1 y 1.

LSTM ha demostrado ser una de las mejores técnicas para tratar con datos de seriestemporales y han sido ampliamente utilizados en distintas industrias. Sus células pueden

12 Estado del Arte

Figura 2.7: Estructura interna de una célula LSTM

funcionar combinándose con otros elementos como convoluciones y técnicas de RL. Un buenejemplo se puede encontrar en [22], en el que se utiliza para reconocer objetivos dentro devideojuegos de mundo abierto o [1], la primera IA desarrollada con DL capaz de derrotar ajugadores profesionales en el videojuego Starcraft II.

2.4 Reinforcement Learning

Uno de los temas principales dentro de ML es la toma de decisiones secuenciales, es decir,decidir, teniendo en cuenta la experiencia, la secuencia de acciones a realizar en un entornodesconocido para conseguir cierto objetivo. Para ello surgió el aprendizaje por refuerzo oReinforcement Learning RL, que propone una infraestructura formal para este problema.

La idea principal es que un agente dotado con inteligencia puede aprender interactuandocon su entorno, de forma similar a la que sucede con los seres vivos. Posteriormente, elagente puede usar esa experiencia para optimizar ciertos objetivos que se le dan en formade recompensa [6]. Para ello el agente empieza en un estado en su entorno s0 y recoge unaobservación inicial w0. Cada vez que pase un tiempo t, el agente tiene que tomar una acciónat. Como podemos observar en la Figura 2.8 esto tiene tres consecuencias: (1) el agenteobtiene una recompensa rt, (2) el estado se convierte en st+1 y (3) el agente obtiene unanueva observación del entorno wt+1. Esta interacción es formalizada como un Proceso deDecisión de Markov (PDM) que es una tupla (s,A, T, r, γ), donde s es un finito número deestados, A un conjunto de acciones, T es la función de transición, r es la función de refuerzoy γ es el valor de descuento.

El agente selecciona la acción según su política (π) que define una distribución de prob-abilidad sobre las acciones para cada estado. Para un estado st, definimos la recompensa alargo plazo como la suma descontada de las futuras recompensas del agente , donde el factor

2.4. Reinforcement Learning 13

Figura 2.8: Esquema de reinforcement learning

de descuento para una acción k pasos en el futuro es dada por el producto de los descuentosantes de ese tiempo. Un agente trata de maximizar ese valor encontrando una buena política.Esta política puede ser aprendida directamente o ser construida como una función de algunaotra incógnita aprendida. Una forma común de derivar una nueva política de una función devalor estado-acción es usar el algoritmo ϵ-greedy, en el que se elige la acción con mayor valorcon una probabilidad (1-ϵ) y se actúa de forma random con una probabilidad de e. Este tipode políticas se usan para introducir exploración, ya que eligiendo acciones de forma aleatoriael agente puede llegar a descubrir una mejor solución.

2.4.1 Q-learningQ-learning es un algoritmo de aprendizaje por refuerzo cuyo objetivo es aprender una seriede normas que indiquen al agente que acción tomar bajo ciertas circunstancias. No necesitaun modelo del entorno y es capaz de manejar problemas con transiciones estocásticas yrecompensas sin ninguna adaptación. La ”Q” es el nombre de la función de la que se obtienela recompensa que proporciona el refuerzo y significa la calidad de una acción es un estado.

En Q-learning definimos una función Q(s, a) que representa el valor a largo plazo cuandotomamos la acción a en el estado s. Podemos expresar el Q-valor del estado s y la acción acomo el Q-valor del siguiente estado s′.

Q(s, a) = r + γmax′aQ(s′, a′)

Esta función es conocida como la ecuación de Bellman. La principal idea del Q-learninges que podemos aproximar iterativamente la función Q usando la ecuación de Bellman. Enel caso más simple, la función Q es implementada como una tala, con los estados como filasy las acciones como columnas como se puede ver en la Figura 2.9. En ella podemos ver unrobot que tiene que llegar al final, recibe puntos positivos al pasar por los rayos y negativos altocar las bombas y la tabla en la que se representa el valor de cada una de las acciones segúnel estado en el que se encuentre. Esa tabla que inicialmente encontramos llena de ceros, iráactualizándose conforme se vayan realizando acciones y obteniendo la recompensa.

Aunque este ejemplo muestre una situación muy simple, existen variantes del Q-learningque sirven para acciones más complejas. Por ejemplo, el Q-learning profundo en el que seutiliza junto con redes convolucionales profundas que son capaces de jugar a juegos de laconsola Atari [24]. En algunas ocasiones este algoritmo puede llegar a sobre estimar algunas

14 Estado del Arte

Figura 2.9: Ejemplo simple de Q-learning

de las acciones, debido a ello otra de las variantes es el doble Q-learning donde una políticadiferente se utiliza para la evaluación del valor que se usa para seleccionar la próxima acción[8].

2.5 AplicacionesEn la última década, las investigaciones en las que se ha usado alguna forma de DL han sufridoun gran aumento, especialmente en el campo de los videojuegos. Uno de los grandes culpablesde esto es el lanzamiento de Arcade Learning Environment (ALE) en 2013 que se define comouna plataforma y metodología para evaluar el desarrollo de IA general, independientementedel dominio [4]. ALE es un entorno de trabajo diseñado para facilitar el desarrollo de agentesque jueguen juegos de la Atari 2600, una videoconsola desarrollada en 1977. Uno de lostrabajos que más ha destacado en este campo y ha servido como base para el desarrollo desoluciones DRL es ”Playing Atari with Deep Reinforcement Learning” [23]. En este artículose introduce un nuevo modelo de aprendizaje que solo tiene como entrada píxeles del juego.Mediante este procedimiento se consiguió superar la puntuación de jugadores expertos en tresde los siete juegos propuestos, en la Figura 2.10 se pueden observar dos de esos juegos. Estodemostró que los videojuegos son una gran forma de probar distintos algoritmos de IA yaque presentan un escenario con limitadas acciones para el agente, unas reglas que aprender yuna puntuación clara. Además, aunque los juegos sean muy simples, al contar con una granvariedad de ellos, juntos forman un entorno más complejo que juegos como el ajedrez o go,que eran usados anteriormente con este fin.

Debido al gran éxito de este entorno, posteriormente aparecieron otras plataformas queofrecen escenarios basados en videojuegos para experimentar con DRL como OpenAI Gym2. Este programa ofrece una mayor variedad de entornos entre los que se pueden encontraralgunos muy simples como equilibrar un poste que se encuentra encima de un coche o bal-ancear un péndulo, el movimiento de robots con distintos esqueletos y juegos populares deconsolas de Nintendo como NES o Game Boy.

Pero el avance más importante y con mayor repercusión fue la creación de AlphaGo [31], elprimer programa capaz de derrotar a un jugador profesional y a un campeón mundial de Go,convirtiéndose en el mejor jugador de la historia en 2016. Un año después, se desarrolló susucesor, AlphaGo Zero [32] que utiliza DRL junto a la búsqueda en arbol de Monte-Carlo para

2https://gym.openai.com/

2.5. Aplicaciones 15

Figura 2.10: Imágenes de Breakout y Space Invaders, juegos usados en el artículo ”Playing Atariwith Deep Reinforcement Learning”

elegir el mejor movimiento. Fue entrenado compitiendo solamente contra el mismo, mientrasque AlphaGo había sido entrenado jugando contra jugadores humanos. Esta versión fuecapaz de superar el nivel de AlphaGo en tan solo 3 días de entrenamiento. Además, usandola misma IA en otros juegos de mesa como ajedrez o shogi consiguió vencer a los mejoresprogramas de cada juego.

Como sus creadores ya habían demostrado grandes avances en juegos de mesa, buscaronun reto mayor con videojuegos modernos más complejos. Por este motivo nació AlphaStar[1] centrado en aprender a jugar al juego Starcraft II Figura 2.11, un juego de estrategiaen tiempo real, es decir, sin turnos como en Go o ajedrez. Además cuenta con un númerode acciones mucho mayor que cualquiera de los juegos de mesa mencionados anteriormenteya que en él se pueden construir distintos edificios, obtener recursos y dirigir a un ejercitoformado por distintos grupos. Es considerado una de los juegos de estrategia más completosy complejos. AlphaStar fue capaz de vencer a varios jugadores profesionales, aunque tambiénperdió alguna batalla, por lo que aún podría mejorar. Su arquitectura está principalmentecompuesta por DRL relacional combinado con LSTM.

Figura 2.11: Imagen del juego Starcraft II

Otro proyecto que surgió de forma paralela a AlphaStar [26] fue OpenAI Five, una IAdiseñada para jugar a Dota 2, un juego en el que se juega por equipos de cinco y cada

16 Estado del Arte

jugador puede elegir entre cientos de campeones con habilidades diferentes. También incluyecompras dentro de la partida con oro que se obtiene al matar monstruos y bases enemigas quehay que derrotar. El principal cambio respecto a los experimentos nombrados anteriormentees que en este caso hay distintos jugadores que tienen que colaborar con el fin de obtenerla victoria. Las pruebas de este programa empezaron siendo de uno contra uno para probarlas habilidades individuales y posteriormente empezó a jugar contra equipos profesionales,consiguiendo ganar a OG el equipo campeón en 2018.

Un tipo de juego del que todavía no hemos hablado son los juegos en primera persona, enlos que el agente recibe solo la información desde su perspectiva, por lo que la informaciónque recibe no es completa. Un ejemplo de esto es ViZDoom [15] presentado como un nuevobanco de pruebas para algoritmos de DRL en el que se juega a Doom un juego de disparos enprimera persona. En este juego los agentes deben aprender dos tipos de tareas principales:una básica en la que mover y disparar y otra más compleja en la que resolver un problemade navegación por laberintos. Uno de las características más importantes de este entorno esque se pueden cargar escenarios creados por los usuarios, lo que aumenta en gran cantidadel número de posibilidades respecto al juego inicial. Gracias al uso de CNN y Q-learningson capaces de entrenar bots competentes que juegan al mismo nivel que los humanos. Lared neuronal que se puede observar en la Figura 2.12 cuenta con dos capas convolucionalescon 32 filtros, después de cada una de ellas hay una capa de max-pooling de tamaño 2, acontinuación hay una capa totalmente conectada con 800 neuronas y por ultimo una capade salida con 8 unidades correspondiente a las 8 combinaciones de las 3 acciones disponibles(derecha, izquierda, disparar). Cada agente aprendió por 600.000 pasos y para monitorizarel progreso de aprendizaje, se juegan 1000 pasos de prueba cada 5000 de aprendizaje.

Figura 2.12: Esquema de la red neuronal empleada en VizDoom, obtenida de [15]

Cambiando de género nos encontramos con TORCS, un juego de carreras, donde las prin-cipales acciones son acelerar, frenar y girar, por lo que los agentes tienen que aprender ladinámica de un coche. FIGAR [30] es un algoritmo de DRL con la habilidad de modelarabstracciones temporales al aumentarlo con la capacidad de predecir el número de pasos enlos que se debe ejecutar una acción elegida para usarse repetidamente. Esta predicción estácondicionada por el estado actual del entorno. En la Figura 2.13 se puede observar unapantalla de TORCS. Usando FIGAR un agente puede completar una carrera de 20 vueltas aun circuito con una gran puntuación.

Aunque ALE haya constituido una gran revolución en este campo, solo tiene un pequeñoconjunto de videojuegos en los que poder probar los algoritmos de IA, lo que hace que esté


Figura 2.13: Imagen del juego TORCS siendo controlado por el algoritmo FIGAR extraída dehttps://www.youtube.com/watch?v=dX8J-sF-WX4

limitado para poder comparar el desempeño de diferentes algoritmos. Para poder analizarla habilidad jugando a videojuegos de forma general de un agente, es necesario probar envideojuegos en los que no ha sido entrenado. Por ello, parecía necesario crear una forma fácilde crear y añadir nuevos juegos de forma fácil a un entorno de trabajo.

El General Video Game AI (GVGAI) [35] es un framework basado en java para jugar amás de 160 juegos de 2 dimensiones tipo arcade para uno y dos jugadores. GVGAI es usadoen una competición anual desde 2014, en la que los agentes propuestos por los concursantesdeben de jugar a 10 juegos desconocidos con 5 niveles diferentes cada uno y obtener la mayorpuntuación. Un ejemplo de los juegos que podemos encontrar son Superman, en el quepersonas inocentes se encuentran en las nubes y en los laterales de la pantalla aparecen losenemigos que disparan a las nubes para que las personas se caigan. Superman puede obtener1 punto salvando a las personas o encerrando a los villanos. Cuando los encierra a todos ganala partida. Otro ejemplo es Wait For Breakfast, en el que un camarero sirve el desayuno enuna de las mesas vacías. El jugador gana el juego si se sienta en la silla adecuada y se come eldesayuno. Estos dos juegos se pueden observar en la Figura 2.14. Uno de los inconvenientesde estos juegos, es que son mucho más simples que los juegos de ALE, ya que los segundosson juegos profesionales lanzados al mercado mientras que estos no pueden tener mecánicasmuy complejas para que sirvan para evaluar de forma general distintos algoritmos de IA [27]

Figura 2.14: Frames de los juegos Superman (derecha) y Wait For BreakFast (izquierda)

Otro entorno propuesto para comparar el rendimiento de diversos algoritmos de DRL es

18 Estado del Arte

Obstacle Tower [13] un entorno que se juega en 3D y en tercera persona. Está formado por100 plantas que debe superar el agente, cada una de ellas puede contener puzzles que hayque resolver, enemigos a los que derrotar, puertas cerradas para las que hay que encontrarla llave u obstáculos que evitar. Estas plantas están generadas de forma procedimental paraque los agentes tengan que explorar y no puedan resolverlo de forma determinista, que es unerror que si sucedía en otros ejemplos. Las acciones que puede tomar el agente son básicasy consisten en moverse en cuatro direcciones (delante, detrás, izquierda y derecha), girar lacámara en un eje y saltar. Con este entorno se realizó un concurso en el que se recibieronmás 3000 agentes. En un principio no se esperaba que nadie consiguiera pasar de las 10primeras plantas, pero esto fue superado por los 6 mejores agentes, proclamándose ganadorun agente que superó 19 plantas. Para ello ese agente fue entrenado en diversos pasos, enprimer lugar, se preparó para distinguir objetos. Luego mediante clonado de comportamientoaprendió a imitar demostraciones realizadas por humanos. Finalmente usó Proximal PolicyOptimization para mejorar el comportamiento de su agente según la función de refuerzo deljuego.

Por último y para dar ejemplo de la gran evolución que han experimentado este tipo dealgoritmos en cuanto a rendimiento, vamos a volver a hablar de ALE. Al principio de estasección, hemos comentado como en el año 2013 se había conseguido superar el rendimientohumano en tres de siete juegos escogidos por su simpleza mediante técnicas de DRL [23].

Durante estos años se ha seguido trabajando en mejorar esos resultados hasta obtenerAgent57 [2], el primer agente capaz de superar la media humana en los 57 juegos de Atarique conforman el entorno, en la Figura 2.15 se puede ver el rendimiento de este agentecomparados con otros algoritmos y con la media humana.

Figura 2.15: Comparación del rendimiento de Agent57 con la media humana y otros agentes.Obtenida de https://deepmind.com/blog/article/Agent57-Outperforming-the-human-Atari-benchmark

Para ello se han aplicado mejoras sobre un agente existente llamado Never Give Up [3]que ya contaba con una buena puntuación en los juegos basados en exploración, pero todavía


no dominaba los 57 juegos. Estas mejoras son (1) usar una parametrización diferente dela función de valor estado-acción, (2) usar un controlador para adaptar de forma dinámicala preferencia y descuento de la novedad y (3) usar un espacio de tiempo más largo paraaprender usando el algoritmo Retrace [25].

3 Materiales

3.1 IntroducciónPara ser capaces de realizar este proyecto ha sido necesario el uso de una gran variedadde tecnologías. Por un lado, ya que este trabajo está centrado en el uso de DRL en losvideojuegos, necesitamos contar con un motor en el que poder crear un entorno virtual conel que poder experimentar. Además, para el uso de diferentes algoritmos de IA tenemos queutilizar algunos frameworks y librerías que cuenten con las características necesarias paracrear redes neuronales y entrenarlas.

Asimismo, es indispensable manejar software con el que poder conectar las dos partesmencionadas anteriormente, el entorno virtual y la red neuronal. Por último, es necesariotener potentes herramientas de hardware, porque crear y entrenar redes y simular el entornovirtual son procesos exigentes y requieren mucha memoria y capacidad de cómputo.

3.2 SoftwareEn esta sección vamos a describir las distintas tecnologías usadas para el desarrollo de esteproyecto.

UE ha sido el motor elegido ya que parte de este proyecto trata de ampliar las característicasde UnrealROX, que esta desarrollado sobre él. Para programar esta parte del proyecto hemosusado C++, mientras que en lo relacionado con las redes neuronales hemos programadoen Python usando Pytorch aunque, en la etapa de aprendizaje, trabajamos también conTensorflow y Keras que se conectaban a entornos de OpenAI.

Para las pruebas de las extensiones a UnrealROX hemos usado un cliente escrito tambiénen Python y usando como IDE Visual Studio Code. En cuanto a las pruebas de DRL, enprimer lugar se realizaron en Jupyter Notebook debido a que era usado por diversos ejemplosencontrados por su capacidad de trabajar con celdas y poder ejecutarse y compartirse fácil-mente. Posteriormente, para poder usar Asimov (servidor de GPUs de 3DPLab), decidimoshacerlo mediante contenedores de Docker. Para ello, pasamos a usar Visual Studio Codeya que, gracias a una extensión, es posible abrir una carpeta remota en otras máquinas ocontenedores mediante un servidor SSH.

3.2.1 Unreal Engine

UE es un motor de videojuegos desarrollado por Epic Games 1, está escrito en C++ y fuemostrado por primera vez en el año 1998, aunque ha estado en continua evolución desde esemomento. Es uno de los principales motores en estos momentos y ha sido utilizado para

1https://www.unrealengine.com

21

22 Materiales

crear una gran variedad de juegos como Fortnite, Dragon Ball FighterZ, Kingdom Hearts III,Rime...

Es un motor versátil porque su propósito es abarcar tanto el desarrollo de videojuegos degran calidad y presupuesto, como el de juegos más simples y modestos. Permite crear ydesplegar juegos para PC (Windows, Linux, MacOS), videoconsolas (PlayStation 4, Switch,Xbox One), plataformas móviles (basadas en Android o iOS) y otras plataformas más het-erogéneas, tales como gafas de Realidad Virtual, plataformas web, entre otras.

Una de sus principales características, por lo que es tan utilizado, son los Blueprints. Es unade las opciones más importantes y potentes del motor ya que permite programar basándoseen nodos, es decir, de forma visual. Gracias a esto, personas sin grandes conocimientos deprogramación pueden usarlos. Otro punto a destacar es que cuenta con una gran comunidad.Dado que se trata de un motor abierto y con una licencia que permite un acceso gratuito asu uso, y a que tiene una enorme cantidad de opciones, cuenta con muchos usuarios que seayudan entre sí en páginas oficiales en las que exponer sus dudas 2 o muestran sus proyectosy debaten sobre diversos temas en el foro oficial3.

En este proyecto estamos usando la versión 4.23, que data de septiembre de 2019 y nos haservido para crear los entornos en los que vamos a probar los algoritmos de DRL. Además,también hemos creado un plugin que actúa como un servidor al cual la red solicita informacióny envía la acción a realizar.

3.2.2 Visual Studio

Es un entorno de desarrollo integrado creado por Microsoft4 y usado para el desarrollo desoftware (páginas web, aplicaciones para móviles, programas...). Incluye un editor de códigocon IntelliSense, que muestran información sobre el código y autocompleta pequeños trozosde código. También dispone de un explorador de soluciones para navegar y organizar elcódigo, Team Explorer que permite manejar tecnologías de control de versiones como Git yun depurador para poder solucionar los fallos.

El principal motivo por el que se ha utilizado es porque UE esta diseñado para integrarse conVisual Studio cuando creamos un proyecto con C++, permitiendo al usuario hacer cambiosde código, recompilar y ejecutar el resultado en poco tiempo. Hemos usado la versión de 2017para programar el plugin del servidor e implementar las mecánicas de los entornos creados,mencionados en el apartado anterior.

3.2.3 Docker

Docker es un proyecto de código abierto que permite automatizar el uso de aplicacionesdentro de contenedores, ligeros y portables, de software5. Gracias a esto se consigue unacapa adicional de abstracción en múltiples sistemas operativos, lo cual concede flexibilidad yportabilidad. Su mayor ventaja es que al desarrollar una aplicación dentro de un contenedor,la aplicación funcionará en cualquier servidor, de la misma manera que lo hace en la máquina

2https://answers.unrealengine.com3https://www.forums.unrealengine.com4https://docs.microsoft.com/es-es/visualstudio/get-started/visual-studio-ide?view=vs-20195https://www.docker.com/

3.2. Software 23

del desarrollador, ya que este contiene las configuraciones, librerías y archivos necesarios paraque funcione adecuadamente.

Un contenedor de Docker, a diferencia de una máquina virtual, no incluye un sistemaoperativo independiente. En su lugar, está basado en las funcionalidades del kernel y usa elaislamiento de recursos para aislar la vista de una aplicación del sistema operativo. Además,una máquina virtual puede tardar hasta varios minutos para crearse y arrancarse, por otrolado, un contenedor puede ser creando y lanzado en pocos segundos. Otra ventaja respecto alas máquinas virtuales, es que las aplicaciones en contenedores tienen un mayor rendimientocomparándolas a las ejecutadas dentro de una máquina virtual.

En cuanto a su uso, Docker se reduce a la crear un script que genera una instalación nosupervisada del entorno donde ejecutaremos las aplicaciones. Podemos encontrar las imágenespara esas instalaciones en Docker Hub 6, que se define como la librería y comunidad másgrande del mundo para imágenes de contenedores y en la que podemos encontrar más de100.000 imágenes creadas por proyectos de código abierto, comerciantes de software y lapropia comunidad.

3.2.4 Jupyter NotebookJupyter Notebook es una aplicación web gratuita y de código abierto lanzada en 2015 porProyecto Jupyter 7. Permite crear y compartir documentos compuestos por una lista ordenadade celdas de entrada y salida, esas celdas pueden contener, código, texto, formulas y contenidomultimedia.

Admite más de 40 lenguajes de programación, entre los que se encuentran R, Julia, Scaley Python. Se ejecuta desde la aplicación web cliente desde cualquier navegador común,los documentos generados pueden exportarse a diversos formatos como: PDF, Markdowno Python y pueden compartirse tanto por Dropbox, Github, correo electrónico o el visorintegrado de Jupyter Notebook.

3.2.5 FrameworksUn framework es una aplicación genérica que nos provee un conjunto de código, prácticasy conceptos para trabajar de una forma estándar sobre un tipo de problema particular,facilitando así la programación. Sirven para resolver problemas similares con mayor facilidad,ya que recogen métodos anteriormente desarrollados y testeados.

Debido a la creciente popularidad de DL en los últimos años, actualmente, es posibleencontrar diversas opciones a la hora de elegir un framework con las funciones necesarias parallevar a cabo nuestras pruebas, haciendo así el proceso mucho más sencillo. A continuaciónse describen algunos de los más utilizados en este ámbito.

3.2.5.1 Tensorflow

Es una biblioteca de código abierto usada para aprendizaje automático. Fue creada porGoogle Brain 8y lanzada en 2015, ganó popularidad rápidamente y es sin ninguna duda el

6https://hub.docker.com/7https://jupyter.org/8https://www.tensorflow.org/

24 Materiales

framework más popular en este momento, ya que muchas marcas importantes como Uber,Airbnb, Nvidia y muchas otras lo utilizan.

Utiliza una estructura de grafo de flujo de datos, en el cual los nodos del grafo representanoperaciones matemáticas y las conexiones del grafo son los conjuntos de datos multidimen-sionales, llamados tensores. Esta aproximación tiene varias ventajas para el desarrollo demodelos de DL, ya que permite calcular la derivada de cada operación de forma individualy aplicar la regla de la cadena, lo cual es útil para calcular la función de pérdida basadaen gradientes descendientes, que es muy comúnmente usada en este entorno. Esto tambiénpermite hacer de forma paralela operaciones entre Graphics Processing Unit (GPU) y CentralProcessing Unit (CPU).

Está escrita principalmente en C++ y proporciona una interfaz de alto nivel en Python,aunque también soporta otros lenguajes como JavaScript, C++, Go, C#, Julia y Java.Además, se pueden desarrollar grafos tanto en la CPU como en la GPU.

3.2.5.2 Keras

Keras9 es una Application Programming Interface (API) de alto nivel para redes neuronales,está escrita en Python y fue creada por François Chollet en 2015. Está diseñada para quepersonas con pocos conocimientos sobre redes neuronales sean capaces de experimentar ráp-idamente con ellas, por lo que una de sus mayores ventajas es que es fácil de usar.

Keras tiene dos diferentes APIs, una que permite crear modelos como una secuencia decapas, Sequential API y otra que lo permite hacer con grafos, Functional API. Usando laprimera, podemos crear un modelo simple y obtener una sola salida por cada entrada. Mien-tras que con la segunda, es posible tener múltiples entradas y salidas en un modelo.

Otra de sus ventajas es su modularidad, ya que un modelo se calcula como una secuen-cia de módulos independientes y completamente configurables, que se pueden unir con lasmenores restricciones posibles. Además nos permite crear nuevos módulos de forma sencillay con variedad de ejemplos, por lo que también se puede utilizar en investigaciones complejasque necesiten herramientas que Keras actualmente no posee. Es capaz de utilizarse sobreTensorFlow, CNTK y Theano.

En el poco tiempo que ha pasado desde su lanzamiento, Keras ha conseguido ser uno delos frameworks más utilizados tanto por la industria como por la comunidad investigadora,siendo solo superado por TensorFlow. Grandes empresas y organizaciones científicas comoNetflix, Uber, NASA y CERN lo utilizan.

3.2.5.3 Pytorch

Pytorch 10 es un paquete de Python de código abierto desarrollado principalmente por elgrupo de investigación de inteligencia artificial de Facebook y fue lanzado en octubre de2016. Como se puede observar por el nombre, está influenciado por Torch, un framework decomputación científica que está especializado en ofrecer un amplio rango de algoritmos deaprendizaje automático. Es una alternativa que está ganando popularidad rápidamente porsu facilidad de uso y otras ventajas, como su capacidad nativa para ejecutar en la GPU oCPU, acelerando procesos lentos como el entrenamiento de modelos.

9https://keras.io/10https://pytorch.org/

3.3. Hardware 25

PyTorch trabaja con grafos dinámicos en vez de estáticos que son los que utiliza Tensorflow.Debido a esto podemos modificar las funciones y el cálculo del gradiente variará con ellas.Esto se debe a que Pytorch crea un nuevo grafo en cada ejecución del modelo. Sin embargoen Tensorflow primero definimos el grafo de computación y después se utiliza la sesión paracalcular los resultados de los tensores, dificultando la depuración e implementación de código.

3.3 HardwareEl hardware utilizado para este proyecto ha sido, principalmente, mi ordenador personal,en el cuál se ha realizado toda la programación e investigación. Los detalles técnicos delordenador Windows usado se pueden ver en la siguiente tabla:

Ordenador PersonalPlaca base Lenovo Allsparks 5ACPU Intel(R) Core(TM) i7-6700HQ

2.60 GHz4 procesadores principales, 8 lógicos45 W TDP

GPU Nvidia GeForce GTX 960M640 CUDA cores2 GiB of GDDR5 Video MemoryPCIe 3.075 W TDP

Memoria RAM 8GB DDR4 2133 MHzDisco duro Western Digital 1 TiB, 5400 rpm

Tabla 3.1: Especificaciones hardware de mi ordenador personal

Sin embargo, debido a su limitada potencia y a la colaboración con el 3DPLab del Depar-tamento de Tecnología Informática y Computación a la hora de entrenar las redes neuronalesse ha utilizado el servidor Asimov, sus especificaciones son:

26 Materiales

AsimovPlaca base Asus X99-A

Intel X99 Chipset

4x PCIe 3.0/2.0 x 16(x16, x16/ x 16, x16/ x 16/ x 8)CPU Intel(R) Core(TM) i7-5820K CPU @ 3.30GHz

3.3 GHz (3.6 GHz Turbo Boost)6 procesadores principales, 12 lógicos140 W TDP

GPU (visualización) Nvidia GeForce GT73096 CUDA cores1024 MiB of DDR3 Video MemoryPCIe 2.049 W TDP

GPU (deep learning) Nvidia GeForce Titan X3072 CUDA cores12 GiB of GDDR5 Video MemoryPCIe 3.0250 W TDP

GPU (computación) Nvidia Tesla K40c2880 CUDA cores12 GiB of GDDR5 Video MemoryPCIe 3.0235 W TDP

Memoria RAM 4 X 8 GiB Kingston Hyper X DDR4 2666 MHz CL13Disco duro (Datos) (RAID 1) Seagate Barracuda 7200rpm 3TiB SATA III HDDDisco duro (SO) Samsung 850 EVO 500 GiB SATA III SSD

Tabla 3.2: Especificaciones hardware de Asimov

4 Extensión de UnrealROX para RL

4.1 IntroducciónEn esta sección se describe la parte del desarrollo realizado en este proyecto relativa a lacreación del pipeline con el que vamos a trabajar posteriormente. En primer lugar, se explicala creación del flujo de trabajo usado en este proyecto, que nos permite entrenar redes neu-ronales. Para ello ha sido necesario conectar una escena de UE, que simula el entorno de unvideojuego, con un programa externo, con el cual poder obtener información de dicha escenao modificarla. Posteriormente, se han introducido esta funcionalidad al proyecto UnrealROX,creado por 3DPLab de la Universidad de Alicante.

4.2 UnrealROXUnrealROX es un proyecto que surge de la necesidad de generar grandes cantidades de datossintéticos que puedan ser utilizados para entrenar algoritmos de aprendizaje profundo queprocesan imágenes y video. Estos datos han de ser lo más realistas posible para que se puedaaplicar lo aprendido entrenando con esos datos en el mundo real.

Es un entorno construido sobre Unreal Engine 4 en el que escenas interiores hiperrealistasson exploradas por agentes con forma humanoide que pueden interactuar de forma realista enese mundo virtual [19]. Esos robots son controlados por una persona haciendo uso de un cascode realidad virtual para controlar el cuerpo y de controladores de movimiento para manejarlas manos. También existe la opción de manejarlo con el teclado para realizar pruebas.

Uno de los puntos clave de este entorno es el subsistema de agarre, que permite manipularobjetos sin importar su geometría, pasárselos de una mano a otra, agarrar varios a la vez ysoltarlos por la escena de forma realista. Para ello, las manos cuentan con sensores que indicansi se está manipulando un objeto y controladores que permiten cerrar la mano dirigiendo cadadedo individualmente hasta que se detecta que toca el objeto. Estos movimientos se realizande forma fluida para replicar los movimientos de un robot real y evita atravesar el objeto.En la Figura 4.1 se puede ver este subsistema en funcionamiento.

Para poder ejecutar el entorno con un framerate (fps - frames por segundo) muy alto, Un-realROX cuenta con dos procesos distintos, grabar y generar datos. El sistema de grabaciónactúa cuando estamos controlando al agente en el entorno virtual y se encarga de recogery guardar, en cada frame, toda la información necesaria para poder reconstruir toda la se-cuencia, como posición, rotación y bounding box de cada objeto y cámara del entorno. Estainformación se guarda en un archivo de texto de forma asíncrona. Después de que toda lasecuencia haya sido guardada se transforma en un archivo JSON para estructurar la infor-mación y facilitar la lectura.

La información obtenida se utiliza después como entrada para el sistema de playback quereproduce la secuencia y genera todos los datos solicitados. Los datos que se pueden obtener

27


Figura 4.1: Imagen de UnrealROX en la que el agente está agarrando una fruta con la mano

son: imágenes RGB, mapas de profundidad, máscaras de segmentación de instancias y nor-males. Además este sistema cuenta con opciones que nos permiten seleccionar solo los framesnecesarios.

4.3 Conexión Cliente-Servidor

Una de las partes más importantes del desarrollo es la integración del algoritmo DRL enun entorno similar al de un videojuego. Para comenzar se ha empleado una arquitecturacliente-servidor mediante la cual es posible conectarlos.

Para ello contamos con un programa escrito en Python que actúa como el cliente. En esteprograma se crea un socket pasándole los parámetros AF_INET, indica que estamos usandoel protocolo IPv4 y SOCK_STREAM, define el tipo de socket, en este caso de flujo que seusa como base para el protocolo Transmission Control Protocol (TCP) y confirma que todoslos mensajes enviados lleguen en el mismo orden. Posteriormente se le indican al socket ladirección del servidor al que queremos conectarnos y el puerto específico al que vamos aacceder.

Mediante un input, el usuario puede introducir el mensaje que desea enviar, se envía elmensaje y finalmente, se recibe la respuesta del servidor. Este proceso se repite en buclehasta que se desee terminar la conexión. Esta es la versión inicial del cliente, en la que solose encarga de enviar y recibir mensajes, posteriormente, a este programa se le añadirán lasdistintas funciones necesarias para poder entrenar modelos de DRL.

Por otro lado tenemos el servidor, creado en UE, en la versión 4.18 y escrito en C++.Este servidor se encuentra dentro de un plugin, ya que así es más fácil utilizarlo en diferentesproyectos del motor, solo es necesario copiar la carpeta generada dentro de Plugins en elproyecto deseado. Una vez creado el plugin, establecemos una nueva clase dentro de él,ROXServer, que hereda de la clase Actor para que así se pueda introducir en la escena yactualizar en cada tick, aunque no tiene ninguna malla asignada por lo que no es visible en laescena. Dentro de esta clase definimos las diferentes funciones para que actué como servidory reciba los mensajes del cliente:

• CreateListener, que se encarga de leer el puerto introducido mediante la interfaz de UEy crea un socket que espera recibir una conexión desde cualquier IP a ese puerto. Esta

4.4. Comandos 29

parte es igual que la realizada en el cliente, la única diferencia es el lenguaje en el queestán escritos. Esta función es llamada una vez al iniciar la ejecución del proyecto.

• UpdateConnectionListener, en la que se comprueba si otro socket ha intentado conec-tarse con este, en caso afirmativo, acepta la conexión. Esta función se ejecuta en cadatick del proyecto, ya que los mensajes deben ser leídos con la mayor rapidez posible.Si ya hay una conexión establecida, verifica si hay información que no ha leído, en esecaso llama a ListenConnection.

• ListenConnection, se ocupa de leer el mensaje pendiente del cliente, comprueba si esemensaje se corresponde con alguno de los comandos establecidos, que serán descritosposteriormente y llama a la función correspondiente pasándole los parámetros el mensajerecibido del cliente.

• SendReponse, recibe un mensaje generado por alguna de las otras operaciones querealiza el servidor y se lo envía al cliente.

4.4 ComandosComo ya se ha comentado anteriormente, en el servidor se han definido una serie de comandoscon los que se puede modificar la escena o recibir información de ella. Se puede obtener unadescripción detallada de cada uno de ellos en el repositorio del proyecto 1. Esta lista decomandos podemos agruparlos según su funcionalidad:

• Listas: Una de las formas en las que se obtiene información sobre la escena y es nece-saria para poder modificar los objetos que hay en ella son las listas. Estas se encargande mostrar los identificadores de una serie de elementos de la escena que tienen carac-terísticas comunes como se muestra en la Figura 4.2. Estas listas son: actor_list paraconocer los actores de la escena, object_list con los actores movibles, camera_listpara las cámaras skeletal_list lista los esqueletos, socket_list las articulaciones deun esqueleto y assets_list que nos informa de los recursos disponibles en una carpetadel proyecto. Esta carpeta se define desde la interfaz de UE, aunque puede ser cambi-ada con change_assets_path. Estos comandos no reciben ningún parámetro extra, aexcepción de socket_list al que hay que indicarle el esqueleto.Estas listas, además de enviarse al cliente se guardan en un mapa (identificador, pun-tero) en el servidor , para así poder acceder a ellos rápidamente al usar los siguientescomando para modificarlos.

• Transformaciones: Dentro de este grupo encontramos las transformaciones básicas quese le pueden aplican a un actor: move, rotate y scale que modifican la posición,rotación y escala respectivamente. A estos comandos es necesario pasarle: el identifi-cador del actor de la escena al que se le quiere aplicar (por esto es necesario hacer laslistas), la modificación en cada uno de los ejes (x,y,z) y, de forma opcional, el tiempo enel que se quiere realizar la transformación. Si no se le pasa el tiempo, la transformación

1https://github.com/3dperceptionlab/UnrealROX-RL-Server


1 Command: object_list2 DefaultPawn_03 ROXCamera_24 ROXCamera_15 StaticMeshActor_06 Cone_27 Cube_28 Floor9 Sphere_5

10 StaticMeshActor_1

Figura 4.2: Resultado del comando object_list, que muestra el identificador de todos los actores dela escena que pueden ser movidos en la escena actual.

se realiza automáticamente. Además contamos con get_location, get_rotation yget_scale que nos devuelven el valor actual en los tres ejes de la transformación elegida.

También existen move_socket y rotate_socket que funcionan exactamente igual quelas anteriores, pero en este caso se le tiene que pasar el esqueleto y la articulación quemodificar. Para obtener el valor actual de estos podemos usar get_socket_locationy get_socket_rotation.

• Recursos: para manejar los recursos hemos definido set_asset_path al que le pasamosla ruta de la que queremos obtener los recursos. change_texture con la que podemoscolocar una textura específica a un actor de la escena. Y spawn_actor para crear unainstancia del recurso en un lugar concreto de la escena con el nombre que queramos.

• Cámaras: al igual que los recursos podemos crear una cámara en la posición deseada yelegir su nombre usando spawn_camera. También se puede girar una cámara paraque mire a un punto u objeto concreto usando el comando camera_look_at.

• UnrealROX: estos comandos sirven para ejecutar acciones que ya se encontraban enlas anteriores versiones del programa. Con toggle_scene_physics podemos activary desactivar las físicas de los actores y con is_scene_physics_enabled saber suestado actual. get_3d_bounding_box sirve para obtener los ochos puntos de labounding_box de un actor.

Se puede hacer que una cámara sea estéreo o mono con set_camera_stereo, indi-cando la cámara que queremos modificar, un booleano que indica si es estéreo y la dis-tancia entre las lentes. Para saber si una cámara es estéreo tenemos is_camera_stereo.

Una de las funcionalidades más importante de UnrealROX permite extraer fotogra-mas del entorno desde diferentes puntos de vista y que contengan diversos tipos deinformación como el color, la profundidad, las normales o identificar los distintosobjetos visibles. Con este fin fueron creados los comandos get_rgb, get_depth,get_normal y get_instace_mask, a los que les tenemos que pasar el nombre dela cámara desde la que queremos obtener la imagen y, opcionalmente, el nombre delarchivo resultante. Este archivo se crea dentro de la ruta establecida, en una carpetacon el nombre de la cámara seleccionada. La ruta establecida se puede modificar con

4.4. Comandos 31

set_output_frames_path y se puede cambiar la resolución de las imágenes (alturay anchura de píxeles) usando set_output_frames_resolution.

5 Pruebas de Deep Reinforcement Learning

5.1 IntroducciónEn esta sección se van a describir las distintas pruebas de RL realizadas utilizando la her-ramienta explicada anteriormente. En primer lugar, se va a explicar el cliente utilizado,que se encarga de crear la red neuronal y comunicarse con el plugin de UE para obtenerlas imágenes del estado actual del experimento y comunicar al agente las acciones que deberealizar. Posteriormente, se detallan los dos entornos utilizados para realizar las pruebas: elprimero proporciona una imagen aérea de la escena y el segundo desde el punto de vista delagente. En cada uno de estos entornos se va a entrenar la red, a continuación, observaremoslos resultados y posibles problemas encontrados e intentaremos modificarlos para obtener unmejor resultado.

5.2 Descripción del cliente y el entornoEl cliente empleado en este caso se conecta al servidor de la forma explicada en la Sección4.3. Para el aprendizaje del cliente vamos a usar Deep Q-Learning debido a los grandesresultados obtenidos en otras investigaciones como [24], que se basa en aprender en cadasituación el resultado de elegir cada movimiento y poder así seleccionar la acción que nosvaya a proporcionar mayor recompensa.

Por ello es necesario crear en el cliente la clase ReplayMemory, que se encarga de guardarlas transiciones que el agente observa recientemente para utilizar esos datos después. Lastransiciones que guarda son un mapeo de pares formados por el estado actual y la acciónseleccionada con el próximo estado y la recompensa obtenida.

Una de las partes más importantes del cliente es la clase DQN, en la que se crea la redneuronal que vamos a entrenar, podemos verla en el Código 5.1. Esta red está formada por:capa de convolución 2d que tiene 3 canales de entrada, pertenecientes a los canales RGBde la imagen de entrada, y produce 16 salidas con un filtro de 5x5. Seguidamente hay unacapa de normalización por grupos, que sirve para reducir el cambio de la distribución de lasentradas en cada capa, que es producido por el cambio de valor de los parámetros de la capaanterior producido durante el entrenamiento [12]. Después hay otra convolución, que en estecaso recibe las 16 salidas de la anterior como entrada y generada 32 salidas. Como en elanterior caso, esta convolución está seguida por una capa de normalización por grupos. Y, enúltimo lugar nos encontramos con una capa que realiza una transformación lineal, que generael número de salidas correspondiente al número de acciones que puede ejecutar el agente ycada una de esas salidas es la probabilidad de que esa acción sea la que conlleve una mayorrecompensa, por lo que la acción elegida es la que cuente con mayor porcentaje.

33


Código 5.1: Creación de la red neuronal

1 class DQN(nn.Module):23 def __init__(self, h, w, outputs): # Se le pasa la altura y la anchura de la foto y el numero de outputs4 super(DQN, self).__init__()5 self.conv1 = nn.Conv2d(3,16,kernel_size=5,stride=2)6 self.bn1 = nn.BatchNorm2d(16)7 self.conv2 = nn.Conv2d(16, 32, kernel_size=5, stride=2)8 self.bn2 = nn.BatchNorm2d(32)9

10 #Calcular en numero resultante segun el tamaño de la imagen11 def conv2d_size_out(size, kernel_size = 5, stride = 2):12 return (size − (kernel_size − 1) − 1) // stride + 11314 convw = conv2d_size_out(conv2d_size_out(w))15 convh = conv2d_size_out(conv2d_size_out(h))1617 linear_input_size = convw ∗ convh ∗ 3218 self.head = nn.Linear(linear_input_size,outputs)

Para seleccionar la acción que va a realizar el agente algunas veces se utiliza el resultado dela red y otras se elige una opción de forma aleatoria. Esto se debe a que el resultado de la redsolo es útil una vez que se han realizado un gran número de ejecuciones del programa y estaha aprendido lo suficiente. Para controlar las veces que se elige una opción u otra usamos elalgoritmo ϵ-greedy, que se basa en elegir la acción con mayor valor con una probabilidad (1-ϵ)y se actúa de forma random con una probabilidad de e. Para ello intervienen tres variablesimportantes que iremos modificando en las distintas pruebas: eps_start que indica el valor deϵ al comenzar, eps_end que es el valor final de ϵ y eps_decay, el número de intentos necesariopara que el valor inicial de ϵ se transforme en el valor final. Este proceso se realiza en lafunción select_action.

Además en el cliente existen varias funciones para comunicarse con el servidor como re-set_gam” para reiniciar el entorno tras finalizar un intento. step_game que se encargade comunicar al servidor la opción elegida y guardar la recompensa que recibe el agente.save_data en la que se guarda el estado actual de todas las variables necesarias en un archivoy load_data que lee el archivo y almacena esos datos en las variables para continuar con elaprendizaje.

Código 5.2: Bucle de aprendizaje

1 while len(episode_durations)<=max_episode:2 reset_game()3 current_screen = get_screen()4 state = current_screen.to(device)56 for t in count():7 action = select_action(state)8 reward, end = step_game(action.item())9 reward = torch.tensor([reward], device=device)

1011 current_screen = get_screen()12 if not end:13 next_state = current_screen14 else:15 next_state = None16

5.2. Descripción del cliente y el entorno 35

17 memory.push(state, action, next_state, reward)1819 state = next_state2021 if end:22 episode_durations.append(reward)23 if len(episode_durations)%episode_save == 0:24 savedata(out_name + str(len(episode_durations)))25 break2627 if len(episode_durations) % target_update == 0:28 target_net.load_state_dict(policy_net.state_dict())

Para terminar con el cliente, vamos a comentar el bucle de aprendizaje, podemos verloen el Código 5.2. Este bucle se lleva a cabo hasta llegar al número máximo de intentosdeseados, definido en la variable max_episode. Lo primero que se hace es reiniciar el entornoy obtener la imagen del estado inicial. A continuación tenemos otro bucle del que no se salehasta finalizar el intento. En él se elige una acción a partir del estado actual y se recibe larecompensa. Se obtiene la captura del entorno después de realizar esa acción, que no existe sise ha llegado al final del intento y se guarda en la memoria para poder usarlo luego. Si se haterminado el intento se guarda la recompensa obtenida para poder mostrarla en los gráficos yse guarda el progreso actual según el valor de episode_save. Finalmente, cada target_updatese actualizan los valores de los biases de la red.

En cuanto al entorno utilizado, como ya hemos comentado está creado en UE utilizando elplugin UnrealROX, incluyendo las funciones añadidas explicadas en el capítulo anterior. Enél, controlamos a un agente representado por un cubo, que está encerrado en una habitaciónsin salida. Dentro de ella también se encuentran algunos obstáculos y un destino al que tieneque llegar. Tanto las paredes como los obstáculos están representados mediante cubos azules,mientras el destino es de color verde.

Figura 5.1: Captura del entorno que está formado por las paredes y los obstáculos de color azul, delagente que controlamos de rojo y el destino de verde. Además se han añadido unas lineasamarillas para delimitar la zona en la que puede aparecer cada uno de estos elementos.

La posición en la que se encuentran estos elementos varía en cada intento, para ello sedelimita el espacio en porciones del mismo tamaño en las que solo puede generarse un el-emento, para evitar que, por ejemplo, el agente aparezca encima de un obstáculo y pierda


automáticamente. Esto se puede observar en la Figura 5.1. A su vez, dentro de esa porciónse genera en una posición aleatoria, para que no se repitan los mismos entornos una y otravez.

En cuanto a medidas, la habitación es un cuadrado en el que cada lado mide 3000 unidades.Tanto el agente como los obstáculos tienen una longitud de 400 unidades, mientras que eldestino es un poco mayor, 500 unidades. El agente se mueve por el entorno a una velocidadde 100 unidades por frame.

5.3 Pruebas con vista cenital

En las primeras pruebas realizadas la red neuronal recibe como entrada una imagen delestado actual con vista cenital, como se puede observar en la Figura 5.1. De este modo setiene información total del entorno. El refuerzo que recibe el cliente después de elegir unaacción, si no ha colisionado con nada, depende tanto de la variación de la posición del agenterespecto al destino al realizar dicho movimiento y a la distancia del obstáculo más cercano.Si el agente se solapa con otro objeto, la recompensa depende de si es el destino o no. Estose puede entender de forma más exacta con el Código 5.3.

Código 5.3: Refuerzo del entorno

1 if (overlapping_object.Num() != 0) #Comprobar si se choca con algo2 {3 UStaticMeshComponent∗ mesh_component = dynamic_cast<UStaticMeshComponent∗>(←↩

↪→ overlapping_object[0]−>GetComponentByClass(UStaticMeshComponent::StaticClass()));45 if (mesh_component)6 {7 FString name_material = mesh_component−>GetMaterial(0)−>GetName();8 if (name_material == "Obstáculo")9 move_reward = −1000 − new_dist; #resultado si es un obstáculo

10 else11 move_reward = 2000 − steps; # si es el destino12 }13 }14 else15 {16 move_reward = dist − new_dist # variación de la distancia17 if (min_dist < 600) # si está muy cerca de algún obstáculo recibe una penalización18 move_reward −= (600 − min_dist) / 6;19 }

Con esta configuración realizamos una prueba inicial para comprobar que, tanto el pipelinecomo la red neuronal, funcionaban correctamente. En esta prueba se han realizado 3500 inten-tos de superar el desafío y con una memoria en la que se guardan las últimas 10.000 accionesrealizadas. En cuanto a la toma de decisiones ϵ-greedy comienza valiendo 1 y desciende hasta0.05 al cabo de 2000 intentos.

Analizando la Figura 5.2, en la que se representan los resultados de esta prueba, podemosafirmar que la curva es ascendente, por lo que el agente está aprendiendo correctamente y enel punto más alto de ella se llegan a superar los 500 puntos de media. Además, observandolos últimos intentos realizados, no percibimos ningún problema importante por el que hayaque aplicar cambios importantes.

5.3. Pruebas con vista cenital 37

Debido a los buenos resultados obtenido, a continuación realizamos otra prueba aumen-tando la cantidad de intentos a 7000. Por ello, también se modificó el valor de ϵ-greedy, quealcanza su valor más bajo al llegar a las 5.000 ejecuciones, aumentando así las posibilidadesde explorar más el entorno y obtener mejores resultados.

0 1,000 2,000 3,000 4,000

−1,000

0

1,000

Número de Intentos

Med

iaR

efue

rzo

Fina

l

Figura 5.2: Primera prueba en vista cenital en azul. En rojo podemos ver una repetición de la mismaprueba para comprobar si se obtienen siempre mejores resultados que en la Figura 5.3.

En la Figura 5.3 y de color azul se expone el rendimiento conseguido, que es menor delobtenido por la prueba anterior. Además, al observar las últimas ejecuciones del entorno sepodía observar un gran problema, el agente en muchas ocasiones, se movía en un direccióny posteriormente justo en la contraria, en bucle durante un gran número de frames. Estasituación se repetía hasta que finalmente, gracias a que sigue existiendo un pequeño porcentajepara elegir una opción aleatoria, consigue salir de esa situación.

Esto puede deberse a que el agente ha aprendido que no debe chocarse con los obstáculosy decide que la mejor decisión es no moverse del mismo lugar para no perder. Este problemahace que aumente considerablemente el tiempo de cada intento y que si después de salir deese bucle consigue llegar al destino, la recompensa obtenida sea mucho menor, por lo que hayque intentar que se siga repitiendo este suceso.

Como solución a este problema, se estableció un máximo de 300 frames en una mismaejecución, llegado a ese punto se da el intento por finalizado y la recompensa obtenida es lamisma que si se hubiera chocado con un obstáculo, es decir, -1000 menos la distancia que hayhasta el destino. La finalidad de esta medida es observar si gracias a esto se evita quedarseen bucle y avanza de forma más directa hasta el destino.

En la Figura 5.3, en rojo, se muestran la consecuencia de aplicar este cambio. Comparán-dola con la prueba anterior, podemos apreciar como, de forma general, ha tenido un peordesempeño alcanzando el destino. En los primeros mil intentos, donde la acción elegida estotalmente aleatoria en la mayoría de casos, no existe una notable mejora como en el anteriorcaso. Esto puede deberse a que el límite puesto sea muy bajo y se alcance en muchas oca-siones en esas condiciones. Por lo tanto en las siguientes pruebas se aumentará el límite, yaque, aunque los resultados obtenidos en este caso no hayan sido mejores que los anteriores,


consideramos que es necesario poner un límite para no retrasar innecesariamente el tiempode aprendizaje.

Si comparamos los resultados de obtenidos en los dos test de la Figura 5.3, con la primeraprueba realizada, la línea azul de la Figura 5.2 podemos percibir como los resultados obtenidosen el ensayo inicial son mejores. Teóricamente, esto no debería ser así ya que en cualquier tipode aprendizaje por refuerzo, cuanto mayor número de intentos se realicen, mejores resultadosse deberían obtener. Por ello se ha realizado otra prueba con las mismas característicasque la primera, que se muestra en la Figura 5.2 de color rojo. En esta se puede ver como elrendimiento recibido es más similar al de las posteriores pruebas. Por tanto, podemos concluirque el aumento del número de intentos no ha perjudicado el resultado, aunque tampoco haconseguido mejorarlo notablemente en ninguno de los dos casos.

0 0.2 0.4 0.6 0.8 1

·104

−1,000

0

1,000

Número de Intentos

Med

iaR

efue

rzo

Fina

l

Figura 5.3: En azul se muestran los resultados de la segunda prueba. En ella se aumenta la cantidadde intentos y se modifica el valor de ϵ-greedy para que alcance su valor más bajo en 5000intentos. En rojo podemos ver la tercera prueba, en la que se pone un límite de 300movimientos a cada intento, contando como derrota si se supera ese número.

5.4 Pruebas en primera persona

En el caso anterior, el agente contaba con información completa del entorno para aprender,lo cual debería aumentar la velocidad de aprendizaje y los resultados obtenidos. Pero, eseno es el caso más habitual en los videojuegos. Normalmente, un sujeto solo cuenta con lainformación del ambiente que recibe con sus sentidos, como la vista.

Por ello, se han realizado algunos cambios en la infraestructura, siendo el más obvio el cam-bio de la cámara, pasando a ser en primera persona, obteniendo imágenes como la mostradaen la Figura 5.4. Debido a este cambio, ahora los obstáculos pasan a ser de color rojo paradiferenciarlos de las paredes, ya que ahora no se muestra el agente, ese color no se utiliza paranada más. Así mismo, se han modificado también las acciones que puede realizar el agente,pasando de poder moverse en cuatro direcciones a poder moverse solo hacia el frente y girarhacia izquierda y derecha 90 grados.

5.4. Pruebas en primera persona 39

Figura 5.4: Vista en primera persona del agente, utilizada como entrada para la red neuronal enestas pruebas.

Del mismo modo, también se va a cambiar los parámetros que afectan la recompensarecibida al realizar una acción. En estas pruebas sólo se va a tener en cuenta la distancia alobstáculo más cercano que se encuentre en la dirección en la que está mirando el agente. Paraello se lanzan dos rayos desde sus laterales y se comprueba la distancia respecto al primerobjeto contra el que chocan, si no es el destino. La distancia mínima a la que se empieza arestar puntos de la recompensa es 1000 unidades.

Se introducen nuevas modificaciones de la recompensa al girar. Si al girar comienza a miraren la dirección del destino, la recompensa es 100 puntos mayor. En caso contrario, es decir,si estaba mirándolo y gira hacia otra dirección, pierde 100 puntos. Ahora, como es necesariogirar para poder moverse en otra dirección, se tienen que realizar más pasos para recorrerla misma trayectoria (excepto si esta es recta) y puede no conocerse la posición del destinodesde el principio. Por ello, cuando se llega al destino en vez de restar el número de pasos,estos se dividen entre dos.

La Figura 5.5 expone los resultados de los dos experimentos realizados con esta configu-ración, diferenciándose únicamente en la cantidad de grados que gira en cada uno, 90 gradosen la azul y 15 grados en la roja. En primer lugar se optó por los 90 grados, para que elagente pueda moverse en cuatro direcciones, como en las pruebas realizadas anteriormente. Acontinuación, se realizó una prueba en la que el giro es menor, permitiendo mayor libertad demovimiento, lo cual conseguiría mejores resultados si quién controlase las acciones del agentefuera una persona. Tras comparar ambas partes de la gráfica, entre ellas no existen grandesdiferencias de rendimiento, aunque girando 90 grados se obtienen resultados ligeramentemejores. En cuanto a la comparación entre las pruebas con vista cenital y primera persona,preveíamos una bajada de puntuación en el segundo caso, ya que no se tiene conocimientocompleto del entorno, pero esta bajada apenas se aprecia.


0 0.2 0.4 0.6 0.8 1

·104

−2,000

−1,000

0

1,000

Número de Intentos

Med

iaR

efue

rzo

Fina

l

Figura 5.5: Pruebas en primera persona. La diferencia entre ellas es que en la azul, los giros querealiza el agente son de 90º, mientras que en la roja son de 15º, para dar mayor libertadde movimiento.

6 Conclusiones

En este capítulo se resume el trabajo que se ha presentado en los anteriores capítulos, ex-trayendo conclusiones en la Sección 6.1 y presentado mejoras y futuras lineas de trabajo enla Sección 6.2.

6.1 ConclusionesEn este proyecto, hemos empezando investigando distintas técnicas de DL, tipos de redesneuronales y las características del RL. Continuamos haciendo un análisis de los avancesconseguidos usando estos procedimientos en el campo de los videojuegos, en los últimos años.Hemos comparado las diferentes arquitecturas y métodos utilizados, el tipo de videojuegosen los que se han utilizado y los resultados obtenidos.

En cuanto al trabajo llevado a cabo, en primer lugar hemos realizado una extensión alas funcionalidades de la herramienta UnrealROX. Añadiendo funcionalidades para podercontrolar un entorno desde un programa externo en tiempo de ejecución, ampliando lasutilidades para futuros proyectos.

A partir de ello, hemos creado un entorno en el que un agente debe aprender a llegar hastaun destino evitando varios obstáculos. Para conseguirlo hemos utilizado una red profunda querecibe la imagen del estado actual de la escena y, al elegir una acción a realizar, un refuerzo,según lo acertada que ha sido la elección. Por ello hemos tenido que crear una función queasigne un refuerzo según la decisión tomada en cada situación.

Una vez creado el sistema, se ha puesto a prueba de dos formas distintas, con vista ceni-tal del entorno completo y con la vista en primera persona del agente. En ambos casos, sehan llevado a cabo distintas pruebas, realizando cambios tanto en las acciones del agente,como en el número de intentos o en la función de refuerzo con el fin de mejorar los resulta-dos obtenidos. Estos resultados muestran claramente como consigue mejorar su rendimientodurante el entrenamiento, aunque todavía queda un gran margen de mejora. Además, com-parando ambas situaciones, no hay gran diferencia en los resultados, a pesar que en una deellas el agente no conoce completamente el entorno desde el principio y tiene que investigarpreviamente para conocer la posición del destino.

6.2 Trabajo futuroDebido a las limitaciones temporales del proyecto y problemas no previstos como la pandemiamundial producida por el Covid-19, varias mejoras y lineas de trabajo no han podido serrealizadas en este proyecto. Para terminar vamos a enumerar algunas de las más importantes:

• Utilizar texturas más realistas o similares a los de otros videojuegos en el entorno.Este no es solamente un cambio estético que haría el resultado final más espectacular

41

42 Conclusiones

visualmente. También serviría para que el aprendizaje realizado en esta escena sepuedan transferir a otras con gráficos similares.

• Explorar otros tipos de estructuras y aumentar la complejidad de los modelos utilizadosen la experimentación. Ya que en esta ocasión ha sido algo que no ha variado en lasdistintas pruebas que hemos elaborado.

• Como hemos visto en los ejemplos mostrados en la Sección 2.5, una de las partes másimportantes para conseguir grandes resultados en este tipo de pruebas es llevar a caboentrenamientos más largos en los que el agente sea capaz de explorar más soluciones y,por tanto, optimizar el rendimiento.

• Si aplicando las mejoras comentadas anteriormente se consiguieran mejores resultados,se podrían aplicar cambios al escenario para dificultar las probabilidades de éxito delagente. Es decir, que el entorno sea dinámico y no completamente estático, intro-duciendo movimiento en obstáculos, o en el propio destino. Por otro lado, podríanañadirse condiciones a cumplir por el agente antes de llegar al destino, como recogerciertos objetos, o en general ampliar las acciones que el agente puede realizar.

• Adaptar el sistema y crear situaciones en las que se controlen múltiples agentes quedeban cooperar para conseguir un objetivo común.

Bibliografía[1] K. Arulkumaran, A. Cully, and J. Togelius. AlphaStar. In Proceedings of the Genetic

and Evolutionary Computation Conference Companion on - GECCO '19. ACM Press,2019.

[2] A. P. Badia, B. Piot, S. Kapturowski, P. Sprechmann, A. Vitvitskyi, D. Guo, andC. Blundell. Agent57: Outperforming the atari human benchmark. 2020.

[3] A. P. Badia, P. Sprechmann, A. Vitvitskyi, D. Guo, B. Piot, S. Kapturowski, O. Tiele-man, M. Arjovsky, A. Pritzel, A. Bolt, and C. Blundell. Never give up: Learning directedexploration strategies. 2020.

[4] M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning envi-ronment: An evaluation platform for general agents. Journal of Artificial IntelligenceResearch, 47:253–279, jun 2013.

[5] G. Chen. A gentle tutorial of recurrent neural network with error backpropagation. 2016.

[6] V. François-Lavet, P. Henderson, R. Islam, M. G. Bellemare, and J. Pineau. An intro-duction to deep reinforcement learning. Foundations and Trends® in Machine Learning,11(3-4):219–354, 2018.

[7] A. Garcia-Garcia. 3d object recognition with convolutional neural network, 2016.

[8] H. V. Hasselt. Double q-learning. In J. D. Lafferty, C. K. I. Williams, J. Shawe-Taylor,R. S. Zemel, and A. Culotta, editors, Advances in Neural Information Processing Systems23, pages 2613–2621. Curran Associates, Inc., 2010.

[9] K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. 2016.

[10] S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural Computation,9(8):1735–1780, 1997.

[11] B. Hu, Z. Lu, H. Li, and Q. Chen. Convolutional neural network architectures formatching natural language sentences. In Z. Ghahramani, M. Welling, C. Cortes, N. D.Lawrence, and K. Q. Weinberger, editors, Advances in Neural Information ProcessingSystems 27, pages 2042–2050. Curran Associates, Inc., 2014.

[12] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training byreducing internal covariate shift. 2015.

[13] A. Juliani, A. Khalifa, V.-P. Berges, J. Harper, E. Teng, H. Henry, A. Crespi, J. To-gelius, and D. Lange. Obstacle tower: A generalization challenge in vision, control, andplanning. 2019.

43

44 Bibliografía

[14] N. Kalchbrenner, E. Grefenstette, and P. Blunsom. A convolutional neural network formodelling sentences. 2014.

[15] M. Kempka, M. Wydmuch, G. Runc, J. Toczek, and W. Jaśkowski. Vizdoom: A doom-based ai research platform for visual reinforcement learning. 2016.

[16] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolu-tional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger,editors, Advances in Neural Information Processing Systems 25, pages 1097–1105. Cur-ran Associates, Inc., 2012.

[17] Le, Ho, Lee, and Jung. Application of long short-term memory (LSTM) neural networkfor flood forecasting. Water, 11(7):1387, jul 2019.

[18] Y. Li. Deep reinforcement learning. 2018.

[19] P. Martinez-Gonzalez, S. Oprea, A. Garcia-Garcia, A. Jover-Alvarez, S. Orts-Escolano,and J. Garcia-Rodriguez. Unrealrox: An extremely photorealistic virtual reality envi-ronment for robotics simulations and synthetic data generation. 2018.

[20] S. A. P. Marvin Minsky. Perceptrons. MIT Press Ltd, 2017.

[21] W. S. McCulloch and W. H. Pitts. A logical caluculus of the ideas immanent in nervousactivity. Bulletin of Matematical Biophysics, Vol. 5, 1943.

[22] W. Min, B. Mott, J. Rowe, R. Taylor, E. Wiebe, K. Boyer, and J. Lester. Multimodalgoal recognition in open-world digital games, 2017.

[23] V. Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wierstra, and M. Ried-miller. Playing atari with deep reinforcement learning. 2013.

[24] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves,M. Riedmiller, A. K. Fidjeland, G. Ostrovski, S. Petersen, C. Beattie, A. Sadik,I. Antonoglou, H. King, D. Kumaran, D. Wierstra, S. Legg, and D. Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, feb 2015.

[25] R. Munos, T. Stepleton, A. Harutyunyan, and M. G. Bellemare. Safe and efficientoff-policy reinforcement learning. 2016.

[26] OpenAI, :, C. Berner, G. Brockman, B. Chan, V. Cheung, P. Dębiak, C. Dennison,D. Farhi, Q. Fischer, S. Hashme, C. Hesse, R. Józefowicz, S. Gray, C. Olsson, J. Pachocki,M. Petrov, H. P. de Oliveira Pinto, J. Raiman, T. Salimans, J. Schlatter, J. Schneider,S. Sidor, I. Sutskever, J. Tang, F. Wolski, and S. Zhang. Dota 2 with large scale deepreinforcement learning. 2019.

[27] D. Perez-Liebana, J. Liu, A. Khalifa, R. D. Gaina, J. Togelius, and S. M. Lucas. Gen-eral video game ai: a multi-track framework for evaluating agents, games and contentgeneration algorithms. 2018.

[28] F. Rosenblatt. The perceptron: A probabilistic model for information storage and orga-nization in the brain. Psychological Review, 65(6):386–408, 1958.

Bibliografía 45

[29] R. Schalkoff. Artificial neural networks. McGraw-Hill series in computer science: Arti-ficial intelligence. McGraw-Hill, 1997.

[30] S. Sharma, A. S. Lakshminarayanan, and B. Ravindran. Learning to repeat: Fine grainedaction repetition for deep reinforcement learning. 2017.

[31] D. Silver, A. Huang, C. J. Maddison, A. Guez, L. Sifre, G. van den Driessche,J. Schrittwieser, I. Antonoglou, V. Panneershelvam, M. Lanctot, S. Dieleman, D. Grewe,J. Nham, N. Kalchbrenner, I. Sutskever, T. Lillicrap, M. Leach, K. Kavukcuoglu,T. Graepel, and D. Hassabis. Mastering the game of go with deep neural networksand tree search. Nature, 529(7587):484–489, jan 2016.

[32] D. Silver, J. Schrittwieser, K. Simonyan, I. Antonoglou, A. Huang, A. Guez, T. Hubert,L. Baker, M. Lai, A. Bolton, Y. Chen, T. Lillicrap, F. Hui, L. Sifre, G. van den Driessche,T. Graepel, and D. Hassabis. Mastering the game of go without human knowledge.Nature, 550(7676):354–359, oct 2017.

[33] O. Simeone. A very brief introduction to machine learning with applications to commu-nication systems. 2018.

[34] R. K. Srivastava, K. Greff, and J. Schmidhuber. Training very deep networks. InC. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett, editors, Advancesin Neural Information Processing Systems 28, pages 2377–2385. Curran Associates, Inc.,2015.

[35] R. R. Torrado, P. Bontrager, J. Togelius, J. Liu, and D. Perez-Liebana. Deep reinforce-ment learning for general video game ai. 2018.

Documents

InteligenciaArtificial paraVideojuegoscon DeepReinforcement … · 2020. 6. 27. · En segundo lugar, a nivel personal, en diferentes asignaturas del grado he obtenido conocimiento