update demo for ensemble learning

app.py

@@ -28,7 +28,7 @@ vlai_template.set_meta(
     description="Predict heart disease risk from patient data with ML models trained on the Cleveland dataset.",
     meta_items=[
         ("Dataset", "Cleveland Heart Disease"),
-        ("Models", "Decision Tree, k-NN, Naive Bayes"),
+        ("Models", "Decision Tree, k-NN, Naive Bayes, Random Forest, AdaBoost, Gradient Boosting, XGBoost"),
         ("Ensemble", "Soft Voting"),
     ],
 )
@@ -247,7 +247,9 @@ with gr.Blocks(theme="gstaff/sketch", css=vlai_template.custom_css, fill_width=T
     
     - **Models are trained once at launch** on `data/cleveland.csv` (80/20 split).
     - **Target is binarized automatically** (0 = no disease, >0 = disease).
-    - **Ensemble uses soft voting** over Decision Tree, k-NN, and Naive Bayes.
+    - **Seven models are compared**: Decision Tree, k-NN, Naive Bayes, Random Forest, AdaBoost, Gradient Boosting, and XGBoost.
+    - **Ensemble uses soft voting** over all individual models.
+    - **Best performing model** on test set is highlighted with 🏆 in the validation metrics table.
     - **Feature descriptions**:
       - `age`: Patient age in years
       - `sex`: Gender (0=female, 1=male)

requirements.txt

@@ -5,4 +5,5 @@ numpy>=1.24.0
 dtreeviz>=2.2.2
 graphviz>=0.20.3
 plotly>=5.15.0
-supertree>=0.5.5
+supertree>=0.5.5
+xgboost>=1.6.0

src/heart_disease_core.py

@@ -12,7 +12,18 @@ from sklearn.metrics import roc_auc_score, accuracy_score, precision_score, reca
 from sklearn.tree import DecisionTreeClassifier
 from sklearn.neighbors import KNeighborsClassifier
 from sklearn.naive_bayes import GaussianNB
-from sklearn.ensemble import VotingClassifier
+from sklearn.ensemble import VotingClassifier, RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier
+
+# Handle XGBoost import gracefully
+XGBOOST_AVAILABLE = False
+XGBClassifier = None
+try:
+    from xgboost import XGBClassifier
+    XGBOOST_AVAILABLE = True
+except (ImportError, Exception):
+    # Handle both import errors and library loading errors
+    XGBOOST_AVAILABLE = False
+    XGBClassifier = None
 
 
 CLEVELAND_FEATURES_ORDER: List[str] = [
@@ -142,22 +153,77 @@ def build_models() -> Dict[str, Pipeline]:
         ("clf", GaussianNB())
     ])
 
+    rf = Pipeline(steps=[
+        ("prep", pre),
+        ("clf", RandomForestClassifier(
+            random_state=42,
+            n_estimators=100,
+            max_depth=5,
+            min_samples_split=2,
+            min_samples_leaf=1
+        ))
+    ])
+
+    ada = Pipeline(steps=[
+        ("prep", pre),
+        ("clf", AdaBoostClassifier(
+            random_state=42,
+            n_estimators=100,
+            learning_rate=1.0
+        ))
+    ])
+
+    gb = Pipeline(steps=[
+        ("prep", pre),
+        ("clf", GradientBoostingClassifier(
+            random_state=42,
+            n_estimators=100,
+            learning_rate=0.1,
+            max_depth=3
+        ))
+    ])
+
+    models = {"Decision Tree": dt, "k-NN": knn, "Naive Bayes": nb, "Random Forest": rf, "AdaBoost": ada, "Gradient Boosting": gb}
+
+    # Add XGBoost if available
+    if XGBOOST_AVAILABLE:
+        xgb = Pipeline(steps=[
+            ("prep", pre),
+            ("clf", XGBClassifier(
+                random_state=42,
+                n_estimators=100,
+                learning_rate=0.1,
+                max_depth=3,
+                eval_metric='logloss'
+            ))
+        ])
+        models["XGBoost"] = xgb
+
     # Soft Voting requires raw estimators, not Pipelines that share the same preprocessor.
     # Easiest: ensemble as a single Pipeline with a VotingClassifier inside.
+    estimators = [
+        ("dt", DecisionTreeClassifier(random_state=42, max_depth=5, min_samples_split=2, min_samples_leaf=1, criterion="gini")),
+        ("knn", KNeighborsClassifier(n_neighbors=5)),
+        ("nb", GaussianNB()),
+        ("rf", RandomForestClassifier(random_state=42, n_estimators=100, max_depth=5, min_samples_split=2, min_samples_leaf=1)),
+        ("ada", AdaBoostClassifier(random_state=42, n_estimators=100, learning_rate=1.0)),
+        ("gb", GradientBoostingClassifier(random_state=42, n_estimators=100, learning_rate=0.1, max_depth=3)),
+    ]
+    
+    if XGBOOST_AVAILABLE:
+        estimators.append(("xgb", XGBClassifier(random_state=42, n_estimators=100, learning_rate=0.1, max_depth=3, eval_metric='logloss')))
+
     ensemble = Pipeline(steps=[
         ("prep", pre),
         ("clf", VotingClassifier(
-            estimators=[
-                ("dt", DecisionTreeClassifier(random_state=42, max_depth=5, min_samples_split=2, min_samples_leaf=1, criterion="gini")),
-                ("knn", KNeighborsClassifier(n_neighbors=5)),
-                ("nb", GaussianNB()),
-            ],
+            estimators=estimators,
             voting="soft",
             weights=None  # can tweak later
         ))
     ])
 
-    return {"Decision Tree": dt, "k-NN": knn, "Naive Bayes": nb, "Ensemble (Soft Voting)": ensemble}
+    models["Ensemble (Soft Voting)"] = ensemble
+    return models
 
 def fit_all_models(df: pd.DataFrame, test_size: float = 0.2, random_state: int = 42) -> Tuple[Dict[str, Pipeline], pd.DataFrame]:
     """
@@ -191,7 +257,7 @@ def fit_all_models(df: pd.DataFrame, test_size: float = 0.2, random_state: int =
         f1 = f1_score(y_te, y_pred, zero_division=0)
 
         metrics.append({
-            "model": name,
+            "Model": name,
             "ROC-AUC": round(float(auc), 4),
             "Accuracy": round(float(acc), 4),
             "Precision": round(float(prec), 4),
@@ -200,6 +266,17 @@ def fit_all_models(df: pd.DataFrame, test_size: float = 0.2, random_state: int =
         })
 
     metrics_df = pd.DataFrame(metrics).sort_values("ROC-AUC", ascending=False, ignore_index=True)
+    
+    # Add performance ranking and highlight best performance
+    metrics_df["Rank"] = range(1, len(metrics_df) + 1)
+    
+    # Mark the best performing model
+    best_model_idx = metrics_df["ROC-AUC"].idxmax()
+    metrics_df.loc[best_model_idx, "Model"] = "🏆 " + metrics_df.loc[best_model_idx, "Model"] + " (BEST)"
+    
+    # Reorder columns to show rank first
+    metrics_df = metrics_df[["Rank", "Model", "ROC-AUC", "Accuracy", "Precision", "Recall", "F1"]]
+    
     return models, metrics_df
 
 def predict_all(models: Dict[str, Pipeline], input_dict: Dict[str, float]) -> Dict[str, Dict[str, float]]: