Update src/streamlit_app.py

src/streamlit_app.py

@@ -654,19 +654,59 @@ with tabs[4]:
                 # evaluate stacked ensemble on a holdout split
                 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
+                base_model_map = {bm["family"]: bm["model"] for bm in base_models}
+
                 meta_inputs = []
+                missing_families = []
                 for fam in selected:
-                    bm = next((b for b in base_models if b["family"] == fam), None)
-                    if bm is not None:
-                        try:
-                            meta_inputs.append(bm["model"].predict(X_val))
-                        except Exception:
-                            meta_inputs.append(np.full(len(X_val), y_tr.mean()))
-                    else:
+                    bm = base_model_map.get(fam, None)
+                    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()))
+                        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())
+                        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)
                 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)
+                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
                 y_meta_pred = meta.predict(X_meta_val)
 
+
                 final_r2 = r2_score(y_val, y_meta_pred)
                 final_rmse = mean_squared_error(y_val, y_meta_pred, squared=False)