Skip to content
The Algotrading Book

Chapter 145: Physics-Informed Neural Networks for Hull-White Interest Rate Model

Chapter 145: Physics-Informed Neural Networks for Hull-White Interest Rate Model

Overview

The Hull-White model (also known as the extended Vasicek model) is one of the most widely used short-rate models in quantitative finance. It describes the evolution of the instantaneous short rate and can be calibrated exactly to the initial term structure of interest rates. In this chapter, we build a Physics-Informed Neural Network (PINN) that embeds the Hull-White PDE directly into the neural network loss function, enabling mesh-free, differentiable bond pricing with automatic term structure fitting.

Why Hull-White + PINNs?

The Hull-White Model

The Hull-White model specifies the short rate dynamics under the risk-neutral measure:

dr(t) = [theta(t) - a * r(t)] dt + sigma * dW(t)

where:

  • r(t) is the instantaneous short rate at time t
  • a > 0 is the mean-reversion speed
  • theta(t) is the time-dependent drift (calibrated to match the initial yield curve)
  • sigma > 0 is the volatility of the short rate
  • W(t) is a standard Brownian motion under the risk-neutral measure

Key Properties

  1. Mean Reversion: Interest rates are pulled toward a long-run level theta(t)/a, preventing rates from drifting to extreme values
  2. Analytical Tractability: Closed-form solutions exist for zero-coupon bond prices, caps, floors, and swaptions
  3. Term Structure Fitting: The function theta(t) can be chosen to exactly match any observed yield curve
  4. Normal Distribution: The short rate r(t) is normally distributed (can go negative, which is realistic in modern markets)

Why PINNs?

Traditional numerical methods (finite differences, trinomial trees) require:

  • Grid construction and boundary condition management
  • Interpolation between grid points
  • Separate calibration and pricing steps

PINNs offer several advantages:

  • Mesh-free: No grid discretization needed
  • Differentiable: Greeks (sensitivities) come for free via automatic differentiation
  • Flexible: Easily extend to higher dimensions or modified dynamics
  • GPU-acceleratable: Natural parallelism through mini-batch training
  • Unified: Calibration and pricing in a single optimization

Mathematical Foundation

The Bond Pricing PDE

For a zero-coupon bond P(r, t; T) maturing at time T, the Hull-White model implies the partial differential equation:

dP/dt + [theta(t) - a*r] * dP/dr + (1/2) * sigma^2 * d^2P/dr^2 - r*P = 0

with terminal condition:

P(r, T; T) = 1  for all r

This PDE must hold for all (r, t) in the domain r in R, t in [0, T].

Analytical Solution

The Hull-White model admits a closed-form bond pricing formula:

P(r, t; T) = A(t, T) * exp(-B(t, T) * r)

where:

B(t, T) = (1 - exp(-a*(T-t))) / a


A(t, T) = (P_M(0, T) / P_M(0, t)) * exp(
    B(t,T) * f_M(0, t) - (sigma^2 / (4*a)) * (1 - exp(-2*a*t)) * B(t,T)^2
)

Here:

  • P_M(0, t) is the market discount factor at time 0 for maturity t
  • f_M(0, t) is the market instantaneous forward rate at time 0 for maturity t

Time-Dependent Drift

The function theta(t) is determined by the initial term structure:

theta(t) = df_M(0, t)/dt + a * f_M(0, t) + (sigma^2 / (2*a)) * (1 - exp(-2*a*t))

This ensures the model exactly reproduces the observed yield curve at time 0.

Interest Rate Distribution

Under the Hull-White model, the short rate at future time s > t is normally distributed:

r(s) | r(t) ~ N(mu(t,s), v(t,s))

where:

mu(t, s) = r(t) * exp(-a*(s-t)) + integral_t^s theta(u) * exp(-a*(s-u)) du


v(t, s) = (sigma^2 / (2*a)) * (1 - exp(-2*a*(s-t)))

PINN Architecture

Network Design

Input Layer: (r, t) -- 2 neurons
    |
Hidden Layer 1: 64 neurons, Tanh activation
    |
Hidden Layer 2: 64 neurons, Tanh activation
    |
Hidden Layer 3: 64 neurons, Tanh activation
    |
Hidden Layer 4: 32 neurons, Tanh activation
    |
Output Layer: P(r, t) -- 1 neuron (bond price)

Loss Function Components

The total loss is a weighted combination of several terms:

