Statisztikai arbitrázs a kriptópiacon — Párkereskedés és átlaghoz való visszatérés

A statisztikai arbitrázs kihasználja az egyensúlyi áraktól való átmeneti eltéréseket. Ha két olyan eszköz, amelyek általában együtt mozognak, eltér egymástól, a statisztikai arbitrázs kereskedő alul teljesítőt vásárol és a túl teljesítőt shortol, arra fogadva, hogy konvergálnak. A kriptópiacon ez különösen erős, mivel az eszközök korrelálnak, de nem tökéletesen, így nyereséges lehetőségeket teremtenek.

Példa: A BTC és ETH korrelációja 0,85. Ha az ETH 1 óra alatt 3%-kal alul teljesít a BTC-hez képest (szokatlan), a statisztikai arbitrázs kereskedő shortolja a BTC-t és longolja az ETH-t. Történelmileg 4-8 órán belül konvergálnak, így ~1-1,5% nyereséghez jutnak.

Párkereskedés alapjai

Párok kiválasztása

Nem minden pár működik. Szükséges:

Python — Párkiválasztás
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:]:
# Számítsd ki a korrelációt
corr, p_value = pearsonr(data[sym1], data[sym2])
if corr > 0.75:
# Teszteld a kointegrációt (Engle-Granger teszt)
residuals = data[sym1] - (data[sym2] * corr)
adf_stat = adf_test(residuals) # stacionaritás
if adf_stat < 0.05: # stacionárius
candidates.append((sym1, sym2, corr))
return candidates

Kointegráció elemzés

Mi a kointegráció?

Két nem stacionárius sorozat kointegrált, ha lineáris kombinációjuk stacionárius. Egyszerűbben: idővel együtt mozognak, és az eltérések ebből a kapcsolatból végül visszatérnek.

BTC és ETH esetén:

Hedging arány megtalálása

Használj közönséges legkisebb négyzetek regresszióját az optimális arány megtalálásához:

Python — Hedging arány számítás
from sklearn.linear_model import LinearRegression
def get_hedge_ratio(price1, price2):
# Regresszálj price1-et price2-re, hogy megtaláld a bétát (hedging arány)
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)

Átlaghoz való visszatérés stratégiák

Z-pontszámok használata

Standardizáld a spreadet, hogy észleld a szélsőségeket. Ha a z-pontszám > 2, a spread szokatlanul széles (kereskedési lehetőség):

Python — Átlaghoz való visszatérés kereskedés
def mean_reversion_signal(spread, lookback=20):
# Számítsd ki a gördülő átlagot és szórást
mean = spread.rolling(window=lookback).mean()
std = spread.rolling(window=lookback).std()
# Z-pontszám: hány szórásnyi az átlagtól
z_score = (spread - mean) / std
# Kereskedési jelek
if z_score[-1] > 2.0:
return "LONG_SPREAD" # spread túl széles, vedd alul teljesítőt
elif z_score[-1] < -2.0:
return "SHORT_SPREAD" # spread túl szűk, shortold alul teljesítőt
else:
return "NEUTRAL"

Kilépési szabályok

Zárd le, ha a spread visszatér az átlaghoz (z-pontszám → 0) vagy veszteségküszöb (állj meg z-pontszám fordulónál):

Python — Kilépési logika
def check_exit(entry_z_score, current_z_score, entry_price):
# Profit felvétel: a spread félig visszatért az átlaghoz
if abs(current_z_score) < abs(entry_z_score) * 0.5:
return KILÉPÉS, profit_cél
# Stop loss: z-score rossz irányba mozdult el >1-gyel
ha (entry_z_score > 0 és current_z_score < entry_z_score + 1.0):
return KILÉPÉS, stop_loss
különben ha (entry_z_score < 0 és current_z_score > entry_z_score - 1.0):
return KILÉPÉS, stop_loss
return TARTÁS, None

Statisztikai arbitrázs stratégiák visszatesztelése

Kulcsfontosságú mérőszámok a statisztikai arbitrázshoz:

Python — Páros stratégia visszatesztelése
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
for i in range(len(z_score)):
ha position is None:
ha z_score[i] > 2.0:
position = {"entry": spread[i], "z_entry": z_score[i], "idx": i}
különben:
exit_reason = check_exit(position["z_entry"], z_score[i], spread[i])[1]
ha exit_reason:
pnl = position["entry"] - spread[i]
trades.append({"pnl": pnl, "reason": exit_reason})
position = None
return pd.DataFrame(trades)

Intelligens pénz szűrése

Fejleszd a páros kereskedést az ügyletek szűrésével Intelligens pénz megerősítéssel:

Python — Szűrt páros stratégia
def smart_money_pairs_strategy(symbol1, symbol2, z_score):
# Ellenőrizd a páros Intelligens pénz megerősítést
sm1 = get_smart_money_signal(symbol1)
sm2 = get_smart_money_signal(symbol2)
# Ha az egyik HIGH bullish és a másik HIGH bearish = erős divergencia
# Ideális idő a spread kereskedésére
divergence_score = abs(sm1["composite"] - sm2["composite"])
ha z_score > 2.0 és divergence_score > 0.3 és sm1["confidence"] != "VETO":
return "KERESKEDÉS" # Magas megbízhatóságú jel
különben:
return "KIHAGYÁS" # Várj az összehangolásra

Turbózd fel a statisztikai arbitrázst Intelligens pénz páros jelekkel

Szűrd a középérték visszafordulásos ügyleteket bálnák konszenzusával és derivatív adatokkal. API-nk 62%-os pontosságnövekedéssel erősíti meg a páros divergencia érvényességét.

Kezdd el a páros kereskedést →