AutoML pour les pipelines de trading systématique

This blog has spent a long arc on how to search: which sampler to use and when (the crossover is eval cost), how to price the search you ran (the Deflated Sharpe Ratio), how to score the selection procedure itself (PBO), and where that whole apparatus honestly lands (no robust edge).

Ce qu'il n'a jamais couvert, c'est ce que vous recherchez sur. Ces articles prennent tous l'ensemble de fonctionnalités et la famille de stratégies comme étant donnés et optimisent les paramètres qu'ils contiennent. AutoML attaque la couche supérieure : il automatise la construction des candidats eux-mêmes. Trois parties n'apparaissent nulle part ailleurs sur ce blog :

1. Extraction automatisée des fonctionnalités — tsfresh transforme une série de prix en environ 794 fonctionnalités statistiquement caractérisées, et Featuretools compose des fonctionnalités sur des tableaux de marché associés via la synthèse approfondie des fonctionnalités.
2. AutoML soucieux du budget — L'optimisation coût-frugal de FLAML, qui trouve le meilleur modèle dans le cadre d'un budget de calcul plutôt que quel que soit le coût.
3. L'usine alpha de formule — Les 101 alphas de formule de WorldQuant en tant que grammaire d'opérateur composable qu'une machine peut énumérer.

Tout le reste – fonction objectif, schéma de validation, correction de tests multiples – est déjà mesuré ailleurs ici, donc cet article établit des liens plutôt que de réenseigner. Cela compte plus que d'habitude, car AutoML fait exploser le nombre d'essais, et le nombre d'essais est précisément l'objet du reste de l'arc.

! ZXQKEEP0QXZ

Ce qu'AutoML automatise

AutoML n'est pas un algorithme unique. Il s’agit d’une famille de techniques qui automatisent différentes étapes du pipeline :

Le principe est que dans le trading systématique, l'espace candidat est énorme : une seule série OHLCV génère des centaines de fonctionnalités techniques, et de multiples actifs, données du carnet d'ordres et sources alternatives le rendent combinatoire. Cette prémisse est aussi le danger : chaque candidat est un essai, et ce sont les essais qui fabriquent de fausses découvertes.

One AutoML-specific point on the objective: the metric the search maximizes must be the financial one, because the search will optimize exactly what you wrote down and nothing you meant. Which scalar you pick silently selects your strategy — see Objective-Function Design, where a naive per-trade Sharpe crowns a sub-5%-exposure lottery in 56% of 600 seeds and posts an in-sample Sharpe of 21 that collapses to 0.13 out of sample. Wire the financial metric into the AutoML scorer from the start; do not optimize roc_auc and hope it transfers.

Ingénierie automatisée des fonctionnalités

L’ingénierie des fonctionnalités est le domaine où vit la plupart des alpha. Les données brutes sur les prix sont les mêmes pour tout le monde. La transformation de ces données en signaux prédictifs est ce qui différencie les stratégies rentables du bruit.

! ZXQKEEP0QXZ

tsfresh : d'une série à prix unique à plus de 800 fonctionnalités

tsfresh (Time Series Feature Extraction based on Scalable Hypothesis Tests) is purpose-built for time series feature extraction. It computes 63 characterization methods that expand into ~794 features by default, including:

• Moments statistiques (moyenne, variance, asymétrie, kurtosis)
• Autocorrélation à plusieurs décalages
• Coefficients de Fourier et énergie spectrale
• Mesures de complexité (entropie approximative, entropie d'échantillon)
• Caractéristiques non linéaires (coefficients de Friedrich, point fixe max de Langevin)
• Modifier les quantiles et le nombre de plages

For financial data, this means a single price series produces hundreds of candidate features — many capturing dynamics that manual feature engineering would miss. This is a materially different approach from the hand-crafted, domain-derived feature sets used in spread modeling and DeepLOB: there a human decides that order-book imbalance matters; here a library enumerates everything and lets a hypothesis test decide. For financial data, this means a single price series produces hundreds of candidate features — many capturing dynamics that manual feature engineering would miss. This is a materially different approach from the hand-crafted, domain-derived feature sets used in spread modeling and DeepLOB : there a human decides that order-book imbalance matters; here a library enumerates everything and lets a hypothesis test decide.

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

The select_features function applies a Benjamini-Yekutieli procedure to control the false discovery rate across the whole feature battery — which is the right instinct, and the same instinct the Deflated Sharpe article applies to strategy searches. Note what it does not do: FDR control on the feature-selection step says nothing about the trial cost of the model search that follows it. Those are two separate multiplicities and both have to be paid.

Featuretools : synthèse approfondie des fonctionnalités

While tsfresh focuses on time series characterization, Featuretools excels at relational feature engineering — constructing features by composing primitive operations across related tables.

Pour le trading, cela est puissant lorsque vous disposez de données multi-tables : historique des transactions, instantanés du carnet d'ordres, taux de financement et mesures en chaîne. Featuretools applique Deep Feature Synthesis (DFS), qui empile les primitives de transformation et d'agrégation : For trading, this is powerful when you have multi-table data: trade history, order book snapshots, funding rates, and on-chain metrics. Featuretools applies Deep Feature Synthesis (DFS), which stacks transformation and aggregation primitives:

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

The time_index declaration is load-bearing: it is what lets Featuretools compute aggregations using only rows that existed at the cutoff. Get it wrong and DFS will happily build a feature out of the future — the relational-data instance of the leaks catalogued in the look-ahead bias taxonomy.

La combinaison de tsfresh (caractérisation de séries chronologiques) et de Featuretools (synthèse relationnelle) vous offre une usine de fonctionnalités qui produit des milliers de signaux candidats à partir de données brutes de marché sans codage manuel des indicateurs.

AutoML soucieux du budget : FLAML

We assume Optuna and Tree-structured Parzen Estimators as background — the derivation, sampler comparison and benchmark are in Coordinate Descent vs Bayesian Optimization. On which sampler to reach for, this blog's own measurement is the reference and it is not the folklore answer: the crossover is governed by evaluation cost, not algorithm cleverness — when a backtest is nearly free, scrambled Sobol wins on throughput (~2,830 cfg/s against ~154 for TPE), and only expensive evaluations make sample efficiency pay (Random vs Smart Search).

! ZXQKEEP0QXZ

That framing is what makes FLAML a different axis rather than a competing sampler. Optuna asks where to sample next; FLAML (Fast Lightweight AutoML) asks what can I afford to sample at all. It optimizes for the best model within a time or compute budget using CFO (Cost-Frugal Optimization), which prioritizes cheap-to-evaluate configurations early and escalates only when the estimated marginal gain justifies the spend. That framing is what makes FLAML a different axis rather than a competing sampler. Optuna asks where to sample next; FLAML (Fast Lightweight AutoML) asks what can I afford to sample at all. It optimizes for the best model within a time or compute budget using CFO (Cost-Frugal Optimization), which prioritizes cheap-to-evaluate configurations early and escalates only when the estimated marginal gain justifies the spend.

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)

L'avantage de FLAML pour le trading réside dans le calcul de l'allocation entre des types de modèles hétérogènes. Si les configurations LightGBM sont évaluées 10 fois plus rapidement que CatBoost, FLAML explore davantage de LightGBM plus tôt et ne change que lorsqu'il estime que l'amélioration marginale justifie le coût. C’est l’idée générale du régime bon marché tirée de l’article croisé : le débit est un terme de premier ordre dans le budget de recherche, pas un détail de mise en œuvre.

Le journal de trajectoire est la partie qui mérite d’être conservée. ZXQKEEP0QXZ vous donne l'historique complet de la configuration, qui correspond à votre nombre d'essais - et le nombre d'essais est l'entrée de chaque dégonflage que vous êtes sur le point de devoir.

Recherche d'architecture neuronale pour les modèles commerciaux

Neural Architecture Search automates the design of network topologies rather than the tuning of a fixed one. Architecture choice for financial series is genuinely non-obvious — non-stationarity, low signal-to-noise, mixed frequencies and dependencies spanning minutes to months all pull in different directions — but that motivation is already argued concretely elsewhere: see Temporal Fusion Transformer on when TFT beats LSTM beats vanilla Transformer, and DeepLOB on the CNN+Inception+LSTM tradeoff, for what carefully hand-designed fixed architectures already achieve. NAS is the argument that this choice should itself be searched.

Research on Neuroevolution NAS for Stock Return Prediction reports that RNNs evolved via EXAMM (Evolutionary eXploration of Augmenting Memory Models) outperformed the DJI and S&P 500 in both bear (2022) and bull (2023) markets using simple long-short strategies. Treat that as a third-party claim, not as a result reproduced here — it is a best-of-search figure with no deflation reported.

Espace de recherche NAS pour le trading

Un espace de recherche NAS pratique pour les modèles de trading comprend : A practical NAS search space for trading models includes:

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}