L_total = w_pde * L_pde + w_ic * L_ic + w_bc * L_bc + w_data * L_data

1. PDE Residual Loss

# Automatic differentiation to compute partial derivatives
P = network(r, t)
P_t = d(P)/d(t)       # time derivative
P_r = d(P)/d(r)       # rate derivative
P_rr = d^2(P)/d(r^2)  # second rate derivative


# Hull-White PDE residual
residual = P_t + (theta_t - a * r) * P_r + 0.5 * sigma**2 * P_rr - r * P


L_pde = mean(residual^2)

2. Terminal Condition Loss (Initial Condition in backward time)

# At maturity T, bond price must equal 1
P_T = network(r_samples, T)
L_ic = mean((P_T - 1.0)^2)

3. Boundary Condition Loss

# As r -> +inf, P -> 0 (for finite T)
# As r -> -inf, P -> exp((T-t)*|r|) approximately large
P_high = network(r_max, t_samples)
L_bc = mean(P_high^2)  # force to zero for very high rates

4. Term Structure Fitting Loss

# Match observed market bond prices at t=0
P_market = market_discount_factors  # from observed yield curve
P_model = network(r0, t_maturities)  # model prices at current rate r0
L_data = mean((P_model - P_market)^2)

Training Strategy

  1. Collocation Points: Sample (r, t) pairs from the domain using Latin Hypercube Sampling
  2. Adaptive Weighting: Dynamically adjust loss weights using gradient-based balancing
  3. Curriculum Learning: Start with short maturities, progressively extend to longer ones
  4. Learning Rate Schedule: Cosine annealing with warm restarts
# Collocation point sampling
r_collocation = uniform(-0.05, 0.15, N_pde)      # rate domain
t_collocation = uniform(0, T_max, N_pde)           # time domain
r_terminal = uniform(-0.05, 0.15, N_ic)            # for terminal condition
r_boundary_high = 0.20 * ones(N_bc)                # high rate boundary
t_boundary = uniform(0, T_max, N_bc)               # boundary times

Zero-Coupon Bond Pricing

The Core Problem

A zero-coupon bond pays $1 at maturity T. Its price at time t when the short rate is r is:

P(r, t; T) = E^Q[exp(-integral_t^T r(s) ds) | r(t) = r]

PINN vs Analytical Comparison

import torch
import numpy as np


# Analytical Hull-White bond price
def hw_bond_price_analytical(r, t, T, a, sigma, f0, P0_t, P0_T):
    """
    Analytical Hull-White zero-coupon bond price.


    Parameters:
        r: current short rate
        t: current time
        T: maturity
        a: mean reversion speed
        sigma: volatility
        f0: instantaneous forward rate at time t
        P0_t: market discount factor P(0, t)
        P0_T: market discount factor P(0, T)
    """
    B = (1 - np.exp(-a * (T - t))) / a
    lnA = np.log(P0_T / P0_t) + B * f0 - (sigma**2 / (4 * a)) * (1 - np.exp(-2 * a * t)) * B**2
    A = np.exp(lnA)
    return A * np.exp(-B * r)


# PINN bond price
def hw_bond_price_pinn(model, r, t, T):
    """
    PINN-based bond price prediction.
    """
    r_tensor = torch.tensor([[r]], dtype=torch.float32, requires_grad=True)
    t_tensor = torch.tensor([[t]], dtype=torch.float32)
    T_tensor = torch.tensor([[T]], dtype=torch.float32)
    with torch.no_grad():
        price = model(r_tensor, t_tensor, T_tensor)
    return price.item()

Yield Curve Construction

Given bond prices, we can extract the yield curve:

y(t, T) = -ln(P(r, t; T)) / (T - t)

The PINN naturally produces a smooth yield curve since the neural network output is a continuous function.

Forward Rate Curve

The instantaneous forward rate is:

f(t, T) = -d(ln P(r, t; T)) / dT

With PINNs, this derivative is computed analytically via automatic differentiation:

def forward_rate(model, r, t, T):
    """Compute instantaneous forward rate using autodiff."""
    T_tensor = torch.tensor([[T]], requires_grad=True)
    r_tensor = torch.tensor([[r]])
    t_tensor = torch.tensor([[t]])
    P = model(r_tensor, t_tensor, T_tensor)
    log_P = torch.log(P)
    f = -torch.autograd.grad(log_P, T_tensor, create_graph=True)[0]
    return f.item()

