Update app.py

app.py

@@ -12,12 +12,10 @@ import time
 import psutil
 import shutil
 import ast
-import seaborn as sns
-from sklearn.svm import SVC
 from smolagents import HfApiModel, CodeAgent
 from huggingface_hub import login
 from sklearn.model_selection import train_test_split, cross_val_score
-from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, classification_report
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
 from sklearn.metrics import ConfusionMatrixDisplay
 from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
 from sklearn.linear_model import LogisticRegression
@@ -254,196 +252,51 @@ def train_model(_):
         print(f"Training Error: {e}")
         return {}, pd.DataFrame()
 
-# Added a/b functions to existing code
-def create_model_comparison_plots(results_df):
-    """Create visualizations for model comparison results"""
-    os.makedirs('./comparison_plots', exist_ok=True)
-    plot_paths = []
-    
-    # Model performance comparison
-    plt.figure(figsize=(12, 6))
-    sns.barplot(data=results_df, x='Model', y='Test Accuracy')
-    plt.title('Model Accuracy Comparison')
-    plt.xticks(rotation=45)
-    accuracy_path = './comparison_plots/accuracy_comparison.png'
-    plt.savefig(accuracy_path, bbox_inches='tight')
-    plot_paths.append(accuracy_path)
-    plt.close()
-    
-    # Metric radar chart
-    metrics = ['Test Accuracy', 'Precision', 'Recall', 'F1 Score']
-    if not results_df['ROC AUC'].isna().all():
-        metrics.append('ROC AUC')
-    
-    plt.figure(figsize=(10, 10))
-    ax = plt.subplot(111, polar=True)
-    
-    angles = np.linspace(0, 2*np.pi, len(metrics), endpoint=False)
-    angles = np.concatenate((angles, [angles[0]]))
-    
-    for idx, row in results_df.iterrows():
-        values = row[metrics].values.flatten().tolist()
-        values += values[:1]
-        ax.plot(angles, values, 'o-', label=row['Model'])
-    
-    ax.set_thetagrids(angles[:-1] * 180/np.pi, metrics)
-    ax.set_title('Model Performance Radar Chart')
-    ax.legend(bbox_to_anchor=(1.1, 1.1))
-    radar_path = './comparison_plots/radar_chart.png'
-    plt.savefig(radar_path, bbox_inches='tight')
-    plot_paths.append(radar_path)
-    plt.close()
-    
-    return plot_paths
-
-def compare_models_enhanced():
-    """Enhanced model comparison with more metrics and visualizations"""
+def ab_test_models():
     if df_global is None:
-        return "Please upload and preprocess a dataset first.", [], []
-    
+        return "Please upload and preprocess a dataset first.", pd.DataFrame()
+
     target = df_global.columns[-1]
-    X = df_global.drop(target, axis=1)
+    X = df_global.drop(columns=[target])
     y = df_global[target]
 
     if y.dtype == 'object':
         y = LabelEncoder().fit_transform(y)
-    
+
     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
-    
-    # Define models to compare
+
     models = {
-        "RandomForest": RandomForestClassifier(),
-        "LogisticRegression": LogisticRegression(max_iter=1000),
-        "GradientBoosting": GradientBoostingClassifier(),
-        "SVC": SVC(probability=True)
+        "Random Forest": RandomForestClassifier(n_estimators=100),
+        "Logistic Regression": LogisticRegression(max_iter=1000),
+        "Gradient Boosting": GradientBoostingClassifier()
     }
