AutoML para pipelines de trading sistemático

Este blog passou um longo período sobre como pesquisar: qual amostrador usar e quando ([o cruzamento é o custo de avaliação](/en/blog/post/método de pesquisa-crossover-eval-cost)), como definir o preço da pesquisa que você executou (o índice de Sharpe deflacionado), como pontuar o próprio procedimento de seleção (PBO), e onde todo esse aparato pousa honestamente (sem borda robusta).

O que nunca foi abordado é o que você pesquisa sobre. Todos esses artigos consideram o conjunto de recursos e a família de estratégias como dados e otimizam os parâmetros dentro deles. O AutoML ataca a camada acima – automatiza a construção dos próprios candidatos. Três partes disso não aparecem em nenhum outro lugar deste blog:

1. Extração automatizada de recursos — tsfresh transformando uma série de preços em aproximadamente 794 recursos caracterizados estatisticamente e Featuretools compondo recursos em tabelas de mercado relacionadas por meio de Deep Feature Synthesis.
2. AutoML com foco no orçamento — Otimização econômica da FLAML, que encontra o melhor modelo dentro de um orçamento de computação, e não independentemente do custo.
3. A fábrica alfa formulaica — Os 101 Alfas Formulaicos da WorldQuant como uma gramática de operadores combináveis ​​que uma máquina pode enumerar.

Todo o resto – função objetivo, esquema de validação, correção de múltiplos testes – já foi medido em outro lugar aqui, então este artigo vincula em vez de ensinar novamente. Isso é mais importante do que o normal, porque o AutoML faz a contagem de testes explodir, e a contagem de testes é exatamente o que trata o resto do arco.

O que o AutoML automatiza

AutoML não é um algoritmo único. É uma família de técnicas que automatizam diferentes etapas do pipeline:

A premissa é que na negociação sistemática o espaço de candidatos é enorme – uma única série OHLCV gera centenas de características técnicas, e múltiplos ativos, dados da carteira de pedidos e fontes alternativas a tornam combinatória. A premissa é também o perigo: todo candidato é uma provação, e são as provações que fabricam falsas descobertas.

Um ponto específico do AutoML sobre o objetivo: a métrica que a pesquisa maximiza deve ser a financeira, porque a pesquisa otimizará exatamente o que você escreveu e nada do que você quis dizer. O escalar que você escolhe seleciona silenciosamente sua estratégia - consulte Design de função objetiva, onde um Sharpe ingênuo por negociação coroa uma loteria com exposição abaixo de 5% em 56% de 600 sementes e publica um Sharpe na amostra de 21 que cai para 0,13 fora da amostra. Conecte a métrica financeira ao marcador do AutoML desde o início; não otimize roc_auc e espero que seja transferido.

Engenharia de recursos automatizada

A engenharia de recursos é onde vive a maior parte do alfa. Os dados brutos de preços são iguais para todos. A transformação desses dados em sinais preditivos é o que separa as estratégias lucrativas do ruído.

tsfresh: de uma série de preços a mais de 800 recursos

tsfresco (Extração de recursos de série temporal baseada em testes de hipóteses escalonáveis) foi desenvolvido especificamente para extração de recursos de série temporal. Ele calcula 63 métodos de caracterização que se expandem para aproximadamente 794 recursos por padrão, incluindo:

• Momentos estatísticos (média, variância, assimetria, curtose)
• Autocorrelação em múltiplas defasagens
• Coeficientes de Fourier e energia espectral
• Medidas de complexidade (entropia aproximada, entropia amostral)
• Recursos não lineares (coeficientes de Friedrich, ponto fixo máximo de Langevin)
• Alterar quantis e contagens de intervalo

Para dados financeiros, isso significa que uma única série de preços produz centenas de recursos candidatos – muitos deles capturando dinâmicas que a engenharia manual de recursos perderia. Esta é uma abordagem materialmente diferente dos conjuntos de recursos artesanais derivados de domínio usados ​​em modelagem de propagação e DeepLOB: lá um ser humano decide que o desequilíbrio da carteira de pedidos é importante; aqui uma biblioteca enumera tudo e deixa um teste de hipótese decidir.

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]}")

O select_features A função aplica um procedimento Benjamini-Yekutieli para controlar a taxa de descoberta falsa em toda a bateria de recursos - que é o instinto correto, e o mesmo instinto que o artigo Deflated Sharpe aplica às pesquisas estratégicas. Observe o que ele não faz: o controle de FDR na etapa de seleção de recursos não diz nada sobre o custo experimental da pesquisa de modelo que o segue. Essas são duas multiplicidades distintas e ambas devem ser pagas.

Featuretools: síntese profunda de recursos

Enquanto tsfresh se concentra na caracterização de séries temporais, Featuretools é excelente em engenharia de recursos relacionais — construindo recursos compondo operações primitivas em tabelas relacionadas.

Para negociação, isso é poderoso quando você tem dados de várias tabelas: histórico de negociações, instantâneos da carteira de pedidos, taxas de financiamento e métricas na rede. Featuretools aplica Deep Feature Synthesis (DFS), que empilha primitivas de transformação e agregação:

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")

O time_index declaração é de suporte de carga: é o que permite que o Featuretools calcule agregações usando apenas linhas que existiam no corte. Se errar, o DFS terá prazer em criar um recurso do futuro - a instância de dados relacionais dos vazamentos catalogados na taxonomia de preconceito antecipado.

A combinação de tsfresh (caracterização de série temporal) e Featuretools (síntese relacional) fornece uma fábrica de recursos que produz milhares de sinais candidatos a partir de dados brutos de mercado, sem codificação manual de indicadores.

AutoML com foco no orçamento: FLAML

Assumimos estimadores Optuna e Parzen estruturados em árvore como pano de fundo - a derivação, comparação do amostrador e benchmark estão em Descida coordenada vs otimização bayesiana. Sobre qual amostrador a ser alcançado, a medição deste blog é a referência e não a resposta folclórica: o cruzamento é governado pelo custo de avaliação, não pela inteligência do algoritmo - quando um backtest é quase gratuito, o Sobol embaralhado vence no rendimento (~2.830 cfg/s contra ~154 para TPE), e apenas avaliações caras fazem a eficiência da amostra compensar (Random vs Smart Pesquisa).

Esse enquadramento é o que torna o FLAML um eixo diferente, em vez de um amostrador concorrente. Optuna pergunta onde provar a seguir; FLAML (Fast Lightweight AutoML) pergunta o que posso pagar para provar. Ele otimiza o melhor modelo dentro de um prazo ou orçamento de cálculo usando CFO (Cost-Frugal Optimization), que prioriza configurações baratas para avaliar antecipadamente e aumenta apenas quando o ganho marginal estimado justifica o 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)

A vantagem do FLAML para negociação é a alocação de computação em tipos de modelos heterogêneos. Se as configurações LightGBM forem avaliadas 10x mais rápido que CatBoost, o FLAML explora mais LightGBM antecipadamente e muda apenas quando estima que a melhoria marginal justifica o custo. Esta é a visão generalizada do artigo cruzado sobre o regime barato: rendimento é um termo de primeira classe no orçamento de pesquisa, não um detalhe de implementação.

O registro de trajetória é a parte que vale a pena guardar. get_output_from_log fornece o histórico completo de configuração, que é sua contagem de teste – e a contagem de teste é a entrada para cada deflação que você está prestes a dever.

Pesquisa de arquitetura neural para modelos de negociação

A Pesquisa de Arquitetura Neural automatiza o projeto de topologias de rede em vez do ajuste de uma topologia fixa. A escolha da arquitetura para séries financeiras não é genuinamente óbvia - não estacionariedade, baixo sinal-ruído, frequências mistas e dependências que abrangem minutos a meses, todas puxam em direções diferentes - mas essa motivação já é discutida concretamente em outro lugar: consulte Temporal Fusion Transformer sobre quando o TFT vence o LSTM vence o vanilla Transformer, e DeepLOB sobre a compensação CNN+Inception+LSTM, sobre o que arquiteturas fixas cuidadosamente projetadas à mão já alcançam. NAS é o argumento de que esta escolha deve ser pesquisada.

Pesquisa sobre Neuroevolution NAS para previsão de retorno de ações relata que os RNNs evoluídos via EXAMM (Evolutionary eXploration of Augmenting Memory Models) superaram o DJI e o S&P 500 nos mercados de baixa (2022) e alta (2023) usando estratégias simples de longo-curto. Trate isso como uma reivindicação de terceiros, e não como um resultado reproduzido aqui – é um número melhor de pesquisa sem nenhuma deflação relatada.

