Wat is de Monte Carlo methode voor het testen van strategie-robuustheid?
Je hebt een strategie gebouwd in Python, getest met je eigen broker API, en de resultaten zien er fantastisch uit.
Een mooi opwaarts pad, winst op elke trade, een prachtige equity curve. Maar hier is de harde waarheid: die resultaten zijn vaak gebaseerd op één specifieke reeks gebeurtenissen. De markt is alleen nooit zo braaf om exact dezelfde volgorde te volgen. De Monte Carlo methode is je reality check. Het is een manier om je strategie te breken, opnieuw te bouwen en te testen op manieren die je niet had kunnen bedenken, om te zien of hij écht overeind blijft staan.
Waarom één backtest een leugen kan zijn
Stel je voor dat je een backtest draait over de afgelopen 2 jaar. Je script haalt data op via de API van een broker zoals Interactive Brokers of LMAX.
Je krijgt een mooie lijn naar boven. Je bent ready om te traden.
Maar wat als je die 2 jaar precies op een andere manier had beleefd? Wat als de volgorde van de prijsbewegingen anders was geweest? Misschien had je net die ene mega-winstgevende trade op dag 100 gehad, en de grootste verliezen op dag 200.
In de echte wereld had die volgorde misschien precies omgedraaid kunnen zijn. Een gewone backtest geeft je één realiteit.
Monte Carlo geeft je er duizend. Het neemt de data die je hebt (de tick data of 1-minuut data) en herschikt deze. Het herschikt de volgorde van de resultaten. Het voegt willekeurige ruis toe.
Op die manier zie je wat er gebeurt als je strategie te maken krijgt met een andere 'loop van de geschiedenis'.
Zo ontdek je of je strategie robuust is of dat hij toevallig goed presteerde op een specifieke volgorde van geluk.
Hoe Monte Carlo precies werkt in je Python-omgeving
De kern van de Monte Carlo methode is willekeur. In plaats van je trade lijst chronologisch af te lopen, herschikken we die lijst.
Stel je hebt een lijst van 500 trades. De Monte Carlo-simulatie pakt deze 500 trades en gooit ze door de war.
Dan loopt hij deze nieuwe, onordende lijst uit. Hij berekent de eindbalans. Dit herhaalt hij misschien 1.000 of 10.000 keer.
Het resultaat is geen enkele equity curve, maar een waaier van duizenden mogelijke curves. In Python is dit redelijk straight forward te bouwen. Je haalt je trade data op via de API van je broker (bijvoorbeeld via de OANDA v20 of de Binance API). Je verwerkt dit in een DataFrame met kolommen als 'entry_time', 'exit_time', 'pnl', 'size'.
De magie gebeurt in een simpele loop. Je gebruikt een bibliotheek als NumPy of Pandas om de volgorde van je 'pnl' array te shufflen.
Je berekent de cumulatieve som. Je slaat het resultaat op.
Monte Carlo is als het opnieuw spelen van een potje poker met dezelfde kaarten, maar in een andere volgorde. Je weet niet of je wint of verliest voordat je de volgorde kent.
Doe dit 5.000 keer en je hebt een dataset van 5.000 mogelijke eindresultaten. Stel je voor: je hebt een strategie die €200 winst maakt in een jaar. In de backtest ziet het er stabiel uit.
Je draait Monte Carlo en ziet dat 10% van de simulaties eindigt met een verlies van €50.
Dat is een wake-up call. Het betekent dat er momenten in de data zaten die, als ze net iets anders waren gelopen, je account hadden geslacht. Je risicomanagement is hier essentieel.
Resampling vs. Random Walk
Zonder goede stop-losses of positie-sizing zou die 10% misschien wel 40% worden. Er zijn een paar manieren om de data te herschikken.
De meest bekende is 'resampling'. Je neemt de lijst van je trade-returns en trekt er willekeurig een aantal uit (met teruglegging). Dit heet bootstrappen.
Je bouwt zo een nieuwe equity curve. Dit is handig om de impact van 'streaks' te zien. Stel je hebt 5 verliezen op rij in je originele data.
Door te bootstrappen kan het zomaar zijn dat die 5 verliezen ineens verspreid raken over de tijd, of juist allemaal op het begin komen. Dat verandert je drawdown drastisch. Een andere variant is de 'Random Walk' aanpak. Hierbij simuleer je niet alleen de volgorde, maar voeg je ook ruis toe aan de returns.
Je zegt: "De gemiddelde winst is €50, maar het kan variëren tussen €20 en €80".
Dit is realistischer voor markten die niet stil staan. Voor high-frequency trading bots of scalping strategieën is deze variant vaak beter, omdat de marktprijs op micro-niveau grilliger is dan de simpele volgorde van je historische trades.
Laten we een voorbeeld nemen met cijfers. Je backtest resultaat is €5.000 winst. Je Monte Carlo simuleert 2.000 runs.
- Mediaan resultaat: €4.800 (niet ver van je originele test).
- 10e percentiel (slechtste 10%): €1.200 winst.
- 1e percentiel (extreem slecht): €-500 (verlies).
In de slechtste scenario's van je Monte Carlo test zit je dus op de rand van break-even of verlies.
Pas dan schrik je wakker en pas je je strategy parameters aan.
De varianten: Price Path vs. Trade Shuffling
Er is een fundamenteel verschil in hoe je de data behandelt. De 'Trade Shuffling' methode die we hierboven besproken hebben, is makkelijk en snel.
Je herschikt simpelweg de uitkomsten. Dit is perfect voor strategieën waarbij de volgorde van trades er minder toe doet, zoals een trendvolgende strategie op daggrafieken. Je weet dat je trades pakt, je weet de gemiddelde winst, je wilt alleen weten of een ongelukkige volgorde je breekt. Een andere aanpak is 'Price Path Shuffling'.
Hierbij pak je niet de trades, maar de prijsdata zelf. Je neemt bijvoorbeeld de 1-minuut candles van de S&P500 index.
Je herschikt de candles per dag. Dus, de openings- en sluitingsprijzen blijven hetzelfde, maar de volgorde van de pieken en dalen binnen die dag wordt willekeurig.
Dit is geavanceerder en rekenintensiever, maar essentieel voor intraday strategies waarbij de exacte volgorde van prijsbewegingen cruciaal is voor je entry en exit triggers. Waarom zou je dit doen? Omdat de markt geen geheugen heeft.
Gisteren was er een dip van 1%. Morgen kan die dip ook gebeuren, maar misschien gebeurt die aan het begin van de sessie in plaats van het einde.
Als je strategie faalt wanneer die dip aan het begin gebeurt, is het geen goede strategie. Met Price Path Monte Carlo test je dit. Je programmeert dit in Python met libraries als Pandas en Numpy.
Je laadt je OHLCV data, chopst het op, en draait je backtest engine eroverheen.
De prijsindicatie voor dit soort werk is nihil als je het zelf codeert. Je hebt een laptop en een internetverbinding nodig.
De data kost geld via de API van je broker of een data provider, maar dat zit vaak in je maandelijkse kosten.
Als je een dure tool zou kopen die dit doet, betaal je al snel €50 - €200 per maand (zoals QuantConnect of specifieke add-ons voor TradingView). Zelf bouwen in Python is vaak gratis, behalve je eigen tijd.
Praktische tips voor je eigen trading bots
Begin klein. Je hoeft niet meteen 10.000 runs te doen.
Start met 100 runs. Kijk of de uitkomsten stabiel zijn.
Als je na 100 runs een bepaalde range ziet, weet je dat je waarschijnlijk genoeg runs hebt. De 'wet van de grote getalen' werkt hier gewoon. Je wilt zeker weten dat je geen toevalstreffers analyseert.
Zorg dat je code schrijft die makkelijk is aan te passen, zodat je snel kunt testen. Focus op de ergste gevallen. De mediaan interesseert je minder. Je wilt weten wat er gebeurt als je in de onderste 5% van de resultaten valt.
Wat is dan je drawdown? Ga je dan failliet?
Als je broker een hefboom aanbiedt van 1:30 (voor retail traders) of 1:100 (voor pro accounts), en je risicomanagement is slecht, dan ben je in die 5% scenario's je account kwijt. Monte Carlo helpt je om je position sizing zo in te stellen dat je die 5% overleeft.
Combineer het met andere tests. Monte Carlo is geen magische bol die alles voorspelt. Gebruik het naast 'Walk-Forward' analyse.
Bij Walk-Forward optimaliseer je op een stuk data en test je op een stuk data daarna.
Monte Carlo herschikt de data die je hebt. Gebruik beide om je bot te harden tegen de markt en vergelijk je resultaten met een benchmark. En onthoud: als je Monte Carlo testen draait op een live account, zorg dan dat je API limieten kent.
Je wilt niet dat je Python script geblokkeerd wordt door je broker omdat je te veel backtests draait via hun historische data endpoint. Let er bovendien op dat resultaten bij je broker vaak afwijken van je eigen code. Een laatste tip: sla de resultaten op.
Sla niet alleen de winst op, maar sla de drawdown, de winstgevendheid en het aantal trades op voor elke run.
Analyseer deze data in Python met Seaborn of Matplotlib. Maak een histogram van de eindwinst. Zie je een scheve verdeling?
Dan is je strategie waarschijnlijk afhankelijk van een paar enorme winsten. Monte Carlo helpt je om die afhankelijkheid te ontdekken voordat de markt je de les leest.