Random vs Smart Search: De Crossover Zit in de Eval-kosten, Niet in het Algoritme

Onderdeel van de serie "Backtests Zonder Illusies".

Er bestaat een stuk gemeenplaats-wijsheid binnen hyperparameteroptimalisatie: random search is een basislijn die je ontgroeit. Het klassieke resultaat van Bergstra & Bengio (2012) toonde aan dat random grid verslaat; vervolgens zouden Bayesiaanse optimalisatie, TPE, CMA-ES en multi-fidelity-methoden zoals Hyperband/ASHA op hun beurt random moeten verslaan. Toen we dus gingen benchmarken welke parameter-zoekmethoden het beste werken voor onze eigen trading-engine, verwachtten we de gebruikelijke ladder: random onderaan, een slimme sampler bovenaan.

We kregen het tegenovergestelde — en daarna kregen we ook het antwoord uit het boekje. Dezelfde strategie, dezelfde parameterruimte, dezelfde objective, dezelfde machine. Het enige dat we veranderden was hoe duur één backtest was, en de rangschikking van de zoekmethoden keerde om. Toen elke evaluatie goedkoop was, verpletterde een domme scrambled Sobol-reeks elke "slimme" sampler. Toen we elke evaluatie duur maakten, trokken de slimme methoden juist aan de winnende hand en vonden ze de enige configuratie die out-of-sample overleefde.

De les is niet "random wordt onderschat" of "Bayesiaans wordt overschat". De les is dat de crossover tussen random en slim zoeken wordt bepaald door de evaluatiekosten, niet door de sluwheid van het algoritme. Kies je optimizer op basis van wat één backtest kost, niet op basis van zijn reputatie. Dit artikel meet precies waar die crossover ligt, waarom hij daar ligt, en één voorwaarde — fidelity — die bepaalt of de trucs van het dure regime (early stopping, multi-fidelity pruning) überhaupt veilig zijn om te gebruiken.

Alles hieronder komt uit twee scripts in onze backtester: bench_search.py (v4, commit ee092f1) voor het goedkope single-timeframe-regime, en bench_search_multitf.py (commit 102853c) voor het dure multi-timeframe-regime. Beide zijn leak-free — beslissing op de close van bar i, fill op open[i+1] — en beide scoren elke methode op een multi-fold rollende walk-forward-objective met een held-out testvenster dat de zoekmethode nooit ziet.

De vraag: doorvoersnelheid of sample-efficiëntie?

Elke zoekmethode besteedt zijn wall-clock-budget aan twee dingen: beslissen waar het volgende punt wordt bemonsterd (de rekenkracht van de sampler zelf) en het punt evalueren (de backtest uitvoeren). Noem het eerste de ask/tell-kosten en het tweede de eval-kosten. De effectieve zoekkracht van een methode over een vast wall-clock-budget is, ruwweg:

$\text{points explored} \;\approx\; \frac{\text{wall-clock budget}}{\text{ask/tell cost} + \text{eval cost}}$

en de uiteindelijke kwaliteit is dat aantal vermenigvuldigd met hoe goed geplaatst elk punt is. Twee knoppen, die tegen elkaar in werken:

• Doorvoersnelheid — punten per seconde. Domme samplers (random, scrambled Sobol/QMC) hebben vrijwel nul ask/tell-kosten: ze produceren een low-discrepancy-punt en gaan verder. Ze maximaliseren het aantal.
• Sample-efficiëntie — kwaliteit per punt. Slimme samplers (TPE, CMA-ES, ASHA) besteden echte rekenkracht aan het modelleren van de objective om elk punt beter te plaatsen. Ze maximaliseren de plaatsing, ten koste van de doorvoersnelheid.

Welke knop wint hangt volledig af van de noemer. Wanneer de eval-kosten piepklein zijn, domineren de ask/tell-kosten de noemer, dus alles wat die kosten opblaast — een surrogaatmodel, een kernel density estimate, een covariantie-update — verkleint direct het aantal punten dat je verkent. Wanneer de eval-kosten groot zijn, zijn de ask/tell-kosten een afrondingsfout, dus is slimheid in feite gratis en kun je er zoveel van kopen als je wilt.

