Monte Carlo: remuestreo de trades, bootstrap de bloques y permutaciones de señales.

Una curva de capital es una muestra de tamaño uno

Un backtest devuelve una curva de capital, un Sharpe y un drawdown máximo. Son cifras de una historia: la que ocurrió. Si el mercado hubiera repartido los mismos días buenos y malos en otro orden, o la estrategia hubiera cerrado sus operaciones en otra secuencia, el drawdown sería otro. La lección 2.1.1 presentó el bootstrap para estimar la incertidumbre de un estadístico; aquí se aplica a la pregunta práctica de un sistema de trading: qué parte del resultado es estructura y qué parte es azar del orden.

«Monte Carlo» en este contexto agrupa tres familias de remuestreo. Cada una parte de un objeto distinto del backtest y responde a una pregunta distinta:

flowchart TB
  B[Backtest] --> O[Operaciones]
  B --> R[Rendimientos]
  B --> S[Señal y mercado]
  O --> T[Remuestreo trades]
  R --> K[Bootstrap bloques]
  S --> P[Permutación]
  T --> T2[Drawdown y ruina]
  K --> K2[IC y abanico]
  P --> P2[p-valor timing]

Ninguno de los tres sabe cuántas estrategias se probaron antes de quedarse con esta. Esa pregunta, la del sesgo de selección, es la de la lección 2.5.4 y vuelve al final de esta.

La estrategia y su control

La estrategia es un momentum de series temporales clásico sobre los 24 futuros sintéticos del nivel 2: en cada mercado, largo si la rentabilidad de las últimas 252 sesiones es positiva y corto si es negativa, con una posición escalada por la inversa de la volatilidad (EWMA de 60 sesiones) para que cada mercado aporte un riesgo parecido. La señal se calcula al cierre de cada sesión y se opera en la siguiente. La lección 2.3.1 la construye paso a paso; la referencia empírica en mercados reales es Moskowitz, Ooi y Pedersen (2012)11Nota 1 · Moskowitz, Ooi y Pedersen (2012), «Time series momentum», Journal of Financial Economics 104(2), 228-250, doi:10.1016/j.jfineco.2011.11.003..

import numpy as np
import pandas as pd

def sharpe(x):
    return np.mean(x) / np.std(x, ddof=1) * np.sqrt(252)

def tendencia(px, L=252, riesgo=0.30):
    """Signo de la rentabilidad de L sesiones, escalado por vol."""
    r = px.pct_change()
    vol = r.ewm(span=60, min_periods=60).std() * np.sqrt(252)
    signo = np.sign(px.pct_change(L))       # se conoce al cierre de t
    escala = riesgo / vol / px.shape[1]     # riesgo por mercado
    pnl = (signo * escala).shift(1) * r     # se opera en t + 1
    return signo, escala, r, pnl.loc["2001-01-02":]

fut = pd.read_parquet("futuros2_continuos.parquet")
px = fut.pivot(index="fecha", columns="mercado",
               values="cierre_ajustado")
signo, escala, r, pnl = tendencia(px)
cartera = pnl.sum(axis=1)
print(f"Sesiones: {len(cartera)}")
print(f"Volatilidad anual: {cartera.std() * np.sqrt(252):.1%}")
print(f"Sharpe: {sharpe(cartera):.2f}")

Sesiones: 6287
Volatilidad anual: 9.0%
Sharpe: 1.00

Veinticinco años, una volatilidad del 9,0 % y un Sharpe de 1,00, sin costes (la lección 2.4.7 los añade; aquí no cambian el método). El 1,00 es mayor que el 0,15 por mercado del README por dos razones: la diversificación entre 24 mercados poco correlados y lo que la regla captura de paso, sobre todo el carry (el README mide una correlación de 0,50 entre el carry y el signo de 252 sesiones) y la prima de los índices. El README da 0,98 para la misma regla con otra ponderación (10 % entre la volatilidad de 63 sesiones): la cifra no depende de ese detalle.

Para cada método hace falta un control: algo con la misma forma que la estrategia y sin efecto. El más directo es un gemelo de los propios futuros: los mismos rendimientos diarios, las mismas filas (cada sesión conserva los 24 mercados juntos, y con ellos sus correlaciones), pero en un orden de sesiones barajado. Así se conservan la distribución de cada día y la estructura entre mercados y se destruye cualquier memoria temporal: en el gemelo, una regla de tendencia no puede tener ventaja.

