Cómo entrenar a tu Inteligencia Artificial jugando videojuegos, Parte 5. Aprende Q-Learning con el juego "Taxi", parte 2 de 2

#Inicializacion de variables
Q=np.zeros([env.observation_space.n, env.action_space.n])
alpha=0.2

Antes de explicar la siguiente parte del código que incluye la función run_episode, vamos a ver primero la parte principal de ejecución, de esta forma entenderemos mejor luego el funcionamiento de dicha función. Observamos el bucle que ejecutará los episodios, en nuestro caso hemos definido 2000:

for episode in range (0,2000):

Luego inicializamos las variables que vamos a utilizar en cada ejecución de episodio, entre ellas también el entorno con la variable observation y env.reset()

    out_done=None
    reward = 0
    rewardstore=0
    observation = env.reset() 

action = np.argmax(Q[observation])

La siguiente parte del código llama la función run_episode utilizando como parámetros la variable observation y action. Esta función devolverá tres valores:

• out_done: ya la hemos comentado antes, devolverá True cuando termine el episodio
• out_totalreward: devolverá un número entero con la recompensa obtenida
• out_observation: devolverá un número entre 0 y 500 que nos indicará en qué estados están las variables del entorno después de realizar una acción (por ejemplo, la nueva ubicación del taxi o si hemos recogido o no un pasajero)

La recompensa obtenida en la ejecución de estas acciones la acumularemos en la variable rewardstore (para tener un valor global de recompensa) y actualizamos los valores de la nueva observación recibida desde out_observation almacenándolos en la variable observation para preparar la siguiente ejecución de acciones:

rewardstore += out_totalreward
observation = out_observation

    print('Episodio {} Recompensa: {}'.format(episode,rewardstore))

def run_episode(observation1, movimiento):   

La primera acción a realizar será ejecutar los movimientos que hemos recibido como parámetros. Para ello utilizamos la función env.step(movimiento). Esta ejecución devolverá 4 valores:

• observation2: situación en la que queda el entorno después de nuestro movimiento
• reward: recompensa obtenida
• done: si hemos finalizado
• info: datos estadísticos (que no usaremos de momento)

Una vez recibida toda esa información procedemos a actualizar la tabla Q con los valores obtenidos después de utilizar la fórmula que explicamos en el anterior artículo: Y que se traduce en código Python de la siguiente manera:

Q[observation1,movimiento] += alpha * (reward + np.max(Q[observation2]) - Q[observation1,movimiento])   

Básicamente, lo que está ocurriendo durante la ejecución de esta función y del algoritmo, es lo siguiente. Como ya hemos comentado, la tabla Q es una matriz NxM, donde N es el número de estados y M las acciones a realizar (definido por las variables env.observation_space.n y env.action_space.n respectivamente). En función de estado donde nos encontremos (en el caso de la imagen anterior era el 64), se comprueba la fila (que básicamente es una lista, como se puede ver también en la imagen) y cada columna (acción) lo que vamos almacenando o comprobando es la probabilidad de elegir esa acción. Así poco a poco vamos construuendo nuestra tabla Q con los valores más óptimos posibles. En el último paso la función devuelve los valores done, reward y observation2 (los cuales corresponderán a las variables out_done, out_totalreward y out_observation:

return done,reward, observation2

Finalmente obtendremos una matriz Q rellena con los valores óptimos para cada posible estado que pueda ofrecer este entorno. La visualización de los algoritmos, datos y tiempos de aprendizaje (ejecución) son muy importantes, por eso vamos a ver cómo crearlos. En este caso, vamos a utilizar la librería Matplotlib para Python para dibujar dos gráficas, la primera de ellas mostrará la evolución de los pasos necesarios a ejecutar en cada episodio hasta encontrar una solución óptima al problema. Por otro lado, también mostraremos la evolución de las recompensas obtenidas. Este primer gráfico muestra como a medida que avanzan los episodios de entrenamiento, son necesarias menos ejecuciones de pasos para encontrar la solución óptima. De hecho, a partir de más o menos los 600 episodios ya podemos notar la disminución del número de pasos a ejecutar: Crear estos gráficos es sencillo, simplemente instalamos la librería Matplotlib en nuestro entorno Linux:

sudo apt-get install python3-matplotlib

Luego la importamos dentro del código:

import matplotlib.pyplot as plt

Y finalmente dibujamos un eje de coordenadas x e y con rango x desde 0 a 2000 (número de episodios) y como rango y desde 0 a 100 (pasos máximos por episodio). Luego etiquetamos los ejes con el comando plt.xlabel y plt.ylabel y finalmente lo dibujamos con el comando plt.plot. La variable episodios será una lista de elementos con los valores de 1 a 2000 y la variable pasostotal será una lista con el número de pasos ejecutados por cada episodio. Por otro lado, la variable recompensas será también una lista donde almacenamos la recompensa obtenida en cada episodio:

#Gráfica de pasos por episodio
plt.axis([0,2000,0,100])
plt.xlabel('Episodios')
plt.ylabel('Pasos realizados')
plt.plot(episodios,pasostotal,color='blue')
plt.show()

#Gráfica de recompensa por episodio
plt.axis([0,2000,-200,100])
plt.xlabel('Episodios')
plt.ylabel('Valor Recompensa')
plt.plot(episodios,recompensas,color='red')
plt.show() 

A continuación mostramos un vídeo con la ejecución y el código fuente final el cual es una modificación del principal que aparece al principio de este artículo, pero esta vez se muestra una ejecución paso a paso, donde vemos todos los valores de la tabla Q así como una visualización de los estados (simulando una animación). Al final de proceso, el cual será largo ya que son 2000 episodios se mostrarán los gráficos. Para acelerarlo podemos comentar todos los comandos print que no necesitemos y sobre todo la la línea input(“->”), la cual espera que pulsemos una tecla para continuar con la ejecución. En el siguiente video podemos ver este proceso, tanto la salida de ejecución como la modificación de los comandos: