AutoML per pipeline di trading sistematico

Questo blog ha dedicato un lungo arco a come cercare: quale campionatore utilizzare e quando (il crossover è il costo di valutazione), come valutare la ricerca eseguita (il Deflated Sharpe Ratio), come assegnare un punteggio alla procedura di selezione stessa (PBO), e dove l'intero apparato atterra onestamente (nessun vantaggio robusto).

Ciò che non ha mai trattato è ciò che cerchi oltre. Tutti questi articoli prendono il set di funzionalità e la famiglia di strategie come dati e ottimizzano i parametri al suo interno. AutoML attacca il livello superiore: automatizza la costruzione dei candidati stessi. Tre parti di questo non compaiono da nessun'altra parte su questo blog:

1. Estrazione automatizzata delle funzionalità: tsfresh trasforma una serie di prezzi in ~794 funzionalità caratterizzate statisticamente e Featuretools compone le funzionalità nelle tabelle di mercato correlate tramite Deep Feature Synthesis.
2. AutoML budget-aware: ottimizzazione frugale dei costi di FLAML, che trova il modello migliore entro un budget di elaborazione anziché indipendentemente dal costo.
3. La fabbrica alfa formulaica: i 101 alfa formulaici di WorldQuant come grammatica operatore componibile che una macchina può enumerare.

Tutto il resto - funzione obiettivo, schema di validazione, correzione tramite test multipli - è già misurato altrove qui, quindi questo articolo si collega piuttosto che insegna nuovamente. Ciò è più importante del solito, perché AutoML fa esplodere il conteggio delle prove e il conteggio delle prove è esattamente ciò di cui tratta il resto dell'arco.

Cosa automatizza AutoML

AutoML non è un singolo algoritmo. Si tratta di una famiglia di tecniche che automatizzano diverse fasi della pipeline:

La premessa è che nel trading sistematico lo spazio candidato è enorme: una singola serie OHLCV genera centinaia di caratteristiche tecniche e molteplici asset, dati del book degli ordini e fonti alternative la rendono combinatoria. La premessa è anche il pericolo: ogni candidato è una prova, e le prove sono ciò che produce false scoperte.

Un punto specifico di AutoML sull'obiettivo: la metrica massimizzata dalla ricerca deve essere quella finanziaria, perché la ricerca ottimizzerà esattamente ciò che hai scritto e nulla di ciò che intendevi. Lo scalare che scegli seleziona silenziosamente la tua strategia: vedi Objective-Function Design, dove un ingenuo Sharpe per-trade incorona una lotteria con esposizione inferiore al 5% nel 56% di 600 seed e pubblica uno Sharpe in-sample di 21 che crolla a 0,13 fuori campione. Collega la metrica finanziaria allo strumento di valutazione AutoML fin dall'inizio; non ottimizzare roc_auc e spero che si trasferisca.

Ingegneria automatizzata delle funzionalità

L'ingegneria delle funzionalità è il luogo in cui vive la maggior parte degli alfa. I dati grezzi sui prezzi sono gli stessi per tutti. La trasformazione di tali dati in segnali predittivi è ciò che distingue le strategie redditizie dal rumore.

tsfresh: da una serie di prezzi a oltre 800 funzionalità

tsfresh (Estrazione di caratteristiche di serie temporali basata su test di ipotesi scalabili) è stato creato appositamente per l'estrazione di caratteristiche di serie temporali. Calcola 63 metodi di caratterizzazione che si espandono in circa 794 funzionalità per impostazione predefinita, tra cui:

• Momenti statistici (media, varianza, asimmetria, curtosi)
• Autocorrelazione a ritardi multipli
• Coefficienti di Fourier ed energia spettrale
• Misure di complessità (entropia approssimativa, entropia campionaria)
• Caratteristiche non lineari (coefficienti di Friedrich, punto fisso massimo di Langevin)
• Modifica quantili e conteggi degli intervalli

Per i dati finanziari, ciò significa che una singola serie di prezzi produce centinaia di funzionalità candidate, molte delle quali catturano dinamiche che la progettazione manuale delle funzionalità non potrebbe cogliere. Si tratta di un approccio sostanzialmente diverso dai set di funzionalità artigianali e derivati ​​dal dominio utilizzati in spread modeling e DeepLOB: lì un essere umano decide che lo squilibrio del registro degli ordini è importante; qui una biblioteca enumera tutto e lascia decidere un test di ipotesi.

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

