Wat is de ARCH library voor het modelleren van volatiliteit?
Stel je voor: je bouwt een Python trading bot die een momentum-strategie op de NASDAQ uitvoert.
Je backtest hem, zet hem live bij Interactive Brokers, en dan gebeurt er iets geks. De markt schrikt tijdens een FOMC-meeting en je bot verliest in één uur wat hij in drie dagen heeft opgebouwd. Het probleem? Je model ging uit van stabiele volatiliteit, maar de werkelijkheid is dat de markt schommelt als een achtbaan. De ARCH library is precies het gereedschap om die schommelingen in kaart te brengen en je risicomanagement op orde te krijgen.
Wat is ARCH eigenlijk?
ARCH staat voor Autoregressive Conditional Heteroskedasticity. Klinkt zwaar, maar het idee is simpel: de volatiliteit van vandaag hangt af van hoe heftig het gisteren was.
Als de markt gisteren hard bewoog, is de kans groot dat vandaag ook onrustig is. ARCH meet die dynamiek in plaats van een gemiddelde volatiliteit over een hele periode te plakken.
In de praktijk van algoritmische trading gebruik je ARCH om een tijdreeks van rendementen te modelleren en de onzekerheid per dag of per uur te schatten. Je krijgt geen vaste volatiliteit, maar een tijdreeks die op en neer beweegt. Dat is precies wat je nodig hebt voor risicomanagement bij een bot die 24/7 handelt. De Python-bibliotheek ARCH is gebouwd op top van pandas en numpy.
Je installeert hem met pip install arch, en je kunt direct beginnen met modellen fitten op je eigen data.
Het werkt naadloos samen met brokers zoals Interactive Brokers via hun API, zodat je de geschatte volatiliteit kunt gebruiken voor position sizing of stop-loss aanpassingen.
Volatiliteit is niet constant. ARCH vangt die veranderingen in een model dat je in Python kunt trainen en live kunt gebruiken.
Waarom is dit cruciaal voor je trading bot?
Veel bots draaien op standaard technische indicaties zoals RSI of Bollinger Bands.
Die geven je entries en exits, maar ze vertellen je niets over hoeveel risico je op een specifiek moment loopt. Als je geen rekening houdt met schommelende volatiliteit, zet je te veel kapitaal in tijdens onrustige periodes en te weinig tijdens rustige.
Stel je backtest een mean-reversion strategie op de AEX-index. Je historische resultaten zien er mooi uit, maar in live trading bij de broker loop je tegen extra slippage en spreadveranderingen aan tijdens pieken in volatiliteit. ARCH helpt je die pieken te voorspellen, zodat je je positiegrootte kunt verkleinen wanneer de markt onrustig wordt. Je kunt ARCH ook combineren met je bestaande Python-code.
Gebruik een rolling window van 20 dagen op je rendementen, fit een ARCH(1)-model en sla de geschatte volatiliteit op.
Deze waarde voed je terug naar je risicomanagement-module, bijvoorbeeld door je stop-loss te verbreden of je leverage te verlagen. Een ander voordeel is transparantie. ARCH levert een model met parameters die je kunt inspecteren.
Je ziet precies hoeveel gewicht het model geeft aan recente schokken. Dat helpt bij het afstemmen van je bot op verschillende markten: een rustig aandeel zoals Shell heeft andere volatiliteitseenheden dan een crypto als Bitcoin.
Hoe ARCH werkt: kern en configuratie
ARCH bouwt een tijdreeksmodel waarbij de variantie (volatiliteit) zelf autoregressief is. In een ARCH(1)-model bepaalt het schok van gisteren de volatiliteit vandaag.
In een GARCH(1,1)-model tel je ook de vorige volatiliteit zelf mee, wat in de praktijk vaak beter werkt voor financiële data. In Python ziet een typische workflow er zo uit:
- Verzamel historische prijsdata via je broker API (bijvoorbeeld Interactive Brokers) of een provider als Alpaca of Yahoo Finance.
- Bereken log-rendementen: r_t = log(p_t / p_{t-1}).
- Fit een GARCH(1,1) model op die rendementen met de ARCH-bibliotheek.
- Haal de geschatte volatiliteit per timestep op en gebruik deze voor risicomanagement.
Standaardcode in Python: Je kunt de volatiliteit rechtstreeks koppelen aan je positiebepaling. Stel je risicobudget per trade is 0,5% van je totale kapitaal. Als de ARCH-schatting aangeeft dat de jaarlijkse volatiliteit 25% is, pas je je positiegrootte daarop aan via de Alpaca-py library voor commissievrij traden.
from arch import arch_model import pandas as pd import numpy as np # voorbeeld: df['close'] bevat sluitkoersen returns = 100 * np.log(df['close'] / df['close'].shift(1)).dropna() model = arch_model(returns, vol='Garch', p=1, q=1) result = model.fit(disp='off') print(result.summary()) # geschatte volatiliteit per observatie vol = result.conditional_volatility
Bij een hogere volatiliteit verlaag je de grootte, bij een lagere verhoog je deze licht.
De parameters p en q bepalen hoe ver het model terugkijkt. Een GARCH(1,1) is een goed startpunt voor aandelenindices en forex. Voor crypto met heftige schokken kun je een GARCH(1,2) of EGARCH proberen, die asymmetrische effecten vangt (negatieve schokken zorgen vaak voor meer volatiliteit dan positieve).
Varianten en modellen met prijsindicaties
Naast GARCH(1,1) zijn er nuttige varianten voor algoritmische trading. Voor een efficiënte dataverwerking is de Toolz library voor functioneel programmeren in finance een aanrader; de ARCH-bibliotheek is verder gratis en open source.
- EGARCH: vangt asymmetrie. Handig voor aandelen waar paniekverkoop de volatiliteit sterker opdrijft. Gebruik dit voor indices en large-caps.
- ARCH-M: neemt de volatiliteit zelf mee in het rendementsmodel. Interessant voor strategieën waarbij risico-premie een rol speelt, zoals value- of momentumfactors.
- FIGARCH: voor langetermijnafhankelijkheid. Bruikbaar op macro-data of langere timeframes.
Reken op 0 tot €50 voor data via broker APIs of providers. Interactive Brokers kost ongeveer €10 per maand voor market data, plus transactiekosten per trade. Voor een retail bot met 100 trades per maand zit je vaak onder €100 tot €150 aan totale kosten, inclusief data en commissies.
Backtesting met ARCH vraagt extra zorg. Fit het model op in-sample data en test out-of-sample met een rolling window.
Gebruik een vaste random seed voor reproduceerbaarheid. Let op dat je geen toekomstige informatie gebruikt: de volatiliteitsschatting op dag t mag alleen gebaseerd zijn op data tot en met dag t-1. Voor risicomanagement kun je een eenvoudige regel instellen: verlaag je positie met 20% als de ARCH-volatiliteit 10% boven het 30-daags gemiddelde ligt.
Of pas je stop-loss dynamisch aan: een bredere stop bij hoge volatiliteit, een smallere bij lage. Dit voorkomt dat je bot gestopt wordt tijdens ruis en beschermt je kapitaal tijdens echte bewegingen.
Praktische tips voor Python traders
Begin klein. Pak een ETF zoals SPY of een bekend aandeel zoals ASML, haal 2 jaar historische data op via je broker API, en fit een GARCH(1,1).
Kijk hoe de geschatte volatiliteit reageert op bekende events zoals rentebesluiten of cijfers. Je zult zien dat ARCH sneller reageert dan een simpel gemiddelde. Combineer ARCH met je bestaande strategie. Gebruik de volatiliteitsschatting niet als entry-signaal, maar als risico-filter.
Je bot blijft zijn reguliere signalen volgen, maar past position sizing en stops aan op basis van de huidige onrust in de markt. Monitor de kwaliteit van je model.
Check residualen op autocorrelatie en ARCH-effecten. Als je model niet goed past, probeer dan een andere variant of verleng je trainingswindow.
Een veelgemaakte fout is te korte datasets: voor stabiele schattingen heb je minimaal 500 tot 1000 observaties nodig. Let op transaction costs en slippage. ARCH helpt je risico te beheersen, maar het voorspelt geen spreads.
Test je bot met realistische kosten en vergelijk de resultaten met en zonder volatiliteitsfilter. Als je bij Interactive Brokers handelt, houd dan rekening met order types en marktdiepte voor betere executie.
Sluit af met een simpele checklist voor je Python libraries: data ophalen, rendementen berekenen, GARCH(1,1) fitten, volatiliteit opslaan, risicoregels definiëren, live koppelen via API, en continu monitoren. Met deze stappen bouw je een robuuste bot die beter omgaat met de grilligheid van de markt en je kapitaal beschermt.