Double Machine Learning: Een Causale Parameter Schatten in Plaats van Returns Voorspellen

Elke modelleringartikel in deze blog stelt tot nu toe dezelfde vorm van vraag: gegeven features, voorspel een getal, verifieer dan dat de voorspelling buiten de steekproef overleeft. Spread-modellen voorspellen spread. Vul-modellen voorspellen vulkans. De gehele validatie-apparatuur — purged walk-forward, gedeflateerde Sharpe, look-ahead taxonomie — bestaat om te controleren of een voorspelling echt is.

Dit artikel stelt een andere vorm van vraag, en het is het enige stuk gereedschap dat de blog nog nooit heeft gehad: schat één enkele scalaire parameter die een causale interpretatie heeft, en hecht er een standaardfout aan die overleeft het feit dat een flexibel ML-model werd gebruikt om daar te komen.

Dat is geen rhetorisch onderscheid. "Wachtrijpositie voorspelt vulkans" is triviaal waar en operationeel nutteloos — natuurlijk doet het dat, beide worden aangedreven door diepte en volatiliteit. "Één positie naar voren schuiven in de wachtrij veroorzaakt een verandering van $\theta$ in vulkans, met markttoestand vastgehouden" is een getal dat je in een orderplaatsingsbeleid kunt stoppen. De eerste is een regressie-fit. De tweede vereist een schatter die niet bestaat in de standaard ML-toolkit, omdat regularisatie en overfitting in een flexibele eerste fase precies de coëfficiënt waar je om geeft vertekenen.

Double Machine Learning (Chernozhukov, Chetverikov, Demirer, Duflo, Hansen, Newey & Robins, 2018) is de schatter die dit oplost. Elke kwantitatieve handelaar heeft het gehoord: correlatie is geen causaliteit. DML is het deel dat na die zin komt.

Waarom Naïeve Regressie Faalt

Stel de vraag in het eigen terrein van de blog. We willen het causale effect van wachtrijpositie op vulkans:

• $Y_i$: of de rustende limietorder bij observatie $i$ binnen de horizon werd gevuld.
• $D_i$: wachtrijpositie bij plaatsing (genormaliseerd door niveau-grootte).
• $X_i$: de confounders — gerealiseerde volatiliteit, quoted spread, diepte-onevenwicht, niveau-grootte, tijdstip, regime-label. Dit zijn de markttoestandsvariabelen die de blog al berekent in spread-modellering met machine learning.

De causale parameter is $\theta_0$ in

$Y_i = D_i \theta_0 + g_0(X_i) + \epsilon_i$

waarbij $g_0(X_i)$ de (potentieel complexe, niet-lineaire) relatie tussen markttoestand en vul-uitkomst vastlegt.

De behandeling is niet willekeurig toegewezen. Je staat vooraan in de wachtrij omdat het niveau dun was, of omdat je plaatste tijdens een rustige periode, of omdat het book in jouw voordeel onevenwichtig was. Dezelfde omstandigheden drijven onafhankelijk of je wordt gevuld. Dat is de confounding.

Aanpak 1: Negeer confounders. Regresseer $Y$ op $D$ alleen. De schatting absorbeert het effect van elke confounder die met beide gecorreleerd is. Klassieke weggelaten variabele bias: dunne niveaus geven je zowel een goede wachtrijplek als een hoog vulpercentage, dus je overschat de waarde van de plek zelf.

Aanpak 2: Lineaire regressie met controles. Regresseer $Y$ op $D$ en $X$. Dit werkt alleen als $g_0(X)$ echt lineair is. Book-dynamiek is dat niet — de vul/volatiliteit-relatie heeft drempels, het diepte-onevenwichtseffect verandert per regime van teken. $g_0$ verkeerd specificeren herintroduceert bias.

Aanpak 3: ML-voorspelling. Pas een gradient boosted model aan op $(D, X)$. Je krijgt goede out-of-sample discriminatie, en totaal geen causale interpretatie. Het model vangt elk voorspellend patroon, causaal of niet; regularisatie krimpt de bijdrage van de behandeling op manieren die $\theta$ vertekenen; en er is geen standaardfout die je kunt vertrouwen.