rng = np.random.default_rng(2028)
orden = rng.permutation(len(r) - 1)
r_g = pd.DataFrame(r.to_numpy()[1:][orden], index=r.index[1:],
                   columns=r.columns)
px_g = (1 + r_g).cumprod()                  # mismos días, otro orden
signo_g, escala_g, r_g, pnl_g = tendencia(px_g)
gemelo = pnl_g.sum(axis=1)
iu = np.triu_indices(24, 1)
print(f"Correlación media entre mercados: real "
      f"{r.corr().to_numpy()[iu].mean():.3f}, "
      f"gemelo {r_g.corr().to_numpy()[iu].mean():.3f}")
print(f"Sharpe de la tendencia en el gemelo: {sharpe(gemelo):.2f}")

Correlación media entre mercados: real 0.081, gemelo 0.081
Sharpe de la tendencia en el gemelo: 0.03

La misma correlación media entre mercados (0,081) y un Sharpe de 0,03: lo esperable en una serie sin memoria. Más abajo se usa también el control que trae el propio README, la serie ruptura de regimenes2.parquet.

Remuestreo de operaciones: drawdown y riesgo de ruina

Es la forma de Monte Carlo más extendida entre los traders: tomar la lista de operaciones cerradas y generar secuencias alternativas. Hay dos variantes. Desordenar (permutar sin reemplazo) conserva exactamente las mismas operaciones, y por tanto el mismo resultado final, y solo cambia el orden: sirve para ver qué drawdown podría haber salido con las mismas operaciones. Remuestrear (con reemplazo) cambia también qué operaciones salen y cuántas veces: sirve para la distribución del resultado y del riesgo de ruina.

En una estrategia de tendencia con señal diaria, una operación es una racha de sesiones con el mismo signo en un mercado:

def operaciones(signo, pnl):
    """Una operación: racha de sesiones con el mismo signo."""
    filas = []
    for m in pnl.columns:
        s = signo[m].shift(1).loc[pnl.index]
        racha = (s != s.shift()).cumsum()
        g = pnl[m].groupby(racha)
        fechas = pnl.index.to_series().groupby(racha)
        filas.append(pd.DataFrame({
            "mercado": m, "salida": fechas.last(),
            "sesiones": g.size(), "pnl": g.sum()}))
    return (pd.concat(filas).sort_values("salida", kind="stable")
            .reset_index(drop=True))

ops = operaciones(signo, pnl)
print(f"{len(ops)} operaciones; ganadoras: "
      f"{(ops['pnl'] > 0).mean():.0%}")
print("Sesiones por operación:",
      ops["sesiones"].quantile([0.25, 0.5, 0.75, 0.99])
      .round().astype(int).to_dict())
(100 * ops["pnl"]).quantile([0.01, 0.1, 0.5, 0.9, 0.99]).round(3)

3229 operaciones; ganadoras: 32%
Sesiones por operación: {0.25: 1, 0.5: 4, 0.75: 16, 0.99: 631}
0.01   -0.827
0.10   -0.254
0.50   -0.050
0.90    0.263
0.99    3.477
Name: pnl, dtype: float64

El perfil es el típico de una tendencia: 3.229 operaciones, solo un 32 % ganadoras, la mitad dura 4 sesiones o menos (la señal cambia de signo varias veces cuando la rentabilidad de 12 meses ronda el cero) y unas pocas duran años. La operación mediana pierde un 0,050 % del capital; la del percentil 99 gana un 3,48 %. El resultado lo hacen las pocas operaciones largas, y por eso el orden en que llegan las pérdidas pequeñas importa tanto para el drawdown.

rng = np.random.default_rng(7)
x = ops["pnl"].to_numpy()
N = 2000

def dd_max(m):
    """Drawdown máximo de cada fila de una matriz de resultados."""
    eq = np.cumprod(1 + m, axis=-1)
    pico = np.maximum.accumulate(eq, axis=-1)
    return (eq / pico - 1).min(axis=-1)

dd_hist = dd_max(x)
dd_perm = dd_max(rng.permuted(np.tile(x, (N, 1)), axis=1))
dd_boot = dd_max(rng.choice(x, size=(N, len(x))))

q = [0.05, 0.5, 0.95]
print(f"Drawdown de la secuencia real: {dd_hist:.1%}")
print(f"Desordenados con un drawdown peor: "
      f"{(dd_perm <= dd_hist).mean():.1%}")
