Analyse de données haute fréquence — Traitement des données de marché au niveau du tick

Le trading haute fréquence en crypto opère à des échelles de temps en millisecondes/microsecondes. Traiter des millions de ticks par jour, gérer des flux de données irréguliers et extraire des signaux de microstructure distingue les traders professionnels des autres. Ce guide explique la gestion des données au niveau du tick et l'analyse en temps réel qui alimentent les cycles de rafraîchissement de 5 minutes de Smart Money API.

Idée clé : Les baleines ne font pas bouger les marchés instantanément. Leurs blocs de transactions créent des signatures détectables dans le déséquilibre du carnet d'ordres, les écarts acheteur-vendeur et les ratios de volume taker. Smart Money API capture ces signatures en temps réel.

Collecte et stockage des données de ticks

Sources de données

Pour les cryptos, les données de ticks proviennent de :

Stockage efficace des ticks avec Parquet

Stockez des données colonnaires compressées pour des requêtes rapides :

Python — Pipeline de données de ticks
import pandas as pd
import pyarrow.parquet as pq
# Tampon de ticks en temps réel (accumule pendant 1h, puis sauvegarde)
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" ou "sell"
})
# Toutes les heures, compresser et sauvegarder
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 = []

Analyse du carnet d'ordres

Instantanés du carnet d'ordres niveau 2

Capturez l'intégralité du carnet d'ordres toutes les 100-500 ms :

Python — Traitement du carnet d'ordres
class OrderBook:
def __init__(self):
self.bids = {} # prix -> taille
self.asks = {} # prix -> taille
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):
# Obtenez les 10 meilleures offres et demandes
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)
# Déséquilibre : >1 = haussier (plus de pression d'achat)
retour bid_volume / ask_volume si ask_volume > 0 sinon 1.0
def get_spread(self):
best_bid = max(self.bids.keys())
best_ask = min(self.asks.keys())
retour (best_ask - best_bid) / best_bid # écart en pourcentage

Signaux de microstructure

Extrayez des signaux exploitables de la structure du carnet d'ordres :

Métriques de microstructure de marché

Prix moyen pondéré par le volume (VWAP)

Un meilleur indicateur d'exécution que le simple prix de clôture :

Python — Calcul du VWAP
def calculate_vwap(ticks):
# ticks : liste de tuples (prix, volume)
numerator = sum(price * volume pour price, volume dans ticks)
denominator = sum(volume pour _, volume dans ticks)
retour numerator / denominator

Ratio Acheteur/Vendeur Taker

Identifiez quel côté est agressif :

Python — Analyse Taker
def get_taker_direction(tick):
# Si le prix du trade = bid, alors le vendeur était agressif (offre)
# Si le prix du trade = ask, alors l'acheteur était agressif (demande)
si abs(tick.price - best_bid) < tick.price_step:
retour "sell"
elif abs(tick.price - best_ask) < tick.price_step:
retour "buy"
sinon:
retour "mid" # À l'intérieur de l'écart, peut-être dark pool
buy_volume = sum(t.size pour t dans ticks si get_taker_direction(t) == "buy")
sell_volume = sum(t.size pour t dans ticks si get_taker_direction(t) == "sell")
retour buy_volume / (buy_volume + sell_volume) # % achat

Architecture de pipeline en temps réel

Traitement de flux WebSocket

Connectez-vous à Bybit/Binance/Hyperliquid WebSocket pour des données en direct :

Python — Gestionnaire de flux en direct
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:
# Abonnez-vous au flux de trades
await ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{symbol}"]
}))
async pour message dans ws:
data = json.loads(message)
pour trade dans données["data"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

Traitement distribué avec Redis Streams

Gérez des millions de ticks par jour avec une file de messages :

Python — Traitement de flux Redis
import redis
r = redis.Redis(host='localhost', port=6379)
# Producteur : envoie les ticks dans le 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
})
# Groupe de consommateurs avec suivi du retard
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

Ajoutez des signaux en temps réel à vos analyses

Smart Money API agrège les données de ticks de 3 exchanges et de plus de 250 portefeuilles de baleines. Utilisez nos signaux de microstructure précalculés pour enrichir votre propre analyse en temps réel.

Commencez gratuitement aujourd'hui →