Comprehensive Guide to Volatility Models

💸 Join the Investing Social Network

📈 If you love investing, you’ll love Blossom. Blossom is a social network built specifically for investors where over 250,000 members are sharing their portfolios and ideas, backed up by what they’re actually investing in.

⭐️ With a 4.7 rating in the App Store and ranked an Essential Finance App of 2024 by Apple, Blossom is packed with tools to help you become a better investor. Tools like:

• Dividend tracking and forecasting

• In-depth portfolio analysis

• Duolingo-style investing courses

• Earnings and dividend calendars

• And most importantly, thousands of incredible posts from our amazing community!

🌼 Join Blossom for free! 🌼 

🚀 Your Investing Journey Just Got Better: Premium Subscriptions Are Here! 🚀

It’s been 4 months since we launched our premium subscription plans at GuruFinance Insights, and the results have been phenomenal! Now, we’re making it even better for you to take your investing game to the next level. Whether you’re just starting out or you’re a seasoned trader, our updated plans are designed to give you the tools, insights, and support you need to succeed.

Here’s what you’ll get as a premium member:

• Exclusive Trading Strategies: Unlock proven methods to maximize your returns.

• In-Depth Research Analysis: Stay ahead with insights from the latest market trends.

• Ad-Free Experience: Focus on what matters most—your investments.

• Monthly AMA Sessions: Get your questions answered by top industry experts.

• Coding Tutorials: Learn how to automate your trading strategies like a pro.

• Masterclasses & One-on-One Consultations: Elevate your skills with personalized guidance.

Our three tailored plans—Starter Investor, Pro Trader, and Elite Investor—are designed to fit your unique needs and goals. Whether you’re looking for foundational tools or advanced strategies, we’ve got you covered.

Don’t wait any longer to transform your investment strategy. The last 4 months have shown just how powerful these tools can be—now it’s your turn to experience the difference.

👉 Explore Premium Plans Now

Introduction
Volatility modelling is fundamental to financial analysis and risk management. Different models have been developed over time to capture various aspects of price movements and market behaviour. This guide explores the major volatility models, their mathematical foundations, and practical applications.

You will have every model written in Python as you read this;

First, let´s import the libraries and $SPY prices:

import numpy as np
import pandas as pd
import yfinance as yf
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

plt.style.use('default')
pd.set_option('display.max_columns', None)


def get_spy_data():
    """
    Retrieves SPY data for the last year using yfinance.
    Returns a DataFrame with Open, High, Low, Close prices.
    """
    end_date = datetime.now()
    start_date = end_date - timedelta(days=365)
    
    spy = yf.download('SPY', start=start_date, end=end_date)
    return spy

Close-to-Close Volatility Model

Read The Daily Upside. Stay Ahead of the Markets. Invest Smarter.

Most financial news is full of noise. The Daily Upside delivers real insights—clear, concise, and free. No clickbait, no fear-mongering. Just expert analysis that helps you make smarter investing decisions.

Join 1M+ readers today.

Overview
The close-to-close volatility model is the most traditional and widely used approach. It uses daily closing prices to estimate volatility, making it particularly reliable due to the high liquidity typically present during closing auctions.

Mathematical Formula
The close-to-close volatility is calculated as:

Where:
- σcc = Close-to-close volatility
- F = Annualization factor (252 for daily data)
- N = Number of observations
- xi = ln(ci/ci-1) = logarithmic return
- ci = Closing price at time i
- x̄ = Mean of logarithmic returns (often assumed to be zero)

Strengths and Limitations
Strengths:
- Uses reliable closing prices from liquid market periods
- Simple to calculate and widely understood
- Most appropriate for variance swap pricing

Limitations:
- Ignores intraday price movements
- May miss significant volatility between closing periods
- Requires more data points for accurate estimation

def calculate_close_to_close(data, window=20):
    """
    Calculates Close-to-Close volatility.
    This is the traditional method using only closing prices.
    
    Parameters:
        data: DataFrame with price data
        window: Rolling window size for calculation
        
    Returns:
        Annualized volatility series
    """
    returns = np.log(data['Close'] / data['Close'].shift(1))
    vol = np.sqrt(252) * returns.rolling(window=window).std(ddof=1)
    return vol

Exponentially Weighted Volatility Model
Overview
This model assigns more weight to recent observations, making it more responsive to current market conditions while still maintaining historical context.

