sync code

code/pimamba/predict.py

@@ -0,0 +1,142 @@
+"""Inference / deployment: run a trained checkpoint on new alloy conditions.
+
+Two use cases
+-------------
+1. *Re-score* held-out samples with a published checkpoint::
+
+       python -m pimamba.predict --run results/runs/main_pimamba_f2_s0
+
+2. *What-if* on new compositions / conditions: give a CSV with the same columns
+   as ``data/processed/samples_meta.csv`` (one row per condition)::
+
+       python -m pimamba.predict --run results/runs/main_pimamba_f0_s0 \
+              --meta my_alloys.csv --out my_preds.csv
+
+Only the *static* columns are used for a new sample; the strain grid is
+synthesised (0 -> eps_max), because the dynamic input channels depend only on
+strain, strain rate, T0 and load mode.  Every column of ``samples_meta.csv``
+must be present (missing optional ones may be left empty / NaN).
+
+Output: long-format CSV with ``sample_id, strain, <13 targets>``.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from .data import (PROC, TARGETS, Normalizer, PackedDataset, build_static_frame,
+                   collate)
+from .models import build_model
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def synth_traj(sids, n_points: int = 401, eps_max: float = 0.2) -> pd.DataFrame:
+    """Strain grid with all targets missing -> the loss mask is all-zero."""
+    eps = np.linspace(0.0, eps_max, n_points)
+    frames = []
+    for s in sids:
+        d = {"sample_id": int(s), "strain": eps}
+        for t in TARGETS:
+            d[t.name] = np.nan
+        frames.append(pd.DataFrame(d))
+    return pd.concat(frames, ignore_index=True)
+
+
+def load_run(run_dir: Path, device="cpu"):
+    import torch
+
+    ck = torch.load(run_dir / "model.pt", map_location=device, weights_only=False)
+    meta = json.loads((run_dir / "metrics.json").read_text())
+    cfg = ck["cfg"]
+    model = build_model(cfg["model"], n_static=int(np.sum(ck["keep_mask"])),
+                        n_out=len(TARGETS), d_model=cfg["d_model"],
+                        n_layers=cfg["n_layers"], d_state=cfg["d_state"],
+                        dropout=cfg["dropout"], coupling=cfg["coupling"]).to(device)
+    model.load_state_dict(ck["state"])
+    model.eval()
+    return model, cfg, meta, ck
+
+
+def predict(run_dir: Path, meta: pd.DataFrame, sids, n_points: int = 401,
+            eps_max: float = 0.2, device="cpu") -> pd.DataFrame:
+    import torch
+
+    model, cfg, run_meta, ck = load_run(run_dir, device)
+    names = ck["names"]
+    km = np.asarray(ck["keep_mask"], dtype=bool)
+    kinds = build_static_frame(meta)[2]
+    norm = Normalizer.from_json(run_meta["normalizer"])
+
+    mtab = meta.reset_index(drop=True)
+    traj = synth_traj(sids, n_points, eps_max)
+    ds = PackedDataset(sids, mtab, traj, norm, names, kinds, km)
+    dl = torch.utils.data.DataLoader(ds, batch_size=8, shuffle=False,
+                                     collate_fn=collate)
+
+    preds, used = [], []
+    with torch.no_grad():
+        for st, x, _Y, _M, sid in dl:
+            out = model(st.to(device), x.to(device))
+            preds.append(out["pred"].cpu().numpy())
+            used.extend([int(v) for v in sid])
+    raw = norm.inverse_targets(np.concatenate(preds, 0))     # (N, T, 13)
+
+    eps = np.linspace(0.0, eps_max, n_points)
+    frames = []
+    for i, s in enumerate(used):
+        d = {"sample_id": s, "strain": eps}
+        for k, t in enumerate(TARGETS):
+            d[t.name] = raw[i, :, k]
+        frames.append(pd.DataFrame(d))
+    return pd.concat(frames, ignore_index=True)
+
+
+def main():
+    ap = argparse.ArgumentParser("pimamba.predict")
+    ap.add_argument("--run", default="results/runs/main_pimamba_f2_s0",
+                    help="run directory containing model.pt + metrics.json")
+    ap.add_argument("--meta", default=None,
+                    help="CSV of new samples (same columns as samples_meta.csv)")
+    ap.add_argument("--sids", default=None,
+                    help="comma separated sample_ids of data/processed/samples_meta.csv")
+    ap.add_argument("--n-points", type=int, default=401)
+    ap.add_argument("--eps-max", type=float, default=0.2)
+    ap.add_argument("--out", default="predictions.csv")
+    ap.add_argument("--device", default="cpu")
+    a = ap.parse_args()
+
+    run_dir = Path(a.run)
+    if not run_dir.is_absolute():
+        run_dir = ROOT / run_dir
+    run_meta = json.loads((run_dir / "metrics.json").read_text())
+
+    if a.meta:
+        meta = pd.read_csv(a.meta)
+    else:
+        meta = pd.read_csv(PROC / "samples_meta.csv")
+    if a.sids:
+        sids = [int(s) for s in a.sids.split(",") if s.strip()]
+    elif a.meta:
+        # a new alloy table: predict every row it contains
+        sids = [int(s) for s in meta.sample_id]
+    else:
+        sids = [int(s) for s in run_meta["test_ids"]]
+
+    missing = set(sids) - set(meta.sample_id.astype(int))
+    if missing:
+        raise SystemExit(f"sample_id not found in meta table: {sorted(missing)}")
+
+    df = predict(run_dir, meta, sids, a.n_points, a.eps_max, a.device)
+    df.to_csv(a.out, index=False)
+    print(f"wrote {a.out}: {df.shape[0]} rows x {df.shape[1]} cols "
+          f"({len(sids)} samples, {a.n_points} strain points)")
+    print(df.head(3).to_string(index=False))
+
+
+if __name__ == "__main__":
+    main()