Have you ever noticed that stock prices or exchange rates tend to behave in clusters? For example, periods of calm with small price changes are often followed by periods of high activity with big jumps. This phenomenon, called volatility clustering, is common in financial data. To model and predict these fluctuations, we use something called a GARCH model.
In this blog post, I’ll break down what GARCH models are, why they’re important, and how you can build one using Python.
What is a GARCH Model?
GARCH stands for Generalized Autoregressive Conditional Heteroskedasticity. While that sounds like a mouthful, it boils down to this:
- Time-Varying Volatility: Unlike basic models that assume constant variance, GARCH assumes that the volatility of a series changes over time.
- Conditional: Today’s volatility depends on past data, such as past returns or errors.
- Autoregressive and Moving Average: It combines two components:
- Past variances (autoregressive part).
- Past squared errors (moving average part).
In simpler terms, GARCH models try to predict how volatile a time series (like stock prices) will be tomorrow, based on past behavior.
Why Do We Need GARCH Models?
Let’s say you’re a financial analyst managing a portfolio. To make good decisions, you need to know the risk associated with your investments. Risk is tied to volatility, and if volatility keeps changing (as it often does in markets), you can’t assume it’s constant.
GARCH models help:
- Forecast Volatility: How bumpy will the market be tomorrow?
- Manage Risk: Estimate Value at Risk (VaR) to prepare for potential losses.
- Optimize Portfolios: Allocate your investments better by understanding future risks.
How Does GARCH Work?
Let’s break it into simple steps:
- Start with Returns: For financial time series, you first calculate daily or weekly returns. Returns are typically more predictable than raw prices.
- Model the Mean: Many time series models focus on predicting the average value. GARCH goes a step further and models the variance (how much the data varies around the mean).
- Lagged Effects: GARCH assumes today’s volatility depends on:
- Past squared errors (big shocks lead to high volatility later).
- Past variances (high volatility tends to persist over time).
The GARCH Formula
The GARCH model predicts the variance ($ \sigma_t^2 $) of the series at time $ t $ using:
\(\sigma_t^2 = \omega + \sum_{i=1}^q \alpha_i \epsilon_{t-i}^2 + \sum_{j=1}^p \beta_j \sigma_{t-j}^2\)
Where:
- $ \omega $: Baseline variance (a constant).
- $ \epsilon_{t-i}^2 $: Past squared errors. These errors are the different between the predicted return and the actual return. in case of a simple GARCH model we consider the predicted return to be the average return which we assume is zero. Therefore this errors are considerend to be just the returns!
- $ \sigma_{t-j}^2 $: Past variances (how volatile the past has been).
- $ \alpha_i $ and $ \beta_j $: Weights assigned to past errors and variances.
We optimize the weights $\alpha$ and $\beta$ using Maximum Likelihood Estimation (MLE).
Let’s Implement GARCH in Python
We’ll use the arch package, a popular Python library for working with volatility models. Let’s dive into the code!
Step 1: Install Required Libraries
1
pip install arch pandas matplotlib
Step 2: Import Libraries
1
2
3
4
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from arch import arch_model
Step 3: Generate or Load Data
Here, we’ll generate synthetic data that mimics financial returns. You can also load real-world data, like stock prices, using APIs like Yahoo Finance.
1
2
3
4
# Generate synthetic returns data
np.random.seed(42)
n = 1000 # Number of data points
returns = np.random.normal(loc=0, scale=1, size=n) # Simulated daily returns
Step 4: Fit a GARCH(1,1) Model
The GARCH(1, 1) model is one of the most commonly used models, with one lag for both errors and variances.
1
2
3
4
5
6
# Fit a GARCH(1, 1) model
model = arch_model(returns, vol='Garch', p=1, q=1, mean='Zero', dist='Normal')
results = model.fit()
# Print the summary
print(results.summary())
Step 5: Plot the Results
Let’s visualize the conditional volatility predicted by the model.
1
2
3
4
5
6
7
8
9
10
11
# Get conditional volatility (sigma_t)
volatility = results.conditional_volatility
# Plot the results
plt.figure(figsize=(10, 6))
plt.plot(volatility, label='Conditional Volatility', color='blue')
plt.title('GARCH(1,1) Conditional Volatility')
plt.xlabel('Time')
plt.ylabel('Volatility')
plt.legend()
plt.show()
Interpreting the Output
Model Summary: The summary provides estimated coefficients ($ \omega, \alpha_1, \beta_1 $). If $ \alpha_1 + \beta_1 $ is close to 1, volatility tends to persist for a long time.
Volatility Plot: The conditional volatility plot shows how predicted volatility changes over time. Peaks indicate periods of high uncertainty.
Real-World Example
For real data, you can use historical stock prices. Here’s how you can load data using Yahoo Finance:
1
2
3
4
5
6
7
8
9
10
import yfinance as yf
# Load stock data
data = yf.download('AAPL', start='2020-01-01', end='2023-01-01')
returns = 100 * data['Adj Close'].pct_change().dropna() # Calculate daily returns
# Fit the GARCH model
model = arch_model(returns, vol='Garch', p=1, q=1, mean='Zero', dist='Normal')
results = model.fit()
print(results.summary())
Conclusion
GARCH models are powerful tools for understanding and predicting volatility in time series data. While they’re widely used in finance, they’re also applicable in areas like weather forecasting or any domain where variability matters.
If you’re just starting out, try experimenting with different datasets and GARCH configurations to see how well they capture volatility patterns.
Comments powered by Disqus.