Ensemble-methoden: zwakke leerlingen combineren voor robuuste alfa

De meeste artikelen over handelsensembles beweren dat meer modellen beter zijn. Dat is de verkeerde as. De fout van een ensemble valt uiteen in drie termen, en bij het handelen is slechts één daarvan ooit de bindende beperking.

Dit artikel gaat over die ene term, en over twee gevolgen daarvan die in de rest van deze blog niet aan de orde komen: stapelen als een expliciete signaalcombinatielaag, en of het combineren van veel signalen daadwerkelijk de omzet verlaagt voordat de transacties de markt bereiken.

De term die feitelijk bindt: bias-variantie-covariantie

Voor een regressie-ensemble van $N$ modellen, de verwachte kwadratische fout van de gemiddelde voorspelling $\bar{f}$ ontleedt als:

$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}}$

Drie termen, drie hefbomen:

• Bagging valt de variantieterm aan door het middelen van bootstrap-steekproeven.
• Boosting valt de bias-term aan door residuen iteratief te corrigeren.
• Stapel valt de covariantieterm aan door combinatiegewichten te leren in plaats van gelijke gewichten aan te nemen.
• Toenemend $N$ verkleint alleen de variantiebijdrage. Het doet helemaal niets met de covariantie – de $(1 - 1/N)$ coëfficiënt is al 0,99 bij $N = 100$.

Dat laatste punt is het hele argument. In de handel worden modellen getraind op dezelfde instrumenten, over dezelfde geschiedenis, tegen doelen die zelf vrijwel identieke transformaties van dezelfde prijsreeks zijn. Hun fouten zijn niet in de buurt van onafhankelijk. De covariantieterm is dus groot en de variantieterm is al uitgeput, wat betekent dat je met het tellen van modellen bijna niets koopt en met structurele verschillen alles.

De concrete, falsifieerbare vorm van de bewering: het toevoegen van de 101e gradiënt-versterkte boom zou de ensemble-metriek minder moeten verplaatsen dan het toevoegen van één structureel ander model – een LSTM, een lineair model op een onsamenhangend kenmerkdomein, alles met een andere inductieve bias. De marginale boom ligt bijna op één lijn met de bomen die al in het boek staan; het structureel andere model is dat niet.

Correlatie, niet het aantal modellen, bepaalt de effectieve breedte van een ensemble – de afleiding, de crypto-gemeten correlatiefactoren per activaklasse, en de simulatie op basis van echte paargegevens staan ​​in Signal Correlation: How Many Pairs to Monitor.

Reduceer de ensemblediversiteit niet tot één enkel getal. De Deflated Sharpe Ratio berekent vijf effectieve$N$ schatters (gemiddelde correlatie, participatieratio, PCA-95%, Kaiser, Cheverud-Nyholt) op een echt raster van 640 cellen, laten zien dat ze zich uitstrekken $N_{\text{eff}}$ van 1,6 tot 370, en stelt dat de bandbreedte – en niet een enkele puntschatting – het haalbare is. Rapporteer de band.

Stapelen als signaalcombinatielaag

Opzakken en boosten worden elders goed behandeld. Spread Modeling with Machine Learning levert de gradiëntverhogende opstelling, de verliesselectie voor scheve doelen, de SHAP-belangbevindingen, de kenmerktaxonomie en een opgeschoonde walk-forward-splitsing met de voorwaartse vensteroverlap die de kloof motiveert. Begin daar; dit gedeelte gaat ervan uit.

Wat niet aan bod komt, is het niveau erboven: een meta-leerling die voorspellingen uit basismodellen als invoerkenmerken neemt en leert hoe deze te combineren.

• Niveau 0 (basisleerlingen): diverse modellen die voorspellingen produceren op basis van onbewerkte functies.
• Niveau 1 (meta-leerling): een model dat leert welke basisleerlingen je kunt vertrouwen, en wanneer.

