Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| import pandas as pd | |
| from scipy.stats import norm | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| class HullWhiteModel: | |
| """Hull-White Interest Rate Model Implementation""" | |
| def __init__(self, scen_size=1000, time_len=30, step_size=360, a=0.1, sigma=0.1, r0=0.05): | |
| self.scen_size = scen_size | |
| self.time_len = time_len | |
| self.step_size = step_size | |
| self.a = a | |
| self.sigma = sigma | |
| self.r0 = r0 | |
| self.dt = time_len / step_size | |
| # Generate time grid | |
| self.t = np.linspace(0, time_len, step_size + 1) | |
| # Market forward rates (constant for simplicity) | |
| self.mkt_fwd = np.full(step_size + 1, r0) | |
| # Market zero-coupon bond prices | |
| self.mkt_zcb = np.exp(-self.mkt_fwd * self.t) | |
| # Alpha function | |
| self.alpha = self._calculate_alpha() | |
| # Generate random numbers | |
| np.random.seed(42) # For reproducibility | |
| self.random_normal = np.random.standard_normal((scen_size, step_size)) | |
| def _calculate_alpha(self): | |
| """Calculate alpha(t) = f^M(0,t) + sigma^2/(2*a^2) * (1-exp(-a*t))^2""" | |
| return self.mkt_fwd + (self.sigma**2 / (2 * self.a**2)) * (1 - np.exp(-self.a * self.t))**2 | |
| def simulate_short_rates(self): | |
| """Simulate short rate paths using Hull-White model""" | |
| r_paths = np.zeros((self.scen_size, self.step_size + 1)) | |
| r_paths[:, 0] = self.r0 | |
| for i in range(1, self.step_size + 1): | |
| # Calculate conditional mean | |
| exp_factor = np.exp(-self.a * self.dt) | |
| mean_r = r_paths[:, i-1] * exp_factor + self.alpha[i] - self.alpha[i-1] * exp_factor | |
| # Calculate conditional variance | |
| var_r = (self.sigma**2 / (2 * self.a)) * (1 - np.exp(-2 * self.a * self.dt)) | |
| std_r = np.sqrt(var_r) | |
| # Generate next step | |
| r_paths[:, i] = mean_r + std_r * self.random_normal[:, i-1] | |
| return r_paths | |
| def calculate_discount_factors(self, r_paths): | |
| """Calculate discount factors from short rate paths""" | |
| # Accumulate short rates (discrete approximation of integral) | |
| accum_rates = np.zeros_like(r_paths) | |
| for i in range(1, self.step_size + 1): | |
| accum_rates[:, i] = accum_rates[:, i-1] + r_paths[:, i-1] * self.dt | |
| # Calculate discount factors | |
| discount_factors = np.exp(-accum_rates) | |
| return discount_factors | |
| def theoretical_mean_short_rate(self): | |
| """Calculate theoretical mean of short rates E[r(t)|F_0]""" | |
| return self.r0 * np.exp(-self.a * self.t) + self.alpha - self.alpha[0] * np.exp(-self.a * self.t) | |
| def theoretical_var_short_rate(self): | |
| """Calculate theoretical variance of short rates Var[r(t)|F_0]""" | |
| return (self.sigma**2 / (2 * self.a)) * (1 - np.exp(-2 * self.a * self.t)) | |
| def create_short_rate_plot(scen_size, time_len, step_size, a, sigma, r0, num_paths): | |
| """Create short rate simulation plot""" | |
| model = HullWhiteModel(scen_size, time_len, step_size, a, sigma, r0) | |
| r_paths = model.simulate_short_rates() | |
| fig, ax = plt.subplots(figsize=(12, 8)) | |
| # Plot first num_paths scenarios | |
| for i in range(min(num_paths, scen_size)): | |
| ax.plot(model.t, r_paths[i], alpha=0.7, linewidth=1) | |
| ax.set_xlabel('Time (years)') | |
| ax.set_ylabel('Short Rate') | |
| ax.set_title(f'Hull-White Short Rate Simulation ({num_paths} paths)\na={a}, σ={sigma}, scenarios={scen_size}') | |
| ax.grid(True, alpha=0.3) | |
| return fig | |
| def create_convergence_plot(scen_size, time_len, step_size, a, sigma, r0): | |
| """Create mean convergence plot""" | |
| model = HullWhiteModel(scen_size, time_len, step_size, a, sigma, r0) | |
| r_paths = model.simulate_short_rates() | |
| # Calculate simulated means and theoretical expectations | |
| simulated_mean = np.mean(r_paths, axis=0) | |
| theoretical_mean = model.theoretical_mean_short_rate() | |
| fig, ax = plt.subplots(figsize=(12, 8)) | |
| ax.plot(model.t, theoretical_mean, 'b-', linewidth=2, label='Theoretical E[r(t)]') | |
| ax.plot(model.t, simulated_mean, 'r--', linewidth=2, label='Simulated Mean') | |
| ax.set_xlabel('Time (years)') | |
| ax.set_ylabel('Short Rate') | |
| ax.set_title(f'Mean Convergence Analysis\na={a}, σ={sigma}, scenarios={scen_size}') | |
| ax.legend() | |
| ax.grid(True, alpha=0.3) | |
| return fig | |
| def create_variance_plot(scen_size, time_len, step_size, a, sigma, r0): | |
| """Create variance convergence plot""" | |
| model = HullWhiteModel(scen_size, time_len, step_size, a, sigma, r0) | |
| r_paths = model.simulate_short_rates() | |
| # Calculate simulated variance and theoretical variance | |
| simulated_var = np.var(r_paths, axis=0) | |
| theoretical_var = model.theoretical_var_short_rate() | |
| fig, ax = plt.subplots(figsize=(12, 8)) | |
| ax.plot(model.t, theoretical_var, 'b-', linewidth=2, label='Theoretical Var[r(t)]') | |
| ax.plot(model.t, simulated_var, 'r--', linewidth=2, label='Simulated Variance') | |
| ax.set_xlabel('Time (years)') | |
| ax.set_ylabel('Variance') | |
| ax.set_title(f'Variance Convergence Analysis\na={a}, σ={sigma}, scenarios={scen_size}') | |
| ax.legend() | |
| ax.grid(True, alpha=0.3) | |
| return fig | |
| def create_discount_factor_plot(scen_size, time_len, step_size, a, sigma, r0): | |
| """Create discount factor convergence plot""" | |
| model = HullWhiteModel(scen_size, time_len, step_size, a, sigma, r0) | |
| r_paths = model.simulate_short_rates() | |
| discount_factors = model.calculate_discount_factors(r_paths) | |
| # Calculate mean discount factors | |
| mean_discount = np.mean(discount_factors, axis=0) | |
| fig, ax = plt.subplots(figsize=(12, 8)) | |
| ax.plot(model.t, model.mkt_zcb, 'b-', linewidth=2, label='Market Zero-Coupon Bonds') | |
| ax.plot(model.t, mean_discount, 'r--', linewidth=2, label='Simulated Mean Discount Factor') | |
| ax.set_xlabel('Time (years)') | |
| ax.set_ylabel('Discount Factor') | |
| ax.set_title(f'Discount Factor Convergence\na={a}, σ={sigma}, σ/a={sigma/a:.2f}, scenarios={scen_size}') | |
| ax.legend() | |
| ax.grid(True, alpha=0.3) | |
| return fig | |
| def create_parameter_sensitivity_plot(base_scen_size, time_len, step_size, base_a, base_sigma, r0, vary_param): | |
| """Create parameter sensitivity analysis""" | |
| fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 12)) | |
| fig.suptitle(f'Parameter Sensitivity Analysis - Varying {vary_param}', fontsize=16) | |
| if vary_param == "sigma": | |
| param_values = [0.05, 0.075, 0.1, 0.125] | |
| base_param = base_a | |
| param_label = "σ" | |
| base_label = f"a={base_a}" | |
| else: # vary a | |
| param_values = [0.05, 0.1, 0.15, 0.2] | |
| base_param = base_sigma | |
| param_label = "a" | |
| base_label = f"σ={base_sigma}" | |
| axes = [ax1, ax2, ax3, ax4] | |
| for i, param_val in enumerate(param_values): | |
| if vary_param == "sigma": | |
| model = HullWhiteModel(base_scen_size, time_len, step_size, base_a, param_val, r0) | |
| ratio = param_val / base_a | |
| else: | |
| model = HullWhiteModel(base_scen_size, time_len, step_size, param_val, base_sigma, r0) | |
| ratio = base_sigma / param_val | |
| r_paths = model.simulate_short_rates() | |
| discount_factors = model.calculate_discount_factors(r_paths) | |
| mean_discount = np.mean(discount_factors, axis=0) | |
| axes[i].plot(model.t, model.mkt_zcb, 'b-', linewidth=2, label='Market ZCB') | |
| axes[i].plot(model.t, mean_discount, 'r--', linewidth=2, label='Simulated Mean') | |
| axes[i].set_title(f'{param_label}={param_val}, σ/a={ratio:.2f}') | |
| axes[i].grid(True, alpha=0.3) | |
| axes[i].legend() | |
| return fig | |
| def generate_statistics_table(scen_size, time_len, step_size, a, sigma, r0): | |
| """Generate summary statistics table""" | |
| model = HullWhiteModel(scen_size, time_len, step_size, a, sigma, r0) | |
| r_paths = model.simulate_short_rates() | |
| # Calculate statistics at key time points | |
| time_points = [0, int(step_size*0.25), int(step_size*0.5), int(step_size*0.75), step_size] | |
| times = [model.t[i] for i in time_points] | |
| stats_data = [] | |
| for i, t_idx in enumerate(time_points): | |
| rates_at_t = r_paths[:, t_idx] | |
| theoretical_mean = model.theoretical_mean_short_rate()[t_idx] | |
| theoretical_var = model.theoretical_var_short_rate()[t_idx] | |
| stats_data.append({ | |
| 'Time': f'{times[i]:.1f}', | |
| 'Simulated Mean': f'{np.mean(rates_at_t):.4f}', | |
| 'Theoretical Mean': f'{theoretical_mean:.4f}', | |
| 'Mean Error': f'{abs(np.mean(rates_at_t) - theoretical_mean):.4f}', | |
| 'Simulated Std': f'{np.std(rates_at_t):.4f}', | |
| 'Theoretical Std': f'{np.sqrt(theoretical_var):.4f}', | |
| 'Std Error': f'{abs(np.std(rates_at_t) - np.sqrt(theoretical_var)):.4f}' | |
| }) | |
| return pd.DataFrame(stats_data) | |
| # Create Gradio interface | |
| with gr.Blocks(title="Hull-White Interest Rate Model Dashboard") as demo: | |
| gr.Markdown(""" | |
| # 📊 Hull-White Interest Rate Model Dashboard | |
| This interactive dashboard allows actuaries and financial professionals to explore the Hull-White short rate model: | |
| **$$dr(t) = (θ(t) - ar(t))dt + σdW$$** | |
| Adjust the parameters below to see how they affect the interest rate simulations and convergence properties. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### Model Parameters") | |
| scen_size = gr.Slider(100, 10000, value=1000, step=100, label="Number of Scenarios") | |
| time_len = gr.Slider(5, 50, value=30, step=5, label="Time Horizon (years)") | |
| step_size = gr.Slider(100, 500, value=360, step=60, label="Number of Time Steps") | |
| a = gr.Slider(0.01, 0.5, value=0.1, step=0.01, label="Mean Reversion Speed (a)") | |
| sigma = gr.Slider(0.01, 0.3, value=0.1, step=0.01, label="Volatility (σ)") | |
| r0 = gr.Slider(0.01, 0.15, value=0.05, step=0.01, label="Initial Rate (r₀)") | |
| gr.Markdown("### Display Options") | |
| num_paths = gr.Slider(1, 50, value=10, step=1, label="Number of Paths to Display") | |
| with gr.Row(): | |
| vary_param = gr.Radio(["sigma", "a"], value="sigma", label="Parameter Sensitivity Analysis") | |
| with gr.Column(scale=2): | |
| with gr.Tabs(): | |
| with gr.TabItem("Short Rate Paths"): | |
| short_rate_plot = gr.Plot(label="Short Rate Simulation") | |
| with gr.TabItem("Mean Convergence"): | |
| convergence_plot = gr.Plot(label="Mean Convergence Analysis") | |
| with gr.TabItem("Variance Convergence"): | |
| variance_plot = gr.Plot(label="Variance Convergence Analysis") | |
| with gr.TabItem("Discount Factors"): | |
| discount_plot = gr.Plot(label="Discount Factor Analysis") | |
| with gr.TabItem("Parameter Sensitivity"): | |
| sensitivity_plot = gr.Plot(label="Parameter Sensitivity Analysis") | |
| with gr.TabItem("Statistics"): | |
| stats_table = gr.Dataframe(label="Summary Statistics") | |
| gr.Markdown(""" | |
| ### About the Hull-White Model | |
| - **Mean Reversion Speed (a)**: Controls how quickly rates revert to the long-term mean | |
| - **Volatility (σ)**: Controls the randomness in rate movements | |
| - **σ/a Ratio**: Key parameter for convergence - ratios > 1 show poor convergence | |
| - **Scenarios**: More scenarios improve Monte Carlo convergence but increase computation time | |
| **Model Features:** | |
| - Gaussian short rate process | |
| - Analytical formulas for conditional moments | |
| - Market-consistent calibration capability | |
| - Monte Carlo simulation for complex derivatives | |
| """) | |
| # Update all plots when parameters change | |
| inputs = [scen_size, time_len, step_size, a, sigma, r0] | |
| # Connect inputs to outputs | |
| for inp in inputs + [num_paths]: | |
| inp.change( | |
| fn=create_short_rate_plot, | |
| inputs=inputs + [num_paths], | |
| outputs=short_rate_plot | |
| ) | |
| for inp in inputs: | |
| inp.change( | |
| fn=create_convergence_plot, | |
| inputs=inputs, | |
| outputs=convergence_plot | |
| ) | |
| inp.change( | |
| fn=create_variance_plot, | |
| inputs=inputs, | |
| outputs=variance_plot | |
| ) | |
| inp.change( | |
| fn=create_discount_factor_plot, | |
| inputs=inputs, | |
| outputs=discount_plot | |
| ) | |
| inp.change( | |
| fn=generate_statistics_table, | |
| inputs=inputs, | |
| outputs=stats_table | |
| ) | |
| # Parameter sensitivity updates | |
| for inp in inputs[:-1] + [vary_param]: # Exclude r0 from base params for sensitivity | |
| inp.change( | |
| fn=create_parameter_sensitivity_plot, | |
| inputs=[scen_size, time_len, step_size, a, sigma, r0, vary_param], | |
| outputs=sensitivity_plot | |
| ) | |
| # Initialize plots on load | |
| demo.load( | |
| fn=create_short_rate_plot, | |
| inputs=inputs + [num_paths], | |
| outputs=short_rate_plot | |
| ) | |
| demo.load( | |
| fn=create_convergence_plot, | |
| inputs=inputs, | |
| outputs=convergence_plot | |
| ) | |
| demo.load( | |
| fn=create_variance_plot, | |
| inputs=inputs, | |
| outputs=variance_plot | |
| ) | |
| demo.load( | |
| fn=create_discount_factor_plot, | |
| inputs=inputs, | |
| outputs=discount_plot | |
| ) | |
| demo.load( | |
| fn=create_parameter_sensitivity_plot, | |
| inputs=[scen_size, time_len, step_size, a, sigma, r0, vary_param], | |
| outputs=sensitivity_plot | |
| ) | |
| demo.load( | |
| fn=generate_statistics_table, | |
| inputs=inputs, | |
| outputs=stats_table | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch() |