Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import numpy as np | |
| import pandas as pd | |
| from sklearn.cluster import KMeans | |
| from sklearn.metrics import pairwise_distances_argmin_min, r2_score | |
| import matplotlib.pyplot as plt | |
| import matplotlib.cm | |
| import io | |
| import os # Added for path joining | |
| from PIL import Image | |
| # Define the paths for example data | |
| EXAMPLE_DATA_DIR = "eg_data" | |
| EXAMPLE_FILES = { | |
| "cashflow_base": os.path.join(EXAMPLE_DATA_DIR, "cashflows_seriatim_10K.xlsx"), | |
| "cashflow_lapse": os.path.join(EXAMPLE_DATA_DIR, "cashflows_seriatim_10K_lapse50.xlsx"), | |
| "cashflow_mort": os.path.join(EXAMPLE_DATA_DIR, "cashflows_seriatim_10K_mort15.xlsx"), | |
| "policy_data": os.path.join(EXAMPLE_DATA_DIR, "model_point_table.xlsx"), | |
| "pv_base": os.path.join(EXAMPLE_DATA_DIR, "pv_seriatim_10K.xlsx"), | |
| "pv_lapse": os.path.join(EXAMPLE_DATA_DIR, "pv_seriatim_10K_lapse50.xlsx"), | |
| "pv_mort": os.path.join(EXAMPLE_DATA_DIR, "pv_seriatim_10K_mort15.xlsx"), | |
| } | |
| class Clusters: | |
| def __init__(self, loc_vars): | |
| self.kmeans = kmeans = KMeans(n_clusters=1000, random_state=0, n_init=10).fit(np.ascontiguousarray(loc_vars)) | |
| closest, _ = pairwise_distances_argmin_min(kmeans.cluster_centers_, np.ascontiguousarray(loc_vars)) | |
| rep_ids = pd.Series(data=(closest+1)) # 0-based to 1-based indexes | |
| rep_ids.name = 'policy_id' | |
| rep_ids.index.name = 'cluster_id' | |
| self.rep_ids = rep_ids | |
| self.policy_count = self.agg_by_cluster(pd.DataFrame({'policy_count': [1] * len(loc_vars)}))['policy_count'] | |
| def agg_by_cluster(self, df, agg=None): | |
| """Aggregate columns by cluster""" | |
| temp = df.copy() | |
| temp['cluster_id'] = self.kmeans.labels_ | |
| temp = temp.set_index('cluster_id') | |
| agg = {c: (agg[c] if agg and c in agg else 'sum') for c in temp.columns} if agg else "sum" | |
| return temp.groupby(temp.index).agg(agg) | |
| def extract_reps(self, df): | |
| """Extract the rows of representative policies""" | |
| temp = pd.merge(self.rep_ids, df.reset_index(), how='left', on='policy_id') | |
| temp.index.name = 'cluster_id' | |
| return temp.drop('policy_id', axis=1) | |
| def extract_and_scale_reps(self, df, agg=None): | |
| """Extract and scale the rows of representative policies""" | |
| if agg: | |
| cols = df.columns | |
| mult = pd.DataFrame({c: (self.policy_count if (c not in agg or agg[c] == 'sum') else 1) for c in cols}) | |
| # Ensure mult has same index as extract_reps(df) for proper alignment | |
| extracted_df = self.extract_reps(df) | |
| mult.index = extracted_df.index | |
| return extracted_df.mul(mult) | |
| else: | |
| return self.extract_reps(df).mul(self.policy_count, axis=0) | |
| def compare(self, df, agg=None): | |
| """Returns a multi-indexed Dataframe comparing actual and estimate""" | |
| source = self.agg_by_cluster(df, agg) | |
| target = self.extract_and_scale_reps(df, agg) | |
| return pd.DataFrame({'actual': source.stack(), 'estimate':target.stack()}) | |
| def compare_total(self, df, agg=None): | |
| """Aggregate df by columns""" | |
| if agg: | |
| # Calculate actual values using specified aggregation | |
| actual_values = {} | |
| for col in df.columns: | |
| if agg.get(col, 'sum') == 'mean': | |
| actual_values[col] = df[col].mean() | |
| else: # sum | |
| actual_values[col] = df[col].sum() | |
| actual = pd.Series(actual_values) | |
| # Calculate estimate values | |
| reps_unscaled = self.extract_reps(df) | |
| estimate_values = {} | |
| for col in df.columns: | |
| if agg.get(col, 'sum') == 'mean': | |
| # Weighted average for mean columns | |
| weighted_sum = (reps_unscaled[col] * self.policy_count).sum() | |
| total_weight = self.policy_count.sum() | |
| estimate_values[col] = weighted_sum / total_weight if total_weight > 0 else 0 | |
| else: # sum | |
| estimate_values[col] = (reps_unscaled[col] * self.policy_count).sum() | |
| estimate = pd.Series(estimate_values) | |
| else: # Original logic if no agg is specified (all sum) | |
| actual = df.sum() | |
| estimate = self.extract_and_scale_reps(df).sum() | |
| # Calculate error, handling division by zero | |
| error = np.where(actual != 0, estimate / actual - 1, 0) | |
| return pd.DataFrame({'actual': actual, 'estimate': estimate, 'error': error}) | |
| def plot_cashflows_comparison(cfs_list, cluster_obj, titles): | |
| """Create cashflow comparison plots""" | |
| if not cfs_list or not cluster_obj or not titles: | |
| return None | |
| num_plots = len(cfs_list) | |
| if num_plots == 0: | |
| return None | |
| # Determine subplot layout | |
| cols = 2 | |
| rows = (num_plots + cols - 1) // cols | |
| fig, axes = plt.subplots(rows, cols, figsize=(15, 5 * rows), squeeze=False) | |
| axes = axes.flatten() | |
| for i, (df, title) in enumerate(zip(cfs_list, titles)): | |
| if i < len(axes): | |
| comparison = cluster_obj.compare_total(df) | |
| comparison[['actual', 'estimate']].plot(ax=axes[i], grid=True, title=title) | |
| axes[i].set_xlabel('Time') | |
| axes[i].set_ylabel('Value') | |
| # Hide any unused subplots | |
| for j in range(i + 1, len(axes)): | |
| fig.delaxes(axes[j]) | |
| plt.tight_layout() | |
| buf = io.BytesIO() | |
| plt.savefig(buf, format='png', dpi=100) | |
| buf.seek(0) | |
| img = Image.open(buf) | |
| plt.close(fig) | |
| return img | |
| def plot_scatter_comparison(df_compare_output, title): | |
| """Create scatter plot comparison from compare() output""" | |
| if df_compare_output is None or df_compare_output.empty: | |
| # Create a blank plot with a message | |
| fig, ax = plt.subplots(figsize=(12, 8)) | |
| ax.text(0.5, 0.5, "No data to display", ha='center', va='center', fontsize=15) | |
| ax.set_title(title) | |
| buf = io.BytesIO() | |
| plt.savefig(buf, format='png', dpi=100) | |
| buf.seek(0) | |
| img = Image.open(buf) | |
| plt.close(fig) | |
| return img | |
| fig, ax = plt.subplots(figsize=(12, 8)) | |
| if not isinstance(df_compare_output.index, pd.MultiIndex) or df_compare_output.index.nlevels < 2: | |
| gr.Warning("Scatter plot data is not in the expected multi-index format. Plotting raw actual vs estimate.") | |
| ax.scatter(df_compare_output['actual'], df_compare_output['estimate'], s=9, alpha=0.6) | |
| else: | |
| unique_levels = df_compare_output.index.get_level_values(1).unique() | |
| colors = matplotlib.cm.rainbow(np.linspace(0, 1, len(unique_levels))) | |
| for item_level, color_val in zip(unique_levels, colors): | |
| subset = df_compare_output.xs(item_level, level=1) | |
| ax.scatter(subset['actual'], subset['estimate'], color=color_val, s=9, alpha=0.6, label=item_level) | |
| if len(unique_levels) > 1 and len(unique_levels) <= 10: | |
| ax.legend(title=df_compare_output.index.names[1]) | |
| ax.set_xlabel('Actual') | |
| ax.set_ylabel('Estimate') | |
| ax.set_title(title) | |
| ax.grid(True) | |
| # Draw identity line | |
| lims = [ | |
| np.min([ax.get_xlim(), ax.get_ylim()]), | |
| np.max([ax.get_xlim(), ax.get_ylim()]), | |
| ] | |
| if lims[0] != lims[1]: | |
| ax.plot(lims, lims, 'r-', linewidth=0.5) | |
| ax.set_xlim(lims) | |
| ax.set_ylim(lims) | |
| buf = io.BytesIO() | |
| plt.savefig(buf, format='png', dpi=100) | |
| buf.seek(0) | |
| img = Image.open(buf) | |
| plt.close(fig) | |
| return img | |
| def process_files(cashflow_base_path, cashflow_lapse_path, cashflow_mort_path, | |
| policy_data_path, pv_base_path, pv_lapse_path, pv_mort_path): | |
| """Main processing function - now accepts file paths""" | |
| try: | |
| # Read uploaded files using paths | |
| cfs = pd.read_excel(cashflow_base_path, index_col=0) | |
| cfs_lapse50 = pd.read_excel(cashflow_lapse_path, index_col=0) | |
| cfs_mort15 = pd.read_excel(cashflow_mort_path, index_col=0) | |
| pol_data_full = pd.read_excel(policy_data_path, index_col=0) | |
| # Ensure the correct columns are selected for pol_data | |
| required_cols = ['age_at_entry', 'policy_term', 'sum_assured', 'duration_mth'] | |
| if all(col in pol_data_full.columns for col in required_cols): | |
| pol_data = pol_data_full[required_cols] | |
| else: | |
| gr.Warning(f"Policy data might be missing required columns. Found: {pol_data_full.columns.tolist()}") | |
| pol_data = pol_data_full | |
| pvs = pd.read_excel(pv_base_path, index_col=0) | |
| pvs_lapse50 = pd.read_excel(pv_lapse_path, index_col=0) | |
| pvs_mort15 = pd.read_excel(pv_mort_path, index_col=0) | |
| cfs_list = [cfs, cfs_lapse50, cfs_mort15] | |
| scen_titles = ['Base', 'Lapse+50%', 'Mort+15%'] | |
| results = {} | |
| mean_attrs = {'age_at_entry':'mean', 'policy_term':'mean', 'duration_mth':'mean', 'sum_assured': 'sum'} | |
| # --- 1. Cashflow Calibration --- | |
| cluster_cfs = Clusters(cfs) | |
| results['cf_total_base_table'] = cluster_cfs.compare_total(cfs) | |
| results['cf_policy_attrs_total'] = cluster_cfs.compare_total(pol_data, agg=mean_attrs) | |
| results['cf_pv_total_base'] = cluster_cfs.compare_total(pvs) | |
| results['cf_pv_total_lapse'] = cluster_cfs.compare_total(pvs_lapse50) | |
| results['cf_pv_total_mort'] = cluster_cfs.compare_total(pvs_mort15) | |
| results['cf_cashflow_plot'] = plot_cashflows_comparison(cfs_list, cluster_cfs, scen_titles) | |
| results['cf_scatter_cashflows_base'] = plot_scatter_comparison(cluster_cfs.compare(cfs), 'Cashflow Calib. - Cashflows (Base)') | |
| # --- 2. Policy Attribute Calibration --- | |
| # Standardize policy attributes | |
| if not pol_data.empty and (pol_data.max() - pol_data.min()).all() != 0: | |
| loc_vars_attrs = (pol_data - pol_data.min()) / (pol_data.max() - pol_data.min()) | |
| else: | |
| gr.Warning("Policy data for attribute calibration is empty or has no variance. Skipping attribute calibration plots.") | |
| loc_vars_attrs = pol_data | |
| if not loc_vars_attrs.empty: | |
| cluster_attrs = Clusters(loc_vars_attrs) | |
| results['attr_total_cf_base'] = cluster_attrs.compare_total(cfs) | |
| results['attr_policy_attrs_total'] = cluster_attrs.compare_total(pol_data, agg=mean_attrs) | |
| results['attr_total_pv_base'] = cluster_attrs.compare_total(pvs) | |
| results['attr_cashflow_plot'] = plot_cashflows_comparison(cfs_list, cluster_attrs, scen_titles) | |
| results['attr_scatter_cashflows_base'] = plot_scatter_comparison(cluster_attrs.compare(cfs), 'Policy Attr. Calib. - Cashflows (Base)') | |
| else: | |
| results['attr_total_cf_base'] = pd.DataFrame() | |
| results['attr_policy_attrs_total'] = pd.DataFrame() | |
| results['attr_total_pv_base'] = pd.DataFrame() | |
| results['attr_cashflow_plot'] = None | |
| results['attr_scatter_cashflows_base'] = None | |
| # --- 3. Present Value Calibration --- | |
| cluster_pvs = Clusters(pvs) | |
| results['pv_total_cf_base'] = cluster_pvs.compare_total(cfs) | |
| results['pv_policy_attrs_total'] = cluster_pvs.compare_total(pol_data, agg=mean_attrs) | |
| results['pv_total_pv_base'] = cluster_pvs.compare_total(pvs) | |
| results['pv_total_pv_lapse'] = cluster_pvs.compare_total(pvs_lapse50) | |
| results['pv_total_pv_mort'] = cluster_pvs.compare_total(pvs_mort15) | |
| results['pv_cashflow_plot'] = plot_cashflows_comparison(cfs_list, cluster_pvs, scen_titles) | |
| results['pv_scatter_pvs_base'] = plot_scatter_comparison(cluster_pvs.compare(pvs), 'PV Calib. - PVs (Base)') | |
| # --- Summary Comparison Plot Data --- | |
| # Error metric for key PV column or mean absolute error | |
| error_data = {} | |
| # Function to safely get error value | |
| def get_error_safe(compare_result, col_name=None): | |
| if compare_result.empty: | |
| return np.nan | |
| if col_name and col_name in compare_result.index: | |
| return abs(compare_result.loc[col_name, 'error']) | |
| else: | |
| # Use mean absolute error if specific column not found | |
| return abs(compare_result['error']).mean() | |
| # Determine key PV column (try common names) | |
| key_pv_col = None | |
| for potential_col in ['PV_NetCF', 'pv_net_cf', 'net_cf_pv', 'PV_Net_CF']: | |
| if potential_col in pvs.columns: | |
| key_pv_col = potential_col | |
| break | |
| # Cashflow Calibration Errors | |
| error_data['CF Calib.'] = [ | |
| get_error_safe(cluster_cfs.compare_total(pvs), key_pv_col), | |
| get_error_safe(cluster_cfs.compare_total(pvs_lapse50), key_pv_col), | |
| get_error_safe(cluster_cfs.compare_total(pvs_mort15), key_pv_col) | |
| ] | |
| # Policy Attribute Calibration Errors | |
| if not loc_vars_attrs.empty: | |
| error_data['Attr Calib.'] = [ | |
| get_error_safe(cluster_attrs.compare_total(pvs), key_pv_col), | |
| get_error_safe(cluster_attrs.compare_total(pvs_lapse50), key_pv_col), | |
| get_error_safe(cluster_attrs.compare_total(pvs_mort15), key_pv_col) | |
| ] | |
| else: | |
| error_data['Attr Calib.'] = [np.nan, np.nan, np.nan] | |
| # Present Value Calibration Errors | |
| error_data['PV Calib.'] = [ | |
| get_error_safe(cluster_pvs.compare_total(pvs), key_pv_col), | |
| get_error_safe(cluster_pvs.compare_total(pvs_lapse50), key_pv_col), | |
| get_error_safe(cluster_pvs.compare_total(pvs_mort15), key_pv_col) | |
| ] | |
| # Create Summary Plot | |
| summary_df = pd.DataFrame(error_data, index=['Base', 'Lapse+50%', 'Mort+15%']) | |
| fig_summary, ax_summary = plt.subplots(figsize=(10, 6)) | |
| summary_df.plot(kind='bar', ax=ax_summary, grid=True) | |
| ax_summary.set_ylabel('Absolute Error Rate') | |
| title_suffix = f' ({key_pv_col})' if key_pv_col else ' (Mean Absolute Error)' | |
| ax_summary.set_title(f'Calibration Method Comparison - Error in Total PV{title_suffix}') | |
| ax_summary.tick_params(axis='x', rotation=0) | |
| ax_summary.legend(title='Calibration Method') | |
| plt.tight_layout() | |
| buf_summary = io.BytesIO() | |
| plt.savefig(buf_summary, format='png', dpi=100) | |
| buf_summary.seek(0) | |
| results['summary_plot'] = Image.open(buf_summary) | |
| plt.close(fig_summary) | |
| return results | |
| except FileNotFoundError as e: | |
| gr.Error(f"File not found: {e.filename}. Please ensure example files are in '{EXAMPLE_DATA_DIR}' or all files are uploaded.") | |
| return {"error": f"File not found: {e.filename}"} | |
| except KeyError as e: | |
| gr.Error(f"A required column is missing from one of the excel files: {e}. Please check data format.") | |
| return {"error": f"Missing column: {e}"} | |
| except Exception as e: | |
| gr.Error(f"Error processing files: {str(e)}") | |
| return {"error": f"Error processing files: {str(e)}"} | |
| def create_interface(): | |
| with gr.Blocks(title="Cluster Model Points Analysis") as demo: | |
| gr.Markdown(""" | |
| # Cluster Model Points Analysis | |
| This application applies cluster analysis to model point selection for insurance portfolios. | |
| Upload your Excel files or use the example data to analyze cashflows, policy attributes, and present values using different calibration methods. | |
| **Required Files (Excel .xlsx):** | |
| - Cashflows - Base Scenario | |
| - Cashflows - Lapse Stress (+50%) | |
| - Cashflows - Mortality Stress (+15%) | |
| - Policy Data (including 'age_at_entry', 'policy_term', 'sum_assured', 'duration_mth') | |
| - Present Values - Base Scenario | |
| - Present Values - Lapse Stress | |
| - Present Values - Mortality Stress | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### Upload Files or Load Examples") | |
| load_example_btn = gr.Button("Load Example Data") | |
| with gr.Row(): | |
| cashflow_base_input = gr.File(label="Cashflows - Base", file_types=[".xlsx"]) | |
| cashflow_lapse_input = gr.File(label="Cashflows - Lapse Stress", file_types=[".xlsx"]) | |
| cashflow_mort_input = gr.File(label="Cashflows - Mortality Stress", file_types=[".xlsx"]) | |
| with gr.Row(): | |
| policy_data_input = gr.File(label="Policy Data", file_types=[".xlsx"]) | |
| pv_base_input = gr.File(label="Present Values - Base", file_types=[".xlsx"]) | |
| pv_lapse_input = gr.File(label="Present Values - Lapse Stress", file_types=[".xlsx"]) | |
| with gr.Row(): | |
| pv_mort_input = gr.File(label="Present Values - Mortality Stress", file_types=[".xlsx"]) | |
| analyze_btn = gr.Button("Analyze Dataset", variant="primary", size="lg") | |
| with gr.Tabs(): | |
| with gr.TabItem("📊 Summary"): | |
| summary_plot_output = gr.Image(label="Calibration Methods Comparison") | |
| with gr.TabItem("💸 Cashflow Calibration"): | |
| gr.Markdown("### Results: Using Annual Cashflows as Calibration Variables") | |
| with gr.Row(): | |
| cf_total_base_table_out = gr.Dataframe(label="Overall Comparison - Base Scenario (Cashflows)") | |
| cf_policy_attrs_total_out = gr.Dataframe(label="Overall Comparison - Policy Attributes") | |
| cf_cashflow_plot_out = gr.Image(label="Cashflow Value Comparisons (Actual vs. Estimate) Across Scenarios") | |
| cf_scatter_cashflows_base_out = gr.Image(label="Scatter Plot - Per-Cluster Cashflows (Base Scenario)") | |
| with gr.Accordion("Present Value Comparisons (Total)", open=False): | |
| with gr.Row(): | |
| cf_pv_total_base_out = gr.Dataframe(label="PVs - Base Total") | |
| cf_pv_total_lapse_out = gr.Dataframe(label="PVs - Lapse Stress Total") | |
| cf_pv_total_mort_out = gr.Dataframe(label="PVs - Mortality Stress Total") | |
| with gr.TabItem("👤 Policy Attribute Calibration"): | |
| gr.Markdown("### Results: Using Policy Attributes as Calibration Variables") | |
| with gr.Row(): | |
| attr_total_cf_base_out = gr.Dataframe(label="Overall Comparison - Base Scenario (Cashflows)") | |
| attr_policy_attrs_total_out = gr.Dataframe(label="Overall Comparison - Policy Attributes") | |
| attr_cashflow_plot_out = gr.Image(label="Cashflow Value Comparisons (Actual vs. Estimate) Across Scenarios") | |
| attr_scatter_cashflows_base_out = gr.Image(label="Scatter Plot - Per-Cluster Cashflows (Base Scenario)") | |
| with gr.Accordion("Present Value Comparisons (Total)", open=False): | |
| attr_total_pv_base_out = gr.Dataframe(label="PVs - Base Scenario Total") | |
| with gr.TabItem("💰 Present Value Calibration"): | |
| gr.Markdown("### Results: Using Present Values (Base Scenario) as Calibration Variables") | |
| with gr.Row(): | |
| pv_total_cf_base_out = gr.Dataframe(label="Overall Comparison - Base Scenario (Cashflows)") | |
| pv_policy_attrs_total_out = gr.Dataframe(label="Overall Comparison - Policy Attributes") | |
| pv_cashflow_plot_out = gr.Image(label="Cashflow Value Comparisons (Actual vs. Estimate) Across Scenarios") | |
| pv_scatter_pvs_base_out = gr.Image(label="Scatter Plot - Per-Cluster Present Values (Base Scenario)") | |
| with gr.Accordion("Present Value Comparisons (Total)", open=False): | |
| with gr.Row(): | |
| pv_total_pv_base_out = gr.Dataframe(label="PVs - Base Total") | |
| pv_total_pv_lapse_out = gr.Dataframe(label="PVs - Lapse Stress Total") | |
| pv_total_pv_mort_out = gr.Dataframe(label="PVs - Mortality Stress Total") | |
| # --- Helper function to prepare outputs --- | |
| def get_all_output_components(): | |
| return [ | |
| summary_plot_output, | |
| # Cashflow Calib Outputs | |
| cf_total_base_table_out, cf_policy_attrs_total_out, | |
| cf_cashflow_plot_out, cf_scatter_cashflows_base_out, | |
| cf_pv_total_base_out, cf_pv_total_lapse_out, cf_pv_total_mort_out, | |
| # Attribute Calib Outputs | |
| attr_total_cf_base_out, attr_policy_attrs_total_out, | |
| attr_cashflow_plot_out, attr_scatter_cashflows_base_out, attr_total_pv_base_out, | |
| # PV Calib Outputs | |
| pv_total_cf_base_out, pv_policy_attrs_total_out, | |
| pv_cashflow_plot_out, pv_scatter_pvs_base_out, | |
| pv_total_pv_base_out, pv_total_pv_lapse_out, pv_total_pv_mort_out | |
| ] | |
| # --- Action for Analyze Button --- | |
| def handle_analysis(f1, f2, f3, f4, f5, f6, f7): | |
| files = [f1, f2, f3, f4, f5, f6, f7] | |
| file_paths = [] | |
| for i, f_obj in enumerate(files): | |
| if f_obj is None: | |
| gr.Error(f"Missing file input for argument {i+1}. Please upload all files or load examples.") | |
| return [None] * len(get_all_output_components()) | |
| # If f_obj is a Gradio FileData object (from direct upload) | |
| if hasattr(f_obj, 'name') and isinstance(f_obj.name, str): | |
| file_paths.append(f_obj.name) | |
| # If f_obj is already a string path (from example load) | |
| elif isinstance(f_obj, str): | |
| file_paths.append(f_obj) | |
| else: | |
| gr.Error(f"Invalid file input for argument {i+1}. Type: {type(f_obj)}") | |
| return [None] * len(get_all_output_components()) | |
| results = process_files(*file_paths) | |
| if "error" in results: | |
| return [None] * len(get_all_output_components()) | |
| return [ | |
| results.get('summary_plot'), | |
| # CF Calib | |
| results.get('cf_total_base_table'), results.get('cf_policy_attrs_total'), | |
| results.get('cf_cashflow_plot'), results.get('cf_scatter_cashflows_base'), | |
| results.get('cf_pv_total_base'), results.get('cf_pv_total_lapse'), results.get('cf_pv_total_mort'), | |
| # Attr Calib | |
| results.get('attr_total_cf_base'), results.get('attr_policy_attrs_total'), | |
| results.get('attr_cashflow_plot'), results.get('attr_scatter_cashflows_base'), results.get('attr_total_pv_base'), | |
| # PV Calib | |
| results.get('pv_total_cf_base'), results.get('pv_policy_attrs_total'), | |
| results.get('pv_cashflow_plot'), results.get('pv_scatter_pvs_base'), | |
| results.get('pv_total_pv_base'), results.get('pv_total_pv_lapse'), results.get('pv_total_pv_mort') | |
| ] | |
| analyze_btn.click( | |
| handle_analysis, | |
| inputs=[cashflow_base_input, cashflow_lapse_input, cashflow_mort_input, | |
| policy_data_input, pv_base_input, pv_lapse_input, pv_mort_input], | |
| outputs=get_all_output_components() | |
| ) | |
| # --- Action for Load Example Data Button --- | |
| def load_example_files(): | |
| missing_files = [fp for fp in EXAMPLE_FILES.values() if not os.path.exists(fp)] | |
| if missing_files: | |
| gr.Error(f"Missing example data files in '{EXAMPLE_DATA_DIR}': {', '.join(missing_files)}. Please ensure they exist.") | |
| return [None] * 7 | |
| gr.Info("Example data paths loaded. Click 'Analyze Dataset'.") | |
| return [ | |
| EXAMPLE_FILES["cashflow_base"], EXAMPLE_FILES["cashflow_lapse"], EXAMPLE_FILES["cashflow_mort"], | |
| EXAMPLE_FILES["policy_data"], EXAMPLE_FILES["pv_base"], EXAMPLE_FILES["pv_lapse"], | |
| EXAMPLE_FILES["pv_mort"] | |
| ] | |
| load_example_btn.click( | |
| load_example_files, | |
| inputs=[], | |
| outputs=[cashflow_base_input, cashflow_lapse_input, cashflow_mort_input, | |
| policy_data_input, pv_base_input, pv_lapse_input, pv_mort_input] | |
| ) | |
| return demo | |
| if __name__ == "__main__": | |
| if not os.path.exists(EXAMPLE_DATA_DIR): | |
| os.makedirs(EXAMPLE_DATA_DIR) | |
| print(f"Created directory '{EXAMPLE_DATA_DIR}'. Please place example Excel files there.") | |
| print(f"Expected files in '{EXAMPLE_DATA_DIR}': {list(EXAMPLE_FILES.values())}") | |
| demo_app = create_interface() | |
| demo_app.launch() |