Arbitraj Statistic în Crypto — Tranzacționare în Perechi și Revenire la Medie

Arbitrajul statistic exploatează abaterile temporare de la prețurile de echilibru. Când două active care în mod normal se mișcă împreună diverg, un trader de arbitraj statistic cumpără activul subperformant și vinde pe celălalt, pariind pe convergență. În crypto, acest lucru este deosebit de puternic deoarece activele sunt corelate, dar nu perfect, creând oportunități profitabile.

Exemplu: Corelația BTC și ETH este de 0,85. Când ETH subperformă față de BTC cu 3% pe o perioadă de 1 oră (neobișnuit), un trader de arbitraj statistic vinde BTC și cumpără ETH. Istoric, acestea converg în 4-8 ore, blocând un profit de ~1-1,5%.

Bazele Tranzacționării în Perechi

Selectarea Perechilor

Nu toate perechile funcționează. Ai nevoie de:

Corelație ridicată: >0,8 (folosește coeficientul de corelație Pearson)
Relație economică: Layer 2s la L1, stablecoins între ele
Volum suficient: Ambele perechi trebuie să fie lichide
Cointegrare: Există un echilibru pe termen lung (teste cu testul Johansen)

Python — Selectarea Perechilor
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:]:
# Calculează corelația
corr, p_value = pearsonr(data[sym1], data[sym2])
if corr > 0.75:
# Testează cointegrarea (test Engle-Granger)
residuals = data[sym1] - (data[sym2] * corr)
adf_stat = adf_test(residuals)  # staționaritate
if adf_stat < 0.05:  # staționar
candidates.append((sym1, sym2, corr))
return candidates

Analiza Cointegrării

Ce este Cointegrarea?

Două serii nestaționare sunt cointegrate dacă combinația lor liniară este staționară. În termeni simpli: ele se mișcă împreună în timp, iar abaterile de la această relație se întorc în cele din urmă.

Pentru BTC și ETH:

Preț BTC: $42,000 (nestaționar — fluctuează în sus/jos)
Preț ETH: $2,300 (nestaționar — fluctuează în sus/jos)
Spread: BTC - (18 × ETH) = $40 (staționar — oscilează în jurul mediei)

Găsirea Raportului de Acoperire

Folosește regresia liniară pentru a găsi raportul optim:

Python — Calculul raportului de acoperire
from sklearn.linear_model import LinearRegression
def get_hedge_ratio(price1, price2):
# Regresează price1 pe price2 pentru a găsi beta (raportul de acoperire)
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)

Strategii de Revenire la Medie

Folosind Z-Scores

Standardizează spreadul pentru a detecta extreme. Când z-score > 2, spreadul este neobișnuit de larg (oportunitate de tranzacționare):

Python — Tranzacționare de revenire la medie
def mean_reversion_signal(spread, lookback=20):
# Calculează media și deviația standard rulantă
mean = spread.rolling(window=lookback).mean()
std = spread.rolling(window=lookback).std()
# Z-score: câte deviații standard de la medie
z_score = (spread - mean) / std
# Semnale de tranzacționare
if z_score[-1] > 2.0:
return "LONG_SPREAD" # spread prea larg, cumpără subperformantul
elif z_score[-1] < -2.0:
return "SHORT_SPREAD" # spread prea strâns, vinde subperformantul
else:
return "NEUTRAL"

Reguli de Ieșire

Închide când spreadul revine la medie (z-score → 0) sau pragul de pierdere (oprește-te la inversarea z-score):

Python — Logică de ieșire
def check_exit(entry_z_score, current_z_score, entry_price):
# Take profit: spreadul a convergit la jumătate înapoi la medie
if abs(current_z_score) < abs(entry_z_score) * 0.5:
return IEȘIRE, țintă_de_profit
# Stop loss: scorul z s-a mișcat în direcția greșită cu >1
dacă (scorul_z_intrare > 0 și scorul_z_curent < scorul_z_intrare + 1.0):
returnează IEȘIRE, stop_loss
altfel dacă (scorul_z_intrare < 0 și scorul_z_curent > scorul_z_intrare - 1.0):
returnează IEȘIRE, stop_loss
returnează ȚINE, None

Testarea Strategiilor de Arbitraj Statistic

Metrici cheie pentru arbitrajul statistic:

Rata de succes: >55% (prinzi consisten revenirile)
Raportul mediu câștig/pierdere: >1.2 (câștigurile depășesc pierderile)
Raportul Sharpe: >0.8 (randament pe unitate de risc)
Scăderea maximă: <-15% (sistemul rămâne sigur)

Python — Testarea strategiei de perechi
def testează_strategia_perechi(preț1, preț2, raport_acoperire):
diferența = preț1 - (raport_acoperire * preț2)
media = diferența.rolling(20).mean()
deviația = diferența.rolling(20).std()
scor_z = (diferența - media) / deviația
tranzacții = []
poziție = None
pentru i în range(len(scor_z)):
dacă poziție este None:
dacă scor_z[i] > 2.0:
poziție = {"intrare": diferența[i], "z_intrare": scor_z[i], "idx": i}
altfel:
motiv_ieșire = verifica_ieșire(poziție["z_intrare"], scor_z[i], diferența[i])[1]
dacă motiv_ieșire:
pnl = poziție["intrare"] - diferența[i]
tranzacții.append({"pnl": pnl, "motiv": motiv_ieșire})
poziție = None
returnează pd.DataFrame(tranzacții)

Adăugarea Inteligenței Smart Money

Îmbunătățește tranzacționarea perechilor prin filtrarea tranzacțiilor cu confirmare Smart Money:

Python — Strategie de perechi filtrată
def strategie_perechi_smart_money(simbol1, simbol2, scor_z):
# Verifică confirmarea Smart Money la nivel de pereche
sm1 = obține_semnal_smart_money(simbol1)
sm2 = obține_semnal_smart_money(simbol2)
# Dacă unul este FOARTE optimist și celălalt FOARTE pesimist = divergență puternică
# Moment excelent pentru a tranzacționa diferența
scor_divergență = abs(sm1["compozit"] - sm2["compozit"])
dacă scor_z > 2.0 și scor_divergență > 0.3 și sm1["încredere"] != "VETO":
returnează "TRANZACȚIE" # Semnal de încredere ridicată
altfel:
returnează "OMITE" # Așteaptă alinierea

Împuternicește arbitrajul statistic cu semnale Smart Money pentru perechi

Filtrează tranzacțiile de revenire la medie cu consensul balenelor și date derivate. API-ul nostru confirmă validitatea divergenței perechilor cu o îmbunătățire a preciziei de 62%.

Începe să Tranzacționezi Perechi →