Interest Rate Derivatives

Caps and Floors

An interest rate cap is a series of caplets, each paying:

max(L(T_i, T_{i+1}) - K, 0) * delta * N

where L is the LIBOR/reference rate, K is the strike, delta is the day count fraction, and N is the notional.

Under Hull-White, each caplet can be priced analytically:

def caplet_price_hw(P_t_Ti, P_t_Ti1, K, sigma_p, delta):
    """
    Hull-White caplet price.


    sigma_p = sigma/a * (1 - exp(-a*delta)) * sqrt((1-exp(-2*a*(Ti-t)))/(2*a))
    """
    from scipy.stats import norm
    X = 1 / (1 + K * delta)
    d1 = (np.log(P_t_Ti1 * X / P_t_Ti) / sigma_p + sigma_p / 2)
    d2 = d1 - sigma_p
    return P_t_Ti1 * X * norm.cdf(d1) - P_t_Ti * norm.cdf(d2)

Swaptions

A swaption gives the right to enter an interest rate swap at a future date. Under Hull-White, Jamshidian’s decomposition expresses a swaption as a portfolio of bond options:

def swaption_price_hw(P0, strike_prices, bond_options):
    """
    Jamshidian decomposition for swaption pricing.


    A swaption is decomposed into a portfolio of zero-coupon bond options.
    The key insight: since bond prices are monotonically decreasing in r,
    we can find a single critical rate r* such that the swap value is zero.
    """
    total = sum(bond_options)
    return total

Application to Crypto Lending Rates

Bybit Funding Rates as Short Rate Proxy

Crypto perpetual futures have funding rates that serve as an analog to short-term interest rates:

Funding Rate = Premium Index + clamp(Interest Rate - Premium Index, -0.05%, 0.05%)

These funding rates exhibit:

  • Mean reversion (driven by arbitrage)
  • Stochastic volatility (regime-dependent)
  • Time-varying drift (market sentiment shifts)

This makes the Hull-White framework applicable to crypto markets.

Data Pipeline

import requests


def fetch_bybit_funding_rates(symbol="BTCUSDT", limit=200):
    """Fetch historical funding rates from Bybit."""
    url = "https://api.bybit.com/v5/market/funding/history"
    params = {
        "category": "linear",
        "symbol": symbol,
        "limit": limit
    }
    response = requests.get(url, params=params)
    data = response.json()
    rates = []
    for item in data["result"]["list"]:
        rates.append({
            "timestamp": int(item["fundingRateTimestamp"]),
            "rate": float(item["fundingRate"])
        })
    return rates

Adapting Hull-White to Crypto

For crypto funding rates, we modify the model:

dr(t) = [theta(t) - a * r(t)] dt + sigma * dW(t)

Key differences from traditional interest rates:

  • Higher volatility: sigma is typically 10-100x larger
  • Faster mean reversion: a is larger (rates adjust within hours, not months)
  • Regime changes: theta(t) may exhibit jumps during market stress
  • Negative rates: Frequently observed (short sellers pay longs)

Comparison with Tree-Based Methods

Trinomial Tree

The traditional trinomial tree for Hull-White:

      r + dr_u (up)
     /
r --+-- r + dr_m (mid)
     \
      r + dr_d (down)


Branching probabilities:
p_u = 1/6 + (a*r*dt - theta*dt)^2/(2*sigma^2*dt) + (a*r*dt - theta*dt)/(2*sigma*sqrt(3*dt))
p_m = 2/3 - (a*r*dt - theta*dt)^2/(sigma^2*dt)
p_d = 1/6 + (a*r*dt - theta*dt)^2/(2*sigma^2*dt) - (a*r*dt - theta*dt)/(2*sigma*sqrt(3*dt))

PINN Advantages Over Trees

FeatureTrinomial TreePINN
Grid requiredYes (N time x M rate steps)No (mesh-free)
GreeksFinite differences (noisy)Autodiff (exact)
InterpolationRequired between nodesContinuous by construction
CalibrationSeparate stepIntegrated into training
High dimensionsCurse of dimensionalityScales better
GPU accelerationLimitedNatural
AccuracyO(dt) or O(dt^2)Depends on network capacity

PINN Disadvantages

  • Training time can be significant
  • Convergence not always guaranteed
  • Harder to debug than explicit methods
  • Requires careful hyperparameter tuning

Yield Curve Dynamics and Risk Management

