Méthodes d'ensemble : combiner des apprenants faibles pour une alpha robuste

La plupart des écrits sur les ensembles de trading soutiennent qu’un plus grand nombre de modèles est préférable. Ce n'est pas le bon axe. L'erreur d'un ensemble se décompose en trois termes, et dans le commerce, un seul d'entre eux constitue toujours la contrainte contraignante.

Cet article porte sur ce terme et sur deux de ses conséquences que le reste de ce blog ne couvre pas : l'empilement en tant que couche explicite de combinaison de signaux et la question de savoir si la combinaison de nombreux signaux réduit réellement le chiffre d'affaires avant que les transactions n'atteignent le marché.

Le terme qui lie réellement : Biais-Variance-Covariance

Pour un ensemble de régression de $N$ modèles, l'erreur quadratique attendue de la prédiction moyenne $\bar{f}$ se décompose comme :

$E\left[\left(\bar{f} - y\right)^2\right] = \overline{\text{bias}^2} + \frac{1}{N}\overline{\text{variance}} + \left(1 - \frac{1}{N}\right)\overline{\text{covariance}}$

Trois mandats, trois leviers :

• Bagging attaque le terme de variance en faisant la moyenne sur des échantillons bootstrap.
• Boosting attaque le terme de biais en corrigeant de manière itérative les résidus.
• Stacking attaque le terme de covariance en apprenant les poids combinés au lieu de supposer qu'ils sont égaux.
• En augmentation $N$ réduit uniquement la contribution à la variance. Cela ne fait rien du tout à la covariance - le $(1 - 1/N)$ le coefficient est déjà de 0,99 à $N = 100$.

C’est ce dernier point qui constitue tout l’argument. En trading, les modèles sont formés sur les mêmes instruments, au cours de la même histoire, contre des cibles qui sont elles-mêmes des transformations quasi identiques de la même série de prix. Leurs erreurs sont loin d’être indépendantes. Ainsi, le terme de covariance est grand et le terme de variance est déjà épuisé, ce qui signifie que le nombre de modèles ne vous rapporte presque rien et que la différence structurelle vous rapporte tout.

La forme concrète et falsifiable de l'affirmation : l'ajout du 101ème arbre amélioré par le gradient devrait moins déplacer la métrique d'ensemble que l'ajout d'un modèle structurellement différent - un LSTM, un modèle linéaire sur un domaine de fonctionnalités disjoint, tout ce qui a un biais inductif différent. L'arbre marginal est presque colinéaire avec les arbres déjà présents dans le livre ; le modèle structurellement différent ne l’est pas.

La corrélation, et non le nombre de modèles, définit l'étendue effective d'un ensemble - la dérivation, les facteurs de corrélation crypto-mesurés par classe d'actifs et la simulation par rapport aux données de paires réelles se trouvent dans [Corrélation du signal : combien de paires à surveiller] (/en/blog/post/signal-correlation-pairs).

Ne réduisez pas la diversité d’ensemble à un seul chiffre. Le ratio de Sharpe dégonflé calcule cinq$N$ estimateurs (corrélation moyenne, taux de participation, PCA-95%, Kaiser, Cheverud-Nyholt) sur une grille réelle de 640 cellules, montrent qu'ils couvrent $N_{\text{eff}}$ de 1,6 à 370, et fait valoir que la bande – et non une estimation ponctuelle – est le résultat attendu. Signalez le groupe.

Empilage en tant que couche de combinaison de signaux

L'ensachage et le boosting sont bien couverts ailleurs. Spread Modeling with Machine Learning fournit la configuration d'amélioration du gradient, la sélection de perte pour les cibles asymétriques, les résultats d'importance SHAP, la taxonomie des fonctionnalités et une division progressive purgée avec le chevauchement de la fenêtre avant qui motive l'écart. Commencez par là ; cette section le suppose.

Ce qui n'est pas couvert, c'est le niveau supérieur : un méta-apprenant qui prend les prédictions du modèle de base comme caractéristiques d'entrée et apprend à les combiner.

