Métodos de Exploración Eficiente: Curiosidad y Count-Based Exploration

Exploración en entornos con recompensas escasas — uno de los desafíos fundamentales del aprendizaje por refuerzo profundo. Cuando las señales de recompensa son raras o están ausentes, el agente debe descubrir caminos útiles sin retroalimentación directa. Aquí surge la necesidad de estrategias de exploración que incentiven la novedad y la cobertura del espacio de estados. Esta lección presenta dos familias poderosas: curiosity-driven exploration (basada en modelo interno) y count-based exploration (conteo de visitas), integrándolas en el agente DQN para juegos como Montezuma’s Revenge.

1. El problema de la exploración en recompensas escasas

En tareas como Montezuma’s Revenge, la recompensa externa (p.ej. recoger una llave) puede aparecer tras cientos de pasos. Sin guía, el agente tiende a repetir acciones que ya conoce (explotación) y no descubre nuevas regiones. La exploración ingenua (ε-greedy) es insuficiente, pues no distingue entre estados novedosos y visitados. Por ello, se introducen bonificaciones de exploración internas, añadidas a la recompensa externa.

2. Exploración basada en curiosidad (curiosity-driven)

La curiosidad se modela mediante el error de predicción de un modelo de dinámica (forward dynamics). El agente aprende a predecir el siguiente estado dado el estado actual y la acción. Si la predicción es errónea (alta sorpresa), el agente recibe una bonificación. La recompensa interna es proporcional al error de predicción.

• Modelo de dinámica: red neuronal que estima s_{t+1} = f(s_t, a_t). Se entrena con las transiciones reales.
• Error de predicción: típicamente error cuadrático medio entre el estado predicho y el real.
• Bonificación de curiosidad: r_i = β · || ŝ_t+1 − s_t+1 ||² (o similar), donde β escala la importancia.
• Recompensa total: r_total = r_externa + r_curiosidad.

Este enfoque permite al agente buscar activamente regiones donde su modelo falla, impulsando el descubrimiento. En Montezuma’s Revenge, el agente puede explorar habitaciones nuevas porque la recompensa de curiosidad lo atrae hacia estados impredecibles (como puertas o escaleras).

3. Implementación en DQN (Deep Q-Network)

La integración es directa: se entrena una DQN estándar con la suma de recompensa externa y bonificación de curiosidad. El modelo de dinámica (forward model) se entrena en paralelo con las transiciones del replay buffer. A continuación, se muestra la estructura básica:

# Pseudocódigo conceptual (PyTorch-like)
for episodio in range(episodios):
    estado = entorno.reset()
    while not terminado:
        accion = dqn.seleccionar_accion(estado)
        estado_siguiente, recompensa_externa, terminado, _ = entorno.paso(accion)
        # calcular curiosidad
        prediccion = forward_model(estado, accion)
        error = MSE(prediccion, estado_siguiente)
        recompensa_curiosidad = beta * error
        recompensa_total = recompensa_externa + recompensa_curiosidad
        # almacenar transición (estado, accion, recompensa_total, siguiente_estado)
        replay_buffer.guardar(estado, accion, recompensa_total, estado_siguiente)
        # entrenar DQN y forward model (cada cierto paso)
        dqn.entrenar(replay_buffer)
        forward_model.entrenar(estado, accion, estado_siguiente)
        estado = estado_siguiente

La curiosidad actúa como recompensa interna, añadida a la externa. Esto reformula la función de valor, incentivando trayectorias que reducen la incertidumbre del modelo.

4. Métodos count-based: conteo de estados visitados

Otra familia clásica se basa en contar cuántas veces se ha visitado un estado. La recompensa interna es inversamente proporcional a la raíz cuadrada del conteo: estados poco visitados dan mayor bonificación. El reto: los espacios de estado son continuos o enormes (píxeles). Para ello se usan técnicas de hashing para discretizar estados.

• SimHash: proyección aleatoria de características del estado a un código binario. Estados similares tienen códigos cercanos (distancia de Hamming pequeña). Se agrupan en buckets.
• Conteo N(s): cada bucket (pseudo-estado) tiene un contador de visitas.
• Fórmula de bonificación: R_bonus = β / sqrt( N(s) + 1 ), donde β controla la magnitud.
• Ventaja: simple, computacionalmente eficiente, no requiere modelo de dinámica.

Combinado con DQN, la recompensa total se modifica de igual forma. La tabla de conteo se actualiza en cada paso. En Atari, este método ha mostrado mejoras significativas en juegos como Montezuma’s Revenge (aunque a veces con menor rendimiento que la curiosidad basada en modelo).

5. Comparativa: curiosidad vs. count-based

6. Aplicación en Montezuma’s Revenge (resultados)

En el entorno Montezuma’s Revenge, la DQN con ε-greedy apenas alcanza ~0-100 puntos. Con curiosidad o count-based, los agentes superan consistentemente los 1000 puntos, incluso llegando a 4000-5000 en variantes con exploración avanzada. La bonificación interna permite descubrir habitaciones, llaves y enemigos que de otra forma serían ignorados. La combinación de ambos métodos (ej. RND o ICM) aún mejora la robustez.

7. Implementación combinada: DQN + bonificación de exploración

Para usar en la práctica, se modifica la recompensa dentro del bucle de interacción. A continuación se presenta un esquema de código en Python (simplificado) que integra count-based con hashing y curiosidad:

# count-based: usar SimHash o tabla hash
class CountBasedExplorer:
    def __init__(self, hash_size=8, beta=0.1):
        self.hash_size = hash_size
        self.beta = beta
        self.counts = dict()  # bucket_id -> contador

    def hash_state(self, state):
        # SimHash sobre características (ej. píxeles reducidos)
        # Se usa proyección aleatoria (predefinida)
        return tuple( (state * self.proj).sum(axis=-1) > 0 )

    def bonus(self, state):
        bucket = self.hash_state(state)
        n = self.counts.get(bucket, 0)
        self.counts[bucket] = n + 1
        return self.beta / (n + 1) ** 0.5

# DQN modificado
dqn = DQN()
explorer = CountBasedExplorer(beta=0.05)

for episodio in range(total_episodios):
    estado = env.reset()
    while not done:
        accion = dqn.act(estado)  # ε-greedy sobre Q
        nuevo_estado, recompensa_ext, done, info = env.step(accion)
        bonus = explorer.bonus(estado)  # recompensa interna
        recompensa_total = recompensa_ext + bonus
        dqn.almacenar(estado, accion, recompensa_total, nuevo_estado)
        dqn.entrenar()
        estado = nuevo_estado

Para curiosidad, se entrena un modelo de dinámica y se calcula el error de predicción en cada paso. Ambos métodos pueden combinarse (suma ponderada).

8. Consideraciones finales

• Curiosidad es más robusta en entornos complejos porque modela la dinámica, pero requiere entrenar una red auxiliar.
• Count-based es más simple y rápido, aunque puede saturarse si el hash no discrimina bien.
• En la práctica, se usan variantes híbridas (ej. RND, ICM) que combinan ambas ideas.
• Para Montezuma’s Revenge, incluso una DQN con count-based moderado duplica el rendimiento de la línea base.

La exploración eficiente es un pilar del aprendizaje por refuerzo moderno. Entender estos mecanismos permite diseñar agentes capaces de resolver tareas con recompensas extremadamente escasas, como en robótica o juegos desafiantes.

Profundización recomendada: artículos de Pathak et al. (2017) “Curiosity-driven Exploration by Self-Supervised Prediction” y Bellemare et al. (2016) “Unifying Count-Based Exploration and Intrinsic Motivation”.