pd.DataFrame({
    "desordenar": np.quantile(dd_perm, q),
    "remuestrear": np.quantile(dd_boot, q)},
    index=["5 %", "mediana", "95 %"]).mul(100).round(1)

Drawdown de la secuencia real: -21.9%
Desordenados con un drawdown peor: 0.0%
         desordenar  remuestrear
5 %           -15.0        -15.3
mediana       -10.0        -10.1
95 %           -7.4         -7.2

rng.permuted(..., axis=1) desordena cada fila por separado: 2.000 órdenes distintos de las mismas operaciones en una sola llamada. El resultado es incómodo. Con las operaciones en orden aleatorio, el drawdown mediano es del −10,0 % y el del percentil 5, del −15,0 %. La secuencia real tuvo un −21,9 %: peor que todas las secuencias desordenadas.

No es mala suerte. Desordenar supone que las operaciones son intercambiables, y en una cartera de 24 mercados no lo son: se solapan en el tiempo, y cuando el mercado da la vuelta (un final de tendencia, una crisis) varios mercados pierden a la vez. La celda siguiente lo mide:

eq = np.cumprod(1 + x)
fondo = int(np.argmin(eq / np.maximum.accumulate(eq)))
pico = int(np.argmax(eq[:fondo + 1]))
print(f"Peor tramo: {ops['salida'][pico]:%Y-%m-%d} a "
      f"{ops['salida'][fondo]:%Y-%m-%d}, {fondo - pico} operaciones")

mes = ops["salida"].dt.to_period("M").to_numpy()
real = pd.Series(x).groupby(mes).sum().std()
barajado = np.mean([pd.Series(rng.permutation(x)).groupby(mes)
                    .sum().std() for _ in range(200)])
print(f"Desviación típica del resultado mensual: real {real:.2%}, "
      f"barajado {barajado:.2%}")

Peor tramo: 2001-01-02 a 2003-01-16, 378 operaciones
Desviación típica del resultado mensual: real 3.30%, barajado 2.52%

Con las operaciones en su mes real, el resultado mensual tiene una desviación típica del 3,30 %; con las mismas operaciones repartidas al azar entre los mismos meses, del 2,52 %. Las ganancias y las pérdidas se agrupan en el tiempo, y el peor tramo de la secuencia real, de enero de 2001 a enero de 2003, encadena 378 operaciones.

Con esa reserva, el remuestreo sirve para una pregunta que el backtest no contesta: qué apalancamiento soporta la estrategia. Si se define la ruina como un drawdown del 20 % o del 40 % (el punto en que un gestor cerraría la estrategia o un cliente retiraría el dinero), basta con multiplicar las operaciones por el apalancamiento:

filas = {}
for apal in (1, 2, 3, 4):
    dd = dd_max(apal * rng.choice(x, size=(N, len(x))))
    filas[f"x{apal}"] = {
        "dd_mediano": np.median(dd),
        "P(dd < -20 %)": (dd < -0.20).mean(),
        "P(dd < -40 %)": (dd < -0.40).mean()}
pd.DataFrame(filas).T.round(3)

    dd_mediano  P(dd < -20 %)  P(dd < -40 %)
x1      -0.101          0.005          0.000
x2      -0.192          0.428          0.000
x3      -0.278          0.952          0.046
x4      -0.359          1.000          0.289

Sin apalancar, la probabilidad de pasar por un drawdown del 20 % en 25 años es del 0,5 %; con el doble de tamaño, del 43 %; con el triple, del 95 %. La de llegar al 40 % es nula con el doble (ninguno de 2.000 caminos), del 4,6 % con el triple y del 29 % con el cuádruple. El drawdown mediano crece algo menos que proporcionalmente (−10,1 %, −19,2 %, −27,8 % y −35,9 %), porque en un capital compuesto cada pérdida se aplica sobre un capital ya menor; la probabilidad de cruzar un umbral fijo, en cambio, se dispara. Y todas estas cifras heredan el sesgo optimista de la celda anterior: la secuencia real ya tuvo un −21,9 % sin apalancar.

Bootstrap de bloques sobre los rendimientos diarios

