Update app.py

app.py

@@ -199,17 +199,24 @@ def normalize_to_abbr(df: pd.DataFrame) -> pd.DataFrame:
     out.columns = newcols
     return out
 
-# ---- Build X in the model's training order & avoid name check ----
-def _make_X_for_model(df: pd.DataFrame, model, fallback_features: list[str]) -> np.ndarray:
+# ---- Model feature order + X builder (returns NumPy to bypass name checks) ----
+def _training_feature_order(model, fallback_features: list[str]) -> list[str]:
+    """Return the model's training feature order if available, else fallback."""
+    names = list(getattr(model, "feature_names_in_", []))
+    if names:
+        return [str(n) for n in names]
+    return list(fallback_features)
+
+def _make_X(df_raw: pd.DataFrame, model, fallback_features: list[str]) -> np.ndarray:
     """
     Returns a NumPy array with columns ordered exactly as in model training.
     Using np.ndarray bypasses sklearn's feature-name validation.
     """
-    df_abbr = normalize_to_abbr(df)
+    df_abbr = normalize_to_abbr(df_raw)
     # mapping abbr -> actual column present
     colmap = { _abbr(c): c for c in df_abbr.columns }
 
-    train_names = list(getattr(model, "feature_names_in_", fallback_features))
+    train_names = _training_feature_order(model, fallback_features)
     order_cols = []
     missing = []
     for nm in train_names:
@@ -220,16 +227,21 @@ def _make_X_for_model(df: pd.DataFrame, model, fallback_features: list[str]) ->
             missing.append(nm)
 
     if missing:
-        st.markdown('<div class="st-message-box st-error">Missing required columns for prediction (by model training): '
-                    + ", ".join(missing) + '</div>', unsafe_allow_html=True)
+        st.markdown(
+            '<div class="st-message-box st-error">Missing required columns for prediction (by model training): '
+            + ", ".join(missing) + '</div>',
+            unsafe_allow_html=True
+        )
         st.stop()
 
-    X = df_abbr[order_cols].apply(pd.to_numeric, errors="coerce")
-    return X.to_numpy()
+    X_df = df_abbr[order_cols].apply(pd.to_numeric, errors="coerce")
+    X_np = X_df.to_numpy(dtype=float, copy=False)
+    # Safety: ensure plain ndarray (no pandas attrs)
+    return np.asarray(X_np, dtype=float)
 
 def ensure_required_features(df: pd.DataFrame, model, fallback_features: list[str]) -> bool:
     df_abbr = normalize_to_abbr(df)
-    need = [_abbr(nm) for nm in list(getattr(model, "feature_names_in_", fallback_features))]
+    need = [_abbr(nm) for nm in _training_feature_order(model, fallback_features)]
     have = {_abbr(c) for c in df_abbr.columns}
     miss = [n for n in need if n not in have]
     if miss:
@@ -237,6 +249,19 @@ def ensure_required_features(df: pd.DataFrame, model, fallback_features: list[st
         return False
     return True
 
+def safe_predict(model, df_raw: pd.DataFrame, fallback_features: list[str]) -> np.ndarray:
+    """
+    Centralized, name-check-proof prediction:
+    - Builds X in training order
+    - Converts to NumPy (bypasses sklearn feature-name validation)
+    """
+    X = _make_X(df_raw, model, fallback_features)
+    try:
+        return model.predict(X)
+    except Exception as e:
+        # As a last resort, try basic float casting
+        return model.predict(np.asarray(X, dtype=float))
+
 def find_sheet(book, names):
     low2orig = {k.lower(): k for k in book.keys()}
     for nm in names:
@@ -557,8 +582,9 @@ if st.session_state.app_step == "dev":
         tr = normalize_to_abbr(tr_raw)
         te = normalize_to_abbr(te_raw)
 
-        tr[PRED_COL] = model.predict(_make_X_for_model(tr_raw, model, FEATURES))
-        te[PRED_COL] = model.predict(_make_X_for_model(te_raw, model, FEATURES))
+        # ---- SAFE PREDICT (NumPy only) ----
+        tr[PRED_COL] = safe_predict(model, tr_raw, FEATURES)
+        te[PRED_COL] = safe_predict(model, te_raw, FEATURES)
 
         st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
         st.session_state.results["m_train"]={
@@ -757,7 +783,7 @@ if st.session_state.app_step == "validate":
             st.stop()
 
         df = normalize_to_abbr(df_raw)
-        df[PRED_COL] = model.predict(_make_X_for_model(df_raw, model, FEATURES))
+        df[PRED_COL] = safe_predict(model, df_raw, FEATURES)
         st.session_state.results["Validate"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=None
@@ -869,7 +895,7 @@ if st.session_state.app_step == "predict":
             st.stop()
 
         df = normalize_to_abbr(df_raw)
-        df[PRED_COL] = model.predict(_make_X_for_model(df_raw, model, FEATURES))
+        df[PRED_COL] = safe_predict(model, df_raw, FEATURES)
         st.session_state.results["PredictOnly"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0