Where:
- σt = Volatility at time t
- λ = Decay factor (typically around 0.94 for daily data)
- xt = Return at time t

Strengths and Limitations
Strengths:
- More responsive to recent market changes
- Smoother transitions in volatility estimates
- Helps prevent volatility estimate collapse

Limitations:
- Sensitive to parameter choice (λ)
- May not handle regular events (like earnings) well
- Can overreact to recent extreme events

def calculate_ewma(data, window=20, lambda_param=0.94):
    """
    Calculates Exponentially Weighted Moving Average volatility.
    This method gives more weight to recent observations.
    
    Parameters:
        data: DataFrame with price data
        window: Initial window size for calculation
        lambda_param: Decay factor (typically 0.94 for daily data)
        
    Returns:
        Annualized EWMA volatility series
    """
    returns = np.log(data['Close'] / data['Close'].shift(1))
    returns = returns.fillna(0)
    
    vol = pd.Series(np.nan, index=returns.index)
    vol.iloc[window-1] = np.sqrt(252) * returns.iloc[:window].std(ddof=1)
    
    for i in range(window, len(returns)):
        if np.isnan(vol.iloc[i-1]):
            vol.iloc[i] = np.sqrt(252) * returns.iloc[i-window:i].std(ddof=1)
        else:
            vol.iloc[i] = np.sqrt(252 * ((1 - lambda_param) * returns.iloc[i]**2 + 
                                        lambda_param * (vol.iloc[i-1]/np.sqrt(252))**2))
    
    return vol

Parkinson Model (High-Low)
Overview
Developed by Michael Parkinson in 1980, this model uses daily high and low prices to estimate volatility, incorporating intraday price movement information.

Where:
- σP = Parkinson volatility
- hi = High price on day i
- li = Low price on day i
- F = Annualization factor
- N = Number of observations

Strengths and Limitations
Strengths:
- Uses intraday price information
- Up to 5.2 times more efficient than close-to-close
- Less sensitive to different trading hours

Limitations:
- Assumes continuous trading
- Underestimates volatility due to overnight gaps
- Doesn’t handle drift well

def calculate_parkinson(data, window=20):
    """
    Calculates Parkinson volatility.
    Uses high and low prices to capture intraday price movements.
    
    Parameters:
        data: DataFrame with price data
        window: Rolling window size for calculation
        
    Returns:
        Annualized Parkinson volatility series
    """
    factor = 1 / (4 * np.log(2))
    hl_square = np.log(data['High'] / data['Low'])**2
    vol = np.sqrt(252 * factor * hl_square.rolling(window=window).mean())
    return vol

Garman-Klass Model
Overview
An extension of the Parkinson model that incorporates opening and closing prices alongside highs and lows.

Where:
- σGK = Garman-Klass volatility
- oi = Opening price
- ci = Closing price
- hi = High price
- li = Low price

Strengths and Limitations
Strengths:
- Up to 7.4 times more efficient than close-to-close
- Uses comprehensive price information
- Good for stocks with Brownian motion

Limitations:
- Assumes zero drift
- Doesn’t handle overnight jumps
- Underestimates volatility in discrete trading

def calculate_garman_klass(data, window=20):
    """
    Calculates Garman-Klass volatility.
    Extends Parkinson model by incorporating opening and closing prices.
    
    Parameters:
        data: DataFrame with price data
        window: Rolling window size for calculation
        
    Returns:
        Annualized Garman-Klass volatility series
    """
    hl = 0.5 * np.log(data['High'] / data['Low'])**2
    co = (2*np.log(2)-1) * (np.log(data['Close'] / data['Open'])**2)
    vol = np.sqrt(252 * (hl - co).rolling(window=window).mean())
    return vol

Rogers-Satchell Model
Overview
Developed in the early 1990s, this model is particularly valuable for securities with non-zero drift.

Where:
- σRS = Rogers-Satchell volatility
- All other variables as previously defined

Strengths and Limitations
Strengths:
- Handles non-zero drift well
- Similar efficiency to Garman-Klass
- More accurate for trending markets

Limitations:
- Doesn’t handle jumps well
- Underestimates volatility in discrete markets
- Requires all four price points (O,H,L,C)