Het mechanisme dat deze kluis maakt, is een out-of-fold meta-functie. De meta-leerling mag nooit een basismodelvoorspelling zien die is gedaan op basis van gegevens waarop het basismodel is getraind. Deze voorspellingen zijn optimistisch bevooroordeeld op een manier die niet standhoudt tijdens live handelen, en de meta-leeraar zal ze dienovereenkomstig wegen.

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)

De splitsingsdiscipline hier is niet optioneel en niet nieuw – gebruik een gezuiverde, embargo-walk-forward, en begrijp wat elke klasse lek waard is in opgeblazen Sharpe voordat je een van deze cijfers vertrouwt. Beide zijn al gemeten: de look-ahead bias-taxonomie kwantificeert de uitvoering, indicator- en normalisatielekkage in een gecontroleerde simulator, en walk-forward-optimalisatie omvat verankerde versus rollende vensters, CPCV, opschonen en de WFER-degradatiediagnostiek.

Drie ontwerpbeslissingen zijn specifiek voor stapelen en het vermelden waard.

Eenvoud voor metaleerlingen. Gebruik een lineair model: nok, lasso, logistische regressie. De basisleerlingen gaan om met niet-lineariteit; de meta-leerling behandelt alleen de combinatie. Een complexe meta-leerling bovenop complexe basisleerlingen is overfitting van de tweede orde, en L1-regularisatie op de combinatielaag heeft het nuttige neveneffect dat basismodellen die alleen maar ruis bijdragen, worden uitgesloten.

Waarschijnlijkheidsuitvoer via harde labels. predict_proba draagt ​​vertrouwensinformatie over die een klassenlabel weggooit, en laat de meta-leerling zelfverzekerde basisvoorspellingen zwaarder wegen.

Partitionering van kenmerkdomeinen. Dit is de diversiteitshefboom met de hoogste hefboomwerking, en volgt rechtstreeks uit het covariantieargument: modellen die dezelfde kenmerken zien, produceren gecorreleerde fouten, ongeacht het algoritme.

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

Elk basismodel wordt een domeinexpert: het momentummodel leert momentumpatronen zonder interferentie van volumeruis, en de meta-leerling leert welke expert hij onder welke omstandigheden kan vertrouwen.

Twee kanttekeningen bij die laatste clausule. Ten eerste is regime-voorwaardelijke weging een opgelost en gepubliceerd probleem – regime detectie met HMM’s leidt regimes op de juiste manier af via Forward/Viterbi/Baum-Welch en voert ze als kenmerken door naar een stroomafwaarts ensemble, en dynamisch combineren van strategieën behandelt regime-gewogen gemiddelde reversie versus momentum met gerapporteerde resultaten. Vervang geen van beide door een ad-hoc momentum-teken-proxy. Ten tweede levert selectie op basis van prestaties binnen de steekproef winnaars op die het niet overleven; het generieke mechanisme en de CSCV-verdediging worden gemeten in de waarschijnlijkheid van backtest-overfitting. Stapelen is een smaller voorbeeld van precies dat probleem.

Voor het wegen van retourstromen in plaats van modelvoorspellingen mag u de gemiddelde variantie niet opnieuw afleiden. 12 Portfolio Optimization Algorithms, Compared races HRP, HERC, GHRP, MHRP, Black-Litterman, NCO, MVO, risicopariteit en gelijk gewicht met gemeten resultaten en open source code; Markowitz-portfoliotheorie voor crypto heeft de SLSQP-implementatie van de gemiddelde variantie; en het resultaat 1/N-is-moeilijk-te-verslaan is al getest tegen HRP en CVaR in de HRP/CVaR-portfoliopijplijn.

Omzetverrekening: de claim die het testen waard is

Hier is het deel van het alfabibliotheekargument dat het uitvoeringskostencluster van deze blog momenteel niet dekt.

