Volatility Forecasting in HFT: GARCH and HAR-RV Algorithmic Models

1. Introduction: Volatility Analytics in Algorithmic Trading

In quantitative finance, accurate volatility forecasting is the foundation for successful risk management, options pricing, and capital allocation. Professional algorithmic trading utilizes volatility forecasting models not to predict absolute price direction, but to estimate the width of price distributions and scale position sizes dynamically.

Quantitative analysis of volatility faces unique challenges in high-frequency trading (HFT) environments, where standard daily estimators are too slow. In this paper, we explore two fundamental classes of models: the classical GARCH model (conditional heteroskedasticity over discrete intervals) and the high-frequency HAR-RV model (cascade of realized variance across different time horizons).

2. Volatility Modeling Methodologies: GARCH vs. HAR-RV

Traditional models capture daily conditional variance, while high-frequency models utilize sub-second tick feeds to estimate realized volatility. The table below outlines the core properties and performance limits of both methodologies:

3. The GARCH(1,1) Model: Capturing Volatility Clustering

One of the most notable features of financial asset returns is volatility clustering—the empirical fact that large price changes tend to be followed by large price changes, of either sign. Developed by Robert Engle and Tim Bollerslev, the Generalized Autoregressive Conditional Heteroskedasticity (GARCH) model represents daily variance $\sigma_t^2$ as a function of the long-term baseline variance $\omega$, recent squared residuals (shocks) $\epsilon_{t-1}^2$, and previous conditional variances $\sigma_{t-1}^2$:

$\sigma_t^2 = \omega + \alpha \epsilon_{t-1}^2 + \beta \sigma_{t-1}^2$

Where the model must satisfy the stability constraint $\alpha + \beta < 1$. In high-frequency setups, GARCH parameters are continuously calibrated in the background. The resulting daily forecasts are used to set static capital allocation envelopes and dynamically adjust portfolio Value-at-Risk (VaR) thresholds.

4. The HAR-RV Model: Multi-Scale Realized Variance

While GARCH processes discrete return intervals, high-frequency desks have access to continuous tick streams. By computing Realized Variance (RV) as the sum of squared high-frequency intraday returns, quants extract clean, noise-free measures of actual market activity. Realized Variance over day $t$ using $M$ intraday intervals is calculated as:

$RV_t = \sum_{j=1}^{M} r_{t,j}^2$

To model and forecast this realized variance, Fulvio Corsi proposed the Heterogeneous Autoregressive model of Realized Volatility (HAR-RV). Inspired by the heterogeneous market hypothesis, the model assumes that different trading participants operate on different time scales (daily speculators, weekly asset managers, monthly pension funds). The forecasting framework is structured as a simple linear regression cascade:

$RV_{t+1} = c + \beta^{(d)} RV_t + \beta^{(w)} RV_{t,w} + \beta^{(m)} RV_{t,m} + e_{t+1}$

Where $RV_{t,w}$ is the average RV over the past 5 days (weekly horizon) and $RV_{t,m}$ is the average over the past 22 days (monthly horizon). Because this cascade is linear, the model can be fitted via ordinary least squares (OLS) in less than a microsecond, making it ideal for real-time risk limit scaling directly inside high-frequency trading (HFT) pipelines.

5. Python Implementation: Calculating Realized Volatility

The following Python implementation demonstrates how to calculate rolling Realized Volatility from intraday tick data and fit a basic OLS linear model for volatility forecasting:

import numpy as np
import pandas as pd

def calculate_realized_variance(price_series, interval_seconds=300):
    """
    Computes realized variance based on high-frequency log-returns.
    Used for volatility analytics in algorithmic execution.
    """
    # 1. Compute log-returns
    log_returns = np.log(price_series / price_series.shift(1))
    
    # 2. Resample returns by interval
    grouped = log_returns.groupby(pd.Grouper(freq=f"{interval_seconds}s"))
    
    # 3. Sum squared log-returns within each interval
    realized_var = grouped.apply(lambda x: np.sum(x**2))
    return realized_var

# Fit a simple HAR-RV model using Ordinary Least Squares
def fit_har_rv_model(rv_series):
    # Calculate rolling averages for weekly and monthly horizons
    df = pd.DataFrame({'RV_daily': rv_series})
    df['RV_weekly'] = df['RV_daily'].rolling(5).mean()
    df['RV_monthly'] = df['RV_daily'].rolling(22).mean()
    
    # Set target variable as next day's RV
    df['Target_RV'] = df['RV_daily'].shift(-1)
    df.dropna(inplace=True)
    
    # Construct design matrix X and target vector Y
    X = df[['RV_daily', 'RV_weekly', 'RV_monthly']]
    X = np.column_stack([np.ones(len(X)), X]) # Add intercept constant
    Y = df['Target_RV'].values
    
    # Solve linear system using normal equations for fast execution
    beta = np.linalg.inv(X.T @ X) @ X.T @ Y
    return {
        "const": beta[0],
        "beta_daily": beta[1],
        "beta_weekly": beta[2],
        "beta_monthly": beta[3]
    }

6. Machine Learning and Volatility Forecasting

In recent years, quantitative researchers have increasingly combined statistical models with machine learning structures. Deep neural networks, such as Long Short-Term Memory (LSTM) cells and Temporal Fusion Transformers (TFT), excel at learning complex non-linear sequence dependencies and regime transitions that standard linear regressions cannot resolve.

However, deep learning models introduce significant latency overhead, making them unsuitable for inline execution loops. To leverage the power of machine learning, modern high-frequency architectures deploy hybrid risk management systems: a neural network identifies long-term volatility regimes and structural breaks offline, adjusting the prior parameters of the linear HAR-RV regression coefficients. The localized execution engine continues to run high-speed OLS logic in hardware, maintaining microsecond-level trading loop operations.