De Recovery Time van een strategie berekenen in Python
Een strategie ziet er op een backtest fantastisch uit. Mooie stijgende lijn, hoge winst.
Maar zodra je hem live zet, zit je direct in een gat.
Een verliesreeks van 10 trades. Je kapitaal is 15% lager. En nu? Hoe lang duurt het voordat je weer op break-even bent?
Dat is de Recovery Time. Het is de meest onderschatte metric in trading.
Iedereen wil weten hoeveel winst, maar niemand vraagt zich af hoe lang je uit de put bent. Tot je een keer flink op je flikker krijgt. Dan had je dit nodig. Recovery Time is simpelweg de tijd die het kost om een dieptepunt in je equity curve goed te maken.
Het gaat niet om het verlies van één trade. Het gaat om het verlies van een serie of een crash.
Je wilt weten: als ik morgen 20% van mijn account verlies, hoeveel trades of dagen ben ik dan kwijt om terug te zijn op mijn startkapitaal? In Python kunnen we dat tot op de dag (of trade) nauwkeurig uitrekenen. Geen gokjes meer. Harde data.
Waarom je deze berekening nu moet maken
Stel je voor dat je een breakout-strategie hebt op de DAX. Je broker (zoals Interactive Brokers of LYNX) geeft je via hun API toegang tot de data.
Je backtest laat een totale return zien van 150% per jaar. Lekker! Maar je maximale drawdown was 35%. Dat betekent dat je op een gegeven moment op 65% van je account zat.
Hoe lang duurde het voordat je die 35% weer had goedgemaakt? Misschien 4 maanden.
In die 4 maanden zat je continue in de stress. En misschien gaf je het op net voordat het weer opliep. Veel traders focussen op de Sharpe Ratio of Profit Factor. Die zeggen iets over efficiëntie, maar niets over het leed dat je moet doorstaan.
Een strategie met een lage winst per trade en een hoge frequentie herstelt sneller van een dipje dan een strategie die slechts 1x per week trade en dikke klappen uitdeelt. Als je weet dat je hersteltijd 3 maanden is, weet je ook dat je risicomanagement strenger moet zijn.
Je kunt niet 2% risico per trade nemen als een verlies van 10 trades je 3 maanden terugwerpt. Dan moet je risico omlaag naar 0.5%.
De kern: Hoe bereken je het in Python?
Om de recovery time te berekenen, heb je maar één ding nodig: je equity curve. Een lijst met je dagelijkse of trade-per-trade balans. Vanuit die lijst zoeken we naar de pieken en dalen.
De logica is simpel: vind een hoogtepunt, vind het volgende dieptepunt dat lager is, en kijk hoe lang het duurt voordat de curve weer boven dat hoogtepunt uitkomt.
Je kunt dit handmatig schrijven, maar met de bibliotheek PyAlgoTrade of simpelweg Pandas en Numpy gaat het in een paar regels code. We gebruiken de expanding functie van Pandas om het maximum tot dat punt te berekenen en vergelijken dit met de huidige waarde.
Als de huidige waarde lager is dan het maximum tot dan toe, zitten we in een drawdown. De recovery time is het aantal stappen (dagen of trades) totdat we dat maximum weer raken. Stel je hebt een equity curve van 100 data-punten.
Op punt 50 is het maximum €15.000. Op punt 55 zakt de curve naar €12.000.
We kijken nu naar punt 56, 57, 58... tot we weer €15.000 raken. Stel dat we op punt 80 weer €15.000 hebben. Dan is de recovery time voor dit specifieke dieptepunt 25 data-punten (80 - 55). We doen dit voor elk dieptepunt in de curve en nemen de gemiddelde of de ergste tijd.
import pandas as pd
import numpy as np
# Simpele equity curve (bijv. na elke trade)
equity = pd.Series([1000, 1100, 1050, 1200, 1150, 950, 1000, 1100, 1300])
# Bereken het maximum tot nu toe (running maximum)
running_max = equity.expanding().max()
# Is de huidige equity lager dan het running max? (Dit is de drawdown status)
in_drawdown = equity < running_max
# We vinden de start van een drawdown en de duur
# Dit is een vereenvoudigde weergave; in de praktijk bereken je de tijd tussen
# een lokale top en het moment waarop die top weer wordt gebroken.
# Een handigere manier: vind de 'peaks' en 'troughs'
# Dit is conceptcode voor de logica:
recovery_times = []
peak_val = equity[0]
peak_idx = 0
for idx, val in equity.items():
if val > peak_val:
# Nieuwe piek bereikt, vorige drawdown is hersteld (indien van toepassing)
peak_val = val
peak_idx = idx
elif val < peak_val:
# We zijn in een drawdown, bereken hoelang het duurt om terug te keren
# Dit doen we later in een aparte loop of door de data te scannen
pass
De echte kunst zit hem in de np.where logica. Je maakt een array van het maximum tot nu toe en vergelijkt die met je equity.
Waar de equity lager is, heb je een drawdown. Vervolgens moet je per segment meten hoe lang het duurt tot de equity terug is op het niveau van de lokale top.
Dit is een standaard rekenmodel dat je in elke backtest van een broker als Degiro of IBKR kunt plakken.
Modellen en varianten: Max Drawdown vs. Max Time Under Water
Er zijn twee hoofdmodellen voor herstel. Ten eerste de Max Drawdown Recovery: de tijd die nodig is om het maximale verlies (de diepste put) te herstellen.
Dit is de klassieke "ik ben alles kwijt" berekening. Als je strategie op de NASDAQ een drawdown van 40% heeft gehad, en je hersteltijd is 6 maanden, dan weet je dat je 6 maanden lang geen winst maakt, maar alleen je verlies aan het goedmaken bent. Een tweede, misschien wel belangrijker model, is Max Time Under Water (Tijd onder water). Dit kijkt niet naar het dieptepunt, maar naar hoe lang je achtereenvolgend onder je vorige hoogtepunt blijft. Wil je weten hoe je een strategie op verschillende tijdsframes valideert?
Stel je hebt een hoogtepunt van €10.000. Je zakt naar €9.500, herstelt naar €9.900, zakt weer, herstelt langzaam.
Pas na 3 maanden ben je weer op €10.001. Dan is je Tijd Onder Water 3 maanden.
Dit voelt mentaal zwaarder dan een snelle, diepe klap. Prijsindicaties voor dit soort analyses via tools: Als je een kant-en-klare tool zoals QuantConnect of Backtrader gebruikt (vaak SaaS, prijzen rond €20-€80 per maand voor de uitgebreidere plannen), hebben ze dit vaak ingebouwd. Maar met Python (gratis) en een beetje tijd (een uurtje coderen) heb je exact hetzelfde.
Je betaalt dus met tijd, niet met geld. Voor professionele risicomanagement software (zoals SimCorp of Bloomberg Port) betaal je duizenden euro's per jaar, maar de kernlogica blijft identiek.
Praktische tips voor risicomanagement
Gebruik de recovery time om je positiegrootte te bepalen. Stel: je berekent dat je gemiddelde hersteltijd 40 trades is als je 2% risico per trade neemt.
Vind je dat te lang (bijv. 2 maanden)? Verlaag je risico naar 1%.
Je zult zien dat je hersteltijd exponentieel korter wordt omdat je minder kapitaal verliest per trade. Je drawdown wordt kleiner en de weg terug is sneller. Check je hersteltijd op out-of-sample data.
Niet alleen in je backtest. Als je live gaat, hou een spreadsheet bij of bouw een scriptje dat je dagelijks equity oppakt van je broker via de API (zoals de TWS API van Interactive Brokers).
Upload die data in je Python script. Zie je dat de hersteltijd in de live markt langer is dan in de event-driven backtester? Stop dan direct met de bot. Je strategie presteert slechter dan verwacht.
Een concrete vuistregel: Als je hersteltijd langer is dan 3 maanden (bij daghandel) of 6 maanden (bij swinghandel), en je drawdown is meer dan 20%, moet je risicomanagement aanpassen.
Of de strategie is gewoon niet houbaar voor je psychologie. Zou je deze backtest in het echt durven draaien? Je hoeft geen genie te zijn om te weten dat je dan beter een andere bot kunt zoeken of je parameters strakker kunt trekken. Houd het simpel, houd het meetbaar.