| """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)) |
|
|
| 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: |
| |
| 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() |
