Modelado de fills: órdenes limitadas, cola, fills parciales, huecos y stops.

El fill también es un supuesto

Un backtest no ejecuta nada: decide, con los datos que tiene, si una orden se habría ejecutado y a qué precio. Esa decisión es el modelo de fill. Con órdenes a mercado pequeñas el modelo importa poco: se ejecutan seguro, y el precio es el de la barra más el deslizamiento y los costes de la lección 2.4.7. Con órdenes limitadas y stops, el modelo decide la estrategia: una limitada que se da por ejecutada cuando no lo habría estado, o al precio de un stop que el mercado saltó, mejora el resultado en cada operación, siempre en el mismo sentido.

Los datos de esta lección son sintéticos: la sesión del 2 de junio de 2025 de NOVA (nivel 1), simulada orden a orden, con su libro L2, sus mensajes L3 y sus operaciones, y las barras de 5 minutos del ETF ficticio KAPA de 2022 a 2025 (nivel 2). Ninguno es de un mercado real.

Una orden en la cola: NOVA a las 10:00

Los mensajes L3 de NOVA cubren de 10:00 a 10:05 de Nueva York (14:00 a 14:05 UTC) y empiezan con una foto de todas las órdenes vivas en orden de prioridad (lección 1.1.3). Con ellos se puede seguir exactamente qué habría pasado con una orden propia que llegara a las 10:00 al final de la cola del mejor precio:

• delante tiene las órdenes que ya estaban a ese precio;
• la cola avanza cuando una de ellas se ejecuta, se cancela o reduce su tamaño;
• cuando no queda nadie delante, la siguiente ejecución a ese precio habría sido contra la orden propia.

import numpy as np
import pandas as pd

l3 = pd.read_parquet("nova_libro_l3.parquet")
foto, mensajes = l3.iloc[:358], l3.iloc[358:]


def simular_cola(lado, precio, tamano=500):
    delante = foto[(foto["lado"] == lado) & (foto["precio"] == precio)]
    vivas = dict(zip(delante["id_orden"], delante["tamano"]))
    inicio = sum(vivas.values())
    toque = fill = None
    lleno = 0
    m = mensajes[(mensajes["lado"] == lado)
                 & (mensajes["precio"] == precio)]
    for msg in m.itertuples():
        if msg.evento == "ejecucion" and toque is None:
            toque = msg.ts                  # modelo por toque
        if msg.id_orden in vivas:           # avanza la cola
            if msg.evento == "cancelacion":
                vivas.pop(msg.id_orden)
            elif msg.evento == "modificacion":
                vivas[msg.id_orden] = msg.tamano
            elif msg.evento == "ejecucion":
                vivas[msg.id_orden] -= msg.tamano
                if vivas[msg.id_orden] <= 0:
                    vivas.pop(msg.id_orden)
        elif msg.evento == "ejecucion" and not vivas:
            lleno += msg.tamano             # contra la propia
            if lleno >= tamano:
                fill = msg.ts
                break
    return inicio, toque, fill


for lado, precio in [("bid", 53.08), ("ask", 53.09)]:
    inicio, toque, fill = simular_cola(lado, precio)
    seg = lambda t: None if t is None else round(
        (t - pd.Timestamp("2025-06-02 14:00", tz="UTC"))
        .total_seconds(), 1)
    print(f"{lado} {precio}: {inicio} acciones delante · toque a",
          f"{seg(toque)} s · fill por cola a {seg(fill)} s")

bid 53.08: 5966 acciones delante · toque a 0.5 s · fill por cola a None s
ask 53.09: 2488 acciones delante · toque a 2.4 s · fill por cola a 27.0 s

Las dos órdenes cuentan la historia entera de las limitadas.

