Module 17: Risk Management & Stress Testing

Introduction: Quantifying the Worst That Could Happen

Risk management is applied statistics with life-or-death stakes. The 2008 financial crisis was, at its core, a failure of risk measurement: institutions vastly underestimated the probability and magnitude of extreme losses. As a statistician, you already have the mathematical toolkit — distributions, quantiles, tail behavior, simulation. This module shows how that toolkit is deployed to answer the most important question in finance: how much could we lose?

1. Value at Risk (VaR): The Industry Standard

1.1 Definition

Value at Risk answers the question: “What is the maximum loss we expect over a given time horizon, at a given confidence level?”

1.2 VaR Parameters

2. Historical Simulation VaR

2.1 Method

The simplest VaR approach: use the empirical distribution of historical returns and take the α-quantile directly. No distributional assumptions required.

1. Collect the last N daily returns (e.g., N = 500).
2. Sort them from worst to best.
3. The VaR at confidence level (1 − α) is the α·N-th worst return.

2.2 Pros and Cons

3. Parametric (Analytical) VaR

3.1 Normal Distribution VaR

Assume returns follow a normal distribution with mean μ and standard deviation σ:

3.2 Student-t Distribution VaR

The normal distribution underestimates tail risk. The Student-t distribution, with its heavier tails controlled by the degrees-of-freedom parameter ν, provides a better fit:

Typical estimates for daily equity returns give ν ≈ 4–6, meaning tails are dramatically heavier than the normal distribution.

3.3 Impact of Distributional Assumptions

4. Monte Carlo VaR

4.1 The Simulation Approach

Monte Carlo VaR generates thousands (or millions) of possible future scenarios by simulating from a model, then takes the quantile of the simulated loss distribution.

1. Specify a model for portfolio returns (e.g., multivariate normal, GARCH, copula).
2. Estimate model parameters from historical data.
3. Simulate N scenarios (e.g., N = 100,000) from the fitted model.
4. Compute portfolio loss for each scenario.
5. Take the α-quantile of the simulated losses.

4.2 Advantages of Monte Carlo

• Flexibility: Can incorporate any model — fat tails, asymmetry, time-varying volatility, copula dependence.
• Non-linear portfolios: Essential for portfolios with options, where losses are non-linear functions of underlying risk factors.
• Extrapolation: Can generate scenarios more extreme than historical experience.
• Full distribution: Produces the entire loss distribution, not just a single quantile.

4.3 Precision and Computational Cost

where f is the density at the VaR quantile and n is the number of simulations. For α = 0.01 (99% VaR), you need approximately 100,000 simulations to get stable estimates. For α = 0.001 (99.9%), you need millions.

5. Expected Shortfall (CVaR): Beyond VaR

5.1 The Limitation of VaR

VaR tells you the threshold of extreme losses, but nothing about what happens beyond that threshold. Two portfolios can have the same VaR but vastly different tail risk profiles. Expected Shortfall addresses this by averaging the losses in the tail.

5.2 VaR vs Expected Shortfall

6. Coherent Risk Measures

6.1 The Axioms

Artzner et al. (1999) proposed four axioms that a “sensible” risk measure ρ should satisfy:

7. Python: Computing VaR and ES All Three Ways

Python
import numpy as np
import pandas as pd
from scipy import stats
import yfinance as yf

# Download portfolio data
tickers = ["SPY", "TLT", "GLD"]
weights = np.array([0.6, 0.3, 0.1])  # 60/30/10 portfolio
data = yf.download(tickers, start="2010-01-01", end="2023-12-31")
returns = data["Adj Close"].pct_change().dropna()

# Portfolio returns
port_returns = (returns * weights).sum(axis=1)
portfolio_value = 1_000_000  # $1M portfolio
alpha = 0.01  # 99% confidence

# ──────────────────────────────────────────────
# METHOD 1: Historical Simulation
# ──────────────────────────────────────────────
var_hist = -np.percentile(port_returns, alpha * 100)
# ES: average of returns below the VaR threshold
tail_returns = port_returns[port_returns <= -var_hist]
es_hist = -tail_returns.mean()

print("=== Historical Simulation ===")
print(f"99% VaR: {var_hist:.4%} (${var_hist * portfolio_value:,.0f})")
print(f"99% ES:  {es_hist:.4%} (${es_hist * portfolio_value:,.0f})")