• Niveau 0 (apprenants de base) : divers modèles produisant des prédictions à partir de fonctionnalités brutes.
• Niveau 1 (méta-apprenant) : un modèle qui apprend à quels apprenants de base faire confiance et à quel moment.

Le mécanisme qui rend cela sûr est constitué de méta-fonctionnalités hors du commun. Le méta-apprenant ne doit jamais voir une prédiction du modèle de base qui a été faite sur les données sur lesquelles le modèle de base a été formé – ces prédictions sont biaisées de manière optimiste d'une manière qui ne survit pas au trading en direct, et le méta-apprenant les pondérera en conséquence.

import numpy as np
import pandas as pd
from sklearn.base import clone
from sklearn.model_selection import TimeSeriesSplit


class TradingStackingEnsemble:
    """
    Two-level stacking ensemble for return prediction.

    Level 0: base learners, each on its own feature domain
    Level 1: meta-learner trained on out-of-fold base predictions
    """

    def __init__(self, base_models: list, meta_model, n_splits: int = 5):
        self.base_models = base_models  # list of (name, model, feature_cols)
        self.meta_model = meta_model
        self.n_splits = n_splits
        self.fitted_base_models_ = {}

    def _generate_meta_features(
        self,
        X: pd.DataFrame,
        y: pd.Series
    ) -> pd.DataFrame:
        """Out-of-fold predictions from each base model."""
        tscv = TimeSeriesSplit(n_splits=self.n_splits)
        meta_features = pd.DataFrame(index=X.index)

        for name, model, feature_cols in self.base_models:
            oof_preds = pd.Series(np.nan, index=X.index)

            for train_idx, val_idx in tscv.split(X):
                X_train = X.iloc[train_idx][feature_cols]
                y_train = y.iloc[train_idx]
                X_val = X.iloc[val_idx][feature_cols]

                fold_model = clone(model)
                fold_model.fit(X_train, y_train)

                if hasattr(fold_model, 'predict_proba'):
                    oof_preds.iloc[val_idx] = fold_model.predict_proba(X_val)[:, 1]
                else:
                    oof_preds.iloc[val_idx] = fold_model.predict(X_val)

            meta_features[name] = oof_preds

        return meta_features.dropna()

    def fit(self, X: pd.DataFrame, y: pd.Series):
        meta_features = self._generate_meta_features(X, y)
        y_meta = y.loc[meta_features.index]

        self.meta_model.fit(meta_features, y_meta)

        for name, model, feature_cols in self.base_models:
            model.fit(X[feature_cols], y)
            self.fitted_base_models_[name] = model

        return self

    def predict(self, X: pd.DataFrame) -> np.ndarray:
        meta_features = pd.DataFrame()

        for name, model, feature_cols in self.base_models:
            fitted = self.fitted_base_models_[name]
            if hasattr(fitted, 'predict_proba'):
                meta_features[name] = fitted.predict_proba(X[feature_cols])[:, 1]
            else:
                meta_features[name] = fitted.predict(X[feature_cols])

        return self.meta_model.predict(meta_features)

La discipline de fractionnement ici n’est ni facultative ni nouvelle – utilisez une procédure purgée et sous embargo et comprenez ce que vaut chaque classe de fuite dans Sharpe gonflé avant de faire confiance à l’un de ces chiffres. Les deux sont déjà mesurés : la taxonomie des biais d'anticipation quantifie les fuites d'exécution, d'indicateur et de normalisation dans un simulateur contrôlé, et l'optimisation walk-forward couvre les fenêtres ancrées et glissantes, le CPCV, la purge et les diagnostics de dégradation du WFER.

Trois décisions de conception sont spécifiques à l’empilage et méritent d’être soulignées.

Simplicité du méta-apprenant. Utilisez un modèle linéaire : crête, lasso, régression logistique. Les apprenants de base gèrent la non-linéarité ; le méta-apprenant gère uniquement la combinaison. Un méta-apprenant complexe au-dessus d'apprenants de base complexes est un surajustement de second ordre, et la régularisation L1 au niveau de la couche de combinaison a pour effet secondaire utile de mettre à zéro les modèles de base qui ne contribuent que du bruit.

