Statistisk arbitrage inom krypto — Parhandel och medelåtergång

Statistisk arbitrage utnyttjar tillfälliga avvikelser från jämviktspriser. När två tillgångar som normalt rör sig tillsammans divergerar, köper en stat arb-handlare den underpresterande och säljer den överpresterande kort, i hopp om konvergens. Inom krypto är detta särskilt kraftfullt eftersom tillgångar är korrelerade men inte perfekt, vilket skapar lönsamma möjligheter.

Exempel: BTC och ETH har en korrelation på 0,85. När ETH underpresterar BTC med 3% under en 1-timmarsperiod (ovanligt), säljer en stat arb-handlare BTC kort och köper ETH. Historiskt sett konvergerar de inom 4-8 timmar, vilket ger en vinst på ~1-1,5%.

Grundläggande parhandel

Val av par

Inte alla par fungerar. Du behöver:

Python — Parval
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:]:
# Beräkna korrelation
corr, p_value = pearsonr(data[sym1], data[sym2])
if corr > 0.75:
# Testa kointegration (Engle-Granger test)
residuals = data[sym1] - (data[sym2] * corr)
adf_stat = adf_test(residuals) # stationaritet
if adf_stat < 0.05: # stationär
candidates.append((sym1, sym2, corr))
return candidates

Kointegrationsanalys

Vad är kointegration?

Två icke-stationära serier är kointegrerade om deras linjära kombination är stationär. Enkelt uttryckt: de rör sig tillsammans över tid, och avvikelser från det förhållandet återgår så småningom.

För BTC och ETH:

Hitta hedgekvoten

Använd linjär regression (OLS) för att hitta den optimala kvoten:

Python — Beräkning av hedgekvot
from sklearn.linear_model import LinearRegression
def get_hedge_ratio(price1, price2):
# Regressera price1 på price2 för att hitta beta (hedgekvot)
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)

Medelåtergångsstrategier

Använda Z-poäng

Standardisera spridningen för att upptäcka extrema värden. När z-poängen > 2 är spridningen ovanligt bred (handelsmöjlighet):

Python — Medelåtergångshandel
def mean_reversion_signal(spread, lookback=20):
# Beräkna rullande medelvärde och standardavvikelse
mean = spread.rolling(window=lookback).mean()
std = spread.rolling(window=lookback).std()
# Z-poäng: hur många standardavvikelser från medelvärdet
z_score = (spread - mean) / std
# Handelssignaler
if z_score[-1] > 2.0:
return "LONG_SPREAD" # spridning för bred, köp underpresterande
elif z_score[-1] < -2.0:
return "SHORT_SPREAD" # spridning för snäv, sälj underpresterande kort
else:
return "NEUTRAL"

Avslutsregler

Stäng när spridningen återgår till medelvärdet (z-poäng → 0) eller förlusttröskel (stopp vid z-poängvändning):

Python — Avslutslogik
def check_exit(entry_z_score, current_z_score, entry_price):
# Ta vinst: spridningen konvergerade halvvägs tillbaka till medelvärdet
if abs(current_z_score) < abs(entry_z_score) * 0.5:
return AVSLUTA, vinstmål
# Stop loss: z-score rörde sig i fel riktning med >1
om (entry_z_score > 0 och current_z_score < entry_z_score + 1.0):
returnera AVSLUTA, stop_loss
elif (entry_z_score < 0 och current_z_score > entry_z_score - 1.0):
returnera AVSLUTA, stop_loss
returnera HÅLL, None

Backtestning av Stat Arb-strategier

Nyckelmått för stat arb:

Python — Backtesta parstrategi
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
för i i range(len(z_score)):
om position är None:
om z_score[i] > 2.0:
position = {"entry": spread[i], "z_entry": z_score[i], "idx": i}
annars:
exit_reason = check_exit(position["z_entry"], z_score[i], spread[i])[1]
om exit_reason:
pnl = position["entry"] - spread[i]
trades.append({"pnl": pnl, "reason": exit_reason})
position = None
returnera pd.DataFrame(trades)

Lägg till Smart Money-intelligens

Förbättra parhandel genom att filtrera affärer med Smart Money-bekräftelse:

Python — Filtrerad parstrategi
def smart_money_pairs_strategy(symbol1, symbol2, z_score):
# Kontrollera Smart Money-bekräftelse på parnivå
sm1 = get_smart_money_signal(symbol1)
sm2 = get_smart_money_signal(symbol2)
# Om en är HÖG hausse och den andra är HÖG baisse = stark divergens
# Perfekt tillfälle att handla spreaden
divergence_score = abs(sm1["composite"] - sm2["composite"])
om z_score > 2.0 och divergence_score > 0.3 och sm1["confidence"] != "VETO":
returnera "TRADE" # Signal med hög tillförlitlighet
annars:
returnera "SKIP" # Vänta på anpassning

Superladda stat arb med Smart Money-parsignaler

Filtrera mean reversion-affärer med valfkonsensus och derivatdata. Vår API bekräftar pardivergensens giltighet med 62% förbättrad noggrannhet.

Börja handla par →