Update app.py

app.py

@@ -175,6 +175,57 @@ def get_bounds(species: str, media: str, target: str):
         return None, None
     lo, hi = rng[tg]
     return float(lo), float(hi)
+# --- Robust canonicalization for species/media -> encoder classes ---
+# Accepts dotted-without-space, dotted-with-space, synonyms, fuzzy fallback.
+
+SPECIES_ALIASES_CANON = {
+    "a. platensis": ["a.platensis", "a platensis", "arthrospira platensis", "spirulina platensis"],
+    "c. pyrenoidosa": ["c.pyrenoidosa", "c pyrenoidosa", "chlorella pyrenoidosa"],
+    "c. sorokiniana": ["c.sorokiniana", "c sorokiniana", "chlorella sorokiniana"],
+    "c. variabilis": ["c.variabilis", "c variabilis", "chlorella variabilis"],
+    "c. vulgaris": ["c.vulgaris", "c vulgaris", "chlorella vulgaris"],
+    "c. zofingiensis": ["c.zofingiensis", "c zofingiensis", "chromochloris zofingiensis", "chlorella zofingiensis"],
+    "h. pluvialis": ["h.pluvialis", "h pluvialis", "haematococcus pluvialis"],
+    "p. purpureum": ["p.purpureum", "p purpureum", "porphyridium purpureum"],
+    "scenedesmus sp.": ["scenedesmus", "scenedesmus sp", "desmodesmus sp."],
+}
+
+def _canon_from_alias(value: str, alias_map: dict[str, list[str]]) -> str:
+    v = normalize_str(value)
+    if v in alias_map:
+        return v
+    # match any key or its synonyms
+    for k, syns in alias_map.items():
+        if v == k or v in [normalize_str(s) for s in syns]:
+            return k
+    # punctuation/spacing heuristics for dotted species
+    v2 = v.replace(" .", ".").replace(". ", ".")  # collapse spaces around dots
+    for k, syns in alias_map.items():
+        if v2 == k or v2 in [normalize_str(s) for s in syns]:
+            return k
+    v3 = v.replace(" .", ".").replace(".", ". ")  # ensure a space after dot
+    for k, syns in alias_map.items():
+        if v3 == k or v3 in [normalize_str(s) for s in syns]:
+            return k
+    return v
+
+def _canon_to_known(value: str, known_classes: list[str] | np.ndarray, alias_map: dict[str, list[str]]) -> str:
+    """Return a token that is guaranteed to exist in known_classes."""
+    known = [str(k) for k in list(known_classes)]
+    v = _canon_from_alias(value, alias_map)
+    if v in known:
+        return v
+    # if alias key maps to a known token, use it
+    for k, syns in alias_map.items():
+        if v == k or v in [normalize_str(s) for s in syns]:
+            if k in known:
+                return k
+    # try fuzzy on known classes
+    hit = get_close_matches(v, known, n=1, cutoff=0.6)
+    if hit:
+        return hit[0]
+    # graceful fallback: try 'nan' if present, else the most frequent class (index 0)
+    return "nan" if "nan" in known else known[0]
 
 # -----------------------------
 # Helpers
@@ -744,19 +795,31 @@ def _load_ensemble(target: str) -> EnsembleBundle:
     return bundle
 
 def _encode_df_for_bundle(bundle: EnsembleBundle, df_like: pd.DataFrame) -> pd.DataFrame:
-    """Apply the SAVED encoders + numeric parsing + SAVED imputer; returns imputed numeric DF in training feature order."""
+    """
+    Apply the SAVED encoders + numeric parsing + SAVED imputer; returns imputed numeric DF in training feature order.
+    Critically: canonizes species/media to avoid 'previously unseen labels' errors.
+    """
     def _norm(x):
         return "nan" if pd.isna(x) else str(x).strip().lower()
 
+    # Build X with exactly the training feature 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
+    # ---- Canonicalize categoricals to known encoder classes BEFORE transform ----
+    if "species" in X.columns:
+        X["species"] = X["species"].map(_norm).apply(
+            lambda v: _canon_to_known(v, bundle.encoders["species"].classes_, SPECIES_ALIASES_CANON)
+        )
+    if "media" in X.columns:
+        X["media"] = X["media"].map(_norm).apply(
+            lambda v: _canon_to_known(v, bundle.encoders["media"].classes_, MEDIA_ALIASES)
+        )
+
+    # Now safe to transform: every token is guaranteed to exist in classes_
     for col in bundle.categorical_cols:
-        if col in X.columns:
-            X[col] = X[col].map(_norm).astype(str)
-            X[col] = X[col].apply(lambda v: bundle.encoders[col].transform([v])[0])
+        X[col] = bundle.encoders[col].transform(X[col].astype(str))
 
-    # numerics – parse like training
+    # ---- Numerics – parse exactly like training ----
     def _extract_first_float(x):
         if pd.isna(x): return np.nan
         s = str(x); m = re.search(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?", s)
@@ -773,6 +836,7 @@ 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 match training numeric space ----
     X_imp = pd.DataFrame(bundle.imputer.transform(X[bundle.feature_order]), columns=bundle.feature_order)
     return X_imp