Sorties de probabilité sur des étiquettes dures. predict_proba contient des informations de confiance qu'une étiquette de classe rejette et permet au méta-apprenant d'évaluer plus fortement les prédictions de base confiantes.

Partitionnement par domaines de fonctionnalités. Il s'agit du levier de diversité le plus efficace, et il découle directement de l'argument de covariance : les modèles qui voient les mêmes fonctionnalités produisent des erreurs corrélées quel que soit l'algorithme.

FEATURE_GROUPS = {
    'momentum': ['ret_5d', 'ret_10d', 'ret_21d', 'ret_63d'],
    'volatility': ['vol_21d', 'vol_ratio', 'vol_skew', 'garch_vol'],
    'volume': ['volume_ratio', 'obv_slope', 'vwap_dist', 'adv_ratio'],
    'mean_reversion': ['dist_from_ma21', 'dist_from_ma63', 'rsi_14', 'bb_pct'],
    'microstructure': ['bid_ask_spread', 'kyle_lambda', 'amihud_illiq'],
    'fundamental': ['ep_ratio', 'bp_ratio', 'roe', 'accruals'],
}

base_models = []
for domain, features in FEATURE_GROUPS.items():
    model = GradientBoostingClassifier(
        n_estimators=200, max_depth=3,
        learning_rate=0.05, subsample=0.7
    )
    base_models.append((domain, model, features))

Chaque modèle de base devient un expert du domaine : le modèle d'impulsion apprend les modèles d'impulsion sans interférence du bruit de volume, et le méta-apprenant apprend à quel expert faire confiance dans quelles conditions.

Deux mises en garde sur cette dernière clause. Premièrement, la pondération conditionnelle du régime est un problème résolu et publié — détection de régime avec HMM dérive les régimes correctement via Forward/Viterbi/Baum-Welch et les alimente en tant que caractéristiques à un ensemble en aval, et stratégies de combinaison dynamique couvre le retour à la moyenne pondéré en fonction du régime. vs momentum avec les résultats rapportés. Ne remplacez pas non plus un proxy de signe d'élan ad hoc. Deuxièmement, la sélection basée sur les performances au sein de l’échantillon produit des gagnants qui ne survivent pas ; le mécanisme générique et la défense CSCV sont mesurés dans la probabilité de surajustement du backtest. L'empilement est un exemple plus restreint de ce problème.

Pour pondérer les flux de retour plutôt que les prédictions du modèle, ne dérivez pas à nouveau la variance moyenne. 12 algorithmes d'optimisation de portefeuille, comparés courses HRP, HERC, GHRP, MHRP, Black-Litterman, NCO, MVO, parité des risques et poids égal avec résultats mesurés et code open source ; Théorie du portefeuille de Markowitz pour la crypto a l'implémentation de la variance moyenne SLSQP ; et le résultat 1/N est difficile à battre est déjà testé par rapport à HRP et CVaR dans le pipeline de portefeuille HRP/CVaR.

Compensation du chiffre d'affaires : l'affirmation vaut la peine d'être testée

Voici la partie de l'argumentation de la bibliothèque alpha que le cluster de coût d'exécution de ce blog ne couvre pas actuellement.

Lorsque l'Alpha n° 4 721 dit « acheter MSFT » et l'Alpha n° 8 392 dit « vendre MSFT » lors du même rééquilibrage, ces transactions se croisent en interne. Seule la position nette arrive sur le marché. L’affirmation est qu’avec suffisamment de signaux, une grande partie du chiffre d’affaires brut prévu s’annule avant de subir des spreads, des frais ou un impact sur le marché – ce qui signifierait qu’un ensemble est moins cher à gérer que la somme de ses composants, et pas seulement plus stable.

