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

Phần lớn tín hiệu lấy từ order book trên blog này là snapshot: hiện tại mỗi phía đang có bao nhiêu volume chờ khớp. Mất cân bằng dòng lệnh là một đối tượng khác. Nó phân rã luồng cập nhật giữa hai snapshot thành một đại lượng có dấu duy nhất — trong đó một lệnh hủy ở bid được tính giống như một market sell.

Phân rã đó là chủ đề của bài viết này. Cụ thể: các event indicator Cont-Kukanov-Stoikov (2014) định nghĩa nó, phần mở rộng đa mức Xu-Gould-Howison (2019) cùng phép rút gọn theo thành phần chính, và các quy tắc Lee-Ready và Bulk Volume Classification cần dùng khi feed không gắn nhãn hướng giao dịch.

Một lưu ý về cách nhìn ngay từ đầu, vì nó quyết định cách đọc mọi con số bên dưới. R-squared 50-65% nổi tiếng trong bài CKS là một hồi quy đồng thời: thay đổi giá trong một khoảng thời gian được hồi quy theo dòng lệnh trong chính khoảng đó. Đây là phân rã biến động giá, không phải dự báo. So sánh nó với 1-2% phương sai mà mô hình lợi nhuận cổ phiếu hằng ngày giải thích là so sánh khập khiễng, và blog này đã lập luận dài — trong DeepLOB và khoảng cách prediction-vs-profit cũng như kết quả phủ định trung thực — rằng việc trộn lẫn hai thứ khiến tutorial trở thành cái bẫy. Hồi quy OFI trễ nghiêm ngặt là một con số hợp lệ và nhỏ hơn nhiều. Bài này không báo cáo nó.

Vì sao là Order Flow, không phải Trades

Thay đổi giá trong limit order book liên tục xảy ra qua đúng bốn cơ chế: market buy tiêu thụ ask đang chờ; market sell tiêu thụ bid đang chờ; lệnh hủy ở bid loại bỏ hỗ trợ và khiến bid giảm; limit order mới ở ask tạo thêm kháng cự. Chỉ hai cơ chế đầu là trade. Hai cơ chế cuối vô hình với mọi thước đo dựa trên volume — VWAP, on-balance volume, signed trade flow — và ở hầu hết venue, tỷ lệ order-to-trade vượt 10:1, nên phần vô hình mới là phần lớn. Toàn bộ tuyên bố về tính hữu ích của OFI là nó định lượng cả bốn cơ chế trên cùng một scale. (Xem DeepLOB để hiểu book như một cấu trúc dữ liệu và vector feature snapshot chuẩn $4L$.)

Mô hình OFI Cont-Kukanov-Stoikov

Mô hình nền tảng đến từ bài báo năm 2014 của Cont, Kukanov và Stoikov, "The Price Impact of Order Book Events" (Journal of Financial Econometrics).

Định nghĩa Order Flow Imbalance

Consider the best bid price $P^b_t$, best ask price $P^a_t$, and their sizes $Q^b_t$ and $Q^a_t$. Between consecutive observations at $t_{n-1}$ and $t_n$:

trong đó đóng góp sự kiện phía mua và phía bán là:

Nói đơn giản: nếu giá bid tốt nhất tăng, đã xuất hiện lực mua mới — tính toàn bộ size của nó là dương. Nếu giá giảm, lực mua đã biến mất — trừ size cũ. Nếu giá không đổi, chỉ tính thay đổi về size. Phía ask là hình ảnh đối xứng.

Điểm tinh tế là ba nhánh indicator này bao phủ mọi chuyển tiếp có thể có ở top of book, nên mỗi update ánh xạ vào đúng một con số có dấu. Không cần phân loại trade, không cần side label, không cần feed cấp message — hai snapshot liên tiếp là đủ.

Aggregation theo Khoảng thời gian

For an interval $[T_1, T_2]$ containing $N$ book updates:

Mô hình Linear Price Impact

trong đó $\Delta P$ là thay đổi mid-price, $\beta$ là hệ số price impact, và $\varepsilon$ là nhiễu residual. Với cổ phiếu Mỹ trong các khoảng từ 10 giây đến 1 phút, CKS báo cáo contemporaneous $R^2$ 50-65% cho mỗi cổ phiếu. Nhắc lại: cùng khoảng thời gian, không phải forward-looking.

Cross-Sectional Scaling

CKS cũng chỉ ra rằng hệ số impact scale ngược với depth:

trong đó $\bar{D}$ là volume resting trung bình tại bid và ask tốt nhất. Cùng một flow đẩy giá đi xa hơn trong book mỏng. Đây là phần duy nhất của mô hình có thể chuyển giữa các venue mà không cần refit level, vì nó dự báo một mối quan hệ thay vì một con số — và có thể test trực tiếp trên các crypto pair có depth khác nhau.

Multi-Level Order Flow Imbalance (MLOFI)

Mô hình gốc chỉ dùng top of book. Xu, Gould và Howison (2019) đã mở rộng nó lên $L$ level.

Định nghĩa

trong đó $OFI_n^{(\ell)}$ áp dụng công thức ba nhánh tương tự cho cặp bid/ask thứ $\ell$.

Multi-Level Price Impact

Kết quả đã công bố trên cổ phiếu Nasdaq cho thấy mỗi level bổ sung làm tăng out-of-sample $R^2$ — khoảng 10-15 điểm phần trăm khi đi từ một lên năm level, và vẫn còn lợi ích biên ở level mười. Các hệ số giảm đơn điệu, $|\beta_1| > |\beta_2| > \cdots > |\beta_L|$: top of book chi phối, nhưng các level sâu hơn vẫn mang tín hiệu gia tăng đáng kể.

Liệu điều này có tồn tại trên crypto book hay không là câu hỏi mở thú vị nhất của bài viết. Crypto book mỏng hơn và churn ở depth nhiều hơn, hoàn toàn có thể các level 2-5 không bổ sung gì khi rời khỏi order book Nasdaq.

Principal Component Reduction

OFI ở các level liền kề tương quan cao (trên 0.8 trong kết quả cổ phiếu đã công bố), nên phân rã principal component là tự nhiên. Thành phần đầu tiên được báo cáo nắm hơn 89% tổng phương sai và hoạt động như một tín hiệu tổng hợp duy nhất:

với $\mathbf{w}$ là eigenvector dẫn đầu của covariance matrix OFI. Lợi ích thực tế là nó rút gọn hồi quy collinear thành một scalar được điều kiện tốt — vẫn đáng làm ngay cả khi tỷ lệ phương sai trên data của bạn thấp hơn.

Phân loại Trade: Buy so với Sell Initiated

Bản thân OFI không cần trade classification. Nhưng nếu muốn so sánh với các thước đo dựa trên trade, hoặc chỉ có aggregated bar, bạn cần suy ra hướng giao dịch.

Quote Rule

Compare the trade price $P_t$ to the prevailing midpoint $M_t = \frac{P^{ask}_t + P^{bid}_t}{2}$:

Một trade trên midpoint có khả năng là buyer lift offer; bên dưới là seller hit bid.

Lee-Ready algorithm (1991) là quote rule có tick-rule fallback cho trade đúng tại midpoint, nơi quote rule không xác định. Tick rule — dấu của thay đổi giá cuối cùng, giữ side trước đó khi tick bằng zero — đã được suy ra và triển khai trong Beyond time bars, có _tick_sign() hoạt động. Độ chính xác phân loại Lee-Ready được báo cáo là 72-85% tùy thị trường và giai đoạn.

Bulk Volume Classification (BVC)