Dit is de kernspanning. ML is goed in voorspelling, maar naïeve toepassing op een causale parameter produceert vertekende, niet-normale, onbetrouwbare schattingen.

Het Gedeeltelijk Lineaire Model

DML opereert binnen een structureel kader. Het werkpaard is de gedeeltelijk lineaire regressie (PLR):

$Y = D\theta_0 + g_0(X) + U, \quad \mathbb{E}[U \mid X, D] = 0$

$D = m_0(X) + V, \quad \mathbb{E}[V \mid X] = 0$

• $\theta_0$ is de causale parameter van belang.
• $g_0(X)$ is een nuisance-functie — het deel van de uitkomst verklaard door markttoestand.
• $m_0(X)$ is een andere nuisance-functie — de conditionele verwachting van behandeling gegeven markttoestand (de "propensity" in een continue behandeling-setting).
• $U$ en $V$ zijn structurele residuen.

Het cruciale inzicht: $\theta_0$ is laag-dimensionaal, maar $g_0$ en $m_0$ kunnen willekeurig complex zijn. We willen ML de nuisance-functies laten afhandelen terwijl we nog steeds geldige inferentie op de schaal leveren.

Waarom "Double"?

Twee ML-modellen, niet één:

1. Uitkomstmodel: $\hat{\ell}(X) \approx \mathbb{E}[Y \mid X]$ — voorspel de uitkomst uit alleen markttoestand.
2. Behandelingsmodel: $\hat{m}(X) \approx \mathbb{E}[D \mid X]$ — voorspel de behandeling uit alleen markttoestand.

Vorm residuen

$\tilde{Y}_i = Y_i - \hat{\ell}(X_i), \quad \tilde{D}_i = D_i - \hat{m}(X_i)$

en schat $\theta_0$ door $\tilde{Y}$ op $\tilde{D}$ te regresseren:

$\hat{\theta}_0 = \frac{\sum_i \tilde{D}_i \tilde{Y}_i}{\sum_i \tilde{D}_i^2}$

Dit is Frisch-Waugh-Lovell op steroïden: partial out de confounders met ML in plaats van een lineaire projectie, lees dan het behandelingseffect af van de residu-variatie.

Neyman-Orthogonaliteit: Waarom Het Werkt

De naïeve partial-out aanpak (schat $g_0$, trek af, regresseer) faalt omdat ML-schattingsfouten in $\hat{g}_0$ rechtstreeks doorpropageren naar $\hat\theta_0$. De DML-score is geconstrueerd om Neyman-orthogonaal te zijn — ongevoelig voor kleine verstoringen in de nuisance-functies.

De orthogonale score voor PLR:

$\psi(W; \theta, \eta) = \big[Y - \ell(X) - \theta(D - m(X))\big] \cdot \big[D - m(X)\big]$

waarbij $\eta = (\ell, m)$. De orthogonaliteitsvoorwaarde is

$\left. \frac{\partial}{\partial \eta} \mathbb{E}\big[\psi(W; \theta_0, \eta)\big] \right|_{\eta = \eta_0} = 0$

Intuïtief gebruikt de score alleen de variatie in $D$ en $Y$ die onafhankelijk is van $X$, en fouten in één nuisance-functie worden gecompenseerd door de andere. Als $\hat{m}$ de behandeling licht overschat, is $\tilde{D}$ iets te klein, maar de corresponderende fout in $\tilde{Y}$ door het verkeerd schatten van $\ell$ duwt in een compenserende richting. De bias wordt tweede orde — het product van twee eerste-orde fouten — in plaats van eerste orde.

Formeel, als beide nuisance-schatters convergeren met snelte $n^{-1/4}$ (mild; de meeste redelijke ML-methoden halen dit), dan

$\sqrt{N}(\hat{\theta}_0 - \theta_0) \xrightarrow{d} \mathcal{N}(0, \sigma^2)$

dus $\hat\theta_0$ convergeert met parametrische snelte en is asymptotisch normaal.

Cross-Fitting: Waarom Het Hier Verplicht Is

