Update app.py

app.py

@@ -21,7 +21,6 @@ from sklearn.base import BaseEstimator
 if not hasattr(BaseEstimator, "sklearn_tags"):
     # scikit-learn < 1.6 only has get_tags(); provide sklearn_tags() alias
     def _sklearn_tags(self):
-        # mimic 1.6 behavior by delegating to get_tags()
         return self.get_tags()
     BaseEstimator.sklearn_tags = _sklearn_tags
 
@@ -252,9 +251,7 @@ def update_suggestion_panel(target, species):
 # Load and normalize real data (for allowed pairs + KNN imputer)
 # -----------------------------
 if not RAW_PATH.exists():
-    raise FileNotFoundError(
-        "Missing 'ai_al.csv'. Please upload it to the Space root (same folder as app.py)."
-    )
+    raise FileNotFoundError("Missing 'ai_al.csv'. Please upload it to the Space root (same folder as app.py).")
 
 df_raw = pd.read_csv(RAW_PATH)
 df_raw.columns = (
@@ -634,7 +631,6 @@ def _encode_df_for_bundle(bundle: EnsembleBundle, df_like: pd.DataFrame) -> pd.D
     def _norm(x):
         return "nan" if pd.isna(x) else str(x).strip().lower()
 
-    # Ensure all columns in the right order
     X = pd.DataFrame({c: df_like[c] if c in df_like.columns else np.nan for c in bundle.feature_order})
 
     # encode categoricals
@@ -660,19 +656,14 @@ def _encode_df_for_bundle(bundle: EnsembleBundle, df_like: pd.DataFrame) -> pd.D
         if c in X.columns:
             X[c] = X[c].apply(_extract_first_float)
 
-    # impute to exact training numeric space
     X_imp = pd.DataFrame(bundle.imputer.transform(X[bundle.feature_order]), columns=bundle.feature_order)
     return X_imp
 
 def predict_stack_batch(target: str, df_raw_rows: pd.DataFrame) -> tuple[np.ndarray, dict]:
-    """
-    Vectorized stacked prediction for multiple rows.
-    Returns (stack_preds, base_pred_dict) where base_pred_dict has arrays for each base.
-    """
+    """Vectorized stacked prediction for multiple rows. Returns (stack_preds, base_pred_dict)."""
     b = _load_ensemble(target)
     X_imp = _encode_df_for_bundle(b, df_raw_rows)
 
-    # Base preds
     pred_xgb = b.xgb.predict(X_imp)
     if b.lgb_booster is not None:
         pred_lgb = b.lgb_booster.predict(X_imp)
@@ -683,7 +674,6 @@ def predict_stack_batch(target: str, df_raw_rows: pd.DataFrame) -> tuple[np.ndar
     X_mlp = b.scaler.transform(X_imp) if b.scaler is not None else X_imp
     pred_mlp = b.mlp.predict(X_mlp, verbose=0).reshape(-1)
 
-    # STACK
     meta_in = np.vstack([pred_xgb, pred_lgb, pred_cat, pred_mlp]).T
     pred_stack = b.meta.predict(meta_in)
 
@@ -693,22 +683,59 @@ def predict_stack_batch(target: str, df_raw_rows: pd.DataFrame) -> tuple[np.ndar
 def predict_with_ensemble_one(target: str, raw_row: dict) -> dict:
     df = pd.DataFrame([raw_row])
     stack, bases = predict_stack_batch(target, df)
-    return {
-        "STACK": float(stack[0]),
-        "XGB": float(bases["XGB"][0]),
-        "LGBM": float(bases["LGBM"][0]),
-        "CAT": float(bases["CAT"][0]),
-        "MLP": float(bases["MLP"][0]),
-    }
+    return {"STACK": float(stack[0]), "XGB": float(bases["XGB"][0]), "LGBM": float(bases["LGBM"][0]),
+            "CAT": float(bases["CAT"][0]), "MLP": float(bases["MLP"][0])}
+
+# ---- New: model chooser support ----
+MODEL_NAMES = ["STACK", "XGB", "LGBM", "CAT", "MLP"]
+
+def _available_models_for_target(target: str) -> list[str]:
+    base = MODEL_DIR / target
+    avail = []
+    if (base / "meta.joblib").exists(): avail.append("STACK")
+    if (base / "xgb.json").exists(): avail.append("XGB")
+    if (base / "lgb.txt").exists() or (base / "lgb.joblib").exists(): avail.append("LGBM")
+    if (base / "cat.cbm").exists(): avail.append("CAT")
+    if (base / "mlp.keras").exists() or (base / "mlp_savedmodel").exists(): avail.append("MLP")
+    # keep order as MODEL_NAMES
+    return [m for m in MODEL_NAMES if m in avail]
+
+def _predict_with_model_choice(target: str, model_choice: str, df_rows: pd.DataFrame) -> np.ndarray:
+    """Predict with a specific model name. Falls back to first available if missing."""
+    avail = _available_models_for_target(target)
+    if not avail:
+        raise FileNotFoundError(f"No saved models found under models/{target}")
+    chosen = model_choice if model_choice in avail else avail[0]
+
+    if chosen == "STACK":
+        y, _ = predict_stack_batch(target, df_rows)
+        return y
+
+    # base models via bundle
+    b = _load_ensemble(target)
+    X_imp = _encode_df_for_bundle(b, df_rows)
+    if chosen == "XGB":
+        return np.asarray(b.xgb.predict(X_imp), dtype=float)
+    if chosen == "LGBM":
+        if b.lgb_booster is not None:
+            return np.asarray(b.lgb_booster.predict(X_imp), dtype=float)
+        return np.asarray(b.lgb_model.predict(X_imp), dtype=float)
+    if chosen == "CAT":
+        return np.asarray(b.cat.predict(X_imp), dtype=float)
+    if chosen == "MLP":
+        Xm = b.scaler.transform(X_imp) if b.scaler is not None else X_imp
+        return b.mlp.predict(Xm, verbose=0).reshape(-1).astype(float)
+
+    raise ValueError(f"Unknown model choice: {model_choice}")
 
 # -----------------------------
 # Predict + Uncertainty + Plot (with bounds clamping)
 # -----------------------------
 def predict_and_plot_ui(
-    target, species, media, light, expo_day, expo_night, temp_c, ph, days, plot_var
+    target, model_choice, species, media, light, expo_day, expo_night, temp_c, ph, days, plot_var
 ):
     try:
-        # 0) raw row for ensemble
+        # 0) raw row for ensemble/base models
         raw_row = {
             "species": species, "media": media, "light": light,
             "expo_day": expo_day, "expo_night": expo_night,
@@ -718,9 +745,16 @@ def predict_and_plot_ui(
         # 1) KNN point for uncertainty
         X_one = preprocess_row(species, media, light, expo_day, expo_night, temp_c, ph, days)
 
-        # 2) Ensemble point prediction (STACK) + bases
-        preds_point = predict_with_ensemble_one(target, raw_row)
-        yhat_raw = preds_point["STACK"]
+        # 2) Model point prediction (selected model) + also compute bases (for info)
+        df_one = pd.DataFrame([raw_row])
+        avail = _available_models_for_target(target)
+        chosen = model_choice if model_choice in avail else (avail[0] if avail else "STACK")
+
+        y_point = _predict_with_model_choice(target, chosen, df_one)
+        yhat_raw = float(y_point[0])
+
+        # (Optional) show base outputs in details
+        preds_point = predict_with_ensemble_one(target, raw_row) if "STACK" in avail else {}
 
         # 3) local uncertainty
         qlo, qhi = _local_interval(target, X_one.values)
@@ -734,7 +768,7 @@ def predict_and_plot_ui(
         lo_pt, _ = _clamp_scalar(lo_raw, b_lo, b_hi)
         hi_pt, _ = _clamp_scalar(hi_raw, b_lo, b_hi)
 
-        # 5) response curve vs selected variable (STACK)
+        # 5) response curve vs selected variable (same chosen model)
         plot_var = (plot_var or "light").strip().lower()
         if plot_var not in FEATURES: plot_var = "light"
         j = FEATURES.index(plot_var)
@@ -743,18 +777,15 @@ def predict_and_plot_ui(
         p05, p95 = _PERC[target][plot_var]
         xs = np.linspace(p05, p95, 60)
 
-        # Build raw grid rows by sweeping only plot_var
         grid_rows = []
-        x0_vals = X_one.values[0]  # imputed numeric point (for reference only)
         for xv in xs:
             row = dict(raw_row)
-            # replace swept variable with numeric value
             if plot_var in ["light","expo_day","expo_night","_c","ph","days"]:
                 row[plot_var] = float(xv)
             grid_rows.append(row)
         raw_grid_df = pd.DataFrame(grid_rows)
 
-        y_grid_raw, _bases_grid = predict_stack_batch(target, raw_grid_df)  # vectorized
+        y_grid_raw = _predict_with_model_choice(target, chosen, raw_grid_df)
 
         # KNN uncertainty band along the grid (independent of model)
         X_grid = np.repeat(X_one.values, len(xs), axis=0)
@@ -766,11 +797,11 @@ def predict_and_plot_ui(
         qlo_g, _ = _clamp_array(qlo_g_raw, b_lo, b_hi)
         qhi_g, _ = _clamp_array(qhi_g_raw, b_lo, b_hi)
 
-        # 6) plot (STACK curve)
+        # 6) plot
         fig, ax = plt.subplots(figsize=(7.0, 4.2))
         if b_lo is not None and b_hi is not None:
             ax.axhspan(b_lo, b_hi, alpha=0.10, label="Allowed range")
-        ax.plot(xs, y_grid, label="STACK (predicted mean)")
+        ax.plot(xs, y_grid, label=f"{chosen} (predicted mean)")
         ax.fill_between(xs, qlo_g, qhi_g, alpha=0.25, label=f"Local {int((Q_HI-Q_LO)*100)}% band")
 
         x0 = float(X_one.values[0, j])
@@ -788,17 +819,20 @@ def predict_and_plot_ui(
 
         clamp_note = " _(clamped to literature range)_" if clamped_point else ""
         md = (
-            f"### Prediction (STACK)\n"
+            f"### Prediction ({chosen})\n"
             f"**{target}** = **{yhat:.3f}**{clamp_note}  \n"
-            f"Local {int((Q_HI-Q_LO)*100)}% interval: **[{lo_pt:.3f}, {hi_pt:.3f}]**\n\n"
-            f"<details><summary>Base models</summary>\n"
-            f"XGB: {preds_point['XGB']:.4f} &nbsp;|&nbsp; "
-            f"LGBM: {preds_point['LGBM']:.4f} &nbsp;|&nbsp; "
-            f"CAT: {preds_point['CAT']:.4f} &nbsp;|&nbsp; "
-            f"MLP: {preds_point['MLP']:.4f}\n"
-            f"</details>"
+            f"Local {int((Q_HI-Q_LO)*100)}% interval: **[{lo_pt:.3f}, {hi_pt:.3f}]**"
             + ("" if not clamped_curve else "\n\n*Response curve clipped to species×medium range.*")
         )
+        if preds_point:
+            md += (
+                "\n\n<details><summary>Base models</summary>\n"
+                f"XGB: {preds_point['XGB']:.4f} &nbsp;|&nbsp; "
+                f"LGBM: {preds_point['LGBM']:.4f} &nbsp;|&nbsp; "
+                f"CAT: {preds_point['CAT']:.4f} &nbsp;|&nbsp; "
+                f"MLP: {preds_point['MLP']:.4f}\n"
+                "</details>"
+            )
         return md, fig
 
     except Exception as e:
@@ -827,6 +861,15 @@ def update_media(species):
     value = choices[0] if choices else None
     return gr.update(choices=choices, value=value)
 
+# ---- New: restrict model choices per target ----
+def update_model_choices(target):
+    avail = _available_models_for_target(target)
+    if not avail:
+        avail = ["STACK"]  # hard fallback (shouldn't happen if models exist)
+    # Prefer STACK if available, else first
+    value = "STACK" if "STACK" in avail else avail[0]
+    return gr.update(choices=avail, value=value)
+
 allowed_species = allowed_species_choices()
 first_species = allowed_species[0] if allowed_species else None
 first_media_choices = allowed_media_for(first_species) if first_species else []
@@ -835,8 +878,9 @@ first_media = first_media_choices[0] if first_media_choices else None
 with gr.Blocks(title="Algae Yield Predictor", theme=theme, css=CSS) as demo:
     gr.Markdown(
         f"<h1>Algae Yield Predictor</h1>"
-        f"<div class='small'>Predict <b>biomass / lipid / protein / carbohydrate</b> with an "
-        f"<b>XGB + LGBM + CAT + MLP</b> stacked ensemble, local uncertainty bands, and species×medium literature range clamping."
+        f"<div class='small'>Predict <b>biomass / lipid / protein / carbohydrate</b> with "
+        f"a selectable model (<b>STACK / XGB / LGBM / CAT / MLP</b>), local uncertainty bands, "
+        f"and species×medium literature-range clamping."
         f"{'' if DOI_READY else ' &nbsp;<em>(DOI file missing or lacks a doi column.)</em>'}"
         f"</div>",
         elem_classes=["card"]
@@ -847,6 +891,7 @@ with gr.Blocks(title="Algae Yield Predictor", theme=theme, css=CSS) as demo:
             with gr.Group(elem_classes=["card"]):
                 gr.Markdown("### Inputs")
                 target_dd = gr.Dropdown(choices=TARGETS, value="biomass", label="Target", info="Choose outcome to predict")
+                model_dd  = gr.Dropdown(choices=MODEL_NAMES, value="STACK", label="Model", info="Choose which trained model to use")
                 with gr.Row():
                     species_dd = gr.Dropdown(choices=allowed_species, value=first_species, label="Species", info="Only curated species")
                     media_dd   = gr.Dropdown(choices=first_media_choices, value=first_media, label="Medium", info="Restricted by species")
@@ -875,11 +920,24 @@ with gr.Blocks(title="Algae Yield Predictor", theme=theme, css=CSS) as demo:
                 gr.Markdown("### Suggested Conditions")
                 suggest_md = gr.Markdown(value=_format_suggestion_md(first_species or "", "biomass"))
 
+            # ---- New: Model tips card ----
+            with gr.Group(elem_classes=["card"]):
+                gr.Markdown("### Model Tips")
+                model_tips_md = gr.Markdown("""\
+**Recommendations**
+- **STACK (Ensemble)** — best overall accuracy (offline metrics ~R² 0.89 / MAE ~0.66).
+- **XGB / LGBM** — fast, strong single models (R² ~0.69).
+- **CAT** — robust to categorical quirks (R² ~0.62).
+- **MLP** — requires scaler; slower cold start (R² ~0.55 here).
+
+**Pick**: Use **STACK** by default. Choose **XGB**/**LGBM** for speed or to sanity-check disagreement across models.
+""")
+
         with gr.Column(scale=6):
             with gr.Group(elem_classes=["card"]):
                 pred_md = gr.Markdown("Click **Predict + Plot** to run.")
             with gr.Group(elem_classes=["card"]):
-                gr.Markdown("### Combined Response Plot")
+                gr.Markdown("### Response Plot")
                 plot_out = gr.Plot()
             with gr.Group(elem_classes=["card"]):
                 gr.Markdown("### Literature (DOI) Matches")
@@ -889,15 +947,16 @@ with gr.Blocks(title="Algae Yield Predictor", theme=theme, css=CSS) as demo:
     species_dd.change(fn=update_media, inputs=species_dd, outputs=media_dd)
     target_dd.change(update_suggestion_panel, inputs=[target_dd, species_dd], outputs=suggest_md)
     species_dd.change(update_suggestion_panel, inputs=[target_dd, species_dd], outputs=suggest_md)
+    target_dd.change(fn=update_model_choices, inputs=target_dd, outputs=model_dd)
 
     go.click(
         fn=predict_and_plot_ui,
-        inputs=[target_dd, species_dd, media_dd, light_sl, day_sl, night_sl, temp_num, ph_num, days_sl, plot_var_dd],
+        inputs=[target_dd, model_dd, species_dd, media_dd, light_sl, day_sl, night_sl, temp_num, ph_num, days_sl, plot_var_dd],
         outputs=[pred_md, plot_out]
     )
     doi_btn.click(
         fn=doi_matches_ui,
-        inputs=[target_dd, species_dd, media_dd, light_sl, day_sl, night_sl, temp_num, ph_num, days_sl],
+        inputs=[target_dd, species_dd, media_dd, light_sl, day_sl, night_sl, temp_c := temp_num, ph_num, days_sl],
         outputs=doi_md
     )