Algoritmos elementales de Aprendizaje por Refuerzo

El Aprendizaje por Refuerzo (RL, por sus siglas en inglés) es una rama del aprendizaje automático que se enfoca en que un agente tome decisiones óptimas en un ambiente dinámico desconocido. El agente aprende a través de la retroalimentación de su comportamiento en forma de recompensas y castigos.

Los algoritmos elementales de RL son aquellos que se utilizan para resolver problemas básicos de RL. Entre estos algoritmos se encuentran el método de Iteración de Valor (VI) y el método de Iteración de Política (PI). En VI, el agente actualiza iterativamente su función de valor de estado hasta converger a la solución óptima. En PI, el agente actualiza su política iterativamente hasta que se encuentra la política óptima.

Otro algoritmo elemental es el de Montecarlo, que estima la función de valor de estado mediante la simulación de episodios completos, y el de TD (Temporal Difference), que actualiza la función de valor de estado en cada paso del episodio.

En general, los algoritmos elementales de RL proporcionan una base sólida para comprender y resolver problemas más complejos de RL.

Los algoritmos elementales de Aprendizaje por Refuerzo (RL) son fundamentales para enseñar a un agente a tomar decisiones en un entorno desconocido. Aquí tienes una descripción estructurada de estos algoritmos:

1. Algoritmo de Aprendizaje de MC (Monte Carlo):

   • Enfoque: Aprender a través de la experiencia.
   • Proceso: El agente toma decisiones en el ambiente y recibe retroalimentación.
   • Método: Utiliza esta retroalimentación para aprender y mejorar su desempeño.

2. Algoritmo de Q-Learning:

   • Enfoque: Aprender a través de la exploración.
   • Proceso: El agente explora el ambiente y toma decisiones basadas en su conocimiento actual.
   • Método: La retroalimentación recibida actualiza su conocimiento, mejorando su desempeño.

3. Algoritmo SARSA (State-Action-Reward-State-Action):

   • Enfoque: Aprender a través de la interacción agente-ambiente.
   • Proceso: El agente toma decisiones basadas en su conocimiento actual y actualiza su conocimiento con la retroalimentación recibida.

4. Algoritmo Actor-Critic:

   • Enfoque: Combina los enfoques de MC y Q-Learning.
   • Método: Utiliza una red neuronal (actor) para tomar decisiones y otra red neuronal (crítico) para evaluar y mejorar el desempeño del actor.

Cada uno de estos algoritmos tiene ventajas y desventajas, por lo que la elección depende del problema específico y del tipo de ambiente en el que se está trabajando.

Un ejemplo práctico de algoritmos elementales de aprendizaje por refuerzo es el Método de Iteración de Valor o Value Iteration, utilizado para resolver problemas de decisión de Markov. Este algoritmo está basado en la iteración de la función de valor óptimo, que representa el valor esperado del retorno que puede obtenerse desde un estado determinado del problema.

La ecuación de iteración de valor se basa en la idea de que el valor de un estado se puede actualizar recursivamente a partir del valor de sus sucesores, es decir, de los posibles estados siguientes que pueden ser alcanzados a partir del estado actual, ponderando la probabilidad de transición hacia ellos. Esto se puede expresar como:

𝑉(𝑠)=max⁡𝑎∑𝑠′𝑃(𝑠′∣𝑠,𝑎)[𝑅(𝑠,𝑎,𝑠′)+𝛾𝑉(𝑠′)]V(s)=maxa​∑s′​P(s′∣s,a)[R(s,a,s′)+γV(s′)]

Donde:

• 𝑉(𝑠)V(s) es el valor de un estado 𝑠s.
• max⁡𝑎maxa​ se refiere a la acción que maximiza la ecuación.
• ∑𝑠′∑s′​ es la suma de los estados siguientes.
• 𝑃(𝑠′∣𝑠,𝑎)P(s′∣s,a) es la probabilidad de transición hacia 𝑠′s′.
• 𝑅(𝑠,𝑎,𝑠′)R(s,a,s′) es la recompensa obtenida por realizar la acción 𝑎a en 𝑠s y alcanzar 𝑠′s′.
• 𝛾γ es el factor de descuento que indica la importancia relativa de las recompensas inmediatas frente a las futuras.

El algoritmo de Iteración de Valor se ejecuta de manera iterativa sobre todos los estados posibles del problema hasta que se converja a un valor óptimo para cada uno de ellos. Esto permite obtener una política óptima para tomar decisiones en el problema, es decir, una estrategia que maximiza el valor esperado de las recompensas a largo plazo.

En resumen, el algoritmo de Iteración de Valor es un ejemplo práctico de método elemental de aprendizaje por refuerzo, que permite resolver problemas de decisión de Markov usando técnicas de optimización basadas en la estimación de la función de valor óptimo.

Uno de los algoritmos elementales de Aprendizaje por Refuerzo es el algoritmo de Q-learning.

Este algoritmo actualiza una tabla de valores Q que indica la recompensa esperada para cada par estado-acción en un entorno determinado. El siguiente ejemplo muestra cómo implementar el algoritmo de Q-learning en Python para resolver el problema clásico "FrozenLake" de Gym:

        
import gym
import numpy as np

env = gym.make('FrozenLake-v0')

# Definir hiperparámetros
num_episodes = 5000
max_steps_per_episode = 100
learning_rate = 0.8
discount_rate = 0.95
exploration_rate = 1
max_exploration_rate = 1
min_exploration_rate = 0.01
exploration_decay_rate = 0.001

# Inicializar la tabla Q
num_states = env.observation_space.n
num_actions = env.action_space.n
Q = np.zeros((num_states, num_actions))

# Ejecutar el ciclo de entrenamiento
for episode in range(num_episodes):
    state = env.reset()
    done = False
    total_reward = 0
    
    for step in range(max_steps_per_episode):
        # Elegir una acción mediante un trade-off de exploración y explotación
        exploration_rate_threshhold = np.random.uniform(0, 1)
        
        if exploration_rate_threshhold > exploration_rate:
            action = np.argmax(Q[state, :])
        else:
            action = env.action_space.sample()
            
        # Realizar la acción y actualizar el entorno
        new_state, reward, done, info = env.step(action)
        
        # Actualizar la tabla Q
        Q[state, action] = (1 - learning_rate) * Q[state, action] + learning_rate * (reward + discount_rate * np.max(Q[new_state, :]))
        
        # Actualizar el estado y la recompensa
        state = new_state
        total_reward += reward
        
        if done:
            break
    
    # Actualizar la tasa de exploración
    exploration_rate = min_exploration_rate + (max_exploration_rate - min_exploration_rate) * np.exp(-exploration_decay_rate * episode)
    
    # Mostrar las estadísticas del episodio
    print("Episodio: {}, Recompensa Total: {}, Tasa de Exploración: {}".format(episode+1, total_reward, exploration_rate))
        
    

Este código crea un entorno "FrozenLake" y define ciertos hiperparámetros, como el número de episodios de entrenamiento y la tasa de aprendizaje. Luego itera a través de los episodios y dentro de cada episodio realiza un ciclo a través de pasos donde se actualiza la tabla Q mediante el algoritmo de Q-learning. También se utiliza una estrategia de trade-off entre exploración y explotación para seleccionar acciones en cada paso. Finalmente, se muestra un registro de las estadísticas de entrenamiento para cada episodio, como la recompensa total y la tasa de exploración en ese momento.