Orthogonaliteit alleen is niet genoeg. Als de nuisance-modellen worden gefit op dezelfde rijen gebruikt om $\theta_0$ te schatten, contamineren eerste-fase overfitting de tweede fase — en de specifieke schade is de moeite waard om precies te stellen, omdat het niet de schade is die je gewend bent. Elders toont overfitting zich als een opgeblazen validatiescore: je merkt het, je discount het, je gaat verder. Hier toont het zich als een verschuivende puntsschatting voor $\theta_0$, met een betrouwbaarheidsinterval dat nog steeds smal en nog steeds gecentreerd op het verkeerde getal. Er is geen score om achterdochtig over te zijn. De schatter liegt gewoon stilletjes.

Cross-fitting verbreekt de afhankelijkheid: de nuisance-voorspellingen van elke observatie komen van een model getraind zonder het, en $\theta_0$ wordt geschat uit de gepoolde held-out residuen. De mechaniek is gewone K-fold machinery, behandeld in spread-modellering met machine learning; wat hieronder uitmaakt is welke folds je het geeft.

Het DML-Algoritme Stap voor Stap

Input: data $\{(Y_i, D_i, X_i)\}_{i=1}^N$, ML-methoden $\mathcal{M}_\ell$ en $\mathcal{M}_m$, folds $K$.

Stap 1 — Partition: splits $\{1, \ldots, N\}$ op in $K$ disjuncte folds.

Stap 2 —Cross-fit nuisance-modellen: voor $k = 1, \ldots, K$, train $\hat{\ell}^{(-k)}$ en $\hat{m}^{(-k)}$ op het complement van fold $k$, bereken dan $\tilde{Y}_i = Y_i - \hat{\ell}^{(-k)}(X_i)$ en $\tilde{D}_i = D_i - \hat{m}^{(-k)}(X_i)$ voor $i \in I_k$.

Stap 3 — Schatting:

$\hat{\theta}_0 = \left(\sum_{i=1}^N \tilde{D}_i^2\right)^{-1} \sum_{i=1}^N \tilde{D}_i \tilde{Y}_i$

Stap 4 — Inferentie:

$\hat{\sigma}^2 = \frac{1}{N} \sum_{i=1}^N \big(\tilde{Y}_i - \hat{\theta}_0 \tilde{D}_i\big)^2 \tilde{D}_i^2 \bigg/ \left(\frac{1}{N} \sum_{i=1}^N \tilde{D}_i^2\right)^2$

met intervallen $\hat{\theta}_0 \pm z_{\alpha/2} \cdot \hat{\sigma} / \sqrt{N}$.

Het betrouwbaarheidsinterval is geldig voor precies één vraag

Dit is de voorwaarde die bepaalt of een DML-resultaat iets waard is, en waar de meeste toegepaste toepassingen van de methode stil uiteenvallen.

De bovenstaande asymptotische normaliteit is een verklaring over één vooraf gespecificeerde behandeling, één vooraf gespecificeerde confounder-set, één vooraf gespecificeerde score. Fix deze van tevoren, voer de schatter één keer uit, en het interval betekent wat het zegt. Probeer drie kandidaat-behandelingen, of vier confounder-sets, of wissel learners totdat de p-waarde er beter uitziet, en je doet geen inferentie meer — je voert een zoekactie, en de gerapporteerde p-waarde is de p-waarde van een maximum, niet van een trekking.

De blog heeft al gemeten wat dat doet. In het gedeflateerde Sharpe ratio onderzoek produceren zoektochten over puur ruis met nul werkelijke edge een naïeve valse-ontdekkingssnelheid van 1.000 — de onaangepaste test vuurt elke keer — terwijl de mediaan naïeve p-waarde van de winnaar nabij 0.0007 zit. Niets over Neyman-orthogonaliteit beschermt je hiertegen. Orthogonaliteit repareert de bias van nuisance-schatting; het zegt niets over de bias van specificatie-zoektocht. Een DML p-waarde van 1e-05 verkregen na het proberen van zes specificaties verdient precies dezelfde Bonferroni/Holm/BHY-behandeling als elke andere winnaar uit een grid, met $M$ ingesteld op het aantal specificaties dat je daadwerkelijk hebt uitgevoerd.

