Cracking the Code: Building a Predictive Volatility Model from Scratch#

Key Terminology#

• Variance: A measure of how spread out a distribution is, calculated as the average of the squared deviations from the mean.
• Standard Deviation (Volatility): The square root of variance. This is often used in finance as the primary measure of risk or uncertainty.
• Annualized Volatility: Typically, volatilities are quoted on an annual basis. For example, if you observe daily prices, you might compute daily volatility and then scale it to annual volatility by multiplying by the square root of 252 (the approximate number of trading days in a year).

Pricing and Risk#

Financial literature is replete with references to volatility because it plays a role in almost every realm of market strategy and decision-making. For instance, option pricing models (like the Black-Scholes model) treat volatility as a crucial input in determining the options price. Portfolio managers also place heavy emphasis on volatility when analyzing the overall risk of a portfolio.

Typical Data Sources#

1. Financial Databases: Platforms like Yahoo Finance, Quandl, or Bloomberg.
2. Broker/Exchange Feeds: Direct data feeds from brokers or exchanges offering historical price data for stocks, indexes, and other assets.
3. Commercial Providers: Subscription-based providers like Refinitiv or FactSet offering high-quality, cleansed data.

Data Organization#

To build a predictive volatility model, you should have a well-organized dataset:

• Date (time index)
• Open, High, Low, and Close Prices
• Volume (optional, but can be useful in certain volatility models)

The most critical element is the closing price (or adjusted close) that is commonly used in daily return computations. If youre focusing on intraday or high-frequency volatility, then youll need to store and process significantly more granular data.

Cleaning and Preprocessing#

Financial data often contains anomalies such as missing observations or outliers (e.g., due to market halts or low liquidity). Common cleaning steps:

1. Identify and remove missing values, or impute them appropriately.
2. Adjust for stock splits and dividends when using long historical data.
3. Check for out-of-range or suspicious price spikes that might be data errors.

Log Returns#

Volatility is often computed and modeled on log returns rather than simple arithmetic returns. The log return, ( r_t ), for an asset price ( P_t ) is given by:

[ r_t = \ln\left(\frac{P_t}{P_{t-1}} \right) = \ln(P_t) - \ln(P_{t-1}). ]

Log returns have nice properties: they are additive over time, making it simpler to handle compounding.

Stationarity#

A key assumption in many time series models is that the series is stationary, meaning its statistical properties (mean, variance) do not change over time. However, daily returns often exhibit non-stationary volatilityleading us to volatility models specifically designed to handle time-varying variance.

Autocorrelation and Heteroskedasticity#

Financial return series often show little autocorrelation in raw returns but significant autocorrelation in the squared returns or the absolute returns. This phenomenonvolatility clusteringforms the foundation of GARCH models.

Computation#

1. Compute the log returns, ( r_t ).
2. Compute the average of these returns, ( \bar{r} ).
3. Compute the variance (\sigma^2) of these returns over a rolling window:
   [ \sigma^2 = \frac{1}{N-1} \sum_{t=1}^{N} (r_t - \bar{r})^2. ]
4. Take the square root to get the standard deviation, (\sigma).

If you want an annualized volatility, multiply by (\sqrt{252}) for daily data.

Example Code Snippet for Historical Volatility in Python#

1
import numpy as np
2
import pandas as pd
3
import yfinance as yf
4

5
# Download data for a stock (e.g., Apple)
6
symbol = "AAPL"
7
data = yf.download(symbol, start="2020-01-01", end="2021-01-01")
8
data.dropna(inplace=True)
9

10
# Compute log returns
11
data['Log_Return'] = np.log(data['Adj Close'] / data['Adj Close'].shift(1))
12

13
# Rolling window size (let's pick 20 days)
14
window_size = 20
15

16
# Compute rolling historical volatility
17
data['HV'] = data['Log_Return'].rolling(window_size).std() * np.sqrt(252)
18

19
# Print last few rows
20
print(data.tail())

In this snippet:

• We load daily adjusted closing prices for Apple using yfinance.
• We compute log returns.
• We apply a rolling window standard deviation, converting it to an annualized statistic by multiplying by the square root of 252.

Pros and Cons of Historical Volatility#

• Pros
  • Easy to implement.
  • Requires minimal computing power.
• Cons
  • Doesnt capture volatility clustering or conditional heteroskedasticity.
  • May lag in reacting to new market information.

What is GARCH(1,1)?#

