Update app.py

app.py

@@ -1,15 +1,18 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+from io import BytesIO
 from sklearn.model_selection import train_test_split
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.metrics import classification_report
 
-# Global variables to store data
 original_df = None
 processed_df = None
+trained_model = None
+processed_X_columns = None  # Keep processed features list for importances
 
-# STEP 1: Load data from file (CSV or Excel)
 def load_data(file):
     global original_df
     try:
@@ -17,128 +20,126 @@ def load_data(file):
             original_df = pd.read_csv(file)
         else:
             original_df = pd.read_excel(file)
-        return original_df.head(10), "✅ File loaded successfully."
+        help_text = (
+            "Step 1: Data loaded successfully! Here you see a preview of the first 10 rows.\n"
+            "Next, click 'Process Data' to discretize numeric columns and add word counts."
+        )
+        return original_df.head(10), "✅ File loaded successfully.", help_text
     except Exception as e:
-        return pd.DataFrame(), f"❌ Error loading file: {e}"
+        return pd.DataFrame(), f"❌ Error loading file: {e}", "Please upload a valid CSV or Excel file."
 
-# STEP 2: Process data
-# - Discretize numeric columns into quartiles (4 bins) and deciles (10 bins)
-# - Count words in text columns
 def process_data():
     global original_df, processed_df
-
     if original_df is None:
-        return pd.DataFrame(), gr.update(choices=[]), gr.update(choices=[]), "⚠️ Please load a dataset first."
-
+        return pd.DataFrame(), gr.update(choices=[]), gr.update(choices=[]), "⚠️ Please load a dataset first.", ""
     df = original_df.copy()
-
-    # Discretize numeric columns into quartiles
+    # Quartiles
     for col in df.select_dtypes(include=np.number).columns:
         try:
             df[col + "_qbin"] = pd.qcut(df[col], 4, labels=False, duplicates='drop')
         except Exception:
-            pass  # skip if not suitable for binning
-
-    # Discretize numeric columns into deciles
+            pass
+    # Deciles
     for col in df.select_dtypes(include=np.number).columns:
         try:
             df[col + "_decil"] = pd.qcut(df[col], 10, labels=False, duplicates='drop')
         except Exception:
-            pass  # skip if not suitable for binning
-
-    # Add word count for text/object columns
+            pass
+    # Word counts
     for col in df.select_dtypes(include='object').columns:
         df[col + "_wordcount"] = df[col].astype(str).apply(lambda x: len(x.split()))
-
     processed_df = df.copy()
-
-    # Update dropdown choices with all columns including new ones
     all_columns = df.columns.tolist()
