Update app.py

Fix 1: Light/Dark Mode Compatibility
Fix 2: Readable Pie Charts - Problem: Percentages and labels were hard to read

app.py

@@ -28,31 +28,53 @@ from xgboost import XGBClassifier
 from lightgbm import LGBMClassifier
 from imblearn.over_sampling import SMOTE
 
-# Set up matplotlib for dark mode compatibility
-plt.rcParams['figure.facecolor'] = '#1a1a2e'
-plt.rcParams['axes.facecolor'] = '#16213e'
-plt.rcParams['axes.edgecolor'] = '#e0e0e0'
-plt.rcParams['axes.labelcolor'] = '#e0e0e0'
-plt.rcParams['text.color'] = '#e0e0e0'
-plt.rcParams['xtick.color'] = '#e0e0e0'
-plt.rcParams['ytick.color'] = '#e0e0e0'
-plt.rcParams['grid.color'] = '#3a3a5c'
-plt.rcParams['legend.facecolor'] = '#1a1a2e'
-plt.rcParams['legend.edgecolor'] = '#e0e0e0'
+
+# ============================================================================
+# PLOT STYLE CONFIGURATION
+# Use white background for universal readability in both light and dark modes
+# ============================================================================
+
+def setup_plot_style():
+    """Configure matplotlib for clean, readable plots."""
+    plt.rcParams.update({
+        'figure.facecolor': 'white',
+        'axes.facecolor': 'white',
+        'axes.edgecolor': '#333333',
+        'axes.labelcolor': '#333333',
+        'text.color': '#333333',
+        'xtick.color': '#333333',
+        'ytick.color': '#333333',
+        'grid.color': '#cccccc',
+        'grid.alpha': 0.5,
+        'legend.facecolor': 'white',
+        'legend.edgecolor': '#cccccc',
+        'font.size': 11,
+        'axes.titlesize': 14,
+        'axes.labelsize': 12,
+    })
+
+setup_plot_style()
+
+# Color palette - vibrant colors that work on white background
+COLORS = {
+    'primary': '#2563eb',      # Blue
+    'success': '#16a34a',      # Green
+    'danger': '#dc2626',       # Red
+    'warning': '#f59e0b',      # Amber
+    'purple': '#9333ea',       # Purple
+    'cyan': '#0891b2',         # Cyan
+}
+
 
 # ============================================================================
 # DATA LOADING AND PREPROCESSING
 # ============================================================================
 
 def load_and_prepare_data():
-    """
-    Load the train and test datasets.
-    The data is already preprocessed and one-hot encoded.
-    """
+    """Load the train and test datasets."""
     train_df = pd.read_csv('train.csv')
     test_df = pd.read_csv('test.csv')
     
-    # Separate features and target
     X_train = train_df.drop('fraud', axis=1)
     y_train = train_df['fraud']
     X_test = test_df.drop('fraud', axis=1)
@@ -62,10 +84,7 @@ def load_and_prepare_data():
 
 
 def apply_smote(X_train, y_train):
-    """
-    Apply SMOTE to handle class imbalance.
-    Fraud cases are rare (~3%), so we oversample the minority class.
-    """
+    """Apply SMOTE to handle class imbalance."""
     smote = SMOTE(random_state=42)
     X_resampled, y_resampled = smote.fit_resample(X_train, y_train)
     return X_resampled, y_resampled
@@ -76,10 +95,7 @@ def apply_smote(X_train, y_train):
 # ============================================================================
 
 def get_models():
