Wat is TA-Lib en hoe bereken je technische indicatoren?

Alex de Vries

Quantitatief Analist & Algo-Trading Expert

Stel je voor: je hebt een prachtig idee voor een trading strategie.

Je ziet het voor je, de patronen, de perfecte instapmomenten. Maar hoe weet je zeker dat het echt werkt?

Je kunt niet elke dag uren achter je scherm zitten om het met je ogen te volgen. Je wilt het testen, meten, en automatiseren. Hier komt TA-Lib om de hoek kijken. Het is de onmisbare bouwsteen voor elke serieuze Python trader.

In deze gids gaan we niet alleen kijken wat het is, maar vooral hoe je het zelf gebruikt.

Ik leer je stap voor stap hoe je deze krachtige bibliotheek inzet voor jouw eigen algoritmische trading bots.

Waarom TA-Lib onmisbaar is voor jouw trading bots

TA-Lib, of Technical Analysis Library, is in feite een enorme gereedschapskist voor je Python scripts.

Stel je voor dat je een calculator hebt die niet alleen optelt en aftrekt, maar die direct complexe wiskundige formules voor technische analyse kan uitvoeren. TA-Lib is dat, maar dan specifiek voor financiële data. Het is een open-source bibliotheek, geschreven in C, wat het extreem snel maakt. Dat snelheidsvoordeel is cruciaal als je later een bot live gaat draaien bij een broker zoals Interactive Brokers of Bitvavo, waar elke milliseconde telt.

Waarom zou je het niet zelf programmeren? Omdat het wiel opnieuw uitvinden tijd verspilling is.

TA-Lib bevat geoptimaliseerde code voor honderden indicatoren. Denk aan de RSI, MACD, Bollinger Bands en de ATR.

Deze berekeningen zijn vaak complexer dan ze lijken en zitten vol randgevallen. Door TA-Lib te gebruiken, weet je zeker dat je berekeningen kloppen. Dit geeft je de rust om je te concentreren op wat echt telt: de strategie zelf, risicomanagement en het interpreteren van de resultaten van je backtests.

Het werkt volgens een simpele logica: je geeft het een of meerdere arrays met data (meestal de koersen van een asset) en TA-Lib geeft je een nieuwe array terug met de indicatorwaarden. Het is een pijler onder je technische analyse. Zonder deze bibliotheek zou je elke keer opnieuw beginnen, met een veel grotere kans op programmeerfouten die je handelsstrategie onbetrouwbaar maken.

Wat je nodig hebt voor een soepele installatie

Voordat we beginnen, moeten we even de basis op orde breken. Een goede voorbereiding is het halve werk en voorkomt frustratie.

TA-Lib installeren is namelijk niet zo simpel als een standaard 'pip install'.

Het is een C-bibliotheek met een Python-wrapper. Je moet dus zorgen dat je systeem de C-code kan compileren of de juiste binaire bestanden vindt. Pak een kop koffie, zet je scherm goed en zorg dat je even ongestoord kunt werken.

Reken op ongeveer 20 tot 30 minuten voor de installatie, afhankelijk van je systeem. Hier is je checklist voor wat je nodig hebt: Een veelgemaakte fout is het direct proberen te installeren via pip install TA-Lib op een verse installatie. Dit werkt bijna nooit direct op Windows.

• Python: Zorg dat je Python 3.8 of nieuwer geïnstalleerd hebt. Gebruik een schone virtuele omgeving (bijvoorbeeld via venv of conda) om conflicten met andere projecten te voorkomen. Dit is een must voor elke serieuze bot-ontwikkeling.
• Een package manager: pip werkt, maar voor TA-Lib is het vaak makkelijker om conda (van Anaconda) te gebruiken. Conda kan binary dependencies beter afhandelen. Als je met pip werkt, moet je soms zelf de juiste .whl-bestanden downloaden.
• Een data-bron: Je hebt historische data nodig om te testen. Denk aan een API van je broker (zoals Kraken of DEGIRO) of een dienst als Yahoo Finance via de yfinance bibliotheek. Zorg dat je data in een 'OHLCV'-structuur hebt (Open, High, Low, Close, Volume).

De foutmeldingen zijn vaak cryptisch en frustrerend. De makkelijkste weg is bijna altijd via de Anaconda Prompt: conda install -c conda-forge ta-lib.

Als je dit eenmaal hebt, ben je er bijna.

Stap-voor-stap: Je eerste indicator berekenen

Laten we de handen uit de mouwen steken. We gaan een van de meest gebruikte indicatoren berekenen: de Relative Strength Index (RSI).

De RSI meet de snelheid en verandering van prijsbewegingen en geeft aan of een asset overkocht (boven 70) of oververkocht (onder 30) is. We doen dit met een Python script. Zorg dat je een data-bestand hebt of een API-call klaarstaat die een pandas DataFrame met prijsdata oplevert.

1. Importeer de libraries: Eerst halen we de benodigde gereedschappen in huis. We hebben TA-Lib zelf nodig en pandas om onze data te manipuleren.

   import talib
   import pandas as pd
   import numpy as np

2. Laad je data: We hebben een dataset nodig. Laten we een voorbeeld-dataarray maken als je nog geen echte data hebt. Dit helpt om te zien hoe het werkt. In de praktijk laad je hier je CSV-bestand of API-data.

   # Simpele data voorbeeld
   close_prices = np.array([45.34, 44.32, 45.10, 46.20, 47.50, 48.10, 47.80, 46.90, 46.30, 45.80, 46.10, 46.50, 47.20, 47.90, 48.40, 48.10, 47.50])

3. Roep de RSI-functie aan: Dit is het magische moment. We geven de data door en TA-Lib doet de rest. De functie verwacht een NumPy-array, dus als je met een pandas DataFrame werkt, gebruik je df['close'].values.

   # Bereken de RSI met een standaard periode van 14
   rsi = talib.RSI(close_prices, timeperiod=14)

4. Bekijk de output: De output is een array met de RSI-waarden. De eerste 14 waarden zijn 'NaN' (Not a Number), omdat er niet genoeg data is voor de eerste berekening. De 15e waarde is de eerste echte RSI. Dit is normaal. Veel traders filteren deze NaN-waarden er later uit voor hun backtesting-logica.
5. Integreer in je DataFrame: Om het overzichtelijk te houden, voeg je de output toe als een nieuwe kolom in je DataFrame. Zo kun je makkelijk zien welke RSI-waarde bij welke candle hoort.

   df['RSI_14'] = talib.RSI(df['close'].values, timeperiod=14)

We gaan uit van een DataFrame 'df' met een 'close' kolom. Een veelgemaakte fout hierbij is het vergeten van de .values als je een pandas DataFrame gebruikt.

TA-Lib werkt met NumPy-arrays. Als je de DataFrame zelf doorgeeft, krijg je een error. Twijfel je nog over je keuze? Lees dan onze vergelijking tussen Pandas-TA en TA-Lib.

Ook een andere valkuil is het verkeerd instellen van de timeperiod. Een RSI van 5 dagen reageert veel sneller op prijsveranderingen dan een RSI van 14 dagen. Test dit goed in je backtests voordat je het in een live bot gebruikt.

Meer dan RSI: SMA en ATR voor risicomanagement

Nu je weet hoe je een indicator berekent, is het tijd om je toolbox uit te breiden.

Een trading bot heeft meer nodig dan alleen een entry-signaal. Je hebt bevestiging nodig en een manier om je risico te beheren. Laten we kijken naar de Simple Moving Average (SMA) en de Average True Range (ATR).

De SMA helpt je de trend te bepalen, de ATR helpt je de volatiliteit te meten en je stop-loss op een slimme manier in te stellen. De Simple Moving Average (SMA) is een basisindicator die je helpt om ruis uit de markt te filteren.

In plaats van elke kleine prijsbeweging te volgen, kijk je naar het gemiddelde over een bepaalde periode.

sma_20 = talib.SMA(df['close'].values, timeperiod=20)
sma_50 = talib.SMA(df['close'].values, timeperiod=50)

Je kunt een 'korte' SMA (bijvoorbeeld 20) en een 'lange' SMA (bijvoorbeeld 50) met elkaar vergelijken. Als de korte SMA de lange kruist, kan dat een signaal zijn om een positie te openen. De code is bijna identiek aan die van de RSI. De Average True Range (ATR) is een echte gamechanger voor risicomanagement.