Dit heeft een direct praktisch gevolg voor de gemaksfuncties van de tooling. DoubleMLData accepteert een lijst in d_cols en zal gelukkig drie behandelingseffecten in één samenvattingstabel teruggeven:

dml_data_multi = dml.DoubleMLData(
    df, y_col='filled', d_cols=['queue_pos', 'toxicity', 'spread_at_post'],
    x_cols=confounder_cols,
)

Drie rijen, drie p-waarden, en een meervoudig testingsprobleem dat de samenvattingstabel niet noemt. Als je alle drie leest, corrigeer alle drie. Als er slechts één de vooraf-geregistreerde vraag was, zeg dat, en behandel de andere twee expliciet als verkennend.

Cross-Fitting op Tijdreeksen: Purge, Embargo, Aangepaste Folds

Standaard DML gaat uit van i.i.d. observaties. Book-data is dat niet, en de faalmodus is degene die de blog al in detail heeft gedocumenteerd: aangrenzende rijen delen overlappende vooruit-vensters, dus een gewone TimeSeriesSplit lekt nog steeds het antwoord over de fold-grens. Zie spread-modellering met machine learning voor de purged, embargoed walk-forward implementatie en de reden waarom een gat van ten minste horizon rijen vereist is, en de look-ahead bias taxonomie voor de volledige catalogus van lekken en hun gemeten magnituden.

Het echt DML-specifieke deel is hoe je purged folds aan de schatter geeft, want set_sample_splitting heeft een contract dat mensen struikelt:

import numpy as np
import doubleml as dml

def purged_folds(n: int, n_splits: int, horizon: int):
    """Expanding-window folds met een purge/embargo-gat van `horizon` rijen.

    Dezelfde constructie als de purged walk-forward CV in het spread-modellering
    artikel: het gat verwijdert de overlap tussen de vooruit-venster van een
    trainingrij en een validatierij.
    """
    fold_size = n // (n_splits + 1)
    for k in range(1, n_splits + 1):
        train_end = fold_size * k
        val_start = train_end + horizon
        val_end = val_start + fold_size
        if val_end > n:
            break
        yield np.arange(0, train_end - horizon), np.arange(val_start, val_end)

folds = list(purged_folds(len(df), n_splits=5, horizon=HORIZON))

dml_plr = dml.DoubleMLPLR(dml_data, ml_l=ml_l, ml_m=ml_m)
dml_plr.set_sample_splitting([folds])
dml_plr.fit()

Twee dingen om je bewust van te zijn, geen van beide obvious uit de library docs:

1. Purged walk-forward folds dekken niet elke rij. De purge-gaten en het initiële trainingsblock zijn nooit iemands test-fold, dus $\theta_0$ wordt geschat uit strikt minder dan $N$ residuen. Dat is correct gedrag, geen bug, maar het betekent dat de effectieve $N$ in de variantieformule het aantal gepoolde test rijen is — controleer het in plaats van aan te nemen.
2. n_rep herhalingen zijn hier niet gratis. Met willekeurige K-fold is cross-fitting herhalen en middelen een goedkope variantiereductie. Met een deterministische tijd-geordende split is er maar één splitsing, dus n_rep koopt niets en verbergt niets; stabiliteit moet komen uit heruitvoeren op verschillende data-vensters.

Voor panelstructuren (veel symbolen over dezelfde periode) ondersteunt DoubleML cluster-robuste standaardfouten — cluster op symbool, niet op tijd, en zie multi-symbol validatie voor de positie van de blog over wanneer een cross-instrument resultaat echt vaststaat.

De Gemeten Casus: Wachtrijpositie en Vulkans

Dit is de enige causale vraag in het artikel waar het project al de data voor heeft, en het moet worden uitgevoerd in plaats van worden opgeworpen. Wachtrijpositie-analyse behandelt al positie-schatting, FIFO-mechanica, drain rates en tijd-tot-vul op echt book-data; vul-simulatie behandelt vulkansmodellering en de kalibratielus tegen live fills. Beide produceren een voorspellend model van fills. DML zet dezelfde inputs om in een causale schatting.