Khi không thể gán từng trade — aggregated bar, phần lớn public candle API — Bulk Volume Classification của Easley, Lopez de Prado và O'Hara ước tính tỷ lệ buy trong volume của bar từ thay đổi giá đã chuẩn hóa:

với $\Phi$ là CDF chuẩn và $\sigma_{\Delta P}$ được ước tính từ thay đổi giá gần đây. Kém chính xác hơn phân loại ở cấp tick, nhưng hoạt động trên OHLCV.

OFI Không Phải Là Gì

Ba đại lượng lân cận thường bị nhầm với OFI. Mỗi đại lượng đã được trình bày đầy đủ ở nơi khác trên blog; điều quan trọng ở đây là sự khác biệt giữa chúng.

Static order book imbalance (OBI) là phiên bản snapshot — volume bid đang chờ so với volume ask đang chờ, không theo dõi sự kiện. Xem traditional LOB features của DeepLOB để biết công thức và dạng đa mức. Tương phản này là toàn bộ điểm của OFI: OBI cho biết trạng thái của book, OFI cho biết trạng thái đó hình thành như thế nào.

Trade imbalance (TI) và các biến thể volume-weighted của nó là signed trade flow, được định nghĩa và triển khai dưới dạng rolling feature trong spread modeling với machine learning. Một kết quả đã công bố về mối quan hệ này rất quan trọng: khi OFI và TI cùng được đưa làm regressor cho thay đổi mid-price, TI trở nên không có ý nghĩa thống kê. Nội dung của nó đã được bao hàm. Đây là cơ sở thực nghiệm để theo dõi sự kiện book thay vì trade — các sự kiện gần như trở thành trade mang cùng thông tin với những sự kiện đã trở thành trade.

Volume-weighted mid là estimator fair-value, không phải thước đo imbalance, và được trình bày trong DeepLOB — kèm lưu ý về tên gọi rằng nó không phải micro-price của Stoikov, vốn là estimator $M_t + g(I,S)$ đã điều chỉnh martingale, được xây dựng chính xác vì weighted mid ngây thơ bị bias.

Triển khai bằng Python

Triển khai trực tiếp phân rã CKS, được tổng quát hóa tới $L$ level.

Tính OFI Cốt lõi

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

Aggregation Thành Window

@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

Hãy chú ý aggregator phát ra gì: mlofi và delta_mid trên cùng một window. Đó là hồi quy đồng thời. Để có hồi quy dự báo, ghép mlofi của window $k$ với delta_mid của window $k+1$ và kỳ vọng một fit kém hơn đáng kể.

Phân loại Trade (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

Chuẩn hóa Tín hiệu

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}

OFI Được Kết nối Ở Đâu

Market making. OFI đi vào như một predictive skew term trên fair value, bổ sung cho inventory skew đã được suy ra và code trong Avellaneda-Stoikov market maker: $P^{fair} = P^{mid} + \gamma_{flow} \cdot OFI_{z} - \gamma_{inv} \cdot q$. Hai term trả lời các câu hỏi khác nhau — flow term cho biết giá sẽ đi đâu, inventory term cho biết bạn có thể nắm giữ gì — và bài viết đã công bố trình bày term thứ hai, bao gồm lý do inventory dương đẩy cả hai quote xuống. $|OFI_z|$ lớn cũng là trigger hợp lý cho adverse selection và các phản ứng phòng thủ (widen, shrink, pull một phía) được liệt kê trong dấu vết số của việc nhận dạng trader và phát hiện bất thường.

Execution. OFI là input cho fill-probability estimate $p$ của tactics layer, không phải urgency controller riêng. Quyết định post-versus-cross là phép tính break-even rõ ràng — $p^* = \delta/(\Pi + \delta)$ với $\Pi = s + f_t - f_m$ — nằm trong chiến thuật thực thi child order, bài viết cũng lập luận tactics layer không bao giờ nên tự suy ra urgency từ góc nhìn riêng về thị trường, vì điều đó tạo ra hai controller bất đồng.