def calculate_rogers_satchell(data, window=20):
    """
    Calculates Rogers-Satchell volatility.
    Handles securities with non-zero drift (trend).
    
    Parameters:
        data: DataFrame with price data
        window: Rolling window size for calculation
        
    Returns:
        Annualized Rogers-Satchell volatility series
    """
    rs = (np.log(data['High'] / data['Close']) * np.log(data['High'] / data['Open']) +
          np.log(data['Low'] / data['Close']) * np.log(data['Low'] / data['Open']))
    vol = np.sqrt(252 * rs.rolling(window=window).mean())
    return vol

Yang-Zhang Model
Overview
Created in 2000, this is considered the most sophisticated volatility estimator, handling both overnight jumps and drift.

Where:
- σYZ = Yang-Zhang volatility
- k = 0.34/(1.34 + (N+1)/(N-1))
- σovernight² = Overnight volatility component
- σopen-to-close² = Open-to-close volatility component
- σRS² = Rogers-Satchell volatility component

Strengths and Limitations
Strengths:
- Handles both jumps and drift
- Up to 14 times more efficient than close-to-close
- Most comprehensive price information usage

Limitations:
- More complex to implement
- Requires all price points (O,H,L,C)
- Slight underestimation due to continuous trading assumption

def calculate_yang_zhang(data, window=20):
    """
    Calculates Yang-Zhang volatility.
    Most comprehensive model handling both overnight jumps and drift.
    
    Parameters:
        data: DataFrame with price data
        window: Rolling window size for calculation
        
    Returns:
        Annualized Yang-Zhang volatility series
    """
    k = 0.34 / (1.34 + (window + 1)/(window - 1))
    
    overnight = np.log(data['Open'] / data['Close'].shift(1))
    sigma_overnight = overnight.rolling(window=window).var()
    
    open_close = np.log(data['Close'] / data['Open'])
    sigma_open_close = open_close.rolling(window=window).var()
    
    rs = (np.log(data['High'] / data['Close']) * np.log(data['High'] / data['Open']) +
          np.log(data['Low'] / data['Close']) * np.log(data['Low'] / data['Open']))
    sigma_rs = rs.rolling(window=window).mean()
    
    vol = np.sqrt(252 * (sigma_overnight + k * sigma_open_close + (1-k) * sigma_rs))
    return vol

Finally, we are going to create the graphs and some correlations between these volatilities:

spy_data = get_spy_data()


volatilities = pd.DataFrame(index=spy_data.index)
volatilities['Close-to-Close'] = calculate_close_to_close(spy_data)
volatilities['EWMA'] = calculate_ewma(spy_data)
volatilities['Parkinson'] = calculate_parkinson(spy_data)
volatilities['Garman-Klass'] = calculate_garman_klass(spy_data)
volatilities['Rogers-Satchell'] = calculate_rogers_satchell(spy_data)
volatilities['Yang-Zhang'] = calculate_yang_zhang(spy_data)

fig, axs = plt.subplots(7, 1, figsize=(15, 20), gridspec_kw={'height_ratios': [1.5, 1, 1, 1, 1, 1, 1]})
fig.suptitle('SPY: Price and Volatility Models', fontsize=16, y=0.95)


axs[0].plot(spy_data.index, spy_data['Close'], label='SPY', color='blue', linewidth=2)
axs[0].set_title('SPY Closing Price')
axs[0].legend()
axs[0].grid(True, alpha=0.3)


colors = ['darkred', 'green', 'purple', 'orange', 'brown', 'black']


for i, (name, color) in enumerate(zip(volatilities.columns, colors)):
    axs[i+1].plot(volatilities.index, volatilities[name], 
                  label=name, color=color, linewidth=1.5)
    axs[i+1].set_title(f'{name} Volatility')
    axs[i+1].legend()
    axs[i+1].grid(True, alpha=0.3)
    axs[i+1].set_ylabel('Annualized Volatility')


plt.tight_layout()
plt.show()


print("\nVolatility Descriptive Statistics:")
print(volatilities.describe().round(4))


print("\nCorrelations between Models:")
print(volatilities.corr().round(4))

Conclusion

Each volatility model offers unique advantages and faces specific limitations. The choice of model should be based on:

1. The specific use case and requirements
2. Available data and computational resources
3. Market characteristics and trading patterns
4. Required accuracy and efficiency
5. Implementation constraints

For most applications, the Yang-Zhang model provides the most comprehensive and accurate estimates, particularly for small sample sizes. However, the traditional close-to-close method remains valuable for large samples and specific applications like variance swap pricing.