Profundizando en el aprendizaje por refuerzo con Q-Learning

Este artículo es parte del curso de aprendizaje de refuerzo profundo con Tensorflow? ️. Consulta el plan de estudios aquí.

Hoy aprenderemos sobre Q-Learning. Q-Learning es un algoritmo de aprendizaje por refuerzo basado en valores.

Este artículo es la segunda parte de una serie gratuita de publicaciones de blog sobre el aprendizaje por refuerzo profundo. Para obtener más información y recursos, consulte el programa del curso. Vea el primer artículo aquí.

En este artículo aprenderá:

  • Qué es Q-Learning
  • Cómo implementarlo con Numpy

El panorama general: el Caballero y la Princesa

Digamos que eres un caballero y necesitas salvar a la princesa atrapada en el castillo que se muestra en el mapa de arriba.

Puede mover un mosaico a la vez. El enemigo no puede, pero aterriza en la misma casilla que el enemigo y morirás.Tu objetivo es ir al castillo por la ruta más rápida posible. Esto se puede evaluar mediante un sistema de "puntuación".

  • ustedperder -1 en cada paso (perder puntos en cada pasoayuda a nuestro agente a ser rápido).
  • Si tocas a un enemigo, pierdes -100 puntos y el episodio termina.
  • Si estás en el castillo que ganas, obtienes +100 puntos.

La pregunta es: ¿cómo se crea un agente que pueda hacer eso?

He aquí una primera estrategia. Digamos que nuestro agente intenta ir a cada mosaico y luego colorea cada mosaico. Verde para "seguro" y rojo si no.

Entonces, podemos decirle a nuestro agente que solo tome fichas verdes.

Pero el problema es que no es realmente útil. No sabemos cuál es la mejor ficha para tomar cuando las fichas verdes están adyacentes entre sí.¡Entonces nuestro agente puede caer en un bucle infinito al tratar de encontrar el castillo!

Presentamos la Q-table

Aquí hay una segunda estrategia: cree una tabla donde calcularemos la recompensa futura máxima esperada, para cada acción en cada estado.

Gracias a eso, sabremos cuál es la mejor acción a tomar para cada estado.

Cada estado (mosaico) permite cuatro acciones posibles. Estos se mueven hacia la izquierda, derecha, arriba o abajo.

En términos de cálculo, podemos transformar esta cuadrícula en una tabla.

Esto se denomina tabla Q ("Q" para "calidad" de la acción). Las columnas serán las cuatro acciones (izquierda, derecha, arriba, abajo). Las filas serán los estados. El valor de cada celda será la recompensa futura máxima esperada para ese estado y acción determinados.

Cada puntuación de Q-table será la máxima recompensa futura esperada que obtendré si tomo esa medida en ese estado con la mejor política dada.

¿Por qué decimos "con la política dada"? Es porque no implementamos una política. En cambio, solo mejoramos nuestra Q-table para elegir siempre la mejor acción.

Piense en esta Q-table como una "hoja de trucos" del juego. Gracias a eso, sabemos para cada estado (cada línea de la tabla Q) cuál es la mejor acción a tomar, al encontrar la puntuación más alta en esa línea.

¡Si! ¡Resolvimos el problema del castillo! Pero espera… ¿Cómo calculamos los valores para cada elemento de la tabla Q?

Para conocer cada valor de esta tabla Q, usaremos el algoritmo de aprendizaje Q.

Algoritmo de Q-learning: aprendizaje de la función de valor de acción

La función de valor de acción (o "función Q") toma dos entradas: "estado" y "acción". Devuelve la recompensa futura esperada de esa acción en ese estado.

Podemos ver esta función Q como un lector que se desplaza por la tabla Q para encontrar la línea asociada con nuestro estado y la columna asociada con nuestra acción. Devuelve el valor Q de la celda correspondiente. Esta es la "recompensa futura esperada".

Pero antes de explorar el entorno, la tabla Q da el mismo valor fijo arbitrario (la mayoría de las veces 0). A medida que exploramos el entorno , la tabla Q nos dará una aproximación cada vez mejor actualizando iterativamente Q (s, a) usando la Ecuación de Bellman (¡ver más abajo!).

El proceso del algoritmo Q-learning

Paso 1: inicializar los valores Q

Construimos una tabla Q, con m columnas (m = número de acciones) y n filas (n = número de estados). Inicializamos los valores en 0.

Paso 2: de por vida (o hasta que se detenga el aprendizaje)

Los pasos 3 a 5 se repetirán hasta que alcancemos un número máximo de episodios (especificado por el usuario) o hasta que detengamos manualmente el entrenamiento.

Paso 3: elige una acción

Elija una acción a en el estado actual s en función de las estimaciones del valor Q actual.

Pero ... ¿qué acción podemos tomar al principio, si cada valor Q es igual a cero?

Ahí es donde será importante la compensación de exploración / explotación de la que hablamos en el último artículo.

