क्रिप्टो में सांख्यिकीय आर्बिट्रेज — जोड़ी ट्रेडिंग और मीन रिवर्जन

सांख्यिकीय आर्बिट्रेज संतुलन मूल्यों से अस्थायी विचलन का फायदा उठाता है। जब दो संपत्तियां जो आमतौर पर एक साथ चलती हैं, अलग हो जाती हैं, तो एक स्टेट आर्ब ट्रेडर अंडरपरफॉर्मर को खरीदता है और आउटपरफॉर्मर को शॉर्ट करता है, अभिसरण पर दांव लगाता है। क्रिप्टो में, यह विशेष रूप से शक्तिशाली है क्योंकि संपत्तियां सहसंबद्ध हैं लेकिन पूरी तरह से नहीं, जिससे लाभदायक अवसर पैदा होते हैं।

उदाहरण: BTC और ETH का सहसंबंध 0.85 है। जब ETH 1-घंटे की अवधि में BTC से 3% कम प्रदर्शन करता है (असामान्य), तो एक स्टेट आर्ब ट्रेडर BTC को शॉर्ट करता है और ETH को लॉन्ग करता है। ऐतिहासिक रूप से, वे 4-8 घंटे के भीतर अभिसरण करते हैं, ~1-1.5% लाभ अर्जित करते हैं।

जोड़ी ट्रेडिंग की मूल बातें

जोड़ी का चयन

सभी जोड़ियां काम नहीं करतीं। आपको चाहिए:

उच्च सहसंबंध: >0.8 (पियर्सन सहसंबंध गुणांक का उपयोग करें)
आर्थिक संबंध: लेयर 2 से L1, स्टेबलकॉइन्स एक दूसरे से
पर्याप्त वॉल्यूम: दोनों जोड़ियां तरल होनी चाहिए
सहसंयोजन: दीर्घकालिक संतुलन मौजूद है (जोहानसन परीक्षण के साथ परीक्षण)

पायथन — जोड़ी चयन
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

सहसंयोजन विश्लेषण

सहसंयोजन क्या है?

दो गैर-स्थिर श्रृंखलाएं सहसंयोजित होती हैं यदि उनका रैखिक संयोजन स्थिर हो। सरल शब्दों में: वे समय के साथ एक साथ चलती हैं, और उस संबंध से विचलन अंततः वापस आता है।

BTC और ETH के लिए:

BTC मूल्य: $42,000 (गैर-स्थिर — ऊपर/नीचे ट्रेंड करता है)
ETH मूल्य: $2,300 (गैर-स्थिर — ऊपर/नीचे ट्रेंड करता है)
स्प्रेड: BTC - (18 × ETH) = $40 (स्थिर — माध्य के आसपास दोलन करता है)

हेज अनुपात ढूँढना

इष्टतम अनुपात खोजने के लिए साधारण न्यूनतम वर्ग प्रतिगमन का उपयोग करें:

पायथन — हेज अनुपात गणना
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)

मीन रिवर्जन रणनीतियाँ

Z-स्कोर का उपयोग करना

चरम सीमाओं का पता लगाने के लिए स्प्रेड को मानकीकृत करें। जब z-score > 2, स्प्रेड असामान्य रूप से चौड़ा होता है (ट्रेड अवसर):

पायथन — मीन रिवर्जन ट्रेडिंग
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"

एग्जिट नियम

बंद करें जब स्प्रेड माध्य पर वापस आ जाए (z-score → 0) या हानि सीमा (z-score उलट पर रुकें):

पायथन — एग्जिट लॉजिक
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 EXIT, लाभ_लक्ष्य
# स्टॉप लॉस: z-स्कोर गलत दिशा में >1 से चला गया
अगर (entry_z_score > 0 और current_z_score < entry_z_score + 1.0):
वापसी EXIT, स्टॉप_लॉस
अन्यथा (entry_z_score < 0 और current_z_score > entry_z_score - 1.0):
वापसी EXIT, स्टॉप_लॉस
वापसी होल्ड, None

बैकटेस्टिंग स्टैट आर्ब स्ट्रैटेजीज

स्टैट आर्ब के लिए मुख्य मेट्रिक्स:

जीत दर: >55% (आप लगातार रिवर्सन पकड़ रहे हैं)
औसत जीत/हानि अनुपात: >1.2 (लाभ हानि से अधिक)
शार्प अनुपात: >0.8 (जोखिम प्रति इकाई रिटर्न)
अधिकतम ड्रॉडाउन: <-15% (सिस्टम सुरक्षित रहता है)

पायथन — बैकटेस्ट पेयर्स स्ट्रैटेजी
def backtest_pairs_strategy(price1, price2, hedge_ratio):
स्प्रेड = price1 - (hedge_ratio * price2)
मीन = स्प्रेड.रोलिंग(20).मीन()
std = स्प्रेड.रोलिंग(20).std()
z_score = (स्प्रेड - मीन) / std
ट्रेड्स = []
पोजिशन = None
के लिए i में रेंज(len(z_score)):
अगर पोजिशन है None:
अगर z_score[i] > 2.0:
पोजिशन = {प्रवेश: स्प्रेड[i], z_प्रवेश: z_score[i], idx: i}
अन्यथा:
exit_reason = check_exit(position[z_प्रवेश], z_score[i], स्प्रेड[i])[1]
अगर exit_reason:
pnl = position[प्रवेश] - स्प्रेड[i]
ट्रेड्स.append({pnl: pnl, कारण: exit_reason})
पोजिशन = None
वापसी pd.DataFrame(ट्रेड्स)

स्मार्ट मनी इंटेलिजेंस जोड़ना

स्मार्ट मनी पुष्टि के साथ ट्रेड्स को फ़िल्टर करके पेयर्स ट्रेडिंग को बढ़ाएं:

पायथन — फ़िल्टर्ड पेयर्स स्ट्रैटेजी
def smart_money_pairs_strategy(symbol1, symbol2, z_score):
# पेयर-लेवल स्मार्ट मनी पुष्टि की जाँच करें
sm1 = get_smart_money_signal(symbol1)
sm2 = get_smart_money_signal(symbol2)
# यदि एक HIGH बुलिश है और दूसरा HIGH बेयरिश है = मजबूत डाइवर्जेंस
# स्प्रेड ट्रेड करने का बेहतरीन समय
डाइवर्जेंस_स्कोर = abs(sm1[कम्पोजिट] - sm2[कम्पोजिट])
अगर z_score > 2.0 और डाइवर्जेंस_स्कोर > 0.3 और sm1[आत्मविश्वास] != VETO:
वापसी ट्रेड # उच्च आत्मविश्वास सिग्नल
अन्यथा:
वापसी स्किप # संरेखण के लिए प्रतीक्षा करें

स्मार्ट मनी पेयर्स सिग्नल के साथ स्टैट आर्ब को सुपरचार्ज करें

व्हेल सहमति और डेरिवेटिव्स डेटा के साथ मीन रिवर्जन ट्रेड्स को फ़िल्टर करें। हमारा API पेयर्स डाइवर्जेंस वैधता को 62% सटीकता सुधार के साथ पुष्टि करता है।

पेयर्स ट्रेडिंग शुरू करें →