Dat is de hele these in één zin: de ask/tell-belasting ligt vast, maar het belang ervan wordt bepaald door de eval-kosten waar je hem tegen deelt. Laten we nu kijken hoe dat zich in de praktijk afspeelt.

Het goedkope regime: domme Sobol wint op doorvoersnelheid

Onze single-timeframe-strategie is een leak-free HMA/HMA3-separatieregel over een 7-parameterruimte, geëvalueerd door een in-process numba eval_batch die prange over configuraties draait zonder inter-process overhead. Op deze engine is één backtest bijna gratis — de ruwe kernel evalueert configs met ruwweg 3–4k cfg/s. Dit is het goedkope regime, en het is precies hier dat trading sterk afwijkt van de deep-learning-setting waar de meeste HPO-folklore vandaan komt: onze "objective function" is geen 6 uur durende GPU-trainingsrun, maar een array-pass van 0.3 milliseconde.

We gaven elke methode hetzelfde budget — 1,500 evaluaties — en registreerden de wall-clock die elke methode nodig had om die evals te besteden, plus de held-out-testobjective die het vond. Omdat het eval-budget vastligt, is de wall-clock-kolom een directe uitlezing van de overhead van elke sampler:

TEST is de walk-forward-objective (geannualiseerde PnL-per-actieve-tijd × trade-count-confidence) op een held-out venster dat de zoekmethode nooit heeft aangeraakt; hoger is beter.

Twee feiten springen eruit. Kijk eerst naar de doorvoersnelheidskolom. Scrambled Sobol draait op ~2,830 cfg/s — vlak bij het plafond van de engine. TPE draait op ~154 cfg/s en ASHA op ~95. Dat is een vertraging van 18–30x om exact hetzelfde aantal evaluaties te doen. De slimme samplers evalueren niets extra's; ze besteden die tijd binnenin hun eigen ask/tell-machinerie.

Ten tweede — en dit is het deel dat het verhaal eerlijk houdt — vond geen enkele methode een positief out-of-sample resultaat. Elke TEST-waarde is negatief. In het single-timeframe-regime heeft onze strategie simpelweg geen duurzame OOS-edge, dus "welke methode wint" is geen vraag over uiteindelijke winst; het is een vraag over zoekefficiëntie. En op zoekefficiëntie bij een vast eval-budget winnen de domme methoden ruimschoots: Sobol en random behalen dezelfde of betere held-out-cijfers als de slimme samplers, terwijl ze slechts 1/20e van de wall-clock gebruiken.

Draai de vergelijking nu om zoals een practicus hem in werkelijkheid ervaart — leg de wall-clock vast, niet het aantal evals. Als je elke methode de 15.8 seconden geeft die ASHA nodig had voor zijn 1,500 evals, dan stopt Sobol niet bij 1,500. Sobol gaat door tot ongeveer 45,000 configuraties. In het goedkope regime luidt de vraag nooit "welke sampler plaatst 1,500 punten het best" — het is "heb je liever 1,500 slim geplaatste punten of 45,000 scrambled punten, als elk punt vrijwel gratis is?" Bij een bijna-gratis eval wint breedte. Dertig keer meer dekking van een 7-dimensionale ruimte verslaat een beter model ervan.

De ask/tell-belasting

Waar gaat die 20x naartoe? Niet naar de backtest — die is identiek voor elke methode. Het gaat naar de per-punt boekhouding van de sampler, uitgevoerd in Python, in de lus:

• TPE fit bij elke ask een paar kernel-density-estimates (goede versus slechte trials), en de kosten groeien met de geschiedenis van trials. Multivariate TPE fit ze gezamenlijk over alle dimensies — meer modelleren, meer Python.
• CMA-ES update en bemonstert elke generatie uit een covariantiematrix. Hier goedkoper dan TPE (het draaide op ~850 cfg/s), maar nog altijd een orde van grootte meer overhead dan het produceren van een Sobol-punt.
• ASHA betaalt de promotie/rung-boekhouding van de pruner en, in ons folds-als-fidelity-ontwerp, betaalt de vaste indicator-precompute voordat er ook maar iets gepruned kan worden — dus de "bespaarde" evaluaties besparen minder dan de boekhouding doet vermoeden.

