Equilibrar exploración y explotación

Reinforcement Learning con Gymnasium en Python

Fouad Trad

Machine Learning Engineer

Entrenar con acciones aleatorias

El agente explora el entorno
Sin optimizar estrategia con lo aprendido
Usa el conocimiento al terminar el entrenamiento

Imagen que muestra un agente dentro de un entorno

Compromiso exploración-explotación

Equilibra exploración y explotación
Explorar continuamente impide refinar la estrategia
Explotar solo puede perder oportunidades no descubiertas

Imagen que muestra a un agente intentando explorar acciones nuevas para descubrir más recompensas y, a la vez, explotar su conocimiento mientras puede perder algunas recompensas.

Elecciones al comer

Imagen de una mesa de restaurante.

Estrategia épsilon-greedy

Explora con probabilidad épsilon

Diagrama que muestra que con probabilidad épsilon, el agente explora eligiendo una acción aleatoria.

Estrategia épsilon-greedy

Explora con probabilidad épsilon
Explota con probabilidad 1-éspsilon
Asegura exploración continua mientras usa el conocimiento

Diagrama que muestra que con probabilidad épsilon, el agente explora eligiendo una acción aleatoria, y con probabilidad 1 - épsilon, explota seleccionando la mejor acción conocida.

Estrategia épsilon-greedy con decaimiento

Reduce épsilon con el tiempo
Más exploración al inicio
Más explotación después
El agente confía cada vez más en lo aprendido

Imagen que muestra cómo épsilon disminuye con el tiempo.

Implementación con Frozen Lake

env = gym.make('FrozenLake', is_slippery=True)

action_size = env.action_space.n
state_size = env.observation_space.n
Q = np.zeros((state_size, action_size))


alpha = 0.1
gamma = 0.99
total_episodes = 10000

Imagen que muestra una vista del entorno Frozen Lake.

Implementar epsilon_greedy()

def epsilon_greedy(state):

    if np.random.rand() < epsilon:
        action = env.action_space.sample()  # Explore

    else:
        action = np.argmax(Q[state, :])  # Exploit
    return action

Entrenamiento épsilon-greedy

epsilon = 0.9   # Exploration rate

rewards_eps_greedy = []

for episode in range(total_episodes):
    state, info = env.reset()
    terminated = False
    episode_reward = 0
    while not terminated:
        action = epsilon_greedy(state)
        new_state, reward, terminated, truncated, info = env.step(action)       
        Q[state, action] = update_q_table(state, action, new_state) 
        state = new_state

        episode_reward += reward
    rewards_eps_greedy.append(episode_reward)

Entrenamiento épsilon-greedy con decaimiento

epsilon = 1.0   # Exploration rate
epsilon_decay = 0.999
min_epsilon = 0.01

rewards_decay_eps_greedy = []
for episode in range(total_episodes):
    state, info = env.reset()
    terminated = False
    episode_reward = 0
    while not terminated:
        action = epsilon_greedy(state)
        new_state, reward, terminated, truncated, info = env.step(action)
        episode_reward += reward        
        Q[state, action] = update_q_table(state, action, new_state) 
        state = new_state
    rewards_decay_eps_greedy.append(episode_reward)

    epsilon = max(min_epsilon, epsilon * epsilon_decay)

Comparar estrategias

avg_eps_greedy= np.mean(rewards_eps_greedy)
avg_decay = np.mean(rewards_decay_eps_greedy)
plt.bar(['Epsilon Greedy', 'Decayed Epsilon Greedy'],
        [avg_eps_greedy, avg_decay], 
        color=['blue', 'green'])
plt.title('Average Reward per Episode')
plt.ylabel('Average Reward')
plt.show()

Imagen de un diagrama de barras que muestra que la recompensa media con épsilon-greedy es ~0,02 y con épsilon-greedy con decaimiento es ~0,55.

¡Vamos a practicar!

Reinforcement Learning con Gymnasium en Python