In financial time series, a GARCH(1,1) model is often the first go-to method for forecasting volatility. The model aims to describe how current volatility depends on previous days volatility and the previous days return shocks (squared residuals).

Let ( r_t ) be the return at time ( t ), and assume ( r_t = \mu_t + \epsilon_t ) where ( \epsilon_t \sim N(0, \sigma_t^2) ). A GARCH(1,1) model references:

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

where:

• (\omega) is a constant term.
• (\alpha) measures the reaction of volatility to last periods squared shock.
• (\beta) captures the persistence of volatility from the previous day.

Intuition#

• When (\epsilon_{t-1}^2) is large (i.e., large shock in the previous time period), volatility (\sigma_t^2) increases for the current period.
• The higher the coefficient (\beta), the longer it takes for volatility to revert back to its mean level after a shock.

Implementation in Python#

Well use the arch library in Python, which makes it straightforward to fit GARCH models.

1
import pandas as pd
2
import numpy as np
3
import yfinance as yf
4
from arch import arch_model
5

6
# Fetch data
7
symbol = "AAPL"
8
data = yf.download(symbol, start="2020-01-01", end="2021-01-01")
9
data.dropna(inplace=True)
10

11
# Compute log returns
12
data['Log_Return'] = np.log(data['Adj Close'] / data['Adj Close'].shift(1))
13
returns = data['Log_Return'].dropna()
14

15
# Specify and fit GARCH(1,1)
16
am = arch_model(returns, vol='GARCH', p=1, q=1, dist='normal')
17
res = am.fit(disp='off')
18
print(res.summary())
19

20
# Forecast
21
forecasts = res.forecast(horizon=1, start=len(returns)-10)
22
print(forecasts.variance.tail())

Interpretation of Results#

• omega ((\omega)): The baseline level of volatility.
• alpha ((\alpha)): How sensitive the volatility is to a new shock.
• beta ((\beta)): The persistence of volatility over time.
• A stationary GARCH(1,1) requires (\alpha + \beta < 1). If (\alpha + \beta) is close to 1, shocks to volatility persist for a long time.

Example: EGARCH#

You can implement EGARCH in arch by specifying vol='EGARCH':

1
from arch import arch_model
2

3
am_egarch = arch_model(returns, vol='EGARCH', p=1, q=1, dist='normal')
4
res_egarch = am_egarch.fit(disp='off')
5
print(res_egarch.summary())

In the summary, youll find terms like theta or gamma which capture asymmetry (the leverage effect). High negative returns can increase volatility more than high positive returns of a similar magnitude.

Practical Advantages of Advanced Models#

• Asymmetric Volatility: Real markets often exhibit higher volatility following negative shocks.
• Better Forecast Performance: These models may yield lower forecast errors in empirical studies.

Why ML for Volatility?#

1. Non-linearities: Real market data often exhibit nonlinear patterns that GARCH might miss.
2. Multiple Explanatory Variables: You can incorporate additional features such as macroeconomic indicators, sentiment data, or technical indicators.
3. Proven Track Record: ML has made inroads in many areas of quantitative finance, from alpha generation to risk factor modeling.

Feature Engineering#

When using ML for volatility, you might start with:

• Past volatility estimates (e.g., from a GARCH approach).
• Rolling window statistical measures (e.g., rolling mean, rolling std of returns).
• Macro indicators (interest rates, economic growth indicators, etc.).
• Market sentiment or implied volatility indices (like VIX).

Sample Random Forest Implementation#

1
import pandas as pd
2
import numpy as np
3
from sklearn.ensemble import RandomForestRegressor
4
from sklearn.metrics import mean_squared_error
5
from arch import arch_model
6

7
# Suppose we already have daily data and computed log returns
8
# We'll create a feature set that includes lagged volatilities and returns
9

10
def create_features(data, n_lags=3):
11
    df = data.copy()
12
    for i in range(1, n_lags+1):
13
        df[f'return_lag_{i}'] = df['Log_Return'].shift(i)
14
        df[f'vol_lag_{i}'] = df['HV'].shift(i)  # Suppose HV is historical vol
15
    df.dropna(inplace=True)
16
    return df
17

18
# Let's assume data already has columns: ['Log_Return', 'HV']
19
df_features = create_features(data, n_lags=3)
20

21
# Train/Test split
22
split_date = '2020-10-01'
23
df_train = df_features.loc[:split_date]
24
df_test = df_features.loc[split_date:]
25