Niets hiervan is kritiek op de algoritmes. Het is precies het punt: de ask/tell-kosten zijn een min of meer vast aantal milliseconden per punt, en wanneer de eval die eromheen zit ook maar een paar milliseconden kost, is die vaste kost plotseling 90% van je budget. De slimme sampler besteedt negen tiende van zijn wall-clock aan nadenken over waar te kijken en een tiende aan daadwerkelijk kijken. Een scrambled Sobol-reeks besteedt alles aan kijken. Als kijken goedkoop is, wint kijken.

We hebben hier bewust geen volledige Bayesiaanse optimizer met Gaussian process gebenchmarkt, en om dezelfde reden: een GP-surrogaat is $O(n^3)$ in het aantal trials. Tegenover een eval die milliseconden kost, zou het fitten van het surrogaat het hele zoekbudget opsouperen voordat het een betekenisvol deel van de ruimte had geëvalueerd. In het goedkope regime wordt GP-BO gediskwalificeerd door pure rekenkunde.

Het dure regime: de crossover keert om

Nu maken we één backtest duur. De multi-timeframe-strategie stapelt een hoge, een midden- en een lage timeframe (triple-TF), waarbij elke laag een eigen indicator-pass en eigen drempels bijdraagt, allemaal gescoord over dezelfde multi-fold walk-forward. Eén evaluatie kost nu in de orde van 0.1–0.5 seconden in plaats van 0.3 milliseconde — een sprong van drie ordes van grootte. De eval-kosten zijn verschoven van de afrondingsfout-term in onze noemer naar de dominante term. Volgens de these zou de ask/tell-belasting nu niet meer moeten uitmaken en zou slimheid moeten gaan lonen. En dat gebeurt ook.

We draaiden elke methode onder een vast wall-clock-budget van ~150 seconden op het triple-TF-probleem (een 18-parameterruimte), lieten elke methode dat budget besteden zoals zijn sampler dat dicteert, en evalueerden de enkele beste config die eruit kwam op een held-out testvenster:

TEST is dezelfde walk-forward-objective als eerder. Slechts één methode kwam boven nul uit.

De domme Sobol-baseline die het goedkope regime domineerde, staat nu helemaal onderaan, op −673. Blinde low-discrepancy-bemonstering van een 18-dimensionale ruimte, met slechts 349 evaluaties te besteden omdat elke evaluatie duur is, lokaliseert nooit iets. De slimme methode, sobol→cmaes — 30% van het budget op Sobol om een basin te seeden, gevolgd door CMA-ES-verfijning vanaf de beste seed — is de enige methode die überhaupt een positief out-of-sample-resultaat opleverde. Op de finale, ongebruikte holdout behaalde de kampioen +2.62% (19 trades, ~6.6% kapitaalexposure) bovenop een testvenster dat +16.35% opleverde (46 trades, ~15.7% exposure). De kampioen van elke concurrent verloor geld out-of-sample.

Dat is de crossover, gemeten op dezelfde strategiefamilie, dezelfde objective, dezelfde machine: verander niets anders dan de kosten van één evaluatie, en de rangschikking van de zoekmethoden keert om. In het goedkope regime wint Sobol en zijn de slimme samplers een verspilling van 20x; in het dure regime is de slimme sampler het enige dat werkt en is Sobol de verspilling.

Waarom "slim" hier wint — en het is niet alleen sample-efficiëntie

De opgeruimde versie van dit verhaal is: "dure evals belonen sample-efficiëntie, dus wint de methode die minder, betere punten plaatst." Dat is voor de helft waar, en de data dwingt ons tot de eerlijke, interessantere andere helft.

Kijk nog eens naar de eval-aantallen. sobol→cmaes won niet door minder punten te evalueren dan blinde Sobol — het evalueerde 15,239 tegenover Sobol's 349, veertig keer meer, in dezelfde 150 seconden. Hoe? Omdat onze multi-TF-eval-kosten gestructureerd zijn, niet uniform. Er zijn twee assen: een dure indicator-as (de timeframe-periodes en HMA-lengtes, elk 30–500 ms om te berekenen, omdat ze een indicator-recompute afdwingen) en een goedkope drempel-as (de entry/exit-separatieniveaus, elk ~1–2 ms op gecachte signalen). De kloof daartussen is 30–100x.

