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

app.py

@@ -4,7 +4,7 @@ import subprocess
 import joblib
 import pandas as pd
 import streamlit as st
-
+from backend.train_model import train_model  # your function
 NONE = None
 # from backend.train_model import train_model
 
@@ -69,27 +69,18 @@ def predict_df(df: pd.DataFrame):
         return None
     return model.predict(df[FEATURES])
 
-# ---------- Pages ----------
-model = joblib.load(MODEL_PATH)
-if page == "Train":
-    st.subheader("🔹 Train")
-    @st.cache_resource
-    def load_model(path):
-        if os.path.exists(path):
-            model = joblib.load(path)
-            st.sidebar.success("✅ Best model loaded")
-            return model
-        else:
-            result = subprocess.run(["python", "backend/train_model.py"], capture_output=True, text=True)
-            st.text(result.stdout)
-            st.text(result.stderr)
-
-            # Reload the trained model
-            model = load_model(MODEL_PATH)
-            return model
+# # ---------- Pages ----------
+# model = joblib.load(MODEL_PATH)
+st.title("Train & Predict Diabetes Model")
 
+if not os.path.exists(MODEL_PATH):
+    st.warning("No trained model found. Please train the model first.")
 
-    model = load_model(MODEL_PATH)
+if st.button("Train Model"):
+    st.info("Training started...")
+    model = train_model(MODEL_PATH, REPORTS_DIR, PLOTS_DIR)
+    joblib.dump(model, MODEL_PATH)
+    st.success(f"Model trained and saved to {MODEL_PATH}")
 elif page == "Predict":
     st.subheader("🔹 Single Prediction")
 

backend/train_model.py

@@ -13,8 +13,8 @@ from sklearn.model_selection import train_test_split, GridSearchCV,StratifiedKFo
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import StandardScaler
 from sklearn.metrics import (
-accuracy_score, f1_score, precision_score, recall_score,
-classification_report
+    accuracy_score, f1_score, precision_score, recall_score,
+    classification_report, log_loss
 )
 from sklearn.linear_model import LogisticRegression
 from sklearn.tree import DecisionTreeClassifier
@@ -51,197 +51,146 @@ os.makedirs(PLOTS_DIR, exist_ok=True)
 #     raise FileNotFoundError(f"Dataset not found at {DATA_PATH}")
 
 ### Load with hugging face dataset
-ds = load_dataset("jonathansuru/diabetes")
-df = ds['train'].to_pandas()
-# df = pd.read_csv(DATA_PATH)
-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)
-# ------------------------------
-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)}")
-# 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')
-plt.title("Feature Variance: Before vs After Outlier Removal")
-plt.ylabel("Variance")
-plt.xticks(rotation=45, ha='right')
-plt.tight_layout()
-plt.savefig(os.path.join(PLOTS_DIR, "variance_comparison.png"),
-bbox_inches='tight')
-plt.close()
-
-# ------------------------------
-# 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
-# ------------------------------
-
-
-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))
-]),
-"DecisionTree": DecisionTreeClassifier(random_state=42),
-"RandomForest": RandomForestClassifier(random_state=42),
-"BaggedDecisionTree": BaggingClassifier(
-estimator=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]},
-}
-# ------------------------------
-# 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} …")
-    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)
-    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
-    })
-    if f1 > best_f1:
-        best_f1 = f1
-    best_estimator = gs.best_estimator_
-    best_name = name
-    # Save table reports
-# results_df = pd.DataFrame(rows).sort_values(by="F1", ascending=False)
- # --- Save model comparison table ---
-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)
-
-# --- Save plots ---
-# 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"))
-# ROC (if proba available)
-if hasattr(best_estimator, "predict_proba"):
-    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}) -> backend/models / best_model.pkl")
-
-# ------------------------------
-# Gradient analysis (loss & accuracy vs iterations) using SAGA
-# ------------------------------
-from sklearn.preprocessing import StandardScaler
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import log_loss, accuracy_score
-import numpy as np
-import os
-
-# Scale data
-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
-)
-
-
-def track_training(penalty, max_iter=50):
-    clf = LogisticRegression(
-        penalty=penalty,
-        solver="saga",
-        warm_start=True,  # allows continuing training
-        max_iter=1,  # train one step at a time
-        random_state=42
+def train_model(MODEL_DIR, REPORTS_DIR, PLOTS_DIR):
+    ds = load_dataset("jonathansuru/diabetes")
+    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)
+    # ------------------------------
+    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)}")
+
+    # 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')
+    plt.title("Feature Variance: Before vs After Outlier Removal")
+    plt.ylabel("Variance")
+    plt.xticks(rotation=45, ha='right')
+    plt.tight_layout()
+    plt.savefig(os.path.join(PLOTS_DIR, "variance_comparison.png"), bbox_inches='tight')
+    plt.close()
+
+    # ------------------------------
+    # 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
     )
 
-    losses, accs = [], []
-    for i in range(max_iter):
-        clf.fit(X_train_g, y_train_g)  # trains 1 iteration per loop
-        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
-
-
-# Collect curves
-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)
-
-# Plot curves
-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}")
-# Accuracy and F1 bar plots
-# 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)")
-# plt.savefig(os.path.join(PLOTS_DIR, "variance_comparison.png"), bbox_inches='tight')
-# plt.close()
-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)")
+    # ------------------------------
+    # Models + 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))
+        ]),
+        "DecisionTree": DecisionTreeClassifier(random_state=42),
+        "RandomForest": RandomForestClassifier(random_state=42),
+        "BaggedDecisionTree": BaggingClassifier(
+            estimator=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]},
+    }
+
+    # ------------------------------
+    # 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} …")
+        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)
+        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
+        })
+        if f1 > best_f1:
+            best_f1 = f1
+            best_estimator = gs.best_estimator_
+            best_name = name
+
+    # --- 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 ---
+    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]
+        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
+    )
 
-print(f"[OK] Plots saved -> {PLOTS_DIR}")
+    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}")