-    """
-    Define the 4 models we'll compare.
-    Each model is tuned for imbalanced fraud detection.
-    """
+    """Define the 4 models for comparison."""
     models = {
         'XGBoost': XGBClassifier(
             n_estimators=100,
@@ -119,20 +135,20 @@ def get_models():
 # ============================================================================
 
 def train_model(model, X_train, y_train):
-    """Train a single model and return the fitted model."""
+    """Train a model."""
     model.fit(X_train, y_train)
     return model
 
 
 def evaluate_model(model, X_test, y_test):
-    """Get predictions and probabilities from a trained model."""
+    """Get predictions and probabilities."""
     y_pred = model.predict(X_test)
     y_proba = model.predict_proba(X_test)[:, 1]
     return y_pred, y_proba
 
 
 def get_metrics(y_test, y_pred, y_proba):
-    """Calculate all relevant metrics for fraud detection."""
+    """Calculate evaluation metrics."""
     metrics = {
         'Accuracy': accuracy_score(y_test, y_pred),
         'Precision': precision_score(y_test, y_pred, zero_division=0),
@@ -144,7 +160,7 @@ def get_metrics(y_test, y_pred, y_proba):
 
 
 def find_optimal_threshold(y_test, y_proba):
-    """Find the optimal classification threshold using F1 score."""
+    """Find optimal threshold using F1 score."""
     thresholds = np.arange(0.1, 0.9, 0.01)
     f1_scores = []
     
@@ -161,124 +177,138 @@ def find_optimal_threshold(y_test, y_proba):
 
 
 # ============================================================================
-# VISUALIZATION FUNCTIONS (Dark Mode Compatible)
+# VISUALIZATION FUNCTIONS
 # ============================================================================
 
 def plot_precision_recall_curve(y_test, y_proba, model_name):
-    """Plot Precision-Recall curve with dark mode colors."""
-    precision, recall, thresholds = precision_recall_curve(y_test, y_proba)
+    """Plot Precision-Recall curve."""
+    setup_plot_style()
+    precision, recall, _ = precision_recall_curve(y_test, y_proba)
     pr_auc = auc(recall, precision)
     
-    fig, ax = plt.subplots(figsize=(8, 6))
-    ax.plot(recall, precision, '#00d4ff', linewidth=2, label=f'{model_name} (AUC = {pr_auc:.3f})')
-    ax.fill_between(recall, precision, alpha=0.3, color='#00d4ff')
+    fig, ax = plt.subplots(figsize=(9, 6))
+    
+    ax.plot(recall, precision, color=COLORS['primary'], linewidth=2.5, 
+            label=f'{model_name} (AUC = {pr_auc:.3f})')
+    ax.fill_between(recall, precision, alpha=0.2, color=COLORS['primary'])
     
     # Baseline
     baseline = y_test.mean()
-    ax.axhline(y=baseline, color='#ff6b6b', linestyle='--', label=f'Baseline = {baseline:.3f}')
+    ax.axhline(y=baseline, color=COLORS['danger'], linestyle='--', linewidth=2,
+               label=f'Random Baseline = {baseline:.3f}')
     
-    ax.set_xlabel('Recall (Fraud Detection Rate)', fontsize=12)
-    ax.set_ylabel('Precision (True Fraud Rate)', fontsize=12)
-    ax.set_title(f'Precision-Recall Curve: {model_name}', fontsize=14, fontweight='bold')
-    ax.legend(loc='best', facecolor='#1a1a2e', edgecolor='#e0e0e0')
+    ax.set_xlabel('Recall (Fraud Detection Rate)', fontweight='bold')
+    ax.set_ylabel('Precision (True Fraud Rate)', fontweight='bold')
+    ax.set_title(f'Precision-Recall Curve: {model_name}', fontsize=15, fontweight='bold', pad=15)
+    ax.legend(loc='upper right', fontsize=11, framealpha=0.95)
     ax.set_xlim([0, 1])
     ax.set_ylim([0, 1])
-    ax.grid(True, alpha=0.3)
+    ax.grid(True, alpha=0.4)
     
     plt.tight_layout()
     return fig
 
 
 def plot_roc_curve(y_test, y_proba, model_name):
-    """Plot ROC curve with dark mode colors."""
-    fpr, tpr, thresholds = roc_curve(y_test, y_proba)
+    """Plot ROC curve."""
+    setup_plot_style()
+    fpr, tpr, _ = roc_curve(y_test, y_proba)
     roc_auc = auc(fpr, tpr)
     
-    fig, ax = plt.subplots(figsize=(8, 6))
-    ax.plot(fpr, tpr, '#00d4ff', linewidth=2, label=f'{model_name} (AUC = {roc_auc:.3f})')
-    ax.fill_between(fpr, tpr, alpha=0.3, color='#00d4ff')
-    ax.plot([0, 1], [0, 1], '#ff6b6b', linestyle='--', label='Random Classifier')
+    fig, ax = plt.subplots(figsize=(9, 6))
+    
+    ax.plot(fpr, tpr, color=COLORS['primary'], linewidth=2.5,
+            label=f'{model_name} (AUC = {roc_auc:.3f})')
+    ax.fill_between(fpr, tpr, alpha=0.2, color=COLORS['primary'])
+    ax.plot([0, 1], [0, 1], color=COLORS['danger'], linestyle='--', linewidth=2,
+            label='Random Classifier')
     
-    ax.set_xlabel('False Positive Rate', fontsize=12)
-    ax.set_ylabel('True Positive Rate (Recall)', fontsize=12)
-    ax.set_title(f'ROC Curve: {model_name}', fontsize=14, fontweight='bold')
-    ax.legend(loc='lower right', facecolor='#1a1a2e', edgecolor='#e0e0e0')
+    ax.set_xlabel('False Positive Rate', fontweight='bold')
+    ax.set_ylabel('True Positive Rate (Recall)', fontweight='bold')
+    ax.set_title(f'ROC Curve: {model_name}', fontsize=15, fontweight='bold', pad=15)
+    ax.legend(loc='lower right', fontsize=11, framealpha=0.95)
     ax.set_xlim([0, 1])
     ax.set_ylim([0, 1])
-    ax.grid(True, alpha=0.3)
+    ax.grid(True, alpha=0.4)
     
     plt.tight_layout()
     return fig
 
 
 def plot_confusion_matrix(y_test, y_pred, model_name):
-    """Plot confusion matrix heatmap with dark mode colors."""
+    """Plot confusion matrix heatmap."""
+    setup_plot_style()
     cm = confusion_matrix(y_test, y_pred)
     
-    fig, ax = plt.subplots(figsize=(8, 6))
+    fig, ax = plt.subplots(figsize=(9, 7))
     
-    # Custom colormap for dark mode
-    cmap = sns.color_palette("Blues", as_cmap=True)
-    
-    sns.heatmap(cm, annot=True, fmt='d', cmap=cmap, ax=ax,
+    # Use a colormap with good contrast
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=ax,
                 xticklabels=['Legitimate', 'Fraud'],
                 yticklabels=['Legitimate', 'Fraud'],
-                annot_kws={'size': 16, 'color': 'white'},
-                cbar_kws={'label': 'Count'})
+                annot_kws={'size': 18, 'fontweight': 'bold'},
+                linewidths=2, linecolor='white',
+                cbar_kws={'label': 'Count', 'shrink': 0.8})
     
-    ax.set_xlabel('Predicted Label', fontsize=12)
-    ax.set_ylabel('True Label', fontsize=12)
-    ax.set_title(f'Confusion Matrix: {model_name}', fontsize=14, fontweight='bold')
+    ax.set_xlabel('Predicted Label', fontweight='bold', fontsize=12)
+    ax.set_ylabel('True Label', fontweight='bold', fontsize=12)
+    ax.set_title(f'Confusion Matrix: {model_name}', fontsize=15, fontweight='bold', pad=15)
     
-    # Add summary text
+    # Summary box
     tn, fp, fn, tp = cm.ravel()
-    text = f"TN: {tn} | FP: {fp}\nFN: {fn} | TP: {tp}"
-    ax.text(1.35, 0.5, text, transform=ax.transAxes, fontsize=10,
-            verticalalignment='center', 
-            bbox=dict(boxstyle='round', facecolor='#2d2d44', edgecolor='#e0e0e0', alpha=0.8))
+    summary = f"True Neg: {tn:,}\nFalse Pos: {fp:,}\nFalse Neg: {fn:,}\nTrue Pos: {tp:,}"
+    ax.text(1.25, 0.5, summary, transform=ax.transAxes, fontsize=11,
+            verticalalignment='center', fontfamily='monospace',
+            bbox=dict(boxstyle='round,pad=0.5', facecolor='#f0f0f0', edgecolor='#cccccc'))
     
     plt.tight_layout()
     return fig
 
 
 def plot_feature_importance(model, feature_names, model_name):
-    """Plot top 15 most important features with dark mode colors."""
+    """Plot top 15 most important features."""
+    setup_plot_style()
     fig, ax = plt.subplots(figsize=(10, 8))
     
-    # Get feature importances based on model type
+    # Get feature importances
     if hasattr(model, 'feature_importances_'):
         importances = model.feature_importances_
     elif hasattr(model, 'coef_'):
         importances = np.abs(model.coef_[0])
     else:
         ax.text(0.5, 0.5, 'Feature importance not available', 
-                ha='center', va='center', fontsize=14, color='#e0e0e0')
+                ha='center', va='center', fontsize=14)
+        ax.set_facecolor('white')
         return fig
     
-    # Create dataframe and sort
+    # Create and sort dataframe
     importance_df = pd.DataFrame({
         'Feature': feature_names,
         'Importance': importances
     }).sort_values('Importance', ascending=True).tail(15)
     
-    # Gradient colors
-    colors = plt.cm.Blues(np.linspace(0.4, 0.9, len(importance_df)))
-    ax.barh(importance_df['Feature'], importance_df['Importance'], color=colors)
+    # Gradient blue bars
+    colors = plt.cm.Blues(np.linspace(0.4, 0.85, len(importance_df)))
+    bars = ax.barh(importance_df['Feature'], importance_df['Importance'], color=colors, edgecolor='#333333', linewidth=0.5)
+    
+    # Add value labels
+    for bar, val in zip(bars, importance_df['Importance']):
+        ax.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2,
+                f'{val:.3f}', va='center', fontsize=9)
     