Duration and Convexity from PINNs

With automatic differentiation, we get exact sensitivities:

def compute_greeks(model, r, t, T):
    """Compute bond price sensitivities using autodiff."""
    r_tensor = torch.tensor([[r]], requires_grad=True)
    t_tensor = torch.tensor([[t]], requires_grad=True)


    P = model(r_tensor, t_tensor, torch.tensor([[T]]))


    # Delta (dP/dr) = -Duration * P
    dP_dr = torch.autograd.grad(P, r_tensor, create_graph=True)[0]


    # Gamma (d^2P/dr^2) = Convexity * P
    d2P_dr2 = torch.autograd.grad(dP_dr, r_tensor, create_graph=True)[0]


    # Theta (dP/dt)
    dP_dt = torch.autograd.grad(P, t_tensor, create_graph=True)[0]


    duration = -dP_dr.item() / P.item()
    convexity = d2P_dr2.item() / P.item()
    theta = dP_dt.item()


    return {
        "price": P.item(),
        "duration": duration,
        "convexity": convexity,
        "theta": theta,
        "dP_dr": dP_dr.item(),
        "d2P_dr2": d2P_dr2.item()
    }

Value at Risk (VaR)

Using the Hull-White rate distribution and PINN pricing:

def compute_var(model, r0, t, T, a, sigma, confidence=0.99, horizon=1/252):
    """
    Compute Value at Risk for a bond position.


    Under Hull-White, r(t+h) is normally distributed:
    r(t+h) ~ N(r0*exp(-a*h) + ..., sigma^2/(2a)*(1-exp(-2*a*h)))
    """
    # Rate distribution parameters
    mu_r = r0 * np.exp(-a * horizon)  # simplified (ignoring theta integral)
    var_r = (sigma**2 / (2 * a)) * (1 - np.exp(-2 * a * horizon))
    std_r = np.sqrt(var_r)


    # Shocked rate at confidence level
    from scipy.stats import norm
    r_shock = mu_r + norm.ppf(confidence) * std_r


    # Price impact
    P_current = model(torch.tensor([[r0]]), torch.tensor([[t]]), torch.tensor([[T]])).item()
    P_shocked = model(torch.tensor([[r_shock]]), torch.tensor([[t]]), torch.tensor([[T]])).item()


    var = P_current - P_shocked
    return var

Code Examples

Quick Start: Train and Price

from python.hull_white_pinn import HullWhitePINN
from python.train import train_pinn
from python.analytical import HullWhiteAnalytical


# Model parameters
a = 0.1          # mean reversion speed
sigma = 0.01     # volatility
r0 = 0.03        # current short rate
T_max = 10.0     # maximum maturity (years)


# Create and train PINN
model = HullWhitePINN(
    a=a, sigma=sigma,
    hidden_layers=[64, 64, 64, 32],
    activation='tanh'
)


train_pinn(
    model=model,
    r0=r0, a=a, sigma=sigma, T_max=T_max,
    n_collocation=5000,
    n_boundary=500,
    n_initial=500,
    epochs=5000,
    lr=1e-3
)


# Compare with analytical
hw = HullWhiteAnalytical(a=a, sigma=sigma)
maturities = [0.5, 1.0, 2.0, 5.0, 10.0]


for T in maturities:
    price_pinn = model.predict(r0, 0.0, T)
    price_analytical = hw.bond_price(r0, 0.0, T)
    error = abs(price_pinn - price_analytical)
    print(f"T={T:5.1f}  PINN={price_pinn:.6f}  Analytical={price_analytical:.6f}  Error={error:.2e}")

Yield Curve Visualization

from python.visualize import plot_yield_curve, plot_bond_surface


# Plot yield curve from PINN
plot_yield_curve(
    model=model,
    r0=r0,
    maturities=np.linspace(0.1, 30, 100),
    title="PINN Hull-White Yield Curve"
)


# 3D bond price surface P(r, T)
plot_bond_surface(
    model=model,
    r_range=(-0.02, 0.10),
    T_range=(0.1, 10.0),
    t=0.0
)

Crypto Funding Rate Application

from python.data_loader import load_bybit_funding_rates
from python.calibration import calibrate_hull_white


# Load Bybit funding rate data
rates = load_bybit_funding_rates(symbol="BTCUSDT", days=90)