El bootstrap de los rendimientos diarios evita el problema del solapamiento: cada día ya contiene todas las posiciones abiertas, con su correlación. Pero el bootstrap clásico de Efron (sacar días sueltos con reemplazo) supone que los días son independientes, y los rendimientos de una cartera no lo son: su volatilidad viene en rachas (lección 1.6.2). La solución es remuestrear bloques de días consecutivos. Künsch (1989) propuso bloques de longitud fija; el bootstrap circular une el final de la serie con el principio para que todos los días tengan la misma probabilidad de aparecer, y el bootstrap estacionario de Politis y Romano (1994) usa bloques de longitud aleatoria, geométrica de media $b$:

Con bloques de longitud aleatoria, la serie remuestreada es estacionaria, cosa que no garantizan los bloques fijos. El mecanismo cabe en un bucle:

def indices_estacionario(n, largo, b, rng):
    """Índices de un remuestreo estacionario (Politis y Romano).

    Cada paso sigue al día siguiente con probabilidad 1 - 1/b o
    salta a un día al azar con probabilidad 1/b: bloques de
    longitud geométrica de media b, con vuelta circular."""
    idx = np.empty(largo, dtype=np.int64)
    idx[0] = rng.integers(n)
    salto = rng.random(largo) < 1 / b
    nuevo = rng.integers(n, size=largo)
    for t in range(1, largo):
        idx[t] = nuevo[t] if salto[t] else (idx[t - 1] + 1) % n
    return idx

rng = np.random.default_rng(11)
print(indices_estacionario(len(cartera), 16, 5, rng))

[ 841  842 3221 5917 5918 5275 3452 3453 3454 3455 3456 3457 3458 5179
 5180 5181]

Se ven los bloques: 841-842, un día suelto, 5917-5918, otro suelto, siete días seguidos desde el 3452 y otros tres al final, con media 5 porque b=5. La librería arch tiene la versión eficiente (StationaryBootstrap, CircularBlockBootstrap) y el selector automático de longitud de bloque de Politis y White (2004), con la corrección de Patton, Politis y White (2009), que estima la $b$ óptima a partir de la autocorrelación de la serie:

from arch.bootstrap import optimal_block_length

pd.concat({"r": optimal_block_length(cartera),
           "r²": optimal_block_length(cartera ** 2)}).round(1)

         stationary  circular
r  None         1.2       1.4
r² None        47.6      54.5

Los rendimientos casi no tienen autocorrelación, y el selector pide bloques de 1 sesión. Sus cuadrados, que miden la volatilidad, piden 48 (estacionario) o 55 (circular). La elección depende de qué estadístico se quiere: la media depende de los rendimientos; el drawdown, de las rachas de volatilidad. Lo prudente es mirar varias longitudes:

from arch.bootstrap import StationaryBootstrap

def drawdown(x):
    eq = np.cumprod(1 + np.asarray(x))
    return (eq / np.maximum.accumulate(eq) - 1).min()

def stats(x):
    return np.array([sharpe(x), drawdown(x)])

print(f"Histórico: Sharpe {sharpe(cartera):.2f}, "
      f"drawdown {drawdown(cartera):.1%}")
filas = {}
for b in (1, 5, 20, 75, 250):
    bs = StationaryBootstrap(b, cartera.to_numpy(), seed=3)
    v = bs.apply(stats, 1000)
    filas[b] = {"sharpe_2.5": np.quantile(v[:, 0], 0.025),
                "sharpe_97.5": np.quantile(v[:, 0], 0.975),
                "dd_mediano": np.median(v[:, 1]),
                "dd_5 %": np.quantile(v[:, 1], 0.05)}
pd.DataFrame(filas).T.rename_axis("bloque").round(3)

Histórico: Sharpe 1.00, drawdown -14.7%
        sharpe_2.5  sharpe_97.5  dd_mediano  dd_5 %
bloque
1            0.591        1.391      -0.179  -0.264
5            0.613        1.374      -0.178  -0.270
20           0.630        1.380      -0.178  -0.265
75           0.600        1.399      -0.177  -0.262
250          0.661        1.326      -0.169  -0.235

Tres lecturas. La primera: el intervalo del 95 % del Sharpe va de 0,6 a 1,4 con cualquier bloque. Se parece a la aproximación de Lo (2002)22Nota 2 · Lo, A. W. (2002), «The Statistics of Sharpe Ratios», Financial Analysts Journal 58(4), 36-52, doi:10.2469/faj.v58.n4.2453. para rendimientos i.i.d., $\sigma(\widehat{SR}) \approx \sqrt{(1 + SR^2/2)/T}$ con $T$ en años: con 1,00 y 25 años, 0,24, y ±1,96 veces eso da de 0,52 a 1,48; el bootstrap sale algo más estrecho. Veinticinco años de datos no bastan para distinguir un Sharpe de 0,6 de uno de 1,4.