Wanneer Alpha #4.721 zegt "koop MSFT" en Alpha #8.392 zegt "verkoop MSFT" in dezelfde herbalancering, kruisen deze transacties elkaar intern. Alleen de nettopositie bereikt de markt. De bewering is dat bij voldoende signalen een groot deel van de beoogde bruto-omzet verdwijnt voordat er sprake is van spread, vergoedingen of marktimpact – wat zou betekenen dat een ensemble goedkoper is om te runnen dan de som van zijn componenten, en niet alleen stabieler.

Dit is een ander mechanisme dan wat cascade strategy Orchestration al verwerkt. Cascade lost conflicten op slot-niveau op: hetzelfde paar, tegenovergestelde richting is verboden en wordt afgehandeld per score, uitzetting tussen paren loopt via een prioriteitswachtrij, en het artikel bewijst empirisch dat PnL per strategie niet eenvoudigweg kan worden opgeteld vanwege tijdoverlap en kapitaalbeperkingen. Netting gaat over bruto-naar-netto-positieberekeningen, waarbij de verhandelde hoeveelheid zelf wordt verminderd.

Het is ook goedkoop om te vervalsen: bereken de bruto versus netto-omzet op echte vullingen wanneer de componentsignalen worden gecombineerd, en bepaal vervolgens de prijs via het bestaande kostenmechanisme – maker-taker vergoedingen en kortingen, implementatietekort en TCA, en slippage-kosten modellen.

Een opmerking over de schaal, aangezien de alfabibliotheek-framing daartoe uitnodigt. WorldQuant meldt dat het een zeer grote alfabibliotheek heeft geproduceerd, en Kakushadze's 101 Formulaic Alphas documenteert de vorm van de afzonderlijke signalen. Maar het delven van alfa's op industriële schaal is ook de grootste machine die je je kunt voorstellen, en het standpunt van deze blog daarover staat vast: een zoektocht naar de omvang $K$ moet worden afgezet tegen het verwachte succes van een zoekopdracht van die omvang. The Deflated Sharpe Ratio toont een raster van 640 cellen dat de naïeve significantietest al doorbreekt, en The Honest Negative toont een zoekactie van ~37.000 tests die een winnaar van +16,35% buiten de steekproef oplevert die leegloopt tot DSR 0,00. De grootte van de bibliotheek is geen bewijs van voorsprong. Het is de noemer die u moet betalen.

Samenvoegen

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

Het laatste doosje is geen decoratie. Over stapelen $K$ basismodellen is een selectieprocedure van maat $K$, en een ensembleartikel dat niet leegloopt, is onverdedigbaar.

Afhaalrestaurants

1. Structureel verschil overtreft het aantal modellen. De covariantieterm krimpt niet mee $N$. Het toevoegen van een zesde gecorreleerde boom is geen diversificatie; het toevoegen van een andere modelklasse of een onsamenhangend featuredomein is dat wel.
2. Rapporteer de effectieve-$N$ band, geen punt. Vijf schatters, vijf antwoorden, soms twee ordes van grootte uit elkaar.
3. Houd de meta-leerling lineair. De complexiteit op de combinatielaag is bijna altijd overfitting, en L1 doet daar een nuttige automatische modelselectie.
4. Uit de plooi of niets. Een meta-leerling die getraind is in basisvoorspellingen binnen de steekproef, leert met groot vertrouwen de verkeerde gewichten.
5. Laat het ensemble zelf leeglopen. Stapelen is zoeken. Prijs het als één.

Verder lezen:

• Kakushadze, Z. (2016). 101 formule-alfa's
• [Ensemble leren in beleggen] (https://rpc.cfainstitute.org/research/foundation/2025/chapter-4-ensemble-learning-investment) — CFA Institute Research Foundation, 2025
• [Voorspelling van aandelenrendement: een verscheidenheid aan modellen stapelen] (https://www.sciencedirect.com/science/article/abs/pii/S0927539822000342) — Journal of Financial Economics
• Jansen, S. [Machine Learning voor algoritmische handel] (https://github.com/stefan-jansen/machine-learning-for-trading), 2e editie