Analiza danych wysokiej częstotliwości — Przetwarzanie danych rynkowych na poziomie ticków

Handel wysokiej częstotliwości w kryptowalutach działa w skali milisekund/mikrosekund. Przetwarzanie milionów ticków dziennie, obsługa nagłych przepływów danych i wyodrębnianie sygnałów mikrostruktury odróżnia profesjonalnych traderów od reszty. Ten przewodnik omawia zarządzanie danymi na poziomie ticków i analitykę w czasie rzeczywistym, które napędzają 5-minutowe cykle odświeżania Smart Money API.

Kluczowa obserwacja: Wieloryby nie poruszają rynków natychmiast. Ich blokowe transakcje pozostawiają wykrywalne ślady w postaci nierównowagi w książce zleceń, spreadów bid-ask i proporcji wolumenu takerów. Smart Money API wychwytuje te sygnały w czasie rzeczywistym.

Zbieranie i przechowywanie danych tickowych

Źródła danych

W przypadku kryptowalut dane tickowe pochodzą z:

Wydajne przechowywanie danych tickowych z Parquet

Przechowuj skompresowane dane kolumnowe dla szybkich zapytań:

Python — Potok danych tickowych
import pandas as pd
import pyarrow.parquet as pq
# Bufor ticków w czasie rzeczywistym (akumuluj przez 1h, następnie zapisz)
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" lub "sell"
})
# Co godzinę, skompresuj i zapisz
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 książki zleceń

Migawki książki zleceń Level 2

Przechwytuj pełną książkę zleceń co 100-500 ms:

Python — Przetwarzanie książki zleceń
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):
# Pobierz 10 najlepszych bidów i asków
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 = byczy (większa presja kupna)
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 # procentowy spread

Sygnały Mikrostruktury

Wyodrębnij sygnały do działania ze struktury księgi zleceń:

Metryki Mikrostruktury Rynku

Średnia Cena Ważona Wolumenem (VWAP)

Lepszy benchmark wykonania niż zwykła cena zamknięcia:

Python — obliczanie VWAP
def calculate_vwap(ticks):
# ticks: lista krotek (cena, wolumen)
numerator = sum(price * volume for price, volume in ticks)
denominator = sum(volume for _, volume in ticks)
return numerator / denominator

Wskaźnik Kupna/Sprzedaży Taker

Określ, która strona jest agresywna:

Python — analiza Taker
def get_taker_direction(tick):
# Jeśli cena transakcji = bid, to sprzedający był agresywny (podaż)
# Jeśli cena transakcji = ask, to kupujący był agresywny (popyt)
if abs(tick.price - best_bid) < tick.price_step:
return "sprzedaż"
elif abs(tick.price - best_ask) < tick.price_step:
return "kupno"
else:
return "mid" # Wewnątrz spreadu, prawdopodobnie dark pool
buy_volume = sum(t.size for t in ticks if get_taker_direction(t) == "kupno")
sell_volume = sum(t.size for t in ticks if get_taker_direction(t) == "sprzedaż")
return buy_volume / (buy_volume + sell_volume) # % kupna

Architektura Potoku w Czasie Rzeczywistym

Przetwarzanie Strumieni WebSocket

Połącz się z WebSocket Bybit/Binance/Hyperliquid dla danych na żywo:

Python — obsługa strumienia na żywo
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:
# Subskrybuj strumień transakcji
await ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{symbol}"]
}))
async for message in ws:
data = json.loads(message)
for trade w dane["data"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

Przetwarzanie rozproszone z wykorzystaniem Redis Streams

Obsługuj miliony ticków dziennie z kolejkowaniem wiadomości:

Python — przetwarzanie strumieni Redis
import redis
r = redis.Redis(host='localhost', port=6379)
# Producent: wysyłanie ticków do strumienia
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
})
# Grupa konsumentów śledząca opóźnienia
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

Dodaj sygnały w czasie rzeczywistym do swoich analiz

Smart Money API agreguje dane tickowe z 3 giełd i 250+ portfeli wielorybów. Wykorzystaj nasze wstępnie obliczone sygnały mikrostruktury, aby ulepszyć własną analizę w czasie rzeczywistym.

Rozpocznij za darmo już dziś →