De specificatie, vooraf geregistreerd voordat naar de schatting wordt gekeken:

• Uitkomst $Y$: gevuld binnen HORIZON snapshots (binair).
• Behandeling $D$: genormaliseerde wachtrijpositie bij plaatsing.
• Confounders $X$: gerealiseerde 1s volatiliteit, quoted spread in bps, diepte-onevenwicht, niveau-grootte bij post, afstand van mid in ticks, tijd-van-dag encoding, regime-label.

from sklearn.ensemble import GradientBoostingRegressor
import doubleml as dml

confounder_cols = [
    'rv_1s', 'spread_bps', 'depth_imbalance', 'level_size',
    'dist_from_mid_ticks', 'tod_sin', 'tod_cos', 'regime',
]

dml_data = dml.DoubleMLData(
    df, y_col='filled', d_cols='queue_pos_norm', x_cols=confounder_cols,
)

ml_l = GradientBoostingRegressor(n_estimators=300, max_depth=5)
ml_m = GradientBoostingRegressor(n_estimators=300, max_depth=5)

dml_plr = dml.DoubleMLPLR(dml_data, ml_l=ml_l, ml_m=ml_m, score='partialling out')
dml_plr.set_sample_splitting([folds])
dml_plr.fit()

print(dml_plr.summary)
dml_plr.sensitivity_analysis()
print(dml_plr.sensitivity_summary)

Het te rapporteren resultaat is een vier-kolom vergelijking, niet één enkele coëfficiënt: de naïeve OLS-schatting van $Y$ op $D$ alleen, de lineaire-control schatting van $Y$ op $D$ en $X$, de DML schatting met zijn standaardfout, en de robustness-waarde uit de gevoeligheidsanalyse — hoe sterk een onwaargenomen confounder moet zijn om het effect teniet te doen. Het gat tussen de naïeve en DML kolommen is de werkelijke hoeveelheid van belang: het is hoeveel van de schijnbare waarde van wachtrijpositie markttoestand in vermom was.

Een nul of negatieve $\theta$ hier is een publiceerbaar resultaat en past beter bij deze blog dan een schone positieve. Als het causale effect van wachtrijpositie instort zodra volatiliteit en niveau-grootte worden gepartialled out, is dat een directe bevinding over orderplaatsingsbeleid: de positie is niet wat de fill verdient, de omstandigheden waaronder je de positie kreeg zijn dat wel.

Causale Factoranalyse

De standaard aanpak voor factor investeren is associatief: sorteer op een kenmerk, vorm long-short portfolio's, observeer dat returns verschillen. DML maakt een andere test mogelijk — schat het directe causale effect van een kenmerk op returns, waarbij de confounder-effecten van andere kenmerken worden weggenomen. Als het effect verdwijnt onder DML, is de factor niet onafhankelijk causaal; het is een proxy.

Dit is een tweede, onafhankelijke vorm van factorscepsis, en het is de moeite waard om expliciet te zijn over hoe het zich verhoudt tot de ene die de blog al publiceert. De gedeflateerde Sharpe ratio valt de factor zoo aan vanuit de selectie-kant: met genoeg trials kan een factor significant lijken puur omdat je vaak hebt gekeken. DML valt het aan vanuit de confounding-kant: een factor kan significant lijken op één eerlijke test en nog steeds een proxy zijn voor iets anders in de conditioneringset. Een factor moet beide overleven om interessant te zijn, en de twee faalmodi zijn onafhankelijk — de ene halen zegt niets over de andere.

Wat DML Niet Kan Doen

1. Het vereist dat confounders worden waargenomen. Als een onwaargenomen variabele zowel behandeling als uitkomst aandrijft, is DML vertekend, en geen ML-sophisticatie repareert een identificatieprobleem. Gevoeligheidsanalyse begrenst het risico; het verwijdert het niet.

2. Het schat een gemiddeld effect. Als het effect van wachtrijpositie scherp verschilt per regime, is de puntsschatting het gemiddelde over de regime-mix van je steekproef. Voor heterogeniteit gebruik het Interactive Regression Model (DoubleMLIRM) of een causaal bos.

