Update app.py

app.py

@@ -4,15 +4,6 @@ import numpy as np
 from numpy.random import default_rng
 import io  # For BytesIO to handle file in memory
 import matplotlib.pyplot as plt
-import seaborn as sns
-from scipy import stats
-import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-
-# Set style for matplotlib
-plt.style.use('default')
-sns.set_palette("husl")
 
 # 1. Data Generation Function (customizable via UI filters)
 def generate_custom_model_points(
@@ -64,6 +55,7 @@ def generate_custom_model_points(
     # And ensure it's at least 1
     duration_mth_col = np.maximum(1, duration_mth_col)
 
+
     # Policy Count
     if policy_count_fixed_val:
         policy_count_col_val = np.ones(mp_count_val, dtype=int)
@@ -95,113 +87,84 @@ def generate_summary_statistics(df):
     numerical_cols = ['age_at_entry', 'policy_term', 'policy_count', 'sum_assured', 'duration_mth']
     summary_stats = df[numerical_cols].describe().round(2)
     
-    # Add additional statistics
-    additional_stats = pd.DataFrame({
-        'age_at_entry': [df['age_at_entry'].mode()[0], df['age_at_entry'].var()],
-        'policy_term': [df['policy_term'].mode()[0], df['policy_term'].var()],
-        'policy_count': [df['policy_count'].mode()[0], df['policy_count'].var()],
-        'sum_assured': [df['sum_assured'].mode()[0], df['sum_assured'].var()],
-        'duration_mth': [df['duration_mth'].mode()[0], df['duration_mth'].var()]
-    }, index=['mode', 'variance']).round(2)
-    
-    summary_stats = pd.concat([summary_stats, additional_stats])
     return summary_stats
 
-def create_distribution_plots(df):
-    """Create distribution plots with normal curve overlay."""
+def create_age_distribution_plot(df):
+    """Create age distribution plot with normal curve overlay."""
     if df is None or df.empty:
-        return None, None, None
+        return None
     
-    # Age distribution with normal curve
-    fig_age = plt.figure(figsize=(10, 6))
+    plt.figure(figsize=(10, 6))
     
-    # Histogram
-    plt.hist(df['age_at_entry'], bins=20, density=True, alpha=0.7, color='skyblue', edgecolor='black')
+    # Create histogram
+    n, bins, patches = plt.hist(df['age_at_entry'], bins=20, density=True, alpha=0.7, color='skyblue', edgecolor='black')
     
-    # Normal curve overlay
+    # Calculate normal curve
     age_mean = df['age_at_entry'].mean()
     age_std = df['age_at_entry'].std()
-    x_age = np.linspace(df['age_at_entry'].min(), df['age_at_entry'].max(), 100)
-    y_age = stats.norm.pdf(x_age, age_mean, age_std)
-    plt.plot(x_age, y_age, 'r-', linewidth=2, label=f'Normal Curve (μ={age_mean:.1f}, σ={age_std:.1f})')
+    x = np.linspace(df['age_at_entry'].min(), df['age_at_entry'].max(), 100)
     
-    plt.title('Age at Entry Distribution with Normal Curve Overlay', fontsize=14, fontweight='bold')
+    # Manual normal distribution calculation
+    y = (1 / (age_std * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - age_mean) / age_std) ** 2)
+    
+    plt.plot(x, y, 'r-', linewidth=2, label=f'Normal Curve (μ={age_mean:.1f}, σ={age_std:.1f})')
+    
+    plt.title('Age at Entry Distribution with Normal Curve Overlay')
     plt.xlabel('Age at Entry')
     plt.ylabel('Density')
     plt.legend()
     plt.grid(True, alpha=0.3)
     plt.tight_layout()
     
-    # Sum Assured distribution with normal curve
-    fig_sa = plt.figure(figsize=(10, 6))
+    return plt.gcf()
+
+def create_sum_assured_plot(df):
+    """Create sum assured distribution plot with normal curve overlay."""
+    if df is None or df.empty:
+        return None
+    
+    plt.figure(figsize=(10, 6))
     
-    # Histogram
+    # Create histogram
     plt.hist(df['sum_assured'], bins=30, density=True, alpha=0.7, color='lightgreen', edgecolor='black')
     
-    # Normal curve overlay
+    # Calculate normal curve
     sa_mean = df['sum_assured'].mean()
     sa_std = df['sum_assured'].std()
-    x_sa = np.linspace(df['sum_assured'].min(), df['sum_assured'].max(), 100)
-    y_sa = stats.norm.pdf(x_sa, sa_mean, sa_std)
-    plt.plot(x_sa, y_sa, 'r-', linewidth=2, label=f'Normal Curve (μ=${sa_mean:,.0f}, σ=${sa_std:,.0f})')
+    x = np.linspace(df['sum_assured'].min(), df['sum_assured'].max(), 100)
+    
+    # Manual normal distribution calculation
+    y = (1 / (sa_std * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - sa_mean) / sa_std) ** 2)
     
-    plt.title('Sum Assured Distribution with Normal Curve Overlay', fontsize=14, fontweight='bold')
+    plt.plot(x, y, 'r-', linewidth=2, label=f'Normal Curve (μ=${sa_mean:,.0f}, σ=${sa_std:,.0f})')
+    
+    plt.title('Sum Assured Distribution with Normal Curve Overlay')
     plt.xlabel('Sum Assured ($)')
     plt.ylabel('Density')
     plt.legend()
     plt.grid(True, alpha=0.3)
-    plt.gca().xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
-    plt.tight_layout()
     
-    # Duration distribution
-    fig_duration = plt.figure(figsize=(10, 6))
+    # Format x-axis to show currency
+    ax = plt.gca()
+    ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
     
-    # Histogram
-    plt.hist(df['duration_mth'], bins=25, density=True, alpha=0.7, color='lightcoral', edgecolor='black')
-    
-    # Normal curve overlay
-    dur_mean = df['duration_mth'].mean()
-    dur_std = df['duration_mth'].std()
-    x_dur = np.linspace(df['duration_mth'].min(), df['duration_mth'].max(), 100)
-    y_dur = stats.norm.pdf(x_dur, dur_mean, dur_std)
-    plt.plot(x_dur, y_dur, 'r-', linewidth=2, label=f'Normal Curve (μ={dur_mean:.1f}, σ={dur_std:.1f})')
-    
-    plt.title('Policy Duration (Months) Distribution with Normal Curve Overlay', fontsize=14, fontweight='bold')
-    plt.xlabel('Duration (Months)')
-    plt.ylabel('Density')
-    plt.legend()
-    plt.grid(True, alpha=0.3)
     plt.tight_layout()
     
-    return fig_age, fig_sa, fig_duration
+    return plt.gcf()
 
-def create_categorical_analysis(df):
-    """Create categorical variable analysis."""
+def create_policy_terms_plot(df):
+    """Create policy terms distribution plot."""
     if df is None or df.empty:
-        return pd.DataFrame(), None
+        return None
     
-    # Sex distribution
-    sex_dist = df['sex'].value_counts().reset_index()
-    sex_dist.columns = ['Sex', 'Count']
-    sex_dist['Percentage'] = (sex_dist['Count'] / len(df) * 100).round(2)
+    plt.figure(figsize=(10, 6))
     
-    # Policy term distribution
-    term_dist = df['policy_term'].value_counts().sort_index().reset_index()
-    term_dist.columns = ['Policy_Term', 'Count']
-    term_dist['Percentage'] = (term_dist['Count'] / len(df) * 100).round(2)
-    
-    # Combined categorical summary
-    categorical_summary = pd.DataFrame({
-        'Variable': ['Sex Distribution', '', 'Policy Term Distribution'] + [''] * (len(term_dist) - 1),
-        'Category': [''] + list(sex_dist['Sex']) + [''] + list(term_dist['Policy_Term'].astype(str) + ' years'),
-        'Count': [''] + list(sex_dist['Count']) + [''] + list(term_dist['Count']),
-        'Percentage': [''] + list(sex_dist['Percentage'].astype(str) + '%') + [''] + list(term_dist['Percentage'].astype(str) + '%')
-    })
-    
-    # Create bar plot for policy terms
-    fig_terms = plt.figure(figsize=(10, 6))
-    bars = plt.bar(term_dist['Policy_Term'].astype(str), term_dist['Count'], color='gold', edgecolor='black', alpha=0.8)
-    plt.title('Policy Term Distribution', fontsize=14, fontweight='bold')
+    # Get policy term counts
+    term_counts = df['policy_term'].value_counts().sort_index()
+    
+    bars = plt.bar(term_counts.index.astype(str), term_counts.values, color='gold', edgecolor='black', alpha=0.8)
+    
+    plt.title('Policy Term Distribution')
     plt.xlabel('Policy Term (Years)')
     plt.ylabel('Count')
     plt.grid(True, alpha=0.3, axis='y')
@@ -214,34 +177,45 @@ def create_categorical_analysis(df):
     
     plt.tight_layout()
     
-    return categorical_summary, fig_terms
+    return plt.gcf()
 
-def create_correlation_analysis(df):
-    """Create correlation analysis."""
+def generate_categorical_summary(df):
+    """Generate categorical variable summary."""
     if df is None or df.empty:
-        return None, pd.DataFrame()
+        return pd.DataFrame()
     
-    # Select numerical columns for correlation
-    numerical_cols = ['age_at_entry', 'policy_term', 'policy_count', 'sum_assured', 'duration_mth']
-    corr_matrix = df[numerical_cols].corr()
-    
-    # Create correlation heatmap
-    fig_corr = plt.figure(figsize=(10, 8))
-    mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
-    sns.heatmap(corr_matrix, mask=mask, annot=True, cmap='RdYlBu_r', center=0,
-                square=True, fmt='.3f', cbar_kws={"shrink": .8})
-    plt.title('Correlation Matrix of Numerical Variables', fontsize=14, fontweight='bold')
-    plt.tight_layout()
+    # Sex distribution
+    sex_counts = df['sex'].value_counts()
+    sex_pct = (sex_counts / len(df) * 100).round(2)
+    
+    # Policy term distribution
+    term_counts = df['policy_term'].value_counts().sort_index()
+    term_pct = (term_counts / len(df) * 100).round(2)
+    
+    # Create summary DataFrame
+    summary_data = []
+    
+    # Add sex distribution
+    summary_data.append(['Sex Distribution', '', '', ''])
+    for sex, count in sex_counts.items():
+        summary_data.append(['', sex, count, f'{sex_pct[sex]:.1f}%'])
     
-    # Create correlation summary table
-    corr_summary = corr_matrix.round(3)
+    # Add empty row
+    summary_data.append(['', '', '', ''])
     
-    return fig_corr, corr_summary
+    # Add policy term distribution
+    summary_data.append(['Policy Term Distribution', '', '', ''])
+    for term, count in term_counts.items():
+        summary_data.append(['', f'{term} years', count, f'{term_pct[term]:.1f}%'])
+    
+    summary_df = pd.DataFrame(summary_data, columns=['Category', 'Value', 'Count', 'Percentage'])
+    
+    return summary_df
 
 def generate_business_insights(df):
     """Generate business insights and key metrics."""
     if df is None or df.empty:
-        return ""
+        return "No data available. Please generate model points first."
     
     total_policies = len(df)
     total_sum_assured = df['sum_assured'].sum()
@@ -254,39 +228,38 @@ def generate_business_insights(df):
     term_percentage = (df['policy_term'] == most_common_term).mean() * 100
     
     # Age groups