Avec NNI (Neural Network Intelligence) de Microsoft, vous pouvez définir et rechercher cet espace : With NNI (Neural Network Intelligence) from Microsoft, you can define and search this space:

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'algorithme de recherche (ENAS, DARTS ou évolutionnaire) évalue les architectures candidates sur un ensemble de validation en utilisant un objectif financier, puis se restreint progressivement aux topologies les plus performantes. Notez l'asymétrie des coûts par rapport à tout le reste dans cet article : le NAS se situe à l'extrémité la plus coûteuse de l'axe des coûts d'évaluation, qui est le seul régime dans lequel les échantillonneurs efficaces en matière d'échantillonnage et l'élagage multi-fidélité sont véritablement rentables.

L'approche WorldQuant Alpha Factory

L'approche de WorldQuant en matière de découverte alpha constitue la mise en œuvre la plus industrielle des principes AutoML en finance. Fondée par Igor Tulchinsky, WorldQuant exploite ce qu'ils appellent une « usine alpha » : un processus systématique permettant de générer, tester et combiner des millions de signaux prédictifs.

Philosophie : génération alpha exponentielle et sa correction

WorldQuant s'est fixé comme objectif en 2010 d'atteindre un million d'alphas, alors qu'ils n'en produisaient que quelques milliers par an. Cet objectif a été atteint en 2016. La philosophie repose sur la loi fondamentale de la gestion active :

ZXQKEEP0QXZ

où ZXQKEEP0QXZ est le ratio d'information, ZXQKEEP1QXZ le coefficient d'information et ZXQKEEP2QXZ la largeur — le nombre de paris indépendants. Chaque ZXQKEEP3QXZ individuel est un prédicteur faible ; l’affirmation est que la combinaison de suffisamment de CI faiblement corrélés permet d’obtenir un rendement ajusté au risque significatif.

The correction that makes or breaks this, and that the naive reading of the formula hides: breadth is not trial count. $BR$ counts independent bets, and generated alphas are not independent — they are composed from the same operators over the same price and volume fields, so they inherit each other's correlation structure. This blog measured the effect directly in Signal Correlation: effective breadth is $N_{eff} = N / C_f$, and with a typical crypto correlation factor $C_f \approx 3$, ten signals are worth about 3.3 independent ones. The $\sqrt{BR}$ term does not grow with how many alphas you generated; it grows with how many uncorrelated ones survived. A million correlated alphas buy you far less than the formula advertises.

C'est pourquoi l'étape 3 ci-dessous — décorrélation par rapport à la bibliothèque existante — n'est pas une étape d'hygiène dans l'usine alpha. C'est l'étape qui produit la largeur en premier lieu.

Les 101 Alphas formulés

The paper "101 Formulaic Alphas" by Kakushadze (associated with WorldQuant research) published a set of formulaic alpha expressions — mathematical expressions over price, volume and fundamental data: The paper "101 Formulaic Alphas" by Kakushadze (associated with WorldQuant research) published a set of formulaic alpha expressions — mathematical expressions over price, volume and fundamental data:

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

Ce qui rend cela intéressant pour AutoML, c'est qu'il s'agit d'une grammaire. Les alphas sont des compositions d'un petit ensemble d'opérateurs ( ZXQKEEP0QXZ , ZXQKEEP1QXZ , ZXQKEEP2QXZ , ZXQKEEP3QXZ , ZXQKEEP4QXZ , ZXQKEEP5QXZ ) sur un petit ensemble de champs ( ZXQKEEP6QXZ , ZXQKEEP7QXZ , ZXQKEEP8QXZ , ZXQKEEP9QXZ , ZXQGARDER10QXZ ). Une grammaire est énumérable, ce qui signifie que l'espace de recherche est généré par une machine d'une manière qui ne l'est pas "penser à une bonne fonctionnalité". Un système AutoML peut :

1. Générer des expressions candidates en composant des opérateurs sur des champs de données
2. Évaluez l'IC, le chiffre d'affaires et le retrait de chaque expression
3. Filtre pour les expressions qui survivent aux tests statistiques et sont suffisamment décorrélées avec la bibliothèque existante
4. Regroupez les survivants dans un portfolio

Notez que les étapes 1 et 2 sont les plus simples et que l'étape 3 correspond à la valeur - voir la correction de largeur ci-dessus.

Découverte alpha améliorée par LLM

WorldQuant has begun integrating large language models into the alpha factory. As reported in financial press, the firm is exploring how LLMs can "transform and discover alphas across different domains" — generating novel expressions, translating research papers into testable hypotheses, and surfacing cross-domain relationships that a pure enumerative search would miss. This is a different mechanism from extracting signals from text, which this blog covers in LLM Alpha Mining on Earnings Calls; here the LLM writes the formula, not the feature.