-
-    return (
-        df.head(10),
-        gr.update(choices=all_columns),
-        gr.update(choices=all_columns),
-        "✅ Data processed: quartiles, deciles, and word counts added."
+    help_text = (
+        "Step 2: Data processed!\n"
+        "- Numeric columns discretized into quartiles and deciles.\n"
+        "- Word counts added for text columns.\n"
+        "You can now select your target and feature columns."
     )
+    return df.head(10), gr.update(choices=all_columns), gr.update(choices=all_columns), "✅ Data processed.", help_text
 
-# STEP 3: Train model
-# - Select target and features from dropdown and checkbox group
-# - Train RandomForestClassifier and show classification report
 def train_model(target_col, feature_cols):
-    global processed_df
-
+    global processed_df, trained_model, processed_X_columns
     if processed_df is None:
-        return "⚠️ Please process your data first."
-
+        return "⚠️ Please process your data first.", None, ""
     if not target_col or not feature_cols:
-        return "⚠️ Please select a target column and at least one feature."
-
+        return "⚠️ Please select a target and at least one feature.", None, ""
     try:
         X = processed_df[feature_cols]
         y = processed_df[target_col]
-
-        # Convert categorical variables into dummy/indicator variables
         X = pd.get_dummies(X)
-
-        # Split data into train and test sets
+        processed_X_columns = X.columns.tolist()
         X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-
-        # Train Random Forest classifier
         clf = RandomForestClassifier(random_state=42)
         clf.fit(X_train, y_train)
-
-        # Predict on test set
+        trained_model = clf
         y_pred = clf.predict(X_test)
-
-        # Generate classification report
         report = classification_report(y_test, y_pred)
-        return report
+
+        help_text = (
+            "Step 3: Model trained!\n"
+            "- Classification report shows precision, recall, f1-score per class.\n"
+            "- Below is a heatmap of feature importances to help interpret what features influenced the model most."
+        )
+        # Create heatmap plot and return as image
+        fi = clf.feature_importances_
+        fi_df = pd.DataFrame({'Feature': processed_X_columns, 'Importance': fi})
+        fi_df = fi_df.sort_values(by='Importance', ascending=False).head(20)  # Top 20 features for clarity
+
+        plt.figure(figsize=(8,6))
+        sns.heatmap(fi_df.set_index('Feature').T, annot=True, cmap="YlGnBu", cbar_kws={'label': 'Feature Importance'})
+        plt.title("Feature Importances Heatmap (Top 20)")
+        plt.tight_layout()
+
+        buf = BytesIO()
+        plt.savefig(buf, format="png")
+        plt.close()
+        buf.seek(0)
+
+        return report, buf.read(), help_text
     except Exception as e:
-        return f"❌ Model training failed: {e}"
+        return f"❌ Model training failed: {e}", None, ""
 
-# Build Gradio Interface
-with gr.Blocks(title="Step-by-Step Model Trainer with Deciles & Word Count") as app:
-    gr.Markdown("## 🧠 Step-by-Step Model Trainer\nUpload your data, process it (discretize & count words), then train a model.")
+with gr.Blocks(title="Step-by-Step Model Trainer with Help and Heatmap") as app:
+    gr.Markdown("## 🧠 Step-by-Step Model Trainer\nUpload your data, process it, train a model, and get help at each step!")
 
-    # Step 1: File upload
     with gr.Row():
         file_input = gr.File(label="📁 Upload CSV or Excel file")
         load_status = gr.Textbox(label="ℹ️ File Load Status", interactive=False)
 
     original_preview = gr.DataFrame(label="🔍 Original Data Preview (first 10 rows)")
+    load_help = gr.Textbox(label="📖 Step 1 Help", interactive=False)
 
-    # Step 2: Process data
-    process_button = gr.Button("⚙️ Process Data (Discretize & Word Count)")
+    process_button = gr.Button("⚙️ Process Data")
     processed_preview = gr.DataFrame(label="🔬 Processed Data Preview (first 10 rows)")
     process_status = gr.Textbox(label="ℹ️ Process Status", interactive=False)
+    process_help = gr.Textbox(label="📖 Step 2 Help", interactive=False)
 
-    # Step 3: Select target and features for model training
     target_selector = gr.Dropdown(label="🎯 Select Target Column", choices=[])
     feature_selector = gr.CheckboxGroup(label="📊 Select Feature Columns", choices=[])
 
-    # Step 4: Train model
     train_button = gr.Button("🚀 Train Model")
     train_output = gr.Textbox(label="📈 Classification Report", lines=10)
+    train_help = gr.Textbox(label="📖 Step 3 Help", interactive=False)
+    heatmap_img = gr.Image(label="🔥 Feature Importances Heatmap")
 
-    # Events & callbacks
+    # Callbacks
     file_input.change(
         fn=load_data,
         inputs=[file_input],
-        outputs=[original_preview, load_status]
+        outputs=[original_preview, load_status, load_help]
     )
 
     process_button.click(
         fn=process_data,
         inputs=[],
-        outputs=[processed_preview, target_selector, feature_selector, process_status]
+        outputs=[processed_preview, target_selector, feature_selector, process_status, process_help]
     )
 
     train_button.click(
         fn=train_model,
         inputs=[target_selector, feature_selector],
-        outputs=[train_output]
+        outputs=[train_output, heatmap_img, train_help]
     )
 
-# Launch app
 app.launch()