AutoML para canalizaciones de trading sistemático

Este blog ha dedicado un largo recorrido a cómo buscar: qué muestra usar y cuándo (el cruce es el costo de evaluación), cómo fijar el precio de la búsqueda que realizó (el índice de Sharpe deflactado), cómo calificar el procedimiento de selección en sí (PBO), y dónde aterriza honestamente todo ese aparato (sin ventaja robusta).

Lo que nunca ha cubierto es lo que buscas sobre. Todos esos artículos toman el conjunto de características y la familia de estrategias tal como se proporcionan y optimizan los parámetros dentro de ellos. AutoML ataca la capa superior: automatiza la construcción de los propios candidatos. Tres partes de eso no aparecen en ningún otro lugar de este blog:

1. Extracción automatizada de características: tsfresh convierte una serie de precios en ~794 características caracterizadas estadísticamente, y Featuretools compone características en tablas de mercados relacionadas a través de Deep Feature Synthesis.
2. AutoML compatible con el presupuesto: optimización económica y económica de FLAML, que encuentra el mejor modelo dentro de un presupuesto informático en lugar de hacerlo independientemente del costo.
3. La fábrica alfa de fórmulas: los 101 alfas de fórmula de WorldQuant como gramática de operador componible que una máquina puede enumerar.

Todo lo demás (función objetivo, esquema de validación, corrección de pruebas múltiples) ya se mide aquí en otra parte, por lo que este artículo vincula en lugar de volver a enseñar. Eso importa más de lo habitual, porque AutoML hace que el recuento de pruebas explote, y el recuento de pruebas es precisamente de lo que trata el resto del arco.

Qué automatiza AutoML

AutoML no es un algoritmo único. Es una familia de técnicas que automatizan diferentes etapas del pipeline:

La premisa es que en el comercio sistemático el espacio candidato es enorme: una única serie OHLCV genera cientos de características técnicas, y múltiples activos, datos de la cartera de pedidos y fuentes alternativas la hacen combinatoria. La premisa es también el peligro: cada candidato es una prueba, y las pruebas son las que producen descubrimientos falsos.

Un punto específico de AutoML sobre el objetivo: la métrica que maximiza la búsqueda debe ser la financiera, porque la búsqueda optimizará exactamente lo que escribiste y nada de lo que quisiste decir. El escalar que elija selecciona silenciosamente su estrategia; consulte Diseño de función objetiva, donde un ingenuo Sharpe por operación corona una lotería de exposición inferior al 5% en el 56% de 600 semillas y publica un Sharpe en la muestra de 21 que colapsa a 0,13 fuera de la muestra. Conecte la métrica financiera al goleador de AutoML desde el principio; no optimizar roc_auc y espero que se transfiera.

Ingeniería de funciones automatizada

La ingeniería de características es donde vive la mayoría de los alfa. Los datos de precios brutos son los mismos para todos. La transformación de esos datos en señales predictivas es lo que separa las estrategias rentables del ruido.

tsfresh: de una serie de precios a más de 800 funciones

tsfresco (Extracción de características de series temporales basada en pruebas de hipótesis escalables) está diseñado específicamente para la extracción de características de series temporales. Calcula 63 métodos de caracterización que se expanden a ~794 características de forma predeterminada, que incluyen:

• Momentos estadísticos (media, varianza, asimetría, curtosis)
• Autocorrelación en múltiples retrasos.
• Coeficientes de Fourier y energía espectral.
• Medidas de complejidad (entropía aproximada, entropía de muestra)
• Características no lineales (coeficientes de Friedrich, punto fijo máximo de Langevin)
• Cambiar cuantiles y recuentos de rango.

Para los datos financieros, esto significa que una única serie de precios produce cientos de características candidatas, muchas de las cuales capturan dinámicas que la ingeniería manual de características pasaría por alto. Este es un enfoque materialmente diferente de los conjuntos de características hechas a mano y derivadas de dominios utilizadas en modelado extendido y DeepLOB: allí un humano decide que el desequilibrio del libro de pedidos es importante; aquí una biblioteca lo enumera todo y deja que una prueba de hipótesis decida.

import pandas as pd
import numpy as np
from tsfresh import extract_features, select_features
from tsfresh.utilities.dataframe_functions import impute

def prepare_rolling_windows(df: pd.DataFrame, window_size: int = 20) -> pd.DataFrame:
    """Convert OHLCV DataFrame into rolling windows for tsfresh."""
    records = []
    for i in range(window_size, len(df)):
        window = df.iloc[i - window_size:i].copy()
        window["id"] = i  # window identifier
        window["time"] = range(window_size)
        records.append(window[["id", "time", "close", "volume", "high", "low"]])
    return pd.concat(records, ignore_index=True)

df_ohlcv = pd.read_csv("btc_1h.csv", parse_dates=["timestamp"])
df_rolled = prepare_rolling_windows(df_ohlcv, window_size=24)

features = extract_features(
    df_rolled,
    column_id="id",
    column_sort="time",
    n_jobs=8,  # parallel extraction
    disable_progressbar=False,
)

impute(features)

y = df_ohlcv["close"].pct_change(4).shift(-4).iloc[24:].reset_index(drop=True)
y_binary = (y > 0).astype(int)

features_selected = select_features(features, y_binary, fdr_level=0.05)
print(f"Selected {features_selected.shape[1]} features from {features.shape[1]}")

El select_features La función aplica un procedimiento de Benjamini-Yekutieli para controlar la tasa de descubrimiento falso en toda la batería de funciones, que es el instinto correcto, y el mismo instinto que el artículo de Deflated Sharpe aplica a las búsquedas de estrategias. Tenga en cuenta lo que no hace: el control FDR en el paso de selección de características no dice nada sobre el costo de prueba de la búsqueda de modelo que le sigue. Se trata de dos multiplicidades distintas y ambas deben pagarse.

Featuretools: Síntesis profunda de funciones

Mientras que tsfresh se centra en la caracterización de series temporales, Featuretools sobresale en ingeniería de características relacionales: construcción de características componiendo operaciones primitivas en tablas relacionadas.

Para el comercio, esto es poderoso cuando tiene datos de varias tablas: historial comercial, instantáneas del libro de pedidos, tasas de financiación y métricas en cadena. Featuretools aplica Deep Feature Synthesis (DFS), que apila primitivas de transformación y agregación:

import featuretools as ft

es = ft.EntitySet(id="crypto_trading")

es = es.add_dataframe(
    dataframe_name="candles",
    dataframe=df_candles,
    index="candle_id",
    time_index="timestamp",
)

es = es.add_dataframe(
    dataframe_name="orderbook",
    dataframe=df_orderbook,
    index="snapshot_id",
    time_index="timestamp",
)

es = es.add_dataframe(
    dataframe_name="funding",
    dataframe=df_funding,
    index="funding_id",
    time_index="timestamp",
)

feature_matrix, feature_defs = ft.dfs(
    entityset=es,
    target_dataframe_name="candles",
    agg_primitives=["mean", "std", "max", "min", "skew", "trend"],
    trans_primitives=["percentile", "diff", "cum_mean"],
    max_depth=2,  # compose up to 2 primitives deep
    features_only=False,
)

print(f"Generated {len(feature_defs)} features via DFS")

El time_index La declaración soporta carga: es lo que permite a Featuretools calcular agregaciones utilizando solo filas que existían en el corte. Hágalo mal y DFS estará encantado de crear una característica del futuro: la instancia de datos relacionales de las filtraciones catalogadas en la [taxonomía de sesgo anticipado] (/en/blog/post/look-ahead-bias-taxonomy).

La combinación de tsfresh (caracterización de series temporales) y Featuretools (síntesis relacional) le brinda una fábrica de funciones que produce miles de señales candidatas a partir de datos de mercado sin procesar sin codificación manual de indicadores.

AutoML consciente del presupuesto: FLAML

Asumimos los estimadores Optuna y Parzen estructurados en árbol como contexto: la derivación, la comparación de muestras y el punto de referencia se encuentran en Descenso de coordenadas frente a optimización bayesiana. Sobre qué sampler elegir, la medición de este blog es la referencia y no es la respuesta tradicional: el cruce se rige por el costo de la evaluación, no por la inteligencia del algoritmo; cuando una prueba retrospectiva es casi gratuita, el Sobol codificado gana en rendimiento (~2,830 cfg/s contra ~154 para TPE), y solo las evaluaciones costosas hacen que la eficiencia de la muestra sea rentable (Random vs Smart Buscar).

Ese encuadre es lo que hace de FLAML un eje diferente en lugar de una muestra competitiva. Optuna pregunta dónde probar a continuación; FLAML (Fast Lightweight AutoML) pregunta ¿qué puedo permitirme probar?. Optimiza para obtener el mejor modelo dentro de un presupuesto de tiempo o de cómputo mediante CFO (optimización de costos frugales), que prioriza las configuraciones económicas de evaluar desde el principio y aumenta solo cuando la ganancia marginal estimada justifica el gasto.

from flaml import AutoML
from sklearn.metrics import make_scorer
import numpy as np

def sharpe_score(y_true, y_pred):
    """Custom scorer: Sharpe ratio of predicted signals."""
    signal = np.sign(y_pred - 0.5)
    returns = signal * y_true  # y_true contains forward returns
    if returns.std() == 0:
        return 0.0
    return np.sqrt(252) * returns.mean() / returns.std()

sharpe_scorer = make_scorer(sharpe_score, greater_is_better=True)

automl = AutoML()
automl_settings = {
    "time_budget": 300,          # 5 minutes
    "metric": sharpe_scorer,     # optimize the financial objective, not accuracy
    "task": "classification",
    "estimator_list": [
        "lgbm", "xgboost", "rf", "extra_tree", "catboost",
    ],
    "eval_method": "cv",
    "split_type": "time",        # time series split (no future leakage)
    "n_splits": 5,
    "log_file_name": "flaml_trading.log",
    "seed": 42,
}

automl.fit(
    X_train=X_train,
    y_train=y_train,
    **automl_settings,
)

print(f"Best model: {automl.best_estimator}")
print(f"Best config: {automl.best_config}")

from flaml.data import get_output_from_log
time_history, best_valid_loss_history, valid_loss_history, config_history, metric_history = \
    get_output_from_log(filename="flaml_trading.log", time_budget=300)

La ventaja de FLAML para el comercio es la asignación informática entre tipos de modelos heterogéneos. Si las configuraciones de LightGBM se evalúan 10 veces más rápido que CatBoost, FLAML explora más LightGBM temprano y cambia solo cuando estima que la mejora marginal justifica el costo. Ésa es la idea del régimen barato del artículo cruzado, generalizada: el rendimiento es un término de primera clase en el presupuesto de búsqueda, no un detalle de implementación.

El registro de trayectoria es la parte que vale la pena conservar. get_output_from_log le brinda el historial de configuración completo, que es su recuento de prueba, y el recuento de prueba es la entrada para cada deflación que está a punto de deber.

Búsqueda de arquitectura neuronal para modelos comerciales

Neural Architecture Search automatiza el diseño de topologías de red en lugar del ajuste de una fija. La elección de la arquitectura para las series financieras realmente no es obvia: la no estacionariedad, la baja relación señal-ruido, las frecuencias mixtas y las dependencias que abarcan minutos a meses van en diferentes direcciones, pero esa motivación ya se argumenta concretamente en otra parte: ver Temporal Fusion Transformer sobre cuándo TFT vence a LSTM vence a Vanilla Transformer, y DeepLOB sobre la compensación CNN+Inception+LSTM, por lo que ya logran las arquitecturas fijas cuidadosamente diseñadas a mano. NAS es el argumento de que se debe buscar esta opción.

Investigación sobre Neuroevolución NAS para la predicción del rendimiento de acciones informa que los RNN evolucionados a través de EXAMM (eXploración evolutiva de modelos de memoria aumentada) superaron al DJI y al S&P 500 tanto en los mercados bajistas (2022) como alcistas (2023) utilizando estrategias simples a largo y corto plazo. Trátelo como una afirmación de un tercero, no como un resultado reproducido aquí: es la mejor cifra de búsqueda sin reportar deflación.

Espacio de búsqueda NAS para operaciones

Un práctico espacio de búsqueda NAS para modelos comerciales incluye:

Search Space:
  - Cell types: {LSTM, GRU, Temporal Conv, Transformer block, Linear}
  - Number of layers: [1, 8]
  - Hidden dimensions: {32, 64, 128, 256}
  - Attention heads (if Transformer): {2, 4, 8}
  - Dropout rate: [0.0, 0.5]
  - Skip connections: {True, False}
  - Normalization: {BatchNorm, LayerNorm, None}
  - Activation: {ReLU, GELU, SiLU, Mish}
  - Lookback window: {20, 60, 120, 252}

Con NNI (Neural Network Intelligence) de Microsoft, puedes definir y buscar este espacio:

import nni
from nni.nas.nn.pytorch import LayerChoice, InputChoice
import torch
import torch.nn as nn

class TradingNASModel(nn.Module):
    """NAS-searchable model for financial time series."""

    def __init__(self, input_dim: int, seq_len: int):
        super().__init__()
        self.input_proj = nn.Linear(input_dim, 128)

        self.temporal_block = LayerChoice([
            nn.LSTM(128, 128, num_layers=2, batch_first=True, dropout=0.1),
            nn.GRU(128, 128, num_layers=2, batch_first=True, dropout=0.1),
            nn.TransformerEncoder(
                nn.TransformerEncoderLayer(d_model=128, nhead=4, batch_first=True),
                num_layers=2,
            ),
        ], label="temporal_cell")

        self.head = LayerChoice([
            nn.Sequential(nn.Linear(128, 64), nn.ReLU(), nn.Linear(64, 1)),
            nn.Sequential(nn.Linear(128, 32), nn.GELU(), nn.Linear(32, 1)),
            nn.Linear(128, 1),
        ], label="prediction_head")

        self.skip = InputChoice(n_candidates=2, n_chosen=1, label="skip_conn")
        self.skip_proj = nn.Linear(input_dim, 128)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        h = self.input_proj(x)
        out = self.temporal_block(h)

        if isinstance(out, tuple):
            out = out[0]

        last = out[:, -1, :]

        skip_val = self.skip_proj(x[:, -1, :])
        last = self.skip([last, last + skip_val])

        return self.head(last).squeeze(-1)

El algoritmo de búsqueda (ENAS, DARTS o evolutivo) evalúa las arquitecturas candidatas en un conjunto de validación utilizando un objetivo financiero y luego se estrecha progresivamente hacia topologías de alto rendimiento. Tenga en cuenta la asimetría de costos frente a todo lo demás en este artículo: NAS se encuentra en el extremo más caro del eje de evaluación-costo, que es el único régimen en el que los muestreadores eficientes y la poda de fidelidad múltiple realmente se pagan por sí solos.

El enfoque de fábrica WorldQuant Alpha

El enfoque de WorldQuant para el descubrimiento alfa es la implementación a mayor escala industrial de los principios de AutoML en finanzas. Fundada por Igor Tulchinsky, WorldQuant opera lo que ellos llaman una "fábrica alfa": un proceso sistemático para generar, probar y combinar millones de señales predictivas.

Filosofía: generación alfa exponencial y su corrección

WorldQuant se fijó en 2010 el objetivo de alcanzar un millón de alfa, en un momento en el que sólo producían varios miles al año. Alcanzaron ese objetivo en 2016. La filosofía se basa en la ley fundamental de la gestión activa:

$IR \approx IC \cdot \sqrt{BR}$

dónde $IR$ es la relación de información, $IC$ el coeficiente de información, y $BR$ la amplitud: el número de apuestas independientes. cada individuo $\alpha_i$ es un predictor débil; la afirmación es que la combinación de suficientes CI débilmente correlacionados convierte a los CI pequeños en un rendimiento significativo ajustado al riesgo.

La corrección que hace o deshace esto, y que la lectura ingenua de la fórmula esconde: la amplitud no es el recuento de pruebas. $BR$ cuenta apuestas independientes y los alfa generados no son independientes: están compuestos por los mismos operadores en los mismos campos de precio y volumen, por lo que heredan la estructura de correlación de cada uno. Este blog midió el efecto directamente en Correlación de señal: la amplitud efectiva es $N_{eff} = N / C_f$, y con un factor de correlación criptográfico típico $C_f \approx 3$, diez señales valen aproximadamente 3,3 señales independientes. El $\sqrt{BR}$ el plazo no crece con la cantidad de alfas que generaste; crece con la cantidad de no correlacionados que sobrevivieron. Un millón de alfas correlacionados te permiten comprar mucho menos de lo que anuncia la fórmula.

Es por eso que el paso 3 a continuación (descorrelación con la biblioteca existente) no es un paso de higiene en la fábrica alfa. Es el paso que produce la amplitud en primer lugar.

Los 101 Alfas formulaicos

El artículo "101 fórmulas alfa" de Kakushadze (asociado con la investigación WorldQuant) publicó un conjunto de expresiones alfa formuladas: expresiones matemáticas sobre precio, volumen y datos fundamentales:

Alpha#1:  (rank(Ts_ArgMax(SignedPower(((returns < 0) ? stddev(returns, 20)
          : close), 2.), 5)) - 0.5)

Alpha#7:  ((adv20 < volume) ? ((-1 * ts_rank(abs(delta(close, 7)), 60))
          * sign(delta(close, 7))) : (-1 * 1))

Alpha#42: (rank(vwap - close) / rank(vwap + close))

