Métodos Basados en Política: Policy Gradient y Juegos Complejos

Bienvenido a una de las fronteras más poderosas del Aprendizaje por Refuerzo. En esta lección abordaremos los métodos basados en política, donde el agente aprende directamente una política parametrizada. Este enfoque es particularmente eficaz en espacios de acción continuos o de alta dimensión, como el control de un brazo robótico o la toma de decisiones en juegos complejos.

Fundamentos: Parametrización de la política

En lugar de aprender una función de valor y derivar la política (como en Q-learning), los métodos de policy gradient parametrizan directamente la política π(a|s;θ). Esto es ideal para:

• Acciones continuas: por ejemplo, controlar la velocidad de un motor o el ángulo de un brazo robótico.
• Políticas estocásticas: necesarias en entornos donde la exploración es clave.
• Convergencia más estable en algunos problemas, aunque con varianza alta.

Algoritmo REINFORCE: paso a paso

1. Recolectar una trayectoria completa τ = (s₀, a₀, r₁, s₁, ..., s_T) siguiendo la política actual.
2. Calcular los retornos acumulados G_t = Σ_k=0 γ^k r_t+k+1.
3. Actualizar los parámetros en la dirección que aumenta la probabilidad de acciones que llevaron a altos retornos:

• θ ← θ + α · ∇log π(a_t|s_t;θ) · G_t

Este método es libre de modelo (model-free) y de Monte Carlo, por lo que sufre de alta varianza en las estimaciones del gradiente.

Derivación intuitiva del gradiente de política

Imaginemos que estamos en un juego complejo (como un brazo robótico con 7 articulaciones). Queremos ajustar la política para aumentar la probabilidad de acciones exitosas. Matemáticamente:

• ∇log π(a|s;θ) · R: indica cómo cambiar la probabilidad de una acción para aumentar la recompensa.
• Promediamos sobre todas las trayectorias (esperanza) para obtener una dirección de mejora.

Implementación en Python con PyTorch

A continuación se muestra una implementación minimalista de REINFORCE para un entorno de control continuo (simulación de brazo robótico simple). La política es una red neuronal con salida gaussiana (media y desviación).

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

class PolicyNetwork(nn.Module):
    def __init__(self, state_dim, action_dim, hidden=128):
        super().__init__()
        self.fc = nn.Sequential(
            nn.Linear(state_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
        )
        self.mean_head = nn.Linear(hidden, action_dim)
        self.log_std = nn.Parameter(torch.zeros(action_dim))

    def forward(self, state):
        x = self.fc(state)
        mean = self.mean_head(x)
        std = torch.exp(self.log_std)
        return mean, std

    def sample_action(self, state):
        mean, std = self.forward(state)
        dist = torch.distributions.Normal(mean, std)
        action = dist.sample()
        log_prob = dist.log_prob(action).sum(dim=-1)
        return action, log_prob

def reinforce(env, policy, optimizer, episodes=1000, gamma=0.99):
    for ep in range(episodes):
        states, actions, rewards, log_probs = [], [], [], []
        state, _ = env.reset()
        done = False
        while not done:
            state_t = torch.FloatTensor(state).unsqueeze(0)
            action, log_prob = policy.sample_action(state_t)
            next_state, reward, done, _, _ = env.step(action.detach().numpy()[0])
            states.append(state)
            actions.append(action)
            rewards.append(reward)
            log_probs.append(log_prob)
            state = next_state

        # Calcular retornos G_t
        G = 0
        returns = []
        for r in reversed(rewards):
            G = r + gamma * G
            returns.insert(0, G)
        returns = torch.tensor(returns, dtype=torch.float32)

        # Actualizar gradiente
        loss = []
        for log_prob, Gt in zip(log_probs, returns):
            loss.append(-log_prob * Gt)  # gradiente ascendente
        loss = torch.stack(loss).mean()

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    return policy

Juegos complejos y espacio de acciones continuas

En el control de un brazo robótico, las acciones pueden ser torques continuos en cada articulación. REINFORCE permite explorar estas acciones sin discretizar el espacio. Sin embargo, la varianza puede ser prohibitiva si no se introduce una línea base (baseline).

Desafíos y línea base (baseline)

• Alta varianza: la actualización depende de la suma total de recompensas, que puede variar drásticamente entre episodios.
• Muestreo ineficiente: REINFORCE usa solo una trayectoria por actualización (Monte Carlo).
• Una línea base común es la función de valor del estado V(s). Se aprende simultáneamente y se resta de G_t.
• Esto da lugar al método REINFORCE with baseline, antecesor de algoritmos como A2C (Advantage Actor-Critic).

Conclusión y próximos pasos

Los métodos basados en política ofrecen un camino natural para abordar problemas con acciones continuas y políticas estocásticas. REINFORCE es el punto de partida, pero su alta varianza motiva el uso de líneas base y el desarrollo de métodos actor-crítico, que exploraremos más adelante.

📌 Para dominar este tema, implementa REINFORCE en un entorno como Pendulum-v1 o LunarLanderContinuous y observa cómo la línea base transforma la estabilidad del aprendizaje.