• La compra a 53,08 se habría dado por ejecutada en el modelo por toque a los 0,5 segundos: una venta agresiva negoció a 53,08 casi enseguida. Pero delante había 5.966 acciones en ocho órdenes. La cola llegó a vaciarse (por ejecuciones y cancelaciones) y, justo entonces, el precio subió y nadie más vendió a 53,08: la orden propia no se ejecuta nunca en la ventana. El precio se fue al alza, que es justo cuando el comprador quería estar dentro.
• La venta a 53,09 se toca a los 2,4 segundos y se ejecuta de verdad a los 27 segundos, cuando se agotan las 2.488 acciones de delante. Para entonces, el precio ya subía.

cot = pd.read_parquet("nova_cotizaciones.parquet")
cot["medio"] = (cot["bid"] + cot["ask"]) / 2
ventana = cot[(cot["ts"] >= "2025-06-02 14:00")
              & (cot["ts"] <= "2025-06-02 14:05")]
ventana.set_index("ts")["medio"].resample("1min").last()

ts
2025-06-02 14:00:00+00:00    53.085
2025-06-02 14:01:00+00:00    53.140
2025-06-02 14:02:00+00:00    53.155
2025-06-02 14:03:00+00:00    53.155
2025-06-02 14:04:00+00:00    53.175
Freq: min, Name: medio, dtype: float64

El punto medio pasa de 53,085 a 53,175 en cuatro minutos. El modelo por toque compra a 53,08 en el primer medio segundo y gana con la subida; el modelo por cola no compra (y se pierde la subida) y vende a 53,09 justo antes de que el precio suba casi nueve céntimos. Es la selección adversa de los creadores de mercado de la lección 2.3.6, vista desde una sola orden: a una limitada la ejecutan sobre todo cuando no conviene.

stateDiagram-v2
  [*] --> EN_COLA
  EN_COLA --> EN_COLA: avanza la cola
  EN_COLA --> PRIMERA: cola vacía
  PRIMERA --> EJECUTADA: llega un agresor
  PRIMERA --> SIN_FILL: el precio se aleja
  EN_COLA --> SIN_FILL: el precio se aleja
  EJECUTADA --> [*]
  SIN_FILL --> [*]

Toque, cruce y cola en toda la sesión

Una orden no es una muestra. Los mensajes L3 solo cubren cinco minutos, pero las fotos L2 de cada 10 segundos y las operaciones de toda la sesión permiten aproximar la cola en cualquier momento: la orden propia llega al final del mejor bid de la foto, con la cantidad del nivel delante, y la cola avanza con el volumen negociado a ese precio en los centros con libro. Es una aproximación conservadora (no ve las cancelaciones de delante, que adelantarían la orden) y es la que se puede hacer con datos L2 y de operaciones; NautilusTrader hace algo parecido con queue_position=True.

Para cada una de las 2.251 fotos entre las 9:35 y las 15:50 se simula una compra limitada de 200 acciones en el mejor bid, válida 60 segundos, con tres modelos: toque (cualquier operación de la cinta consolidada a ese precio o menos), cruce (una operación por debajo) y cola (el volumen negociado a ese precio en los libros visibles supera la cantidad de delante más la propia, o el precio cruza).

l2 = pd.read_parquet("nova_libro_l2.parquet")
op = pd.read_parquet("nova_operaciones.parquet")
con_libro = op[op["centro"].isin(["PRINCIPAL", "MTF_A", "MTF_B"])
               & (op["condicion"] == "regular")].reset_index(drop=True)
mejor_bid = l2[(l2["nivel"] == 1) & (l2["lado"] == "bid")]
mejor_bid = mejor_bid[mejor_bid["ts"].between(
    "2025-06-02 13:35", "2025-06-02 19:50")]
H, TAM = pd.Timedelta(seconds=60), 200


def tramo(df, desde, hasta):
    i = df["ts"].searchsorted(desde, side="right")
    j = df["ts"].searchsorted(hasta, side="right")
    return df.iloc[i:j]


filas = []
for foto_l2 in mejor_bid.itertuples():
    p, delante = foto_l2.precio, foto_l2.tamano
    cinta = tramo(op, foto_l2.ts, foto_l2.ts + H)
    libro = tramo(con_libro, foto_l2.ts, foto_l2.ts + H)
    toque = cinta.loc[cinta["precio"] <= p, "ts"].min()
    cruce = libro.loc[libro["precio"] < p, "ts"].min()
    en_p = libro["tamano"].where(libro["precio"] == p, 0).cumsum()
    cola = libro.loc[en_p >= delante + TAM, "ts"].min()
    cola = min(t for t in [cola, cruce] if pd.notna(t)) if (
        pd.notna(cola) or pd.notna(cruce)) else pd.NaT
    filas.append({"ts": foto_l2.ts, "precio": p, "delante": delante,
                  "toque": toque, "cruce": cruce, "cola": cola})
fills = pd.DataFrame(filas)
print(len(fills), "órdenes · cantidad delante (mediana):",
      int(fills["delante"].median()), "acciones")
fills[["toque", "cruce", "cola"]].notna().mean().round(3)

2251 órdenes · cantidad delante (mediana): 6900 acciones
toque    0.868
cruce    0.413
cola     0.444
dtype: float64

Con el modelo por toque, el 87 % de las órdenes se ejecuta en un minuto; con el de cola, el 44 %, y con el de cruce, el 41 %. La diferencia es casi entera la cola: la mediana de lo que hay delante en el mejor bid son 6.900 acciones, treinta y tantas veces la orden propia, y en un minuto no siempre se negocian.

La selección adversa: a quién y cuándo ejecutan

El porcentaje de ejecuciones es la mitad del problema. La otra mitad es cuáles se ejecutan. El markout mide la calidad de una ejecución: dónde está el punto medio un tiempo después, comparado con el precio pagado. Para una compra, un markout negativo significa que el precio siguió cayendo después de comprar.

medio = cot.set_index("ts")["medio"]
ask = cot.set_index("ts")["ask"]


def a_los(serie, ts, segundos):
    i = serie.index.searchsorted(
        ts + pd.Timedelta(seconds=segundos)) - 1
    return serie.iloc[i].to_numpy()


markout = {}
for modelo in ["toque", "cruce", "cola"]:
    f = fills[fills[modelo].notna()]
    fila = {}
    for s in [5, 30, 60, 300]:
        m = a_los(medio, f[modelo], s)
        fila[f"{s}s"] = (1e4 * (m - f["precio"]) / f["precio"]).mean()
    a = a_los(ask, f[modelo], 60)
    fila["ida_vuelta_60s"] = (1e4 * (a - f["precio"])
                              / f["precio"]).mean()
    fila["p_fill"] = len(f) / len(fills)
    markout[modelo] = fila
pd.DataFrame(markout).T.round(2)

         5s   30s   60s   300s  ida_vuelta_60s  p_fill
toque  0.80  0.11 -0.57  -2.74            0.39    0.87
cruce -1.14 -3.32 -5.95 -13.20           -4.98    0.41
cola  -0.94 -2.98 -5.38 -12.27           -4.40    0.44

En los tres modelos el markout empeora con el tiempo: las compras pasivas se llenan cuando el flujo es vendedor, y el flujo vendedor sigue. Pero el modelo por toque está mucho más arriba en todos los horizontes: incluye las ejecuciones «gratis» de los toques en que el precio rebota, que en la cola real no llegan a ejecutarse.

La columna ida_vuelta_60s es una estrategia de creador de mercado mínima: comprar en el bid y vender en el ask 60 segundos después, suponiendo (con generosidad, en los tres casos por igual) que la salida se ejecuta. Con el modelo por toque gana 0,39 pb por operación; con el de cola, pierde 4,40. El mismo código, los mismos datos y la misma salida: solo cambia la regla de entrada, y la estrategia pasa de ganar a perder. La figura de la cabecera lo resume en dos ejes, la probabilidad de ejecución y el resultado de cada ejecución.

