in

Iteración de valor para función V

APRENDIZAJE PROFUNDO DE REFUERZO EXPLICADO —10

Iteración de valor para función V

Función V en la práctica para entornos de lagos congelados

Jordi TORRES.AI

15 de junio de 2020·9 min de lectura

En el post anterior presentamos el Iteración de valor método para calcular los valores V y Q requeridos por los agentes basados ​​en el valor. En esta publicación, presentaremos cómo implementar el método de iteración de valor para calcular el valor del estado resolviendo el entorno de lago congelado.

Versión en español de esta publicación

4. Programación dinámica

Acceso abierto al capítulo 4 del libro Introducción al aprendizaje por refuerzo profundo

medium.com

Iteración de valores con función V en la práctica

El código completo de esta publicación se puede encontrar en GitHub y se puede ejecutar como un cuaderno de Google Colab usando este enlace.

A continuación, presentaremos en detalle el código que conforma el método Value Iteration que presentamos en el post anterior. Así que vayamos al código. Al principio, importamos las bibliotecas utilizadas y definimos las constantes principales:

import gym
import collections
from torch.utils.tensorboard import SummaryWriter
ENV_NAME="FrozenLake-v0"GAMMA = 0.9
TEST_EPISODES = 20
N =100
REWARD_GOAL = 0.8

Estructuras de datos del agente

Las principales estructuras de datos que mantendrán la información del Agente son:

  • rewards: Un diccionario con la clave compuesta «estado de origen» + «acción» + «estado de destino». El valor se obtiene de la recompensa inmediata.
  • transits: Una mesa como un diccionario que mantiene contadores de las transiciones experimentadas. La clave es el compuesto «estado» + «acción», y el valor es otro diccionario que mapea el estado de destino en un recuento de veces que lo hemos visto.
  • values: Diccionario que asigna un estado al valor calculado de este estado (valor V).
  • state: Estado actual del Agente.

El maISe crean n estructuras de datos en el constructor de clases del Agente.

Algoritmo de entrenamiento

La lógica general de nuestro algoritmo de entrenamiento es simple. Hasta que no se alcance el objetivo de recompensa deseado, ejecutaremos los siguientes pasos:

  1. reproducir N pasos aleatorios desde el entorno hasta poblar el reward y transits mesas.
  2. Después de esos N pasos, realiza un paso de iteración de valor sobre todos los estados, actualizando el value mesa.
  3. Luego jugamos varios episodios completos para verificar las mejoras usando la tabla de valores actualizada.
  4. Si la recompensa promedio para esos episodios de prueba está por encima del límite deseado, entonces dejamos de entrenar.

Antes de entrar en más detalles sobre este código, será útil revisar primero el código del agente.

Clase de agente

En el Agentconstructor de clases, creamos un entorno que usaremos para muestras de datos, obtenemos nuestra primera observación y definimos tablas para recompensas, transiciones y valores:

class Agent: 
def __init__(self):
self.env = gym.make(ENV_NAME)
self.state = self.env.reset()
self.rewards = collections.defaultdict(float)
self.transits = collections.defaultdict(
collections.Counter)
self.values = collections.defaultdict(float)

Reproducir pasos aleatorios

Recuerda que en el post anterior adelantamos que la estimación de Transiciones y Recompensas se obtendrá a través del historial de interacción del Agente con el Medio Ambiente.

Esto se hace mediante el método play_n_random_steps que juega N pasos aleatorios del entorno, que pueblan el reward y transits mesas con experiencias aleatorias.

def play_n_random_steps(self, count):
for _ in range(count):
action = self.env.action_space.sample()
new_state, reward, is_done, _ = self.env.step(action)
self.rewards[(self.state, action, new_state)] = reward
self.transits[(self.state, action)][new_state] += 1
if is_done:
self.state = self.env.reset()
else:
self.state = new_state

Tenga en cuenta que no es necesario esperar al final del episodio para comenzar a aprender; solo actuamos N pasos y recuerde sus resultados. Esta es una de las diferencias entre la iteración de valor y el método de entropía cruzada que se muestra en una publicación anterior, que requiere episodios completos para aprender.