-    ax.set_xlabel('Importance Score', fontsize=12)
-    ax.set_title(f'Top 15 Feature Importances: {model_name}', fontsize=14, fontweight='bold')
-    ax.grid(True, alpha=0.3, axis='x')
+    ax.set_xlabel('Importance Score', fontweight='bold')
+    ax.set_title(f'Top 15 Feature Importances: {model_name}', fontsize=15, fontweight='bold', pad=15)
+    ax.grid(True, alpha=0.4, axis='x')
     
     plt.tight_layout()
     return fig
 
 
 def plot_threshold_analysis(y_test, y_proba, model_name):
-    """Plot threshold analysis with dark mode colors."""
+    """Plot threshold analysis."""
+    setup_plot_style()
     thresholds = np.arange(0.05, 0.95, 0.01)
-    precisions = []
-    recalls = []
-    f1_scores = []
+    precisions, recalls, f1_scores = [], [], []
     
     for thresh in thresholds:
         y_pred_thresh = (y_proba >= thresh).astype(int)
@@ -291,46 +321,104 @@ def plot_threshold_analysis(y_test, y_proba, model_name):
     
     fig, ax = plt.subplots(figsize=(10, 6))
     
-    ax.plot(thresholds, precisions, '#00d4ff', linewidth=2, label='Precision')
-    ax.plot(thresholds, recalls, '#00ff88', linewidth=2, label='Recall')
-    ax.plot(thresholds, f1_scores, '#ff6b6b', linewidth=2, label='F1 Score')
+    ax.plot(thresholds, precisions, color=COLORS['primary'], linewidth=2.5, label='Precision')
+    ax.plot(thresholds, recalls, color=COLORS['success'], linewidth=2.5, label='Recall')
+    ax.plot(thresholds, f1_scores, color=COLORS['danger'], linewidth=2.5, label='F1 Score')
+    
+    ax.axvline(x=best_threshold, color=COLORS['warning'], linestyle='--', linewidth=2,
+               label=f'Optimal = {best_threshold:.2f}')
+    ax.axvline(x=0.5, color='#888888', linestyle=':', linewidth=1.5, label='Default (0.5)')
     
-    ax.axvline(x=best_threshold, color='#ffd700', linestyle='--', 
-               label=f'Optimal Threshold = {best_threshold:.2f}')
-    ax.axvline(x=0.5, color='#888888', linestyle=':', alpha=0.7, label='Default (0.5)')
+    # Mark optimal point
+    ax.scatter([best_threshold], [f1_scores[best_idx]], color=COLORS['warning'], s=100, zorder=5)
     
-    ax.set_xlabel('Classification Threshold', fontsize=12)
-    ax.set_ylabel('Score', fontsize=12)
-    ax.set_title(f'Threshold Analysis: {model_name}', fontsize=14, fontweight='bold')
-    ax.legend(loc='best', facecolor='#1a1a2e', edgecolor='#e0e0e0')
+    ax.set_xlabel('Classification Threshold', fontweight='bold')
+    ax.set_ylabel('Score', fontweight='bold')
+    ax.set_title(f'Threshold Analysis: {model_name}', fontsize=15, fontweight='bold', pad=15)
+    ax.legend(loc='center right', fontsize=11, framealpha=0.95)
     ax.set_xlim([0, 1])
     ax.set_ylim([0, 1])
-    ax.grid(True, alpha=0.3)
+    ax.grid(True, alpha=0.4)
     
     plt.tight_layout()
     return fig
 
 
 def plot_class_distribution(train_df, test_df):
-    """Plot class distribution with dark mode colors."""
-    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
+    """Plot class distribution with clear, readable labels."""
+    setup_plot_style()
+    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
     
-    colors = ['#00ff88', '#ff6b6b']
-    explode = (0, 0.1)
+    colors = [COLORS['success'], COLORS['danger']]
+    explode = (0, 0.08)
     
     # Training data
-    train_counts = train_df['fraud'].value_counts()
-    axes[0].pie(train_counts, labels=['Legitimate', 'Fraud'], autopct='%1.1f%%',
-                colors=colors, explode=explode, shadow=True, startangle=90,
-                textprops={'color': '#e0e0e0', 'fontsize': 11})
-    axes[0].set_title('Training Data Distribution', fontsize=14, fontweight='bold')
+    train_fraud = train_df['fraud'].sum()
+    train_legit = len(train_df) - train_fraud
+    train_sizes = [train_legit, train_fraud]
+    train_pct = [train_legit/len(train_df)*100, train_fraud/len(train_df)*100]
+    
+    wedges1, texts1, autotexts1 = axes[0].pie(
+        train_sizes, 
+        explode=explode,
+        colors=colors,
+        autopct='%1.1f%%',
+        startangle=90,
+        shadow=False,
+        wedgeprops={'edgecolor': 'white', 'linewidth': 2}
+    )
+    
+    # Style the percentage text
+    for autotext in autotexts1:
+        autotext.set_color('white')
+        autotext.set_fontsize(14)
+        autotext.set_fontweight('bold')
+    
+    axes[0].set_title('Training Data Distribution', fontsize=14, fontweight='bold', pad=10)
+    
+    # Add legend with counts
+    axes[0].legend(
+        wedges1, 
+        [f'Legitimate: {train_legit:,} ({train_pct[0]:.1f}%)', 
+         f'Fraud: {train_fraud:,} ({train_pct[1]:.1f}%)'],
+        loc='lower center',
+        bbox_to_anchor=(0.5, -0.15),
+        fontsize=11,
+        framealpha=0.95
+    )
     
     # Test data
-    test_counts = test_df['fraud'].value_counts()
-    axes[1].pie(test_counts, labels=['Legitimate', 'Fraud'], autopct='%1.1f%%',
-                colors=colors, explode=explode, shadow=True, startangle=90,
-                textprops={'color': '#e0e0e0', 'fontsize': 11})
-    axes[1].set_title('Test Data Distribution', fontsize=14, fontweight='bold')
+    test_fraud = test_df['fraud'].sum()
+    test_legit = len(test_df) - test_fraud
+    test_sizes = [test_legit, test_fraud]
+    test_pct = [test_legit/len(test_df)*100, test_fraud/len(test_df)*100]
+    
+    wedges2, texts2, autotexts2 = axes[1].pie(
+        test_sizes,
+        explode=explode,
+        colors=colors,
+        autopct='%1.1f%%',
+        startangle=90,
+        shadow=False,
+        wedgeprops={'edgecolor': 'white', 'linewidth': 2}
+    )
+    
+    for autotext in autotexts2:
+        autotext.set_color('white')
+        autotext.set_fontsize(14)
+        autotext.set_fontweight('bold')
+    
+    axes[1].set_title('Test Data Distribution', fontsize=14, fontweight='bold', pad=10)
+    
+    axes[1].legend(
+        wedges2,
+        [f'Legitimate: {test_legit:,} ({test_pct[0]:.1f}%)',
+         f'Fraud: {test_fraud:,} ({test_pct[1]:.1f}%)'],
+        loc='lower center',
+        bbox_to_anchor=(0.5, -0.15),
+        fontsize=11,
+        framealpha=0.95
+    )
     
     fig.suptitle('Class Imbalance in Fraud Detection Dataset', fontsize=16, fontweight='bold', y=1.02)
     plt.tight_layout()
@@ -338,40 +426,42 @@ def plot_class_distribution(train_df, test_df):
 
 
 def plot_model_comparison(all_metrics):
-    """Bar chart comparing all 4 models with dark mode colors."""
+    """Bar chart comparing all models."""
+    setup_plot_style()
     fig, ax = plt.subplots(figsize=(12, 6))
     
-    models = list(all_metrics.keys())
+    models_list = list(all_metrics.keys())
     metrics = ['Accuracy', 'Precision', 'Recall', 'F1 Score', 'ROC AUC']
     
     x = np.arange(len(metrics))
     width = 0.2
     
-    colors = ['#00d4ff', '#00ff88', '#ff6b6b', '#ffd700']
+    colors = [COLORS['primary'], COLORS['success'], COLORS['danger'], COLORS['purple']]
     
-    for i, model in enumerate(models):
+    for i, model in enumerate(models_list):
         values = [all_metrics[model][m] for m in metrics]
-        bars = ax.bar(x + i*width, values, width, label=model, color=colors[i])
+        bars = ax.bar(x + i*width, values, width, label=model, color=colors[i], 
+                     edgecolor='white', linewidth=0.5)
         
-        # Add value labels on bars
+        # Add value labels
         for bar, v in zip(bars, values):
-            ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.02, 
-                   f'{v:.2f}', ha='center', va='bottom', fontsize=8, color='#e0e0e0')
+            ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.02,
+                   f'{v:.2f}', ha='center', va='bottom', fontsize=9, fontweight='bold')
     
-    ax.set_ylabel('Score', fontsize=12)
-    ax.set_title('Model Performance Comparison', fontsize=14, fontweight='bold')
+    ax.set_ylabel('Score', fontweight='bold')
+    ax.set_title('Model Performance Comparison', fontsize=15, fontweight='bold', pad=15)
     ax.set_xticks(x + width * 1.5)
-    ax.set_xticklabels(metrics)
-    ax.legend(loc='upper left', bbox_to_anchor=(1, 1), facecolor='#1a1a2e', edgecolor='#e0e0e0')
+    ax.set_xticklabels(metrics, fontweight='bold')
+    ax.legend(loc='upper right', fontsize=10, framealpha=0.95)
     ax.set_ylim([0, 1.15])
-    ax.grid(True, alpha=0.3, axis='y')
+    ax.grid(True, alpha=0.4, axis='y')
     
     plt.tight_layout()
     return fig
 
 
 # ============================================================================
-# LOAD DATA AND TRAIN MODELS AT STARTUP
+# LOAD DATA AND TRAIN MODELS
 # ============================================================================
 
 print("Loading data...")
@@ -380,7 +470,7 @@ X_train, X_test, y_train, y_test, train_df, test_df = load_and_prepare_data()
 print("Applying SMOTE to handle class imbalance...")
 X_train_balanced, y_train_balanced = apply_smote(X_train, y_train)
 
-print("Training models (this may take a moment)...")
+print("Training models...")
 models = get_models()
 trained_models = {}
 all_metrics = {}
@@ -399,12 +489,12 @@ print("Models trained successfully!")
 
 
 # ============================================================================
-# GRADIO INTERFACE FUNCTIONS
+# GRADIO INTERFACE
 # ============================================================================
 
 def get_data_overview():
-    """Return dataset summary."""
-    summary = f"""
+    """Dataset summary."""
+    return f"""
 ## Dataset Overview
 
 ### Training Data
@@ -419,17 +509,16 @@ def get_data_overview():
 
 ### Features
 - **Number of Features:** {X_train.shape[1]}
-- **Feature Types:** All numeric (pre-processed and one-hot encoded)
+- **Feature Types:** All numeric (pre-processed)
 
 ### Class Imbalance Handling
 - Applied **SMOTE** (Synthetic Minority Over-sampling Technique)
 - Training samples after SMOTE: {len(X_train_balanced):,}
 """
-    return summary
 
 
 def update_model_display(model_name):
-    """Update metrics display when model is selected."""
+    """Update metrics when model is selected."""
     metrics = all_metrics[model_name]
     y_pred = all_predictions[model_name]
     y_proba = all_probabilities[model_name]
@@ -437,7 +526,7 @@ def update_model_display(model_name):
     best_thresh, best_f1, _, _ = find_optimal_threshold(y_test, y_proba)
     
     metrics_text = f"""
-## {model_name} Performance Metrics
+## {model_name} Performance
 
 | Metric | Score |
 |--------|-------|
@@ -460,7 +549,7 @@ def update_model_display(model_name):
 
 
 def get_selected_plot(model_name, plot_type):
-    """Generate selected plot for chosen model."""
+    """Generate selected plot."""
     y_proba = all_probabilities[model_name]
     y_pred = all_predictions[model_name]
     
@@ -478,53 +567,31 @@ def get_selected_plot(model_name, plot_type):
 
 
 def get_comparison_results():
-    """Generate comparison table and plot."""
+    """Generate comparison."""
     comparison_df = pd.DataFrame(all_metrics).T.round(4)
-    
     best_models = comparison_df.idxmax()
     
-    summary = "## Model Comparison Summary\n\n"
-    summary += "| Metric | Best Model | Score |\n|--------|------------|-------|\n"
+    summary = "## Best Model by Metric\n\n| Metric | Best Model | Score |\n|--------|------------|-------|\n"
     for metric in comparison_df.columns:
         best = best_models[metric]
         score = comparison_df.loc[best, metric]
-        summary += f"| {metric} | {best} | {score:.4f} |\n"
+        summary += f"| {metric} | **{best}** | {score:.4f} |\n"
     
     return comparison_df.to_markdown(), summary, plot_model_comparison(all_metrics)
 
 
 def update_threshold_plot(model_name):
-    """Update threshold analysis plot."""
-    y_proba = all_probabilities[model_name]
-    return plot_threshold_analysis(y_test, y_proba, model_name)
+    """Update threshold plot."""
+    return plot_threshold_analysis(y_test, all_probabilities[model_name], model_name)
 
 
-# ============================================================================
-# GRADIO UI LAYOUT
-# ============================================================================
-
-# Use a dark-friendly theme
-with gr.Blocks(
-    title="Auto Insurance Fraud Detection",
-    theme=gr.themes.Base(
-        primary_hue="blue",
-        secondary_hue="slate",
-        neutral_hue="slate",
-    ).set(
-        body_background_fill="#0f0f1a",
-        body_background_fill_dark="#0f0f1a",
-        block_background_fill="#1a1a2e",
-        block_background_fill_dark="#1a1a2e",
-        border_color_primary="#3a3a5c",
-        border_color_primary_dark="#3a3a5c",
-    )
-) as demo:
+# Build UI
+with gr.Blocks(title="Auto Insurance Fraud Detection", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("""
     # 🚗 Auto Insurance Claims Fraud Detection
     
-    This application demonstrates machine learning models for detecting fraudulent auto insurance claims.
-    The models are trained on historical claims data and can predict whether a claim is likely fraudulent.
+    Machine learning models for detecting fraudulent auto insurance claims.
     
     **Models:** XGBoost | LightGBM | Random Forest | Logistic Regression
     """)
@@ -533,7 +600,7 @@ with gr.Blocks(
         # Tab 1: Data Overview
         with gr.TabItem("📊 Data Overview"):
             gr.Markdown(get_data_overview())
-            dist_plot = gr.Plot(value=plot_class_distribution(train_df, test_df))
+            gr.Plot(value=plot_class_distribution(train_df, test_df))
         
         # Tab 2: Model Evaluation
         with gr.TabItem("🎯 Model Evaluation"):
@@ -562,69 +629,42 @@ with gr.Blocks(
                 plot = get_selected_plot(model_name, plot_type)
                 return metrics, report, plot
             
-            model_selector.change(
-                fn=update_all,
-                inputs=[model_selector, plot_selector],
-                outputs=[metrics_display, report_display, plot_display]
-            )
-            plot_selector.change(
-                fn=update_all,
-                inputs=[model_selector, plot_selector],
-                outputs=[metrics_display, report_display, plot_display]
-            )
-            
-            demo.load(
-                fn=update_all,
-                inputs=[model_selector, plot_selector],
-                outputs=[metrics_display, report_display, plot_display]
-            )
+            model_selector.change(fn=update_all, inputs=[model_selector, plot_selector],
+                                 outputs=[metrics_display, report_display, plot_display])
+            plot_selector.change(fn=update_all, inputs=[model_selector, plot_selector],
+                                outputs=[metrics_display, report_display, plot_display])
+            demo.load(fn=update_all, inputs=[model_selector, plot_selector],
+                     outputs=[metrics_display, report_display, plot_display])
         
-        # Tab 3: Model Comparison
+        # Tab 3: Compare Models
         with gr.TabItem("📈 Compare Models"):
-            gr.Markdown("## All Models Performance Comparison")
-            
             comparison_table, comparison_summary, comparison_plot = get_comparison_results()
-            
+            gr.Markdown("## All Models Performance Comparison")
             gr.Markdown(comparison_summary)
             gr.Markdown(comparison_table)
             gr.Plot(value=comparison_plot)
         
-        # Tab 4: Threshold Analysis
+        # Tab 4: Threshold
         with gr.TabItem("⚖️ Threshold Optimization"):
             gr.Markdown("""
-            ## Finding the Optimal Classification Threshold
+            ## Finding the Optimal Threshold
             
-            In fraud detection, the default 0.5 threshold often isn't optimal. 
-            We need to balance catching frauds (recall) vs. false alarms (precision).
-            The optimal threshold maximizes F1 score.
+            The default 0.5 threshold often isn't optimal for imbalanced data.
+            We balance **Recall** (catching frauds) vs **Precision** (avoiding false alarms).
             """)
             
-            thresh_model = gr.Dropdown(
-                choices=list(models.keys()),
-                value="XGBoost",
-                label="Select Model for Threshold Analysis"
-            )
-            
+            thresh_model = gr.Dropdown(choices=list(models.keys()), value="XGBoost",
+                                       label="Select Model")
             thresh_plot = gr.Plot()
             
-            thresh_model.change(
-                fn=update_threshold_plot,
-                inputs=[thresh_model],
-                outputs=[thresh_plot]
-            )
+            thresh_model.change(fn=update_threshold_plot, inputs=[thresh_model], outputs=[thresh_plot])
+            demo.load(fn=update_threshold_plot, inputs=[thresh_model], outputs=[thresh_plot])
             
-            demo.load(
-                fn=update_threshold_plot,
-                inputs=[thresh_model],
-                outputs=[thresh_plot]
-            )
-            
-            # Optimal thresholds table
-            thresh_summary = "### Optimal Thresholds by Model\n\n| Model | Optimal Threshold | F1 at Optimal |\n|-------|-------------------|---------------|\n"
+            # Thresholds table
+            thresh_summary = "### Optimal Thresholds\n\n| Model | Threshold | F1 Score |\n|-------|-----------|----------|\n"
             for name in models.keys():
-                opt_thresh, opt_f1, _, _ = find_optimal_threshold(y_test, all_probabilities[name])
-                thresh_summary += f"| {name} | {opt_thresh:.2f} | {opt_f1:.4f} |\n"
-            
+                opt_t, opt_f1, _, _ = find_optimal_threshold(y_test, all_probabilities[name])
+                thresh_summary += f"| {name} | {opt_t:.2f} | {opt_f1:.4f} |\n"
             gr.Markdown(thresh_summary)
         
         # Tab 5: About
@@ -633,30 +673,19 @@ with gr.Blocks(
             ## About This Project
             
             ### Business Context
-            Auto insurance fraud costs the industry billions of dollars annually. 
-            This project builds ML models to flag potentially fraudulent claims.
+            Auto insurance fraud costs billions annually. This tool flags potentially fraudulent claims.
             
-            ### Technical Approach
-            1. **Data Preparation:** 46 features describing claims and customers
-            2. **Class Imbalance:** ~3% fraud rate, handled with SMOTE
-            3. **Model Training:** Four algorithms compared
-            4. **Evaluation:** Precision-Recall focus due to imbalance
-            5. **Threshold Optimization:** Find optimal cutoff for business needs
-            
-            ### Models Used
+            ### Models
             - **XGBoost:** Gradient boosting, excellent for tabular data
-            - **LightGBM:** Fast, memory efficient gradient boosting
-            - **Random Forest:** Robust ensemble of decision trees
-            - **Logistic Regression:** Interpretable linear baseline
+            - **LightGBM:** Fast, memory-efficient gradient boosting
+            - **Random Forest:** Robust ensemble method
+            - **Logistic Regression:** Interpretable baseline
             
             ### Key Metrics
-            - **Precision:** Of flagged claims, how many are actually fraud
-            - **Recall:** Of actual frauds, how many did we catch
-            - **F1 Score:** Harmonic mean balancing both metrics
-            - **ROC AUC:** Overall discrimination ability
+            - **Precision:** Of flagged claims, how many are actually fraud?
+            - **Recall:** Of actual frauds, how many did we catch?
+            - **F1 Score:** Balance of precision and recall
             """)
 
-
-# Launch
 if __name__ == "__main__":
     demo.launch()