Lo que hace que esto sea interesante para AutoML es que es una gramática. Los alfa son composiciones de un pequeño conjunto de operadores (rank, delta, ts_rank, stddev, correlation, signedpower) sobre un pequeño conjunto de campos (close, volume, vwap, returns, adv20). Una gramática es enumerable, lo que significa que el espacio de búsqueda se puede generar por máquina de una manera que "pensar en una buena característica" no lo es. Un sistema AutoML puede:

1. Generar expresiones candidatas componiendo operadores sobre campos de datos
2. Evaluar el IC, la rotación y la reducción de cada expresión.
3. Filtro para expresiones que sobreviven a las pruebas estadísticas y no están lo suficientemente correlacionadas con la biblioteca existente
4. Combina a los supervivientes en una cartera.

Tenga en cuenta que los pasos 1 y 2 son los fáciles y el paso 3 es donde está el valor; consulte la corrección de amplitud anterior.

Descubrimiento Alpha mejorado con LLM

WorldQuant ha comenzado a integrar grandes modelos de lenguaje en la fábrica alfa. Como se informó en la prensa financiera, la firma está explorando cómo los LLM pueden "transformar y descubrir alfas en diferentes dominios", generando expresiones novedosas, traduciendo artículos de investigación en hipótesis comprobables y sacando a la luz relaciones entre dominios que una búsqueda enumerativa pura pasaría por alto. Este es un mecanismo diferente a la extracción de señales de texto, que este blog cubre en LLM Alpha Mining on Earnings Calls; aquí el LLM escribe la fórmula, no la característica.

Construyendo tu propia mini fábrica Alpha

Aquí hay una fábrica alfa compacta pero funcional sobre la gramática del operador:

import itertools
from dataclasses import dataclass
from typing import Callable, List
import pandas as pd
import numpy as np
from scipy.stats import spearmanr

@dataclass
class Alpha:
    name: str
    expression: Callable[[pd.DataFrame], pd.Series]
    ic: float = 0.0
    turnover: float = 0.0
    sharpe: float = 0.0

def ts_rank(series: pd.Series, window: int) -> pd.Series:
    return series.rolling(window).apply(lambda x: pd.Series(x).rank().iloc[-1] / len(x))

def ts_delta(series: pd.Series, period: int) -> pd.Series:
    return series.diff(period)

def ts_std(series: pd.Series, window: int) -> pd.Series:
    return series.rolling(window).std()

def cs_rank(series: pd.Series) -> pd.Series:
    return series.rank(pct=True)

def ts_mean(series: pd.Series, window: int) -> pd.Series:
    return series.rolling(window).mean()

ALPHA_TEMPLATES = [
    ("momentum_{w}",
     lambda df, w: cs_rank(ts_delta(df["close"], w))),
    ("mean_reversion_{w}",
     lambda df, w: -cs_rank(df["close"] / ts_mean(df["close"], w) - 1)),
    ("vol_surprise_{w}",
     lambda df, w: cs_rank(df["volume"] / ts_mean(df["volume"], w))),
    ("price_vol_divergence_{w}",
     lambda df, w: cs_rank(ts_delta(df["close"], w)) * -cs_rank(ts_delta(df["volume"], w))),
    ("volatility_rank_{w}",
     lambda df, w: -cs_rank(ts_std(df["close"].pct_change(), w))),
    ("high_low_range_{w}",
     lambda df, w: cs_rank(ts_mean(df["high"] - df["low"], w) / df["close"])),
]

WINDOWS = [5, 10, 20, 60, 120]

def generate_alphas(df: pd.DataFrame, forward_returns: pd.Series) -> List[Alpha]:
    """Generate and evaluate all alpha candidates."""
    alphas = []

    for (name_tpl, expr_fn), window in itertools.product(ALPHA_TEMPLATES, WINDOWS):
        name = name_tpl.format(w=window)
        try:
            signal = expr_fn(df, window)
            signal = signal.replace([np.inf, -np.inf], np.nan)

            valid = signal.notna() & forward_returns.notna()
            if valid.sum() < 100:
                continue

            ic, _ = spearmanr(signal[valid], forward_returns[valid])
            turnover = signal.diff().abs().mean()

            ret = (signal * forward_returns).dropna()
            sharpe = np.sqrt(252) * ret.mean() / (ret.std() + 1e-9)

            alphas.append(Alpha(
                name=name,
                expression=lambda df, fn=expr_fn, w=window: fn(df, w),
                ic=ic,
                turnover=turnover,
                sharpe=sharpe,
            ))
        except Exception:
            continue

    alphas.sort(key=lambda a: abs(a.ic), reverse=True)
    return alphas

