Add app.py, backend, and model for HF Space

app.py

@@ -78,7 +78,7 @@ if not os.path.exists(MODEL_PATH):
 
 if st.button("Train Model"):
     st.info("Training started...")
-    model = train_model(MODEL_PATH, REPORTS_DIR, PLOTS_DIR)
+    model = train_model()
     joblib.dump(model, MODEL_PATH)
     st.success(f"Model trained and saved to {MODEL_PATH}")
 elif page == "Predict":

backend/train_model.py

@@ -1,197 +1,131 @@
-import os, json, warnings
-
-from datasets import load_dataset
-
-warnings.filterwarnings("ignore")
+import os
+import json
+import warnings
 import numpy as np
 import pandas as pd
 import joblib
 from scipy import stats
 import matplotlib.pyplot as plt
-import seaborn as sns
-from sklearn.model_selection import train_test_split, GridSearchCV,StratifiedKFold
+from datasets import load_dataset
+
+from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import (
-    accuracy_score, f1_score, precision_score, recall_score,
-    classification_report, log_loss
-)
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report
 from sklearn.linear_model import LogisticRegression
 from sklearn.tree import DecisionTreeClassifier
 from sklearn.ensemble import RandomForestClassifier, BaggingClassifier
-from .utils import (
-    ensure_dirs, save_json, plot_cm, plot_roc, barplot_metric,
-    lineplot_curves
-)
 
+from utils import ensure_dirs, save_json, plot_cm, plot_roc, barplot_metric, lineplot_curves
+
+warnings.filterwarnings("ignore")
 
 # ------------------------------
-# Paths
+# Base paths
 # ------------------------------
-# DATA_PATH = os.path.join(ROOT, "data", "diabetes.csv")
-# ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-# DATA_PATH = os.path.join(ROOT, "data", "diabetes.csv")
-# Use shared folders at project root
-MODEL_DIR = "models"              # volume for models
-REPORTS_DIR = "reports"           # volume for reports
+BASE_DIR = os.getcwd()  # repo folder in Hugging Face Spaces
+MODEL_DIR = os.path.join(BASE_DIR, "models")
+REPORTS_DIR = os.path.join(BASE_DIR, "reports")
 PLOTS_DIR = os.path.join(REPORTS_DIR, "plots")
 
-
-# Make sure folders exist
+# Ensure folders exist
 os.makedirs(MODEL_DIR, exist_ok=True)
 os.makedirs(REPORTS_DIR, exist_ok=True)
 os.makedirs(PLOTS_DIR, exist_ok=True)
 
 
-# def train_and_get_model():
-#     """Train the model (or reload if exists) and return it"""
-# ------------------------------
-# Load data
-# ------------------------------
-# if not os.path.exists(DATA_PATH):
-#     raise FileNotFoundError(f"Dataset not found at {DATA_PATH}")
-
-### Load with hugging face dataset
-def train_model(MODEL_DIR, REPORTS_DIR, PLOTS_DIR):
+def train_model():
+    # Load dataset
     ds = load_dataset("jonathansuru/diabetes")
-    df = ds['train'].to_pandas()
+    df = ds["train"].to_pandas()
     X = df.drop("Outcome", axis=1)
     Y = df["Outcome"].astype(int)
     print(f"[INFO] Loaded dataset: {df.shape[0]} rows, {df.shape[1]} cols")
 
-    # ------------------------------
-    # Outlier removal (z-score)
-    # ------------------------------
+    # Outlier removal
     z = np.abs(stats.zscore(X))
-    non_outlier_mask = (z < 3).all(axis=1)
-    X_clean = X[non_outlier_mask]
-    Y_clean = Y[non_outlier_mask]
-    print(f"[INFO] Outliers removed: {len(X) - len(X_clean)} | Clean size:{len(X_clean)}")
+    mask = (z < 3).all(axis=1)
+    X_clean, Y_clean = X[mask], Y[mask]
+    print(f"[INFO] Outliers removed: {len(X) - len(X_clean)} | Clean size: {len(X_clean)}")
 
-    # Variance comparison
+    # Save variance comparison
     var_df = pd.DataFrame({"Before": X.var(), "After": X_clean.var()})
     var_df.to_csv(os.path.join(REPORTS_DIR, "variance_before_after.csv"))
     plt.figure(figsize=(10,5))
