🧠 ¿Qué es Q-Learning?

Q-Learning es un algoritmo de aprendizaje por refuerzo, donde un “agente” aprende probando acciones en un entorno, recibiendo recompensas o castigos según lo que hace.

Es como entrenar a un perrito: si hace algo bien, le das un premio 🦴; si no, le ignoras o corriges. Con el tiempo, aprende qué hacer para obtener más premios.

🎯 ¿Para qué sirve?

• Entrenar agentes autónomos que toman decisiones.
• Robots que aprenden a moverse.
• Juegos (ajedrez, Mario Bros, etc.).
• Control automático, navegación, trading, entre otros.

🤖 ¿Cómo funciona Q-Learning?

Imagina que tienes:

• Estados (S): dónde está el agente (ej: una celda de un laberinto).
• Acciones (A): lo que puede hacer (ej: moverse arriba, abajo…).
• Recompensas (R): el puntaje que gana o pierde.
• Una tabla Q (Q(s, a)) que guarda lo «bueno» que es tomar cierta acción en cierto estado.

El agente:

1. Empieza en algún estado.
2. Elige una acción (explora o explota lo que sabe).
3. Observa el nuevo estado y la recompensa.
4. Actualiza su Q-table con esta fórmula:

Q(s,a)=Q(s,a)+α[r+γ⋅max⁡Q(s′,a′)−Q(s,a)]Q(s, a) = Q(s, a) + \alpha [r + \gamma \cdot \max Q(s’, a’) – Q(s, a)]Q(s,a)=Q(s,a)+α[r+γ⋅maxQ(s′,a′)−Q(s,a)]

Donde:

• α = tasa de aprendizaje
• γ = descuento del futuro
• r = recompensa
• s' = nuevo estado
• a' = mejor acción futura

Con el tiempo, la tabla se llena de valores que le indican cuál es la mejor acción a tomar en cada estado.

🧪 Ventajas

✅ Aprende solo a través de prueba y error
✅ No necesita saber cómo funciona el entorno
✅ Se adapta a cambios en el entorno
✅ Muy potente cuando se combina con redes neuronales (Deep Q-Learning)

🚨 Desventajas

❌ Requiere muchas interacciones para aprender bien
❌ Difícil en entornos muy grandes o continuos
❌ Puede quedarse atrapado si explora poco

🧑‍💻 Ejemplo simple: agente en un laberinto

pythonCopyEditimport numpy as np

# Crear entorno: matriz 4x4 (16 estados)
states = 16
actions = 4  # 0: arriba, 1: derecha, 2: abajo, 3: izquierda

# Inicializar tabla Q
Q = np.zeros((states, actions))

# Parámetros
alpha = 0.1    # tasa de aprendizaje
gamma = 0.9    # descuento
epsilon = 0.1  # exploración

# Funciones dummy para ejemplo
def obtener_estado_siguiente(estado, accion):
    # lógica simple de transición (se puede personalizar)
    return (estado + 1) % 16

def recompensa(estado):
    return 1 if estado == 15 else 0

# Entrenamiento
for episodio in range(1000):
    estado = np.random.randint(0, 16)

    for _ in range(50):
        # Elegir acción: explorar o explotar
        if np.random.rand() < epsilon:
            accion = np.random.randint(0, actions)
        else:
            accion = np.argmax(Q[estado])

        nuevo_estado = obtener_estado_siguiente(estado, accion)
        r = recompensa(nuevo_estado)

        # Actualizar Q
        Q[estado, accion] += alpha * (r + gamma * np.max(Q[nuevo_estado]) - Q[estado, accion])

        estado = nuevo_estado

🔍 Este es un ejemplo simplificado sin entorno visual, pero ya muestra cómo el agente actualiza su Q-table y aprende.

🧩 En resumen