AutoML voor systematische handelspijplijnen

Deze blog heeft veel aandacht besteed aan hoe te zoeken: welke sampler je moet gebruiken en wanneer (de crossover is eval cost), hoe je de door jou uitgevoerde zoekopdracht moet prijzen (de Deflated Sharpe Ratio), hoe je de selectieprocedure zelf kunt scoren (PBO), en waar dat hele apparaat eerlijk terechtkomt (geen robuuste voorsprong).

Wat het nooit heeft behandeld, is waar u over naar zoekt. Deze artikelen nemen allemaal de functieset en de strategiefamilie als gegeven en optimaliseren de parameters daarin. AutoML valt de bovenstaande laag aan: het automatiseert de constructie van de kandidaten zelf. Drie delen daarvan verschijnen nergens anders op deze blog:

1. Geautomatiseerde extractie van kenmerken — tsfresh zet één prijsreeks om in ~794 statistisch gekarakteriseerde kenmerken, en Featuretools stelt kenmerken samen uit gerelateerde markttabellen via Deep Feature Synthesis.
2. Budgetbewuste AutoML: FLAML's kostenbesparende optimalisatie, die het beste model binnen een computerbudget vindt in plaats van ongeacht de kosten.
3. De formule-alfafabriek — WorldQuant's 101 formule-alfa's als een samenstelbare operatorgrammatica die een machine kan opsommen.

Al het andere – objectieve functie, validatieschema, meervoudige testcorrectie – wordt hier al elders gemeten, dus dit artikel linkt in plaats van opnieuw te leren. Dat is belangrijker dan normaal, omdat AutoML het aantal proefversies doet exploderen, en het aantal proefversies is precies waar de rest van de boog over gaat.

Wat AutoML automatiseert

AutoML is geen enkel algoritme. Het is een familie van technieken die verschillende fasen van de pijplijn automatiseren:

Het uitgangspunt is dat bij systematische handel de ruimte voor kandidaten enorm is: één enkele OHLCV-serie genereert honderden technische kenmerken, en meerdere activa, orderboekgegevens en alternatieve bronnen maken deze combinatorisch. Het uitgangspunt is ook het gevaar: elke kandidaat is een beproeving, en beproevingen zorgen voor valse ontdekkingen.

Eén AutoML-specifiek punt over de doelstelling: de metriek die door de zoekopdracht wordt gemaximaliseerd, moet de financiële waarde zijn, omdat de zoekopdracht precies zal optimaliseren wat u hebt opgeschreven en niets wat u bedoelde. Welke scalair u kiest, selecteert stilletjes uw strategie - zie Objective-Function Design, waar een naïeve Sharpe per transactie een loterij met een blootstelling van minder dan 5% bekroont in 56% van de 600 zaden en een Sharpe in de steekproef van 21 plaatst, die instort tot 0,13 buiten de steekproef. Verbind de financiële meetgegevens vanaf het begin met de AutoML-scorer; niet optimaliseren roc_auc en hopen dat het wordt overgedragen.

Geautomatiseerde functie-engineering

Functie-engineering is waar de meeste alfa leeft. Ruwe prijsgegevens zijn voor iedereen hetzelfde. De transformatie van die gegevens in voorspellende signalen is wat winstgevende strategieën onderscheidt van ruis.

tsfresh: van één prijsserie tot meer dan 800 functies

tsfris (Time Series Feature Extraction gebaseerd op schaalbare hypothesetests) is speciaal gebouwd voor time series feature-extractie. Het berekent 63 karakteriseringsmethoden die standaard worden uitgebreid naar ~794 functies, waaronder:

• Statistische momenten (gemiddelde, variantie, scheefheid, kurtosis)
• Autocorrelatie bij meerdere vertragingen
• Fouriercoëfficiënten en spectrale energie
• Complexiteitsmetingen (geschatte entropie, monsterentropie)
• Niet-lineaire kenmerken (Friedrich-coëfficiënten, max. Langevin-vast punt)
• Verander kwantielen en bereiktellingen

Voor financiële gegevens betekent dit dat één enkele prijsreeks honderden kandidaat-functies oplevert; veel daarvan vangen dynamiek op die handmatige feature-engineering zou missen. Dit is een wezenlijk andere benadering dan de handgemaakte, domein-afgeleide functiesets die worden gebruikt in spread modeling en DeepLOB: daar besluit een mens dat de onbalans in het orderboek ertoe doet; hier somt een bibliotheek alles op en laat een hypothesetest beslissen.

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

De select_features -functie past een Benjamini-Yekutieli-procedure toe om het aantal valse ontdekkingen over de hele functiebatterij te controleren – wat het juiste instinct is, en hetzelfde instinct dat het [Deflated Sharpe-artikel] (/en/blog/post/deflated-sharpe-multiple-testing) toepast op strategiezoekopdrachten. Merk op wat het niet doet: FDR-controle bij de functieselectiestap zegt niets over de proefkosten van de modelzoekopdracht die daarop volgt. Dat zijn twee afzonderlijke veelvouden en beide moeten worden betaald.