Valor de la acción

El siguiente método calcula la función Q, el valor de una acción de un estado usando el transits, reward, y value tablas del Agente. Lo usaremos para dos propósitos: seleccionar la mejor acción a realizar desde el estado y calcular el nuevo valor del estado en el algoritmo de iteración de valor.

def calc_action_value(self, state, action):
target_counts = self.transits[(state, action)]
total = sum(target_counts.values())

action_value = 0.0
for tgt_state, count in target_counts.items():
reward = self.rewards[(state, action, tgt_state)]
val = reward + GAMMA * self.values[tgt_state]
action_value += (count / total) * val
return action_value

Primero, desde el transits tabla, extraemos contadores de transición para el estado y la acción dados que el método recibe como argumentos. Sumamos todos los contadores para obtener el recuento total de veces que hemos ejecutado la acción del estado. Luego iteramos cada estado objetivo en el que ha aterrizado nuestra acción y calculamos su contribución al valor total de la acción utilizando la fórmula presentada en la publicación de la ecuación de Bellman:

Este valor es igual a la recompensa inmediata más el valor descontado para el estado objetivo y multiplica esta suma por la probabilidad de esta transición (contador individual dividido por el valor total calculado antes). Agregamos el resultado de cada iteración a una variable action_value, la variable que se devolverá.

Seleccione la mejor acción

Para seleccionar la mejor acción de un estado dado, tenemos el método select_action que usa el anterior calc_action_value método para tomar la decisión:

def select_action(self, state):
best_action, best_value = None, None
for action in range(self.env.action_space.n):
action_value = self.calc_action_value(state, action)
if best_value is None or best_value < action_value:
best_value = action_value
best_action = action
return best_action

El código de este método itera sobre todas las acciones posibles en el entorno, calcula el valor de cada acción y devuelve la acción con el valor Q más grande.

Función de iteración de valor

Y aquí tenemos la función principal, que como describimos en la publicación anterior, lo que hace el método de iteración de valor es simplemente recorrer todos los estados en el entorno:

def value_iteration(self):
for state in range(self.env.observation_space.n):
state_values = [
self.calc_action_value(state, action)
for action in range(self.env.action_space.n)
]
self.values[state] = max(state_values)

Para cada estado, actualizamos su valor con el valor máximo de la acción disponible en el estado.

Training Loop y seguimiento del código

Después de presentar la clase del Agente y sus métodos, volvemos a describir el ciclo principal. En primer lugar, creamos el entorno que usaremos para las pruebas, creamos una instancia de la clase Agent, el escritor de resumen para TensorBoard y algunas variables que usaremos:

test_env = gym.make(ENV)
agent = Agent()
writer = SummaryWriter()
iter_no = 0
best_reward = 0.0

Recuerde que el método de iteración de valor requiere formalmente un número infinito de iteraciones para converger exactamente para obtener la función de valor óptimo. En la práctica, en la publicación anterior, mostramos que podemos detenernos una vez que la función de valor cambia solo una pequeña cantidad en una iteración del ciclo de entrenamiento.

En este ejemplo, para mantener el código simple y con pocas iteraciones, decidimos detenernos cuando alcanzamos algún umbral de recompensa. Pero todo el resto del código es idéntico.

La lógica general de nuestro código es simplemente un ciclo que se repetirá hasta que el Agente logre el rendimiento esperado (si la recompensa promedio para esos episodios de prueba está por encima del REWARD_GOALlímite, luego dejamos de entrenar):

while best_reward < REWARD_GOAL:
agent.play_n_random_steps(N)
agent.value_iteration()

...

El cuerpo del bucle se compone de los pasos introducidos anteriormente:

PASO 1: reproduce N pasos aleatorios llamando al método plays_n_random_steps.

PASO 2: Realiza un barrido de iteración de valor sobre todos los estados que llaman al método value_iteration.

