MDP, Q-learning, PPO y entornos Gymnasium.

Del backtest a la decisión secuencial

Todo lo que el nivel 5 ha hecho hasta aquí es aprendizaje supervisado: una tabla de features, una etiqueta y un modelo que predice la etiqueta. La decisión de operar venía después, como una regla fija encima de la predicción (comprar el decil alto, lección 5.4.4). El aprendizaje por refuerzo (RL, reinforcement learning) junta las dos cosas: un agente observa el estado, elige una acción, el entorno le devuelve una recompensa y un estado nuevo, y el agente aprende la regla de decisión que maximiza la suma de recompensas futuras. No hay etiqueta: solo la consecuencia de cada acción.

flowchart LR
  A[Agente] -->|acción| E[Entorno]
  E -->|recompensa| A
  E -->|estado nuevo| A

Esa forma encaja con problemas de trading donde la acción de hoy cambia el problema de mañana: una posición abierta que cuesta cerrar, un inventario que hay que liquidar (lección 4.3.1), las cotizaciones de un creador de mercado que acumulan inventario (lección 2.3.6). El precio de la flexibilidad es alto: el agente aprende por prueba y error, con recompensas ruidosas, y nada garantiza que lo aprendido sea lo óptimo. Por eso esta lección empieza por un problema cuya respuesta exacta se puede calcular, y solo después deja que los algoritmos la busquen.

Un problema de trading como MDP

