| """Stacked out-of-fold (OOF) ensemble with nested cross-validation. |
| |
| The base models are trained on exactly the same five folds (``--split_seed`` |
| fixed), so every sample has one out-of-fold prediction per model. A per-target |
| linear blend is then fitted *inside* the loop: for fold ``k`` the weights are |
| estimated on the other four folds and applied to fold ``k``. No sample ever |
| contributes to the weights that predict it, so the reported score is an honest |
| out-of-sample estimate of the stacked model. |
| |
| Why stacking: the architectures fail in different places (the physics-informed |
| Mamba is best at the absolute stress level, the attention hybrids at the curve |
| shape). A fixed average cannot exploit that; a fitted blend can. |
| |
| Usage:: |
| |
| python -m pimamba.stack --prefix best --models hymba gdn llama pimamba \ |
| --seeds 0 1 2 --out stack_best |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| from pathlib import Path |
| from typing import Dict, Iterable, List, Sequence |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| from .data import TARGETS, TARGET_KEYS |
| from .metrics import PRIMARY, _r2, regression_metrics |
| from .pooled import RUNS, TABLES |
|
|
| TAG_RE = re.compile(r"^(?P<prefix>[a-z0-9]+)_(?P<model>.+)_f(?P<fold>\d+)_s(?P<seed>\d+)$") |
|
|
|
|
| |
| |
| |
| def collect(prefix: str, models: Sequence[str], seeds: Sequence[int], |
| n_folds: int = 5, pmap: Dict[str, str] | None = None, |
| smap: Dict[str, Sequence[int]] | None = None |
| ) -> Dict[str, Dict[int, np.ndarray]]: |
| """Read ``predictions.npz`` for every (model, fold, seed). |
| |
| Returns ``{model: {sid: (pred, true, mask)}}`` where each array is |
| ``(T, 13)``. Seeds are averaged *after* inverse normalisation (the stored |
| predictions are already in physical units), which is the same operation as |
| averaging the sampled curves. |
| """ |
| pmap = pmap or {} |
| smap = smap or {} |
| acc: Dict[str, Dict[int, List[np.ndarray]]] = {m: {} for m in models} |
| for m in models: |
| pref = pmap.get(m, prefix) |
| for f in range(n_folds): |
| for s in smap.get(m, seeds): |
| d = RUNS / f"{pref}_{m}_f{f}_s{s}" / "predictions.npz" |
| if not d.exists(): |
| continue |
| z = np.load(d, allow_pickle=True) |
| P, Y, M = z["pred"], z["true"], z["mask"] |
| sids = np.asarray(z["sids"]).astype(int) |
| for i, sid in enumerate(sids): |
| slot = acc[m].setdefault(int(sid), {"p": [], "y": None, "m": None}) |
| slot["p"].append(P[i]) |
| slot["y"] = Y[i] |
| slot["m"] = M[i] |
| out: Dict[str, Dict[int, tuple]] = {} |
| for m, per in acc.items(): |
| out[m] = {sid: (np.mean(v["p"], 0), v["y"], v["m"]) for sid, v in per.items()} |
| return out |
|
|
|
|
| def fold_of(prefix: str, models: Sequence[str], seeds: Sequence[int], |
| n_folds: int = 5, pmap: Dict[str, str] | None = None, |
| smap: Dict[str, Sequence[int]] | None = None) -> Dict[int, int]: |
| """Recover the fold membership of every sample from the run folders.""" |
| pmap = pmap or {} |
| smap = smap or {} |
| fmap: Dict[int, int] = {} |
| m = models[0] |
| pref = pmap.get(m, prefix) |
| for f in range(n_folds): |
| d = RUNS / f"{pref}_{m}_f{f}_s{smap.get(m, seeds)[0]}" / "predictions.npz" |
| if not d.exists(): |
| continue |
| z = np.load(d, allow_pickle=True) |
| for sid in np.asarray(z["sids"]).astype(int): |
| fmap[int(sid)] = f |
| return fmap |
|
|
|
|
| |
| |
| |
| def _fit_weights(X: np.ndarray, y: np.ndarray, ridge: float = 1e-3, |
| nonneg: bool = True) -> tuple: |
| """Ridge regression with optional non-negativity on the model weights. |
| |
| Returns ``(w, b)`` such that ``pred = X @ w + b``. Centring removes the |
| intercept from the penalty; the solution is obtained with a small |
| projected-gradient loop (``nonneg``) or a closed form. |
| """ |
| mu_x, mu_y = X.mean(0), float(y.mean()) |
| Xc, yc = X - mu_x, y - mu_y |
| A = Xc.T @ Xc + ridge * np.eye(X.shape[1]) |
| b_vec = Xc.T @ yc |
| if not nonneg: |
| w = np.linalg.solve(A, b_vec) |
| else: |
| w = np.clip(np.linalg.solve(A, b_vec), 0, None) |
| |
| step = 1.0 / (np.linalg.eigvalsh(A).max() + 1e-9) |
| for _ in range(400): |
| w = np.clip(w - step * (A @ w - b_vec), 0, None) |
| b = mu_y - float(mu_x @ w) |
| return w, b |
|
|
|
|
| def nested_stack(data: Dict[str, Dict[int, tuple]], fmap: Dict[int, int], |
| models: Sequence[str], n_folds: int = 5, |
| ridge: float = 1e-3, nonneg: bool = True): |
| """Fit per-target blends in a leave-one-fold-out loop. |
| |
| Returns ``(P, Y, M, S, weights)`` with stacked predictions in the same |
| (sample, time, target) layout as a single model, plus the per-fold weight |
| matrix for inspection. |
| """ |
| sids = sorted(fmap, key=lambda s: (fmap[s], s)) |
| keep = [s for s in sids if all(s in data[m] for m in models)] |
| S = np.asarray(keep, dtype=int) |
| shp = data[models[0]][keep[0]][0].shape |
| P = np.zeros((len(keep),) + shp, np.float32) |
| Y = np.zeros_like(P) |
| M = np.zeros_like(P) |
| weights = [] |
| fold_arr = np.array([fmap[s] for s in keep]) |
| for f in range(n_folds): |
| te = fold_arr == f |
| tr = ~te |
| for i, s in enumerate(keep): |
| Y[i] = data[models[0]][s][1] |
| M[i] = data[models[0]][s][2] |
| for j in range(shp[-1]): |
| Xtr, ytr = [], [] |
| for i in np.where(tr)[0]: |
| msk = M[i, :, j] > 0 |
| if not msk.any(): |
| continue |
| Xtr.append(np.stack([data[m][keep[i]][0][msk, j] for m in models], -1)) |
| ytr.append(Y[i, msk, j]) |
| if not Xtr: |
| continue |
| Xc = np.concatenate(Xtr, 0) |
| yc = np.concatenate(ytr, 0) |
| w, b = _fit_weights(Xc, yc, ridge=ridge, nonneg=nonneg) |
| for i in np.where(te)[0]: |
| msk = M[i, :, j] > 0 |
| if not msk.any(): |
| continue |
| Xte = np.stack([data[m][keep[i]][0][msk, j] for m in models], -1) |
| P[i, msk, j] = Xte @ w + b |
| weights.append({"fold": f, "target": TARGET_KEYS[j], |
| **{f"w_{m}": float(wi) for m, wi in zip(models, w)}, |
| "b": float(b)}) |
| return P, Y, M, S, pd.DataFrame(weights) |
|
|
|
|
| def mean_ensemble(data: Dict[str, Dict[int, tuple]], fmap: Dict[int, int], |
| models: Sequence[str]): |
| sids = sorted(fmap, key=lambda s: (fmap[s], s)) |
| keep = [s for s in sids if all(s in data[m] for m in models)] |
| S = np.asarray(keep, dtype=int) |
| P = np.mean([np.stack([data[m][s][0] for s in keep]) for m in models], 0) |
| Y = np.stack([data[models[0]][s][1] for s in keep]) |
| M = np.stack([data[models[0]][s][2] for s in keep]) |
| return P, Y, M, S |
|
|
|
|
| def greedy_blend(data: Dict[str, Dict[int, tuple]], fmap: Dict[int, int], |
| models: Sequence[str], n_folds: int = 5, iters: int = 15): |
| """Caruana-style forward selection with replacement, fitted per fold. |
| |
| For every target we start from an empty blend and repeatedly add the model |
| that most reduces the squared error on the *training* folds; the final |
| prediction on the held-out fold is the average of the selected models |
| (a model can be picked several times, which gives it a larger weight). |
| Selection uses only training folds, so the score stays out-of-sample. |
| |
| Why this instead of ridge: with 26 training trajectories the models are |
| strongly correlated, and unconstrained least squares produces unstable, |
| sometimes negative weights. Greedy selection is a coarse but much more |
| stable procedure on this sample size. |
| """ |
| sids = sorted(fmap, key=lambda s: (fmap[s], s)) |
| keep = [s for s in sids if all(s in data[m] for m in models)] |
| S = np.asarray(keep, dtype=int) |
| shp = data[models[0]][keep[0]][0].shape |
| P = np.zeros((len(keep),) + shp, np.float32) |
| Y = np.zeros_like(P) |
| M = np.zeros_like(P) |
| fold_arr = np.array([fmap[s] for s in keep]) |
| for i, s in enumerate(keep): |
| Y[i] = data[models[0]][s][1] |
| M[i] = data[models[0]][s][2] |
| picks = [] |
| for f in range(n_folds): |
| te = np.where(fold_arr == f)[0] |
| tr = np.where(fold_arr != f)[0] |
| for j in range(shp[-1]): |
| trn = [i for i in tr if (M[i, :, j] > 0).sum() >= 4] |
| if not trn: |
| continue |
| ytr = np.concatenate([Y[i, M[i, :, j] > 0, j] for i in trn]) |
| Xtr = {m: np.concatenate([data[m][keep[i]][0][M[i, :, j] > 0, j] |
| for i in trn]) for m in models} |
| sel: List[str] = [] |
| cur = np.zeros_like(ytr) |
| for _ in range(iters): |
| best = None |
| for m in models: |
| trial = (cur * len(sel) + Xtr[m]) / (len(sel) + 1) |
| err = float(np.mean((trial - ytr) ** 2)) |
| if best is None or err < best[0]: |
| best = (err, m, trial) |
| sel.append(best[1]) |
| cur = best[2] |
| cnt = {m: sel.count(m) / float(len(sel)) for m in models} |
| picks.append({"fold": f, "target": TARGET_KEYS[j], **cnt}) |
| for i in te: |
| msk = M[i, :, j] > 0 |
| if not msk.any(): |
| continue |
| P[i, msk, j] = sum(cnt[m] * data[m][keep[i]][0][msk, j] |
| for m in models if cnt[m] > 0) |
| return P, Y, M, S, pd.DataFrame(picks) |
|
|
| |
| |
| |
| def score(P: np.ndarray, Y: np.ndarray, M: np.ndarray, S: np.ndarray) -> Dict: |
| pt = regression_metrics(Y.reshape(-1, len(TARGETS)), |
| P.reshape(-1, len(TARGETS)), |
| M.reshape(-1, len(TARGETS))) |
| row = {k: (round(pt[k]["r2"], 3) if np.isfinite(pt[k]["r2"]) else np.nan) |
| for k in TARGET_KEYS} |
| prim = [pt[k]["r2"] for k in PRIMARY if np.isfinite(pt[k]["r2"])] |
| row["primary_mean"] = round(float(np.mean(prim)), 3) if prim else np.nan |
| j = TARGET_KEYS.index("sigma") |
| mm = M[:, :, j] > 0 |
| yv, pv = Y[:, :, j][mm], P[:, :, j][mm] |
| row["sigma_r2"] = round(_r2(yv, pv), 3) |
| ys, ps = [], [] |
| for i in range(len(S)): |
| msk = M[i, :, j] > 0 |
| if msk.sum() < 4: |
| continue |
| ys.append(Y[i, msk, j] - Y[i, msk, j].mean()) |
| ps.append(P[i, msk, j] - P[i, msk, j].mean()) |
| row["shape_r2"] = round(_r2(np.concatenate(ys), np.concatenate(ps)), 3) |
| row["n_samples"] = int(len(S)) |
| return row |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser("pimamba.stack") |
| ap.add_argument("--prefix", default="best") |
| ap.add_argument("--models", nargs="+", |
| default=["hymba", "gdn", "llama", "pimamba"]) |
| ap.add_argument("--seeds", nargs="+", type=int, default=[0]) |
| ap.add_argument("--n_folds", type=int, default=5) |
| ap.add_argument("--ridge", type=float, default=1e-3) |
| ap.add_argument("--allow-negative", action="store_true") |
| ap.add_argument("--method", default="greedy", |
| choices=["greedy", "ridge", "mean"], |
| help="greedy = forward selection with replacement " |
| "(stable on small samples); ridge = per-target " |
| "non-negative least squares; mean = equal weights") |
| ap.add_argument("--iters", type=int, default=15) |
| ap.add_argument("--out", default="stack") |
| ap.add_argument("--prefixes", nargs="*", default=[], |
| help="per-model run prefix, e.g. mlp=main pimamba=main") |
| ap.add_argument("--seeds_map", nargs="*", default=[], |
| help="per-model seeds, e.g. mlp=0 pimamba=0,1,2") |
| a = ap.parse_args() |
|
|
| pmap = {} |
| for kv in a.prefixes: |
| k, v = kv.split("=") |
| pmap[k] = v |
| smap = {} |
| for kv in a.seeds_map: |
| k, v = kv.split("=") |
| smap[k] = [int(x) for x in v.split(",")] |
|
|
| data = collect(a.prefix, a.models, a.seeds, a.n_folds, pmap, smap) |
| fmap = fold_of(a.prefix, a.models, a.seeds, a.n_folds, pmap, smap) |
| rows = [] |
| for m in a.models: |
| if not data.get(m): |
| continue |
| sids = sorted(data[m]) |
| P = np.stack([data[m][s][0] for s in sids]) |
| Y = np.stack([data[m][s][1] for s in sids]) |
| M = np.stack([data[m][s][2] for s in sids]) |
| rows.append({"model": m, **score(P, Y, M, np.asarray(sids))}) |
| P, Y, M, S = mean_ensemble(data, fmap, a.models) |
| rows.append({"model": "mean-ensemble", **score(P, Y, M, S)}) |
| if a.method == "mean": |
| Ps, Ys, Ms, Ss, W = P, Y, M, S, None |
| elif a.method == "greedy": |
| Ps, Ys, Ms, Ss, W = greedy_blend(data, fmap, a.models, a.n_folds, |
| iters=a.iters) |
| else: |
| Ps, Ys, Ms, Ss, W = nested_stack(data, fmap, a.models, a.n_folds, |
| ridge=a.ridge, |
| nonneg=not a.allow_negative) |
| rows.append({"model": f"stacked-{a.method}", **score(Ps, Ys, Ms, Ss)}) |
| df = pd.DataFrame(rows) |
| df.to_csv(TABLES / f"tab_{a.out}.csv", index=False) |
| if W is not None: |
| W.to_csv(TABLES / f"tab_{a.out}_weights.csv", index=False) |
| print(df.to_string(index=False)) |
| print("\nmean weight per model (greedy: selection frequency):") |
| wcols = [c for c in W.columns if c not in ("fold", "target")] |
| print(W[wcols].mean().round(3).to_string()) |
| else: |
| print(df.to_string(index=False)) |
| np.savez_compressed(TABLES / f"{a.out}_pred.npz", pred=Ps, true=Ys, |
| mask=Ms, sids=Ss) |
| (TABLES / f"{a.out}_meta.json").write_text(json.dumps( |
| {"models": a.models, "seeds": a.seeds, "prefixes": pmap, |
| "seeds_map": smap, "method": a.method, "ridge": a.ridge, |
| "nonneg": not a.allow_negative}, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