La segunda: en esta cartera el drawdown apenas depende del bloque. El mediano va del −17,9 % con días sueltos al −17,7 % con bloques de 75 sesiones, y el del percentil 5, del −26,4 % al −26,2 %. La razón está en la construcción: cada posición se escala por la inversa de su volatilidad, y eso quita a la cartera casi toda la agrupación de volatilidad que un bloque largo conservaría. En una serie sin escalar es distinto. La celda siguiente repite la prueba con el futuro de índice IDA comprado y mantenido:

ida = r["IDA"].loc["2001-01-02":].to_numpy()
b_ida = optimal_block_length(ida ** 2)["stationary"].iloc[0]
print(f"IDA: bloque de Politis y White para r²: {b_ida:.0f}")
print(f"Drawdown histórico: {drawdown(ida):.1%}")
for b in (1, 75):
    v = StationaryBootstrap(b, ida, seed=3).apply(
        lambda x: np.array([drawdown(x)]), 500)[:, 0]
    print(f"Bloque {b:>2}: drawdown mediano {np.median(v):.1%}, "
          f"percentil 5 {np.quantile(v, 0.05):.1%}")

IDA: bloque de Politis y White para r²: 156
Drawdown histórico: -62.2%
Bloque  1: drawdown mediano -53.0%, percentil 5 -74.9%
Bloque 75: drawdown mediano -65.3%, percentil 5 -86.8%

En IDA el selector pide bloques de 156 sesiones para los cuadrados (48 en la cartera), y el drawdown mediano pasa del −53,0 % con días sueltos al −65,3 % con bloques de 75 sesiones; el percentil 5, del −74,9 % al −86,8 %. Los bloques largos conservan las rachas de volatilidad, y con ellas las caídas encadenadas; los días sueltos las reparten y el drawdown sale optimista: con ellos, el histórico de IDA (−62,2 %) parecería peor de lo normal. La regla práctica: el bloque importa para el drawdown en la medida en que la serie tenga rachas de volatilidad, y lo prudente es mirar varias longitudes.

La tercera: el drawdown histórico de la cartera (−14,7 %) es más suave que la mediana del bootstrap con cualquier bloque (entre −16,9 % y −17,9 %). La historia que ocurrió fue algo afortunada en el orden de sus días: el riesgo que conviene esperar es el del bootstrap, no el del backtest. (El −21,9 % de la secuencia de operaciones no es comparable: allí cada operación se apunta entera el día de su salida.)

El abanico de capital

Con el bootstrap estacionario se pueden generar caminos de cualquier longitud. Mil caminos de cinco años con bloques de 75 sesiones de media dan el abanico de la figura de la cabecera:

rng = np.random.default_rng(5)
n, largo, b = len(cartera), 5 * 252, 75
caminos = np.array([
    cartera.to_numpy()[indices_estacionario(n, largo, b, rng)]
    for _ in range(1000)])
capital = np.cumprod(1 + caminos, axis=1)
bandas = pd.DataFrame(
    np.quantile(capital, [0.05, 0.25, 0.5, 0.75, 0.95], axis=0).T,
    columns=["p5", "p25", "p50", "p75", "p95"])
print(bandas.iloc[[251, 503, 755, 1007, 1259]]
      .set_axis([1, 2, 3, 4, 5]).rename_axis("año").round(2))
print(f"P(perder a 5 años): {(capital[:, -1] < 1).mean():.1%}")

       p5   p25   p50   p75   p95
año
1    0.94  1.02  1.09  1.16  1.25
2    0.96  1.10  1.20  1.30  1.45
3    1.01  1.17  1.29  1.44  1.67
4    1.07  1.26  1.41  1.59  1.88
5    1.14  1.36  1.54  1.77  2.10
P(perder a 5 años): 1.2%

La mediana llega a 1,54 en cinco años; la banda del 25 al 75 %, de 1,36 a 1,77. El percentil 5 es la línea que importa para decidir el tamaño: pasa el primer año por 0,94 (un 6 % de pérdida), el segundo por 0,96, no vuelve a 1 hasta el tercero (1,01) y a los cinco años está en 1,14. Aun con un Sharpe de 1,00, un 1,2 % de los caminos pierde dinero a cinco años y uno de cada veinte pasa dos años en pérdidas. Es lo que conviene enseñar a quien vaya a invertir antes de que lo viva.

