Arbitragem Estatística em Cripto — Pairs Trading e Reversão à Média

A arbitragem estatística explora desvios temporários dos preços de equilíbrio. Quando dois ativos que normalmente se movem juntos divergem, um trader de stat arb compra o underperformer e vende o outperformer, apostando na convergência. No cripto, isso é especialmente poderoso porque os ativos são correlacionados, mas não perfeitamente, criando oportunidades lucrativas.

Exemplo: A correlação entre BTC e ETH é 0.85. Quando o ETH underperforms o BTC em 3% em um período de 1 hora (incomum), um trader de stat arb vende BTC e compra ETH. Historicamente, eles convergem em 4-8 horas, garantindo ~1-1.5% de lucro.

Noções Básicas de Pairs Trading

Seleção de Pares

Nem todos os pares funcionam. Você precisa de:

Alta correlação: >0.8 (use o coeficiente de correlação de Pearson)
Relação econômica: Layer 2s para L1, stablecoins entre si
Volume suficiente: Ambos os pares devem ser líquidos
Cointegração: Existe um equilíbrio de longo prazo (testes com o teste de Johansen)

Python — Seleção de Pares
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:]:
# Calculate correlation
corr, p_value = pearsonr(data[sym1], data[sym2])
if corr > 0.75:
# Test cointegration (Engle-Granger test)
residuals = data[sym1] - (data[sym2] * corr)
adf_stat = adf_test(residuals)  # stationarity
if adf_stat < 0.05:  # stationary
candidates.append((sym1, sym2, corr))
return candidates

Análise de Cointegração

O que é Cointegração?

Duas séries não estacionárias são cointegradas se sua combinação linear for estacionária. Em linguagem simples: elas se movem juntas ao longo do tempo, e os desvios dessa relação eventualmente revertem.

Para BTC e ETH:

Preço do BTC: $42,000 (não estacionário — tende a subir/descer)
Preço do ETH: $2,300 (não estacionário — tende a subir/descer)
Spread: BTC - (18 × ETH) = $40 (estacionário — oscila em torno da média)

Encontrando a Razão de Hedge

Use regressão de mínimos quadrados ordinários para encontrar a razão ótima:

Python — Cálculo da razão de hedge
from sklearn.linear_model import LinearRegression
def get_hedge_ratio(price1, price2):
# Regress price1 on price2 to find 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)

Estratégias de Reversão à Média

Usando Z-Scores

Padronize o spread para detectar extremos. Quando z-score > 2, o spread está anormalmente amplo (oportunidade de trade):

Python — Trading de reversão à média
def mean_reversion_signal(spread, lookback=20):
# Calculate rolling mean and std
mean = spread.rolling(window=lookback).mean()
std = spread.rolling(window=lookback).std()
# Z-score: how many std devs from mean
z_score = (spread - mean) / std
# Trading signals
if z_score[-1] > 2.0:
return "LONG_SPREAD" # spread too wide, buy underperformer
elif z_score[-1] < -2.0:
return "SHORT_SPREAD" # spread too tight, short underperformer
else:
return "NEUTRAL"

Regras de Saída

Feche quando o spread retornar à média (z-score → 0) ou atingir um limite de perda (stop no reversão do z-score):

Python — Lógica de saída
def check_exit(entry_z_score, current_z_score, entry_price):
# Take profit: spread converged halfway back to mean
if abs(current_z_score) < abs(entry_z_score) * 0.5:
return SAIR, alvo_de_lucro
# Stop loss: z-score moveu na direção errada por >1
se (entry_z_score > 0 e current_z_score < entry_z_score + 1.0):
retornar SAIR, stop_loss
elif (entry_z_score < 0 e current_z_score > entry_z_score - 1.0):
retornar SAIR, stop_loss
retornar MANTER, Nenhum

Backtest de Estratégias de Arbitragem Estatística

Métricas-chave para arbitragem estatística:

Taxa de acerto: >55% (você está capturando reversões consistentemente)
Razão média de ganho/perda: >1.2 (ganhos superam perdas)
Razão de Sharpe: >0.8 (retornos por unidade de risco)
Drawdown máximo: <-15% (o sistema permanece seguro)

Python — Estratégia de backtest de pares
def backtest_pairs_strategy(price1, price2, hedge_ratio):
spread = price1 - (hedge_ratio * price2)
média = spread.rolling(20).mean()
desvio_padrão = spread.rolling(20).std()
z_score = (spread - média) / desvio_padrão
trades = []
posição = Nenhum
para i em range(len(z_score)):
se posição é Nenhum:
se z_score[i] > 2.0:
posição = {"entrada": spread[i], "z_entrada": z_score[i], "idx": i}
senão:
motivo_saída = check_exit(posição["z_entrada"], z_score[i], spread[i])[1]
se motivo_saída:
pnl = posição["entrada"] - spread[i]
trades.append({"pnl": pnl, "motivo": motivo_saída})
posição = Nenhum
retornar pd.DataFrame(trades)

Adicionando Inteligência Smart Money

Melhore o trading de pares filtrando trades com confirmação Smart Money:

Python — Estratégia de pares filtrada
def smart_money_pairs_strategy(symbol1, symbol2, z_score):
# Verifique a confirmação Smart Money no nível de par
sm1 = get_smart_money_signal(symbol1)
sm2 = get_smart_money_signal(symbol2)
# Se um é ALTAMENTE bullish e o outro é ALTAMENTE bearish = forte divergência
# Ótimo momento para negociar o spread
pontuação_divergência = abs(sm1["composto"] - sm2["composto"])
se z_score > 2.0 e pontuação_divergência > 0.3 e sm1["confiança"] != "VETO":
retornar "NEGOCIAR" # Sinal de alta confiança
senão:
retornar "PULAR" # Aguarde alinhamento

Supercarregue a arbitragem estatística com sinais Smart Money de pares

Filtre trades de reversão à média com consenso de baleias e dados de derivativos. Nossa API confirma a validade da divergência de pares com uma melhoria de 62% na precisão.

Comece a Negociar Pares →