Blinde Sobol negeert deze structuur. Elk punt dat het trekt, jittert de dure indicator-as, wat een verse recompute afdwingt — dus betaalt het de volle prijs op alle 349 evaluaties. sobol→cmaes houdt, zodra CMA-ES een veelbelovende regio heeft gelokaliseerd, de grove indicatorstructuur doorgaans ongeveer vast en verstoort het de continue drempels, die op gecachte signalen terechtkomen en vrijwel niets kosten. De slimme methode zet dezelfde wall-clock om in zowel beter geplaatste punten als veel meer daarvan, omdat adaptief zijn hier betekent dat je cost-aware bent: op de goedkope as blijven nadat de dure as is vastgepind. Onze expliciete cascade(sobol²×64)-exploit doet dit het meest agressief — 20,864 evals door goedkope drempels te batchen op gecachte signalen — en hoewel die de triple-TF-test verloor, won hij in de two-timeframe-variant het testvenster ruimschoots met +20.2% (voordat hij zijn eigen holdout niet doorstond — daarover hieronder meer).

Dus de scherpere formulering van de crossover: in het dure regime wordt de ask/tell-belasting verwaarloosbaar, wat je vrijmaakt om slim te zijn — en "slim" betekent hier: je aanpassen aan de kostenstructuur van de objective, niet alleen aan de vorm ervan. Blinde bemonstering kan geen van beide. Dit is precies de tweeassige structuur waarrond onze adaptive-resolution drill-down-engine is gebouwd om te exploiteren, en het is waarom multi-fidelity-methoden thuishoren in het dure regime — mits aan één voorwaarde is voldaan.

Fidelity: de verborgen voorwaarde voor pruning

Multi-fidelity-methoden — Hyperband, ASHA, elke early-stopping-pruner — rusten op één aanname: dat een goedkope, gedeeltelijke evaluatie configuraties op dezelfde manier rangschikt als de dure, volledige evaluatie zou doen. Als een config die er goed uitziet op één walk-forward-fold, er ook goed uitziet op alle andere, kun je de verliezers vroeg elimineren en het budget van de overlevenden besteden aan de winnaars. Als de goedkope fidelity willekeurig rangschikt, is early stopping niets anders dan goede configs weggooien op basis van een muntworp.

Dus voordat we een pruner vertrouwen, meten we de aanname rechtstreeks. Onze fidelity is het aantal walk-forward-folds (goedkoop evalueren op r folds, of alle K folds tegen volle kosten), en de fidelity-gate berekent de Spearman-rangcorrelatie ρ tussen de goedkope r-fold-objective en de volledige objective over een steekproef van willekeurige configs. ρ@1 is de correlatie wanneer je oordeelt op basis van een enkele fold — de meest agressieve, goedkoopste fidelity. Dit is wat die gate rapporteerde over de twee regimes:

In het single-timeframe-regime rangschikt één fold configs met een correlatie van ~0.03 ten opzichte van de waarheid — statistisch niet te onderscheiden van willekeur. Dat is geen toeval; het is hetzelfde feit als "geen enkele methode vond een OOS-edge". Wanneer een strategie geen duurzaam signaal heeft, is de prestatie per fold vooral geluk, dus is elke afzonderlijke fold een bijna-willekeurige trekking, en zou low-fidelity-pruning goede configs elimineren en gelukkige configs promoten. Multi-fidelity is hier onveilig in het goedkope regime — niet omdat de methode slecht is, maar omdat het goedkope signaal ruis is. (Onze gate signaleert dit en weigert agressief te prunen.)

In het multi-timeframe-regime bestaat er een echte edge, en verandert het fidelity-beeld volledig: ρ@1 stijgt naar 0.43, en bij vijf folds klimt ρ naar 0.91. Nu draagt één fold echte rangschikkingsinformatie en dragen vijf folds bijna alles daarvan. Early stopping wordt veilig — een config die verliest op de eerste paar folds, is ook werkelijk waarschijnlijk een verliezer. Dit is de tweede reden waarom multi-fidelity-methoden thuishoren in het dure regime: niet alleen omdat dure evals pruning de moeite waard maken, maar omdat het dure regime precies is waar de goedkope fidelity eindelijk net zo rangschikt als de dure.

