Analisis Data Frekuensi Tinggi — Memproses Data Pasar Level Tick

Trading frekuensi tinggi di crypto beroperasi dalam skala waktu milidetik/mikrodetik. Memproses jutaan tick per hari, menangani aliran data yang meledak-ledak, dan mengekstrak sinyal mikrostruktur membedakan trader profesional dari yang lain. Panduan ini membahas manajemen data level tick dan analitik real-time yang mendukung siklus penyegaran 5 menit Smart Money API.

Insight kunci: Paus tidak menggerakkan pasar secara instan. Blok trade mereka menciptakan tanda yang terdeteksi dalam ketidakseimbangan order book, spread bid-ask, dan rasio volume taker. Smart Money API menangkap tanda ini secara real-time.

Pengumpulan dan Penyimpanan Data Tick

Sumber Data

Untuk crypto, data tick berasal dari:

Penyimpanan Tick Efisien dengan Parquet

Simpan data kolom terkompresi untuk kueri cepat:

Python — Pipeline data tick
import pandas as pd
import pyarrow.parquet as pq
# Buffer tick real-time (akumulasi selama 1h, lalu simpan)
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" atau "sell"
})
# Setiap jam, kompres dan simpan
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 = []

Analisis Order Book

Snapshot Order Book Level 2

Tangkap order book lengkap setiap 100-500ms:

Python — Pemrosesan order book
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):
# Ambil 10 bid dan ask terbaik
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)
# Imbalance: >1 = bullish (tekanan beli lebih besar)
return bid_volume / ask_volume if ask_volume > 0 else 1.0
def get_spread(self):
best_bid = max(self.bids.keys())
best_ask = min(self.asks.keys())
return (best_ask - best_bid) / best_bid # persentase spread

Sinyal Mikrostruktur

Ekstrak sinyal yang dapat ditindaklanjuti dari struktur order book:

Metrik Mikrostruktur Pasar

Volume-Weighted Average Price (VWAP)

Tolok ukur eksekusi yang lebih baik daripada harga penutupan sederhana:

Python — Perhitungan VWAP
def calculate_vwap(ticks):
# ticks: list of (price, volume) tuples
numerator = sum(price * volume for price, volume in ticks)
denominator = sum(volume for _, volume in ticks)
return numerator / denominator

Rasio Pembeli/Penjual Taker

Identifikasi sisi yang agresif:

Python — Analisis Taker
def get_taker_direction(tick):
# Jika harga perdagangan = bid, maka penjual agresif (supply)
# Jika harga perdagangan = ask, maka pembeli agresif (demand)
if abs(tick.price - best_bid) < tick.price_step:
return "sell"
elif abs(tick.price - best_ask) < tick.price_step:
return "buy"
else:
return "mid" # Di dalam spread, kemungkinan dark pool
buy_volume = sum(t.size untuk t di ticks jika get_taker_direction(t) == "buy")
sell_volume = sum(t.size untuk t di ticks jika get_taker_direction(t) == "sell")
return buy_volume / (buy_volume + sell_volume) # % beli

Arsitektur Pipeline Real-Time

Pemrosesan Aliran WebSocket

Hubungkan ke WebSocket Bybit/Binance/Hyperliquid untuk data langsung:

Python — Penanganan aliran langsung
import asyncio
import websockets
async def connect_bybit_ticks(symbol):
url = f"wss://stream.bybit.com/v5/public/spot"
async dengan websockets.connect(url) sebagai ws:
# Berlangganan ke aliran perdagangan
await ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{symbol}"]
}))
async untuk pesan di ws:
data = json.loads(pesan)
untuk trade di data["data"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

Pemrosesan Terdistribusi dengan Redis Streams

Tangani jutaan tick per hari dengan antrian pesan:

Python — Pemrosesan stream Redis
import redis
r = redis.Redis(host='localhost', port=6379)
# Produsen: kirim tick ke stream
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
})
# Grup konsumen membaca dengan pelacakan lag
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

Tambahkan sinyal real-time ke analitik Anda

Smart Money API mengumpulkan data tick dari 3 bursa dan 250+ dompet paus. Gunakan sinyal mikrostruktur yang telah dihitung sebelumnya untuk meningkatkan analisis real-time Anda sendiri.

Mulai Gratis Hari Ini →