Multiprocessing gebruiken in Python om backtests te versnellen
Stel je voor: je hebt een prachtige strategie gebouwd in Python, je broker API is ingesteld, en je wilt weten of je bot geld zou hebben verdiend in 2023.
Je start een backtest op één core van je laptop. Het duurt uren. Misschien wel een hele nacht. Dat voelt frustrerend, vooral als je weet dat je machine veel meer kan.
Gelukkig hoef je niet te wachten. Met multiprocessing kun je al je CPU-kernen tegelijkertijd laten werken, waardoor je backtests soms wel 10 tot 20 keer sneller gaan. Dat betekent dat je in plaats van een hele nacht, een strategie in 20 minuten kunt valideren.
Waarom snelheid essentieel is in trading
In de wereld van algoritmische trading is tijd geld. Als je een daghandel-strategie wilt testen over drie jaar aan tick-data van Interactive Brokers of XT, kan een enkele run makkelijk 50.000 tot 100.000 iteraties vergen.
Zonder multiprocessing draait dit lineair op één processor. Je zit te wachten, terwijl je machine voor 75% niets doet.
Multiprocessing benut al je beschikbare cores – denk aan 4, 8 of zelfs 16 – om tegelijkertijd parameters te testen of verschillende tijdframes te doorlopen. Stel je voor dat je een momentum-strategie op de AEX-index test met 50 verschillende stop-loss en take-profit combinaties. Zonder parallelisatie duurt dat misschien 3 uur.
Met multiprocessing op een moderne laptop met 8 cores, knal je daar doorheen in 20 minuten. Die tijdswinst is cruciaal als je snel moet schakelen tussen marktomstandigheden of je risicomanagement wilt fine-tunen.
De kern van multiprocessing in Python
Python heeft een ingebouwde module die heet multiprocessing. Die maakt het mogelijk om aparte processen te starten, elk met hun eigen geheugenruimte.
Dat is anders dan threading, waarbij Python door de Global Interpreter Lock (GIL) vaak maar één thread tegelijkertijd laat draaien. Bij CPU-intensieve taken zoals backtesten is multiprocessing dus de betere keuze. Je start een hoofdproces dat taken verdeelt over subprocessen.
Een simpel voorbeeld: je hebt een functie die een backtest draait voor één set parameters. Je kunt deze functie aanroepen in een pool van processen.
De pool verdeelt de taken over je beschikbare cores. Als je 4 cores hebt en 20 parametercombinaties, draaien er 4 tegelijkertijd.
Zodra één klaar is, pakt de pool de volgende op. Zo blijft je CPU constant bezig zonder dat je zelf taken hoeft te schedulen. Belangrijk om te weten: multiprocessing heeft overhead. Het opstarten van een nieuw proces kost tijd en geheugen.
Daarom is het slim om niet voor elke kleine iteratie een nieuw proces te starten. Groeperen van taken vermindert die overhead. Voor backtests met veel data is deze overhead vaak verwaarloosbaar ten opzichte van de rekentijd.
Stappenplan: van code naar snelheid
Stap 1: identificeer wat je parallel wilt draaien. Meestal zijn dat parametercombinaties, verschillende instrumenten, of tijdframes.
Bijvoorbeeld: test een RSI-strategie op Apple, Microsoft en Tesla, elk met 10 parameterinstellingen. Dat zijn 30 runs. Die kun je makkelijk verdelen.
Stap 2: zorg dat je backtestfunctie puur is. Geen globale variabelen die tussen processen kunnen conflicteren.
Geef alle data mee als argumenten. Als je vanuit een Pandas DataFrame werkt, kopieer die dan per subprocess of gebruik read-only arrays. Zo voorkom je dat processen elkaars geheugen overschrijven. Stap 3: gebruik de Pool.map functie.
from multiprocessing import Pool
import backtrader as bt # of je eigen backtest-engine
def run_backtest(params):
cerebro = bt.Cerebro()
# voeg data toe vanuit broker API of CSV
# voeg strategie toe met params['rsi_period'], params['buy_threshold']
cerebro.run()
return cerebro.broker.getvalue()
if __name__ == '__main__':
param_list = [{'rsi_period': p, 'buy_threshold': q} for p in range(10, 31, 2) for q in range(20, 81, 10)]
with Pool(processes=8) as pool:
results = pool.map(run_backtest, param_list)
Hieronder een voorbeeld in pseudocode, specifiek voor een trading context: Stap 4: analyseer de resultaten.
Je krijgt een lijst met eindsaldi per combinatie. Sorteer op risico-reward en kijk naar drawdown. Gebruik die data om je risicomanagement aan te scherpen, zoals het instellen van een trailing stop op basis van de gemiddelde true range.
Modellen en varianten met prijsindicaties
Er zijn verschillende manieren om multiprocessing in te zetten, afhankelijk van je broker en data. Een populaire aanpak is parameter grid search.
Je test een reeks waarden voor indicatoren zoals RSI, MACD of Bollinger Bands.
Voor een AEX-strategie kun je een grid bouwen van 50 tot 200 combinaties. Op een 8-core machine met 16 GB RAM kost dit vaak minder dan een half uur, afhankelijk van de datagrootte. Een andere variant is Monte Carlo-simulatie voor risicomanagement.
Je draait duizenden runs met willekeurige startmomenten of geluid in je data. Parallelisatie maakt dit haalbaar zonder dagen te wachten.
Voor een portfolio van 10 aandelen met elk 500 runs, kom je op 5.000 runs. Op een krachtige workstation (€1.500 - €2.500) met 16 cores, ben je binnen een uur klaar. Je kunt ook verschillende dataverzamelingen parallel verwerken. Denk aan intraday data van 1 minuut versus 5 minuten, of meerdere brokers zoals Interactive Brokers en DEGIRO vergelijken.
Als je voor elk een aparte backtest draait, kun je backtests efficiënt parallel uitvoeren om die taken gelijktijdig te verwerken.
Let wel op API-limieten: broker APIs hebben vaak rate limits, zoals 100 requests per seconde. Verdeel je aanvragen over processen om blokkades te voorkomen. Vergeet ook niet dat je voor betrouwbare marktdata een professioneel Python data-feed abonnement nodig hebt. Prijsindicaties voor hardware: een laptop met een Intel i7 of Apple M2 van rond de €1.200 - €1.800 is vaak al voldoende voor 8-12 cores.
Een desktop met AMD Ryzen 9 (16 cores) kost tussen €1.800 - €2.500 en levert een enorme boost voor grotere grids. Cloud-opties zoals AWS EC2 (c5.2xlarge) kosten circa €0,34 per uur en bieden 8 vCPUs. Handig als je incidenteel grote backtests draait.
Praktische tips voor soepel draaien
- Beperk het geheugen per proces: kopieer alleen de benodigde data. Gebruik indien mogelijk numpy arrays in plaats van volledige Pandas DataFrames.
- Log per subprocess: schrijf resultaten direct weg naar een JSON of CSV per run, zodat je geen gegevens verliest bij een crash.
- Test eerst op kleine schaal: begin met 4 runs en 4 cores. Controleer of de uitkomsten kloppen voordat je opschaaft.
- Monitor CPU en RAM: gebruik tools zoals htop (Linux) of Task Manager (Windows). Zorg dat je niet tegen swap aanloopt, dat vertraagt enorm.
- Let op API-limieten: bij live trading via broker API, stel een vertraging in tussen calls. Gebruik time.sleep(0.1) per call om rate limits te respecteren.
- Vermijd nested multiprocessing: draai niet binnen een pool nog een pool. Dat leidt tot deadlock.
- Kies de juiste broker: Interactive Brokers biedt een stabiele API voor Python, maar de instap is technisch. DEGIRO is eenvoudiger maar minder uitgebreid voor algoritmisch gebruik.
Een laatste tip: combineer multiprocessing met risicomanagement. Voor wie de basis nog wil versterken: lees onze Python voor financiële analyse gids. Bereken na elke run de Sharpe ratio, maximum drawdown en winstpercentage.
Sla deze metrics op en filter later de beste parameters eruit. Zo voorkom je dat je blindelings de hoogste return achtervolgt zonder rekening te houden met risico.
Met deze aanpak versnel je je backtests aanzienlijk en houd je tijd over voor wat echt telt: het verfijnen van je strategie en het beheren van je risico. Je machine doet het zware werk, jij blijft de strategische beslissingen nemen. En dat is precies hoe je als algoritmische trader voorop blijft lopen.