Các Lưu ý Thực tế

Half-life của tín hiệu và rolling recalibration. Đây là phần riêng của OFI. Nội dung dự báo của OFI suy giảm trong thang thời gian từ mili giây đến giây ở các instrument thanh khoản, nghĩa là aggregation window không phải tham số miễn phí — đó là một đặt cược vào horizon. Và $\beta$ không phải hằng số: nó thay đổi trong ngày, theo depth và quanh các sự kiện đã lên lịch, vì vậy production fit phải ước tính lại trên rolling window thay vì cố định giá trị từ backtest.

Mọi thứ khác đã được trình bày ở nơi khác. Ngân sách latency và ladder co-location / FPGA / kernel-bypass: phần production của DeepLOB. Mẫu thanh khoản intraday hình chữ U và thống kê normalization trôi dạt: spread modeling. Recalibration theo venue và lý do model fit trên Nasdaq không thể chuyển nguyên trạng sang crypto pair: lại xem DeepLOB, còn phần fragmentation nằm trong smart order routing.

Thao túng. Một hệ quả riêng của model này cần nói thẳng: phân rã CKS weight mọi event chỉ theo size, không có khái niệm intent hay persistence. Vì vậy một spoofer đặt rồi hủy size sẽ trực tiếp bơm vào tín hiệu với full weight theo đúng thiết kế. Các heuristic phát hiện — cancel rate, lifetime của order, hành vi wall khi giá tiến gần — nằm trong phân tích queue position và wall của order book; thanh khoản ảo cross-venue nằm trong smart order routing.

Các Điểm Chính

1. OFI là phân rã sự kiện, không phải snapshot. Công thức indicator ba nhánh ánh xạ mọi chuyển tiếp top-of-book — giá tăng, giá giảm, thay đổi size — thành một số có dấu từ hai snapshot liên tiếp và không gì khác.

2. R-squared headline là đồng thời. Con số 50-65% của CKS phân rã chuyển động giá trong cùng interval; nó không phải forecast và không nên so sánh với model return forward-looking.

3. Multi-level OFI bổ sung level và PCA rút gọn chúng. Kết quả incremental-$R^2$ và 89%-variance đã công bố đến từ cổ phiếu Nasdaq. Depth có còn hữu ích trên crypto book hay không vẫn chưa được test ở đây.

4. OFI bao hàm trade imbalance. Khi đưa vào cùng nhau, TI trở nên không có ý nghĩa — chính các lệnh hủy mà OFI thấy còn TI không thấy tạo ra khác biệt.

5. Model không nhìn thấy intent. Weight ngang nhau theo size chính là điều khiến nó có thể bị spoof.

6. Không có gì trong bài này được đo. Mọi con số được trích đều đến từ literature về cổ phiếu. Trước khi tín hiệu này chạm vào vốn, cần fit trên book data của chính bạn, báo cáo riêng lagged specification, và kiểm tra edge có tồn tại sau fee và spread hay không.

Đọc thêm

• Cont, R., Kukanov, A., & Stoikov, S. (2014). "The Price Impact of Order Book Events." Journal of Financial Econometrics, 12(1), 47-88.
• Xu, K., Gould, M., & Howison, S. (2019). "Multi-Level Order-Flow Imbalance in a Limit Order Book." arXiv:1907.06230.
• Kolm, P., Turiel, J., & Westray, N. (2023). "Deep Order Flow Imbalance: Extracting Alpha at Multiple Horizons from the Limit Order Book." Mathematical Finance, 33(4).
• Lee, C., & Ready, M. (1991). "Inferring Trade Direction from Intraday Data." Journal of Finance, 46(2), 733-746.
• Easley, D., Lopez de Prado, M., & O'Hara, M. (2012). "Flow Toxicity and Liquidity in a High-Frequency World." Review of Financial Studies, 25(5), 1457-1493.