Wat is TensorFlow en hoe gebruik je het voor koersvoorspellingen?
Stel je voor: je hebt een handelsstrategie die in je achterhoofd sluimert, gebaseerd op patronen in koersdata. Je wilt die strategie vertalen naar een Python-script dat voor je kan traden, zonder dat je elke seconde de markt in de gaten hoeft te houden. TensorFlow is de sleutel.
Het is een krachtige bibliotheek van Google waarmee je die patronen leert herkennen.
In dit stap-voor-stap plan leg ik precies uit hoe je TensorFlow inzet voor het voorspellen van koersen, zodat je bot slimmere beslissingen kan maken op platforms als Interactive Brokers of Binance.
Wat je nodig hebt: de basis voor je voorspelmodel
Voordat je code tikt, zorg je dat je gereedschap klaar staat. Je hebt een computer nodig met minimaal 8 GB RAM, want TensorFlow kan flink wat geheugen vragen.
Een moderne processor (i5 of Ryzen 5) helpt, maar een GPU is geen must voor deze eerste stap; een CPU werkt prima voor kleine datasets.
- Python 3.9 of nieuwer: download van python.org. Zorg dat je pip bijgewerkt hebt.
- Virtuele omgeving: om je project stabiel te houden, maak je een aparte omgeving.
- Data: een CSV-bestand met historische koersen (bijv. van Yahoo Finance of je broker).
- Brokers-API: toegangstokens voor je broker. Test met een paper trading account.
Reken op een uurtje of twee om alles geïnstalleerd te krijgen als je een schone machine hebt. Je betaalt niets; TensorFlow is gratis en open source. Je broker-API (denk aan IBKR via TWS of Alpaca) heb je al aangevraagd, want straks wil je de voorspellingen direct inzetten.
Veelgemaakte fout: direct in je systeem-Python installeren. Dat leidt tot conflicten.
Gebruik altijd een virtuele omgeving. Een andere valkuil is het downloaden van onbetrouwbare data; zorg dat je data van een bron als je broker of een betaalde dienst zoals Refinitiv gebruikt, om sjoemelen met de dataset te voorkomen.
Stap 1: Je omgeving opzetten en TensorFlow installeren
Open je terminal of command prompt. Maak een nieuwe map, bijvoorbeeld C:\Trading\TensorFlow_Project of ~/Trading/TensorFlow_Project.
Binnen die map draai je python -m venv venv om een virtuele omgeving te maken. Activeer hem: op Windows is dat venv\Scripts\activate en op Mac/Linux source venv/bin/activate. Je ziet nu (venv) in je prompt staan.
Dit duurt seconden, maar bespaart je uren hoofdpijn later. Installeer de benodigde libraries.
Typ: pip install tensorflow pandas numpy scikit-learn matplotlib. Als je een NVIDIA GPU hebt en je wilt sneller trainen, installeer dan tensorflow[and-cuda], maar check eerst of je CUDA-compatible drivers hebt. Dit duurt 5 tot 15 minuten, afhankelijk van je internet. Veelgemaakte fout: vergeten je virtuele omgeving te activeren, waardoor installaties in de verkeerde map belanden. Controleer met pip list of de packages er nu echt staan.
Tip: gebruik een IDE zoals VS Code. Het maakt het leven makkelijker met IntelliSense en debug-tools. Kost niets, werkt perfect voor Python.
Stap 2: Data laden en voorbereiden voor de bot
Haal je data op. Voor een test kun je met yfinance (installeren via pip) een CSV trekken: bijvoorbeeld de BTC-USD koers van de afgelopen 2 jaar.
Schrijf een simpel scriptje: import yfinance as yf; data = yf.download('BTC-USD', start='2022-01-01', end='2024-01-01'); data.to_csv('btc_data.csv'). Dit duurt een minuutje. Je dataset moet schoner zijn dan je keuken: verwijder nullen en check op outliers.
Gebruik data.dropna() en data.describe() om inzicht te krijgen. Zorg dat je minimaal 1000 data-punten hebt voor een beetje betrouwbare voorspelling.
TensorFlow werkt met getallen, dus je moet de data schalen. Bij het kiezen tussen TensorFlow of PyTorch voor trading bots is data-preprocessing cruciaal; koersen kunnen variëren van €20.000 tot €60.000, dus zonder schaling gaat je model ontsporen.
Gebruik MinMaxScaler van scikit-learn om alles tussen 0 en 1 te brengen. Splits je data: 80% voor training, 20% voor test. Voor tijdreeksen (zoals koersen) doe je dit chronologisch: de eerste 80% om te leren, de rest om te testen. Veelgemaakte fout: willekeurig splitten via train_test_split.
Dat lekt toekomstige data in je training en geeft vals optimisme. Doe het handmatig: train_size = int(len(data) * 0.8).
Stap 3: Het model bouwen met Keras (TensorFlow's high-level API)
Maak een nieuw Python-bestand, bijvoorbeeld koers_predictor.py. We bouwen een simpel LSTM-model (Long Short-Term Memory), ideaal voor tijdreeksen zoals koersen. Zodra je model draait, wil je natuurlijk je koersgrafieken in Python visualiseren om de resultaten te valideren.
TensorFlow's Keras maakt dit makkelijk: je definieert lagen als blokken. Als je liever PyTorch voor deep learning in de financiële markten gebruikt, begin dan met de imports: import tensorflow as tf; from tensorflow.keras.models import Sequential; from tensorflow.keras.layers import Dense, LSTM, Dropout.
- Maak sequences: herschrijf je data zodat elke input 60 voorgaande dagen zijn en de output de volgende dag is. Gebruik een functie:
def create_sequences(data, time_steps=60): .... Dit duurt even om te schrijven, maar is essentieel. - Bouw het model:
model = Sequential(); model.add(LSTM(50, return_sequences=True, input_shape=(60, 1))); model.add(Dropout(0.2)); model.add(LSTM(50)); model.add(Dense(1)). Dropout voorkomt overfitting – je wilt niet dat je bot traint op ruis. - Compileer:
model.compile(optimizer='adam', loss='mean_squared_error'). Adam is een goeie standaard; MSE werkt voor regressie (prijs voorspellen). - Train:
model.fit(X_train, y_train, epochs=50, batch_size=32, validation_split=0.1). Epochs zijn rondjes door je data; 50 is een safe start. Batch_size 32 is prima voor een CPU. Dit duurt 10-30 minuten op een gemiddelde laptop.
Een LSTM kan patronen onthouden van de afgelopen 60 dagen, bijvoorbeeld. Definieer de shape: input is (60, 1) – 60 dagen koers, 1 feature (de closing price). Dit bouw je op in code.
Veelgemaakte fouten: te veel lagen toevoegen (blijf bij 2-3 LSTM-lagen voor beginners), waardoor training eeuwig duurt en je overfit. Of vergeten data te normaliseren voor training – je model crasht of leert niks. Test tussendoor met model.predict(X_test[:1]) om te zien of het loopt.
Stap 4: Voorspellingen testen en integreren met je broker
Evalueer je model op de testset. Gebruik predictions = model.predict(X_test) en vergelijk met y_test.
Plot het met matplotlib: import matplotlib.pyplot as plt; plt.plot(y_test, label='Echt'); plt.plot(predictions, label='Voorspeld'); plt.legend(); plt.show(). Je ziet lijnen die (hopelijk) dicht bij elkaar liggen. Bereken RMSE: from sklearn.metrics import mean_squared_error; rmse = mean_squared_error(y_test, predictions, squared=False). Een RMSE van €50 op een BTC-koers van €50k is oké; boven €500 is het niets.
Dit duurt 5 minuten. Sluit je broker-API aan.
Voor Interactive Brokers: gebruik ib_insync (pip install). Schrijf een functie die de laatste 60 koersen ophaalt, scaled, en voorspelt.
Als de voorspelling boven de huidige prijs ligt, stuur een buy-order via de API. Test eerst met paper trading – geen echt geld op het spel. Zet risicomanagement in: stop-loss op 2% en position sizing van max 1% van je totaal.
Veelgemaakte fout: live traden zonder backtest. Gebruik libraries als Backtrader of Zipline om je strategie eerst te backtesten met historische data. Zo voorkom je dat je bot geld verliest aan slechte modellen.
Onthoud: een voorspelling is geen garantie. De markt is chaotisch; combineer TensorFlow met andere indicatoren zoals RSI of MACD voor betere resultaten.
Stap 5: Optimaliseren en valkuilen vermijden
Nu je model loopt, tune je het. Verander het aantal epochs van 50 naar 100 als je underfit ziet (training loss daalt niet).
Speel met de sequence-lengte: probeer 30 of 90 dagen in plaats van 60, afhankelijk van je asset (crypto is volatiel, dus korter).
Gebruik TensorBoard voor visualisatie: model.fit(..., callbacks=[tf.keras.callbacks.TensorBoard(log_dir='./logs')]). Dit helpt patronen in je training te zien. Duur: 30-60 minuten per run.
Veelgemaakte fouten: de dataset is te klein (minder dan 500 punten), wat leidt tot overfitting. Of je vergeet de API-limieten van je broker (bijv. 100 requests per minuut bij Binance), waardoor je geblokkeerd wordt. Test altijd op een aparte test-dataset die je model nooit heeft gezien.
En voor risicomanagement: implementeer een eenvoudige Kelly-criteria formule in je bot: risk_per_trade = total_capital * 0.01.
Zo beperk je verliezen.
Verificatie-checklist: Is je opzet klaar?
Loop deze lijst na voordat je live gaat. Als je alle vinkjes hebt, ben je ready om te draaien. Verwacht 1-2 uur om alles te controleren.
- ✅ Virtuele omgeving actief en packages geïnstalleerd (check met
pip list | grep tensorflow). - ✅ Data geladen, geschoond en geschaald (geen nullen, waarden tussen 0-1).
- ✅ Dataset gesplitst: 80% train, 20% test, chronologisch.
- ✅ LSTM-model gebouwd met 2 lagen, gecompileerd en getraind (loss < 0.001 na 50 epochs).
- ✅ Voorspellingen geplot en RMSE berekend (lager dan 1% van gemiddelde koers).
- ✅ API-integratie getest in paper-mode (geen echte orders).
- ✅ Risicoregels ingesteld (stop-loss, position sizing).
- ✅ Backtest uitgevoerd met een tool als Backtrader (minstens 1 jaar historische data).
Als iets faalt, retourneer naar de betreffende stap. TensorFlow is krachtig, maar vereist precisie.
Begin klein, experimenteer, en je bot wordt een betrouwbare partner in je trading-avontuur.