Create app.py

app.py

@@ -0,0 +1,652 @@
+# ===============================================
+# Algae Yield Predictor — Uncertainty + Response Plot
+# (Hugging Face Spaces–ready)
+# ===============================================
+
+import re
+import numpy as np
+import pandas as pd
+import gradio as gr
+import matplotlib.pyplot as plt
+from pathlib import Path
+from difflib import get_close_matches
+
+from sklearn.preprocessing import LabelEncoder
+from sklearn.impute import SimpleImputer
+from sklearn.neighbors import NearestNeighbors
+
+from catboost import CatBoostRegressor
+from gradio.themes import Soft
+
+# -----------------------------
+# Paths (relative to repo root)
+# -----------------------------
+HERE = Path(__file__).parent
+RAW_PATH = HERE / "ai_al.csv"   # required
+DOI_PATH = HERE / "doi.csv"     # optional
+MODEL_DIR = HERE / "models"     # optional pre-trained .cbm
+MODEL_DIR.mkdir(parents=True, exist_ok=True)
+
+# -----------------------------
+# Helpers
+# -----------------------------
+def extract_first_float(x: str):
+    if pd.isna(x): return np.nan
+    s = str(x)
+    m = re.search(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?", s)
+    return float(m.group(0)) if m else np.nan
+
+def parse_cycle_first(x: str):
+    if pd.isna(x): return np.nan
+    s = str(x)
+    m = re.search(r"(\d+(?:\.\d+)?)\s*:\s*(\d+(?:\.\d+)?)", s)
+    return float(m.group(1)) if m else extract_first_float(s)
+
+def coerce_numeric(series: pd.Series, mode: str = "float"):
+    return series.apply(parse_cycle_first if mode == "cycle_first" else extract_first_float)
+
+def normalize_str(x):
+    if pd.isna(x): return "nan"
+    return str(x).strip().lower()
+
+# -----------------------------
+# Curated suggestions
+# -----------------------------
+SPECIES_SUGGESTIONS = {
+    "a. platensis": {
+        "biomass": {"light": "60–300", "days": "15–25"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "15–25"},
+        "protein": {"light": "60–300", "days": "12–18"},
+        "carb":    {"light": "60–300", "days": "15–25"},
+    },
+    "c. pyrenoidosa": {
+        "biomass": {"light": "50–150", "days": "12–25"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "12–25"},
+        "protein": {"light": "50–150", "days": "12–18"},
+        "carb":    {"light": "50–150", "days": "12–25"},
+    },
+    "c. sorokiniana": {
+        "biomass": {"light": "60–300", "days": "15–25"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "15–25"},
+        "protein": {"light": "60–300", "days": "12–18"},
+        "carb":    {"light": "60–300", "days": "15–25"},
+    },
+    "c. variabilis": {
+        "biomass": {"light": "60–250", "days": "15–25"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "15–25"},
+        "protein": {"light": "60–250", "days": "12–18"},
+        "carb":    {"light": "60–250", "days": "15–25"},
+    },
+    "c. vulgaris": {
+        "biomass": {"light": "60–300", "days": "12–21"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "15–21"},
+        "protein": {"light": "60–300", "days": "12–18"},
+        "carb":    {"light": "60–300", "days": "12–21"},
+    },
+    "c. zofingiensis": {
+        "biomass": {"light": "50–150", "days": "25–30"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "25–30"},
+        "protein": {"light": "50–150", "days": "25–30"},
+        "carb":    {"light": "50–150", "days": "25–30"},
+    },
+    "h. pluvialis": {
+        "biomass": {"light": "50–250", "days": "25–30"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "25–30"},
+        "protein": {"light": "50–250", "days": "25–30"},
+        "carb":    {"light": "50–250", "days": "25–30"},
+    },
+    "p. purpureum": {
+        "biomass": {"light": "100–250", "days": "17–19"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "17–19"},
+        "protein": {"light": "100–250", "days": "12–15"},
+        "carb":    {"light": "100–250", "days": "17–19"},
+    },
+    "scenedesmus sp.": {
+        "biomass": {"light": "50–250", "days": "12–25"},
+        "lipid":   {"light": "High light intensity (stress)", "days": "12–25"},
+        "protein": {"light": "50–250", "days": "12–20"},
+        "carb":    {"light": "50–250", "days": "12–25"},
+    },
+}
+
+def _normalize_species_label(s: str) -> str:
+    if s is None: return ""
+    s0 = str(s).strip().lower()
+    s1 = re.sub(r"[_\-]+", " ", s0).replace("  ", " ").strip()
+    s2 = s1.replace(" .", ".").replace(". ", ". ")
+    alias = {
+        "a platensis": "a. platensis", "a.platensis": "a. platensis", "arthrospira platensis": "a. platensis",
+        "c pyrenoidosa": "c. pyrenoidosa", "c.pyrenoidosa": "c. pyrenoidosa", "chlorella pyrenoidosa": "c. pyrenoidosa",
+        "c sorokiniana": "c. sorokiniana", "c.sorokiniana": "c. sorokiniana",
+        "c variabilis": "c. variabilis", "c.variabilis": "c. variabilis",
+        "c vulgaris": "c. vulgaris", "c.vulgaris": "c. vulgaris", "chlorella vulgaris": "c. vulgaris",
+        "c zofingiensis": "c. zofingiensis", "c.zofingiensis": "c. zofingiensis",
+        "h pluvialis": "h. pluvialis", "h.pluvialis": "h. pluvialis", "haematococcus pluvialis": "h. pluvialis",
+        "p purpureum": "p. purpureum", "p.purpureum": "p. purpureum", "porphyridium purpureum": "p. purpureum",
+        "scenedesmus": "scenedesmus sp.", "scenedesmus sp": "scenedesmus sp.", "scenedesmus sp.": "scenedesmus sp.",
+    }
+    return alias.get(s2, s2)
+
+def _format_suggestion_md(species: str, target: str) -> str:
+    sp = _normalize_species_label(species)
+    tg = (target or "").strip().lower()
+    data = SPECIES_SUGGESTIONS.get(sp, {}).get(tg)
+    if not data:
+        return f"> ℹ️ No curated suggestion for **{species}** and **{target}**."
+    return (
+        f"### 💡 Suggested conditions for *{sp}* → *{tg}*\n"
+        f"**Light intensity:** {data['light']}  |  **Days:** {data['days']}"
+    )
+
+def update_suggestion_panel(target, species):
+    return _format_suggestion_md(species, target)
+
+# -----------------------------
+# Load and normalize real data
+# -----------------------------
+df_raw = pd.read_csv(RAW_PATH)
+df_raw.columns = (
+    df_raw.columns.str.strip()
+          .str.lower()
+          .str.replace("[^0-9a-zA-Z]+", "_", regex=True)
+)
+
+FEATURES = ["species","media","light","expo_day","expo_night","_c","ph","days"]
+CATEGORICAL = ["species","media"]
+NUM_CYCLE_FIRST = ["light"]
+NUM_PLAIN = ["expo_day","expo_night","_c","ph","days"]
+TARGETS = ["biomass","lipid","protein","carb"]
+
+# Normalize for encoders
+df_enc = df_raw.copy()
+for col in CATEGORICAL:
+    if col in df_enc.columns:
+        df_enc[col] = df_enc[col].map(normalize_str)
+
+# Fit encoders on CSV categories
+encoders, value_lists = {}, {}
+for col in CATEGORICAL:
+    le = LabelEncoder()
+    vals = df_enc[col].astype(str).fillna("nan")
+    le.fit(vals)
+    encoders[col] = le
+    value_lists[col] = sorted(set(vals) - {"nan"})
+
+# Prepare numerics for imputer fit
+for c in NUM_CYCLE_FIRST:
+    if c in df_enc.columns:
+        df_enc[c] = coerce_numeric(df_enc[c], "cycle_first")
+for c in NUM_PLAIN:
+    if c in df_enc.columns:
+        df_enc[c] = coerce_numeric(df_enc[c], "float")
+
+def encode_frame(df_like: pd.DataFrame) -> pd.DataFrame:
+    X = pd.DataFrame()
+    for col in CATEGORICAL:
+        if col in df_like.columns:
+            X[col] = df_like[col].map(normalize_str)
+            X[col] = encoders[col].transform(X[col].astype(str).fillna("nan"))
+    for c in NUM_CYCLE_FIRST:
+        if c in df_like.columns:
+            X[c] = coerce_numeric(df_like[c], "cycle_first")
+    for c in NUM_PLAIN:
+        if c in df_like.columns:
+            X[c] = coerce_numeric(df_like[c], "float")
+    for c in FEATURES:
+        if c not in X.columns:
+            X[c] = np.nan
+    return X[FEATURES]
+
+X_for_imputer = encode_frame(df_raw)
+imputer = SimpleImputer(strategy="median").fit(X_for_imputer)
+
+# -----------------------------
+# Species-media vocab + aliases
+# -----------------------------
+ALLOWED_PAIRS_ALIAS = {
+    "a.platensis": ["zarrouks", "bg 11"],
+    "c sorokiniana": ["tap", "bg 11"],
+    "c vulgaris": ["bg 11", "bbm"],
+    "scenedesmus": ["bg 11", "bbm"],
+    "p purpureum": ["artificial sea water", "erdseirber and bold nv", "f2"],
+    "h pluvalis": ["bg 11"],
+    "c pyreniidosa": ["bg 11", "bbm", "selenite media"],
+    "c zofingensis": ["bg 11", "bbm", "tap"],
+    "c variabilis": ["bg 11", "zorrouks", "tap"],
+}
+SPECIES_ALIASES = {
+    "a.platensis": ["arthrospira platensis", "spirulina platensis", "a. platensis"],
+    "c sorokiniana": ["chlorella sorokiniana", "c. sorokiniana"],
+    "c vulgaris": ["chlorella vulgaris", "c. vulgaris"],
+    "scenedesmus": ["scenedesmus", "scenedesmus sp.", "desmodesmus sp."],
+    "p purpureum": ["porphyridium purpureum", "p. purpureum"],
+    "h pluvalis": ["haematococcus pluvialis", "h. pluvialis", "h pluvalis"],
+    "c pyreniidosa": ["chlorella pyrenoidosa", "c. pyrenoidosa", "c pyreniidosa"],
+    "c zofingensis": ["chromochloris zofingiensis", "c. zofingiensis", "chlorella zofingiensis"],
+    "c variabilis": ["chlorella variabilis", "c. variabilis"],
+}
+MEDIA_ALIASES = {
+    "zarrouks": ["zarrouk's", "zarrouks", "zarrouk"],
+    "zorrouks": ["zarrouk's", "zarrouks", "zarrouk"],
+    "bg 11": ["bg 11", "bg-11", "bg11"],
+    "bbm": ["bbm", "bold's basal medium", "bold basal medium", "bolds basal medium"],
+    "tap": ["tap", "tap water"],
+    "artificial sea water": ["artificial sea water", "artificial seawater", "asw"],
+    "erdseirber and bold nv": ["erdschreiber and bold nv", "erdschreiber", "bold nv", "bold's nv", "erdschreiber & bold nv"],
+    "f2": ["f/2", "guillard f/2", "f2"],
+    "selenite media": ["selenite medium", "selenite media"],
+}
+
+def match_to_vocab(name: str, vocab: list[str], aliases: dict[str, list[str]], cutoff=0.6):
+    n = normalize_str(name)
+    if n in vocab: return n
+    for syn in aliases.get(n, []):
+        sn = normalize_str(syn)
+        if sn in vocab: return sn
+    hit = get_close_matches(n, vocab, n=1, cutoff=cutoff)
+    return hit[0] if hit else None
+
+species_vocab = value_lists["species"]
+media_vocab   = value_lists["media"]
+
+ALLOWED_PAIRS = {}
+for s_alias, m_aliases in ALLOWED_PAIRS_ALIAS.items():
+    s_canon = match_to_vocab(s_alias, species_vocab, SPECIES_ALIASES)
+    if not s_canon:
+        continue
+    canon_media = []
+    for m_alias in m_aliases:
+        m_canon = match_to_vocab(m_alias, media_vocab, MEDIA_ALIASES)
+        if m_canon:
+            canon_media.append(m_canon)
+    if canon_media:
+        ALLOWED_PAIRS[s_canon] = sorted(set(canon_media))
+
+if not ALLOWED_PAIRS:
+    # Fallback: allow any species-media (warn in UI)
+    ALLOWED_PAIRS = {s: sorted(set(media_vocab)) for s in species_vocab}
+    WARN_ALL = True
+else:
+    WARN_ALL = False
+
+def allowed_media_for(species_norm):
+    return ALLOWED_PAIRS.get(species_norm, [])
+
+# -----------------------------
+# Model loader
+# -----------------------------
+def get_augmented_path(target: str):
+    p200 = HERE / f"augmented_{target}_200k.csv"
+    p20  = HERE / f"augmented_{target}_20k.csv"
+    return p200 if p200.exists() else (p20 if p20.exists() else None)
+
+def load_or_train_catboost(target: str) -> CatBoostRegressor:
+    model_path = MODEL_DIR / f"{target}.cbm"
+    if model_path.exists():
+        model = CatBoostRegressor()
+        model.load_model(str(model_path))
+        return model
+
+    aug_path = get_augmented_path(target)
+    if aug_path is None:
+        # Fallback: light train on real data if augmented not uploaded
+        if target not in df_raw.columns:
+            raise FileNotFoundError(
+                f"No model '{model_path.name}' and no column '{target}' in ai_al.csv."
+            )
+        y = df_raw[target].apply(extract_first_float).astype(float)
+        if y.dropna().empty:
+            raise FileNotFoundError(f"No model and no usable labels for target '{target}'.")
+        X = X_for_imputer
+        model = CatBoostRegressor(
+            iterations=400, depth=8, learning_rate=0.06,
+            loss_function="RMSE", random_seed=42, verbose=False
+        )
+        model.fit(X, y)
+        model.save_model(str(model_path))
+        return model
+
+    df_aug = pd.read_csv(aug_path)
+    X_aug = df_aug.drop(columns=[target])
+    y_aug = df_aug[target].astype(float)
+    model = CatBoostRegressor(
+        iterations=700, depth=8, learning_rate=0.06,
+        loss_function="RMSE", random_seed=42, verbose=False
+    )
+    model.fit(X_aug, y_aug)
+    model.save_model(str(model_path))
+    return model
+
+_models = {}
+def get_model(target: str):
+    if target not in _models:
+        _models[target] = load_or_train_catboost(target)
+    return _models[target]
+
+# -----------------------------
+# Optional DOI database
+# -----------------------------
+try:
+    if DOI_PATH.exists():
+        df_doi_raw = pd.read_csv(DOI_PATH)
+    else:
+        raise FileNotFoundError("doi.csv not found")
+
+    df_doi_raw.columns = (
+        df_doi_raw.columns.str.strip()
+                 .str.lower()
+                 .str.replace("[^0-9a-zA-Z]+", "_", regex=True)
+    )
+    for c in ["species", "media"]:
+        if c in df_doi_raw.columns: df_doi_raw[c] = df_doi_raw[c].map(normalize_str)
+    if "light" in df_doi_raw.columns: df_doi_raw["light"] = coerce_numeric(df_doi_raw["light"], "cycle_first")
+    for c in ["expo_day","expo_night","_c","ph","days"]:
+        if c in df_doi_raw.columns: df_doi_raw[c] = coerce_numeric(df_doi_raw[c], "float")
+
+    doi_col_candidates = [c for c in df_doi_raw.columns if c.lower() in {"doi","doi_id","reference","url","link"}]
+    DOI_COL = doi_col_candidates[0] if doi_col_candidates else None
+
+    NUMERIC_COLS = ["light","expo_day","expo_night","_c","ph","days"]
+    scales = {}
+    for col in NUMERIC_COLS:
+        if col not in df_doi_raw.columns: continue
+        v = pd.to_numeric(df_doi_raw[col], errors="coerce").dropna()
+        if len(v) >= 4:
+            lo, hi = np.percentile(v, [5,95]); span = max(1e-6, hi - lo)
+        elif len(v) > 1:
+            span = max(1e-6, v.max() - v.min())
+        else:
+            span = 1.0
+        scales[col] = span
+
+    def _media_similarity(a, b):
+        a = normalize_str(a); b = normalize_str(b)
+        def canon(m):
+            if m in MEDIA_ALIASES: return m
+            for k, syns in MEDIA_ALIASES.items():
+                ns = [normalize_str(s) for s in syns]
+                if m == k or m in ns: return k
+            return m
+        from difflib import SequenceMatcher
+        ca, cb = canon(a), canon(b)
+        return 1.0 if ca == cb else SequenceMatcher(None, ca, cb).ratio()
+
+    def _doi_url(x):
+        if x is None or (isinstance(x, float) and np.isnan(x)): return None
+        s = str(x).strip()
+        if s.startswith("http://") or s.startswith("https://"): return s
+        s = s.lower().replace("doi:", "").strip()
+        return f"https://doi.org/{s}"
+
+    def _closest_doi(species, media, light, expo_day, expo_night, temp_c, ph, days, topk=3):
+        if df_doi_raw.empty: return "> ℹ️ doi.csv is empty."
+        s_key = _normalize_species_label(normalize_str(species))
+        df_cand = df_doi_raw[df_doi_raw["species"] == s_key]
+        if df_cand.empty:
+            sp_unique = df_doi_raw["species"].dropna().unique().tolist()
+            best = get_close_matches(s_key, sp_unique, n=1, cutoff=0.6)
+            df_cand = df_doi_raw[df_doi_raw["species"] == (best[0] if best else s_key)]
+
+        q = {
+            "light": parse_cycle_first(light),
+            "expo_day": extract_first_float(expo_day),
+            "expo_night": extract_first_float(expo_night),
+            "_c": extract_first_float(temp_c),
+            "ph": extract_first_float(ph),
+            "days": extract_first_float(days),
+        }
+
+        rows = []
+        for _, r in df_cand.iterrows():
+            sim = _media_similarity(media, r.get("media", "")); media_penalty = (1.0 - sim) * 0.5
+            dist = 0.0; denom = 0
+            for col in ["light","expo_day","expo_night","_c","ph","days"]:
+                if col in df_cand.columns:
+                    rv, qv = r.get(col, np.nan), q[col]
+                    if pd.notna(rv) and pd.notna(qv):
+                        dist += abs(float(qv) - float(rv)) / scales.get(col, 1.0); denom += 1
+            dist = dist/denom if denom>0 else 1.0
+            rows.append((media_penalty + dist, r))
+        if not rows: return "> ℹ️ No comparable rows in doi.csv."
+        rows.sort(key=lambda x: x[0]); top = rows[:topk]
+
+        md = "### 📚 Closest DOI matches\n"
+        for rank, (score, r) in enumerate(top, 1):
+            sim_pct = max(0.0, min(100.0, 100.0 * np.exp(-score)))
+            doi_link = _doi_url(r.get(DOI_COL)) if DOI_COL else None
+            head = f"**{rank}. {r.get('species','?')} — {r.get('media','?')}** · Similarity **{sim_pct:.1f}%**"
+            if doi_link: head += f" · [DOI]({doi_link})"
+            md += head + "\n"
+            md += (f"• Light: {r.get('light','NA')} · Day: {r.get('expo_day','NA')} · Night: {r.get('expo_night','NA')} · "
+                   f"T(°C): {r.get('_c','NA')} · pH: {r.get('ph','NA')} · Days: {r.get('days','NA')}\n")
+        return md
+
+    DOI_READY = True
+except Exception as e:
+    DOI_READY = False
+    def _closest_doi(*args, **kwargs): return f"> ⚠️ DOI lookup unavailable: {e}"
+
+# -----------------------------
+# Preprocess + validate pair
+# -----------------------------
+def preprocess_row(species, media, light, expo_day, expo_night, temp_c, ph, days):
+    species_n = normalize_str(species); media_n = normalize_str(media)
+    if species_n not in ALLOWED_PAIRS:
+        raise ValueError(f"Species '{species}' not allowed.")
+    if media_n not in ALLOWED_PAIRS[species_n]:
+        raise ValueError(f"Media '{media}' not allowed for species '{species}'.")
+    if species_n not in value_lists["species"]:
+        raise ValueError(f"Species '{species}' not present in training encodings.")
+    if media_n not in value_lists["media"]:
+        raise ValueError(f"Media '{media}' not present in training encodings.")
+
+    row = pd.DataFrame([{
+        "species": species_n, "media": media_n, "light": light,
+        "expo_day": expo_day, "expo_night": expo_night,
+        "_c": temp_c, "ph": ph, "days": days
+    }], columns=FEATURES)
+
+    for col in CATEGORICAL:
+        row[col] = encoders[col].transform([row.loc[0, col]])[0]
+
+    row["light"] = row["light"].apply(parse_cycle_first)
+    for c in ["expo_day","expo_night","_c","ph","days"]:
+        row[c] = row[c].apply(extract_first_float)
+
+    row = pd.DataFrame(imputer.transform(row[FEATURES]), columns=FEATURES)
+    return row
+
+# -----------------------------
+# Uncertainty engine (KNN on augmented)
+# -----------------------------
+_AUG = {}        # target -> (X_aug_np, y_aug_np)
+_KNN = {}        # target -> fitted NearestNeighbors
+_PERC = {}       # target -> {feature: (p05, p95)}
+K_NEI = 200
+Q_LO, Q_HI = 0.10, 0.90
+
+def _load_aug_and_knn(target: str):
+    if target in _KNN: return
+    aug_path = get_augmented_path(target)
+    if aug_path is None:
+        raise FileNotFoundError(
+            f"Missing augmented file for '{target}'. Upload 'augmented_{target}_200k.csv' or '_20k.csv'."
+        )
+    df_aug = pd.read_csv(aug_path)
+    for c in FEATURES:
+        if c not in df_aug.columns: df_aug[c] = np.nan
+    X_aug = df_aug[FEATURES].copy()
+    X_aug_imp = pd.DataFrame(imputer.transform(X_aug), columns=FEATURES)
+    y_aug = df_aug[target].astype(float).values
+    X_np = X_aug_imp.values.astype(float)
+
+    perc = {}
+    for j, c in enumerate(FEATURES):
+        colv = X_np[:, j]
+        perc[c] = (np.nanpercentile(colv, 5), np.nanpercentile(colv, 95))
+
+    nn = NearestNeighbors(n_neighbors=min(K_NEI, len(X_np)), algorithm="auto")
+    nn.fit(X_np)
+    _AUG[target] = (X_np, y_aug)
+    _KNN[target] = nn
+    _PERC[target] = perc
+
+def _local_interval(target: str, X_query: np.ndarray):
+    _load_aug_and_knn(target)
+    X_aug, y_aug = _AUG[target]
+    nn = _KNN[target]
+    k_use = min(K_NEI, len(X_aug))
+    dists, idxs = nn.kneighbors(X_query, n_neighbors=k_use, return_distance=True)
+    qlo = np.quantile(y_aug[idxs], Q_LO, axis=1)
+    qhi = np.quantile(y_aug[idxs], Q_HI, axis=1)
+    return qlo, qhi
+
+# -----------------------------
+# Predict + Uncertainty + Plot
+# -----------------------------
+def predict_and_plot_ui(target, species, media, light, expo_day, expo_night, temp_c, ph, days, plot_var):
+    try:
+        # 1) preprocess single row
+        X_one = preprocess_row(species, media, light, expo_day, expo_night, temp_c, ph, days)
+        model = get_model(target)
+        yhat = float(model.predict(X_one)[0])
+
+        # 2) local uncertainty at current point
+        qlo, qhi = _local_interval(target, X_one.values)
+        lo, hi = float(qlo[0]), float(qhi[0])
+
+        # 3) response curve vs selected variable
+        plot_var = (plot_var or "light").strip().lower()
+        if plot_var not in FEATURES:
+            plot_var = "light"
+        j = FEATURES.index(plot_var)
+        _load_aug_and_knn(target)
+        p05, p95 = _PERC[target][plot_var]
+        xs = np.linspace(p05, p95, 60)
+
+        X_grid = np.repeat(X_one.values, len(xs), axis=0)
+        X_grid[:, j] = xs
+        y_grid = model.predict(pd.DataFrame(X_grid, columns=FEATURES)).astype(float)
+        qlo_g, qhi_g = _local_interval(target, X_grid)
+
+        # 4) combined plot
+        fig, ax = plt.subplots(figsize=(7.0, 4.2))
+        ax.plot(xs, y_grid, label="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])
+        ax.axvline(x0, linestyle="--", alpha=0.6)
+        ax.scatter([x0], [yhat], zorder=3)
+        ax.set_xlabel(plot_var)
+        ax.set_ylabel(target)
+        ax.set_title(f"{target} vs {plot_var} (others fixed)")
+        ax.legend(loc="best")
+        plt.tight_layout()
+
+        md = (
+            f"### Prediction\n"
+            f"**{target}** = **{yhat:.3f}**  \n"
+            f"Local {int((Q_HI-Q_LO)*100)}% interval: **[{lo:.3f}, {hi:.3f}]**"
+        )
+        return md, fig
+    except Exception as e:
+        fig, ax = plt.subplots(figsize=(6,3)); ax.axis("off"); plt.tight_layout()
+        return f"Error: {e}", fig
+
+def doi_matches_ui(target, species, media, light, expo_day, expo_night, temp_c, ph, days):
+    return _closest_doi(species, media, light, expo_day, expo_night, temp_c, ph, days, topk=3)
+
+def update_suggestion(species, target):
+    return _format_suggestion_md(species, target)
+
+# -----------------------------
+# UI — layout
+# -----------------------------
+theme = Soft(primary_hue="emerald", neutral_hue="slate", radius_size="lg", spacing_size="sm")
+CSS = """
+.card { border: 1px solid var(--border-color-primary); border-radius: 12px; padding: 14px; background: var(--block-background-fill); }
+.small { font-size: 0.92rem; opacity: 0.95; }
+"""
+
+def update_media(species):
+    s = normalize_str(species) if species else None
+    choices = allowed_media_for(s) if s else []
+    value = choices[0] if choices else None
+    return gr.update(choices=choices, value=value)
+
+allowed_species = sorted(ALLOWED_PAIRS.keys())
+first_species = allowed_species[0] if allowed_species else None
+first_media_choices = allowed_media_for(first_species) if first_species else []
+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> and visualize local uncertainty."
+        f"{' &nbsp;<em>(All species–media pairs enabled; CSV match not found.)</em>' if WARN_ALL else ''}"
+        f"{'' if DOI_PATH.exists() and DOI_READY else ' &nbsp;<em>(DOI file missing or lacks a doi column.)</em>'}"
+        f"</div>",
+        elem_classes=["card"]
+    )
+
+    with gr.Row():
+        with gr.Column(scale=6):
+            with gr.Group(elem_classes=["card"]):
+                gr.Markdown("### Inputs")
+                target_dd = gr.Dropdown(choices=TARGETS, value="biomass", label="Target", info="Choose outcome to predict")
+                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")
+                gr.Markdown("#### Culture Conditions", elem_classes=["small"])
+                with gr.Row():
+                    light_sl = gr.Slider(10, 400, value=120, step=5, label="Light (μmol·m⁻²·s⁻¹)")
+                    days_sl  = gr.Slider(1, 45, value=14, step=1, label="Days", info="Total culture duration")
+                with gr.Row():
+                    day_sl   = gr.Slider(0, 24, value=18, step=1, label="Day Exposure (h)")
+                    night_sl = gr.Slider(0, 24, value=6, step=1, label="Night Exposure (h)")
+                with gr.Row():
+                    temp_num = gr.Number(value=25, label="Temperature (°C)", precision=1)
+                    ph_num   = gr.Number(value=7.0, label="pH", precision=2)
+                with gr.Row():
+                    plot_var_dd = gr.Dropdown(
+                        choices=["light","days","expo_day","expo_night","_c","ph"],
+                        value="light",
+                        label="Plot variable",
+                        info="Sweep one input to see response curve with uncertainty band"
+                    )
+                with gr.Row():
+                    go = gr.Button("Predict + Plot", variant="primary")
+                    doi_btn = gr.Button("Find Closest DOI Matches", variant="secondary")
+
+            with gr.Group(elem_classes=["card"]):
+                gr.Markdown("### Suggested Conditions")
+                suggest_md = gr.Markdown(value=_format_suggestion_md(first_species or "", "biomass"))
+
+        with gr.Column(scale=6):
+            with gr.Group(elem_classes=["card"]):
+                pred_md = gr.Markdown("Click <b>Predict + Plot</b> to run.")
+            with gr.Group(elem_classes=["card"]):
+                gr.Markdown("### Combined Response Plot")
+                plot_out = gr.Plot()
+            with gr.Group(elem_classes=["card"]):
+                gr.Markdown("### Literature (DOI) Matches")
+                doi_md = gr.Markdown("Click <b>Find Closest DOI Matches</b> to see references.")
+
+    # Wiring
+    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)
+
+    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],
+        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],
+        outputs=doi_md
+    )
+
+# Spaces will run this automatically; keep main guard for local dev.
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)