Order Flow Imbalance: The Cont-Kukanov-Stoikov Event Decomposition

De meeste uit boeken afkomstige signalen op deze blog zijn snapshots: hoeveel volume er momenteel aan elke kant rust. Een onevenwicht in de orderstroom is een ander probleem. Het is een ontleding van de stroom van updates tussen twee momentopnamen in één enkele ondertekende hoeveelheid – een hoeveelheid die een annulering van het bod telt op dezelfde manier als een marktverkoop.

Die ontleding is het onderwerp van dit artikel. Concreet: de gebeurtenisindicatoren van Cont-Kukanov-Stoikov (2014) die dit definiëren, de Xu-Gould-Howison (2019) uitbreiding op meerdere niveaus en de reductie ervan op hoofdcomponenten, en de Lee-Ready- en Bulk Volume Classification-regels die u nodig heeft als uw feed geen handelsrichting aangeeft.

Eén notitie vooraf, omdat deze bepaalt hoe je elk getal hieronder moet lezen. De beroemde 50-65% R-kwadraat uit het CKS-papier is een gelijktijdige regressie: prijsverandering over een interval regressief op basis van de orderstroom over hetzelfde interval. Het is een ontleding van prijsbewegingen, geen voorspelling ervan. Als we dit vergelijken met de variantie van 1-2% die volgens het dagelijkse rendementsmodel op aandelen appels met peren is, en deze blog heeft uitvoerig betoogd – in DeepLOB en de kloof tussen voorspelling en winst en in het eerlijke negatieve resultaat – dat het samenvoegen van deze twee de manier is waarop tutorials valkuilen worden. Een strikt vertraagde OFI-regressie is een legitiem en veel kleiner aantal. Dit artikel rapporteert er niet één.

Waarom orderstroom, geen transacties

Een prijsverandering in een continu limietorderboek vindt plaats via precies vier mechanismen: een marktaankoop verbruikt rustende vragen; een marktverkoop verbruikt rustende biedingen; een annulering van het bod neemt de steun weg en laat het bod dalen; een nieuwe limietorder op de ask zorgt voor weerstand. Alleen de eerste twee zijn transacties. De laatste twee zijn onzichtbaar voor elke op volume gebaseerde maatstaf – VWAP, volume op de balans, ondertekende handelsstroom – en op de meeste platforms is de order-to-trade-ratio groter dan 10:1, dus het onzichtbare deel is het grootste deel. OFI's claim op bruikbaarheid is dat het alle vier de mechanismen op dezelfde schaal prijst. (Voor het boek als datastructuur en de standaard $4L$ snapshot-functievector, zie DeepLOB.)

Het Cont-Kukanov-Stoikov OFI-model

Het fundamentele model komt uit het artikel van Cont, Kukanov en Stoikov uit 2014, "The Price Impact of Order Book Events" (Journal of Financial Econometrics).

Onevenwicht in de orderstroom definiëren

Denk aan de beste biedprijs $P^b_t$, de beste vraagprijs $P^a_t$ en hun maten $Q^b_t$ en $Q^a_t$. Tussen opeenvolgende waarnemingen bij $t_{n-1}$ en $t_n$:

waarbij de buy-side en sell-side evenementbijdragen zijn:

In gewone taal: als de beste biedprijs stijgt, ontstaat er interesse voor nieuwe koop – tel de volledige omvang ervan als positief. Als het daalt, verdwijnt de kooprente – trek de oude maat af. Als de prijs ongewijzigd blijft, telt u alleen de maatverandering. De vraagkant is het spiegelbeeld.

Het mooie is dat deze drie indicatortakken elke mogelijke overgang van de bovenkant van het boek bestrijken, zodat elke update op precies één ondertekend nummer betrekking heeft. Geen handelsclassificatie, geen zijlabels, geen feed op berichtniveau vereist: twee opeenvolgende snapshots zijn voldoende.

Aggregatie over intervallen

Voor een interval $[T_1, T_2]$ met $N$ boekupdates:

Het lineaire prijsimpactmodel

waarbij $\Delta P$ de verandering in de middenprijs is, $\beta$ de prijsimpactcoëfficiënt is en $\varepsilon$ het restgeluid is. Voor Amerikaanse aandelen met intervallen van 10 seconden tot 1 minuut rapporteert CKS een gelijktijdige $R^2$ van 50-65% per aandeel. Nogmaals: hetzelfde interval, niet toekomstgericht.

Cross-sectionele schaling

CKS toonde ook de schalen van de impactcoëfficiënt omgekeerd aan de diepte:

waarbij $\bar{D}$ het gemiddelde rustvolume is bij de beste bied- en laatprijs. Dezelfde stroom duwt de prijs verder in een dun boekje. Dit is het enige deel van het model dat over verschillende locaties wordt overgedragen zonder het niveau opnieuw aan te passen, omdat het een relatie voorspelt in plaats van een getal – en het is direct testbaar op cryptoparen met verschillende diepte.

Onevenwicht in de orderstroom op meerdere niveaus (MLOFI)

Het originele model gebruikt alleen de bovenkant van het boek. Xu, Gould en Howison (2019) hebben het uitgebreid naar $L$-niveaus.

Definitie

waarbij $OFI_n^{(\ell)}$ de identieke formule met drie takken toepast op het $\ell$-de bied/laat-paar.

Prijsimpact op meerdere niveaus

De gepubliceerde bevinding met betrekking tot Nasdaq-aandelen is dat elk extra niveau $R^2$ buiten de steekproef toevoegt – grofweg 10-15 procentpunten van één niveau naar vijf, met een marginale winst van tien. De coëfficiënten vervallen monotoon, $|\beta_1| > |\beta_2| > \cdots > |\beta_L|$: de bovenkant van het boek domineert, maar diepere niveaus dragen een niet-triviaal incrementeel signaal.

Of dit ook in een cryptoboek overleeft, is de meest interessante open vraag in dit artikel. Cryptoboeken zijn dunner en dieper gekarnd, en het is volkomen aannemelijk dat niveaus 2-5 niets toevoegen als je eenmaal een Nasdaq-orderboek hebt verlaten.

Reductie hoofdcomponent

OFI's op aangrenzend niveau zijn sterk gecorreleerd (meer dan 0,8 in de gepubliceerde aandelenresultaten), dus een ontleding van de hoofdcomponenten ligt voor de hand. De gerapporteerde eerste component vangt meer dan 89% van de totale variantie op en dient als één enkel aggregaat signaal:

met $\mathbf{w}$ de leidende eigenvector van de OFI-covariantiematrix. De praktische aantrekkingskracht is dat het een collineaire regressie samenvoegt tot één goed geconditioneerde scalair – de moeite waard om te doen, zelfs als het variantieaandeel op uw gegevens lager uitvalt.

Transacties classificeren: kopen versus verkopen gestart

OFI zelf heeft geen handelsclassificatie nodig. Maar als je het wilt vergelijken met op handel gebaseerde maatstaven, of als je alleen maar geaggregeerde staven hebt, moet je de richting ervan afleiden.

Citaatregel

Vergelijk de handelsprijs $P_t$ met het heersende middelpunt $M_t = \frac{P^{ask}_t + P^{bid}_t}{2}$:

Een transactie boven het middelpunt was waarschijnlijk een koper die het bod introk; daaronder een verkoper die het bod haalt.

Het Lee-Ready-algoritme (1991) is de quote-regel met een tick-rule fallback voor transacties precies in het midden, waar de quote-regel onbepaald is. De tick-regel – het teken van de laatste prijsverandering, waarbij de vorige kant naar voren wordt gebracht op een nul-tic – is al afgeleid en geïmplementeerd in Beyond time bars, dat een werkende _tick_sign() levert. De gerapporteerde nauwkeurigheid van de Lee-Ready-classificatie is 72-85%, afhankelijk van de markt en de periode.

Bulkvolumeclassificatie (BVC)