Construisez votre propre mini-usine Alpha

Voici une fabrique alpha compacte mais fonctionnelle sur la grammaire des opérateurs : Here is a compact but functional alpha factory over the operator grammar:

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

Six modèles sur cinq fenêtres représentent un balayage de 30 configurations. Le rapport qu'il produit a cette forme schématique : les champs sont ce que l'usine émet, et aucun chiffre n'est renseigné car aucun n'a été mesuré ici : Six templates over five windows is a 30-configuration sweep. The report it produces has this schematic shape — the fields are what the factory emits, and no numbers are filled in because none have been measured here:

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

The raw Sharpe of the top alpha out of a 30-configuration sweep is not a result — it is the maximum of 30 draws, and on 1,000 zero-edge strategies the best annualized Sharpe averages 1.63 while the naive test declares a discovery 100% of the time (Deflated Sharpe Ratio). The honest deliverable from a factory is therefore not "we found an alpha" but how many alphas survived deflation: the IC distribution, the trial count, the winner's DSR against that count, and the PBO of the selection. That is the measurement this section still owes.

Garde-corps : ce que vous devez déjà

AutoML amplifie la découverte et le surajustement dans une mesure égale, et il le fait au moment du nombre d'essais où la différence cesse d'être subtile. Chacun d’entre eux est traité en profondeur ailleurs ; le point ici est qu’AutoML les rend tous obligatoires plutôt que conseillés.

Price the search, do not merely correct it. A feature-model-hyperparameter sweep is a trial count and the trial count moves the bar — see The Deflated Sharpe Ratio.

Validate temporally, with purging and embargo. See Walk-Forward Optimization and the Look-Ahead Bias Taxonomy for the leaks that survive a naive temporal split.

Score the procedure, not just the winner. See Probability of Backtest Overfitting, and carry its load-bearing correction: PBO's null is 0.5, not 1 — half is not "half overfit," it is fully overfit, a coin flip.

Watch for peaks that are not there. Searching a noise-dominated surface efficiently just finds sharper illusions faster (Plateau Analysis); this bites hardest on strategy parameters and least on ML hyperparameters, which is the case FLAML and Optuna are actually built for.

Contraindre l'espace de recherche. Échantillons de feuilles minimum, profondeur plafonnée et nombre d'estimateurs, budget de fonctionnalités, pénalité de chiffre d'affaires : régulariser la recherche coûte moins cher que de la dégonfler par la suite.

Conclusion

AutoML fait passer l'automatisation à un niveau supérieur : du réglage des paramètres à l'intérieur d'un candidat fixe à la génération des candidats eux-mêmes. Trois composants valent la peine : tsfresh et Featuretools pour la génération de fonctionnalités, la recherche économique de FLAML pour une sélection de modèles tenant compte du budget et la grammaire des opérateurs de formule pour la construction alpha énumérable. Le NAS ne vaut son calcul que lorsque votre rapport signal/bruit le justifie, et il se situe à l'extrémité coûteuse de l'axe des coûts d'évaluation, là où l'efficacité de l'échantillonnage finit par payer.

L'argument de l'ampleur de WorldQuant ne survit au contact avec les propres mesures de ce blog que sous sa forme corrigée : ZXQKEEP0QXZ où ZXQKEEP1QXZ compte les paris indépendants, et la production d'une usine est loin d'être indépendante. Générer un million d'alphas est la partie la plus facile. Établir qu'ils sont suffisamment décorrélés pour être considérés comme de la largeur est la moitié qui détermine si la formule signifie quelque chose.

And the honest caveat is not a moral, it is a measured result. This blog ran the search-and-overfit arc to its conclusion in The Honest Negative: tens of thousands of backtests across five majors, DSR = 0.00 at ~37,000 trials, PBO 0.264 and 0.327, and no robust edge. AutoML raises the trial count by orders of magnitude. Whatever it finds, it will owe a correspondingly larger deflation — and the useful output of an alpha factory is the survival rate after that deflation, not the top line before it. And the honest caveat is not a moral, it is a measured result. This blog ran the search-and-overfit arc to its conclusion in The Honest Negative : tens of thousands of backtests across five majors, DSR = 0.00 at ~37,000 trials, PBO 0.264 and 0.327, and no robust edge. AutoML raises the trial count by orders of magnitude. Whatever it finds, it will owe a correspondingly larger deflation — and the useful output of an alpha factory is the survival rate after that deflation, not the top line before it.