IL select_features La funzione applica una procedura Benjamini-Yekutieli per controllare il tasso di false scoperte nell'intera batteria di funzionalità, che è l'istinto giusto e lo stesso istinto che l'articolo Deflated Sharpe applica alle ricerche strategiche. Nota cosa non fa: il controllo FDR nella fase di selezione delle caratteristiche non dice nulla sul costo di prova della ricerca del modello che lo segue. Queste sono due molteplicità separate ed entrambe devono essere pagate.

Strumenti di funzionalità: sintesi approfondita di funzionalità

Mentre tsfresh si concentra sulla caratterizzazione delle serie temporali, Featuretools eccelle nell'ingegneria delle funzionalità relazionali: costruendo funzionalità componendo operazioni primitive su tabelle correlate.

Per il trading, questo è potente quando si dispone di dati multi-tabella: cronologia delle transazioni, istantanee del registro degli ordini, tassi di finanziamento e parametri on-chain. Featuretools applica la Deep Feature Synthesis (DFS), che impila le primitive di trasformazione e aggregazione:

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

IL time_index La dichiarazione è portante: è ciò che consente a Featuretools di calcolare le aggregazioni utilizzando solo le righe che esistevano al momento del taglio. Se sbagli, DFS creerà felicemente una funzionalità dal futuro: l'istanza di dati relazionali delle fughe di notizie catalogate nella tassonomia dei bias look-ahead.

La combinazione di tsfresh (caratterizzazione delle serie temporali) e Featuretools (sintesi relazionale) offre una feature factory che produce migliaia di segnali candidati da dati di mercato grezzi senza codifica manuale degli indicatori.

AutoML attento al budget: FLAML

Assumiamo Optuna e gli stimatori Parzen strutturati ad albero come background: la derivazione, il confronto del campionatore e il benchmark si trovano in Coordinate Descent vs Bayesian Optimization. Su quale campionatore cercare, la misurazione di questo blog è il riferimento e non è la risposta folcloristica: il crossover è governato dal costo di valutazione, non dall'abilità dell'algoritmo - quando un backtest è quasi gratuito, Sobol criptato vince in termini di throughput (~2.830 cfg/s contro ~154 per TPE), e solo valutazioni costose rendono conveniente l'efficienza del campione (Random vs Smart Cerca).

Questa inquadratura è ciò che rende FLAML un asse diverso piuttosto che un campionatore concorrente. Optuna chiede dove campionare successivamente; FLAML (Fast Lightweight AutoML) chiede cosa posso permettermi di campionare. Ottimizza per il modello migliore entro un tempo o un budget di calcolo utilizzando CFO (Cost-Frugal Optimization), che dà priorità alle configurazioni più economiche da valutare in anticipo e aumenta solo quando il guadagno marginale stimato giustifica la spesa.

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)

Il vantaggio di FLAML per il trading è l'allocazione del calcolo tra tipi di modelli eterogenei. Se le configurazioni LightGBM vengono valutate 10 volte più velocemente di CatBoost, FLAML esplora più LightGBM in anticipo e cambia solo quando stima che il miglioramento marginale giustifichi il costo. Questa è l’intuizione sul regime economico emersa dall’articolo crossover, generalizzata: il throughput è un termine di prima classe nel budget della ricerca, non un dettaglio di implementazione.

Il registro della traiettoria è la parte che vale la pena conservare. get_output_from_log ti fornisce la cronologia completa della configurazione, che è il conteggio delle prove e il conteggio delle prove è l'input per ogni deflazione che stai per pagare.

Architettura neurale Ricerca di modelli di trading

Neural Architecture Search automatizza la progettazione delle topologie di rete anziché la messa a punto di una topologia fissa. La scelta dell'architettura per le serie finanziarie non è davvero ovvia: non stazionarietà, basso rapporto segnale-rumore, frequenze miste e dipendenze che vanno da minuti a mesi spingono in direzioni diverse, ma questa motivazione è già stata discussa concretamente altrove: vedere Temporal Fusion Transformer su quando TFT batte LSTM batte Vanilla Transformer, e DeepLOB sul compromesso CNN+Inception+LSTM, per ciò che le architetture fisse attentamente progettate a mano già ottengono. NAS è l'argomento secondo cui questa scelta dovrebbe essere cercata essa stessa.

Ricerca su Neuroevolution NAS per la previsione dei rendimenti azionari riporta che gli RNN evoluti tramite EXAMM (Evolutionary eXploration of Augmenting Memory Models) hanno sovraperformato il DJI e l'S&P 500 sia nei mercati ribassisti (2022) che rialzisti (2023) utilizzando semplici strategie long-short. Consideralo come un'affermazione di terze parti, non come il risultato riprodotto qui: è un dato migliore della ricerca senza alcuna deflazione segnalata.