Permutar la señal: ¿acierta el momento?

El bootstrap dice cuánto varía el Sharpe; no dice si es distinto de lo que daría una estrategia sin acierto. Un test de permutación construye esa referencia directamente: se rompe la relación entre la señal y los rendimientos y se recalcula el estadístico muchas veces. El p-valor es la fracción de permutaciones que igualan o superan lo observado, con la corrección habitual para que nunca sea cero:

Lo delicado es decidir qué se permuta. La pregunta es si la dirección elegida en cada momento aporta algo, así que se permuta solo el signo; la escala por volatilidad y los rendimientos se quedan en su sitio. Y hay dos formas de permutar el signo: barajar las sesiones (rompe también la persistencia de la señal) o desplazarlo circularmente un número aleatorio de sesiones (conserva sus rachas, su rotación y su autocorrelación, y solo cambia su alineación con el mercado). White (2000) y Hansen (2005)33Nota 3 · Hansen, P. R. (2005), «A Test for Superior Predictive Ability», Journal of Business & Economic Statistics 23(4), 365-380, doi:10.1198/073500105000000063. extienden la idea al caso de muchas reglas a la vez.

def p_valor_perm(signo, escala, r, n_perm=1000, seed=0,
                 modo="circular"):
    """Sharpe observado, p-valor y distribución nula.

    Solo se permuta la DIRECCIÓN (el signo); la escala por
    volatilidad y los rendimientos quedan en su sitio."""
    rng = np.random.default_rng(seed)
    s = signo.shift(1).to_numpy()
    e = escala.shift(1).to_numpy()
    rr = r.to_numpy()
    ok = ~(np.isnan(s).any(axis=1) | np.isnan(e).any(axis=1)
           | np.isnan(rr).any(axis=1))
    s, e, rr = s[ok], e[ok], rr[ok]
    obs = sharpe((s * e * rr).sum(axis=1))
    nula = np.empty(n_perm)
    for i in range(n_perm):
        if modo == "barajar":
            sp = s[rng.permutation(len(s))]
        else:  # desplazamiento circular de al menos un año
            sp = np.roll(s, rng.integers(252, len(s) - 252), axis=0)
        nula[i] = sharpe((sp * e * rr).sum(axis=1))
    p = (1 + (nula >= obs).sum()) / (1 + n_perm)
    return obs, p, nula

res, nulas = {}, {}
for nombre, args in {"tendencia": (signo, escala, r),
                     "gemelo": (signo_g, escala_g, r_g)}.items():
    for modo in ("barajar", "circular"):
        obs, p, nula = p_valor_perm(*args, modo=modo)
        nulas[(nombre, modo)] = nula
        res[(nombre, modo)] = {"sharpe": obs, "p": p,
                               "nula_media": nula.mean(),
                               "nula_95": np.quantile(nula, 0.95)}
pd.DataFrame(res).T.round(3)

                    sharpe      p  nula_media  nula_95
tendencia barajar    0.999  0.001       0.202    0.519
          circular   0.999  0.001       0.048    0.552
gemelo    barajar    0.026  0.536       0.039    0.376
          circular   0.026  0.248      -0.066    0.212

El método distingue los dos casos. En los futuros con efecto plantado, el Sharpe observado (1,00) supera a todas las permutaciones, barajando y desplazando: p = 0,001, el mínimo posible con 1.000. En el gemelo sin memoria, el 0,03 cae dentro de su nula: p = 0,25 con el desplazamiento circular (0,54 barajando).

Fíjate en la media de la nula: 0,20 al barajar y 0,05 con el desplazamiento circular, no 0. Cualquier permutación conserva la proporción de sesiones largas y cortas de cada mercado, y con ella la parte del resultado que viene de la exposición media:

largo = (signo.shift(1).loc[pnl.index] > 0).mean()
largo.sort_values().round(2).iloc[[0, 1, -2, -1]].to_dict()

{'MEA': 0.42, 'DIC': 0.43, 'IDB': 0.7, 'IDA': 0.71}