-    
-    results = []
-    
-    for name, model in models.items():
-        start_time = time.time()
-        
-        # Cross validation
-        cv_scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
-        
-        # Full training and test evaluation
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        y_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, 'predict_proba') else None
-        
-        # Calculate metrics
-        metrics = {
-            'Model': name,
-            'CV Mean Accuracy': np.mean(cv_scores),
-            'CV Std Dev': np.std(cv_scores),
-            'Test Accuracy': accuracy_score(y_test, y_pred),
-            'Precision': precision_score(y_test, y_pred, average='weighted'),
-            'Recall': recall_score(y_test, y_pred, average='weighted'),
-            'F1 Score': f1_score(y_test, y_pred, average='weighted'),
-            'ROC AUC': roc_auc_score(y_test, y_proba) if y_proba is not None and len(np.unique(y_test)) == 2 else np.nan,
-            'Training Time (s)': time.time() - start_time
-        }
-        
-        results.append(metrics)
-        
-        # Log to wandb
-        if wandb.run:
-            wandb.log({f"{name}_{k}": v for k, v in metrics.items() if k != 'Model'})
-    
-    # Create visualizations
-    results_df = pd.DataFrame(results)
-    plot_paths = create_model_comparison_plots(results_df)
-    
-    return results_df, plot_paths
 
-def perform_ab_test(model_a_name, model_b_name):
-    """Perform A/B test between two specific models"""
-    if df_global is None:
-        return {"error": "Please upload and preprocess a dataset first."}, []
-    
-    target = df_global.columns[-1]
-    X = df_global.drop(target, axis=1)
-    y = df_global[target]
+    results = []
 
