Analiză de Date de Înaltă Frecvență — Prelucrarea Datelor Tick-Level de Piață

Tradingul de înaltă frecvență în crypto operează la scale de timp de milisecunde/microsecunde. Prelucrarea a milioane de tick-uri pe zi, gestionarea fluxurilor de date bruște și extragerea semnalelor de microstructură separă traderii profesioniști de restul. Acest ghid trece prin managementul datelor tick-level și analitica în timp real care alimentează ciclurile de actualizare de 5 minute ale Smart Money API.

Cheie de înțelegere: Balenele nu mișcă piețele instantaneu. Tranzacțiile lor în bloc creează semnături detectabile în dezechilibrul cărții de comenzi, spreadurile bid-ask și rapoartele de volum taker. Smart Money API capturează aceste semnături în timp real.

Colectarea și Stocarea Datelor Tick

Surse de Date

Pentru crypto, datele tick provin de la:

Stocare Eficientă a Tick-urilor cu Parquet

Stochează date coloane comprimate pentru interogări rapide:

Python — Pipeline de date tick
import pandas as pd
import pyarrow.parquet as pq
# Buffer tick în timp real (acumulează pentru 1h, apoi salvează)
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" sau "sell"
})
# La fiecare oră, comprimă și salvează
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 = []

Analiza Cărții de Comenzi

Instantanee ale Cărții de Comenzi Nivelul 2

Capturează întreaga carte de comenzi la fiecare 100-500ms:

Python — Prelucrarea cărții de comenzi
class OrderBook:
def __init__(self):
self.bids = {} # preț -> mărime
self.asks = {} # preț -> mărime
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):
# Obține cele mai bune 10 bid-uri și ask-uri
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 (presiune de cumpărare mai mare)
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 # procentaj spread

Semnale de Microstructură

Extrage semnale acționabile din structura cărții de ordine:

Metrici de Microstructură a Pieței

Prețul Mediu Ponderat pe Volum (VWAP)

Punct de referință mai bun pentru execuție decât prețul de închidere simplu:

Python — Calcul VWAP
def calculate_vwap(ticks):
# ticks: listă de tupluri (preț, volum)
numerator = sum(price * volume for price, volume in ticks)
denominator = sum(volume for _, volume in ticks)
return numerator / denominator

Raportul Taker Buy/Sell

Identifică care parte este agresivă:

Python — Analiză Taker
def get_taker_direction(tick):
# Dacă prețul tranzacției = bid, atunci vânzătorul a fost agresiv (ofertă)
# Dacă prețul tranzacției = ask, atunci cumpărătorul a fost agresiv (cerere)
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" # În interiorul spread-ului, posibil dark pool
buy_volume = sum(t.size for t in ticks if get_taker_direction(t) == "buy")
sell_volume = sum(t.size for t in ticks if get_taker_direction(t) == "sell")
return buy_volume / (buy_volume + sell_volume) # % cumpărare

Arhitectura în Timp Real a Pipeline-ului

Prelucrarea Fluxului WebSocket

Conectează-te la WebSocket Bybit/Binance/Hyperliquid pentru date live:

Python — Manipulator flux live
import asyncio
import websockets
async def connect_bybit_ticks(symbol):
url = f"wss://stream.bybit.com/v5/public/spot"
async with websockets.connect(url) as ws:
# Abonează-te la fluxul de tranzacții
await ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{symbol}"]
}))
async for message in ws:
data = json.loads(message)
for trade în date["date"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

Procesare Distribuită cu Fluxuri Redis

Gestionează milioane de tick-uri pe zi cu coadă de mesaje:

Python — Procesare flux Redis
import redis
r = redis.Redis(host='localhost', port=6379)
# Producător: trimite tick-uri în flux
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
})
# Grupul de consumatori citește cu urmărire a întârzierii
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

Adaugă semnale în timp real la analizele tale

Smart Money API agregă date de tick de la 3 exchange-uri și peste 250 de portofele de balene. Folosește semnalele noastre precalculate de microstructură pentru a îmbunătăți propria analiză în timp real.

Începe Gratuit Astăzi →