"""Single-run training / evaluation engine.""" from __future__ import annotations import argparse import json import time from dataclasses import dataclass, field, asdict from pathlib import Path from typing import Dict, List, Optional, Sequence import numpy as np import pandas as pd import torch import torch.nn.functional as F from torch.utils.data import DataLoader from .data import (PROC, TARGETS, TARGET_KEYS, Normalizer, PackedDataset, build_static_frame, collate, kfold_split, loao_split, random_split) from .losses import masked_mse, masked_mse_balanced, physics_losses, peak_loss from .metrics import (curve_metrics, regression_metrics, sigma_decomposition, summarise) from .models import build_model ROOT = Path(__file__).resolve().parents[2] RUNS = ROOT / "results" / "runs" @dataclass class Cfg: model: str = "pimamba" seed: int = 0 split: str = "random" # random | loao | kfold holdout: str = "" # alloy name for loao # K-fold assignment seed. ``None`` keeps the old behaviour (split changes # with the run seed); an integer fixes the partition so that different # seeds / architectures see exactly the same folds, which is required for # seed averaging and for stacking. split_seed: Optional[int] = None n_folds: int = 5 fold: int = 0 test_frac: float = 0.2 epochs: int = 250 batch: int = 8 lr: float = 3e-4 wd: float = 1e-4 d_model: int = 64 n_layers: int = 2 d_state: int = 16 dropout: float = 0.1 coupling: bool = True w_mono: float = 0.0 w_init: float = 0.0 w_smooth: float = 0.0 w_peak: float = 0.0 # curve-level peak-matching weight drop_features: Sequence[str] = () norm_mode: str = "full" # full | none train_frac: float = 1.0 # data-efficiency ablation use_val: bool = True # False -> fixed-epoch fit on all train data tag: str = "" device: str = "cuda" if torch.cuda.is_available() else "cpu" def _seed_all(seed: int): np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) def feature_mask(names: List[str], drop: Sequence[str]) -> np.ndarray: m = np.ones(len(names), np.float32) if not drop: return m for j, nm in enumerate(names): for d in drop: if d == "ensemble" and nm.startswith("ensemble="): m[j] = 0 elif d == "shape" and nm.startswith("shape_type="): m[j] = 0 elif d == "geom_flags" and nm.startswith("app_"): m[j] = 0 elif d == "geom" and nm.startswith(("geom_", "app_", "orient_")): m[j] = 0 elif d == "composition" and nm.startswith("at_"): m[j] = 0 elif d == "init_rho" and nm.startswith("init_d_"): m[j] = 0 elif d == "init_phase" and nm.startswith("init_xi_"): m[j] = 0 elif d == "descriptors" and nm in { "VEC", "delta", "rbar", "dHmix", "dSmix", "chi", "Mavg", "dmu", "Tm", "rhomass"}: m[j] = 0 elif d == "orientation" and nm.startswith("orient_"): m[j] = 0 return m def _split_ids(meta: pd.DataFrame, cfg: Cfg, alloys: List[str]): if cfg.split == "loao": return loao_split(alloys, meta, cfg.holdout) if cfg.split == "kfold": ss = cfg.seed if cfg.split_seed is None else int(cfg.split_seed) return kfold_split(alloys, meta, ss, cfg.n_folds, cfg.fold) tr, te = random_split(alloys, meta, cfg.seed, cfg.test_frac) return tr, te def _train_val_split(train_ids, meta, alloys, seed, frac=0.15): """Carve a validation set out of the training ids, alloy-aware.""" rng = np.random.default_rng(seed + 991) by_alloy: Dict[str, List[int]] = {} amap = dict(zip(meta.sample_id.tolist(), alloys)) for s in train_ids: by_alloy.setdefault(amap[s], []).append(s) val = [] for al, ids in by_alloy.items(): if len(ids) >= 3: k = max(1, int(round(len(ids) * frac))) val += list(rng.choice(ids, size=k, replace=False)) val = sorted(set(int(x) for x in val)) tr = [s for s in train_ids if s not in val] return tr, val @torch.no_grad() def predict(model, dl, device): model.eval() outs = [] for st, x, Y, M, sids in dl: st, x = st.to(device), x.to(device) pred = model(st, x)["pred"] outs.append((pred.cpu().numpy(), Y.numpy(), M.numpy(), list(sids))) return outs def evaluate(model, dl, norm, device) -> Dict: outs = predict(model, dl, device) P = np.concatenate([o[0] for o in outs], 0) Y = np.concatenate([o[1] for o in outs], 0) M = np.concatenate([o[2] for o in outs], 0) S = np.concatenate([o[3] for o in outs], 0).astype(int) raw_p = norm.inverse_targets(P) raw_y = norm.inverse_targets(Y) per_t = regression_metrics(raw_y.reshape(-1, len(TARGETS)), raw_p.reshape(-1, len(TARGETS)), M.reshape(-1, len(TARGETS))) # curve-level (per sample) j = TARGET_KEYS.index("sigma") curves = [] for i, sid in enumerate(S): m = M[i, :, j] > 0 if m.sum() < 10: continue eps = np.linspace(0, 0.2, len(m))[m] # grid is uniform 0->0.2 cm = curve_metrics(eps, raw_y[i, m, j], raw_p[i, m, j]) cm["sample_id"] = int(sid) curves.append(cm) cm_df = pd.DataFrame(curves) agg_curve = {} if len(cm_df): for c in ["peak_rel_err", "curve_rmse", "sig@0.02_rel_err", "sig@0.05_rel_err", "sig@0.1_rel_err"]: if c in cm_df: agg_curve[c + "_mean"] = float(cm_df[c].mean()) agg_curve[c + "_median"] = float(cm_df[c].median()) decomp = sigma_decomposition(raw_y, raw_p, M, S) return {"per_target": per_t, "summary": summarise(per_t), "decomp": decomp, "curve": agg_curve, "curves": cm_df, "raw_pred": raw_p, "raw_true": raw_y, "mask": M, "sids": S} def run(cfg: Cfg, verbose: bool = True) -> Dict: _seed_all(cfg.seed) device = torch.device(cfg.device) meta = pd.read_csv(PROC / "samples_meta.csv") traj = pd.read_csv(PROC / "trajectories.csv") Xraw, names, kinds = build_static_frame(meta) alloys = meta.alloy.tolist() train_ids, test_ids = _split_ids(meta, cfg, alloys) if cfg.use_val: tr_ids, va_ids = _train_val_split(train_ids, meta, alloys, cfg.seed) if len(va_ids) == 0: va_ids = tr_ids[-2:] else: tr_ids, va_ids = list(train_ids), [] if cfg.train_frac < 1.0: rng = np.random.default_rng(cfg.seed + 17) k = max(2, int(round(len(tr_ids) * cfg.train_frac))) tr_ids = sorted(int(x) for x in rng.choice(tr_ids, size=k, replace=False)) tr_traj = traj[traj.sample_id.isin(tr_ids)] norm = Normalizer(mode=cfg.norm_mode).fit_static( Xraw[[i for i, s in enumerate(meta.sample_id) if s in set(tr_ids)]], names, kinds ).fit_targets(tr_traj) km = feature_mask(names, cfg.drop_features) ds_tr = PackedDataset(tr_ids, meta, traj, norm, names, kinds, km) ds_va = PackedDataset(va_ids, meta, traj, norm, names, kinds, km) if va_ids else None ds_te = PackedDataset(test_ids, meta, traj, norm, names, kinds, km) dl_tr = DataLoader(ds_tr, batch_size=min(cfg.batch, len(ds_tr)), shuffle=True, collate_fn=collate) dl_va = (DataLoader(ds_va, batch_size=min(cfg.batch, len(ds_va)), shuffle=False, collate_fn=collate) if ds_va is not None else None) dl_te = DataLoader(ds_te, batch_size=min(cfg.batch, len(ds_te)), shuffle=False, collate_fn=collate) model = build_model(cfg.model, n_static=int(km.sum()), 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) n_par = sum(p.numel() for p in model.parameters()) opt = torch.optim.AdamW(model.parameters(), lr=cfg.lr, weight_decay=cfg.wd) steps = max(1, len(dl_tr)) total_steps = max(2, cfg.epochs * steps) sched = torch.optim.lr_scheduler.OneCycleLR( opt, max_lr=cfg.lr, total_steps=total_steps, pct_start=0.25 if cfg.epochs * steps >= 8 else 0.0) best = float("inf") best_state = None bad = 0 nan_batches = 0 hist = [] t0 = time.time() for ep in range(cfg.epochs): model.train() tl, n = 0.0, 0 for st, x, Y, M, _ in dl_tr: st, x, Y, M = st.to(device), x.to(device), Y.to(device), M.to(device) # models that need the labels (world model posterior, flow matching) if getattr(model, "needs_y", False): out = model(st, x, y=Y, m=M) else: out = model(st, x) if "replace_loss" in out: # generative models define their own objective (e.g. CFM) loss = out["replace_loss"] else: loss = masked_mse_balanced(out["pred"], Y, M, torch.from_numpy(norm.loss_w)) if out.get("aux_loss") is not None: loss = loss + out["aux_loss"] if cfg.w_mono or cfg.w_init or cfg.w_smooth: pl, _ = physics_losses(out["pred"], Y, M, x[..., 0] * 0.2, cfg) loss = loss + pl if cfg.w_peak: loss = loss + cfg.w_peak * peak_loss(out["pred"], Y, M) opt.zero_grad(set_to_none=True) if not torch.isfinite(loss): # numerically poisoned batch: skip the update, keep the schedule nan_batches += 1 sched.step() continue loss.backward() gn = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) if not torch.isfinite(gn): # inf/nan gradients: clip would turn them into nan -> skip update nan_batches += 1 opt.zero_grad(set_to_none=True) sched.step() continue opt.step() sched.step() tl += float(loss.detach()) * len(Y) n += len(Y) model.eval() vl, vn = 0.0, 0 with torch.no_grad(): for st, x, Y, M, _ in (dl_va if dl_va is not None else []): st, x, Y, M = st.to(device), x.to(device), Y.to(device), M.to(device) out = model(st, x) vl += float(masked_mse_balanced(out["pred"], Y, M, torch.from_numpy(norm.loss_w))) * len(Y) vn += len(Y) vl = vl / vn if vn else tl / max(n, 1) hist.append({"epoch": ep, "train": tl / max(n, 1), "val": vl, "nan_batches": nan_batches}) if not np.isfinite(vl): continue if vl < best - 1e-6: best, bad = vl, 0 best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()} else: bad += 1 if cfg.use_val and bad >= 60 and ep > 80: break if best_state is not None: model.load_state_dict(best_state) res = evaluate(model, dl_te, norm, device) out = { "config": asdict(cfg), "n_params": n_par, "n_train": len(tr_ids), "n_val": len(va_ids), "n_test": len(test_ids), "train_ids": tr_ids, "val_ids": va_ids, "test_ids": test_ids, "best_val": best, "nan_batches": nan_batches, "epochs_run": len(hist), "wall_time_s": round(time.time() - t0, 1), "per_target": res["per_target"], "summary": res["summary"], "decomp": res.get("decomp", {}), "curve": res["curve"], "curves": res["curves"], "test_alloys": sorted(set(alloys[meta.index[meta.sample_id == s][0]] for s in test_ids)), "normalizer": norm.to_json(), "feature_names": names, "keep_mask": km.tolist(), } tag = cfg.tag or f"{cfg.model}_{cfg.split}_s{cfg.seed}" outdir = RUNS / tag outdir.mkdir(parents=True, exist_ok=True) (outdir / "metrics.json").write_text(json.dumps( {k: v for k, v in out.items() if k not in ("curves",)}, ensure_ascii=False, indent=2)) (outdir / "history.json").write_text(json.dumps(hist)) res["curves"].to_csv(outdir / "curves.csv", index=False) np.savez_compressed(outdir / "predictions.npz", pred=res["raw_pred"], true=res["raw_true"], mask=res["mask"], sids=res["sids"]) torch.save({"state": model.state_dict(), "cfg": asdict(cfg), "keep_mask": km, "names": names}, outdir / "model.pt") if verbose: print(f"[{tag}] params={n_par} best_val={best:.4f} " f"test macroR2={out['summary']['macro_r2']:.4f} " f"time={out['wall_time_s']}s") return out def main(): ap = argparse.ArgumentParser() ap.add_argument("--model", default="pimamba") ap.add_argument("--seed", type=int, default=0) ap.add_argument("--split", default="random") ap.add_argument("--holdout", default="") ap.add_argument("--epochs", type=int, default=250) ap.add_argument("--lr", type=float, default=3e-3) ap.add_argument("--batch", type=int, default=8) ap.add_argument("--d_model", type=int, default=64) ap.add_argument("--n_layers", type=int, default=2) ap.add_argument("--physics", type=float, default=0.0) ap.add_argument("--peak", type=float, default=0.0, help="weight of the curve-level peak-matching loss") ap.add_argument("--no-coupling", action="store_true") ap.add_argument("--drop", nargs="*", default=[]) ap.add_argument("--fold", type=int, default=0) ap.add_argument("--n_folds", type=int, default=5) ap.add_argument("--norm", default="full") ap.add_argument("--train_frac", type=float, default=1.0) ap.add_argument("--no_val", action="store_true") ap.add_argument("--tag", default="") ap.add_argument("--split_seed", type=int, default=None) a = ap.parse_args() cfg = Cfg(model=a.model, seed=a.seed, split=a.split, holdout=a.holdout, epochs=a.epochs, lr=a.lr, batch=a.batch, d_model=a.d_model, n_layers=a.n_layers, coupling=not a.no_coupling, w_mono=a.physics, w_init=a.physics, w_smooth=0.1 * a.physics, w_peak=a.peak, drop_features=tuple(a.drop), tag=a.tag, fold=a.fold, split_seed=a.split_seed, n_folds=a.n_folds, norm_mode=a.norm, train_frac=a.train_frac, use_val=not a.no_val) run(cfg) if __name__ == "__main__": main()