¿Arregla el sesgo una probabilidad de fill, como el prob_fill_on_limit de NautilusTrader (lección 2.4.5)? Se puede comprobar: ejecutar al azar el 44 % de los toques, la misma proporción que da el modelo por cola (sobre todas las órdenes, el 38,9 %).

rng = np.random.default_rng(2028)
p_cola = fills["cola"].notna().mean()
azar = fills[fills["toque"].notna()
             & (rng.random(len(fills)) < p_cola)]
a = a_los(ask, azar["toque"], 60)
m = a_los(medio, azar["toque"], 60)
print(f"fills: {len(azar) / len(fills):.1%}")
print(f"markout 60 s: {(1e4 * (m / azar['precio'] - 1)).mean():.2f} pb")
print(f"ida y vuelta: {(1e4 * (a / azar['precio'] - 1)).mean():.2f} pb")

fills: 38.9%
markout 60 s: -0.50 pb
ida y vuelta: 0.47 pb

No lo arregla: el ida y vuelta sigue en +0,47 pb, frente a los −4,40 del modelo por cola. La probabilidad ajusta cuántas órdenes se ejecutan, pero las elige al azar entre los toques, que son las buenas y las malas mezcladas. Las reales son las malas. Para una estrategia que vive de limitadas, la probabilidad de fill aleatoria es mejor que nada para el número de operaciones y casi nada para el resultado.

Fills parciales: participar en el volumen

Una orden grande no se ejecuta en una barra. La forma habitual de modelarlo es un límite de participación: en cada barra se ejecuta como mucho una fracción del volumen negociado (aquí, el 10 %) y el resto espera a la siguiente. Con las barras de KAPA, para cada una de las 1.003 sesiones, una compra que empieza a las 10:00 y se ejecuta al cierre de cada barra:

barras = pd.read_parquet("indice2_5min.parquet")
ny = barras["ts"].dt.tz_convert("America/New_York")
barras["dia"], barras["hora"] = ny.dt.date, ny.dt.strftime("%H:%M")


def participar(sesion, total, part=0.10, inicio="10:00"):
    s = sesion[sesion["hora"] >= inicio]
    llegada = s["apertura"].iloc[0]          # precio de decisión
    resto, gasto, n = total, 0.0, 0
    for b in s.itertuples():
        q = min(resto, int(part * b.volumen))
        gasto, resto, n = gasto + q * b.cierre, resto - q, n + 1
        if resto == 0:
            break
    medio = gasto / (total - resto)
    return n, resto > 0, 1e4 * (medio / llegada - 1)


tabla = {}
for total in [50_000, 500_000, 2_000_000, 10_000_000]:
    r = pd.DataFrame([participar(g, total)
                      for _, g in barras.groupby("dia")],
                     columns=["barras", "incompleta", "desl_pb"])
    tabla[f"{total:,}"] = {
        "barras_mediana": r["barras"].median(),
        "incompleta_pct": 100 * r["incompleta"].mean(),
        "desl_medio_pb": r["desl_pb"].mean(),
        "desl_desv_pb": r["desl_pb"].std()}
pd.DataFrame(tabla).T.round(2)

            barras_mediana  incompleta_pct  desl_medio_pb  desl_desv_pb
50,000                 1.0             0.0           0.59         12.62
500,000                6.0             0.0           0.75         18.21
2,000,000             31.0             0.0           1.42         30.36
10,000,000            72.0            98.4           3.23         48.43

Con 50.000 acciones la orden cabe en una barra; con dos millones tarda una mediana de 31 barras, dos horas y media, y con diez millones no se completa en el día en el 98 % de las sesiones. El deslizamiento medio frente al precio de llegada es pequeño y positivo (KAPA sube en la muestra: comprar más tarde sale algo más caro), pero su desviación típica crece con el tiempo de ejecución, de 13 a 48 pb. Repartir una orden reduce el impacto, pero la expone al mercado mientras se ejecuta: el coste se convierte en riesgo.

