Update src/streamlit_app.py

src/streamlit_app.py

@@ -651,109 +651,124 @@ with tabs[4]:
                 meta = Ridge(alpha=1.0)
                 meta.fit(X_stack, y)
 
-                # evaluate stacked ensemble on a holdout split
+                # --- Robust holdout evaluation & SHAP (safe for deployment) ---
+                # Split for holdout
                 X_tr, X_val, y_tr, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
-                # predict with base models -> create meta inputs
-                # build a map of family -> fitted model
+                
+                # Helper to always produce scalar-safe mean
+                def scalar_mean(arr):
+                    try:
+                        return float(np.mean(arr))
+                    except Exception:
+                        return float(np.mean(np.ravel(arr)))
+                
+                # Build family → model map
                 base_model_map = {bm["family"]: bm["model"] for bm in base_models}
-
+                
                 meta_inputs = []
                 missing_families = []
+                n_meta_features_trained = X_stack.shape[1]
+                
+                # Collect predictions from each selected model
                 for fam in selected:
-                    bm = base_model_map.get(fam, None)
+                    bm = base_model_map.get(fam)
                     if bm is None:
-                        # missing base model: fill with training mean as safe fallback
                         missing_families.append(fam)
-                        meta_inputs.append(np.full(len(X_val), y_tr.mean()))
+                        safe_mean = scalar_mean(y_tr)
+                        meta_inputs.append(np.full(len(X_val), safe_mean))
                         continue
-
+                
                     try:
                         preds = bm.predict(X_val)
-                        # make sure preds is 1D and correct length
-                        preds = np.asarray(preds).reshape(-1)
-                        if len(preds) != len(X_val):
-                            # fallback to mean if shape mismatch
-                            preds = np.full(len(X_val), y_tr.mean())
+                        preds = np.asarray(preds)
+                        # Collapse multi-output predictions to 1D
+                        if preds.ndim == 2:
+                            preds = preds.mean(axis=1)
+                        preds = preds.reshape(-1)
+                        if preds.shape[0] != len(X_val):
+                            preds = np.full(len(X_val), scalar_mean(y_tr))
                         meta_inputs.append(preds)
-                    except Exception:
-                        # fallback to mean predictions on error
-                        meta_inputs.append(np.full(len(X_val), y_tr.mean()))
-
-                if len(missing_families) > 0:
-                    st.warning(f"Warning: missing base models for families: {missing_families}. Filled with mean predictions.")
-
-                # Now stack into (n_samples, n_models_selected)
+                    except Exception as e:
+                        safe_mean = scalar_mean(y_tr)
+                        meta_inputs.append(np.full(len(X_val), safe_mean))
+                
+                if missing_families:
+                    st.warning(f"Missing base models: {missing_families}. Using mean predictions.")
+                
+                # Stack meta features
+                if not meta_inputs:
+                    st.error("No meta features to predict — aborting.")
+                    st.stop()
+                
                 X_meta_val = np.column_stack(meta_inputs)
-
-                # Defensive check: ensure X_meta_val has same number of cols as meta was trained on
-                n_meta_features_trained = X_stack.shape[1]
                 n_meta_features_val = X_meta_val.shape[1]
-                if n_meta_features_val != n_meta_features_trained:
-                    st.warning(f"Meta feature mismatch: trained on {n_meta_features_trained} cols, validating with {n_meta_features_val} cols. Aligning by padding/truncating.")
-                    # If fewer cols, pad with columns of means
-                    if n_meta_features_val < n_meta_features_trained:
-                        pad_cols = n_meta_features_trained - n_meta_features_val
-                        pad = np.tile(np.full((len(X_val),1), y_tr.mean()), (1, pad_cols))
-                        X_meta_val = np.hstack([X_meta_val, pad])
-                    # If more cols, truncate to the trained size (keeps leftmost selected order)
-                    else:
-                        X_meta_val = X_meta_val[:, :n_meta_features_trained]
-
-                # final safety assert (will raise an informative error if still wrong)
+                
+                # Align meta features between training and validation
+                if n_meta_features_val < n_meta_features_trained:
+                    pad_cols = n_meta_features_trained - n_meta_features_val
+                    safe_mean = scalar_mean(y_tr)
+                    pad = np.tile(np.full((len(X_val), 1), safe_mean), (1, pad_cols))
+                    X_meta_val = np.hstack([X_meta_val, pad])
+                elif n_meta_features_val > n_meta_features_trained:
+                    X_meta_val = X_meta_val[:, :n_meta_features_trained]
+                
                 if X_meta_val.shape[1] != n_meta_features_trained:
-                    raise ValueError(f"Final X_meta_val columns ({X_meta_val.shape[1]}) != trained meta features ({n_meta_features_trained})")
-
-                # predict
+                    st.error(f"Stack alignment failed: {X_meta_val.shape[1]} != {n_meta_features_trained}")
+                    st.stop()
+                
+                # Meta prediction
                 y_meta_pred = meta.predict(X_meta_val)
-
-
+                
+                # Final evaluation
                 final_r2 = r2_score(y_val, y_meta_pred)
                 final_rmse = mean_squared_error(y_val, y_meta_pred, squared=False)
-
+                
                 c1, c2 = st.columns(2)
                 c1.metric("Stacked Ensemble R² (holdout)", f"{final_r2:.4f}")
                 c2.metric("Stacked Ensemble RMSE (holdout)", f"{final_rmse:.4f}")
-
-                # scatter plot
-                fig, ax = plt.subplots(figsize=(7,4))
+                
+                # Scatter comparison
+                fig, ax = plt.subplots(figsize=(7, 4))
                 ax.scatter(y_val, y_meta_pred, alpha=0.6)
                 ax.plot([y_val.min(), y_val.max()], [y_val.min(), y_val.max()], "r--")
-                ax.set_xlabel("Actual"); ax.set_ylabel("Stacked Predicted")
+                ax.set_xlabel("Actual")
+                ax.set_ylabel("Stacked Predicted")
                 st.pyplot(fig)
-
-                # save artifacts: base models list + meta learner
-                stack_artifact = os.path.join(DATA_DIR, f"stacked_{use_case.replace(' ','_')}.joblib")
-                to_save = {"base_models": {bm["family"]: bm["model"] for bm in base_models if bm["family"] in selected}, "meta": meta, "features": features, "selected": selected, "target": target}
+                
+                # Save trained stack artifacts
+                stack_artifact = os.path.join(DATA_DIR, f"stacked_{use_case.replace(' ', '_')}.joblib")
+                to_save = {
+                    "base_models": {bm["family"]: bm["model"] for bm in base_models if bm["family"] in selected},
+                    "meta": meta,
+                    "features": features,
+                    "selected": selected,
+                    "target": target,
+                }
                 joblib.dump(to_save, stack_artifact)
-                st.caption(f"Stacked ensemble saved: {stack_artifact}")
-
-                # --- SHAP on final stack: approximate by SHAP of top base model or meta contributions ---
+                st.caption(f"✅ Stacked ensemble saved: {stack_artifact}")
+                
+                # Explainability
                 st.markdown("### Explainability (approximate)")
                 try:
-                    # Prefer SHAP on top base model (tree) for interpretability
                     top_base = next((b for b in base_models if b["family"] == selected[0]), None)
-                    if top_base is not None and hasattr(top_base["model"], "predict"):
-                        # sample for speed
+                    if top_base and hasattr(top_base["model"], "predict"):
                         sample_X = X_val.sample(min(300, len(X_val)), random_state=42)
-                        if hasattr(top_base["model"], "predict") and ("XGBoost" in top_base["family"] or "LightGBM" in top_base["family"] or "RandomForest" in top_base["family"] or "ExtraTrees" in top_base["family"] or "CatBoost" in top_base["family"]):
-                            expl = None
-                            # safe tree explainer creation
-                            try:
-                                expl = shap.TreeExplainer(top_base["model"])
-                                shap_vals = expl.shap_values(sample_X)
-                                fig_sh = plt.figure(figsize=(8,6))
-                                shap.summary_plot(shap_vals, sample_X, show=False)
-                                st.pyplot(fig_sh)
-                            except Exception as e:
-                                st.warning(f"SHAP tree explainer unavailable: {e}")
+                        if any(k in top_base["family"] for k in ["XGBoost", "LightGBM", "RandomForest", "ExtraTrees", "CatBoost"]):
+                            expl = shap.TreeExplainer(top_base["model"])
+                            shap_vals = expl.shap_values(sample_X)
+                            fig_sh = plt.figure(figsize=(8, 6))
+                            shap.summary_plot(shap_vals, sample_X, show=False)
+                            st.pyplot(fig_sh)
                         else:
-                            st.info("Top base model not tree-based; SHAP summary skipped. You can inspect per-base feature importances above.")
+                            st.info("Top model not tree-based; skipping SHAP summary.")
                     else:
-                        st.info("No suitable base model for SHAP explanation found.")
+                        st.info("No suitable base model for SHAP explanation.")
                 except Exception as e:
-                    st.warning(f"SHAP step failed gracefully: {e}")
+                    st.warning(f"SHAP computation skipped: {e}")
+                
+                st.success("✅ AutoML + Stacking complete — metrics, artifacts, and SHAP ready.")
+
 
-                st.success("AutoML + Stacking complete. Review metrics and saved artifacts.")
     
 # -----  Target & Business Impact tab
 with tabs[5]: