Statistische Arbitrage in Crypto — Pairs Trading en Mean Reversion

Statistische arbitrage maakt gebruik van tijdelijke afwijkingen van evenwichtsprijzen. Wanneer twee activa die normaal gesproken samen bewegen divergeren, koopt een stat arb trader de underperformer en short de outperformer, in de verwachting van convergentie. In crypto is dit vooral krachtig omdat activa gecorreleerd zijn maar niet perfect, wat winstgevende mogelijkheden creëert.

Voorbeeld: BTC en ETH correlatie is 0.85. Wanneer ETH BTC met 3% onderpresteert gedurende een periode van 1 uur (ongebruikelijk), short een stat arb trader BTC en gaat long op ETH. Historisch gezien convergeren ze binnen 4-8 uur, wat een winst van ~1-1.5% oplevert.

Basisprincipes van Pairs Trading

Selecteren van Paren

Niet alle paren werken. Je hebt nodig:

Hoge correlatie: >0.8 (gebruik Pearson correlatiecoëfficiënt)
Economische relatie: Layer 2s naar L1, stablecoins naar elkaar
Voldoende volume: Beide paren moeten liquide zijn
Cointegratie: Langetermijn-evenwicht bestaat (testen met Johansen test)

Python — Paarselectie
import pandas as pd
from scipy.stats import pearsonr
def find_cointegrated_pairs(symbols, data):
candidates = []
for i, sym1 in enumerate(symbols):
for sym2 in symbols[i+1:]:
# Bereken correlatie
corr, p_value = pearsonr(data[sym1], data[sym2])
if corr > 0.75:
# Test cointegratie (Engle-Granger test)
residuals = data[sym1] - (data[sym2] * corr)
adf_stat = adf_test(residuals)  # stationariteit
if adf_stat < 0.05:  # stationair
candidates.append((sym1, sym2, corr))
return candidates

Cointegratie Analyse

Wat is Cointegratie?

Twee niet-stationaire reeksen zijn gecoïntegreerd als hun lineaire combinatie stationair is. In gewoon Nederlands: ze bewegen samen in de tijd, en afwijkingen van die relatie keren uiteindelijk terug.

Voor BTC en ETH:

BTC prijs: $42,000 (niet-stationair — trend omhoog/omlaag)
ETH prijs: $2,300 (niet-stationair — trend omhoog/omlaag)
Spread: BTC - (18 × ETH) = $40 (stationair — oscilleert rond het gemiddelde)

Het vinden van de Hedge Ratio

Gebruik ordinary least squares regressie om de optimale ratio te vinden:

Python — Hedge ratio berekening
from sklearn.linear_model import LinearRegression
def get_hedge_ratio(price1, price2):
# Regress price1 op price2 om beta (hedge ratio) te vinden
X = price2.reshape(-1, 1)
y = price1
model = LinearRegression().fit(X, y)
hedge_ratio = model.coef_[0]
intercept = model.intercept_
return hedge_ratio, intercept
# Spread = price1 - (hedge_ratio × price2) + intercept
beta, alpha = get_hedge_ratio(btc_prices, eth_prices)
spread = btc - (beta * eth)

Mean Reversion Strategieën

Gebruik van Z-Scores

Standaardiseer de spread om extremen te detecteren. Wanneer z-score > 2, is de spread ongebruikelijk breed (handelsmogelijkheid):

Python — Mean reversion trading
def mean_reversion_signal(spread, lookback=20):
# Bereken rollend gemiddelde en std
mean = spread.rolling(window=lookback).mean()
std = spread.rolling(window=lookback).std()
# Z-score: hoeveel std devs van het gemiddelde
z_score = (spread - mean) / std
# Handelssignalen
if z_score[-1] > 2.0:
return "LONG_SPREAD" # spread te breed, koop underperformer
elif z_score[-1] < -2.0:
return "SHORT_SPREAD" # spread te smal, short underperformer
else:
return "NEUTRAL"

Exit Regels

Sluit wanneer de spread terugkeert naar het gemiddelde (z-score → 0) of verliesdrempel (stop bij z-score omkering):

Python — Exit logica
def check_exit(entry_z_score, current_z_score, entry_price):
# Neem winst: spread convergeerde halverwege terug naar het gemiddelde
if abs(current_z_score) < abs(entry_z_score) * 0.5:
return EXIT, winstdoel
# Stop loss: z-score bewoog in verkeerde richting met >1
als (entry_z_score > 0 en current_z_score < entry_z_score + 1.0):
retourneer EXIT, stop_loss
anders als (entry_z_score < 0 en current_z_score > entry_z_score - 1.0):
retourneer EXIT, stop_loss
retourneer HOLD, None

Backtesten van Statistische Arbitrage Strategieën

Belangrijke metrieken voor stat arb:

Winpercentage: >55% (je pakt consistent reversies)
Gemiddelde winst/verlies ratio: >1.2 (winsten overtreffen verliezen)
Sharpe ratio: >0.8 (rendement per risico-eenheid)
Maximale drawdown: <-15% (systeem blijft veilig)

Python — Backtest paarsstrategie
def backtest_pairs_strategy(price1, price2, hedge_ratio):
spread = price1 - (hedge_ratio * price2)
mean = spread.rolling(20).mean()
std = spread.rolling(20).std()
z_score = (spread - mean) / std
trades = []
position = None
voor i in range(len(z_score)):
als position is None:
als z_score[i] > 2.0:
position = {"entry": spread[i], "z_entry": z_score[i], "idx": i}
anders:
exit_reason = check_exit(position["z_entry"], z_score[i], spread[i])[1]
als exit_reason:
pnl = position["entry"] - spread[i]
trades.append({"pnl": pnl, "reason": exit_reason})
position = None
retourneer pd.DataFrame(trades)

Smart Money Intelligence Toevoegen

Verbeter paarshandel door trades te filteren met Smart Money-bevestiging:

Python — Gefilterde paarsstrategie
def smart_money_pairs_strategy(symbol1, symbol2, z_score):
# Controleer Smart Money-bevestiging op paar niveau
sm1 = get_smart_money_signal(symbol1)
sm2 = get_smart_money_signal(symbol2)
# Als één HOOG bullish is en de ander HOOG bearish = sterke divergentie
# Ideaal moment om de spread te verhandelen
divergence_score = abs(sm1["composite"] - sm2["composite"])
als z_score > 2.0 en divergence_score > 0.3 en sm1["confidence"] != "VETO":
retourneer "TRADE" # Hoog vertrouwen signaal
anders:
retourneer "SKIP" # Wacht op afstemming

Turbocharge stat arb met Smart Money paarsignalen

Filter mean reversion trades met walvisconsensus en derivatendata. Onze API bevestigt de validiteit van paardivergentie met 62% nauwkeurigheidsverbetering.

Start met Paarshandel →