De ATR meet de volatiliteit van een asset. Een hoge ATR betekent dat de koers sterk op en neer beweegt, een lage ATR betekent een stabielere markt.

Waarom is dit zo belangrijk? Omdat je je stop-loss hierop kunt baseren. Zet je een stop-loss op een vast bedrag, bijvoorbeeld €50,-, dan word je in een rustige markt misschien te vroeg uitgestopt, en in een heel volatiele markt loop je te veel risico.

Een betere methode is je stop-loss plaatsen op een veelvoud van de ATR, bijvoorbeeld 2x de ATR onder je instapprijs.

atr = talib.ATR(df['high'].values, df['low'].values, df['close'].values, timeperiod=14)
stop_loss = entry_prijs - (2 * atr[-1]) # Voorbeeldberekening

Op een rustige dag zit je stop-loss dan dichter bij je entry, en op een volatiele dag geef je de trade meer ruimte. Dit is een dynamische manier van risicomanagement die je bot robuuster maakt. De code ziet er zo uit:

Veel beginners vergeten dat de ATR-net als de RSI de eerste paar periodes NaN-waarden heeft.

Een andere fout is het verwarren van de ATR met een prijsvoorspelling. De ATR zegt niets over de richting van de prijs, alleen over de grootte van de beweging. Gebruik het dus nooit als entry-signaal, maar puur voor position sizing en stop-loss plaatsing.

Je indicator data gebruiken in een backtest

Goed, je hebt nu een DataFrame vol met bruikbare signalen: RSI-waarden, SMA-kruisingen en ATR-waarden. Maar hoe koppel je dit aan een daadwerkelijke backtest? De volgende stap is het schrijven van simpele logica, zoals het Z-Score berekenen voor Mean Reversion strategieën, die deze getallen vertaalt naar 'Kopen' of 'Verkopen'.

Dit is waar je Python script verandert in een trading strategie. We houden het simpel: we kopen als de RSI laag is en de prijs boven de lange SMA zit, en we verkopen als de RSI hoog is.

Een veelgemaakte fout is 'look-ahead bias'. Dit betekent dat je per ongeluk toekomstige data gebruikt in je huidige beslissing.

Controleer je code altijd dubbel. In je backtest-loop moet je de indicatorwaarden van de vorige dag gebruiken om de beslissing voor vandaag te nemen. Een andere klassieke fout is het vergeten van transactiekosten en slippage.

Een strategie die op papier 5% winst maakt, kan na kosten verliesgevend zijn.

Reken altijd met realistische kosten, bijvoorbeeld €2,- per transactie en 0,1% aan handelskosten. Als je eenmaal een werkende backtest hebt, kun je deze verfijnen. Voeg parameters toe voor je stop-loss en take-profit, gebaseerd op de ATR. Test verschillende tijdperioden voor je indicatoren.

Dit proces van testen, analyseren en optimaliseren heet 'iteratieve strategieontwikkeling'. Ontdek wat TA-Lib is en hoe je hiermee snel nieuwe variaties op je strategie test, zonder elke keer de basisberekeningen opnieuw te coderen.

Verificatie-checklist

Voordat je je bot live zet, loop deze lijst na om de meest voorkomende problemen te voorkomen. Wees streng voor jezelf, beter een dag langer testen dan een dag na livegang je geld verliezen.

• Installatie: Is TA-Lib correct geïnstalleerd? Run import talib en print(talib.__version__) om het te controleren.
• Data-integriteit: Bevat je data geen gaten (missende dagen) of extreme outliers die je berekeningen verpesten?
• NaN-waarden: Weet je precies waar en waarom er NaN-waarden in je indicator-data zitten (meestal de eerste 'timeperiod' dagen) en handel je hier correct?
• Look-ahead bias: Gebruik je bij elke beslissing in je backtest alleen data die op dat moment beschikbaar was?
• Realistische kosten: Zijn transactiekosten, financieringskosten (swap) en slippage meegenomen in je winst/verlies berekening?
• Risicomanagement: Is je stop-loss logica gebaseerd op een indicator zoals ATR en niet op een willekeurig getal?
• Edge Cases: Wat gebeurt er als de API van je broker even down is? Of als de markt sluit? Is je bot hierop voorbereid?