De Fidelity Gate: Grof-naar-Fijn Backtesten Bedriegt Je Sneller Tenzij de Goedkope Proxy Net Zo Rangschikt als de Dure

Onderdeel van de reeks "Backtests Zonder Illusies".

Elke serieuze parameterzoektocht loopt tegen dezelfde muur aan: de ruimte is enorm en elke eerlijke evaluatie is duur. Een multi-timeframe-strategie met een dozijn drempelwaarden en drie indicatorperiodes, geëvalueerd over een multi-fold walk-forward-split, kan seconden per configuratie kosten. Tienduizend configuraties zijn uren. Dus zoek je een kortere weg, en die kortere weg is altijd hetzelfde idee: evalueer goedkoop, promoveer alleen de overlevenden naar de dure test. Screen tienduizend configuraties op één fold, houd de beste paar honderd over, draai die op alle folds. Screen op uurkaarsen, ga pas voor de finalisten dieper naar 1 seconde.

Dit is grof-naar-fijn zoeken — drill-down, multi-fidelity, successive halving, Hyperband, ASHA — en het is een van de echt goede ideeën in optimalisatie. Het kan een dag rekenwerk omzetten in een uur. Wij gebruiken het. Maar het verbergt een valstrik die zo stil is dat de meeste mensen die het toepassen er nooit op controleren, en de valstrik is dit: de hele methode gaat ervan uit dat je goedkope proxy configuraties op dezelfde manier rangschikt als de dure evaluatie. Als dat niet zo is, zoek je niet sneller. Je gooit je toekomstige winnaars weg bij de eerste poort en promoveert ruis — je bedriegt jezelf gewoon sneller.

Dit artikel gaat over de ene meting die je vertelt of je drill-down echt is of een illusie. We hebben het uitgevoerd op onze eigen multi-timeframe-zoektocht, en het antwoord was ongemakkelijk: bij de goedkoopste fidelity rangschikte onze proxy configuraties bijna willekeurig (Spearman ρ ≈ 0.03). Als we agressief hadden gesnoeid bij die fidelity — zoals elke kant-en-klare ASHA-standaard je uitnodigt te doen — hadden we de uiteindelijke winnaars in de eerste ronde weggegooid. De oplossing is een verplichte poort die voor de zoektocht draait: meet de rangcorrelatie, en weiger te snoeien onder de fidelity waarop die betrouwbaar is.

Wat multi-fidelity zoeken werkelijk is

De familie van methoden heeft één vorm. Je definieert een fidelity (ook wel een resource of budget genoemd): een knop van goedkoop naar duur die, op zijn maximum, de ware doelfunctie geeft. Vervolgens draai je configuraties op lage fidelity, rangschik je ze, houd je het beste deel over, en draai je alleen die overlevenden opnieuw op hogere fidelity — herhaal dit tot een klein aantal finalisten op volledige fidelity is geëvalueerd.

Successive halving (Jamieson & Talwalkar, 2016) is de kern: start N configuraties op de minimale resource, houd de beste 1/η, vermenigvuldig de resource met η, herhaal. Hyperband (Li et al., 2018) verpakt successive halving in een buitenste lus die afdekt over verschillende startresources, zodat je niet hoeft te raden hoe agressief je moet snoeien. ASHA (Li et al., 2020) is de asynchrone, parallel-vriendelijke versie. De eliminatiesnelheid η is de ene knop die ze delen; de canonieke standaard is η = 3 — houd het beste derde deel op elke trede, verdrievoudig het budget.

De fidelity zelf kan bijna alles zijn dat van goedkoop naar duur convergeert naar de waarheid:

• Aantal walk-forward-folds. Evalueer op 1 fold, dan 2, dan 3, tot K. Dit is de fidelity die we hieronder bestuderen, omdat het de natuurlijke is voor een backtest met een rollende out-of-sample-split.
• Kaarsresolutie. Screen op uurbalken, promoveer naar 1 minuut, ga pas voor de finalisten dieper naar 1 seconde of ruwe trades. Dit is het idee van adaptieve resolutie-drill-down toegepast op zoeken in plaats van op fill-simulatie.
• Lengte van de geschiedenis, epochs, dataset-subsample — de klassieke ML-fidelities.

In een backtest zijn folds en resolutie de twee die ertoe doen, en — dit is het hele punt van het artikel — ze zijn niet gelijk veilig. Een van de twee heeft een bias die stilletjes de verkeerde parameters selecteert, hoe zorgvuldig je het ook bewaakt.