Featuretools: diepgaande featuresynthese

Terwijl tsfresh zich richt op de karakterisering van tijdreeksen, is Featuretools blinkt uit in relationele feature-engineering: het construeren van features door primitieve bewerkingen over gerelateerde tabellen samen te stellen.

Voor handelen is dit krachtig als u gegevens uit meerdere tabellen heeft: handelsgeschiedenis, momentopnamen van orderboeken, financieringspercentages en on-chain-statistieken. Featuretools past Deep Feature Synthesis (DFS) toe, die transformatie- en aggregatieprimitieven stapelt:

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

De time_index declaratie is dragend: hierdoor kan Featuretools aggregaties berekenen met alleen rijen die bestonden op de grens. Als je het mis hebt, zal DFS graag een functie uit de toekomst bouwen: de relationele gegevensinstantie van de lekken die zijn gecatalogiseerd in de look-ahead bias-taxonomie.

De combinatie van tsfresh (karakterisering van tijdreeksen) en Featuretools (relationele synthese) geeft u een functiefabriek die duizenden kandidaatsignalen produceert uit ruwe marktgegevens zonder handmatige indicatorcodering.

Budgetbewuste AutoML: FLAML

We gaan uit van Optuna en boomgestructureerde Parzen-schatters als achtergrond; de afleiding, de vergelijking van de samplers en de benchmark staan in [Coördinatie van afdaling versus Bayesiaanse optimalisatie] (/en/blog/post/optuna-vs-coördinaat-afdaling). Op welke sampler je moet gebruiken, is de eigen meting van deze blog de referentie en het is niet het folkloristische antwoord: de crossover wordt bepaald door de evaluatiekosten, niet door de slimheid van het algoritme - wanneer een backtest bijna gratis is, wint de gecodeerde Sobol op doorvoer (~2.830 cfg/s tegen ~154 voor TPE), en alleen dure evaluaties maken de monsterefficiëntie lonend (Random vs Smart Zoeken).

Die framing maakt FLAML tot een andere as dan tot een concurrerende sampler. Optuna vraagt ​​waar we de volgende keer kunnen proeven; FLAML (Fast Lightweight AutoML) vraagt ​​wat kan ik me überhaupt veroorloven om te samplen. Het optimaliseert voor het beste model binnen een tijds- of rekenbudget met behulp van CFO (Cost-Frugal Optimization), die in een vroeg stadium prioriteit geeft aan goedkoop te evalueren configuraties en alleen escaleert wanneer de geschatte marginale winst de uitgaven rechtvaardigt.

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)

Het voordeel van FLAML voor de handel is de rekentoewijzing over heterogene modeltypen. Als LightGBM-configuraties 10x sneller evalueren dan CatBoost, onderzoekt FLAML vroegtijdig meer LightGBM en schakelt alleen over als de marginale verbetering de kosten rechtvaardigt. Dat is het goedkope-regime-inzicht uit het crossover-artikel, gegeneraliseerd: doorvoer is een eersteklas term in het zoekbudget, geen implementatiedetail.

Het trajectlogboek is het onderdeel dat de moeite waard is om bij te houden. get_output_from_log geeft u de volledige configuratiegeschiedenis, wat uw proeftelling is - en de proeftelling is de input voor elke deflatie die u op het punt staat verschuldigd te zijn.

Neurale architectuur Zoeken naar handelsmodellen

Neural Architecture Search automatiseert het ontwerp van netwerktopologieën in plaats van het afstemmen van een vaste topologie. De architectuurkeuze voor financiële reeksen ligt werkelijk niet voor de hand – niet-stationariteit, lage signaal-ruisverhouding, gemengde frequenties en afhankelijkheden van minuten tot maanden trekken allemaal in verschillende richtingen – maar die motivatie wordt elders al concreet beargumenteerd: zie Temporal Fusion Transformer over wanneer TFT verslaat LSTM verslaat vanilla Transformer, en DeepLOB over de afweging tussen CNN+Inception+LSTM, voor wat zorgvuldig met de hand ontworpen vaste architecturen al bereiken. NAS is het argument dat deze keuze zelf gezocht moet worden.

Onderzoek naar Neuroevolution NAS voor voorspelling van aandelenrendement meldt dat RNN's die zijn geëvolueerd via EXAMM (Evolutionary eXploration of Augmenting Memory Models) beter presteerden dan de DJI en S&P 500 in zowel bear- (2022) als bull-markten (2023) met behulp van eenvoudige long-short-strategieën. Beschouw dat als een claim van een derde partij, en niet als resultaat dat hier wordt weergegeven – het is een best-of-search-cijfer waarin geen deflatie wordt gerapporteerd.

