Microstructural Features

This chapter explores how to derive predictive features from market microstructure data (like FIX messages). This data reveals how participants trade, which often exposes informational asymmetries that ML algorithms can exploit. The literature is divided into three generations of models.

First Generation: Price Sequences

These models use only price information to infer market properties like liquidity.

• The Tick Rule: A simple algorithm to infer the aggressor side (buy or sell) of a trade. A buy is 1, a sell is -1.
  $$b_{t}= \begin{cases}1 & \text { if } \Delta p_{t}>0 \\ -1 & \text { if } \Delta p_{t}<0 \\ b_{t-1} & \text { if } \Delta p_{t}=0\end{cases}$$
• The Roll Model: Estimates the effective bid-ask spread ($c$) from the serial covariance of price changes. This is useful for illiquid assets without a visible order book.
  $$\sigma\left(\Delta p_{t}, \Delta p_{t-1}\right)=-c^{2} \quad \implies \quad c=\sqrt{\max \left\{0,-\sigma\left(\Delta p_{t}, \Delta p_{t-1}\right)\right\}}$$
• Corwin and Schultz Estimator: Estimates the spread ($S_t$) using only daily (or bar) high and low prices, based on the principle that H/L ratios capture both volatility and the spread.
  • The spread is estimated as:
    $$S_{t}=\frac{2\left(e^{\alpha_{t}}-1\right)}{1+e^{\alpha_{t}}}$$
  • Where $\alpha_t$ is derived from $\beta_t$ (a 2-bar average of squared log H/L ratios) and $\gamma_t$ (the squared log H/L ratio over the 2-bar period).
    $$\alpha_{t}=\frac{\sqrt{2 \beta_{t}}-\sqrt{\beta_{t}}}{3-2 \sqrt{2}}-\sqrt{\frac{\gamma_{t}}{3-2 \sqrt{2}}}$$

Implementation RiskLabAI

In our RiskLabAI library, we provide a direct implementation of this estimator in the features.microstructural_features.corwin_schultz module. The code is modular, with each function corresponding to a component of the formula.

The core logic is broken into:

• beta_estimates: Calculates $\beta_t$, the two-day sum of squared log H/L ratios, averaged over a window_span.
• gamma_estimates: Calculates $\gamma_t$, the squared log-ratio of the two-day high and low.
• alpha_estimates: Uses $\beta_t$ and $\gamma_t$ to solve for $\alpha_t$.

The main function, corwin_schultz_estimator, orchestrates these steps to return the final spread $S_t$.

Bekker-Parkinson Volatility Estimator

As an extension, we also implement the Bekker-Parkinson volatility estimator, which adjusts the standard Parkinson volatility by incorporating the Corwin-Schultz spread components.

Methodology

The estimator is calculated as:

Where $\beta$ and $\gamma$ are the same components calculated for the Corwin-Schultz estimator.

Implementation

In our RiskLabAI library, we implement this in the features.microstructural_features.bekker_parkinson_volatility_estimator module.

The main function bekker_parkinson_volatility_estimates is a convenience wrapper that first computes $\beta$ and $\gamma$ (by calling beta_estimates and gamma_estimates from the corwin_schultz module) and then passes them to the sigma_estimates function, which contains the core logic for the $\sigma$ formula.

Second Generation: Strategic Trade Models

These models incorporate volume to measure illiquidity and price impact, modeling trade as a strategic interaction.

• Kyle's Lambda ($\lambda$): Models price impact as the result of a game between an informed trader and a market maker. $\lambda$ is an inverse measure of liquidity. It can be estimated via a simple regression:

  $$\Delta p_{t}=\lambda\left(b_{t} V_{t}\right)+\varepsilon_{t}$$

  where $b_t V_t$ is the signed volume.

• Amihud's Lambda ($\lambda$): Measures illiquidity as the absolute price response per dollar of trading volume.

  $$\left|\Delta \log \left(\tilde{p}_{\tau}\right)\right| = \lambda \sum_{t \in B_{\tau}}\left(p_{t} V_{t}\right)+\varepsilon_{\tau}$$

• Hasbrouck's Lambda ($\lambda$): A Bayesian model that estimates price impact using the square-root of dollar volume, which is often found to be a more accurate specification.

  $$\log \left(\tilde{p}_{i, \tau}\right)-\log \left(\tilde{p}_{i, \tau-1}\right)=\lambda_{i} \sum_{t \in B_{i, \tau}}\left(b_{i, t} \sqrt{p_{i, t} V_{i, t}}\right)+\varepsilon_{i, \tau}$$