-    var_df.plot(kind='bar')
+    var_df.plot(kind="bar")
     plt.title("Feature Variance: Before vs After Outlier Removal")
     plt.ylabel("Variance")
-    plt.xticks(rotation=45, ha='right')
+    plt.xticks(rotation=45, ha="right")
     plt.tight_layout()
-    plt.savefig(os.path.join(PLOTS_DIR, "variance_comparison.png"), bbox_inches='tight')
+    plt.savefig(os.path.join(PLOTS_DIR, "variance_comparison.png"), bbox_inches="tight")
     plt.close()
 
-    # ------------------------------
-    # Split
-    # ------------------------------
+    # Train/test split
     X_train, X_test, y_train, y_test = train_test_split(
         X_clean, Y_clean, test_size=0.2, random_state=42, stratify=Y_clean
     )
 
-    # ------------------------------
-    # Models + grids
-    # ------------------------------
+    # Models and parameter grids
     cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
     models = {
-        "LogReg_L1": Pipeline([
-            ("scaler", StandardScaler()),
-            ("clf", LogisticRegression(penalty="l1", solver="liblinear", max_iter=2000))
-        ]),
-        "LogReg_L2": Pipeline([
-            ("scaler", StandardScaler()),
-            ("clf", LogisticRegression(penalty="l2", solver="lbfgs", max_iter=2000))
-        ]),
+        "LogReg_L1": Pipeline([("scaler", StandardScaler()),
+                               ("clf", LogisticRegression(penalty="l1", solver="liblinear", max_iter=2000))]),
+        "LogReg_L2": Pipeline([("scaler", StandardScaler()),
+                               ("clf", LogisticRegression(penalty="l2", solver="lbfgs", max_iter=2000))]),
         "DecisionTree": DecisionTreeClassifier(random_state=42),
         "RandomForest": RandomForestClassifier(random_state=42),
-        "BaggedDecisionTree": BaggingClassifier(
-            estimator=DecisionTreeClassifier(random_state=42),
-            n_estimators=50,
-            random_state=42
-        )
+        "BaggedDecisionTree": BaggingClassifier(DecisionTreeClassifier(random_state=42),
+                                                n_estimators=50, random_state=42)
     }
+
     param_grids = {
         "LogReg_L1": {"clf__C": [0.01, 0.1, 1, 10]},
         "LogReg_L2": {"clf__C": [0.01, 0.1, 1, 10]},
         "DecisionTree": {"max_depth": [3,5,7,None], "min_samples_split": [2,5,10]},
         "RandomForest": {"n_estimators": [100,200], "max_depth": [None,5,10], "min_samples_split": [2,5]},
-        "BaggedDecisionTree": {"n_estimators": [30,50,100]},
+        "BaggedDecisionTree": {"n_estimators": [30,50,100]}
     }
 
-    # ------------------------------
     # Grid search + evaluation
-    # ------------------------------
     rows = []
     best_name, best_estimator, best_f1 = None, None, -1
-
     for name, model in models.items():
-        print(f"\n[GRID] Tuning {name} …")
+        print(f"[GRID] Tuning {name} …")
         gs = GridSearchCV(model, param_grids[name], scoring="f1", cv=cv, n_jobs=-1)
         gs.fit(X_train, y_train)
         y_pred = gs.best_estimator_.predict(X_test)
-        acc = accuracy_score(y_test, y_pred)
-        f1 = f1_score(y_test, y_pred)
-        prec = precision_score(y_test, y_pred)
-        rec = recall_score(y_test, y_pred)
+        acc, f1 = accuracy_score(y_test, y_pred), f1_score(y_test, y_pred)
+        prec, rec = precision_score(y_test, y_pred), recall_score(y_test, y_pred)
         print(f"[GRID] {name} | best_params={gs.best_params_} | ACC={acc:.4f} F1={f1:.4f} P={prec:.4f} R={rec:.4f}")
-        print(classification_report(y_test, y_pred, digits=4))
-        rows.append({
-            "Model": name,
-            "BestParams": gs.best_params_,
-            "Accuracy": acc,
-            "F1": f1,
-            "Precision": prec,
-            "Recall": rec
-        })
+        rows.append({"Model": name, "BestParams": gs.best_params_, "Accuracy": acc, "F1": f1,
+                     "Precision": prec, "Recall": rec})
         if f1 > best_f1:
-            best_f1 = f1
-            best_estimator = gs.best_estimator_
-            best_name = name
+            best_f1, best_estimator, best_name = f1, gs.best_estimator_, name
 
-    # --- Save model comparison ---
+    # Save model comparison
     results_df = pd.DataFrame(rows).sort_values(by="F1", ascending=False)
     results_df.to_csv(os.path.join(REPORTS_DIR, "model_comparison.csv"), index=False)
     with open(os.path.join(REPORTS_DIR, "model_comparison.json"), "w") as f:
         json.dump(rows, f, indent=4)
 
-    # --- Best model diagnostics ---
+    # Plot Accuracy and F1 barplots
+    barplot_metric(results_df, "Accuracy", os.path.join(PLOTS_DIR, "model_accuracy.png"), "Model Accuracy (tuned)")
+    barplot_metric(results_df, "F1", os.path.join(PLOTS_DIR, "model_f1.png"), "Model F1 (tuned)")
+
+    # Best model diagnostics
     y_best = best_estimator.predict(X_test)
     plot_cm(y_test, y_best, f"Confusion Matrix – {best_name}", os.path.join(PLOTS_DIR, "confusion_matrix.png"))
+
     if hasattr(best_estimator, "predict_proba"):
-        y_prob = best_estimator.predict_proba(X_test)[:,1]
+        y_prob = best_estimator.predict_proba(X_test)[:, 1]
         plot_roc(y_test, y_prob, f"ROC – {best_name}", os.path.join(PLOTS_DIR,"roc_curve.png"))
 
     # Save best model
-    joblib.dump(best_estimator, os.path.join(MODEL_DIR, "best_model.pkl"))
-    print(f"\n[OK] Saved best model: {best_name} (F1={best_f1:.4f}) -> {MODEL_DIR}/best_model.pkl")
-
-    # ------------------------------
-    # Gradient analysis (loss & accuracy vs iterations) using SAGA
-    # ------------------------------
-    scaler = StandardScaler()
-    X_scaled = scaler.fit_transform(X_clean)
-    X_train_g, X_test_g, y_train_g, y_test_g = train_test_split(
-        X_scaled, Y_clean, test_size=0.2, random_state=42, stratify=Y_clean
-    )
+    model_path = os.path.join(MODEL_DIR, "best_model.pkl")
+    joblib.dump(best_estimator, model_path)
 
-    def track_training(penalty, max_iter=50):
-        clf = LogisticRegression(penalty=penalty, solver="saga", warm_start=True, max_iter=1, random_state=42)
-        losses, accs = [], []
-        for i in range(max_iter):
-            clf.fit(X_train_g, y_train_g)
-            y_pred = clf.predict_proba(X_train_g)
-            losses.append(log_loss(y_train_g, y_pred))
-            accs.append(accuracy_score(y_train_g, np.argmax(y_pred, axis=1)))
-        return losses, accs
-
-    loss_curves, acc_curves = {}, {}
-    loss_curves["L2"], acc_curves["L2"] = track_training("l2", max_iter=50)
-    loss_curves["L1"], acc_curves["L1"] = track_training("l1", max_iter=50)
-
-    lineplot_curves(loss_curves, ylabel="Log Loss", title="Logistic Regression – Loss vs Iterations",
-                    save_path=os.path.join(PLOTS_DIR, "logreg_loss_curves.png"))
-    lineplot_curves(acc_curves, ylabel="Training Accuracy", title="Logistic Regression – Accuracy vs Iterations",
-                    save_path=os.path.join(PLOTS_DIR, "logreg_accuracy_curves.png"))
-
-    print(f"[OK] Reports saved under: {REPORTS_DIR}")
-    barplot_metric(results_df, "Accuracy", os.path.join(PLOTS_DIR, "model_accuracy.png"), "Model Accuracy (tuned)")
-    barplot_metric(results_df, "F1", os.path.join(PLOTS_DIR, "model_f1.png"), "Model F1 (tuned)")
-    print(f"[OK] Plots saved -> {PLOTS_DIR}")
+    print(f"[OK] Best model ({best_name}) saved with F1={best_f1:.4f}")
+    print(f"[OK] All plots saved -> {PLOTS_DIR}")
+    print(f"[OK] Reports saved -> {REPORTS_DIR}")
+
+    return best_estimator