Spazio di ricerca NAS per il trading

Un pratico spazio di ricerca NAS per modelli di trading include:

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) di Microsoft, puoi definire e cercare questo spazio:

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)

L'algoritmo di ricerca (ENAS, DARTS o evolutivo) valuta le architetture candidate su un set di validazione utilizzando un obiettivo finanziario, quindi si restringe progressivamente verso topologie ad alte prestazioni. Si noti l'asimmetria dei costi rispetto a tutto il resto in questo articolo: il NAS si trova all'estremità più costosa dell'asse dei costi di valutazione, che è l'unico regime in cui i campionatori efficienti in termini di campionamento e la potatura multi-fedeltà si ripagano davvero da soli.

L'approccio WorldQuant Alpha Factory

L'approccio di WorldQuant all'alpha discovery è l'implementazione su scala industriale dei principi AutoML nel settore finanziario. Fondata da Igor Tulchinsky, WorldQuant gestisce quella che chiamano una "fabbrica alfa", un processo sistematico per generare, testare e combinare milioni di segnali predittivi.

Filosofia: generazione esponenziale dell'alfa e sua correzione

WorldQuant si è posta l'obiettivo nel 2010 di raggiungere un milione di alfa, in un momento in cui ne producevano solo diverse migliaia all'anno. L’obiettivo è stato raggiunto nel 2016. La filosofia si basa sulla legge fondamentale della gestione attiva:

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

Dove $IR$ è il rapporto informativo, $IC$ il coefficiente di informazione, e $BR$ l'ampiezza: il numero di scommesse indipendenti. Ogni individuo $\alpha_i$ è un predittore debole; l’affermazione è che combinando un numero sufficiente di quelli debolmente correlati si compongono minuscoli circuiti integrati in un rendimento significativo corretto per il rischio.

La correzione che crea o distrugge questo, e che la lettura ingenua della formula nasconde: l'ampiezza non è il conteggio delle prove. $BR$ conta le scommesse indipendenti e gli alfa generati non sono indipendenti: sono composti dagli stessi operatori sugli stessi campi di prezzo e volume, quindi ereditano la struttura di correlazione l'uno dell'altro. Questo blog ha misurato l'effetto direttamente in Signal Correlation: l'ampiezza effettiva è $N_{eff} = N / C_f$e con un tipico fattore di correlazione crittografica $C_f \approx 3$, dieci segnali valgono circa 3,3 segnali indipendenti. IL $\sqrt{BR}$ il termine non cresce con il numero di alfa generati; cresce con il numero di quelli non correlati sopravvissuti. Un milione di alfa correlati ti fanno guadagnare molto meno di quanto pubblicizza la formula.

Questo è il motivo per cui il passaggio 3 riportato di seguito – decorrelazione rispetto alla libreria esistente – non è un passaggio igienico nella fabbrica alfa. È innanzitutto il passo che produce l’ampiezza.

I 101 alfa stereotipati

L'articolo "101 formule alfa" di Kakushadze (associato alla ricerca WorldQuant) ha pubblicato una serie di formule alfa - espressioni matematiche su prezzo, volume e dati fondamentali:

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

Ciò che lo rende interessante per AutoML è che si tratta di una grammatica. Gli alfa sono composizioni di un piccolo set di operatori (rank, delta, ts_rank, stddev, correlation, signedpower) su un piccolo campo impostato (close, volume, vwap, returns, adv20). Una grammatica è enumerabile, il che significa che lo spazio di ricerca è generabile dalla macchina in un modo che "pensare a una buona funzionalità" non lo è. Un sistema AutoML può:

1. Genera espressioni candidate componendo operatori sui campi dati
2. Valuta l'IC, il fatturato e il prelievo di ciascuna espressione
3. Filtro per le espressioni che sopravvivono ai test statistici e sono sufficientemente non correlate con la libreria esistente
4. Combina i sopravvissuti in un portfolio

Tieni presente che i passaggi 1 e 2 sono quelli semplici e il passaggio 3 è dove si trova il valore: vedi la correzione dell'ampiezza sopra.

LLM-Enhanced Alpha Discovery

WorldQuant ha iniziato a integrare grandi modelli linguistici nella fabbrica alfa. Come riportato dalla stampa finanziaria, l'azienda sta esplorando il modo in cui i LLM possono "trasformare e scoprire alfa in diversi domini", generando nuove espressioni, traducendo documenti di ricerca in ipotesi verificabili e facendo emergere relazioni tra domini che una pura ricerca enumerativa non potrebbe cogliere. Si tratta di un meccanismo diverso dall'estrazione di segnali dal testo, di cui questo blog tratta in LLM Alpha Mining on Earnings Calls; qui il LLM scrive la formula, non la caratteristica.