Espaço de pesquisa NAS para negociação

Um espaço prático de pesquisa NAS para modelos de negociação inclui:

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}

Com NNI (Neural Network Intelligence) da Microsoft, você pode definir e pesquisar este espaço:

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)

O algoritmo de busca (ENAS, DARTS ou evolutivo) avalia arquiteturas candidatas em um conjunto de validação usando um objetivo financeiro e, em seguida, restringe progressivamente as topologias de alto desempenho. Observe a assimetria de custos em relação a tudo o mais neste artigo: o NAS fica na extremidade mais cara do eixo de custo de avaliação, que é o único regime em que amostradores eficientes em amostragem e podas de multifidelidade realmente se pagam.

A abordagem da fábrica WorldQuant Alpha

A abordagem da WorldQuant para descoberta alfa é a implementação em escala industrial dos princípios do AutoML em finanças. Fundada por Igor Tulchinsky, a WorldQuant opera o que chama de “fábrica alfa” – um processo sistemático para gerar, testar e combinar milhões de sinais preditivos.

Filosofia: Geração Alfa Exponencial e Sua Correção

A WorldQuant estabeleceu como meta em 2010 atingir um milhão de alfas, numa altura em que produziam apenas alguns milhares por ano. Eles atingiram essa meta em 2016. A filosofia baseia-se na lei fundamental da gestão ativa:

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

onde $IR$ é a proporção de informações, $IC$ o coeficiente de informação, e $BR$ a amplitude — o número de apostas independentes. Cada indivíduo $\alpha_i$ é um preditor fraco; a alegação é que a combinação de fatores fracamente correlacionados em número suficiente transforma pequenos ICs em um retorno significativo ajustado ao risco.

A correção que faz ou quebra isso, e que a leitura ingênua da fórmula esconde: amplitude não é contagem experimental. $BR$ conta apostas independentes e os alfas gerados não são independentes - eles são compostos pelos mesmos operadores nos mesmos campos de preço e volume, portanto, herdam a estrutura de correlação um do outro. Este blog mediu o efeito diretamente em Correlação de sinal: a amplitude efetiva é $N_{eff} = N / C_f$, e com um fator de correlação criptográfico típico $C_f \approx 3$, dez sinais valem cerca de 3,3 sinais independentes. O $\sqrt{BR}$ o prazo não cresce com quantos alfas você gerou; cresce com quantos não correlacionados sobreviveram. Um milhão de alfas correlacionados compram muito menos do que a fórmula anuncia.

É por isso que a etapa 3 abaixo – decorrelação com a biblioteca existente – não é uma etapa de higiene na fábrica alfa. É a etapa que produz a amplitude em primeiro lugar.

Os 101 Alfas Fórmulas

O artigo "101 Alfas Fórmulas" de Kakushadze (associado à pesquisa WorldQuant) publicou um conjunto de expressões alfa estereotipadas – expressões matemáticas sobre preço, volume e dados fundamentais:

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))

O que torna isso interessante para o AutoML é que ele é uma gramática. Os alfas são composições de um pequeno conjunto de operadores (rank, delta, ts_rank, stddev, correlation, signedpower) sobre um pequeno conjunto de campos (close, volume, vwap, returns, adv20). Uma gramática é enumerável, o que significa que o espaço de busca pode ser gerado por máquina de uma forma que “pense em um bom recurso” não é. Um sistema AutoML pode:

1. Gere expressões candidatas compondo operadores em campos de dados
2. Avalie o IC, o turnover e o drawdown de cada expressão
3. Filtro para expressões que sobrevivem aos testes estatísticos e são suficientemente não correlacionadas com a biblioteca existente
4. Combine os sobreviventes em um portfólio

Observe que as etapas 1 e 2 são as mais fáceis e a etapa 3 é onde está o valor - veja a correção de amplitude acima.

Descoberta Alfa Aprimorada por LLM

A WorldQuant começou a integrar grandes modelos de linguagem na fábrica alfa. Conforme relatado na imprensa financeira, a empresa está explorando como os LLMs podem “transformar e descobrir alfas em diferentes domínios” – gerando novas expressões, traduzindo artigos de pesquisa em hipóteses testáveis ​​e revelando relações entre domínios que uma pesquisa enumerativa pura não perceberia. Este é um mecanismo diferente da extração de sinais de texto, que este blog aborda em LLM Alpha Mining on Earnings Calls; aqui o LLM escreve a fórmula, não o recurso.