La cartera está larga el 71 % de las sesiones en IDA y el 70 % en IDB, y solo el 42 % en el oro (MEA). Los índices llevan la prima de la renta variable del guion, así que una permutación que los deja largos el 70 % del tiempo gana algo con cualquier orden; lo mismo pasa con la parte del carry que la regla recoge. El test no pregunta si la estrategia gana dinero, sino si el momento elegido añade algo sobre esa exposición. Una estrategia siempre larga en un mercado alcista ganaría dinero y no pasaría el test.

flowchart TB
  Q{¿Qué preguntas?} -- riesgo --> D[Bootstrap bloques]
  Q -- ¿acierta? --> P[Permutación]
  Q -- ¿elegí bien? --> S[DSR y PBO]
  D --> C{¿Pérdidas juntas?}
  C -- sí --> B[Bloques largos]
  C -- no --> T[Trades o i.i.d.]

Potencia: no rechazar no es no tener efecto

Los 24 mercados tienen el mismo efecto plantado. Mercado a mercado:

p_merc = pd.Series({
    m: p_valor_perm(signo[[m]], escala[[m]], r[[m]],
                    n_perm=500, seed=1)[1]
    for m in r.columns})
print(f"Mercados con p < 0,05: {(p_merc < 0.05).sum()} de 24")
print(p_merc.sort_values().round(3).head(6).to_dict())

Mercados con p < 0,05: 7 de 24
{'AGB': 0.002, 'BOD': 0.002, 'BOC': 0.01, 'AGC': 0.012, 'BOA': 0.034, 'AGA': 0.042}

Solo 7 de los 24 pasan al 5 %, con los agrícolas y los bonos en cabeza. Con un Sharpe verdadero de momentum en torno a 0,15 por mercado y 25 años de datos, el error típico del Sharpe (≈ 0,2) es mayor que el efecto: el test casi nunca lo detecta en un mercado solo. La cartera lo detecta porque suma 24 efectos débiles poco correlados. Descartar 17 mercados por «no significativos» sería descartar un efecto real; la conclusión correcta es que un mercado solo no tiene datos suficientes.

Y en el ruido, ¿cuántos falsos positivos?

El control del README es la serie ruptura de regimenes2.parquet después de su ruptura (el 2013-05-22): rendimientos normales i.i.d. de media cero, donde ninguna regla de tendencia tiene ventaja. Una sola serie de ruido no basta para saber si el test está bien calibrado, así que se añaden 200 series simuladas como ella:

reg = pd.read_parquet("regimenes2.parquet")
ru = (reg[reg["serie"] == "ruptura"].set_index("fecha")[["precio"]]
      .loc["2013-05-22":])          # tras la ruptura: i.i.d., media 0
s_ru, e_ru, r_ru, _ = tendencia(ru, riesgo=0.10)
obs, p, _ = p_valor_perm(s_ru, e_ru, r_ru)
print(f"Serie «ruptura» desde 2013: Sharpe {obs:.2f}, p = {p:.3f}")

rng = np.random.default_rng(99)
ps = []
for i in range(200):
    ruido = pd.DataFrame(
        np.cumprod(1 + 0.013 * rng.standard_normal(len(ru))),
        index=ru.index)
    ps.append(p_valor_perm(*tendencia(ruido, riesgo=0.10)[:3],
                           n_perm=200, seed=i)[1])
ps = np.array(ps)
print(f"Series de ruido con p < 0,05: {(ps < 0.05).mean():.1%}")
print(np.histogram(ps, bins=5, range=(0, 1))[0])

Serie «ruptura» desde 2013: Sharpe 0.55, p = 0.032
Series de ruido con p < 0,05: 4.5%
[36 47 33 27 57]

La serie del README da un Sharpe de 0,55 y p = 0,032: un falso positivo. No hay error en el test: en 200 series de ruido como ella, un 4,5 % sale con p < 0,05, y los p-valores se reparten de forma aproximadamente uniforme entre 0 y 1 (36, 47, 33, 27 y 57 por quintil). Eso es lo que significa un nivel del 5 %: uno de cada veinte controles sale «significativo». Por eso un único p-valor por debajo de 0,05 no demuestra nada, y por eso un control que pasa el test no invalida el método: invalida la costumbre de probar una sola cosa y creer el resultado.

Lo que ningún remuestreo corrige

Los tres métodos trabajan sobre una estrategia ya elegida. Si esa estrategia es la mejor de muchas, todos heredan el sesgo de la elección. El conjunto ruido2_estrategias.parquet tiene 1.000 estrategias, 995 de ellas sin ninguna ventaja (la verdad está en ruido2_verdad.csv):