Un proceso de decisión de Markov (MDP) es una tupla $(\mathcal{S}, \mathcal{A}, P, R, \gamma)$: estados, acciones, probabilidades de transición $P(s' \mid s, a)$, recompensa esperada $R(s, a)$ y factor de descuento $\gamma \in [0, 1)$. «De Markov» significa que el estado actual resume todo lo que importa del pasado para lo que viene.

El problema de la lección:

• Régimen del mercado: bajista, neutro o alcista. Sigue una cadena de Markov: cada régimen extremo dura de media cinco pasos (probabilidad de seguir 0,8) y del neutro se sale a cualquiera de los dos lados con la misma probabilidad.
• Rendimiento del paso siguiente: normal con media $\mu_s = -5, 0, +5$ pb según el régimen actual y desviación $\sigma = 20$ pb.
• Acción: la posición nueva, corto (−1), fuera (0) o largo (+1).
• Recompensa: el P&L neto, $r_{t+1} = a_t \cdot \text{ret}_{t+1} - c \cdot |a_t - p_t|$, con un coste $c = 6$ pb por unidad negociada. Pasar de corto a largo cuesta 12 pb.
• Estado: el par (régimen, posición actual). La posición tiene que estar en el estado: con costes, la mejor acción depende de dónde se está. Son 3 × 3 = 9 estados.

stateDiagram-v2
  Bajista --> Neutro: 0,2
  Neutro --> Bajista: 0,1
  Neutro --> Alcista: 0,1
  Alcista --> Neutro: 0,2

El régimen es observable, como si el agente tuviera un indicador perfecto del estado del mercado. Es una simplificación fuerte (en la realidad se estima con ruido, lección 2.2.7), pero aísla lo que interesa aquí: cómo interactúan una señal persistente y los costes.

import numpy as np
import pandas as pd

P = np.array([[0.8, 0.2, 0.0],    # desde bajista
              [0.1, 0.8, 0.1],    # desde neutro
              [0.0, 0.2, 0.8]])   # desde alcista
MU = np.array([-5.0, 0.0, 5.0])   # rendimiento esperado, pb/paso
SIGMA, COSTE, GAMMA = 20.0, 6.0, 0.95
POS = np.array([-1.0, 0.0, 1.0])  # corto, fuera, largo
REG = ["bajista", "neutro", "alcista"]

def recompensas(pos):
    """R[s, p, a]: recompensa esperada en el régimen s con la
    posición p al pasar a la posición a."""
    nueva, actual = pos[None, None, :], pos[None, :, None]
    return (MU[:, None, None] * nueva
            - COSTE * np.abs(nueva - actual))

R = recompensas(POS)
w, v = np.linalg.eig(P.T)
estac = np.real(v[:, np.argmin(np.abs(w - 1))])
estac /= estac.sum()
print("distribución estacionaria:", np.round(estac, 3))
print("duración media de un régimen extremo:",
      round(1 / (1 - P[2, 2]), 1), "pasos")

distribución estacionaria: [0.25 0.5  0.25]
duración media de un régimen extremo: 5.0 pasos

A largo plazo, el mercado pasa la mitad del tiempo en neutro y una cuarta parte en cada extremo. Un régimen alcista dura de media cinco pasos: si el agente entra en largo al empezar, espera ganar unos 25 pb antes de que cambie, con un coste de entrada de 6. La pregunta es si un algoritmo lo descubre, y para saberlo hace falta la respuesta.

La política óptima: iteración de valor

El valor de una política $\pi$ en un estado es la suma descontada de recompensas que se espera al seguirla desde ahí. La función de valor de acción óptima $Q^*(s, a)$ (lo que se espera ganar si se hace $a$ en $s$ y después se actúa de forma óptima) cumple la ecuación de Bellman:

La política óptima es elegir en cada estado la acción con mayor $Q^*$. Cuando se conocen $P$ y $R$, como aquí, la ecuación se resuelve aplicándola una y otra vez a partir de cualquier tabla inicial: es la iteración de valor, que converge porque cada pasada encoge el error por un factor $\gamma$. En este MDP, el estado siguiente es (régimen nuevo, posición elegida), así que $\max_{a'} Q^*(s', a')$ es el valor $V^*$ del régimen siguiente con la posición $a$.

def iteracion_valor(R, pos=POS, tol=1e-10):
    V = np.zeros((3, len(pos)))
    for it in range(1, 100_000):
        cont = np.einsum("st,ta->sa", P, V)  # E[V(s', a) | s]
        Q = R + GAMMA * cont[:, None, :]
        V_nuevo = Q.max(axis=2)
        if np.abs(V_nuevo - V).max() < tol:
            return Q, it
        V = V_nuevo

Q_opt, iters = iteracion_valor(R)
pi_opt = Q_opt.argmax(axis=2)  # índice de la posición nueva
print(f"converge en {iters} iteraciones")
pd.DataFrame(POS[pi_opt], index=REG,
             columns=["desde corto", "desde fuera", "desde largo"])

converge en 463 iteraciones
         desde corto  desde fuera  desde largo
bajista         -1.0         -1.0         -1.0
neutro          -1.0          0.0          1.0
alcista          1.0          1.0          1.0

La política óptima es sencilla de leer y no es la obvia. En régimen bajista, corto desde cualquier sitio; en alcista, largo desde cualquier sitio; en neutro, mantener lo que se tenga. La media en neutro es cero, así que cerrar solo cuesta, y desde el neutro se vuelve al régimen anterior o se pasa al contrario con la misma probabilidad. Es la histéresis que imponen los costes: una zona en la que no se negocia (la lección 2.4.7 la midió en estrategias reales; la 4.3.1, en ejecución).

Para comparar políticas no hace falta simular. Una política tabular convierte el MDP en una cadena de Markov sobre los 9 estados; su distribución estacionaria dice cuánto tiempo se pasa en cada estado, y la recompensa media a largo plazo es la media de las recompensas esperadas ponderada por ese tiempo. Es una cifra exacta, sin ruido de muestreo.

def recompensa_media(pi, pos=POS):
    """pb/paso a largo plazo de una política tabular pi[s, p]."""
    n = len(pos)
    T = np.zeros((3 * n, 3 * n))
    r = np.zeros(3 * n)
    for s in range(3):
        for p in range(n):
            a = pi[s, p]
            r[s * n + p] = (MU[s] * pos[a]
                            - COSTE * abs(pos[a] - pos[p]))
            T[s * n + p, np.arange(3) * n + a] = P[s]
    w, v = np.linalg.eig(T.T)
    d = np.real(v[:, np.argmin(np.abs(w - 1))])
    return float(d @ r / d.sum())

sin_costes = np.tile([[0], [1], [2]], (1, 3))  # signo de la media
miope = R.argmax(axis=2)                        # solo el paso actual
ref = {"óptima (iteración de valor)": recompensa_media(pi_opt),
       "señal sin pensar en costes": recompensa_media(sin_costes),
       "miope (un paso)": recompensa_media(miope)}
for k, val in ref.items():
    print(f"{k:<30}{abs(val):5.2f} pb/paso")

óptima (iteración de valor)    1.90 pb/paso
señal sin pensar en costes     1.30 pb/paso
miope (un paso)                0.00 pb/paso

La regla que ignora los costes pierde un tercio del óptimo por cerrar en cada neutro. La miope no opera nunca: entrar en largo en un régimen alcista da 5 − 6 = −1 pb en el primer paso, y solo cuenta ese paso. Es el error de evaluar una decisión por su primer periodo, muy común al diseñar reglas con costes. El abs() del print solo evita el «−0.00» del redondeo de la miope.

¿Y si la posición pudiera ser cualquier valor entre −1 y 1? SAC, más abajo, trabaja con acciones continuas. Repetir la iteración de valor con 21 posiciones posibles responde si el óptimo cambia:

pos_fina = np.round(np.linspace(-1, 1, 21), 2)
Q_fina, _ = iteracion_valor(recompensas(pos_fina), pos_fina)
pi_fina = Q_fina.argmax(axis=2)
print("rejilla de 21 posiciones:",
      round(recompensa_media(pi_fina, pos_fina), 2), "pb/paso")
print("en neutro, desde 0.3 va a", pos_fina[pi_fina[1, 13]])

rejilla de 21 posiciones: 1.9 pb/paso
en neutro, desde 0.3 va a 0.3

Mismo valor, 1,90 pb por paso. Con la recompensa lineal en la posición, los extremos dominan: en bajista y alcista, posición completa; en neutro, mantener cualquier posición que se tenga. Las posiciones intermedias no añaden nada. Así, el óptimo de la versión continua es el mismo, y cualquier diferencia de SAC será del agente, no del problema.

Q-learning: aprender sin conocer el modelo

La iteración de valor necesita $P$ y $R$. En un mercado no se conocen: solo se observan transiciones. Q-learning (Watkins, 1989) aprende $Q^*$ a partir de cada transición observada $(s, a, r, s')$ con una actualización que imita a Bellman con una muestra en vez de la esperanza:

El término entre corchetes es el error de diferencia temporal: lo que la tabla esperaba frente a lo que ha visto más lo que espera del estado siguiente. Converge a $Q^*$ si cada par (estado, acción) se visita infinitas veces y el paso $\alpha$ decrece lo bastante despacio. Para que se visiten todos, el agente explora: con probabilidad $\varepsilon = 0{,}1$ elige una acción al azar y, si no, la mejor según su tabla (política $\varepsilon$-voraz). El paso es $\alpha = n^{-0{,}7}$, con $n$ las visitas a ese par.

rng = np.random.default_rng(0)
PASOS = 300_000
explora = rng.random(PASOS) < 0.1
azar = rng.integers(0, 3, PASOS)
ruido = rng.standard_normal(PASOS)
u = rng.random(PASOS)
acum = P.cumsum(axis=1)

Q = np.zeros((3, 3, 3))
visitas = np.zeros((3, 3, 3))
s, p = 1, 1
idx = np.indices((3, 3))
curva = []
for k in range(PASOS):
    a = azar[k] if explora[k] else int(Q[s, p].argmax())
    r = (POS[a] * (MU[s] + SIGMA * ruido[k])
         - COSTE * abs(POS[a] - POS[p]))
    s2 = int(np.searchsorted(acum[s], u[k], side="right"))
    visitas[s, p, a] += 1
    alfa = visitas[s, p, a] ** -0.7
    Q[s, p, a] += alfa * (r + GAMMA * Q[s2, a].max() - Q[s, p, a])
    s, p = s2, a
    if (k + 1) % 10_000 == 0:
        pi = Q.argmax(axis=2)
        err = np.abs(Q - Q_opt)
        curva.append({
            "pasos": k + 1, "aciertos": int((pi == pi_opt).sum()),
            "pb/paso": round(recompensa_media(pi), 2) + 0.0,
            "error Q máx.": round(err.max(), 1),
            "error Q óptima": round(err[idx[0], idx[1],
                                        pi_opt].max(), 1)})
curva = pd.DataFrame(curva).set_index("pasos")
pi_q = Q.argmax(axis=2)
curva.iloc[[0, 1, 3, 5, 9, 14, 19, 29]]

        aciertos  pb/paso  error Q máx.  error Q óptima
pasos
10000          1     0.00          59.0            59.0
20000          2     0.00          55.5            55.5
40000          3     0.65          54.5            54.5
60000          4     0.65          48.2            48.2
100000         6     0.95          43.1            43.1
150000         9     1.90          29.3            17.2
200000         9     1.90          28.2            14.4
300000         9     1.90          27.3             9.7

La tabla y la figura cuentan dos convergencias distintas. La política acierta en los 9 estados a los 140.000 pasos (la figura tiene los 30 puntos; la tabla, ocho) y desde ahí gana el óptimo exacto, 1,90 pb por paso. Los valores van mucho más despacio: el error máximo de la tabla sigue en 27,3 pb al final, y el de las acciones óptimas baja hasta 9,7 pb, pero tampoco llega a cero. Las acciones que la política voraz no elige solo se prueban en el 10 % de exploración, y su valor se estima con pocas muestras de una recompensa con desviación de 20 pb. Para decidir basta con que, en cada estado, la acción buena tenga el valor más alto.

Hacen falta cientos de miles de pasos para un problema de 9 estados con una señal enorme. Un paso aquí es una sesión, un minuto o una operación según el problema; 140.000 sesiones son más de 550 años. Esa es la primera razón por la que el RL en trading se entrena casi siempre en simuladores, y la razón por la que el simulador tiene que ser bueno (lección 5.9.2).

Un entorno Gymnasium con costes en la recompensa

Para usar algoritmos ya escritos, el problema se empaqueta con la interfaz estándar de Gymnasium (1.4, la continuación de OpenAI Gym que mantiene la Farama Foundation): una clase con un espacio de observaciones, un espacio de acciones, reset() para empezar un episodio y step(acción) para avanzar un paso, que devuelve la observación, la recompensa, si el episodio ha terminado (terminated, un final del problema) o se ha cortado (truncated, un límite de tiempo) y un diccionario de información.

Decisiones de diseño, que en RL pesan tanto como el algoritmo:

• Observación: el régimen en one-hot (tres columnas) y la posición actual. Una red neuronal aprende mejor con el régimen como tres entradas de 0 y 1 que como un número 0, 1, 2 que sugiere un orden.
• Costes dentro de la recompensa: el agente optimiza lo que se le recompensa. Si el coste no está en la recompensa, no existe para él (la lección 5.9.3 lo mide).
• Escala: la recompensa es el P&L dividido por σ = 20 pb. Las redes y los optimizadores de Stable-Baselines3 tienen hiperparámetros por defecto pensados para recompensas de orden 1; con el P&L en pb, los gradientes del crítico son cientos de veces mayores.
• Episodios de 250 pasos, cortados con truncated y no con terminated: el mercado no termina, solo deja de observarse. Con terminated, el algoritmo creería que después del paso 250 no hay valor futuro.
• Azar del entorno con self.np_random, que reset(seed=…) siembra: así cada episodio es reproducible.

import gymnasium as gym
from gymnasium import spaces
from gymnasium.utils.env_checker import check_env

class RegimenEnv(gym.Env):
    """MDP de regímenes: observa el régimen (one-hot) y la posición;
    la acción es la posición nueva; la recompensa, el P&L neto."""

    def __init__(self, continua=False, pasos=250):
        self.continua, self.pasos = continua, pasos
        self.observation_space = spaces.Box(-1.0, 1.0, (4,),
                                            np.float32)
        if continua:
            self.action_space = spaces.Box(-1.0, 1.0, (1,),
                                           np.float32)
        else:
            self.action_space = spaces.Discrete(3)

    def _obs(self):
        o = np.zeros(4, np.float32)
        o[self.s], o[3] = 1.0, self.pos
        return o

    def reset(self, seed=None, options=None):
        super().reset(seed=seed)
        u = self.np_random.random()
        self.s = int(np.searchsorted(estac.cumsum(), u,
                                     side="right"))
        self.pos, self.t = 0.0, 0
        return self._obs(), {}

    def step(self, action):
        if self.continua:
            nueva = float(np.clip(action[0], -1.0, 1.0))
        else:
            nueva = float(POS[int(action)])
        ret = MU[self.s] + SIGMA * self.np_random.standard_normal()
        pnl = nueva * ret - COSTE * abs(nueva - self.pos)
        u = self.np_random.random()
        self.s = int(np.searchsorted(acum[self.s], u, side="right"))
        self.pos, self.t = nueva, self.t + 1
        truncado = self.t >= self.pasos
        return self._obs(), pnl / SIGMA, False, truncado, {"pnl": pnl}

check_env(RegimenEnv(), skip_render_check=True)
check_env(RegimenEnv(continua=True), skip_render_check=True)
print("check_env: sin errores en las dos versiones")
env = RegimenEnv()
obs, _ = env.reset(seed=1)
print(obs, env.observation_space, env.action_space)

check_env: sin errores en las dos versiones
[0. 1. 0. 0.] Box(-1.0, 1.0, (4,), float32) Discrete(3)

check_env comprueba la interfaz: que reset y step devuelvan lo que deben, que las observaciones estén dentro de su espacio y con su tipo (float32), que la semilla haga los episodios reproducibles. skip_render_check=True se salta la prueba de los modos de dibujo, que este entorno no tiene (sin ella, avisa de que el entorno no se creó con gymnasium.make). Lo que check_env no comprueba es la economía: un coste con el signo cambiado, un rendimiento del paso equivocado (el de hoy en vez del de mañana, una fuga como las de 5.4.1) o una posición que no se guarda pasan la prueba igual. Esas se cazan comparando con una solución conocida, como aquí, o con controles sin señal.

Policy gradient y PPO

Q-learning aprende valores y deriva de ellos la política. Los métodos de gradiente de la política (policy gradient) parametrizan la política directamente, $\pi_\theta(a \mid s)$ (una red que da probabilidades de cada acción), y suben por el gradiente de la recompensa esperada:

donde $\hat{A}_t$ es la ventaja: cuánto mejor fue la acción $a_t$ de lo que el crítico (una segunda red que estima el valor del estado) esperaba. Las acciones que salieron mejor de lo esperado se vuelven más probables. El problema es que un paso de gradiente grande puede estropear la política de golpe, y con recompensas ruidosas pasa a menudo.

PPO (Proximal Policy Optimization, Schulman et al., 2017) limita cuánto puede cambiar la política en cada actualización. Con $\rho_t = \pi_\theta(a_t \mid s_t) / \pi_{\theta_{\text{old}}}(a_t \mid s_t)$, el cociente entre la política nueva y la que recogió los datos, maximiza

con $\epsilon = 0{,}2$: más allá de un 20 % de cambio en la probabilidad de una acción, el objetivo deja de premiar el cambio. Es el algoritmo por defecto de muchos trabajos de RL por su estabilidad. Funciona con acciones discretas y continuas; aquí, con las tres posiciones.

La configuración: 8 copias del entorno en paralelo (make_vec_env, cada una con su semilla), 256 pasos por copia antes de cada actualización, red de dos capas de 32 neuronas, el mismo descuento que el MDP y seed=0 con device="cpu" y algoritmos deterministas de PyTorch. 60.000 pasos en tres bloques, y tras cada bloque se lee la acción determinista del agente en los 9 estados y se evalúa con la fórmula exacta.

import torch
from stable_baselines3 import PPO, SAC
from stable_baselines3.common.env_util import make_vec_env

torch.manual_seed(0)
torch.use_deterministic_algorithms(True)

OBS9 = np.zeros((9, 4), np.float32)  # los 9 estados
for s in range(3):
    for p in range(3):
        OBS9[3 * s + p, s], OBS9[3 * s + p, 3] = 1.0, POS[p]

def tabla_politica(modelo):
    """Acción determinista del agente en los 9 estados."""
    a, _ = modelo.predict(OBS9, deterministic=True)
    return np.asarray(a).reshape(3, 3)

vec = make_vec_env(RegimenEnv, n_envs=8, seed=0)
ppo = PPO("MlpPolicy", vec, gamma=GAMMA, n_steps=256,
          batch_size=256, learning_rate=1e-3,
          policy_kwargs={"net_arch": [32, 32]},
          seed=0, device="cpu", verbose=0)
for bloque in range(3):
    ppo.learn(20_000, reset_num_timesteps=bloque == 0)
    pi_ppo = tabla_politica(ppo)
    print(f"{20_000 * (bloque + 1):>6} pasos: "
          f"{int((pi_ppo == pi_opt).sum())}/9 como el óptimo, "
          f"{recompensa_media(pi_ppo):.2f} pb/paso")
pd.DataFrame(POS[pi_ppo], index=REG,
             columns=["desde corto", "desde fuera", "desde largo"])

 20000 pasos: 9/9 como el óptimo, 1.90 pb/paso
 40000 pasos: 8/9 como el óptimo, 1.90 pb/paso
 60000 pasos: 8/9 como el óptimo, 1.90 pb/paso
         desde corto  desde fuera  desde largo
bajista         -1.0         -1.0         -1.0
neutro          -1.0         -1.0          1.0
alcista          1.0          1.0          1.0

PPO da con la política óptima a los 20.000 pasos y después cambia la acción de un estado: en neutro y sin posición, abre un corto. La recompensa media a largo plazo no se mueve (1,90 pb por paso) porque ese estado no forma parte del ciclo de la política: una vez dentro, nunca se vuelve a estar fuera. Solo se visita al empezar cada episodio, así que el agente tiene muy pocas muestras de él y la red lo decide por cercanía con los estados vecinos. Es un aviso general: un agente es fiable donde ha pasado tiempo y arbitrario donde no, y los estados raros de un mercado (una crisis, un hueco) son justo los que más importan.

SAC: acciones continuas y entropía

Con la posición continua entre −1 y 1, la elección habitual es SAC (Soft Actor-Critic, Haarnoja et al., 2018): un método off-policy (reutiliza transiciones viejas guardadas en un búfer, lo que lo hace más eficiente en muestras que PPO) que maximiza la recompensa más un premio por la entropía de la política:

El término de entropía mantiene la exploración, y $\alpha$ fija cuánto. Stable-Baselines3 lo ajusta solo (ent_coef="auto") para alcanzar una entropía objetivo. En las pruebas previas a esta lección, con el mismo presupuesto de 8.000 pasos, el valor inicial por defecto de $\alpha$ (1,0) dejaba una política tímida, con posiciones de 0,1 a 0,45 en valor absoluto donde el óptimo pide 1: la entropía pesaba más que unas recompensas de unas décimas. Con "auto_0.01" (ajuste automático empezando en 0,01) se acerca mucho más. Y con la recompensa dividida por 100 (en porcentaje) en vez de por σ, SAC no aprendía nada: posiciones casi nulas. Son las dos perillas que más cambian el resultado y ninguna sale del problema financiero: es ingeniería del algoritmo.

vec_c = make_vec_env(lambda: RegimenEnv(continua=True), n_envs=4,
                     seed=0)
sac = SAC("MlpPolicy", vec_c, gamma=GAMMA, learning_starts=1000,
          batch_size=128, ent_coef="auto_0.01",
          policy_kwargs={"net_arch": [32, 32]},
          seed=0, device="cpu", verbose=0)
sac.learn(8_000)
a_sac = sac.predict(OBS9, deterministic=True)[0].reshape(3, 3)
pd.DataFrame(a_sac, index=REG,
             columns=["desde corto", "desde fuera",
                      "desde largo"]).round(2)

         desde corto  desde fuera  desde largo
bajista        -0.92        -0.65        -0.57
neutro         -0.82         0.42         0.95
alcista         0.87         0.96         0.98

SAC ha aprendido la forma de la política óptima: largo en alcista, corto en bajista y, en neutro, una posición que crece con la que ya tenía (la histéresis). Pero no llega a los extremos: en bajista se queda entre −0,57 y −0,92 en vez de −1. Con más pasos se acercaría; con 8.000 (4.000 actualizaciones de las redes, unos segundos de CPU), esto es lo que da. En producción se entrenaría más y con varias semillas, y aun así habría que medir el hueco.

La comparación honesta

La recompensa media exacta solo existe para políticas tabulares. Para comparar a todos, incluido SAC, se simulan los mismos 40 episodios de 250 pasos (semillas 10.000 a 10.039) con cada política: mismos regímenes y mismos rendimientos, de modo que la diferencia con el óptimo no depende del azar de los caminos, solo de las decisiones. El error típico de esa diferencia sale de los 40 episodios.

def evalua(politica, episodios=40, pasos=250):
    """pb/paso medio de cada episodio, mismos caminos para todas."""
    res = []
    for e in range(episodios):
        env = RegimenEnv(continua=True, pasos=pasos)
        o, _ = env.reset(seed=10_000 + e)
        tot = 0.0
        for _ in range(pasos):
            a = np.array([politica(o)], np.float32)
            o, _, _, _, info = env.step(a)
            tot += info["pnl"]
        res.append(tot / pasos)
    return np.array(res)

def de_tabla(pi):
    return lambda o: POS[pi[int(o[:3].argmax()), int(o[3]) + 1]]

def de_sac(o):
    return float(sac.predict(o, deterministic=True)[0][0])

politicas = {"óptima": de_tabla(pi_opt), "Q-learning": de_tabla(pi_q),
             "PPO": de_tabla(pi_ppo), "SAC": de_sac,
             "sin costes": de_tabla(sin_costes),
             "miope": de_tabla(miope)}
res = {k: evalua(f) for k, f in politicas.items()}
filas = []
for k, x in res.items():
    d = x - res["óptima"]
    filas.append({"política": k, "pb/paso": round(x.mean(), 2),
                  "frente al óptimo": round(d.mean(), 2),
                  "error típico": round(d.std(ddof=1) / 40**0.5, 2)})
pd.DataFrame(filas).set_index("política")

            pb/paso  frente al óptimo  error típico
política
óptima         1.99              0.00          0.00
Q-learning     1.99              0.00          0.00
PPO            1.93             -0.06          0.02
SAC            1.55             -0.44          0.13
sin costes     1.28             -0.71          0.15
miope          0.00             -1.99          0.24

La figura de la cabecera resume la tabla. En estos 40 caminos el óptimo gana 1,99 pb por paso (algo más que el 1,90 exacto: es una muestra). Q-learning, con la política óptima en los 9 estados, coincide con él al céntimo. PPO queda 0,06 pb por debajo, con un error típico de 0,02: es su error en el estado inicial, que sí cuenta en episodios cortos. SAC queda a 0,44 pb (error típico 0,13), un 22 % por debajo. La regla sin costes pierde 0,71 y la miope, todo.

Tres lecciones, que valen para todo el módulo. Primera: sin el óptimo no se sabría que SAC deja un 22 % sobre la mesa ni que PPO falla en un estado; en un mercado no hay óptimo, así que hay que construir referencias (analíticas, como en 5.9.2) y controles sin señal (como en 5.9.3). Segunda: los algoritmos son sensibles a decisiones que no tienen nada de financiero (escala de la recompensa, entropía, presupuesto), y un resultado vale lo que su configuración. Tercera: incluso en un problema de 9 estados con una señal veinte veces mejor que la de un mercado, hacen falta decenas de miles de pasos.

Ejercicios

1. Barre el coste por unidad negociada: 6, 12, 18 y 24 pb. Para cada uno, calcula la política óptima, en cuántos de los 9 estados cambia de posición y su recompensa media, junto a la de la regla sin costes. ¿Cuándo deja de compensar operar?

for c in (6.0, 12.0, 18.0, 24.0):
    COSTE = c  # recompensas() y recompensa_media() lo leen
    pic = iteracion_valor(recompensas(POS))[0].argmax(axis=2)
    opera = int((POS[pic] != POS[None, :]).sum())
    print(f"coste {c:4.0f} pb: cambia en {opera}/9 estados, "
          f"óptima {abs(recompensa_media(pic)):5.2f}, "
          f"sin costes {recompensa_media(sin_costes):6.2f} pb/paso")
COSTE = 6.0  # se restaura para el resto de la lección

coste    6 pb: cambia en 4/9 estados, óptima  1.90, sin costes   1.30 pb/paso
coste   12 pb: cambia en 4/9 estados, óptima  1.30, sin costes   0.10 pb/paso
coste   18 pb: cambia en 4/9 estados, óptima  0.70, sin costes  -1.10 pb/paso
coste   24 pb: cambia en 0/9 estados, óptima  0.00, sin costes  -2.30 pb/paso

2. Repite el Q-learning con un paso constante $\alpha = 0{,}05$ en vez de $n^{-0{,}7}$ y compara los aciertos y la recompensa media de su política a los 50.000, 150.000 y 300.000 pasos.

Qc = np.zeros((3, 3, 3))
s, p = 1, 1
for k in range(PASOS):
    a = azar[k] if explora[k] else int(Qc[s, p].argmax())
    r = (POS[a] * (MU[s] + SIGMA * ruido[k])
         - COSTE * abs(POS[a] - POS[p]))
    s2 = int(np.searchsorted(acum[s], u[k], side="right"))
    Qc[s, p, a] += 0.05 * (r + GAMMA * Qc[s2, a].max() - Qc[s, p, a])
    s, p = s2, a
    if (k + 1) in (50_000, 150_000, 300_000):
        pi = Qc.argmax(axis=2)
        print(f"{k + 1:>7}: {int((pi == pi_opt).sum())}/9, "
              f"{recompensa_media(pi):.2f} pb/paso")

  50000: 4/9, 0.95 pb/paso
 150000: 5/9, 0.65 pb/paso
 300000: 8/9, 1.81 pb/paso

3. Un compañero escribe el step de su entorno con la recompensa nueva * ret y descuenta los costes después, al calcular el P&L del backtest. Su agente opera en cada paso. ¿Qué ha pasado y qué habría detectado check_env?