26
X_train = df_train.drop(['Log_Return', 'HV'], axis=1)
27
y_train = df_train['HV']  # We'll predict historical vol as a proxy
28
X_test = df_test.drop(['Log_Return', 'HV'], axis=1)
29
y_test = df_test['HV']
30

31
# Fit Random Forest
32
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
33
rf_model.fit(X_train, y_train)
34

35
# Predict and evaluate
36
y_pred = rf_model.predict(X_test)
37
mse = mean_squared_error(y_test, y_pred)
38
print("Test MSE:", mse)

In this rudimentary example:

1. We use a function create_features to create lagged returns and volatilities.
2. We train a random forest to predict a target volatility.
3. We evaluate the model using mean squared error on the test set.

Of course, you can refine this approach by:

• Using actual realized volatility over short intervals (e.g., intraday).
• Incorporating GARCH-based volatility forecasts as features in the ML model.
• Experimenting with additional hyperparameters or advanced feature engineering.

Key Metrics#

1. Mean Squared Error (MSE): Quantifies the average squared deviation between model predictions and true values, penalizing large errors.
2. Mean Absolute Error (MAE): Averages absolute errors, making it more robust against outliers.
3. Diebold-Mariano Test: A statistical test specifically designed to compare predictive accuracy across time series forecasting models.

In-Sample vs. Out-of-Sample#

Its crucial to test your model on out-of-sample data, i.e., data not used during training. Overfitting is common in complex models, including ML-based methods, so ensuring generalizability is paramount.

Rolling Window Evaluation#

Volatility modeling often relies on rolling or expanding window evaluations:

1. Fixed Window: Train on a fixed period (e.g., 1 year) and then test on new data.
2. Expanding Window: Over time, you incorporate more data in your training set.
3. Walk-Forward Analysis: Re-train the model at each step to simulate real-world conditions.

A typical approach:

1. Split your time series into segments.
2. Fit the model on the earliest segment, predict for the subsequent periods.
3. Move the window forward (or expand your training set), re-fit the model, generate forecasts for the next segment.
4. Accumulate the errors across all forecasted segments for an unbiased performance measure.

Data Frequency#

• Daily: The most common frequency for volatility modeling.
• Intraday: Capturing intraday price changes can provide more accurate volatility estimates (realized volatility). This often involves extremely large datasets.
• TIPS: If you plan to model intraday volatility, youll need robust data management systems and faster modeling techniques to handle the real-time computational load.

Computing Environment#

1. Cloud Computing: Services like AWS (Amazon Web Services) and GCP (Google Cloud Platform) offer scalable compute resources, which can be particularly helpful for large or complex models.
2. Local GPUs: If youre experimenting with deep learning approaches, a GPU significantly reduces training time for large neural networks.

Data Quality#

• Survivorship Bias: If using historical data, watch out for delisted securities or missing data that skews results.
• Corporate Actions: Mergers, stock splits, dividends. Ensure youre using adjusted prices.
• Clean vs. Real-time Feeds: Real-time data can have anomalies (microstructure noise, missing ticks). Data cleaning routines are essential.

Trading Strategy Integration#

A predictive volatility model is often just one piece of a broader trading or risk management strategy. Possible downstream uses:

• Risk Parity: Adjusting position sizes based on forecasted volatility.
• Option Trading: Identifying mispriced options by comparing model volatility forecasts to implied volatility in the options market.
• Portfolio Hedging: Dynamically adjusting hedge positions if your volatility forecast suggests increased risk.

Further Resources#

• Books:

  • Analysis of Financial Time Series?by Ruey S. Tsay
  • The Econometrics of Financial Markets?by John Y. Campbell, Andrew W. Lo, and A. Craig MacKinlay

• Online Courses and Tutorials:

  • Coursera, edX, and other platforms offer comprehensive courses on time series analysis and ML in finance.
  • QuantStart and QuantInsti blogs provide intermediate to advanced tutorials.

• Python Libraries:

  • arch for GARCH.
  • statsmodels for general time series.
  • scikit-learn for ML algorithms.

Volatility modeling is an ever-evolving area of research. By combining classical econometric models with modern machine learning techniques, you can build sophisticated forecasting systems that adapt to changing market conditions. Whether for professional trading, portfolio management, or academic research, volatility modeling offers invaluable insights into market risk and dynamics. With the knowledge gained in this post, youre now equipped with the foundational tools to start experimenting, iterating, and refining your own predictive volatility models. May your journey in volatility forecasting be both intellectually rewarding and practically beneficial!