Construindo sua própria mini fábrica Alpha

Aqui está uma fábrica alfa compacta, mas funcional sobre a gramática do 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 modelos em cinco janelas representam uma varredura de 30 configurações. O relatório produzido tem este formato esquemático — os campos são os que a fábrica emite e nenhum número é preenchido porque nenhum foi medido aqui:

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>
  ...

O Sharpe bruto do alfa superior de uma varredura de 30 configurações não é um resultado - é o máximo de 30 empates, e em 1.000 estratégias de borda zero o melhor Sharpe anualizado tem média de 1,63 enquanto o teste ingênuo declara uma descoberta 100% do tempo (Deflated Sharpe Ratio). O resultado honesto de uma fábrica não é, portanto, “encontramos um alfa”, mas sim quantos alfas sobreviveram à deflação: a distribuição IC, a contagem experimental, o DSR do vencedor em relação a essa contagem e o PBO da seleção. Essa é a medida que esta seção ainda deve.

Guardrails: O que você já deve

O AutoML amplifica a descoberta e o overfitting em igual medida, e faz isso nas contagens de teste, onde a diferença deixa de ser sutil. Cada um deles é abordado em profundidade em outro lugar; a questão aqui é que o AutoML torna todos eles obrigatórios, em vez de aconselháveis.

Atribua um preço à pesquisa, não apenas corrija-a. Uma varredura de hiperparâmetro de modelo de recurso é uma contagem de teste e a contagem de teste move a barra — consulte A proporção de Sharpe deflacionada.

Validar temporalmente, com eliminação e embargo. Consulte Otimização Walk-Forward e Taxonomia de preconceito look-ahead para os vazamentos que sobrevivem a uma divisão temporal ingênua.

Pontue o procedimento, não apenas o vencedor. Consulte Probabilidade de overfitting de backtest e carregue sua correção de suporte de carga: O nulo do PBO é 0,5, não 1 — metade não é "metade overfitting", é totalmente overfitting, um cara ou coroa.

Observe os picos que não existem. Pesquisar eficientemente uma superfície dominada por ruído apenas encontra ilusões mais nítidas com mais rapidez (Análise de platô); isso prejudica mais os parâmetros de estratégia e menos os hiperparâmetros de ML, que é o caso para o qual FLAML e Optuna foram criados.

Restringir o espaço de pesquisa. Amostras mínimas de folhas, profundidade limitada e contagens de estimadores, um orçamento de recursos, uma penalidade de rotatividade — regularizar a pesquisa é mais barato do que esvaziá-la posteriormente.

Conclusão

O AutoML eleva a automação a um nível superior: desde o ajuste de parâmetros dentro de um candidato fixo até a geração dos próprios candidatos. Três componentes valem o esforço: tsfresh e Featuretools para geração de recursos, a busca econômica do FLAML para seleção de modelos com foco no orçamento e a gramática de operadores estereotipados para construção alfa enumerável. O NAS só vale a pena quando sua relação sinal-ruído o justifica, e ele fica na extremidade cara do eixo de custo de avaliação, onde a eficiência da amostra finalmente compensa.

O argumento da amplitude do WorldQuant sobrevive ao contato com as medições deste blog apenas em sua forma corrigida: $IR \approx IC\sqrt{BR}$ onde $BR$ conta apostas independentes, e a produção de uma fábrica está longe de ser independente. Gerar um milhão de alfas é a metade fácil. Estabelecer que eles não estão correlacionados o suficiente para contar como amplitude é a metade que determina se a fórmula significa alguma coisa.

E a advertência honesta não é uma moral, é um resultado medido. Este blog executou o arco de busca e superajuste até sua conclusão em The Honest Negative: dezenas de milhares de backtests em cinco especialidades, DSR = 0,00 em aproximadamente 37.000 testes, PBO 0,264 e 0,327, e nenhuma borda robusta. O AutoML aumenta a contagem de testes em ordens de magnitude. Seja o que for que descubra, deverá uma deflação correspondentemente maior – e o resultado útil de uma fábrica alfa é a taxa de sobrevivência após essa deflação, e não o lucro líquido antes dela.