Wat zijn 'Random Forests' en hoe werken ze voor aandelen?
Je kent het wel: je zit uren te pielen aan een trading strategie, de backtest ziet er veelbelovend uit en dan... crashen de aandelen.
Of je model draait als een zonnetje op oude data, maar faalt volledig zodra je het met echt geld aan de praat krijgt. Het gevoel dat je constant achter de feiten aanloopt, is herkenbaar.
Vooral als je met Python en algoritmische bots werkt, is het vinden van een stabiele voorspeller een uitdaging. Het antwoord ligt vaak niet in een ingewikkeler formule, maar in een slimmere structuur. Daar kom je Random Forests tegen: een methode die niet één, maar honderden slimme voorspellers tegelijk inzet. Het is alsof je een heel team van analisten in je computer stopt. In dit artikel ontdek je stap voor stap wat Random Forests zijn, hoe je ze bouwt voor aandelen en hoe je ze veilig integreert in je trading stack.
Wat is een Random Forest eigenlijk?
Stel je voor dat je een groep experts vraagt om te voorspellen of een aandeel morgen omhoog of omlaag gaat. De een kijkt naar het volume, de ander naar de RSI, een derde naar de MACD.
Als je ze allemaal hun eigen ding laat doen en daarna hun stemmen telt, heb je een veel beter beeld dan wanneer je er maar één om advies vraagt.
Dat is precies het idee achter Random Forests. Een Random Forest is een verzameling van 'beslissingsbomen' (decision trees). Elke boom probeert de markt te voorspellen op basis van een beperkte set data en een beperkte set kenmerken.
Door honderden van deze bomen te combineren, verdwijnt de ruis en blijft het echte patroon over. De kracht zit 'm in de 'vermenigvuldiging'. Een enkele boom maakt snel een fout, maar een bos van 500 bomen maakt zelden allemaal dezelfde fout. Deze aanpak is robuust en minder gevoelig voor 'overfitting'.
Overfitting is de nachtmerrie van elke quant: een model dat te goed past op historische data en daardoor in de echte markt faalt.
Random Forests filteren deze valsheid eruit. Ze zijn de basis voor veel professionele trading bots en worden vaak gebruikt als benchmark voordat er complexere deep learning modellen aan te pas komen.
Stap 1: De juiste data verzamelen
Elk goed model begint met schone, betrouwbare data. Voor een Random Forest die aandelen voorspelt, heb je meer nodig dan alleen de slotkoers.
Je hebt een dataset nodig met features (kenmerken) en een target (wat je wilt voorspellen).
Standaard gebruik je een broker API, bijvoorbeeld van Interactive Brokers (IBKR) of een partij als Alpaca, om intraday data te halen. Voor een first step experiment kun je ook gratis data gebruiken via de Yahoo Finance API (via de Python library yfinance). Je hebt minimaal 2 tot 3 jaar historische data nodig.
Voor een model dat morgen voorspelt, gebruik je dagelijkse data (Daily OHLCV: Open, High, Low, Close, Volume). Zorg dat je data geen gaten heeft. Als je via een API haalt, check dit dan altijd met een simpele df.isnull().sum() in Python. Gaten vul je op of je snijdt de periode eruit.
- Prijsmomentum: rendement over de afgelopen 1, 5 en 20 dagen.
- Volatiliteit: de standaardafwijking van de koers over 10 dagen.
- Technische indicatoren: RSI(14), MACD, Bollinger Bands.
- Volume: gemiddelde volume over 20 dagen.
- Marktbrede signalen: bijvoorbeeld de beweging van de S&P 500 index.
Vergeet ook niet corporate actions (splitsingen, dividend) te corrigeren; je wilt geen verkeerde patronen leren door een aandelensplitsing.
Maak een lijstje van features die je wilt gebruiken. Denk aan: Je target is simpel: 1 als de prijs morgen stijgt, 0 als hij daalt (of blijft).
Veelgemaakte fout: Te veel features gebruiken met te weinig data. Dit leidt tot 'overfitting'. Begin met 10-15 sterke features. Een vuistregel: aantal data punten moet minstens 10x het aantal features zijn.
Stap 2: De data voorbereiden (Feature Engineering)
Random Forests zijn sterke dieren, maar ze eten alleen getallen. Je hebt dus geen 'ruwe' data nodig, maar bewerkte data.
Dit is waar de meeste beginners tijd verliezen. Je doel is om patronen bloot te leggen die de boom makkelijk kan splitsen.
df['Target'] = (df['Close'].shift(-1) > df['Close']).astype(int)In Python gebruik je hiervoor libraries zoals pandas voor data manipulatie en ta-lib of pandas-ta voor technische indicatoren. Stap 1 is het normaliseren of standaardiseren van je data. Random Forests zijn hier redelijk tolerant tegen, maar het helpt.
Je kunt de features schalen (bijvoorbeeld via MinMaxScaling) zodat ze tussen 0 en 1 liggen. Stap 2 is het creëren van de target variabele. Je schuift de prijs één dag op: Dit zorgt ervoor dat je model leert van vandaag om morgen te voorspellen.
De meest cruciale stap is het splijten van je data. Voordat je begint, moet je controleren of jouw dataset klaar voor machine learning is. Je mag nooit je model testen op data die het heeft gezien tijdens het trainen.
- Train set (70%): Hier leert het bos de patronen.
- Validatie set (15%): Hier tune je de hyperparameters (zoals het aantal bomen).
- Test set (15%): De onbekende examen-data om te zien of het werkt.
Deel je data op in: Gebruik voor financiële data een 'time-series split'.
Je moet de data in chronologische volgorde splitsen, niet random. Je traint op het verleden en test op de toekomst.
Pro-tip: Voeg 'lag features' toe. Dit zijn waardes van eerdere dagen (bijv. het rendement van 2 dagen geleden). De boom kan dan patronen herkennen als "als het gisteren daalde en vandaag steeg, dan...".
Stap 3: Het Random Forest model bouwen
Nu komt het leuke gedeelte: de code. We gebruiken de scikit-learn library in Python.
Dit is de standaard voor machine learning. Voor wie twijfelt over de keuze tussen deep learning vs random forests voor kleine datasets: de Random Forest Classifier is bijna 'plug-and-play'. Een basis implementatie ziet er zo uit (onderdeel van je Python script):
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# Het model initialiseren
model = RandomForestClassifier(n_estimators=200, min_samples_split=50, random_state=42)
# Trainen
model.fit(X_train, y_train)
# Voorspellen
predictions = model.predict(X_test)
# Controleren
print(accuracy_score(y_test, predictions))De parameters hier zijn belangrijk. n_estimators is het aantal bomen. 100 is oké, 200-500 is vaak beter (maar trager). min_samples_split bepaalt hoeveel data er minimaal in een 'blad' van de boom moet zitten.
Zet je dit te laag (bijv. 2), dan leer je ruis. Zet je het te hoog, dan mis je subtiele patronen. Een waarde tussen 20 en 100 is een goed startpunt voor aandelen.
Trainen duurt op een normale laptop (i5/16GB) met 500 bomen en 3 jaar data ongeveer 1 tot 5 minuten. Als het langer duurt, controleer dan of je niet teveel features of data gebruikt.
De uitvoer van model.predict() geeft je 0 of 1. Dit vertaal je naar een actie: bij 1 koop je (of houd je), bij 0 verkoop je (of blijft je cash).
Veelgemaakte fout: De default parameters van scikit-learn gebruiken. Die zijn niet geoptimaliseerd voor financiële tijdreeksen. Gebruik altijd een grid-search (via GridSearchCV) op je validatieset om de beste parameters te vinden.
Stap 4: Backtesten en integratie met Brokers
Een model trainen is makkelijk. De kunst is om het in een trading bot te stoppen die geen geld verliest.
Hiervoor gebruik je een backtesting framework. Populaire opties in Python zijn Backtrader, Zipline of VectorBT. Deze libraries simuleren een broker en een portefeuille.
Je bouwt een 'Strategy' class die op elke candle (tijdstip) de volgende dingen doet:
- Haal de meest recente data op.
- Bereken de features (RSI, momentum, etc.).
- Laat het getrainde Random Forest model een voorspelling doen.
- Geef een 'Long' (koop) of 'Short' (verkoop) signaal.
De backtest engine rekent uit wat je rendement zou zijn geweest. Let op: zorg dat je transactiekosten meeneemt! Bij Interactive Brokers of LMAX Global liggen deze vaak rond de $0.005 per aandeel.
Bij hefboomproducten tellen spreads en rolkosten mee. Een model dat 5% winst maakt zonder kosten, kan verlies draaien met kosten.
Als de backtest er goed uitziet (Sharpe ratio > 1.0, max drawdown < 20%), kun je de bot live zetten.
Je koppelt je script via de API van je broker (bijv. IBKR via IB_insync of Alpaca via hun Python client). Zorg altijd voor een 'paper trading' fase. Laat de bot eerst een week of 2 draaien met 'nepgeld' om te zien of de API connectie stabiel is en of de ordelexecution correct verloopt.
Verificatie-checklist
Voordat je je bot live zet, loop je deze checklist af. Eén foutje kan je account leegtrekken.
- Data Kwaliteit: Zijn er null values? Zijn de data points gesorteerd op tijd? Is er rekening gehouden met stock splits?
- Time-Series Split: Train je op het verleden en test je op de toekomst? (Niet random splitten!).
- Overfitting Check: Is je score op de testset vergelijkbaar met de score op de trainset? Als trainset 95% is en testset 55%, ben je overfitted.
- Cost of Trading: Zijn transactiekosten en spreads meegerekend in de backtest?
- Risk Management: Staat er een stop-loss in je code? (Max 2% risico per trade is standaard).
- API Limits: Weet je hoeveel calls je per minuut mag doen naar je broker? (Bij Alpaca is dit 200/min).
- Logging: Logt je bot elke trade, elke voorspelling en elke fout in een bestand?
Als je hier allemaal 'ja' op kunt antwoorden, ben je klaar. Random Forests bieden een krachtige basis voor algoritmische handel. Ze zijn niet magisch, maar door een Random Forest classifier te trainen bouw je een robuust fundament voor je trading bot. Veel succes met coderen!