rs = pd.read_parquet("ruido2_estrategias.parquet").pivot(
    index="fecha", columns="estrategia", values="rendimiento")
verdad = pd.read_csv("ruido2_verdad.csv", index_col="estrategia")
sin_ventaja = verdad.index[verdad["sharpe_real"] == 0]
sr = rs[sin_ventaja].apply(sharpe)
mejor = sr.idxmax()
print(f"{len(sin_ventaja)} estrategias sin ventaja; la mejor: "
      f"{mejor}, Sharpe {sr.max():.2f}")
bs = StationaryBootstrap(5, rs[mejor].to_numpy(), seed=2)
v = bs.apply(sharpe, 2000)[:, 0]
print(f"Intervalo del 95 %: {np.quantile(v, 0.025):.2f} a "
      f"{np.quantile(v, 0.975):.2f}")
print(f"Remuestreos con Sharpe <= 0: {(v <= 0).mean():.2%}")

995 estrategias sin ventaja; la mejor: e0598, Sharpe 1.50
Intervalo del 95 %: 0.46 a 2.54
Remuestreos con Sharpe <= 0: 0.15%

La mejor de las 995 tiene un Sharpe de 1,50 en cuatro años, un intervalo bootstrap de 0,46 a 2,54 y solo un 0,15 % de remuestreos con Sharpe negativo. Todo indica una estrategia excelente, y su Sharpe verdadero es cero. El bootstrap responde bien a su pregunta (cuánto varía el Sharpe de esta serie) y no puede responder a otra que no se le hizo: cuántas series se miraron antes de elegirla. Con 995 intentos y un error típico del Sharpe de 0,5, un máximo de 1,5 es lo esperable. La corrección es el Deflated Sharpe Ratio o el PBO de la lección 2.5.4, que necesitan el número de pruebas, y el diario de experimentos de la lección 2.2.4, que es donde ese número queda escrito.

En resumen, el orden de trabajo con una estrategia candidata:

1. Bootstrap de bloques de los rendimientos diarios, con varias longitudes de bloque: intervalo del Sharpe, del drawdown y abanico para decidir el tamaño.
2. Remuestreo de operaciones solo como suelo del riesgo, comprobando dónde cae la secuencia real.
3. Test de permutación de la señal (circular si la señal es persistente) para separar acierto de exposición, también en un control sin efecto.
4. Deflated Sharpe o PBO con el número real de pruebas (lección 2.5.4); la lección 2.5.8 junta todo en una lista.

Ejercicios

1. Repite el riesgo de ruina con el bootstrap estacionario de los rendimientos diarios (bloques de 75) en lugar de las operaciones: probabilidad de un drawdown del 20 % en 25 años con apalancamiento 1 y 2. Compáralo con la tabla de las operaciones.

rng = np.random.default_rng(21)
n = len(cartera)
caminos = np.array([cartera.to_numpy()[
    indices_estacionario(n, n, 75, rng)] for _ in range(500)])
for apal in (1, 2):
    dd = dd_max(apal * caminos)
    print(f"x{apal}: drawdown mediano {np.median(dd):.1%}, "
          f"P(dd < -20 %) {(dd < -0.20).mean():.1%}")

x1: drawdown mediano -17.6%, P(dd < -20 %) 29.8%
x2: drawdown mediano -33.0%, P(dd < -20 %) 99.6%

2. Aplica el test de permutación circular a la misma regla con una ventana de 63 sesiones en lugar de 252, en los futuros y en el gemelo. ¿Detecta el test un efecto que el README planta a 252 sesiones?

for nombre, precios in (("tendencia", px), ("gemelo", px_g)):
    s63, e63, r63, _ = tendencia(precios, L=63)
    obs, p, nula = p_valor_perm(s63, e63, r63, n_perm=500)
    print(f"{nombre}: Sharpe {obs:.2f}, p = {p:.3f}, "
          f"media de la nula {nula.mean():.2f}")

tendencia: Sharpe 0.63, p = 0.020, media de la nula 0.07
gemelo: Sharpe 0.00, p = 0.403, media de la nula -0.04

3. Una estrategia está larga todos los días en un índice que sube un 8 % anual. ¿Qué p-valor da el test de permutación de la señal y por qué? ¿Qué te dice eso sobre lo que mide el test?