Create app.py

app.py

@@ -0,0 +1,368 @@
+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()