La idea es que al principio,Usaremos la estrategia codiciosa de épsilon:

  • We specify an exploration rate “epsilon,” which we set to 1 in the beginning. This is the rate of steps that we’ll do randomly. In the beginning, this rate must be at its highest value, because we don’t know anything about the values in Q-table. This means we need to do a lot of exploration, by randomly choosing our actions.
  • We generate a random number. If this number > epsilon, then we will do “exploitation” (this means we use what we already know to select the best action at each step). Else, we’ll do exploration.
  • The idea is that we must have a big epsilon at the beginning of the training of the Q-function. Then, reduce it progressively as the agent becomes more confident at estimating Q-values.

Steps 4–5: Evaluate!

Take the action a and observe the outcome state s’ and reward r. Now update the function Q(s,a).

We take the action a that we chose in step 3, and then performing this action returns us a new state s’ and a reward r (as we saw in the Reinforcement Learning process in the first article).

Then, to update Q(s,a) we use the Bellman equation:

The idea here is to update our Q(state, action) like this:

New Q value = Current Q value + lr * [Reward + discount_rate * (highest Q value between possible actions from the new state s’ ) — Current Q value ]

Let’s take an example:

  • One cheese = +1
  • Two cheese = +2
  • Big pile of cheese = +10 (end of the episode)
  • If you eat rat poison =-10 (end of the episode)

Step 1: We init our Q-table

Step 2: Choose an action

From the starting position, you can choose between going right or down. Because we have a big epsilon rate (since we don’t know anything about the environment yet), we choose randomly. For example… move right.

We found a piece of cheese (+1), and we can now update the Q-value of being at start and going right. We do this by using the Bellman equation.

Steps 4–5: Update the Q-function

  • First, we calculate the change in Q value ΔQ(start, right)
  • Then we add the initial Q value to the ΔQ(start, right) multiplied by a learning rate.

Think of the learning rate as a way of how quickly a network abandons the former value for the new. If the learning rate is 1, the new estimate will be the new Q-value.

Good! We’ve just updated our first Q value. Now we need to do that again and again until the learning is stopped.

Implement a Q-learning algorithm

Hicimos un video donde implementamos un agente de Q-learning que aprende a jugar Taxi-v2 con Numpy.

Ahora que sabemos cómo funciona, implementaremos el algoritmo Q-learning paso a paso. Cada parte del código se explica directamente en el cuaderno de Jupyter a continuación.

Puede acceder a él en el repositorio del curso de aprendizaje de refuerzo profundo.

O puede acceder a él directamente en Google Colaboratory:

Q * Aprendiendo con Frozen Lake

colab.research.google.com

Un resumen ...

  • Q-learning es un algoritmo de aprendizaje por refuerzo basado en valores que se utiliza para encontrar la política óptima de selección de acciones mediante la función aq.
  • Evalúa qué acción tomar en función de una función de valor de acción que determina el valor de estar en un estado determinado y realizar una acción determinada en ese estado.
  • Objetivo: maximizar la función de valor Q (recompensa futura esperada dado un estado y una acción).
  • Q table helps us to find the best action for each state.
  • To maximize the expected reward by selecting the best of all possible actions.
  • The Q come from qualityof a certain action in a certain state.
  • Function Q(state, action) → returns expected future reward of that action at that state.
  • This function can be estimated using Q-learning, which iteratively updates Q(s,a) using the Bellman Equation
  • Before we explore the environment: Q table gives the same arbitrary fixed value → but as we explore the environment → Q gives us a better and better approximation.

That’s all! Don’t forget to implement each part of the code by yourself — it’s really important to try to modify the code I gave you.

Try to add epochs, change the learning rate, and use a harder environment (such as Frozen-lake with 8x8 tiles). Have fun!

Next time we’ll work on Deep Q-learning, one of the biggest breakthroughs in Deep Reinforcement Learning in 2015. And we’ll train an agent that that plays Doom and kills enemies!

If you liked my article, please click the ? below as many time as you liked the article so other people will see this here on Medium. And don’t forget to follow me!

If you have any thoughts, comments, questions, feel free to comment below or send me an email: [email protected], or tweet me @ThomasSimonini.

Keep learning, stay awesome!

Deep Reinforcement Learning Course with Tensorflow ?️

? Syllabus

? Video version

Part 1: An introduction to Reinforcement Learning

Part 2: Diving deeper into Reinforcement Learning with Q-Learning

Part 3: An introduction to Deep Q-Learning: let’s play Doom

Part 3+: Improvements in Deep Q Learning: Dueling Double DQN, Prioritized Experience Replay, and fixed Q-targets

Part 4: An introduction to Policy Gradients with Doom and Cartpole

Part 5: An intro to Advantage Actor Critic methods: let’s play Sonic the Hedgehog!

Part 6: Proximal Policy Optimization (PPO) with Sonic the Hedgehog 2 and 3

Part 7: Curiosity-Driven Learning made easy Part I