-    if y.dtype == 'object':
-        y = LabelEncoder().fit_transform(y)
-    
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
-    
-    # Define all available models
-    model_library = {
-        "RandomForest": RandomForestClassifier(),
-        "LogisticRegression": LogisticRegression(max_iter=1000),
-        "GradientBoosting": GradientBoostingClassifier(),
-        "SVC": SVC(probability=True)
-    }
-    
-    # Get the selected models
-    model_a = model_library.get(model_a_name)
-    model_b = model_library.get(model_b_name)
-    
-    if not model_a or not model_b:
-        return {"error": "Invalid model selection"}, []
-    
-    # Train both models
-    model_a.fit(X_train, y_train)
-    model_b.fit(X_train, y_train)
-    
-    # Get predictions
-    y_pred_a = model_a.predict(X_test)
-    y_pred_b = model_b.predict(X_test)
-    
-    # Calculate metrics
-    metrics_a = {
-        'accuracy': accuracy_score(y_test, y_pred_a),
-        'precision': precision_score(y_test, y_pred_a, average='weighted'),
-        'recall': recall_score(y_test, y_pred_a, average='weighted'),
-        'f1': f1_score(y_test, y_pred_a, average='weighted')
-    }
-    
-    metrics_b = {
-        'accuracy': accuracy_score(y_test, y_pred_b),
-        'precision': precision_score(y_test, y_pred_b, average='weighted'),
-        'recall': recall_score(y_test, y_pred_b, average='weighted'),
-        'f1': f1_score(y_test, y_pred_b, average='weighted')
-    }
-    
-    # Calculate relative improvements
-    improvements = {
-        'accuracy_improvement': metrics_b['accuracy'] - metrics_a['accuracy'],
-        'f1_improvement': metrics_b['f1'] - metrics_a['f1'],
-        'relative_improvement': (metrics_b['accuracy'] - metrics_a['accuracy']) / metrics_a['accuracy'] if metrics_a['accuracy'] != 0 else 0
-    }
-    
-    # Create comparison DataFrame
-    comparison_df = pd.DataFrame({
-        'Metric': list(metrics_a.keys()),
-        model_a_name: list(metrics_a.values()),
-        model_b_name: list(metrics_b.values())
-    })
-    
-    # Log to wandb
-    if wandb.run:
-        wandb.log({
-            f"A_B_Test/{model_a_name}_metrics": metrics_a,
-            f"A_B_Test/{model_b_name}_metrics": metrics_b,
-            f"A_B_Test/Improvements": improvements
+    for name, clf in models.items():
+        clf.fit(X_train, y_train)
+        y_pred = clf.predict(X_test)
+        results.append({
+            "Model": name,
+            "Accuracy": accuracy_score(y_test, y_pred),
+            "Precision": precision_score(y_test, y_pred, average="weighted", zero_division=0),
+            "Recall": recall_score(y_test, y_pred, average="weighted", zero_division=0),
+            "F1 Score": f1_score(y_test, y_pred, average="weighted", zero_division=0)
         })
-    
-    # Create visualization
-    plt.figure(figsize=(10, 6))
-    comparison_df.set_index('Metric').plot(kind='bar', rot=0)
-    plt.title(f'A/B Test: {model_a_name} vs {model_b_name}')
-    plt.ylabel('Score')
-    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
-    plot_path = './comparison_plots/ab_test_comparison.png'
-    plt.savefig(plot_path, bbox_inches='tight')
-    plt.close()
-    
-    return {
-        'metrics_comparison': comparison_df.to_dict(),
-        'improvements': improvements
-    }, [plot_path]
+        wandb.log({f"{name}_metrics": results[-1]})
+
+    result_df = pd.DataFrame(results)
+    best_model = result_df.sort_values("F1 Score", ascending=False).iloc[0]
+
+    summary = f"""
+    🔍 <b>Best Model:</b> {best_model['Model']}<br>
+    ✅ <b>F1 Score:</b> {best_model['F1 Score']:.4f}<br>
+    📊 <b>Accuracy:</b> {best_model['Accuracy']:.4f}<br>
+    🧠 <b>Precision:</b> {best_model['Precision']:.4f}<br>
+    🔁 <b>Recall:</b> {best_model['Recall']:.4f}
+    """
+
+    return summary, result_df
 
 def explainability(_):
     import warnings
@@ -543,49 +396,16 @@ with gr.Blocks() as demo:
         explain_btn = gr.Button("SHAP + LIME Explainability")
         shap_img = gr.Image(label="SHAP Summary Plot")
         lime_img = gr.Image(label="LIME Explanation")
-  
-    # Add new A/B testing components
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 🆚 Model A/B Testing")
-            with gr.Row():
-                model_a_select = gr.Dropdown(
-                    choices=["RandomForest", "LogisticRegression", "GradientBoosting", "SVC"],
-                    label="Select Model A",
-                    value="RandomForest"
-                )
-                model_b_select = gr.Dropdown(
-                    choices=["RandomForest", "LogisticRegression", "GradientBoosting", "SVC"],
-                    label="Select Model B",
-                    value="LogisticRegression"
-                )
-            ab_test_btn = gr.Button("Run A/B Test")
-        
-        with gr.Column():
-            ab_test_results = gr.JSON(label="A/B Test Results")
-            ab_test_plots = gr.Gallery(label="A/B Test Visualizations")
+    
+    with gr.Blocks():
+        ab_test_button = gr.Button("Run A/B Testing")
+        ab_summary = gr.HTML()
+        ab_results = gr.Dataframe()
 
-    # Add model comparison components
-    with gr.Row():
-        compare_btn = gr.Button("Compare All Models")
-        comparison_results = gr.DataFrame(label="Model Comparison Results")
-        comparison_plots = gr.Gallery(label="Comparison Visualizations")
+        ab_test_button.click(fn=ab_test_models, inputs=[], outputs=[ab_summary, ab_results])
 
     agent_btn.click(fn=analyze_data, inputs=[file_input], outputs=[insights_output, visual_output])
     train_btn.click(fn=train_model, inputs=[file_input], outputs=[metrics_output, trials_output])
     explain_btn.click(fn=explainability, inputs=[], outputs=[shap_img, lime_img])
 
-    # New handlers for A/B testing and comparison
-    ab_test_btn.click(
-        fn=perform_ab_test,
-        inputs=[model_a_select, model_b_select],
-        outputs=[ab_test_results, ab_test_plots]
-    )
-    
-    compare_btn.click(
-        fn=compare_models_enhanced,
-        inputs=[],
-        outputs=[comparison_results, comparison_plots]
-    )
-
 demo.launch(debug=True)