Third Generation: Sequential Trade Models

These models focus on asymmetric information and the strategic, sequential nature of trading.

• PIN (Probability of Informed Trading): A foundational model where the bid-ask spread is the premium a market maker charges for the risk of being adversely selected. The probability of informed trading is a function of:
  • $\alpha$: Probability of a new information event.
  • $\mu$: Arrival rate of informed traders.
  • $\varepsilon$: Arrival rate of uninformed (noise) traders.
  $$P I N_{t}=\frac{\alpha_{t} \mu}{\alpha_{t} \mu+2 \varepsilon}$$
• VPIN (Volume-Synchronized PIN): A high-frequency, practical estimate of PIN that uses volume bars.
  • Key Insight: In a volume bar of size $V$, the total volume is $V = \alpha\mu + 2\varepsilon$ and the expected imbalance is $\mathrm{E}(|V_{\tau}^{B}-V_{\tau}^{S}|) \approx \alpha \mu$.
  • VPIN Equation: The fraction of volume that is from informed traders is the ratio of imbalance to total volume.
    $$V P I N_{\tau}=\frac{\sum_{\tau=1}^{n}\left|V_{\tau}^{B}-V_{\tau}^{S}\right|}{n V}$$

Additional Microstructural Features

• Order Size Distribution: Round numbers (e.g., 10, 50, 100 contracts) indicate human "GUI traders," while randomized sizes indicate "silicon traders" (algorithms). A shift in this distribution can be predictive.
• Cancellations & Order Types: High cancellation rates or specific patterns can reveal predatory algorithms (quote stuffers, squeezers, pack hunters).
• TWAP Algorithm Footprints: Institutional (TWAP) algorithms often execute at regular time intervals, creating detectable volume spikes (e.g., at the beginning of every minute).
• Serial Correlation of Signed Order Flow: High persistence in order flow (e.g., many buy orders in a row) is attributed to informed traders splitting large orders.

Author's Definition: What is Microstructural Information?

The chapter proposes a novel definition of information, not as "news," but as a measure of market maker predictability.

• Concept: "Information" is high when market makers' models are failing. This failure is measured by the cross-entropy loss ($L_{\tau}$) of the market maker's own classifier.
• Feature: The "microstructural information" feature $\phi_{\tau}$ is the Cumulative Distribution Function (CDF) of this loss.
  $$\phi_{\tau}=F\left(-L_{\tau}\right)$$
• Interpretation: When $\phi_{\tau}$ is high, the market maker's model is experiencing high losses, signaling the presence of informed traders and a high probability of adverse selection. This was evident during the 2010 Flash Crash.

API reference

RiskLabAI implements these in Python and Julia (signatures auto-generated from the package source):

def beta_estimates(
    high_prices: pd.Series, low_prices: pd.Series, window_span: int
) -> pd.Series:

function beta_estimates(
    high_prices::AbstractVector{<:Real},
    low_prices::AbstractVector{<:Real},
    window_span::Integer,
)

def gamma_estimates(high_prices: pd.Series, low_prices: pd.Series) -> pd.Series:

function gamma_estimates(
    high_prices::AbstractVector{<:Real},
    low_prices::AbstractVector{<:Real},
)

def alpha_estimates(beta: pd.Series, gamma: pd.Series) -> pd.Series:

function alpha_estimates(beta::AbstractVector{<:Real}, gamma::AbstractVector{<:Real})

def corwin_schultz_estimator(
    high_prices: pd.Series, low_prices: pd.Series, window_span: int = 20
) -> pd.Series:

function corwin_schultz_estimator(
    high_prices::AbstractVector{<:Real},
    low_prices::AbstractVector{<:Real},
    window_span::Integer = 20,
)

def sigma_estimates(beta: pd.Series, gamma: pd.Series) -> pd.Series:

function sigma_estimates(beta::AbstractVector{<:Real}, gamma::AbstractVector{<:Real})

def bekker_parkinson_volatility_estimates(
    high_prices: pd.Series, low_prices: pd.Series, window_span: int = 20
) -> pd.Series:

function bekker_parkinson_volatility_estimates(
    high_prices::AbstractVector{<:Real},
    low_prices::AbstractVector{<:Real},
    window_span::Integer = 20,
)

Full source: Python · Julia