Realized Quantiles

A Python implementation of the Realized Quantiles methodology for high-frequency financial data analysis, based on the work of Dimitriadis & Halbleib (2022).

Overview

This package provides tools for computing tail risk measures (Value-at-Risk and Expected Shortfall) from high-frequency trading data using intrinsic-time sampling schemes. It enables more accurate risk forecasting by accounting for the time-varying nature of financial markets.

Key Features

Multiple Intrinsic-Time Sampling Schemes:
- CTS (Constant Time Sampling): Traditional calendar-time sampling
- TickTS (Tick Time Sampling): Based on transaction counts
- TTS (Time Transformation Sampling): Based on average intraday transaction patterns
- BTS (Business Time Sampling): Volatility-based sampling using tripower variation
Realized Risk Measures:
- Realized Quantiles (RQ): high-frequency VaR estimates
- Realized Expected Shortfall (RES): high-frequency ES estimates
Forecasting & Evaluation:
- HAR (Heterogeneous AutoRegressive) models for RQ/RES forecasting
- Proper scoring rules (Fissler-Ziegel) for forecast evaluation
- Coverage testing and model comparison

Installation

From source

git clone https://github.com/Mapirlet/Realized-Quantiles.git
cd Realized-Quantiles
pip install -e .

Requirements

Python >= 3.11
pandas >= 2.2.0
numpy >= 2.0.0
scipy >= 1.13.0
arch >= 7.2.0 (for HAR models)
statsmodels >= 0.14.0
matplotlib >= 3.9.0
tqdm >= 4.67.0

Quick Start

1. Load High-Frequency Data

import realized_quantiles as rq

# Load stock data from CSV files
data = rq.load_stock_data("AAPL")

Expected data format: CSV files with columns Dates, Time, Price

2. Build Intensity Measures

# Choose a sampling scheme: "CTS", "TickTS", "TTS", or "BTS"
intensity = rq.build_intensity(
    data=data,
    scheme="BTS",
    frequency_seconds=1
)

3. Resample to Intrinsic Time

# Resample trades based on the intensity measure
resampled_data, cumulative_intensity = rq.batch_resample(
    data=data,
    intensities=intensity,
    n_trades=390  # Number of observations per day
)

4. Compute Realized Quantiles & Expected Shortfall

from realized_quantiles.returns import compute_intraday_returns

# Compute intraday returns
intraday_returns = compute_intraday_returns(resampled_data)

# Compute empirical VaR and ES
var_es = rq.compute_daily_var_es(
    intraday_returns,
    prob_levels=[0.01, 0.025, 0.05]  # 1%, 2.5%, 5% risk levels
)

# Scale to daily Realized Quantiles and Realized ES
rq_res = rq.compute_daily_realized_var_es(
    var_es,
    scaling_index_H=0.5,  # Hurst exponent (0.5 for Brownian motion)
    c=390  # Number of intraday observations
)

5. Forecast with HAR Models

# Rolling forecast using Heterogeneous AutoRegressive models
forecasts = rq.rolling_forecast_HAR(
    series=rq_res,
    window_size=252,  # 1 year of trading days
    forecast_horizon=1,  # 1-day ahead
    har_lags=[1, 5, 22]  # Daily, weekly, monthly lags
)

6. Evaluate Forecasts

from realized_quantiles.returns import calculate_daily_log_returns

# Compute actual daily returns
daily_returns = calculate_daily_log_returns(data)

# Calculate average asymmetric VaR scores
var_scores = rq.calculate_average_asymmetric_var_scores(
    actual_returns=daily_returns,
    forecasted_data=forecasts,
    probability_levels=[0.01, 0.025, 0.05]
)

# Calculate joint VaR-ES scores (Fissler-Ziegel)
joint_scores = rq.calculate_average_svares_scores(
    actual_returns=daily_returns,
    forecasted_data=forecasts,
    probability_levels=[0.01, 0.025, 0.05]
)

print(var_scores)
print(joint_scores)

Package Structure

realized_quantiles/
├── __init__.py           # Main package interface
├── config.py             # Configuration (trading hours, paths)
├── data_loader.py        # Load high-frequency data
├── intensity.py          # Build intensity measures (CTS/TickTS/TTS/BTS)
├── sampling.py           # Resample to intrinsic time
├── returns.py            # Compute log returns (intraday & daily)
├── tail_risk.py          # Compute RQ, RES, volatility measures
├── forecasting.py        # HAR forecasting models
├── scoring.py            # Forecast evaluation (scoring rules, coverage)
└── dma.py                # DMA estimator for Hurst exponent (diagnostics)

Methodology

This implementation follows the methodology from:

Dimitriadis, T., & Halbleib, R. (2022). Realized Quantiles.

Intrinsic Time Sampling

Traditional risk measures computed on calendar-time data may miss important intraday dynamics. This package implements intrinsic-time sampling schemes that adapt to market activity:

CTS: Uniform sampling (baseline)
TickTS: Sample proportionally to transaction counts
TTS: Sample based on average historical transaction patterns
BTS: Sample based on realized volatility (tripower variation)