हाई-फ्रीक्वेंसी डेटा विश्लेषण — टिक-लेवल मार्केट डेटा प्रोसेसिंग

क्रिप्टो में हाई-फ्रीक्वेंसी ट्रेडिंग मिलीसेकंड/माइक्रोसेकंड स्केल पर काम करती है। प्रतिदिन लाखों टिक्स को प्रोसेस करना, बर्स्टी डेटा फ्लो को हैंडल करना और माइक्रोस्ट्रक्चर सिग्नल्स निकालना पेशेवर ट्रेडर्स को बाकियों से अलग करता है। यह गाइड टिक-लेवल डेटा मैनेजमेंट और रियल-टाइम एनालिटिक्स के बारे में बताती है जो Smart Money API के 5-मिनट रिफ्रेश साइकल को पावर देती है।

मुख्य अंतर्दृष्टि: व्हेल्स मार्केट को तुरंत नहीं हिलाते। उनके ब्लॉक ट्रेड्स ऑर्डर बुक असंतुलन, बिड-आस्क स्प्रेड्स और टेकर वॉल्यूम अनुपात में पहचाने जाने योग्य सिग्नेचर बनाते हैं। Smart Money API इन सिग्नेचर्स को रियल-टाइम में कैप्चर करती है।

टिक डेटा संग्रह और भंडारण

डेटा स्रोत

क्रिप्टो के लिए, टिक डेटा आता है:

Parquet के साथ कुशल टिक स्टोरेज

फास्ट क्वेरीज़ के लिए कंप्रेस्ड कॉलमर डेटा स्टोर करें:

Python — टिक डेटा पाइपलाइन
import pandas as pd
import pyarrow.parquet as pq
# रियल-टाइम टिक बफर (1h के लिए जमा करें, फिर सेव करें)
tick_buffer = []
def on_tick(exchange, symbol, price, size, side, timestamp):
tick_buffer.append({
"timestamp": timestamp,
"exchange": exchange,
"symbol": symbol,
"price": price,
"size": size,
"side": side # "buy" या "sell"
})
# हर घंटे, कंप्रेस करें और सेव करें
if len(tick_buffer) > 1_000_000:
df = pd.DataFrame(tick_buffer)
pq.write_table(
pa.Table.from_pandas(df),
f"ticks/{symbol}_{timestamp:%Y%m%d_%H}.parquet",
compression="snappy"
)
tick_buffer = []

ऑर्डर बुक विश्लेषण

लेवल 2 ऑर्डर बुक स्नैपशॉट्स

पूरी ऑर्डर बुक को हर 100-500ms पर कैप्चर करें:

Python — ऑर्डर बुक प्रोसेसिंग
class OrderBook:
def __init__(self):
self.bids = {} # price -> size
self.asks = {} # price -> size
def update(self, side, price, size):
if side == "bid":
if size == 0: del self.bids[price]
else: self.bids[price] = size
else:
if size == 0: del self.asks[price]
else: self.asks[price] = size
def get_imbalance(self, depth=10):
# सबसे अच्छी 10 बिड्स और आस्क्स प्राप्त करें
top_bids = sorted(self.bids.items(), reverse=True)[:depth]
top_asks = sorted(self.asks.items())[:depth]
bid_volume = sum(size for _, size in top_bids)
ask_volume = sum(size for _, size in top_asks)
# असंतुलन: >1 = तेजी (खरीद दबाव अधिक)
वापसी बोली_मात्रा / पूछ_मात्रा अगर पूछ_मात्रा > 0 अन्यथा 1.0
परिभाषित फैलाव_प्राप्त_करें(स्वयं):
सर्वोत्तम_बोली = अधिकतम(स्वयं.बोलियाँ.कुंजियाँ())
सर्वोत्तम_पूछ = न्यूनतम(स्वयं.पूछ.कुंजियाँ())
वापसी (सर्वोत्तम_पूछ - सर्वोत्तम_बोली) / सर्वोत्तम_बोली # प्रतिशत फैलाव

सूक्ष्मसंरचना संकेत