Il s'agit d'un mécanisme distinct de ce que l'orchestration de stratégie en cascade gère déjà. Cascade résout les conflits au niveau slot : la même paire, la direction opposée est interdite et réglée par score, l'expulsion entre paires s'effectue via une file d'attente prioritaire, et l'article prouve empiriquement que les PnL par stratégie ne peuvent pas simplement être additionnés en raison du chevauchement temporel et des contraintes de capital. La compensation consiste à arithmétique de position brute à nette réduisant la quantité échangée elle-même.

Il est également peu coûteux de falsifier : calculez le chiffre d'affaires brut par rapport au chiffre d'affaires net sur les remplissages réels lorsque les signaux des composants sont combinés, puis évaluez à la fois via la machinerie de coûts existante - frais et remises du fabricant-preneur, manque de mise en œuvre et TCA et coût de dérapage modèles.

Une note à l'échelle, puisque le cadrage de l'alpha-librairie l'invite. WorldQuant rapporte avoir produit une très grande bibliothèque alpha, et les 101 Formulaic Alphas documente la forme des signaux individuels. Mais l'extraction d'alphas à l'échelle industrielle est également la plus grande machine de tests multiples imaginable, et la position de ce blog à ce sujet est arrêtée : une recherche de taille $K$ doit être dégonflé par rapport à la meilleure chance attendue d’une recherche de cette taille. Le ratio de Sharpe dégonflé montre une grille de 640 cellules qui dépasse déjà les tests de signification naïfs, et The Honest Negative montre une recherche d'environ 37 000 essais produisant un gagnant hors échantillon de +16,35 % qui se dégonfle en DSR 0,00. La taille de la bibliothèque n'est pas une preuve de l'avantage. C'est le dénominateur que vous devez payer.

L'assembler

Raw Data
  |
  v
Feature Engineering
  |
  v
Feature Subsets (partitioned by domain -> decorrelated errors)
  |
  +---> Base Model 1: RF on momentum features
  +---> Base Model 2: GBM on volatility features
  +---> Base Model 3: LSTM on price sequences
  +---> Base Model 4: Lasso on fundamental features
  +---> Base Model 5: XGBoost on microstructure features
  |
  v
Out-of-Fold Predictions (purged walk-forward)
  |
  v
Meta-Learner (Ridge)
  |
  v
Combined Signal -> Net Position -> Execution
  |
  v
DSR >= 0.95 and PBO <= 0.2 gate, or it does not ship

La dernière case n’est pas une décoration. Empiler $K$ les modèles de base sont une procédure de sélection de taille $K$, et un article d’ensemble qui ne se dégonfle pas est indéfendable.

À retenir

1. La différence structurelle dépasse le nombre de modèles. Le terme de covariance ne diminue pas avec $N$. L’ajout d’un sixième arbre corrélé n’est pas une diversification ; l'ajout d'une classe de modèle différente ou d'un domaine de fonctionnalités disjoint l'est.
2. Déclarer l'efficacité-$N$ bande, pas un point. Cinq estimateurs, cinq réponses, parfois à deux ordres de grandeur d'intervalle.
3. Gardez le méta-apprenant linéaire. La complexité au niveau de la couche de combinaison est presque toujours surajustée, et L1 y effectue une sélection automatique de modèle utile.
4. Hors du pli ou rien. Un méta-apprenant formé sur les prédictions de base dans l'échantillon apprend les mauvais poids avec une grande confiance.
5. Dégonflez l'ensemble lui-même. L'empilage est une recherche. Prix-le comme un.

Lectures complémentaires :

• Kakushadze, Z. (2016). 101 Alphas de formule
• Ensemble Learning in Investment — Fondation de recherche du CFA Institute, 2025
• [Prédiction du rendement des actions : empilement d'une variété de modèles] (https://www.sciencedirect.com/science/article/abs/pii/S0927539822000342) — Journal of Financial Economics
• Jansen, S. [Machine Learning for Algorithmic Trading] (https://github.com/stefan-jansen/machine-learning-for-trading), 2e édition