-    young_pct = ((df['age_at_entry'] <= 30).mean() * 100).round(1)
-    middle_pct = (((df['age_at_entry'] > 30) & (df['age_at_entry'] <= 50)).mean() * 100).round(1)
-    mature_pct = ((df['age_at_entry'] > 50).mean() * 100).round(1)
-    
-    insights_text = f"""
-    ## 📊 Business Insights & Key Metrics
-    
-    ### Portfolio Overview
-    - **Total Policies Generated**: {total_policies:,}
-    - **Total Sum Assured**: ${total_sum_assured:,.0f}
-    - **Average Sum Assured**: ${avg_sum_assured:,.0f}
-    - **Average Issue Age**: {avg_age:.1f} years
-    - **Average Policy Duration**: {avg_duration:.1f} months ({avg_duration/12:.1f} years)
-    
-    ### Demographics
-    - **Young Policyholders (≤30)**: {young_pct}%
-    - **Middle-aged (31-50)**: {middle_pct}%
-    - **Mature (>50)**: {mature_pct}%
-    
-    ### Product Mix
-    - **Most Popular Term**: {most_common_term} years ({term_percentage:.1f}% of policies)
-    - **Policy Duration Range**: {df['duration_mth'].min()} - {df['duration_mth'].max()} months
-    - **Sum Assured Range**: ${df['sum_assured'].min():,.0f} - ${df['sum_assured'].max():,.0f}
-    """
+    young_pct = ((df['age_at_entry'] <= 30).mean() * 100)
+    middle_pct = (((df['age_at_entry'] > 30) & (df['age_at_entry'] <= 50)).mean() * 100)
+    mature_pct = ((df['age_at_entry'] > 50).mean() * 100)
+    
+    insights_text = f"""## Business Insights & Key Metrics
+
+### Portfolio Overview
+- **Total Policies Generated**: {total_policies:,}
+- **Total Sum Assured**: ${total_sum_assured:,.0f}
+- **Average Sum Assured**: ${avg_sum_assured:,.0f}
+- **Average Issue Age**: {avg_age:.1f} years
+- **Average Policy Duration**: {avg_duration:.1f} months ({avg_duration/12:.1f} years)
+
+### Demographics
+- **Young Policyholders (≤30)**: {young_pct:.1f}%
+- **Middle-aged (31-50)**: {middle_pct:.1f}%
+- **Mature (>50)**: {mature_pct:.1f}%
+
+### Product Mix
+- **Most Popular Term**: {most_common_term} years ({term_percentage:.1f}% of policies)
+- **Policy Duration Range**: {df['duration_mth'].min()} - {df['duration_mth'].max()} months
+- **Sum Assured Range**: ${df['sum_assured'].min():,.0f} - ${df['sum_assured'].max():,.0f}
+"""
     
     return insights_text
 
 # 3. Gradio App Definition
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎯 Actuarial Model Points Generator with Analytics")
+with gr.Blocks() as demo:
+    gr.Markdown("# Actuarial Model Points Generator")
     gr.Markdown(
         "Configure the parameters below to generate a custom set of seriatim model points. "
-        "The generated table can be viewed and downloaded as an Excel file, complete with comprehensive analytics and insights."
+        "The generated table can be viewed and downloaded as an Excel file."
     )
 
     df_state = gr.State()  # To hold the generated DataFrame
@@ -331,70 +304,57 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                 value=True, label="Fixed Policy Count = 1 (Uncheck for variable count 1-100)"
             )
 
-            generate_btn = gr.Button("Generate Model Points", variant="primary", size="lg")
+            generate_btn = gr.Button("Generate Model Points", variant="primary")
 
         with gr.Column(scale=2):
             model_points_display = gr.Dataframe(label="Generated Model Points")
             download_excel_btn = gr.DownloadButton(
-                label="📥 Download Excel",
-                value="model_points.xlsx",
+                label="Download Excel",
+                value="model_points.xlsx", # Default filename
                 variant="secondary"
             )
 
     # Analytics Section
     gr.Markdown("---")
     
-    with gr.Row():
-        with gr.Column():
-            business_insights = gr.Markdown("Generate model points to see business insights...")
+    # Business Insights
+    business_insights_display = gr.Markdown("Generate model points to see business insights and analytics...")
     
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 📈 Summary Statistics")
+            gr.Markdown("### Summary Statistics")
             summary_stats_display = gr.Dataframe(label="Descriptive Statistics")
         with gr.Column():
-            gr.Markdown("### 🏷️ Categorical Analysis")
+            gr.Markdown("### Categorical Analysis")
             categorical_display = gr.Dataframe(label="Category Distributions")
 
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 📊 Age Distribution")
-            age_plot = gr.Plot(label="Age Distribution with Normal Curve")
+            gr.Markdown("### Age Distribution with Normal Curve")
+            age_plot = gr.Plot(label="Age Distribution")
         with gr.Column():
