Logaritmische returns vs simpele returns in Python
Stel je voor: je hebt een Python-script gebouwd dat een handelsstrategie op de historische data van bijvoorbeeld Interactive Brokers of Binance test.
Je kijkt naar je resultaten en ziet een mooie stijgende lijn. Maar klopt die lijn wel?
Gebruik je de juiste wiskunde om je winst te meten? Het verschil tussen simpele returns en logaritmische returns is klein in percentages, maar gigantisch in betekenis, vooral als je risicomanagement en compound interest serieus neemt. Laten we dit samen uitzoeken, zonder ingewikkelde formules, maar met praktische Python-code voor je trading bots.
Wat zijn simpele returns eigenlijk?
Simpele returns, of discrete returns, zijn wat je waarschijnlijk als eerste leert. Het is de procentuele verandering tussen twee tijdstippen.
Stel, je koopt een aandeel voor €100 en verkoopt het later voor €110.
Je winst is €10, en je simpele return is 10%. Dit voelt intuïtief correct en is makkelijk uit te rekenen. In Python bereken je dit met een eenvoudige formule: (huidige_prijs - vorige_prijs) / vorige_prijs.
Als je een Pandas DataFrame hebt met prijzen, doe je dit makkelijk met de `.pct_change()` functie. Het is snel, direct en voor één transactie perfect. Waarom gebruiken zoveel mensen dit? Omdat het makkelijk te communiceren is.
Tegen een vriend zeg je niet "ik heb een logaritmische return van 0,0953", je zegt "ik heb 10% rendement".
Het is de taal van de financiële markten en de meeste brokers tonen dit in hun dashboards. Maar er zit een addertje onder het gras.
Simpele returns werken niet goed bij meerdere transacties achter elkaar, vooral niet als je winst en verlies afwisselt. Een verlies van 50% gevolgd door een winst van 50% betekent niet dat je break-even bent. Je bent dan nog steeds 25% kwijt. Dit is de valkuil van simpele returns.
De kracht van logaritmische returns
Logaritmische returns (ook wel continu compound returns genoemd) lossen het compoundingsprobleem op.
In plaats van procentuele veranderingen, kijk je naar de logaritmische waarde van de prijsverhouding. De formule is simpel: log(huidige_prijs / vorige_prijs). In Python gebruik je hiervoor de `numpy.log()` functie. Stel opnieuw: je verliest 50% (return van -0,50) en wint daarna 50% (return van +0,50).
Bij simpele returns tel je ze op: 0% totaalrendement. Bij logaritmische returns is de som nul: -0,693 + 0,405 = -0,288.
Wacht, dat klopt niet helemaal. Laten we het simpel houden: de som van logaritmische returns over een periode is altijd de log van de eindwaarde gedeeld door de beginwaarde.
Ze zijn tijd-additief, wat betekent dat je ze kunt optellen zonder dat compoundings-effect de boel verstoort. Waarom is dit cruciaal voor algoritmische trading? Omdat je strategieën backtest op historische data.
Je bot handelt misschien 100 keer per dag op een exchange als Binance of BitMEX. Je totale rendement over een jaar is het product van al die individuele returns.
Logaritmische returns maken deze berekening stukken eenvoudiger en voorkomen fouten in je risicomanagement modellen. Stel je voor dat je een Python-script bouwt voor een mean-reversion bot op de NASDAQ. Je gebruikt de API van Interactive Brokers.
Als je simpele returns gebruikt, kan je totaalrendement er beter uitzien dan het in werkelijkheid is, vooral als je strategie veel kleine winsten en enkele grote verliezen heeft.
Logaritmische returns geven een eerlijker beeld van je werkelijke groei.
Python in de praktijk: een directe vergelijking
Laten we even praktisch worden met code. Stel, je hebt een lijst met prijzen van een aandeel of crypto.
Je wilt de returns berekenen voor je backtesting script. Voor simpele returns in Python met Pandas: Dit geeft je een reeks percentages: NaN, 0,05, -0,019, 0,068.
import pandas as pd
prijzen = pd.Series([100, 105, 103, 110])
simpele_returns = prijzen.pct_change()
print(simpele_returns)Makkelijk te begrijpen, direct te plotten in een equity curve. Voor logaritmische returns met NumPy:
Dit geeft kleine getallen: NaN, 0,0488, -0,0192, 0,0657. Zie je hoe dichtbij elkaar ze liggen? Voor kleine returns is het verschil verwaarloosbaar. Maar als je een aandeel ziet dalen van €100 naar €10 (een daling van 90%), is de simpele return -90%, maar de logaritmische return is ln(10/100) = -2,30.
import numpy as np
log_returns = np.log(prijzen / prijzen.shift(1))
print(log_returns)Een veel groter getal, maar wiskundig correcter voor compoundberekeningen. Wanneer kies je wat in je Python-bot?
Als je een snelle analyse doet van één trade, is simpele return prima. Als je een backtest bouwt waarin je duizenden trades simuleert en je wilt het risico berekenen (bijvoorbeeld standaarddeviatie van de returns), zijn logaritmische returns de standaard. Ze zijn symmetrisch en beter voor statistische analyse.
Waarom dit uitmaakt voor risicomanagement en brokers
Risicomanagement is het hart van elke trading bot. Stel, je gebruikt de API van een broker zoals DEGIRO of Interactive Brokers en je wilt logging implementeren om fouten op te sporen.
Je bot moet weten wanneer hij moet stoppen met handelen. Hiervoor bereken je de volatiliteit van je returns. Logaritmische returns geven een stabielere schatting van volatiliteit, vooral bij extreme marktbewegingen.
Simpele returns zijn asymmetrisch. Een stijging van 10% en een daling van 10% voelen hetzelfde, maar zijn dat niet in getallen.
Logaritmische returns zijn symmetrisch: een log-return van 0,10 (10,5% simpele return) en -0,10 (-9,5% simpele return) compenseren elkaar precies. Dit is essentieel voor het berekenen van je Value at Risk (VaR) in Python. Denk aan een Python-bot die handelt op meerdere assets, zoals aandelen en crypto.
Je wilt je totale portfolio rendement berekenen. Met simpele returns moet je rekening houden met de volgorde van trades.
Met logaritmische returns kun je de returns gewoon optellen, wat het backtesting proces versnelt.
Geen gedoe met compoundformules in je code. Broker-kosten spelen hier ook een rol. Stel, je betaalt €5 per transactie bij een broker zoals Lynx. Je rendement na kosten is lager.
Logaritmische returns helpen je om de netto-impact van kosten beter te modelleren, vooral bij hoge frequentie trading. Je simulatie in Python wordt realistischer.
Concrete criteria: een eerlijke vergelijking
Laten we beide opties langs de meetlat leggen voor algoritmische trading in Python.
- Prijs (tijd/rekenkracht): Simpele returns zijn gratis en snel in Python met Pandas. Logaritmische returns vereisen NumPy, maar dat is ook gratis en even snel. Geen verschil in hardware-kosten.
- Capaciteit: Beide werken met grote datasets (bijv. 10 jaar tick-data van Binance). Simpele returns zijn iets lichter, maar voor 99% van de bots maakt het niets uit.
- Gebruiksgemak: Simpele returns zijn intuïtiever. Je legt het makkelijker uit aan een teamgenoot. Logaritmische returns vragen een kleine wiskundige stap, maar met Python-code is het een koud kunstje.
- Kosten op termijn: Simpele returns kunnen leiden tot onnauwkeurige backtests, wat foute beslissingen kost. Bij een bot met €10.000 kapitaal kan een fout van 1% per jaar €100 schelen. Logaritmische returns minimaliseren deze fout.
- Nauwkeurigheid risicomanagement: Logaritmische wins hier. Ze geven betere schattingen voor standaarddeviatie en correlaties, cruciaal voor diversificatie in je portfolio.
We kijken naar 5 criteria: prijs (in tijd en rekenkracht), capaciteit voor grote datasets, gebruiksgemak, kosten op termijn (foute berekeningen), en nauwkeurigheid voor risicomanagement. Geen van beide is "duur" in geld, maar simpele returns kunnen duurder zijn door onnauwkeurigheid. Logaritmische returns zijn de investering in tijd waard voor serieuze traders.
Keuzehulp: welke kies jij?
Kies simpele returns als je net begint met Python en algoritmische trading, of gebruik Xlwings voor je data-analyse.
Als je een eenvoudige bot bouwt voor één asset, zoals een aandeel op Euronext, en je wilt snel een equity curve plotten. Of als je resultaten moet presenteren aan investeerders die procenten begrijpen. Het is de taal van de markt, en voor korte-termijn trades prima. Kies logaritmische returns als je een serieuze backtest bouwt voor een bot met meerdere strategieën.
Als je risicomanagement toevoegt, zoals stop-losses of position sizing gebaseerd op volatiliteit. Of als je werkt met grote datasets van brokers zoals Interactive Brokers en je compound rendement wilt berekenen.
Het is de standaard in professionele Python-libraries voor finance. Een middenweg? Gebruik beide.
In je Python-script bereken je logaritmische returns voor analyse en risicoberekeningen, maar converteer je naar simpele returns voor rapportage. Bibliotheken zoals `quantstats` in Python doen dit automatisch voor je. Zo krijg je het beste van beide werelden: nauwkeurigheid en begrijpelijkheid.
Wat je ook kiest, test het uit met echte data. Pak een historische dataset van je broker, schrijf een simpel Python-script, en kijk wat de returns doen.
De praktijk leert je meer dan elke theorie. Zo bouw je bots die niet alleen werken, maar ook winstgevend zijn op de lange termijn.