# ──────────────────────────────────────────────
# METHOD 2: Parametric (Normal and Student-t)
# ──────────────────────────────────────────────
mu = port_returns.mean()
sigma = port_returns.std()

# Normal
var_norm = -(mu + sigma * stats.norm.ppf(alpha))
es_norm = -(mu - sigma * stats.norm.pdf(stats.norm.ppf(alpha)) / alpha)

# Student-t (fit degrees of freedom)
nu, loc, scale = stats.t.fit(port_returns)
var_t = -(loc + scale * stats.t.ppf(alpha, nu))
# ES for Student-t
t_pdf_at_var = stats.t.pdf(stats.t.ppf(alpha, nu), nu)
es_t = -(loc - scale * (t_pdf_at_var / alpha) * (nu + stats.t.ppf(alpha, nu)**2) / (nu - 1))

print("\n=== Parametric (Normal) ===")
print(f"99% VaR: {var_norm:.4%} (${var_norm * portfolio_value:,.0f})")
print(f"99% ES:  {es_norm:.4%} (${es_norm * portfolio_value:,.0f})")

print(f"\n=== Parametric (Student-t, nu={nu:.1f}) ===")
print(f"99% VaR: {var_t:.4%} (${var_t * portfolio_value:,.0f})")
print(f"99% ES:  {es_t:.4%} (${es_t * portfolio_value:,.0f})")

# ──────────────────────────────────────────────
# METHOD 3: Monte Carlo Simulation
# ──────────────────────────────────────────────
n_simulations = 100_000

# Simulate from fitted Student-t
np.random.seed(42)
simulated_returns = stats.t.rvs(nu, loc=loc, scale=scale, size=n_simulations)

var_mc = -np.percentile(simulated_returns, alpha * 100)
es_mc = -simulated_returns[simulated_returns <= -var_mc].mean()

print("\n=== Monte Carlo (100K simulations) ===")
print(f"99% VaR: {var_mc:.4%} (${var_mc * portfolio_value:,.0f})")
print(f"99% ES:  {es_mc:.4%} (${es_mc * portfolio_value:,.0f})")

# ──────────────────────────────────────────────
# Comparison summary
# ──────────────────────────────────────────────
summary = pd.DataFrame({
    "Historical": [var_hist, es_hist],
    "Normal": [var_norm, es_norm],
    "Student-t": [var_t, es_t],
    "Monte Carlo": [var_mc, es_mc],
}, index=["99% VaR", "99% ES"])

print("\n=== Summary (as % of portfolio) ===")
print((summary * 100).round(3))

8. Stress Testing: Beyond Statistical Models

8.1 The Philosophy

VaR and ES assume that the future resembles the past (through either historical data or fitted distributions). Stress testing asks a different question: what if something truly extreme happens? Stress tests apply specific hypothetical or historical scenarios to the portfolio and compute the resulting loss.

8.2 Types of Stress Tests

8.3 Python: Stress Testing a Portfolio

Python
import numpy as np
import pandas as pd

# Current portfolio: 60% stocks, 30% bonds, 10% gold
weights = {"Equities": 0.60, "Bonds": 0.30, "Gold": 0.10}
portfolio_value = 1_000_000

# Historical crisis scenarios (approximate peak-to-trough moves)
scenarios = {
    "2008 GFC": {"Equities": -0.50, "Bonds": 0.20, "Gold": 0.05},
    "2020 COVID Crash": {"Equities": -0.34, "Bonds": 0.15, "Gold": -0.03},
    "2022 Rate Hikes": {"Equities": -0.25, "Bonds": -0.18, "Gold": 0.00},
    "Dot-Com Bust 2000": {"Equities": -0.45, "Bonds": 0.10, "Gold": -0.05},
    "Hypothetical: Stagflation": {"Equities": -0.30, "Bonds": -0.15, "Gold": 0.25},
    "Hypothetical: Everything Crash": {"Equities": -0.40, "Bonds": -0.20, "Gold": -0.10},
}

print(f"Portfolio: ${portfolio_value:,.0f}")
print(f"Weights: {weights}\n")

results = []
for scenario_name, shocks in scenarios.items():
    port_return = sum(weights[asset] * shocks[asset] for asset in weights)
    dollar_loss = port_return * portfolio_value
    results.append({
        "Scenario": scenario_name,
        "Equities": f"{shocks['Equities']:+.0%}",
        "Bonds": f"{shocks['Bonds']:+.0%}",
        "Gold": f"{shocks['Gold']:+.0%}",
        "Portfolio Return": f"{port_return:+.1%}",
        "Dollar P&L": f"${dollar_loss:+,.0f}",
    })