NAS Zoekruimte voor handel

Een praktische NAS-zoekruimte voor handelsmodellen omvat:

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}

Met NNI (Neural Network Intelligence) van Microsoft kunt u deze ruimte definiëren en doorzoeken:

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)

Het zoekalgoritme (ENAS, DARTS of evolutionair) evalueert kandidaat-architecturen op basis van een validatieset met behulp van een financiële doelstelling, en beperkt zich vervolgens geleidelijk tot goed presterende topologieën. Let op de kostenasymmetrie ten opzichte van al het andere in dit artikel: NAS bevindt zich aan het uiterste dure uiteinde van de evaluatie-kostenas, wat het enige regime is waarbij monsterefficiënte samplers en multi-fidelity-snoei zichzelf echt terugbetalen.

De WorldQuant Alpha Factory-aanpak

WorldQuant's benadering van alpha-ontdekking is de meest industriële implementatie van AutoML-principes in de financiële wereld. WorldQuant, opgericht door Igor Tulchinsky, exploiteert wat zij een ‘alfafabriek’ noemen: een systematisch proces voor het genereren, testen en combineren van miljoenen voorspellende signalen.

Filosofie: exponentiële alfageneratie en de correctie ervan

WorldQuant stelde zich in 2010 ten doel één miljoen alfa's te bereiken, in een tijd waarin ze slechts enkele duizenden per jaar produceerden. In 2016 hebben ze dat doel bereikt. De filosofie berust op de fundamentele wet van actief beheer:

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

waar $IR$ is de informatieverhouding, $IC$ de informatiecoëfficiënt, en $BR$ de breedte — het aantal onafhankelijke weddenschappen. Elk individu $\alpha_i$ is een zwakke voorspeller; de bewering is dat het combineren van voldoende zwak gecorreleerde kleine IC's kleine IC's samenvoegt tot een betekenisvol risicogecorrigeerd rendement.

De correctie die dit maakt of breekt, en die de naïeve lezing van de formule verbergt: breedte is niet het aantal proeven. $BR$ telt onafhankelijke weddenschappen, en gegenereerde alfa's zijn niet onafhankelijk: ze zijn samengesteld uit dezelfde operators over dezelfde prijs- en volumevelden, dus erven ze elkaars correlatiestructuur. Deze blog heeft het effect rechtstreeks gemeten in Signal Correlation: effectieve breedte is $N_{eff} = N / C_f$, en met een typische crypto-correlatiefactor $C_f \approx 3$, tien signalen zijn ongeveer 3,3 onafhankelijke signalen waard. De $\sqrt{BR}$ de termijn groeit niet mee met het aantal alfa's dat u heeft gegenereerd; het groeit met het aantal niet-gecorreleerde overlevenden. Met een miljoen gecorreleerde alfa's koopt u veel minder dan de formule adverteert.

Dit is de reden waarom stap 3 hieronder – decorrelatie met de bestaande bibliotheek – geen hygiënestap is in de alpha-fabriek. Het is de stap die in de eerste plaats de breedte oplevert.

De 101 formule-alfa's

Het artikel "101 formule-alfa's" van Kakushadze (geassocieerd met WorldQuant-onderzoek) publiceerde een reeks formule-alfa-expressies - wiskundige uitdrukkingen over prijs, volume en fundamentele gegevens:

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

Wat dit interessant maakt voor AutoML is dat het een grammatica is. De alfa's zijn composities van een kleine operatorset (rank, delta, ts_rank, stddev, correlation, signedpower) over een kleine veldset (close, volume, vwap, returns, adv20). Een grammatica is opsombaar, wat betekent dat de zoekruimte machinaal kan worden gegenereerd op een manier die 'denk aan een goede eigenschap' niet mogelijk is. Een AutoML-systeem kan:

1. Genereer kandidaat-expressies door operatoren voor gegevensvelden samen te stellen
2. Evalueer de IC, omzet en opname van elke expressie
3. Filter voor expressies die statistische tests overleven en voldoende ongecorreleerd zijn met de bestaande bibliotheek
4. Combineer de overlevenden in een portefeuille

Merk op dat de stappen 1 en 2 de makkelijke zijn en dat stap 3 de waarde is - zie de breedtecorrectie hierboven.

LLM-verbeterde alfadetectie