Un aviso sobre estos datos: los precios de KAPA no reaccionan a la orden simulada, como no reacciona ningún histórico. El modelo de participación decide cuánto y cuándo se ejecuta; el impacto que esas compras habrían causado hay que sumarlo aparte, con la ley de la raíz cuadrada de la lección 2.4.7. Y si una estrategia solo funciona con órdenes que necesitan días para ejecutarse, el problema no es el modelo de fill: es su capacidad (lección 2.2.3).

Stops y huecos

Un stop es una orden de mercado dormida (lección 1.1.4): cuando el precio llega al disparo, se ejecuta al primer precio disponible. Dentro de una sesión continua ese precio está cerca del disparo. Entre sesiones no: si el precio abre por debajo de un stop de venta, la primera operación es la apertura, y la orden se ejecuta ahí. El modelo optimista, que ejecuta siempre al precio del stop, regala la diferencia.

Con KAPA: cada día se compra al cierre y se protege la posición con un stop de venta a un porcentaje del cierre. La ejecución honrada es la apertura si la sesión abre por debajo del stop, y el stop en otro caso (en estas barras la apertura de cada barra es el cierre de la anterior, así que dentro de la sesión no hay huecos):

diario = barras.groupby("dia").agg(
    apertura=("apertura", "first"), minimo=("minimo", "min"),
    cierre=("cierre", "last"))
diario["cierre_previo"] = diario["cierre"].shift()
diario = diario.dropna()

filas, huecos_1pct = [], None
for pct in [0.005, 0.01, 0.015, 0.02]:
    stop = (diario["cierre_previo"] * (1 - pct)).round(2)
    dispara = diario["minimo"] <= stop
    hueco = diario["apertura"] <= stop
    ejecucion = diario["apertura"].where(hueco, stop)
    desl = 1e4 * (stop - ejecucion) / stop
    filas.append({"stop_pct": 100 * pct, "disparos": dispara.sum(),
                  "en_hueco": hueco.sum(),
                  "desl_medio_hueco_pb": desl[hueco].mean(),
                  "desl_max_pb": desl.max(),
                  "coste_total_pb": desl.sum()})
    if pct == 0.01:
        huecos_1pct = diario[hueco].assign(stop=stop, desl_pb=desl)
pd.DataFrame(filas).set_index("stop_pct").round(1)

          disparos  en_hueco  desl_medio_hueco_pb  desl_max_pb  coste_total_pb
stop_pct
0.5            565       122                 27.9        138.1          3405.5
1.0            277        18                 27.9         88.5           502.2
1.5            127         4                 19.1         38.0            76.6
2.0             52         0                  NaN          0.0             0.0

Con un stop al 1 %, 18 de los 277 disparos llegan en un hueco, y en esos el modelo optimista se ahorra una media de 28 pb por operación; en el peor (18 de mayo de 2022) son 88 pb. Cuanto más cerca está el stop, más disparos hay en hueco. Un stop al 2 % no se salta nunca en estos datos, pero la cola de los huecos de un ETF sobre un índice es corta; en una acción individual, el día después de unos resultados, el hueco puede ser de varias veces el stop (lección 1.1.4, el hueco del 5,1 % de NOVA).

huecos_1pct.sort_values("desl_pb", ascending=False)[
    ["cierre_previo", "stop", "apertura", "desl_pb"]].head(4).round(2)

            cierre_previo    stop  apertura  desl_pb
dia
2022-05-18         243.12  240.69    238.56    88.50
2023-12-22         366.15  362.49    360.05    67.31
2024-02-29         372.71  368.98    366.62    63.96
2025-03-27         365.66  362.00    359.89    58.29

