| """Pooled out-of-fold (OOF) evaluation. |
| |
| Each of the 33 samples is a test sample in exactly one of the 5 folds, so the |
| fold predictions can be concatenated into a single OOF set of 33 trajectories. |
| Per-target R2 computed on that pooled set is far more stable than averaging five |
| per-fold R2 values, several of which are computed on 1-3 labelled samples. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| import os |
| from pathlib import Path |
| from typing import Dict, List, Tuple |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| from .data import TARGETS, TARGET_KEYS |
| from .metrics import PRIMARY, _r2, regression_metrics |
|
|
| ROOT = Path(os.environ.get("PIMAMBA_ROOT") |
| or Path(__file__).resolve().parents[2]) |
| RUNS = ROOT / "results" / "runs" |
| TABLES = ROOT / "results" / "tables" |
|
|
|
|
| def gather(model: str, seed: int = 0, n_folds: int = 5, prefix: str = "main"): |
| P, Y, M, S = [], [], [], [] |
| for f in range(n_folds): |
| d = RUNS / f"{prefix}_{model}_f{f}_s{seed}" / "predictions.npz" |
| if not d.exists(): |
| continue |
| z = np.load(d, allow_pickle=True) |
| P.append(z["pred"]); Y.append(z["true"]); M.append(z["mask"]) |
| S.append(np.asarray(z["sids"])) |
| if not P: |
| return None |
| return (np.concatenate(P, 0), np.concatenate(Y, 0), |
| np.concatenate(M, 0), np.concatenate(S, 0)) |
|
|
|
|
| def pooled_table(models: List[str], seed: int = 0, |
| prefix: str = "main") -> Tuple[pd.DataFrame, pd.DataFrame]: |
| rows, dec_rows = [], [] |
| for m in models: |
| g = gather(m, seed, prefix=prefix) |
| if g is None: |
| continue |
| P, Y, M, S = g |
| pt = regression_metrics(Y.reshape(-1, len(TARGETS)), |
| P.reshape(-1, len(TARGETS)), |
| M.reshape(-1, len(TARGETS))) |
| r = {"model": m, "n_samples": len(S)} |
| for k in TARGET_KEYS: |
| v = pt[k] |
| r[k] = round(v["r2"], 3) if np.isfinite(v["r2"]) else np.nan |
| prim = [pt[k]["r2"] for k in PRIMARY if np.isfinite(pt[k]["r2"])] |
| r["primary_mean"] = round(float(np.mean(prim)), 3) if prim else np.nan |
| r["primary_median"] = round(float(np.median(prim)), 3) if prim else np.nan |
| rows.append(r) |
|
|
| j = TARGET_KEYS.index("sigma") |
| mm = M[:, :, j] > 0 |
| yv, pv = Y[:, :, j][mm], P[:, :, j][mm] |
| ys, ps, lv = [], [], [] |
| for i in range(len(S)): |
| s = M[i, :, j] > 0 |
| if s.sum() < 4: |
| continue |
| ys.append(Y[i, s, j] - Y[i, s, j].mean()) |
| ps.append(P[i, s, j] - P[i, s, j].mean()) |
| lv.append((Y[i, s, j].mean(), P[i, s, j].mean())) |
| ys, ps = np.concatenate(ys), np.concatenate(ps) |
| lv = np.array(lv) |
| dec_rows.append({ |
| "model": m, |
| "sigma_r2": round(_r2(yv, pv), 3), |
| "shape_r2": round(_r2(ys, ps), 3), |
| "level_corr": round(float(np.corrcoef(lv[:, 0], lv[:, 1])[0, 1]), 3), |
| "level_mae_GPa": round(float(np.mean(np.abs(lv[:, 0] - lv[:, 1]))), 3), |
| "level_bias_GPa": round(float(np.mean(lv[:, 1] - lv[:, 0])), 3), |
| "peak_rel_err": round(float(np.mean([ |
| abs(max(P[i, M[i, :, j] > 0, j]) - max(Y[i, M[i, :, j] > 0, j])) |
| / max(abs(max(Y[i, M[i, :, j] > 0, j])), 1e-6) |
| for i in range(len(S)) if (M[i, :, j] > 0).sum() > 4])), 3), |
| }) |
| return pd.DataFrame(rows), pd.DataFrame(dec_rows) |
|
|
|
|
| def ensemble(models: List[str], seed: int = 0, prefix: str = "main", |
| prefixes: Dict[str, str] | None = None): |
| """Average the normalised predictions of several runs (same fold split). |
| |
| All models see the identical test ids in the identical order, so the fold |
| predictions are directly averageable; the result is inverse-transformed and |
| scored exactly like a single model. |
| """ |
| from .metrics import regression_metrics |
| Ps, Ys, Ms, Ss = [], None, None, None |
| for m in models: |
| pref = (prefixes or {}).get(m, prefix) |
| g = gather(m, seed, prefix=pref) |
| if g is None: |
| continue |
| P, Y, M, S = g |
| Ps.append(P) |
| Ys, Ms, Ss = Y, M, S |
| if not Ps: |
| return None |
| P = np.mean(Ps, 0) |
| pt = regression_metrics(Ys.reshape(-1, len(TARGETS)), |
| P.reshape(-1, len(TARGETS)), |
| Ms.reshape(-1, len(TARGETS))) |
| prim = [pt[k]["r2"] for k in PRIMARY if np.isfinite(pt[k]["r2"])] |
| return {"model": "+".join(models), "sigma_r2": round(pt["sigma"]["r2"], 3), |
| "primary_mean": round(float(np.mean(prim)), 3)} |
|
|
|
|
| NEXT = ["llama", "xlstm", "gdn", "hymba", "koopman", "node", "rssm", "flow", |
| "pimamba2"] |
|
|
|
|
| def main(): |
| models = ["mlp", "gru", "lstm", "transformer", "mamba", "mamba2", "pimamba"] |
| t, d = pooled_table(models) |
| TABLES.mkdir(parents=True, exist_ok=True) |
| t.to_csv(TABLES / "tab_pooled_per_target.csv", index=False) |
| d.to_csv(TABLES / "tab_pooled_sigma.csv", index=False) |
| ens = [] |
| combos = [(["pimamba", "mamba"], None), |
| (["pimamba", "llama"], {"llama": "next"}), |
| (["pimamba", "xlstm"], {"xlstm": "next"}), |
| (["pimamba", "gdn"], {"gdn": "next"}), |
| (["pimamba", "koopman"], {"koopman": "next"}), |
| (["pimamba", "node"], {"node": "next"}), |
| (["hymba", "mamba"], {"hymba": "next"}), |
| (["hymba", "mamba", "pimamba"], {"hymba": "next"}), |
| (["hymba", "llama"], {"hymba": "next", "llama": "next"})] |
| for combo, pref in combos: |
| r = ensemble(combo, prefixes=pref) |
| if r: |
| ens.append(r) |
| print("ensemble", r) |
| if ens: |
| pd.DataFrame(ens).to_csv(TABLES / "tab_ensemble.csv", index=False) |
| t2, d2 = pooled_table(NEXT, prefix="next") |
| if len(t2): |
| t2.to_csv(TABLES / "tab_pooled_next_per_target.csv", index=False) |
| d2.to_csv(TABLES / "tab_pooled_next_sigma.csv", index=False) |
| print("\n## pooled OOF (next-gen)") |
| print(t2.to_string(index=False)) |
|
|
| V2 = ["pimamba2", "pimamba2_peak", "pimamba_peak", "pimamba2_nocouple"] |
| t3, d3 = pooled_table(V2, prefix="v2") |
| if len(t3): |
| t3.to_csv(TABLES / "tab_pooled_v2_per_target.csv", index=False) |
| d3.to_csv(TABLES / "tab_pooled_v2_sigma.csv", index=False) |
| print("\n## pooled OOF (v2)") |
| print(t3.to_string(index=False)) |
| print("## pooled OOF per-target R2") |
| print(t.to_string(index=False)) |
| print("\n## pooled OOF stress decomposition") |
| print(d.to_string(index=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