-            gr.Markdown("### 💰 Sum Assured Distribution")
-            sa_plot = gr.Plot(label="Sum Assured Distribution with Normal Curve")
+            gr.Markdown("### Sum Assured Distribution with Normal Curve") 
+            sa_plot = gr.Plot(label="Sum Assured Distribution")
 
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### ⏱️ Duration Distribution")
-            duration_plot = gr.Plot(label="Duration Distribution with Normal Curve")
-        with gr.Column():
-            gr.Markdown("### 📋 Policy Term Distribution")
+            gr.Markdown("### Policy Term Distribution")
             terms_plot = gr.Plot(label="Policy Terms")
 
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 🔗 Correlation Analysis")
-            correlation_plot = gr.Plot(label="Correlation Heatmap")
-        with gr.Column():
-            gr.Markdown("### 📋 Correlation Matrix")
-            correlation_matrix_display = gr.Dataframe(label="Correlation Coefficients")
-
     # 4. Event Handlers
     def handle_generate_button_click(
         mp_c, s, age_m, age_mx, sa_m, sa_mx, p_terms, incl_sex, pc_fixed
     ):
         if int(age_m) >= int(age_mx):
             gr.Warning("Minimum Age must be less than Maximum Age.")
-            return [df_state.value] * 10  # Return current state for all outputs
+            return df_state.value, df_state.value, "Error: Invalid age range", pd.DataFrame(), pd.DataFrame(), None, None, None
         if float(sa_m) >= float(sa_mx):
             gr.Warning("Minimum Sum Assured must be less than Maximum Sum Assured.")
-            return [df_state.value] * 10
-
+            return df_state.value, df_state.value, "Error: Invalid sum assured range", pd.DataFrame(), pd.DataFrame(), None, None, None
         if not p_terms:
             gr.Warning("No Policy Terms selected. Using defaults: [10, 15, 20].")
 
-        gr.Info("Generating model points and analytics... Please wait.")
+        gr.Info("Generating model points... Please wait.")
         
         # Generate data
         df = generate_custom_model_points(
@@ -404,25 +364,16 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         # Generate analytics
         insights = generate_business_insights(df)
         summary_stats = generate_summary_statistics(df)
-        categorical_summary, terms_fig = create_categorical_analysis(df)
-        age_fig, sa_fig, duration_fig = create_distribution_plots(df)
-        corr_fig, corr_matrix = create_correlation_analysis(df)
+        categorical_summary = generate_categorical_summary(df)
         
-        gr.Info(f"✅ {len(df)} model points generated successfully with complete analytics!")
+        # Generate plots
+        age_fig = create_age_distribution_plot(df)
+        sa_fig = create_sum_assured_plot(df)
+        terms_fig = create_policy_terms_plot(df)
         
-        return (
-            df,  # model_points_display
-            df,  # df_state
-            insights,  # business_insights
-            summary_stats,  # summary_stats_display
-            categorical_summary,  # categorical_display
-            age_fig,  # age_plot
-            sa_fig,  # sa_plot
-            duration_fig,  # duration_plot
-            terms_fig,  # terms_plot
-            corr_fig,  # correlation_plot
-            corr_matrix  # correlation_matrix_display
-        )
+        gr.Info(f"{len(df)} model points generated successfully!")
+        
+        return df, df, insights, summary_stats, categorical_summary, age_fig, sa_fig, terms_fig
 
     def handle_download_button_click(current_df_to_download):
         if current_df_to_download is None or current_df_to_download.empty:
@@ -444,16 +395,11 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         include_sex_input, policy_count_fixed_input
     ]
 
-    outputs_list = [
-        model_points_display, df_state, business_insights, summary_stats_display,
-        categorical_display, age_plot, sa_plot, duration_plot, terms_plot,
-        correlation_plot, correlation_matrix_display
-    ]
-
     generate_btn.click(
         fn=handle_generate_button_click,
         inputs=inputs_list,
-        outputs=outputs_list
+        outputs=[model_points_display, df_state, business_insights_display, 
+                summary_stats_display, categorical_display, age_plot, sa_plot, terms_plot]
     )
 
     download_excel_btn.click(
@@ -462,5 +408,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         outputs=[download_excel_btn]
     )
 
+
 if __name__ == "__main__":
     demo.launch()