Wanneer individuele transacties niet kunnen worden toegewezen (geaggregeerde staven, de meeste openbare kaars-API's) schat Easley, Lopez de Prado en O'Hara's Bulk Volume Classification de koopfractie van het volume van een staaf op basis van de genormaliseerde prijsverandering:

met $\Phi$ de standaard normale CDF en $\sigma_{\Delta P}$ geschat op basis van recente prijswijzigingen. Minder nauwkeurig dan classificatie op tick-niveau, maar het werkt op OHLCV.

Wat OFI niet is

Drie aangrenzende grootheden worden verward met OFI. Ze worden allemaal elders op deze blog uitgebreid behandeld; het gaat hier om de verschillen.

Statische onbalans in het orderboek (OBI) is de momentopnameversie: rustbodvolume versus rustvraagvolume, geen tracking van gebeurtenissen. Zie DeepLOB's traditionele LOB-functies voor de formule en de vorm met meerdere niveaus. Het contrast is het hele punt van OFI: OBI vertelt je de staat van het boek, OFI vertelt je hoe het daar terecht is gekomen.

Handelsonbalans (TI) en de volumegewogen varianten ervan zijn ondertekende handelsstromen, gedefinieerd en geïmplementeerd als voortschrijdende functies in spread-modellering met machine learning. Eén gepubliceerd resultaat over de relatie is hier overtuigend: wanneer OFI en TI samen worden ingevoerd als regressoren voor veranderingen in het midden van de prijs, wordt TI statistisch insignificant. De inhoud ervan is ondergebracht. Dat is het empirische argument voor het volgen van boekgebeurtenissen in plaats van transacties: de gebeurtenissen die bijna transacties werden, bevatten dezelfde informatie als de gebeurtenissen die dat wel deden.

Het naar volume gewogen midden is een reële-waardeschatter, geen maatstaf voor onevenwichtigheid, en wordt behandeld in DeepLOB – inclusief het voorbehoud bij de naamgeving dat het niet de microprijs van Stoikov is, wat een voor martingaal gecorrigeerde $M_t + g(I,S)$-schatter is, die juist is gebouwd omdat het naïeve gewogen midden bevooroordeeld is.

Python-implementatie

Een directe implementatie van de CKS-decompositie, gegeneraliseerd naar $L$-niveaus.

Kern OFI-berekening

import numpy as np
import pandas as pd
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class OrderBookSnapshot:
    timestamp: float
    bid_prices: np.ndarray   # best bid at index 0, descending
    ask_prices: np.ndarray   # best ask at index 0, ascending
    bid_sizes: np.ndarray
    ask_sizes: np.ndarray

@dataclass
class OFICalculator:
    """
    Computes Order Flow Imbalance from consecutive order book snapshots.
    Supports multi-level OFI (MLOFI) up to `n_levels` deep.
    """
    n_levels: int = 5
    prev_snapshot: Optional[OrderBookSnapshot] = field(default=None, init=False)

    def compute_level_ofi(
        self,
        prev_price: float, curr_price: float,
        prev_size: float, curr_size: float,
        side: str
    ) -> float:
        """Compute single-level OFI contribution for bid or ask side."""
        if side == "bid":
            if curr_price > prev_price:
                return curr_size              # new level appeared above
            elif curr_price < prev_price:
                return -prev_size             # old level disappeared
            else:
                return curr_size - prev_size  # same level, size changed
        else:  # ask side
            if curr_price < prev_price:
                return curr_size              # new level appeared below
            elif curr_price > prev_price:
                return -prev_size             # old level disappeared
            else:
                return curr_size - prev_size  # same level, size changed

    def update(self, snapshot: OrderBookSnapshot) -> Optional[np.ndarray]:
        """
        Process new snapshot, return MLOFI vector of shape (n_levels,).
        Returns None on first call (no previous snapshot to compare).
        """
        if self.prev_snapshot is None:
            self.prev_snapshot = snapshot
            return None

        prev = self.prev_snapshot
        n = min(self.n_levels, len(snapshot.bid_prices), len(prev.bid_prices))
        ofi = np.zeros(n)

        for level in range(n):
            e_buy = self.compute_level_ofi(
                prev.bid_prices[level], snapshot.bid_prices[level],
                prev.bid_sizes[level], snapshot.bid_sizes[level],
                side="bid"
            )
            e_sell = self.compute_level_ofi(
                prev.ask_prices[level], snapshot.ask_prices[level],
                prev.ask_sizes[level], snapshot.ask_sizes[level],
                side="ask"
            )
            ofi[level] = e_buy - e_sell

        self.prev_snapshot = snapshot
        return ofi

Aggregatie naar Windows

@dataclass
class OFIAggregator:
    """
    Aggregates raw OFI updates into fixed time windows.
    Emits the regression inputs (aggregated MLOFI) and target (delta mid).
    """
    window_seconds: float = 10.0
    n_levels: int = 5
    calculator: OFICalculator = field(init=False)
    buffer: list = field(default_factory=list, init=False)
    window_start: float = 0.0

    def __post_init__(self):
        self.calculator = OFICalculator(n_levels=self.n_levels)

    def on_snapshot(self, snapshot: OrderBookSnapshot) -> Optional[dict]:
        """
        Feed a new order book snapshot.
        Returns aggregated window dict when a window completes, else None.
        """
        ofi_vec = self.calculator.update(snapshot)
        if ofi_vec is None:
            self.window_start = snapshot.timestamp
            return None

        if not self.buffer:
            self.window_start = snapshot.timestamp

        self.buffer.append({
            "timestamp": snapshot.timestamp,
            "ofi": ofi_vec.copy(),
            "mid": (snapshot.bid_prices[0] + snapshot.ask_prices[0]) / 2,
        })

        elapsed = snapshot.timestamp - self.window_start
        if elapsed >= self.window_seconds:
            return self._flush()
        return None

    def _flush(self) -> dict:
        """Aggregate buffered OFI updates into a single window record."""
        ofi_matrix = np.array([b["ofi"] for b in self.buffer])
        agg_ofi = ofi_matrix.sum(axis=0)  # shape: (n_levels,)

        result = {
            "window_start": self.window_start,
            "window_end": self.buffer[-1]["timestamp"],
            "n_updates": len(self.buffer),
            "mid_open": self.buffer[0]["mid"],
            "mid_close": self.buffer[-1]["mid"],
            "delta_mid": self.buffer[-1]["mid"] - self.buffer[0]["mid"],
            "ofi_level1": agg_ofi[0],
            "ofi_total": agg_ofi.sum(),
            "mlofi": agg_ofi,
        }

        self.buffer.clear()
        return result

Merk op wat de aggregator uitzendt: mlofi en delta_mid in hetzelfde venster. Dat is de gelijktijdige regressie. Om een ​​voorspellende waarde te krijgen, koppelt u de mlofi van venster $k$ aan de delta_mid van venster $k+1$ en verwacht u een aanzienlijk slechtere fit.

Handelsclassificatie (Lee-Ready)

def classify_trades_lee_ready(
    trades: pd.DataFrame,
    quotes: pd.DataFrame
) -> pd.DataFrame:
    """
    Classify trades as buy (+1) or sell (-1) using Lee-Ready:
    quote rule first, tick rule as fallback at the midpoint.

    Parameters
    ----------
    trades : DataFrame with columns ['timestamp', 'price', 'size']
    quotes : DataFrame with columns ['timestamp', 'bid', 'ask']

    Returns
    -------
    trades with added 'side' column
    """
    trades = trades.sort_values("timestamp").copy()
    quotes = quotes.sort_values("timestamp")

    trades = pd.merge_asof(
        trades, quotes,
        on="timestamp",
        direction="backward"
    )

    trades["mid"] = (trades["bid"] + trades["ask"]) / 2

    trades["side"] = np.where(
        trades["price"] > trades["mid"], 1,
        np.where(trades["price"] < trades["mid"], -1, 0)
    )

    trades["price_diff"] = trades["price"].diff()
    tick_sign = np.sign(trades["price_diff"])
    tick_sign = tick_sign.replace(0, np.nan).ffill().fillna(1)

    midpoint_mask = trades["side"] == 0
    trades.loc[midpoint_mask, "side"] = tick_sign[midpoint_mask].astype(int)

    return trades

Het signaal normaliseren

class OFISignal:
    """
    Rolling z-score normalization of aggregated OFI.

    Deliberately does NOT convert OFI into a predicted return: that
    requires a fitted beta, and beta is venue-, pair- and regime-specific.
    Fit it on your own data before wiring this into anything.
    """
    def __init__(self, window_seconds: float = 10.0, n_levels: int = 5,
                 lookback: int = 100):
        self.aggregator = OFIAggregator(
            window_seconds=window_seconds, n_levels=n_levels,
        )
        self.lookback = lookback
        self.ofi_history: list[float] = []

    def process(self, snapshot: OrderBookSnapshot) -> Optional[dict]:
        agg = self.aggregator.on_snapshot(snapshot)
        if agg is None:
            return None

        ofi = agg["ofi_level1"]
        self.ofi_history.append(ofi)
        if len(self.ofi_history) > self.lookback:
            self.ofi_history.pop(0)

        if len(self.ofi_history) >= 20:
            arr = np.array(self.ofi_history)
            mu, sigma = arr.mean(), arr.std()
            zscore = (ofi - mu) / max(sigma, 1e-10)
        else:
            zscore = 0.0

        return {**agg, "ofi_zscore": zscore}

Waar OFI aansluit

Marktmaking. OFI wordt ingevoerd als een voorspellende scheefheidsterm voor de reële waarde, bovenop de voorraadscheefheid die al is afgeleid en gecodeerd in de marktmaker van Avellaneda-Stoikov: $P^{fair} = P^{mid} + \gamma_{flow} \cdot OFI_{z} - \gamma_{inv} \cdot q$. De twee termen beantwoorden verschillende vragen – de flowterm geeft aan waar de prijs naartoe gaat, de voorraadterm zegt wat u zich kunt veroorloven om aan te houden – en het gepubliceerde artikel behandelt de tweede, inclusief waarom positieve voorraad beide koersen naar beneden duwt. Een grote $|OFI_z|$ is ook een redelijke trigger voor negatieve selectie voor de defensieve reacties (verruimen, krimpen, aan één kant trekken) die zijn gecatalogiseerd in [digitale vingerafdrukken van handelaarsidentificatie] (/en/blog/post/digital-fingerprint-trader-identification) en [anomaliedetectie] (/en/blog/post/anomaly-detection-algotrading).

Uitvoering. OFI is een invoer voor de schatting van de waarschijnlijkheid van de tactieklaag $p$, en niet een afzonderlijke urgentiecontroller. De post-versus-cross-beslissing is een expliciete break-even-rekenkunde – $p^* = \delta/(\Pi + \delta)$ met $\Pi = s + f_t - f_m$ – en leeft in [tactieken voor de uitvoering van onderliggende orders] (/en/blog/post/child-order-execution-tactics), die ook stelt dat de tactieklaag nooit de urgentie mag herleiden uit zijn eigen kijk op de markt, omdat dat twee controleurs creëert die het er niet mee eens zijn.

Praktische overwegingen

Signaalhalfwaardetijd en rollende herkalibratie. Dit is het OFI-specifieke onderdeel. De voorspellende inhoud van OFI vervalt op een tijdschaal van milliseconden tot seconden in vloeibare instrumenten, wat betekent dat het aggregatievenster geen vrije parameter is – het is een gok op de horizon. En $\beta$ is geen constante: het beweegt zich binnen de dag, met diepte en rond geplande gebeurtenissen, dus elke productiefit schat het opnieuw in op basis van rollende vensters in plaats van een waarde vast te leggen uit een backtest.

Al het andere hier wordt elders behandeld. Latencybudgetten en de co-locatie / FPGA / kernel-bypass-ladder: [DeepLOB's productiesectie] (/en/blog/post/deeplob-deep-learning-order-book). Het U-vormige intraday-liquiditeitspatroon en afwijkende normalisatiestatistieken: spreadmodellering. Herkalibratie per locatie en waarom een ​​model dat op Nasdaq is gemonteerd niet onaangeroerd naar een cryptopaar zal worden overgedragen: [DeepLOB] (/en/blog/post/deeplob-deep-learning-order-book) opnieuw, met de fragmentatiekant in [smart order routing] (/en/blog/post/smart-order-routing-crypto).

Manipulatie. Eén consequentie is specifiek voor dit model en de moeite waard om duidelijk te vermelden: de CKS-decompositie weegt elke gebeurtenis alleen op basis van de grootte, zonder enig idee van intentie of doorzettingsvermogen. De plaatsings- en annuleringsgrootte van een spoofer injecteert daarom door de constructie rechtstreeks in het signaal, op volle sterkte. Detectieheuristieken – annuleringspercentages, orderlevensduur, muurgedrag naarmate de prijs nadert – bevinden zich in [wachtrijpositie en orderboekmuuranalyse] (/en/blog/post/queue-position-order-book-wall-analysis); fantoomliquiditeit tussen locaties bevindt zich in [slimme orderrouting] (/en/blog/post/smart-order-routing-crypto).

Belangrijkste afhaalrestaurants

1. OFI is een ontleding van gebeurtenissen, geen momentopname. De indicatorformule met drie takken brengt elke overgang naar de top van het boek (prijs omhoog, prijs omlaag, verandering van grootte) in kaart naar één getal met teken, van twee opeenvolgende momentopnamen en niets anders.

2. De kop R-kwadraat is gelijktijdig. Het CKS-cijfer van 50-65% ontleedt prijsbewegingen met hetzelfde interval; het is geen voorspelling en mag niet worden vergeleken met toekomstgerichte rendementsmodellen.

3. Multi-level OFI voegt niveaus toe en PCA vouwt ze samen. De gepubliceerde resultaten met incrementele $R^2$ en 89% variantie zijn afkomstig van Nasdaq-aandelen. Of diepte nog steeds helpt bij een cryptoboek is hier niet getest.

4. OFI omvat handelsonevenwichtigheden. Gezamenlijk ingevoerd, wordt TI onbeduidend – de annuleringen die OFI ziet en die TI niet kan zijn, zijn wat het verschil maakt.

5. Het model is blind voor bedoelingen. Gelijke weging op grootte is precies wat het spoofbaar maakt.

6. Niets in dit artikel is gemeten. Elk genoemd getal komt uit de aandelenliteratuur. Voordat dit signaal het kapitaal raakt, moet het worden aangepast aan uw eigen boekgegevens, een vertraagde specificatie die afzonderlijk wordt gerapporteerd en een controle of de voorsprong de vergoedingen en de spread overleeft.

Verder lezen

• Cont, R., Kukanov, A., en Stoikov, S. (2014). "De prijsimpact van orderboekgebeurtenissen." Journal of Financial Econometrics, 12(1), 47-88.
• Xu, K., Gould, M., & Howison, S. (2019). "Order-flow-onevenwichtigheid op meerdere niveaus in een limietorderboek." arXiv:1907.06230.
• Kolm, P., Turiel, J., en Westray, N. (2023). "Diepe orderstroomonbalans: alfa op meerdere horizonten uit het limietorderboek halen." Wiskundige financiën, 33(4).
• Lee, C., en Klaar, M. (1991). "Handelsrichting afleiden uit intraday-gegevens." Journal of Finance, 46(2), 733-746.
• Easley, D., Lopez de Prado, M., & O'Hara, M. (2012). "Stroomtoxiciteit en liquiditeit in een hoogfrequente wereld." Overzicht van financiële studies, 25(5), 1457-1493.