stress_df = pd.DataFrame(results)
print(stress_df.to_string(index=False))

9. Extreme Value Theory (EVT): Modeling Only the Tails

9.1 Why EVT?

Standard distributions model the entire return distribution, but risk management cares primarily about the tails. Extreme Value Theory provides a rigorous framework for modeling only the extreme observations, using distributions justified by mathematical limit theorems (analogous to how the CLT justifies using the normal distribution for means).

9.2 Two Approaches

9.3 The Generalized Pareto Distribution

The shape parameter ξ determines the tail behavior:

9.4 Choosing the Threshold

The threshold u is the key modeling choice in POT. Too low: you include non-extreme observations, violating the GPD assumption. Too high: you have too few exceedances for reliable estimation. Diagnostic tools include:

• Mean Excess Plot: Plot E[X − u | X > u] vs u. Should be approximately linear for GPD data.
• Parameter stability plot: Estimate GPD parameters for a range of thresholds. The parameters should stabilize above the correct threshold.
• Rule of thumb: Use the 90th–95th percentile of losses as the threshold.

9.5 Python: Fitting GPD to Portfolio Losses

Python
import numpy as np
import pandas as pd
from scipy import stats
import matplotlib.pyplot as plt

# Use portfolio returns from earlier
losses = -port_returns  # Convention: positive losses

# Step 1: Choose threshold (90th percentile of losses)
threshold = losses.quantile(0.90)
exceedances = losses[losses > threshold] - threshold
n_total = len(losses)
n_exceed = len(exceedances)

print(f"Threshold: {threshold:.4%}")
print(f"Exceedances: {n_exceed} out of {n_total} ({n_exceed/n_total:.1%})")

# Step 2: Fit GPD to exceedances
xi, loc, beta = stats.genpareto.fit(exceedances, floc=0)
print(f"GPD parameters: xi={xi:.4f}, beta={beta:.6f}")
print(f"Tail index xi={xi:.4f}: {'Heavy tail' if xi > 0 else 'Thin tail'}")

# Step 3: Compute VaR and ES using GPD
def gpd_var(alpha, n_total, n_exceed, threshold, xi, beta):
    """VaR from GPD tail estimate."""
    p_exceed = n_exceed / n_total
    return threshold + (beta / xi) * ((alpha / p_exceed)**(-xi) - 1)

def gpd_es(var_alpha, xi, beta, threshold):
    """ES from GPD tail estimate."""
    return var_alpha / (1 - xi) + (beta - xi * threshold) / (1 - xi)

for alpha in [0.05, 0.01, 0.005, 0.001]:
    var_gpd = gpd_var(alpha, n_total, n_exceed, threshold, xi, beta)
    es_gpd = gpd_es(var_gpd, xi, beta, threshold)
    print(f"{1-alpha:.1%} VaR (GPD): {var_gpd:.4%}  |  ES: {es_gpd:.4%}")

# Step 4: Mean Excess Plot
thresholds = np.linspace(losses.quantile(0.70), losses.quantile(0.98), 50)
mean_excess = [losses[losses > u].mean() - u for u in thresholds]

plt.figure(figsize=(10, 5))
plt.plot(thresholds * 100, mean_excess, "b.-")
plt.axvline(x=threshold * 100, color="red", linestyle="--",
            label=f"Chosen threshold ({threshold:.2%})")
plt.xlabel("Threshold (%)")
plt.ylabel("Mean Excess (%)")
plt.title("Mean Excess Plot (should be ~linear above good threshold)")
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

10. The Basel Regulatory Framework

10.1 Why Regulation Matters

Banks are required by regulators to hold capital reserves proportional to their risk. The Basel framework (Basel Committee on Banking Supervision) specifies how banks must measure and report risk. Understanding Basel is essential because it determines which statistical methods are mandated by law.

10.2 Evolution of Basel Risk Measures

10.3 Backtesting VaR Models

Regulators require banks to backtest their VaR models by comparing predicted VaR to realized losses. If actual losses exceed VaR more often than expected (more than 1% of the time for 99% VaR), the model is penalized and the bank must hold more capital.

11. Chapter Summary