De ene aanname waar alles op rust

Schrijf op wat successive halving werkelijk nodig heeft om correct te zijn. Het heeft niet nodig dat de goedkope fidelity de juiste waarde van de doelfunctie geeft — het kan niemand iets schelen dat één fold een andere Sharpe rapporteert dan zes folds. Het heeft iets zwakkers nodig maar veel specifieker: de goedkope fidelity moet configuraties rangschikken op dezelfde manier als de dure. Als configuratie A configuratie B verslaat op volledige fidelity, zou A B ook op lage fidelity moeten verslaan. Dat is alles. En het is ook alles wat ertoe doet.

Formeel is de grootheid die bepaalt of drill-down werkt de rangcorrelatie tussen de low-fidelity en high-fidelity doelfunctie, over de configuratieruimte heen. Als die correlatie hoog is, zijn de overlevenden van de goedkope ronde dezelfde configuraties die de dure ronde zouden hebben gewonnen, en heb je gratis rekentijd bespaard. Als hij laag is, is de goedkope ronde een willekeurig filter: het verwerpt goede configuraties en promoveert slechte, en je hebt je budget besteed om sneller naar een slechter antwoord te komen. Er is geen tussenliggende instelling van η die je redt — een slechte proxy die zachtjes wordt gesnoeid, lekt nog steeds winnaars; agressief gesnoeid bloedt hij ze leeg.

De mislukking is onzichtbaar op de gebruikelijke manier. De zoektocht voltooit, rapporteert een kampioen, de kampioen ziet er in-sample prima uit. Er wordt geen fout gegooid. Je ontdekt pas dat de proxy loog wanneer de kampioen out-of-sample instort — en tegen die tijd heb je de mislukking toegeschreven aan de strategie, niet aan de zoektocht die hem selecteerde. Dus de discipline is dezelfde waar deze reeks steeds weer op uitkomt: meet wat de methode aanneemt, voordat je de methode vertrouwt. Voor drill-down is de rangcorrelatie het ding om te meten, en de meting is goedkoop.

Het meten: de fidelity gate

De poort is een klein experiment dat je één keer uitvoert, vóór de eigenlijke zoektocht, op dezelfde ruimte die je op het punt staat te doorzoeken. De procedure:

1. Trek een paar honderd configuraties willekeurig uit de parameterruimte (wij gebruiken ~200 — genoeg voor een stabiele Spearman-schatting, goedkoop genoeg om te betalen).
2. Evalueer elk op elke fidelity-trede: op 1 fold, 2 folds, … tot de volledige K folds. Voor een fold-aantal-fidelity is dit vrijwel gratis, omdat de folds die je voor de goedkope tredes berekent, worden hergebruikt in de dure — een cumulatief gemiddelde.
3. Bereken voor elke trede r de Spearman-rangcorrelatie tussen de r-fold-rangschikking en de volledige K-fold-rangschikking, over die ~200 configuraties.
4. De eerste trede waar ρ een drempel overschrijdt (wij gebruiken ρ ≥ 0.5) is de ondiepste fidelity waarbij je mag snoeien. Daaronder is de rangschikking te ruizig om te vertrouwen; je mag daar geen configuraties elimineren.

Het geheel is een paar tientallen regels. De kern ervan:

def fidelity_check(cache, n_probe, seed=7):
    """Spearman ρ: cumulative mean over the first r folds (in FOLD_ORDER)
    vs the full K-fold objective, on n_probe random configs."""
    rng = np.random.default_rng(seed)
    k = len(FOLDS)
    per_fold = np.empty((k, n_probe))
    order_win = np.array([list(FOLDS[fi]) for fi in FOLD_ORDER], np.int64)
    for j in range(n_probe):
        p = _unit_to_params(rng.random(len(PNAMES)))       # random config
        scores, *_ = eval_group(cache, p, _sp_of(p)[None, :], order_win, False)
        per_fold[:, j] = scores[0]                          # score on each fold
    cums = np.cumsum(per_fold, axis=0) / np.arange(1, k + 1)[:, None]  # r-fold mean
    rhos = []
    for r in range(1, k):
        rho = spearmanr(cums[r - 1], cums[-1]).statistic    # r folds vs all K
        rhos.append(0.0 if math.isnan(rho) else rho)
    return rhos