PASO 3: Luego jugamos varios episodios completos para verificar las mejoras usando la tabla de valores actualizada. Para eso el código usa agent.elect_action() para encontrar la mejor acción para realizar en la nueva test_env Entorno (no queremos alterar el estado actual del entorno principal utilizado para recopilar datos aleatorios), para comprobar las mejoras del Agente:

iter_no += 1
reward_avg = 0.0
for _ in range(TEST_EPISODES):
total_reward = 0.0
state = test_env.reset()
while True:
action = Select_action(state)
new_state, new_reward, is_done, _ = test_env.step(action)
total_reward += new_reward
if is_done: break
state = new_state
reward_test += total_reward
reward_test /= TEST_EPISODES

Además, el código escribe datos en TensorBoard para rastrear la mejor recompensa promedio:

writer.add_scalar("reward", reward_test, iter_no)
if reward_test > best_reward:
print("Best reward updated %.2f at iteration %d " %
(reward_test ,iter_no) )
best_reward = reward_test

¡Y eso es todo!

Ejecuta el programa

Bien, ejecutemos nuestro programa:

Best reward updated 0.40 in iteration 13 
Best reward updated 0.65 in iteration 20
Best reward updated 0.80 in iteration 23
Best reward updated 0.85 in iteration 28
Best reward updated 0.90 in iteration 76

Prueba al cliente

Ahora, si intentamos con el mismo código de prueba de cliente que en el caso de Cross-Entropy, podemos ver que el Agente que hemos construido, puede aprender de un Entorno resbaladizo:

new_test_env = gym.make(‘FrozenLake-v0’, is_slippery=True)
state = new_test_env.reset()
new_test_env.render()
is_done = False
iter_no = 0
while not is_done:
action = Select_action(state)
new_state, reward, is_done, _ = new_test_env.step(action)
new_test_env.render()
state = new_state
iter_no +=1
print(“reward = “, reward)
print(“iterations =”, iter_no)

. . .

1*3ru7oeHkCrV418Gakrwtig

Conclusiones

Tenga en cuenta que el algoritmo presentado es estocástico y para diferentes ejecuciones, emplea un número diferente de iteraciones para llegar a una solución. Sin embargo, podría aprender de un entorno resbaladizo en lugar de la entropía cruzada presentada anteriormente. Podemos trazar todos ellos usando Tensorboard que mostrará gráficos como el siguiente:

Podemos notar que en todos los casos, se necesitan unos segundos como máximo para encontrar una buena política que resuelva el Medio Ambiente en el 80% de las ejecuciones. Si recuerda el método de la entropía cruzada, para un entorno resbaladizo, se necesitaron muchas horas para lograr una tasa de éxito de solo el 60%.

Además, podemos aplicar este algoritmo a una versión más grande de FrozenLake, que tiene el nombre FrozenLake8x8-v0. La versión más grande de FrozenLake puede tomar muchas más iteraciones para resolver y, según los gráficos de TensorBoard, la mayoría de las veces espera el primer episodio exitoso (debe tener al menos un episodio exitoso para comenzar a aprender de la tabla de valores útiles), luego alcanza la convergencia muy rápidamente. A continuación se muestra un cuadro que compara la dinámica de recompensas durante el entrenamiento en la versión FrozenLake-4×4 y 8×8:

1*n3Q6FLzP7Va7BL0ecBDEVg

Además de cambiar el entorno en ENV_NAME(«FrozenLake-v0» vs «FrozenLake8x8-v0»), el lector puede realizar pruebas con diferentes valores de los hiperparámetros como GAMMA, TEST_EPISODE, REWARD_GOAL o N. ¿Por qué no lo intentas?

¿Lo que sigue?

En la próxima publicación, presentaremos el código del método Value Iteration que aprende los valores de las acciones en lugar de aprender los valores de los estados como lo hemos hecho aquí. ¡Nos vemos en la siguiente publicación!

El código completo de esta publicación se puede encontrar en …

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Wbis7aHCeU7QTfigvbTtHK 1200 80

La mejor cámara para principiantes 2021: las 8 mejores cámaras para principiantes que puedes comprar en 2020

obic customer sales account management f 3889594.svg.svgxml charset

Grupo de seguridad nacional de Oracle | Carreras