3. Het gaat uit van een structureel model. De gedeeltelijk lineaire specificatie vereist dat de behandeling op een bepaalde manier de uitkomstvergelijking binnenkomt. Als het echte proces fundamenteel anders is, is DML stellig fout.

4. Het ontdekt geen causale structuur. DML schat het effect van een vooraf gespecificeerde behandeling. Het vertelt je niet welke variabelen oorzaken zijn.

5. Het ontslaat je niet van meervoudig testen. Het herhalen van bovenstaande punt omdat het het vaakst wordt overgeslagen: orthogonaliteit de-biast nuisance-schatting, niet specificatie-zoektocht.

Praktische Notities

Steekproefgrootte. DML vereist dat de nuisance-modellen convergeren met $n^{-1/4}$, wat in de praktijk betekent genoeg rijen voor de ML-modellen om $g_0$ en $m_0$ überhaupt te benaderen. In plaats van te vertrouwen op afrondingsdrempels, stel adequaatheid empirisch vast op de manier waarop multi-symbol validatie dat doet — controleer of de schatting over instrumenten en subperiodes standhoudt, en behandel instabiliteit als het signaal dat het is.

Learner-keuze. Het DML-specifieke feit is nauw maar nuttig: gegeven $n^{-1/4}$ convergentie, beïnvloedt de learner de efficiëntie van $\hat\theta_0$ (intervalbreedte), niet zijn consistentie. Welke learners de moeite waard zijn om te bereiken op tabellaire marktdata, en waarom gradient boosting de standaard is, is al behandeld in spread-modellering met machine learning. Als $\hat\theta_0$ materieel beweegt over learners, is dat geen menu om uit te kiezen — het is bewijs dat de nuisance-functies slecht zijn geschat, en per de sectie hierboven, kiezen voor de vriendelijkste maakt de oefening tot een zoektocht.

Conclusie

DML geeft de blog iets wat het niet had: een manier om een microstructuur-claim te stellen als een causale parameter met een verdedigbare standaardfout, in plaats van als een voorspelling met een goede validatiescore.

De drie dragende ideeën zijn:

• Orthogonaliseer de score zodat eerste-fouten naar tweede orde compenseren.
• Cross-fit, met purged en embargoed folds op tijdreeks-data, zodat eerste-fase overfitting $\theta_0$ niet kan verschuiven.
• Pre-specificeer, zodat het interval dat je rapporteert het interval is dat je daadwerkelijk hebt verdiend.

De schatter is het gemakkelijke deel. De moeilijke delen blijven ongewijzigd: beslissen welke confounders ertoe doen, beargumenteren dat de identificatieaannames gelden, en de weerstaan aan de drang om de specificatie nog één keer uit te voeren.

Referenties

De afstamming van DML is kort en één regel waard: het is Robinsons (1988) gedeeltelijk lineaire model met ML die de kernel-schatters vervangt, de semiparametische efficiëntiegrens bereikt, met een orthogonaliteitsvoorwerp terugtraceerbaar naar Neymans C($\alpha$) toets en een naaste verwant in de gerichte-learning (TMLE) literatuur. Chernozhukov et al.'s bijdrage was laten zien dat dit operationeel kon worden gemaakt met willekeurige ML-learners terwijl $\sqrt{N}$-consistente, asymptotisch normale inferentie behouden blijft.

1. Chernozhukov, V., Chetverikov, D., Demirer, M., Duflo, E., Hansen, C., Newey, W., & Robins, J. (2018). Double/Debiased Machine Learning for Treatment and Structural Parameters. The Econometrics Journal, 21(1), C1-C68.
2. Robinson, P. M. (1988). Root-N-Consistent Semiparametric Regression. Econometrica, 56(4), 931-954.
3. Bach, P., Chernozhukov, V., Kurz, M. S., & Spindler, M. (2022). DoubleML — An Object-Oriented Implementation of Double Machine Learning in Python. Journal of Machine Learning Research, 23(53), 1-6.
4. Facure, M. (2022). Causal Inference for the Brave and True. Chapter 22: Debiased/Orthogonal Machine Learning.
5. Cahan, E., Bai, J., & Ng, S. (2024). Causal Factor Investing. Quantitative Finance.