Let op een bewust detail: de folds worden genomen in FOLD_ORDER, een verweven volgorde die vroege en late plakken van de kalender afwisselt (fold 0, dan een middelste fold, dan fold 1, dan een latere, …). Dit is enorm belangrijk en is het onderwerp van een latere sectie: het betekent dat "1 fold" een plak is die het midden van de geschiedenis overspant, en "2 folds" is één vroege plus één late plak — nooit een aaneengesloten recent venster. De goedkope fidelity wordt goedkoper door minder folds te gebruiken, niet door recentere.

Resultaten: één fold rangschikt bijna willekeurig

Hier is wat de poort rapporteerde, uitgevoerd op twee van onze multi-timeframe-opstellingen. Het getal is de Spearman ρ tussen de r-fold-rangschikking en de volledige K-fold-rangschikking over ~200 willekeurige configuraties — hoe getrouw de low-fidelity-rangschikking de full-fidelity-rangschikking voorspelt.

Lees eerst de kolom van het lastigere regime, want die is alarmerend. Bij één fold is ρ = 0.03. Dat is geen zwakke correlatie; het is geen correlatie — de rangschikking op één fold van tweehonderd configuraties is statistisch niet te onderscheiden van ze willekeurig door elkaar husselen. Een successive-halving-run die (zoals de meeste, standaard) is ingesteld om te beginnen met snoeien bij min_resource = 1, zou in dit regime zijn eerste en meest agressieve snede maken op basis van kop of munt. De configuraties die uiteindelijk zouden winnen op volledige fidelity hebben een kans van 50/50 om de allereerste ronde te overleven. Tegen de tijd dat je de fidelity bereikt waar rangschikking iets betekent (ρ = 0.78 bij drie folds), is de meerderheid al verdwenen.

De multi-TF-kolom is milder maar maakt hetzelfde punt op een andere manier. Zelfs daar geeft één fold ρ = 0.43 — onder onze poort van 0.5. Het lijkt een redelijke correlatie, en dat is precies het gevaar: 0.43 is hoog genoeg om je in slaap te sussen en laag genoeg om je beste configuraties te laten lekken. Pas bij twee folds (ρ = 0.67) wordt de rangschikking betrouwbaar.

Twee dingen zijn hieruit te generaliseren. Ten eerste is ρ bij één fold regime-afhankelijk en onbetrouwbaar — we maten overal tussen 0.03 en 0.43 bij verschillende opstellingen, en in geen van beide gevallen haalde één enkele fold de lat. Ten tweede stijgt ρ monotoon en snel: bij drie folds staan beide opstellingen op 0.78, en bij vijf convergeren ze naar 0.91. Het signaal is er; je moet gewoon genoeg fidelity besteden om het te zien. De taak van de poort is precies de trede te vinden waar "genoeg" begint — en snoeien daaronder te verbieden.

Waarom één enkele fold zo ruizig is

De ruis is geen fout in onze fold-constructie; hij is intrinsiek, en begrijpen waarom weerhoudt je ervan het op de verkeerde manier te "repareren." Een enkele walk-forward-fold is een kort venster — weken van één marktregime. De score van een strategie op dat venster wordt gedomineerd door hoe goed zijn parameters toevallig bij dat regime passen, wat maar losjes samenhangt met hoe goed ze generaliseren. Twee configuraties die werkelijk van kwaliteit verschillen, kunnen op één fold van plaats wisselen alleen omdat de ene een trend ving die die fold toevallig bevatte. De doelfunctie op één fold is een schatter met hoge variantie van de doelfunctie waar het je werkelijk om gaat, en rangcorrelatie is precies wat hoge variantie als eerste vernietigt — je kunt het gemiddelde van een schatter behouden terwijl zijn rangschikking pure ruis is.

Meer folds toevoegen middelt die variantie weg. Elke fold is een deels onafhankelijke trekking van marktomstandigheden; het r-fold-gemiddelde is een schatter met lagere variantie, en zijn rangschikking convergeert naar de full-fidelity-rangschikking. Dat is precies de klim ρ = 0.03 → 0.43 → 0.78 → 0.91: niet de doelfunctie die verandert, maar zijn rangschatting die stabiliseert naarmate regimespecifiek geluk wegmiddelt. De les is dat fidelity, voor een backtest, fundamenteel gaat over hoeveel onafhankelijke regimes je hebt bemonsterd — en één is bijna nooit genoeg om op te rangschikken.

Dit verklaart ook waarom het lastigere regime bij 0.03 begint terwijl de multi-TF-run bij 0.43 begint. In het lastigere regime is de enkele fold regimespecifieker — de één-fold-scores van de configuraties worden meer gedreven door geluk en minder door duurzame edge, dus rangschikken ze dichter bij willekeurig. De poort leest dat verschil automatisch af en reageert door meer folds te eisen voordat hij snoeit. Je hoeft niet vooraf te weten in welk regime je zit; je meet.

De poort in code: automatisch de minimale fidelity verhogen

De output van de poort is één enkel geheel getal: min_resource, de ondiepste fidelity waarbij ASHA mag snoeien. De regel is mechanisch — loop de tredes af, neem de eerste waarvan ρ de drempel haalt:

RHO_GATE = 0.5
min_res = len(FOLDS)                      # default: pruning OFF (full fidelity)
rhos = fidelity_check(cache, n_probe=200) # [ρ@1, ρ@2, …, ρ@(K-1)]
passing = [r for r, rho in enumerate(rhos, 1) if rho >= RHO_GATE]
if passing:
    min_res = passing[0]                  # first rung that clears the gate

pruner = SuccessiveHalvingPruner(min_resource=min_res, reduction_factor=3)

Volg het door de twee runs. In de multi-TF-opstelling faalt ρ@1 = 0.43 de poort maar haalt ρ@2 = 0.67 hem, dus wordt min_resource automatisch verhoogd naar 2: ASHA draait elke configuratie op minstens twee folds voordat het iets mag elimineren, en snoeit dan vanaf daar normaal verder. In het lastigere regime falen ρ@1 = 0.03 en ρ@2 = 0.43 allebei; ρ@3 = 0.78 is de eerste die hem haalt, dus wordt min_resource 3. En de cruciale terugvaloptie: als geen enkele trede 0.5 bereikt, is passing leeg en blijft min_resource op K — snoeien wordt volledig uitgeschakeld, en de zoektocht degradeert elegant tot een gewone full-fidelity-zoektocht in plaats van een snelle verkeerde. Een drill-down die zijn proxy niet kan bewijzen, weigert simpelweg te snoeien.

Dit is de hele filosofie in één regel controlestroom. De standaard van elke successive-halving-bibliotheek is "snoei vanaf min_resource = 1, vertrouw de goedkope trede." De poort vervangt dat door "snoei vanaf de eerste trede waarvan de data zegt dat hij betrouwbaar is, en als geen enkele dat is, snoei dan niet." Het kost één vooraf uitgevoerde sonde van ~200 configuraties en het maakt van drill-down een gemeten beslissing in plaats van een daad van geloof. De eliminatiesnelheid η = 3 blijft ongewijzigd; de poort raakt niet aan hoe hard je snoeit, alleen aan hoe vroeg je mag beginnen.

Een eerlijkheidsnotitie zichtbaar in de bovenstaande code: het verhogen van min_resource eet in op de snelheidswinst. Snoeien bij 3 folds in plaats van 1 betekent dat elke configuratie — inclusief de configuraties die je zult weggooien — voor drie folds betaalt. Dat is de prijs van correctheid, en het is de juiste ruil: een 2× kleinere snelheidswinst op een zoektocht die echte winnaars vindt, verslaat een 6× snelheidswinst op een zoektocht die ze weggooit. De poort maakt die ruil expliciet in plaats van hem te verbergen.

De verkeerde goedkope as: kortere geschiedenis is een valstrik

Er is een goedkope fidelity die verleidelijk is, voor de hand liggend, en bevooroordeeld, en het is de moeite waard om hem bij naam te noemen omdat iedereen er als eerste naar grijpt: kortere geschiedenis. Screen configuraties op de laatste maand, promoveer de overlevenden naar de volledige twee jaar. Het is triviaal goedkoop en het voelt als hetzelfde idee als minder folds. Dat is het niet.

Minder folds en kortere geschiedenis verschillen op één beslissende manier. Een fold-aantal-fidelity die goed is gedaan, overspant nog steeds de hele kalender — hij bemonstert hem alleen grover. Een kortere-geschiedenis-fidelity bemonstert dicht een subinterval van de kalender. En een subinterval van marktgeschiedenis is een specifiek regime. Wanneer je configuraties rangschikt op de laatste maand, krijg je geen ruizige-maar-onbevooroordeelde schatting van hun rang over de hele periode; je krijgt een bevooroordeelde schatting die systematisch configuraties bevoordeelt die zijn afgestemd op het regime van de afgelopen maand. Verhoog de steekproefgrootte zoveel je wilt — middel over meer configuraties, meer trials — en de bias krimpt niet, omdat het geen variantie is. Je zult de configuraties promoveren die het beste bij het screeningvenster passen, en dat zijn precies degene die het meest waarschijnlijk overfit zijn op een voorbijgaand regime.