# Calibrate Hull-White parameters
params = calibrate_hull_white(rates)
print(f"Mean reversion: a={params['a']:.4f}")
print(f"Volatility: sigma={params['sigma']:.6f}")
print(f"Long-run rate: theta/a={params['theta_mean']/params['a']:.6f}")


# Train PINN with crypto parameters
model_crypto = HullWhitePINN(a=params['a'], sigma=params['sigma'])
train_pinn(model_crypto, r0=rates[-1], a=params['a'], sigma=params['sigma'], T_max=1.0)

Rust Implementation

The Rust implementation provides a high-performance version suitable for production:

use ndarray::{Array1, Array2};


/// Hull-White PINN layer
pub struct PINNLayer {
    weights: Array2<f64>,
    biases: Array1<f64>,
}


/// Hull-White PINN model
pub struct HullWhitePINN {
    layers: Vec<PINNLayer>,
    a: f64,      // mean reversion
    sigma: f64,  // volatility
}


impl HullWhitePINN {
    pub fn predict(&self, r: f64, t: f64, maturity: f64) -> f64 {
        // Forward pass through network
        let input = Array1::from_vec(vec![r, t, maturity]);
        let mut x = input;
        for (i, layer) in self.layers.iter().enumerate() {
            x = layer.weights.dot(&x) + &layer.biases;
            if i < self.layers.len() - 1 {
                x.mapv_inplace(|v| v.tanh()); // Tanh activation
            }
        }
        x[0].max(0.0) // Bond price must be non-negative
    }
}

Performance Benchmarks

Training Performance

ConfigurationTime (s)Final PDE LossMax Price Error
2-layer, 32 hidden452.3e-41.2e-3
3-layer, 64 hidden1208.7e-63.4e-5
4-layer, 64 hidden2102.1e-68.9e-6
4-layer, 128 hidden3805.4e-72.1e-6

Pricing Speed (per bond price)

MethodCPU (us)GPU (us)
Analytical0.5N/A
Trinomial Tree (100 steps)150N/A
PINN (single)120.8
PINN (batch 1000)351.2

The PINN excels at batch pricing since all prices can be computed in a single forward pass.

Summary

Key Takeaways

  1. Hull-White is the gold standard for single-factor short rate models, offering analytical tractability and exact term structure fitting
  2. PINNs embed the PDE directly into the loss function, ensuring physical consistency
  3. Automatic differentiation provides exact Greeks without finite differences
  4. Mesh-free approach avoids discretization artifacts
  5. Crypto funding rates exhibit mean-reverting behavior suitable for Hull-White modeling
  6. Batch pricing on GPUs gives PINNs a speed advantage for large portfolios

When to Use This Approach

  • Use PINNs when you need: batch pricing, smooth Greeks, flexible extensions, GPU acceleration
  • Use analytical when you need: single-price speed, guaranteed convergence, interpretability
  • Use trees when you need: path-dependent products, early exercise features, simplicity

Further Reading

  • Hull, J. & White, A. (1990). “Pricing Interest-Rate-Derivative Securities”
  • Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). “Physics-Informed Neural Networks”
  • Brigo, D. & Mercurio, F. (2006). “Interest Rate Models - Theory and Practice”
  • Jamshidian, F. (1989). “An Exact Bond Option Formula”

File Structure

145_pinn_hull_white_rates/
├── README.md                      # This file
├── README.ru.md                   # Russian translation
├── readme.simple.md               # Simple explanation (English)
├── readme.simple.ru.md            # Simple explanation (Russian)
├── python/
│   ├── __init__.py
│   ├── requirements.txt
│   ├── hull_white_pinn.py         # PINN architecture
│   ├── train.py                   # Training loop
│   ├── data_loader.py             # Treasury + Bybit data
│   ├── analytical.py              # Analytical pricing
│   ├── calibration.py             # Model calibration
│   ├── derivatives.py             # Caps, floors, swaptions
│   ├── visualize.py               # Plotting functions
│   └── backtest.py                # Interest rate strategy
└── rust_pinn_hw/
    ├── Cargo.toml
    ├── src/
    │   ├── lib.rs                 # Core PINN implementation
    │   └── bin/
    │       ├── train.rs           # Training binary
    │       ├── price_bonds.rs     # Bond pricing binary
    │       └── fetch_data.rs      # Data fetching binary
    └── examples/
        ├── basic_pricing.rs       # Basic bond pricing example
        └── yield_curve.rs         # Yield curve construction