De regel die hieruit volgt is bot en goedkoop om uit te voeren: meet ρ voordat je pruned. Fidelity-correlatie is een berekening van twee regels code op een paar honderd willekeurige configs, en het is het verschil tussen multi-fidelity-search die je versnelt en multi-fidelity-search die je in stilte saboteert.

De zoektocht winnen is hem niet overleven

Nog één eerlijkheidsnoot, want deze serie gaat over backtests die liegen. Onze triple-TF-kampioen, sobol→cmaes, was de enige methode met een positieve holdout — +2.62%, bovenop +16.35% in het testvenster. Dat is het goede nieuws. Hier is de kanttekening: hij overleefde de statistische deflatie niet.

De kampioen is de beste van tienduizenden configuraties die zijn geprobeerd over alle methoden heen. Bij zo veel multiple testing is een holdout van +2.62% niet automatisch echt. We hebben de overfitting-gates gedraaid waar de hele serie op leunt — de Deflated Sharpe Ratio met effective-N gecorrigeerd voor de correlatie tussen trials, en PBO via combinatorially-symmetric cross-validation. De kampioen doorstond PBO (0.12, ruim onder de drempel van 0.2 — zijn rang is stabiel over de CSCV-splits) maar zijn deflated Sharpe stortte in tot nul (de gate eist ≥ 0.95). Oordeel: overleeft niet.

Lees dat aandachtig, want het is het hele punt van deze exercitie. Het crossover-resultaat is echt: slim zoeken won de zoektocht in het dure regime, en wel overtuigend, en Sobol verloor hem. Maar de zoektocht winnen is een uitspraak over de optimizer, niet over de strategie. De beste config die een goede optimizer kan vinden in een edgeloze ruimte is nog altijd edgeloos — deflatie is wat je vertelt welke van de twee je in handen hebt. De juiste zoekmethode kiezen levert je efficiënt het best beschikbare antwoord op; het fabriceert geen edge die er nooit was. De optimizer en de overfitting-gates zijn verschillende instrumenten die verschillende dingen meten, en je hebt ze allebei nodig.

Een beslisregel die je daadwerkelijk kunt toepassen

Je hoeft onze benchmark niet opnieuw te draaien om een optimizer te kiezen. Je hebt maar één getal nodig: hoelang duurt één backtest? Meet de tijd van één enkele evaluatie van je objective — één volledige walk-forward-pass, alle folds — en lees daaruit het regime af.

• Goedkope eval (≲ ~10 ms/backtest): koop doorvoersnelheid. Gebruik scrambled Sobol/QMC of random. De ask/tell-belasting van TPE/CMA-ES/ASHA kost je 10–30x je puntenaantal, voor een plaatsing die een bijna-gratis eval niet beloont. Doe niet aan multi-fidelity-pruning — en als je in de verleiding komt, check dan eerst ρ@1; in een low-edge goedkoop regime ligt die waarschijnlijk vlak bij nul, wat betekent dat pruning neerkomt op een muntworp. Besteed de bespaarde engineering-tijd aan het verbreden van de zoektocht, niet aan het versmallen ervan.
• Dure eval (≳ ~100 ms–seconden/backtest): koop sample-efficiëntie. Gebruik CMA-ES, TPE, of een Sobol-seeded CMA-ES-hybride; de sampler-overhead is nu een afrondingsfout tegenover de eval. Als je eval-kosten gestructureerd zijn (een trage indicator-as en een snelle drempel-as, zoals bij multi-TF), geef dan de voorkeur aan methoden die deze structuur exploiteren — cascades, drill-downs, alles wat cost-aware is — boven methoden die elke dimensie als even duur behandelen.
• Ertussenin, of niet zeker: een Sobol-seeded hybride (sobol→cmaes) is de robuuste standaardkeuze. Vroeg in de zoektocht gedraagt hij zich als breadth-first Sobol (goedkoop, geen model om te fitten), later als een slimme verfijner, waardoor hij gracieus degradeert in welk regime je ook blijkt te zitten — precies waarom hij onze kampioen was in het dure regime.
• Meet fidelity voordat je pruned. Bereken Spearman ρ tussen de goedkope fidelity en de volledige objective op een paar honderd willekeurige configs. Als ρ@1 laag is, prune dan niet op één fold; verhoog de minimale resource totdat ρ boven ~0.5 uitkomt. Dit kost twee regels code en voorkomt dat je accelerator in stilte je beste configs weggooit.
• Welke methode de zoektocht ook wint, draai de deflatie-gates. De winnaar van de optimizer is het object dat de hele week het meest vatbaar is voor overfitting. DSR en PBO, niet de score van de optimizer, bepalen of hij verhandelbaar is.