Seis plantillas en cinco ventanas es un barrido de 30 configuraciones. El informe que produce tiene esta forma esquemática: los campos son lo que emite la fábrica y no se completa ningún número porque ninguno se ha medido aquí:

SCHEMATIC — illustrative format only, not a measurement

Generated <N> alphas from <N> candidate configurations

Top by |IC|:
  <alpha_name>   IC=<±0.0xxx>   Sharpe=<±x.xxx>   Turnover=<0.0xxx>
  ...

El Sharpe bruto del alfa superior de un barrido de 30 configuraciones no es un resultado: es el máximo de 30 sorteos, y en 1.000 estrategias de borde cero el mejor Sharpe anualizado promedia 1,63, mientras que la prueba ingenua declara un descubrimiento el 100% de las veces (Deflated Sharpe Ratio). Por lo tanto, el resultado honesto de una fábrica no es "encontramos un alfa", sino cuántos alfa sobrevivieron a la deflación: la distribución de IC, el recuento de prueba, el DSR del ganador frente a ese recuento y el PBO de la selección. Ésa es la medida que aún debe este apartado.

Barandillas: lo que ya debes

AutoML amplifica el descubrimiento y el sobreajuste en igual medida, y lo hace en los recuentos de prueba donde la diferencia deja de ser sutil. Cada uno de estos se trata en profundidad en otra parte; El punto aquí es que AutoML hace que todos ellos sean obligatorios en lugar de aconsejables.

Ponle precio a la búsqueda, no te limites a corregirla. Un barrido de característica-modelo-hiperparámetro es un recuento de prueba y el recuento de prueba mueve la barra; consulta The Deflated Sharpe Ratio.

Validar temporalmente, con purga y embargo. Consulte Optimización Walk-Forward y la Taxonomía de sesgo anticipado para conocer las filtraciones que sobreviven a una división temporal ingenua.

Califique el procedimiento, no solo el ganador. Consulte Probabilidad de sobreajuste de la prueba retrospectiva y lleve a cabo su corrección de carga: El valor nulo de PBO es 0,5, no 1: la mitad no es "mitad sobreadaptada", sino completamente sobreadaptada, un lanzamiento de moneda.

Esté atento a los picos que no existen. La búsqueda eficiente en una superficie dominada por el ruido solo encuentra ilusiones más nítidas y más rápido (Análisis de Plateau); esto afecta más a los parámetros de estrategia y menos a los hiperparámetros de ML, que es el caso para el que están diseñados FLAML y Optuna.

Restringe el espacio de búsqueda. Muestras de hojas mínimas, profundidad limitada y recuentos de estimadores, un presupuesto de funciones, una penalización por rotación: regularizar la búsqueda es más barato que desinflarla después.

Conclusión

AutoML lleva la automatización a un nivel superior: desde ajustar parámetros dentro de un candidato fijo hasta generar los propios candidatos. Tres componentes merecen el esfuerzo: tsfresh y Featuretools para la generación de características, la búsqueda económica de FLAML para la selección de modelos con conocimiento del presupuesto y la gramática del operador formulaico para la construcción alfa enumerable. NAS vale la pena computar solo cuando su relación señal-ruido lo justifica, y se encuentra en el extremo costoso del eje de evaluación-costo donde finalmente vale la pena la eficiencia de la muestra.

El argumento de la amplitud de WorldQuant sobrevive al contacto con las propias mediciones de este blog sólo en su forma corregida: $IR \approx IC\sqrt{BR}$ dónde $BR$ cuenta apuestas independientes, y la producción de una fábrica no es ni de lejos independiente. Generar un millón de alfas es la parte fácil. Establecer que no están lo suficientemente correlacionados como para contar como amplitud es la mitad que determina si la fórmula significa algo.

Y la advertencia honesta no es una moraleja, es un resultado mesurado. Este blog recorrió el arco de búsqueda y sobreajuste hasta su conclusión en The Honest Negative: decenas de miles de pruebas retrospectivas en cinco especialidades, DSR = 0,00 en ~37 000 ensayos, PBO 0,264 y 0,327, y ninguna ventaja sólida. AutoML aumenta el recuento de pruebas en órdenes de magnitud. Independientemente de lo que encuentre, deberá una deflación correspondientemente mayor, y la producción útil de una fábrica alfa es la tasa de supervivencia después de esa deflación, no la línea superior antes de ella.