Costruisci la tua mini fabbrica Alpha

Ecco una fabbrica alfa compatta ma funzionale sulla grammatica dell'operatore:

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

Sei modelli su cinque finestre corrispondono a 30 configurazioni. Il rapporto che produce ha questa forma schematica: i campi sono ciò che emette la fabbrica e nessun numero viene compilato perché nessuno è stato misurato qui:

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

Lo Sharpe grezzo dell'alfa superiore su una scansione di 30 configurazioni non è un risultato: è il massimo di 30 estrazioni e su 1.000 strategie zero-edge il miglior Sharpe annualizzato ha una media di 1,63 mentre il test ingenuo dichiara una scoperta il 100% delle volte (Rapporto Sharpe deflazionato). Il risultato onesto di una fabbrica quindi non è "abbiamo trovato un alfa" ma quanti alfa sono sopravvissuti alla deflazione: la distribuzione dell'IC, il conteggio delle prove, il DSR del vincitore rispetto a quel conteggio e il PBO della selezione. Questa è la misura che questa sezione deve ancora.

Guardrail: quello che già devi

AutoML amplifica la scoperta e l'overfitting in egual misura, e lo fa durante i conteggi delle prove dove la differenza smette di essere sottile. Ognuno di questi è trattato in modo approfondito altrove; il punto qui è che AutoML li rende tutti obbligatori anziché consigliabili.

Prezzare la ricerca, non limitarsi a correggerla. Una scansione dell'iperparametro del modello di funzionalità è un conteggio delle prove e il conteggio delle prove sposta la barra: vedere The Deflated Sharpe Ratio.

Convalida temporaneamente, con eliminazione ed embargo. Consulta la Ottimizzazione Walk-Forward e la Tassonomia dei bias look-ahead per le fughe di notizie che sopravvivono a un'ingenua suddivisione temporale.

Dai un punteggio alla procedura, non solo al vincitore. Vedi Probabilità di Backtest Overfitting, e riporta la sua correzione portante: Il valore nullo del PBO è 0,5, non 1 — la metà non è "metà overfit", è completamente overfit, un lancio di moneta.

Fai attenzione ai picchi che non ci sono. La ricerca efficiente di una superficie dominata dal rumore trova solo illusioni più nitide più velocemente (Analisi del plateau); questo incide più duramente sui parametri della strategia e meno sugli iperparametri ML, che è il caso per cui FLAML e Optuna sono effettivamente creati.

Limitare lo spazio di ricerca. Campioni minimi di foglie, profondità limitata e conteggi degli stimatori, un budget per le funzionalità, una penalità per il fatturato: regolarizzare la ricerca è più economico che sgonfiarla in seguito.

Conclusione

AutoML sposta l'automazione a un livello superiore: dall'ottimizzazione dei parametri all'interno di un candidato fisso alla generazione dei candidati stessi. Tre componenti valgono lo sforzo: tsfresh e Featuretools per la generazione di funzionalità, la ricerca frugale di FLAML per la selezione di modelli rispettosi del budget e la grammatica degli operatori formali per la costruzione alfa enumerabile. Il NAS vale il suo calcolo solo quando il rapporto segnale-rumore lo giustifica e si trova all'estremità costosa dell'asse dei costi di valutazione dove l'efficienza del campionamento alla fine paga.

L'argomento sull'ampiezza di WorldQuant sopravvive al contatto con le misurazioni di questo blog solo nella sua forma corretta: $IR \approx IC\sqrt{BR}$ Dove $BR$ conta le scommesse indipendenti e la produzione di una fabbrica non è neanche lontanamente indipendente. Generare un milione di alfa è la metà facile. Stabilire che sono sufficientemente non correlati da poter contare come ampiezza è la metà che determina se la formula significa qualcosa.

E l’onesto avvertimento non è una morale, è un risultato misurato. Questo blog ha eseguito l'arco di ricerca e overfit fino alla sua conclusione in The Honest Negative: decine di migliaia di backtest su cinque major, DSR = 0,00 a circa 37.000 prove, PBO 0,264 e 0,327 e nessun vantaggio robusto. AutoML aumenta il numero di prove in base a ordini di grandezza. Qualunque cosa trovi, dovrà affrontare una deflazione corrispondentemente maggiore – e il risultato utile di una fabbrica alfa è il tasso di sopravvivenza dopo quella deflazione, non la linea superiore prima di essa.