Blame for code/pimamba/train.py

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