Dit is waarom onze fidelity de folds in een verweven volgorde doorloopt in plaats van chronologisch. Met K folds verspreid over de hele geschiedenis is "1 fold" één plak in de buurt van het midden, "2 folds" is één vroege en één late plak, "3 folds" spreidt vroeg/midden/laat — elk fidelity-niveau, zelfs het goedkoopste, bemonstert over de hele kalender. De goedkope proxy is een grof beeld van de hele periode, nooit een scherp beeld van één plak ervan. Die verweving is wat de fold-aantal-fidelity slechts ruizig maakt (te genezen door de poort) in plaats van bevooroordeeld (wat geen poort kan repareren — een hoge ρ tegen een bevooroordeeld doel bevestigt alleen dat je betrouwbaar de regime-afgestemde configuratie zult kiezen). Als de enige manier om een fidelity goedkoper te maken is hem recenter te maken, heb je geen geldige fidelity. Maak hem in plaats daarvan grover.

Resolutie als de eerlijke goedkope as

De andere goedkope as vermijdt de bias volledig, en het is de natuurlijke partner van de adaptieve drill-down die we beschreven voor fill-simulatie: kaarsresolutie. Screen de hele ruimte op uurbalken, promoveer overlevenden naar 1 minuut, en ga pas voor de handvol finalisten dieper naar 1 seconde of ruwe trades. Grovere kaarsen over dezelfde volledige geschiedenis zijn goedkoper te evalueren — minder balken, snellere indicatorberekeningen, snellere simulatie — en, anders dan een korter venster, is een grof beeld van de hele kalender onbevooroordeeld: het ziet elk regime, alleen met minder intrabar-detail.

Resolutie en folds zijn complementaire fidelity-assen, en de fidelity gate is van toepassing op beide. Voordat je een 1-uur-screening vertrouwt, voer dezelfde sonde uit: neem ~200 configuraties, scoor ze op 1u en op 1m, en meet de rangcorrelatie. Als ρ(1u, 1m) hoog is, is screenen op uren veilig en heb je eerlijk een grote snelheidswinst gekocht. Als hij laag is — wat gebeurt wanneer de edge van de strategie leeft in intrabar-structuur die uurkaarsen wegvegen — dan is uurscreening een willekeurig filter voor die strategie, en de poort vertelt je fijner te beginnen. De regel verandert nooit: je mag alleen snoeien bij een fidelity nadat je hebt gemeten dat zijn rangschikking overeenkomt met de waarheid.

De twee assen falen ook op tegengestelde manieren, wat handig is. Grove resolutie verliest intrabar-informatie; minder folds verliezen cross-regime-informatie. Een momentumstrategie op dagelijkse horizonten kan perfect rangschikken op uurkaarsen maar veel folds nodig hebben om regimegeluk weg te middelen; een scalpingstrategie kan prima rangschikken op weinig folds maar instorten boven 1-seconderesolutie. De poort, per as uitgevoerd, vertelt je op welke fidelity je je voor deze strategie goedkoop kunt veroorloven te zijn — in plaats van een antwoord aan te nemen dat toevallig uitkomt.

Waar de besparingen werkelijk vandaan komen

Een kanttekening die drill-down eerlijk houdt: een fidelity bespaart alleen rekenwerk waar de kosten werkelijk zitten. In onze multi-timeframe-engine is het dure deel het vooraf berekenen van indicatoren — de multi-timeframe-HMA en scheidingssignalen — die één keer per configuratie worden betaald, voordat er ook maar één fold draait. De per-fold-simulatie op de gecachte signalen is relatief goedkoop. Dus snoeien op foldaantal bespaart alleen de simulatiekosten, niet de indicatorkosten die domineren; de fold-aantal-fidelity is echt maar zijn plafond is lager dan de ruwe foldverhouding suggereert.

De resolutie-as daarentegen valt de dominante kosten rechtstreeks aan: grovere kaarsen betekenen minder balken om indicatoren op te berekenen, dus zowel de dure voorberekening als de goedkope simulatie krimpen samen. Dit is geen detail — het bepaalt welke drill-down het waard is om te bouwen. Voordat je investeert in een multi-fidelity-zoektocht, vraag jezelf af waar je seconden naartoe gaan. Als 90% voorberekening van indicatoren is die gedeeld wordt over folds, koopt een fold-aantal-fidelity je weinig en een resolutie-fidelity koopt je veel. Profileer eerst; de juiste goedkope as is degene die de kosten wegneemt die je werkelijk hebt, en hij moet nog steeds de poort halen.

