Arbitraggio statistico in crypto — Pairs Trading e Mean Reversion

L'arbitraggio statistico sfrutta deviazioni temporanee dai prezzi di equilibrio. Quando due asset che normalmente si muovono insieme divergono, un trader di stat arb acquista quello sottoperformante e vende quello sovraperformante, puntando sulla convergenza. Nel crypto, questo è particolarmente efficace perché gli asset sono correlati ma non perfettamente, creando opportunità redditizie.

Esempio: La correlazione tra BTC e ETH è 0.85. Quando ETH sottoperforma BTC del 3% in un periodo di 1 ora (insolito), un trader di stat arb vende BTC e compra ETH. Storicamente, convergono entro 4-8 ore, bloccando un profitto di ~1-1.5%.

Nozioni di base sul Pairs Trading

Selezione delle coppie

Non tutte le coppie funzionano. Servono:

Alta correlazione: >0.8 (usa il coefficiente di correlazione di Pearson)
Relazione economica: Layer 2 rispetto a L1, stablecoin tra loro
Volume sufficiente: Entrambe le coppie devono essere liquide
Cointegrazione: Esiste un equilibrio a lungo termine (test con il test di Johansen)

Python — Selezione delle coppie
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:]:
# Calcola la correlazione
corr, p_value = pearsonr(data[sym1], data[sym2])
if corr > 0.75:
# Test di cointegrazione (test di Engle-Granger)
residuals = data[sym1] - (data[sym2] * corr)
adf_stat = adf_test(residuals)  # stazionarietà
if adf_stat < 0.05:  # stazionario
candidates.append((sym1, sym2, corr))
return candidates

Analisi di cointegrazione

Cos'è la cointegrazione?

Due serie non stazionarie sono cointegrate se la loro combinazione lineare è stazionaria. In parole semplici: si muovono insieme nel tempo, e le deviazioni da questa relazione alla fine si ripristinano.

Per BTC e ETH:

Prezzo BTC: $42,000 (non stazionario — tende a salire/scendere)
Prezzo ETH: $2,300 (non stazionario — tende a salire/scendere)
Spread: BTC - (18 × ETH) = $40 (stazionario — oscilla attorno alla media)

Trovare l'hedge ratio

Usa la regressione OLS per trovare il rapporto ottimale:

Python — Calcolo dell'hedge ratio
from sklearn.linear_model import LinearRegression
def get_hedge_ratio(price1, price2):
# Regressione di price1 su price2 per trovare beta (hedge ratio)
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)

Strategie di Mean Reversion

Utilizzo degli Z-Score

Standardizza lo spread per rilevare estremi. Quando z-score > 2, lo spread è insolitamente ampio (opportunità di trading):

Python — Trading di mean reversion
def mean_reversion_signal(spread, lookback=20):
# Calcola media e deviazione standard mobile
mean = spread.rolling(window=lookback).mean()
std = spread.rolling(window=lookback).std()
# Z-score: quante deviazioni standard dalla media
z_score = (spread - mean) / std
# Segnali di trading
if z_score[-1] > 2.0:
return "LONG_SPREAD" # spread troppo ampio, acquista sottoperformante
elif z_score[-1] < -2.0:
return "SHORT_SPREAD" # spread troppo stretto, vendi sottoperformante
else:
return "NEUTRAL"

Regole di uscita

Chiudi quando lo spread torna alla media (z-score → 0) o soglia di perdita (stop al ribaltamento dello z-score):

Python — Logica di uscita
def check_exit(entry_z_score, current_z_score, entry_price):
# Prendi profitto: spread convergente a metà strada verso la media
if abs(current_z_score) < abs(entry_z_score) * 0.5:
return USCITA, obiettivo_di_profitto
# Stop loss: lo z-score si è mosso nella direzione sbagliata di >1
if (entry_z_score > 0 and current_z_score < entry_z_score + 1.0):
return USCITA, stop_loss
elif (entry_z_score < 0 and current_z_score > entry_z_score - 1.0):
return USCITA, stop_loss
return MANTIENI, None

Backtest delle strategie di arbitraggio statistico

Metriche chiave per l'arbitraggio statistico:

Percentuale di successo: >55% (stai cogliendo le inversioni in modo consistente)
Rapporto medio vincita/perdita: >1.2 (i guadagni superano le perdite)
Indice di Sharpe: >0.8 (rendimenti per unità di rischio)
Massimo drawdown: <-15% (il sistema rimane sicuro)

Python — Backtest della strategia a coppie
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)):
if position is None:
if z_score[i] > 2.0:
position = {"entry": spread[i], "z_entry": z_score[i], "idx": i}
else:
exit_reason = check_exit(position["z_entry"], z_score[i], spread[i])[1]
if exit_reason:
pnl = position["entry"] - spread[i]
trades.append({"pnl": pnl, "reason": exit_reason})
position = None
return pd.DataFrame(trades)

Aggiungere l'intelligenza Smart Money

Migliora il trading a coppie filtrando le operazioni con la conferma Smart Money:

Python — Strategia a coppie filtrata
def smart_money_pairs_strategy(symbol1, symbol2, z_score):
# Controlla la conferma Smart Money a livello di coppia
sm1 = get_smart_money_signal(symbol1)
sm2 = get_smart_money_signal(symbol2)
# Se uno è MOLTO rialzista e l'altro è MOLTO ribassista = forte divergenza
# Ottimo momento per negoziare lo spread
divergence_score = abs(sm1["composite"] - sm2["composite"])
if z_score > 2.0 and divergence_score > 0.3 and sm1["confidence"] != "VETO":
return "TRADE" # Segnale ad alta confidenza
else:
return "SKIP" # Aspetta l'allineamento

Potenzia l'arbitraggio statistico con i segnali Smart Money a coppie

Filtra le operazioni di mean reversion con il consenso delle balene e i dati derivati. La nostra API conferma la validità della divergenza di coppia con un miglioramento dell'accuratezza del 62%.

Inizia a Fare Trading a Coppie →