ක්‍රිප්ටෝවල සංඛ්‍යානමය අර්බුධය — යුගල වෙළඳාම සහ මධ්‍යන්ය ප්‍රතිලෝමනය

සංඛ්‍යානමය අර්බුධය සමතුලිත මිලෙන් තාවකාලික අපගමනයන් උපයෝගී කර ගනී. සාමාන්‍යයෙන් එකට ගමන් කරන වත්කම් දෙකක් වෙන් වූ විට, සංඛ්‍යානමය අර්බුධ වෙළෙන්දා කාර්ය සාධනය අඩු වූ වත්කම මිලට ගෙන කාර්ය සාධනය වැඩි වූ වත්කම කෙටි කරයි, ඒවා එක්වීමට අපේක්ෂා කරමින්. ක්‍රිප්ටෝවලදී, මෙය විශේෂයෙන් බලවත් වන්නේ වත්කම් සහසම්බන්ධ වී ඇතත් සම්පූර්ණයෙන් නොවන නිසා ලාභදායී අවස්ථා ඇති වීමෙනි.

උදාහරණය: BTC සහ ETH හි සහසම්බන්ධතාවය 0.85 කි. ETH පැය 1 ක කාලයක් තුළ BTC ට වඩා 3% කින් කාර්ය සාධනය අඩු වූ විට (අසාමාන්‍ය), සංඛ්‍යානමය අර්බුධ වෙළෙන්දා BTC කෙටි කර ETH දිගු කරයි. ඓතිහාසිකව, ඒවා පැය 4-8 තුළ එක්වී ~1-1.5% ලාභය අගුළු දමයි.

යුගල වෙළඳාමේ මූලික කරුණු

යුගල තෝරා ගැනීම

සියලුම යුගල ක්‍රියා නොකරයි. ඔබට අවශ්‍ය:

Python — යුගල තේරීම
ආයාත කරන්න pandas as pd
සිට scipy.stats ආයාත කරන්න pearsonr
def find_cointegrated_pairs(symbols, data):
අපේක්ෂිතයන් = []
සඳහා i, sym1 හි enumerate(symbols):
සඳහා sym2 හි symbols[i+1:]:
# සහසම්බන්ධතාවය ගණනය කරන්න
corr, p_value = pearsonr(data[sym1], data[sym2])
නම් corr > 0.75:
# සහයෝගී ඒකාබද්ධතාව පරීක්ෂා කරන්න (Engle-Granger පරීක්ෂණය)
residuals = data[sym1] - (data[sym2] * corr)
adf_stat = adf_test(residuals) # ස්ථාවරත්වය
නම් adf_stat < 0.05: # ස්ථාවර
අපේක්ෂිතයන්.append((sym1, sym2, corr))
ප්‍රතිදානය අපේක්ෂිතයන්

සහයෝගී ඒකාබද්ධතා විශ්ලේෂණය

සහයෝගී ඒකාබද්ධතාවය යනු කුමක්ද?

ස්ථාවර නොවන ශ්‍රේණි දෙකක රේඛීය සංයෝජනය ස්ථාවර නම් ඒවා සහයෝගී ඒකාබද්ධතාවයකි. සරල භාෂාවෙන්: ඒවා කාලයත් සමඟ එකට ගමන් කරන අතර, එම සබඳතාවයෙන් අපගමනය අවසානයේ ප්‍රතිලෝම වේ.

BTC සහ ETH සඳහා:

හෙජ් අනුපාතය සොයා ගැනීම

ප්‍රශස්ත අනුපාතය සොයා ගැනීමට සාමාන්‍ය අවම වර්ග ප්‍රතිගාමී භාවිතා කරන්න:

Python — හෙජ් අනුපාතය ගණනය කිරීම
සිට sklearn.linear_model ආයාත කරන්න LinearRegression
def get_hedge_ratio(price1, price2):
# price1 price2 මත ප්‍රතිගාමී කිරීමෙන් beta (හෙජ් අනුපාතය) සොයා ගන්න
X = price2.reshape(-1, 1)
y = price1
model = LinearRegression().fit(X, y)
hedge_ratio = model.coef_[0]
intercept = model.intercept_
ප්‍රතිදානය hedge_ratio, intercept
# විස්තාරය = price1 - (hedge_ratio × price2) + intercept
beta, alpha = get_hedge_ratio(btc_prices, eth_prices)
spread = btc - (beta * eth)

මධ්‍යන්ය ප්‍රතිලෝමනය උපාය මාර්ග

Z-ලකුණු භාවිතා කිරීම

අන්තයන් හඳුනා ගැනීමට විස්තාරය සම්මත කරන්න. z-score > 2 වූ විට, විස්තාරය අසාමාන්‍ය ලෙස පළල් වේ (වෙළඳ අවස්ථාව):

Python — මධ්‍යන්ය ප්‍රතිලෝමනය වෙළඳාම
def mean_reversion_signal(spread, lookback=20):
# රෝලින් මධ්‍යන්ය සහ std ගණනය කරන්න
mean = spread.rolling(window=lookback).mean()
std = spread.rolling(window=lookback).std()
# Z-score: මධ්‍යන්යයෙන් std dev කීයක් දුරින්ද
z_score = (spread - mean) / std
# වෙළඳ සංඥා
නම් z_score[-1] > 2.0:
ප්‍රතිදානය "LONG_SPREAD" # විස්තාරය ඉතා පළල්, කාර්ය සාධනය අඩු වූවා මිලට ගන්න
නැතහොත් z_score[-1] < -2.0:
ප්‍රතිදානය "SHORT_SPREAD" # විස්තාරය ඉතා තද, කාර්ය සාධනය අඩු වූවා කෙටි කරන්න
නැතිනම්:
ප්‍රතිදානය "NEUTRAL"

නික්මීමේ නීති

විස්තාරය මධ්‍යන්යය වෙත ආපසු එන විට (z-score → 0) හෝ අලාභ සීමාව (z-score ප්‍රතිලෝමයේදී නවත්වන්න) වසා දමන්න:

Python — නික්මීමේ තර්කනය
def check_exit(entry_z_score, current_z_score, entry_price):
# ලාභ ගන්න: විස්තාරය මධ්‍යන්යය වෙත අඩක් ආපසු එක් විය
නම් abs(current_z_score) < abs(entry_z_score) * 0.5:
ප්‍රතිදානය පිටවීම, ලාභ ඉලක්කය
# Stop loss: z-score moved in wrong direction by >1
if (entry_z_score > 0 and current_z_score < entry_z_score + 1.0):
return පිටවීම, stop_loss
elif (entry_z_score < 0 and current_z_score > entry_z_score - 1.0):
return පිටවීම, stop_loss
return අල්ලාගෙන සිටින්න, None

Backtesting Stat Arb Strategies

Key metrics for stat arb:

Python — Backtest pairs strategy
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)

Adding Smart Money Intelligence

Enhance pairs trading by filtering trades with Smart Money confirmation:

Python — Filtered pairs strategy
def smart_money_pairs_strategy(symbol1, symbol2, z_score):
# Check pair-level Smart Money confirmation
sm1 = get_smart_money_signal(symbol1)
sm2 = get_smart_money_signal(symbol2)
# If one is HIGH bullish and other is HIGH bearish = strong divergence
# Great time to trade the spread
divergence_score = abs(sm1["composite"] - sm2["composite"])
if z_score > 2.0 and divergence_score > 0.3 and sm1["confidence"] != "VETO":
return "TRADE" # High confidence signal
else:
return "SKIP" # Wait for alignment

Supercharge stat arb with Smart Money pairs signals

Filter mean reversion trades with whale consensus and derivatives data. Our API confirms pair divergence validity with 62% accuracy improvement.

Start Trading Pairs →