ऑर्डर बुक संरचना से कार्रवाई योग्य संकेत निकालें:

बाजार सूक्ष्मसंरचना मेट्रिक्स

वॉल्यूम-भारित औसत मूल्य (VWAP)

साधारण समापन मूल्य से बेहतर निष्पादन मानक:

Python — VWAP गणना
परिभाषित vwap_गणना_करें(टिक्स):
# टिक्स: (मूल्य, मात्रा) टुपल्स की सूची
अंश = योग(मूल्य * मात्रा के लिए मूल्य, मात्रा में टिक्स)
हर = योग(मात्रा के लिए _, मात्रा में टिक्स)
वापसी अंश / हर

टेकर खरीद/बिक्री अनुपात

पहचानें कि कौन सा पक्ष आक्रामक है:

Python — टेकर विश्लेषण
परिभाषित टेकर_दिशा_प्राप्त_करें(टिक):
# यदि व्यापार मूल्य = बोली, तो विक्रेता आक्रामक था (आपूर्ति)
# यदि व्यापार मूल्य = पूछ, तो खरीदार आक्रामक था (मांग)
अगर abs(टिक.मूल्य - सर्वोत्तम_बोली) < टिक.मूल्य_चरण:
वापसी "बेचें"
अन्यथा यदि abs(टिक.मूल्य - सर्वोत्तम_पूछ) < टिक.मूल्य_चरण:
वापसी "खरीदें"
अन्यथा:
वापसी "मध्य" # फैलाव के अंदर, संभवतः डार्क पूल
खरीद_मात्रा = योग(टी.आकार के लिए t में टिक्स अगर टेकर_दिशा_प्राप्त_करें(टी) == "खरीदें")
बिक्री_मात्रा = योग(टी.आकार के लिए t में टिक्स अगर टेकर_दिशा_प्राप्त_करें(टी) == "बेचें")
वापसी खरीद_मात्रा / (खरीद_मात्रा + बिक्री_मात्रा) # % खरीद

रीयल-टाइम पाइपलाइन आर्किटेक्चर

वेबसॉकेट स्ट्रीम प्रोसेसिंग

Bybit/Binance/Hyperliquid वेबसॉकेट से लाइव डेटा के लिए कनेक्ट करें:

Python — लाइव स्ट्रीम हैंडलर
आयात asyncio
आयात websockets
असिंक परिभाषित bybit_टिक्स_कनेक्ट_करें(प्रतीक):
यूआरएल = f"wss://stream.bybit.com/v5/public/spot"
असिंक साथ websockets.connect(यूआरएल) के रूप में ws:
# ट्रेड स्ट्रीम की सदस्यता लें
प्रतीक्षा करें ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{प्रतीक}"]
}))
असिंक के लिए संदेश में ws:
डेटा = json.loads(संदेश)
के लिए व्यापार में डेटा["data"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

Redis स्ट्रीम्स के साथ वितरित प्रसंस्करण

मैसेज क्यूइंग के साथ प्रतिदिन लाखों टिक्स को संभालें:

Python — Redis स्ट्रीम प्रोसेसिंग
import redis
r = redis.Redis(host='localhost', port=6379)
# प्रोड्यूसर: स्ट्रीम पर टिक्स पुश करें
def publish_tick(exchange, symbol, tick):
stream_key = f"ticks:{exchange}:{symbol}"
r.xadd(stream_key, {
"price": tick.price,
"size": tick.size,
"side": tick.side,
"ts": tick.timestamp
})
# कंज्यूमर ग्रुप लैग ट्रैकिंग के साथ पढ़ता है
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

अपने एनालिटिक्स में रीयल-टाइम सिग्नल जोड़ें

Smart Money API 3 एक्सचेंजों और 250+ व्हेल वॉलेट्स से टिक डेटा एकत्रित करता है। अपने स्वयं के रीयल-टाइम विश्लेषण को बढ़ाने के लिए हमारे पूर्व-गणना किए गए माइक्रोस्ट्रक्चर सिग्नल्स का उपयोग करें।

आज ही मुफ्त में शुरू करें →