WorldQuant is begonnen met het integreren van grote taalmodellen in de alfafabriek. Zoals gerapporteerd in de financiële pers, onderzoekt het bedrijf hoe LLM's 'alfa's in verschillende domeinen kunnen transformeren en ontdekken' - door nieuwe uitdrukkingen te genereren, onderzoekspapers te vertalen in toetsbare hypothesen en domeinoverschrijdende relaties aan het licht te brengen die bij een puur enumeratieve zoektocht over het hoofd zouden worden gezien. Dit is een ander mechanisme dan het extraheren van signalen uit tekst, waarover deze blog gaat in LLM Alpha Mining on Earnings Calls; hier schrijft de LLM de formule, niet de functie.

Bouw je eigen mini-alfafabriek

Hier is een compacte maar functionele alfafabriek over de operatorgrammatica:

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

Zes sjablonen over vijf vensters is een sweep van 30 configuraties. Het rapport dat het produceert heeft deze schematische vorm: de velden zijn wat de fabriek uitzendt, en er zijn geen cijfers ingevuld omdat er hier geen zijn gemeten:

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

De ruwe Sharpe van de top alpha uit een sweep van 30 configuraties is geen resultaat – het is het maximum van 30 trekkingen, en op 1.000 zero-edge strategieën is de beste Sharpe op jaarbasis gemiddeld 1,63, terwijl de naïeve test 100% van de tijd een ontdekking meldt (Deflated Sharpe Ratio). Het eerlijke resultaat van een fabriek is daarom niet "we hebben een alfa gevonden" maar hoeveel alfa's de deflatie hebben overleefd: de IC-verdeling, het aantal proeven, de DSR van de winnaar ten opzichte van dat aantal, en de PBO van de selectie. Dat is de maatstaf die deze sectie nog steeds verschuldigd is.

Vangrails: wat je al verschuldigd bent

AutoML versterkt ontdekking en overfitting in gelijke mate, en doet dit bij de proeftellingen waar het verschil niet langer subtiel is. Elk van deze wordt elders diepgaand behandeld; het punt hier is dat AutoML ze allemaal verplicht maakt in plaats van raadzaam.

Bepaal de zoekopdracht, corrigeer deze niet alleen. Een feature-model-hyperparameter sweep is een proeftelling en de proeftelling verplaatst de lat — zie The Deflated Sharpe Ratio.

Tijdelijk valideren, met opschonen en embargo. Zie Walk-Forward Optimization en de Look-Ahead Bias Taxonomy voor de lekken die een naïeve temporele splitsing overleven.

Beoordeel de procedure, niet alleen de winnaar. Zie Kans op backtest-overfitting, en voer de dragende correctie uit: PBO's nul is 0,5, niet 1 — de helft is niet 'half overfit', het is volledig overfit, een muntje.

Kijk uit naar pieken die er niet zijn. Door efficiënt te zoeken op een door ruis gedomineerd oppervlak worden sneller scherpere illusies gevonden (Plateau Analysis); dit bijt het hardst op strategieparameters en het minst op ML-hyperparameters, wat het geval is waar FLAML en Optuna feitelijk voor zijn gebouwd.

Beperk de zoekruimte. Minimale bladmonsters, maximale diepte en aantal schatters, een functiebudget, een omzetboete – het regulariseren van de zoekopdracht is goedkoper dan deze achteraf leeg te laten lopen.

Conclusie

AutoML tilt de automatisering een niveau hoger: van het afstemmen van parameters binnen een vaste kandidaat tot het genereren van de kandidaten zelf. Drie componenten zijn de moeite waard: tsfresh en Featuretools voor het genereren van functies, FLAML's kostenbesparende zoektocht naar budgetbewuste modelselectie, en de formule-operatorgrammatica voor de constructie van optelbare alfa. NAS wordt zijn rekenkracht alleen waard als uw signaal-ruisverhouding dit rechtvaardigt, en hij bevindt zich aan de dure kant van de evaluatie-kostenas, waar monsterefficiëntie uiteindelijk loont.

Het WorldQuant-breedteargument overleeft het contact met de eigen metingen van deze blog alleen in de gecorrigeerde vorm: $IR \approx IC\sqrt{BR}$ waar $BR$ telt onafhankelijke weddenschappen, en de productie van een fabriek is lang niet onafhankelijk. Het genereren van een miljoen alfa's is de makkelijke helft. Vaststellen dat ze voldoende ongecorreleerd zijn om als breedte te tellen, is de helft die bepaalt of de formule iets betekent.

En het eerlijke voorbehoud is geen moraal, het is een gemeten resultaat. Deze blog leidde de zoek-en-overfit-boog tot zijn conclusie in The Honest Negative: tienduizenden backtests over vijf majors, DSR = 0,00 bij ~37.000 tests, PBO 0,264 en 0,327, en geen robuust voordeel. AutoML verhoogt het aantal proefversies met ordes van grootte. Wat het ook vindt, het zal een overeenkomstig grotere deflatie te danken hebben – en de bruikbare output van een alfafabriek is het overlevingspercentage na die deflatie, niet de bovenste regel ervoor.