Hay una segunda trampa con stops sobre barras: si en la misma barra caen el stop y el objetivo de beneficio, la barra no dice cuál se tocó primero. La regla prudente es suponer que el stop (la pérdida) fue primero. NautilusTrader recorre cada barra en el orden apertura, máximo, mínimo, cierre, o con bar_adaptive_high_low_ordering=True, primero el extremo más cercano a la apertura (lección 2.4.5): las dos son convenciones, no información.

Qué modelo usar

flowchart TB
  O{Tipo de orden} --> M[Mercado]
  O --> L[Limitada]
  O --> S[Stop]
  M --> MP[Precio y costes]
  L --> D{Datos de libro}
  D -- L3 --> CE[Cola exacta]
  D -- L2 y cinta --> CA[Cola aproximada]
  D -- barras --> CR[Por cruce]
  S --> HA[Apertura en hueco]

La regla general es elegir el modelo pesimista que los datos permitan y comprobar cuánto cambia el resultado con el optimista. Si la estrategia solo funciona con el optimista, no funciona. En el registro de experimentos (lección 2.2.4), el modelo de fill va junto a los costes: dos backtests con distinto modelo son dos experimentos distintos.

Ejercicios

1. Repite el estudio de los tres modelos para ventas limitadas en el mejor ask (lado == "ask", ejecución con operaciones a ese precio o más). ¿Se mantiene la conclusión?

mejor_ask = l2[(l2["nivel"] == 1) & (l2["lado"] == "ask")]
mejor_ask = mejor_ask[mejor_ask["ts"].between(
    "2025-06-02 13:35", "2025-06-02 19:50")]
bid = cot.set_index("ts")["bid"]
res = {"toque": [], "cola": []}
for foto_l2 in mejor_ask.itertuples():
    p, delante = foto_l2.precio, foto_l2.tamano
    cinta = tramo(op, foto_l2.ts, foto_l2.ts + H)
    libro = tramo(con_libro, foto_l2.ts, foto_l2.ts + H)
    toque = cinta.loc[cinta["precio"] >= p, "ts"].min()
    cruce = libro.loc[libro["precio"] > p, "ts"].min()
    en_p = libro["tamano"].where(libro["precio"] == p, 0).cumsum()
    cola = libro.loc[en_p >= delante + TAM, "ts"].min()
    cola = min([t for t in [cola, cruce] if pd.notna(t)],
               default=pd.NaT)
    for modelo, t in [("toque", toque), ("cola", cola)]:
        if pd.notna(t):
            b = a_los(bid, pd.Series([t]), 60)[0]
            # vende en el ask, recompra en el bid
            res[modelo].append(1e4 * (p - b) / p)
for modelo, v in res.items():
    print(f"{modelo:6} p_fill {len(v) / len(mejor_ask):.1%}",
          f"· ida y vuelta 60 s {np.mean(v):.2f} pb")

toque  p_fill 84.9% · ida y vuelta 60 s 0.88 pb
cola   p_fill 43.1% · ida y vuelta 60 s -4.20 pb

2. En el estudio de los stops, calcula el coste total del modelo optimista en USD para una posición de 1.000 acciones con el stop al 1 %, y compáralo con lo que costaría una comisión de 1 USD por orden en los 277 disparos.

desl_usd = 1000 * (huecos_1pct["stop"] - huecos_1pct["apertura"])
print(f"deslizamiento escondido: {desl_usd.sum():,.0f} USD",
      f"en {len(huecos_1pct)} huecos")
print(f"comisiones de 277 ventas a 1 USD: {277 * 1:,} USD")

deslizamiento escondido: 15,940 USD en 18 huecos
comisiones de 277 ventas a 1 USD: 277 USD

3. Un compañero presenta una estrategia de reversión a la media en barras diarias que compra con limitadas un 1 % por debajo del cierre y vende al cierre siguiente, con ejecución «si el mínimo del día toca el precio». ¿Qué tres cambios le pedirías en el backtest antes de discutir el resultado?