Waar dit mee verbindt

De fidelity gate bevindt zich op een specifiek punt in de keten van backtest-hygiëne van deze reeks:

• Het staat stroomopwaarts van overfitting-controle. Een drill-down die snoeit op een slechte proxy is een nieuwe manier om te overfitten — je laat een ruizige vroege trede je finalisten selecteren. De kampioen moet nog steeds Deflated Sharpe en PBO overleven, en het aantal trials dat die poorten voedt moet elke gesnoeide trial meetellen, niet alleen de overlevenden — snoeien maakt een trial niet gratis ten opzichte van het multiple-testing-grootboek.
• Het deelt zijn vijand met plateau-analyse: een configuratie die één fold of één screeningvenster wint en verder nergens, is hetzelfde regime-afgestemde artefact dat beide instrumenten bestaan om af te wijzen. De poort weigert te selecteren op zo'n fold; plateau-analyse weigert een kampioen te vertrouwen die op één enkele steunt.
• Het veronderstelt de eerlijke walk-forward-split eronder — folds die de hele kalender overspannen, met de out-of-sample apart gehouden — en het is het zoektijd-complement van de drill-down die we bouwden voor fill-simulatie: hetzelfde grof-naar-fijn-principe, toegepast op welke configuraties te evalueren in plaats van op hoe precies ze te vullen.
• En het hangt volledig af van de fidelity die op elke trede lekvrij is. Als de goedkope trede look-ahead-bias heeft die de dure mist, meet ρ overeenstemming met een besmet doel en bevestigt de poort een lek. Meet de rangcorrelatie, ja — maar op een eerlijke doelfunctie.

Het verenigende idee is, opnieuw, degene die deze reeks niet zal ophouden te herhalen: een backtest is een statistisch experiment, en elke kortere weg erin is een hypothese die je verplicht bent te testen. De hypothese van drill-down is "goedkope rang ≈ dure rang." Het is testbaar in ~200 configuraties. Test het.

Belangrijkste conclusies

1. Grof-naar-fijn zoeken rust op één aanname: de goedkope proxy rangschikt configuraties zoals de dure. Niet dezelfde waarde — dezelfde rangschikking. Als de rangcorrelatie laag is, verwerpt agressief snoeien je toekomstige winnaars en promoveert het ruis. Je zoekt sneller naar een slechter antwoord.
2. Meet het voordat je het vertrouwt. Trek ~200 willekeurige configuraties, scoor ze op elke fidelity-trede, en bereken de Spearman ρ tussen elke goedkope trede en de full-fidelity-rangschikking. Het is een paar tientallen regels en één goedkope sonde.
3. Eén fold rangschikt bijna willekeurig. We maten ρ@1 van 0.03 (kop of munt) tot 0.43 (nog steeds onder vertrouwen) afhankelijk van het regime; het klimt naar 0.67, 0.78, 0.82 en 0.91 naarmate folds zich opstapelen. De standaard min_resource = 1 van elke kant-en-klare ASHA is, voor een backtest, meestal verkeerd.
4. Verhoog de minimale fidelity automatisch naar de eerste trede waar ρ ≥ 0.5, en als geen enkele die haalt, snoei dan helemaal niet. De poort werd min_resource = 2 voor de ene opstelling en 3 voor een lastigere; de terugvaloptie degradeert elegant naar een full-fidelity-zoektocht. Correctheid kost wat snelheidswinst — betaal het.
5. Kies de goedkope as op basis van of hij bevooroordeeld is, niet op basis van hoe goedkoop hij is. Kortere geschiedenis is bevooroordeeld — hij selecteert regime-afgestemde parameters en geen steekproefgrootte lost dat op. Gebruik minder folds die de hele kalender overspannen (verweven, niet aaneengesloten) of grovere resolutie over de hele periode. En besteed de goedkope as waar je kosten werkelijk zitten.

Drill-down is een van de beste snelheidswinsten in backtesten, en een van de makkelijkste om te veranderen in een snellere manier om jezelf te bedriegen. Het verschil tussen de twee is één enkel getal dat je kunt meten voordat de zoektocht begint. Als je proxy niet kan bewijzen dat hij rangschikt zoals de waarheid, is het geen proxy — het is een generator van willekeurige getallen met een aannemelijk kostenprofiel.