Waar dit op aansluit

Dit resultaat zit in het hart van een paar draden die deze serie al heeft getrokken:

• Het veronderstelt dat de onderliggende engine eerlijk is. Het hele voordeel van het goedkope regime bestaat omdat onze in-process numba-engine duizenden configs per seconde haalt zonder IPC — de speed ladder is wat je überhaupt in het regime brengt waar doorvoersnelheid wint. Een trage, door frameworks belaste engine zou elk probleem standaard in het dure regime plaatsen, en je zou de crossover nooit zien.
• De exploit van het dure regime is precies de tweeassige kostenstructuur waarrond onze adaptive-resolution drill-down-engine is ontworpen: lokaliseer op de grove, dure as, exploiteer vervolgens de fijne, goedkope as.
• Elke methode hier is alleen betrouwbaar omdat de engine leak-free is. Een zoektocht over tienduizenden trials is de meest efficiënte machine denkbaar om een look-ahead-bug te vinden en te exploiteren — de "winnaar" zou dan gewoon de config zijn die het hardst op de leak leunde. Fix eerst de klok, zoek daarna.
• En het lot van de kampioen — de zoektocht winnen, de deflatie niet doorstaan — is het hele argument om parameter search en overfitting-controle als aparte fases met aparte instrumenten te behandelen.

De academische achtergrond is dezelfde waar het vakgebied steeds naar terugkeert: Bergstra & Bengio (2012) over waarom random grid verslaat; Hyperband van Li et al. (2018) en de ASHA-opvolger (2020) over multi-fidelity; en Bailey & López de Prado (2014) over waarom de winnaar van elke grote zoektocht gedeflateerd moet worden voordat je hem gelooft. Geen van hen schrijft één beste optimizer voor, want die bestaat niet — er is een regime, en een kostenpost die het bepaalt.

Belangrijkste inzichten

1. De crossover tussen random en slim zoeken wordt bepaald door de evaluatiekosten, niet door het algoritme. We keerden de rangschikking van elke methode om door niets anders te veranderen dan hoe duur één backtest was.
2. Goedkope eval → domme Sobol wint op doorvoersnelheid. Op onze single-TF-engine (~3–4k cfg/s) draaiden TPE en ASHA 18–30x trager voor hetzelfde aantal evals — ~95–154 cfg/s tegenover ~2,830 voor Sobol. Bij gelijke wall-clock verslaat breedte een beter model van de ruimte, wanneer elk punt vrijwel gratis is.
3. Dure eval → slimme methoden winnen op efficiëntie. Op het triple-TF-probleem was sobol→cmaes de enige methode die een positief out-of-sample-resultaat vond (+16.35% test, +2.62% holdout); blinde Sobol eindigde helemaal onderaan.
4. In het dure regime betekent "slim" cost-aware. De winnaar exploiteerde de kloof van 30–100x tussen de dure indicator-as en de goedkope drempel-as — hij deed meer evals en plaatste ze beter, door op de goedkope as te blijven zodra de dure as was vastgepind.
5. Fidelity is de voorwaarde voor pruning. De single-fold-rangcorrelatie steeg van ρ@1 ≈ 0.03 (single-TF, in feite willekeurig) naar 0.43 (multi-TF), en bereikte 0.91 bij vijf folds. Multi-fidelity/ASHA loont pas zodra de goedkope fidelity net zo rangschikt als de dure — dus meet ρ voordat je pruned.
6. De zoektocht winnen is hem niet overleven. De kampioen doorstond PBO maar faalde op de Deflated-Sharpe-gate. Kies de optimizer op basis van eval-kosten; bepaal verhandelbaarheid met de deflatie-gates. Het zijn verschillende instrumenten, en je hebt ze allebei nodig.

Kies je optimizer op basis van wat één backtest kost. Onthoud dan dat het beste antwoord dat een optimizer kan vinden in een edgeloze ruimte nog altijd edgeloos is — en laat de gates, niet de zoektocht, je vertellen welke van de twee je in handen hebt.