Datasets:

eduzrh
/

training-model-material

"""Dataset / normalisation / splitting utilities.
Everything the model sees is built here so that the *exact* same transform is
applied at train, validation and inference time (statistics are fitted on the
training split only and stored in a JSON file).
"""
from __future__ import annotations

import json
from dataclasses import dataclass, field
from pathlib import Path
from typing import Dict, List, Sequence, Tuple

import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset

ROOT = Path(__file__).resolve().parents[2]
PROC = ROOT / "data" / "processed"

ELEMENTS = ["Al", "Ti", "Zr", "Nb", "Mo", "Ta", "V", "Cr", "Mn", "Fe",
            "Co", "Ni", "Cu", "Hf", "W", "Re", "Sc", "Mg", "Si", "Sn"]

# ---------------------------------------------------------------------------
# target specification
# ---------------------------------------------------------------------------
@dataclass
class Target:
    name: str          # column in trajectories.csv
    key: str           # short key used in metrics / heads
    unit: str
    transform: str     # "identity" | "asinh"
    group: str         # "macro" | "phase" | "dislocation" | "twin"


TARGETS: List[Target] = [
    Target("sigma_GPa", "sigma", "GPa", "zscore", "macro"),
    Target("xi_BCC", "xi_BCC", "vol.fr.", "fraction", "phase"),
    Target("xi_FCC", "xi_FCC", "vol.fr.", "fraction", "phase"),
    Target("xi_HCP", "xi_HCP", "vol.fr.", "fraction", "phase"),
    Target("xi_other", "xi_other", "vol.fr.", "fraction", "phase"),
    Target("rho_total", "rho_total", "1e19 m^-2", "asinh", "dislocation"),
    Target("rho_perfect", "rho_perfect", "1e19 m^-2", "asinh", "dislocation"),
    Target("rho_shockley", "rho_shockley", "1e19 m^-2", "asinh", "dislocation"),
    Target("rho_stairrod", "rho_stairrod", "1e19 m^-2", "asinh", "dislocation"),
    Target("rho_hirth", "rho_hirth", "1e19 m^-2", "asinh", "dislocation"),
    Target("rho_other_disl", "rho_other_disl", "1e19 m^-2", "asinh", "dislocation"),
    Target("rho_112_111", "rho_112_111", "1e19 m^-2", "asinh", "dislocation"),
    Target("twin_density_nm-1", "twin", "nm^-1", "asinh", "twin"),
]
TARGET_KEYS = [t.key for t in TARGETS]

# static numeric features (raw column -> transform)
NUMERIC_STATIC = [
    ("VEC", "identity"), ("delta", "identity"), ("rbar", "identity"),
    ("dHmix", "identity"), ("dSmix", "identity"), ("chi", "identity"),
    ("Mavg", "identity"), ("dmu", "identity"), ("Tm", "identity"),
    ("rhomass", "identity"), ("T0", "identity"), ("strain_rate", "log10"),
    ("eta", "identity"),
]
GEOM_STATIC = ["geom_L", "geom_W", "geom_H", "geom_D", "geom_AR", "geom_volume_nm3"]
GEOM_FLAGS = ["app_L", "app_W", "app_H", "app_D", "app_AR", "app_V"]
CATEGORICAL = {
    "shape_type": ["prism", "cylinder"],
    "crystalline": ["s", "p"],
    "ensemble": ["NPT", "NVT", "NVE"],
    "potential": ["EAM", "MEAM", "SNAP"],
    "load_mode": ["T", "C", "S"],
}
INIT_PHASE = ["init_xi_BCC", "init_xi_FCC", "init_xi_HCP", "init_xi_other"]
INIT_RHO = ["init_d_perfect", "init_d_shockley", "init_d_stairrod",
            "init_d_hirth", "init_d_oth", "init_d_112_111", "init_d_100"]


def build_static_frame(meta: pd.DataFrame) -> Tuple[np.ndarray, List[str], List[str]]:
    """Return (raw static matrix, feature names, feature kinds)."""
    cols, names, kinds = [], [], []
    for c in ELEMENTS:
        cols.append(meta["at_" + c].to_numpy(float))
        names.append("at_" + c)
        kinds.append("composition")
    for c, _ in NUMERIC_STATIC:
        cols.append(meta[c].to_numpy(float))
        names.append(c)
        kinds.append("numeric")
    for c in GEOM_STATIC:
        cols.append(meta[c].to_numpy(float))
        names.append(c)
        kinds.append("geom")
    for c in GEOM_FLAGS:
        cols.append(meta[c].to_numpy(float))
        names.append(c)
        kinds.append("flag")
    for c in INIT_PHASE:
        cols.append(meta[c].to_numpy(float))
        names.append(c)
        kinds.append("init_phase")
    for c in INIT_RHO:
        cols.append(meta[c].to_numpy(float))
        names.append(c)
        kinds.append("init_rho")
    cols.append(meta["orient_h"].to_numpy(float))
    cols.append(meta["orient_k"].to_numpy(float))
    cols.append(meta["orient_l"].to_numpy(float))
    cols.append(meta["app_orient"].to_numpy(float))
    names += ["orient_h", "orient_k", "orient_l", "app_orient"]
    kinds += ["geom", "geom", "geom", "flag"]
    for cat, levels in CATEGORICAL.items():
        raw = meta[cat].astype(str).to_numpy()
        for lv in levels:
            cols.append((raw == lv).astype(float))
            names.append(f"{cat}={lv}")
            kinds.append("onehot")
    X = np.stack(cols, axis=1)
    return X, names, kinds


class Normalizer:
    """Train-split statistics for static features and targets.
    * composition / phase fractions / one-hot / flags -> already dimensionless,
      left untouched (step 2: 0-1 variables need no normalisation);
    * physical quantities -> z-score;
    * strain rate -> log10 then z-score (spans 1e8-5e11);
    * geometry -> log10 then z-score, with a separate applicability flag so a
      non-applicable dimension is encoded as "0 after normalisation" rather
      than a fake physical zero;
    * dislocation density / twin density -> asinh(x / s0) then z-score, which
      is defined at exactly zero and ~log for large values.
    """

    def __init__(self, mode: str = "full"):
        self.mode = mode               # "full" | "none" (ablation)
        self.mu = None
        self.sd = None
        self.tgt_mu = np.zeros(len(TARGETS))
        self.tgt_sd = np.ones(len(TARGETS))
        self.tgt_s0 = np.ones(len(TARGETS))
        self.loss_w = np.ones(len(TARGETS))

    # -- static ------------------------------------------------------------
    def fit_static(self, X: np.ndarray, names: Sequence[str], kinds: Sequence[str]):
        n = X.shape[1]
        self.mu = np.zeros(n)
        self.sd = np.ones(n)
        if self.mode == "none":
            return self
        for j, (nm, kd) in enumerate(zip(names, kinds)):
            col = X[:, j].astype(float).copy()
            if kd in ("composition", "flag", "onehot", "init_phase"):
                self.mu[j], self.sd[j] = 0.0, 1.0
                continue
            if kd == "geom" and nm in ("geom_L", "geom_W", "geom_H", "geom_D",
                                       "geom_AR", "geom_volume_nm3"):
                col = np.log10(np.clip(col, 1e-6, None))
            if kd == "init_rho":
                col = np.arcsinh(col / 1.0)
            m = np.nanmean(col)
            s = np.nanstd(col)
            if not np.isfinite(s) or s < 1e-9:
                s = 1.0
            self.mu[j], self.sd[j] = (0.0 if not np.isfinite(m) else m), s
        return self

    def transform_static(self, X: np.ndarray, names: Sequence[str],
                         kinds: Sequence[str]) -> np.ndarray:
        if self.mode == "none":
            return np.nan_to_num(X.astype(float), nan=0.0, posinf=0.0, neginf=0.0)
        Z = X.astype(float).copy()
        for j, (nm, kd) in enumerate(zip(names, kinds)):
            col = Z[:, j]
            if kd == "geom" and nm in ("geom_L", "geom_W", "geom_H", "geom_D",
                                       "geom_AR", "geom_volume_nm3"):
                col = np.log10(np.clip(col, 1e-6, None))
            if kd == "init_rho":
                col = np.arcsinh(col / 1.0)
            Z[:, j] = (col - self.mu[j]) / self.sd[j]
        Z = np.nan_to_num(Z, nan=0.0, posinf=0.0, neginf=0.0)
        return Z

    # -- targets -----------------------------------------------------------
    def fit_targets(self, traj: pd.DataFrame):
        if self.mode == "none":
            return self
        for i, t in enumerate(TARGETS):
            v = traj[t.name].to_numpy(float)
            v = v[np.isfinite(v)]
            if t.transform == "fraction":
                self.tgt_s0[i] = 1.0
                self.tgt_mu[i] = 0.0
                self.tgt_sd[i] = 1.0
                continue
            if t.transform == "asinh":
                pos = v[v > 0]
                s0 = float(np.median(pos)) if len(pos) else 1.0
                if not np.isfinite(s0) or s0 <= 0:
                    s0 = 1.0
                self.tgt_s0[i] = s0
                z = np.arcsinh(v / s0)
            else:
                self.tgt_s0[i] = 1.0
                z = v
            self.tgt_mu[i] = float(np.mean(z)) if len(z) else 0.0
            sd = float(np.std(z)) if len(z) else 1.0
            self.tgt_sd[i] = sd if sd > 1e-9 else 1.0
        # optimisation weights: equalise the variance each head sees, so a
        # 0-1 phase fraction and a z-scored stress contribute comparably.
        Y, M = self.transform_targets(traj)
        for i in range(len(TARGETS)):
            m = M[:, i] > 0
            v = Y[m, i]
            var = float(np.var(v)) if len(v) > 1 else 1.0
            self.loss_w[i] = 1.0 / max(var, 0.05)
        self.loss_w = self.loss_w / np.mean(self.loss_w)
        return self

    def transform_targets(self, traj: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:
        T = len(traj)
        Y = np.full((T, len(TARGETS)), np.nan, dtype=np.float32)
        M = np.zeros((T, len(TARGETS)), dtype=np.float32)
        for i, t in enumerate(TARGETS):
            v = traj[t.name].to_numpy(float).astype(np.float32)
            obs = np.isfinite(v)
            z = np.where(obs, v, 0.0)
            if self.mode == "none":
                Y[obs, i] = z[obs]
                M[obs, i] = 1.0
                continue
            if t.transform == "asinh":
                z = np.arcsinh(z / self.tgt_s0[i])
                z = (z - self.tgt_mu[i]) / self.tgt_sd[i]
            elif t.transform == "zscore":
                z = (z - self.tgt_mu[i]) / self.tgt_sd[i]
            Y[obs, i] = z[obs]
            M[obs, i] = 1.0
        Y = np.nan_to_num(Y, nan=0.0, posinf=0.0, neginf=0.0)
        return Y, M

    def inverse_targets(self, Z: np.ndarray) -> np.ndarray:
        """(..., n_targets) normalised -> raw physical units."""
        Z = np.asarray(Z, dtype=np.float64)
        out = np.empty_like(Z)
        for i, t in enumerate(TARGETS):
            v = Z[..., i] * self.tgt_sd[i] + self.tgt_mu[i]
            if t.transform == "asinh":
                v = np.sinh(v) * self.tgt_s0[i]
            out[..., i] = v
        return out

    def to_json(self) -> dict:
        return {"static_mu": self.mu.tolist(), "static_sd": self.sd.tolist(),
                "target_mu": self.tgt_mu.tolist(), "target_sd": self.tgt_sd.tolist(),
                "target_s0": self.tgt_s0.tolist(),
                "target_keys": TARGET_KEYS, "loss_w": self.loss_w.tolist()}

    @classmethod
    def from_json(cls, d: dict):
        z = cls()
        z.mu = np.asarray(d["static_mu"], float)
        z.sd = np.asarray(d["static_sd"], float)
        z.tgt_mu = np.asarray(d["target_mu"], float)
        z.tgt_sd = np.asarray(d["target_sd"], float)
        z.tgt_s0 = np.asarray(d["target_s0"], float)
        z.loss_w = np.asarray(d.get("loss_w", np.ones(len(TARGETS))), float)
        return z


class PackedDataset(Dataset):
    """Packed tensors for a set of sample ids.
    Returns (static, seq_input, Y, M, sample_id).
    seq_input channels: [strain/0.2, dstrain/5e-4, log10(rate)/10, T0/1000, sign]
    """

    def __init__(self, sids, meta: pd.DataFrame, traj: pd.DataFrame,
                 norm: Normalizer, names, kinds, keep_mask=None):
        mm = meta.set_index("sample_id")
        self.sids = list(sids)
        idx = {int(s): i for i, s in enumerate(meta.sample_id)}
        Xraw = np.stack([_static_row(meta, idx[s]) for s in self.sids])
        Z = norm.transform_static(Xraw, names, kinds).astype(np.float32)
        if keep_mask is not None:
            # *select* the retained columns: dropping a feature must shrink the
            # input width (train.py builds the encoder with n_static=km.sum()),
            # not pad it with a constant zero.
            Z = Z[:, np.asarray(keep_mask, dtype=bool)]
        self.static = torch.from_numpy(Z)

        xs, ys, ms = [], [], []
        for s in self.sids:
            sub = traj[traj.sample_id == s].sort_values("strain")
            eps = sub.strain.to_numpy(np.float32)
            de = np.zeros_like(eps)
            de[1:] = np.diff(eps)
            rate = np.log10(max(float(mm.loc[s, "strain_rate"]), 1.0)) / 10.0
            T0 = float(mm.loc[s, "T0"]) / 1000.0
            sign = 1.0 if str(mm.loc[s, "load_mode"]).upper().startswith("T") else -1.0
            x = np.stack([eps / 0.2, de / 5e-4,
                          np.full_like(eps, rate), np.full_like(eps, T0),
                          np.full_like(eps, sign)], axis=1)
            Y, M = norm.transform_targets(sub)
            xs.append(torch.from_numpy(x.astype(np.float32)))
            ys.append(torch.from_numpy(Y))
            ms.append(torch.from_numpy(M))
        self.x = xs
        self.Y = ys
        self.M = ms

    def __len__(self):
        return len(self.sids)

    def __getitem__(self, i):
        return self.static[i], self.x[i], self.Y[i], self.M[i], self.sids[i]


_STATIC_CACHE = {}


def _static_row(meta: pd.DataFrame, i: int):
    key = id(meta)
    if key not in _STATIC_CACHE:
        _STATIC_CACHE[key] = build_static_frame(meta)[0]
    return _STATIC_CACHE[key][i]


def collate(batch):
    statics, xs, ys, ms, sids = zip(*batch)
    return (torch.stack(statics), torch.stack(xs), torch.stack(ys),
            torch.stack(ms), list(sids))


# ---------------------------------------------------------------------------
# splits
# ---------------------------------------------------------------------------
def random_split(alloys: List[str], meta: pd.DataFrame, seed: int,
                 test_frac: float = 0.2) -> Tuple[List[int], List[int]]:
    """Sample-level split stratified by alloy (a held-out alloy never appears)."""
    rng = np.random.default_rng(seed)
    sids = meta.sample_id.tolist()
    by_alloy: Dict[str, List[int]] = {}
    for sid, al in zip(sids, alloys):
        by_alloy.setdefault(al, []).append(sid)
    test = []
    for al, ids in by_alloy.items():
        k = max(1, int(round(len(ids) * test_frac))) if len(ids) > 1 else 0
        if len(ids) == 1:
            k = 1 if rng.random() < test_frac else 0
        test += list(rng.choice(ids, size=k, replace=False))
    test = sorted(set(int(x) for x in test))
    train = sorted(set(sids) - set(test))
    return train, test


def kfold_split(alloys: List[str], meta: pd.DataFrame, seed: int, k: int,
                fold: int) -> Tuple[List[int], List[int]]:
    """Alloy-stratified K-fold over samples."""
    rng = np.random.default_rng(seed)
    by_alloy: Dict[str, List[int]] = {}
    for sid, al in zip(meta.sample_id.tolist(), alloys):
        by_alloy.setdefault(al, []).append(int(sid))
    assign = {}
    counter = 0
    for al in sorted(by_alloy):
        ids = list(by_alloy[al])
        rng.shuffle(ids)
        for sid in ids:
            assign[sid] = counter % k
            counter += 1
    test = sorted(s for s, f in assign.items() if f == fold)
    train = sorted(s for s, f in assign.items() if f != fold)
    return train, test


def loao_split(alloys: List[str], meta: pd.DataFrame, held: str):
    sids = meta.sample_id.tolist()
    test = [int(s) for s, a in zip(sids, alloys) if a == held]
    train = [int(s) for s in sids if s not in test]
    return train, test

	"""Dataset / normalisation / splitting utilities.

	Everything the model sees is built here so that the exact same transform is
	applied at train, validation and inference time (statistics are fitted on the
	training split only and stored in a JSON file).
	"""
	from __future__ import annotations

	import json
	from dataclasses import dataclass, field
	from pathlib import Path
	from typing import Dict, List, Sequence, Tuple

	import numpy as np
	import pandas as pd
	import torch
	from torch.utils.data import Dataset

	ROOT = Path(__file__).resolve().parents[2]
	PROC = ROOT / "data" / "processed"

	ELEMENTS = ["Al", "Ti", "Zr", "Nb", "Mo", "Ta", "V", "Cr", "Mn", "Fe",
	"Co", "Ni", "Cu", "Hf", "W", "Re", "Sc", "Mg", "Si", "Sn"]

	# ---------------------------------------------------------------------------
	# target specification
	# ---------------------------------------------------------------------------
	@dataclass
	class Target:
	name: str # column in trajectories.csv
	key: str # short key used in metrics / heads
	unit: str
	transform: str # "identity" \| "asinh"
	group: str # "macro" \| "phase" \| "dislocation" \| "twin"


	TARGETS: List[Target] = [
	Target("sigma_GPa", "sigma", "GPa", "zscore", "macro"),
	Target("xi_BCC", "xi_BCC", "vol.fr.", "fraction", "phase"),
	Target("xi_FCC", "xi_FCC", "vol.fr.", "fraction", "phase"),
	Target("xi_HCP", "xi_HCP", "vol.fr.", "fraction", "phase"),
	Target("xi_other", "xi_other", "vol.fr.", "fraction", "phase"),
	Target("rho_total", "rho_total", "1e19 m^-2", "asinh", "dislocation"),
	Target("rho_perfect", "rho_perfect", "1e19 m^-2", "asinh", "dislocation"),
	Target("rho_shockley", "rho_shockley", "1e19 m^-2", "asinh", "dislocation"),
	Target("rho_stairrod", "rho_stairrod", "1e19 m^-2", "asinh", "dislocation"),
	Target("rho_hirth", "rho_hirth", "1e19 m^-2", "asinh", "dislocation"),
	Target("rho_other_disl", "rho_other_disl", "1e19 m^-2", "asinh", "dislocation"),
	Target("rho_112_111", "rho_112_111", "1e19 m^-2", "asinh", "dislocation"),
	Target("twin_density_nm-1", "twin", "nm^-1", "asinh", "twin"),
	]
	TARGET_KEYS = [t.key for t in TARGETS]

	# static numeric features (raw column -> transform)
	NUMERIC_STATIC = [
	("VEC", "identity"), ("delta", "identity"), ("rbar", "identity"),
	("dHmix", "identity"), ("dSmix", "identity"), ("chi", "identity"),
	("Mavg", "identity"), ("dmu", "identity"), ("Tm", "identity"),
	("rhomass", "identity"), ("T0", "identity"), ("strain_rate", "log10"),
	("eta", "identity"),
	]
	GEOM_STATIC = ["geom_L", "geom_W", "geom_H", "geom_D", "geom_AR", "geom_volume_nm3"]
	GEOM_FLAGS = ["app_L", "app_W", "app_H", "app_D", "app_AR", "app_V"]
	CATEGORICAL = {
	"shape_type": ["prism", "cylinder"],
	"crystalline": ["s", "p"],
	"ensemble": ["NPT", "NVT", "NVE"],
	"potential": ["EAM", "MEAM", "SNAP"],
	"load_mode": ["T", "C", "S"],
	}
	INIT_PHASE = ["init_xi_BCC", "init_xi_FCC", "init_xi_HCP", "init_xi_other"]
	INIT_RHO = ["init_d_perfect", "init_d_shockley", "init_d_stairrod",
	"init_d_hirth", "init_d_oth", "init_d_112_111", "init_d_100"]


	def build_static_frame(meta: pd.DataFrame) -> Tuple[np.ndarray, List[str], List[str]]:
	"""Return (raw static matrix, feature names, feature kinds)."""
	cols, names, kinds = [], [], []
	for c in ELEMENTS:
	cols.append(meta["at_" + c].to_numpy(float))
	names.append("at_" + c)
	kinds.append("composition")
	for c, _ in NUMERIC_STATIC:
	cols.append(meta[c].to_numpy(float))
	names.append(c)
	kinds.append("numeric")
	for c in GEOM_STATIC:
	cols.append(meta[c].to_numpy(float))
	names.append(c)
	kinds.append("geom")
	for c in GEOM_FLAGS:
	cols.append(meta[c].to_numpy(float))
	names.append(c)
	kinds.append("flag")
	for c in INIT_PHASE:
	cols.append(meta[c].to_numpy(float))
	names.append(c)
	kinds.append("init_phase")
	for c in INIT_RHO:
	cols.append(meta[c].to_numpy(float))
	names.append(c)
	kinds.append("init_rho")
	cols.append(meta["orient_h"].to_numpy(float))
	cols.append(meta["orient_k"].to_numpy(float))
	cols.append(meta["orient_l"].to_numpy(float))
	cols.append(meta["app_orient"].to_numpy(float))
	names += ["orient_h", "orient_k", "orient_l", "app_orient"]
	kinds += ["geom", "geom", "geom", "flag"]
	for cat, levels in CATEGORICAL.items():
	raw = meta[cat].astype(str).to_numpy()
	for lv in levels:
	cols.append((raw == lv).astype(float))
	names.append(f"{cat}={lv}")
	kinds.append("onehot")
	X = np.stack(cols, axis=1)
	return X, names, kinds


	class Normalizer:
	"""Train-split statistics for static features and targets.

	* composition / phase fractions / one-hot / flags -> already dimensionless,
	left untouched (step 2: 0-1 variables need no normalisation);
	* physical quantities -> z-score;
	* strain rate -> log10 then z-score (spans 1e8-5e11);
	* geometry -> log10 then z-score, with a separate applicability flag so a
	non-applicable dimension is encoded as "0 after normalisation" rather
	than a fake physical zero;
	* dislocation density / twin density -> asinh(x / s0) then z-score, which
	is defined at exactly zero and ~log for large values.
	"""

	def __init__(self, mode: str = "full"):
	self.mode = mode # "full" \| "none" (ablation)
	self.mu = None
	self.sd = None
	self.tgt_mu = np.zeros(len(TARGETS))
	self.tgt_sd = np.ones(len(TARGETS))
	self.tgt_s0 = np.ones(len(TARGETS))
	self.loss_w = np.ones(len(TARGETS))

	# -- static ------------------------------------------------------------
	def fit_static(self, X: np.ndarray, names: Sequence[str], kinds: Sequence[str]):
	n = X.shape[1]
	self.mu = np.zeros(n)
	self.sd = np.ones(n)
	if self.mode == "none":
	return self
	for j, (nm, kd) in enumerate(zip(names, kinds)):
	col = X[:, j].astype(float).copy()
	if kd in ("composition", "flag", "onehot", "init_phase"):
	self.mu[j], self.sd[j] = 0.0, 1.0
	continue
	if kd == "geom" and nm in ("geom_L", "geom_W", "geom_H", "geom_D",
	"geom_AR", "geom_volume_nm3"):
	col = np.log10(np.clip(col, 1e-6, None))
	if kd == "init_rho":
	col = np.arcsinh(col / 1.0)
	m = np.nanmean(col)
	s = np.nanstd(col)
	if not np.isfinite(s) or s < 1e-9:
	s = 1.0
	self.mu[j], self.sd[j] = (0.0 if not np.isfinite(m) else m), s
	return self

	def transform_static(self, X: np.ndarray, names: Sequence[str],
	kinds: Sequence[str]) -> np.ndarray:
	if self.mode == "none":
	return np.nan_to_num(X.astype(float), nan=0.0, posinf=0.0, neginf=0.0)
	Z = X.astype(float).copy()
	for j, (nm, kd) in enumerate(zip(names, kinds)):
	col = Z[:, j]
	if kd == "geom" and nm in ("geom_L", "geom_W", "geom_H", "geom_D",
	"geom_AR", "geom_volume_nm3"):
	col = np.log10(np.clip(col, 1e-6, None))
	if kd == "init_rho":
	col = np.arcsinh(col / 1.0)
	Z[:, j] = (col - self.mu[j]) / self.sd[j]
	Z = np.nan_to_num(Z, nan=0.0, posinf=0.0, neginf=0.0)
	return Z

	# -- targets -----------------------------------------------------------
	def fit_targets(self, traj: pd.DataFrame):
	if self.mode == "none":
	return self
	for i, t in enumerate(TARGETS):
	v = traj[t.name].to_numpy(float)
	v = v[np.isfinite(v)]
	if t.transform == "fraction":
	self.tgt_s0[i] = 1.0
	self.tgt_mu[i] = 0.0
	self.tgt_sd[i] = 1.0
	continue
	if t.transform == "asinh":
	pos = v[v > 0]
	s0 = float(np.median(pos)) if len(pos) else 1.0
	if not np.isfinite(s0) or s0 <= 0:
	s0 = 1.0
	self.tgt_s0[i] = s0
	z = np.arcsinh(v / s0)
	else:
	self.tgt_s0[i] = 1.0
	z = v
	self.tgt_mu[i] = float(np.mean(z)) if len(z) else 0.0
	sd = float(np.std(z)) if len(z) else 1.0
	self.tgt_sd[i] = sd if sd > 1e-9 else 1.0
	# optimisation weights: equalise the variance each head sees, so a
	# 0-1 phase fraction and a z-scored stress contribute comparably.
	Y, M = self.transform_targets(traj)
	for i in range(len(TARGETS)):
	m = M[:, i] > 0
	v = Y[m, i]
	var = float(np.var(v)) if len(v) > 1 else 1.0
	self.loss_w[i] = 1.0 / max(var, 0.05)
	self.loss_w = self.loss_w / np.mean(self.loss_w)
	return self

	def transform_targets(self, traj: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:
	T = len(traj)
	Y = np.full((T, len(TARGETS)), np.nan, dtype=np.float32)
	M = np.zeros((T, len(TARGETS)), dtype=np.float32)
	for i, t in enumerate(TARGETS):
	v = traj[t.name].to_numpy(float).astype(np.float32)
	obs = np.isfinite(v)
	z = np.where(obs, v, 0.0)
	if self.mode == "none":
	Y[obs, i] = z[obs]
	M[obs, i] = 1.0
	continue
	if t.transform == "asinh":
	z = np.arcsinh(z / self.tgt_s0[i])
	z = (z - self.tgt_mu[i]) / self.tgt_sd[i]
	elif t.transform == "zscore":
	z = (z - self.tgt_mu[i]) / self.tgt_sd[i]
	Y[obs, i] = z[obs]
	M[obs, i] = 1.0
	Y = np.nan_to_num(Y, nan=0.0, posinf=0.0, neginf=0.0)
	return Y, M

	def inverse_targets(self, Z: np.ndarray) -> np.ndarray:
	"""(..., n_targets) normalised -> raw physical units."""
	Z = np.asarray(Z, dtype=np.float64)
	out = np.empty_like(Z)
	for i, t in enumerate(TARGETS):
	v = Z[..., i] * self.tgt_sd[i] + self.tgt_mu[i]
	if t.transform == "asinh":
	v = np.sinh(v) * self.tgt_s0[i]
	out[..., i] = v
	return out

	def to_json(self) -> dict:
	return {"static_mu": self.mu.tolist(), "static_sd": self.sd.tolist(),
	"target_mu": self.tgt_mu.tolist(), "target_sd": self.tgt_sd.tolist(),
	"target_s0": self.tgt_s0.tolist(),
	"target_keys": TARGET_KEYS, "loss_w": self.loss_w.tolist()}

	@classmethod
	def from_json(cls, d: dict):
	z = cls()
	z.mu = np.asarray(d["static_mu"], float)
	z.sd = np.asarray(d["static_sd"], float)
	z.tgt_mu = np.asarray(d["target_mu"], float)
	z.tgt_sd = np.asarray(d["target_sd"], float)
	z.tgt_s0 = np.asarray(d["target_s0"], float)
	z.loss_w = np.asarray(d.get("loss_w", np.ones(len(TARGETS))), float)
	return z


	class PackedDataset(Dataset):
	"""Packed tensors for a set of sample ids.

	Returns (static, seq_input, Y, M, sample_id).
	seq_input channels: [strain/0.2, dstrain/5e-4, log10(rate)/10, T0/1000, sign]
	"""

	def __init__(self, sids, meta: pd.DataFrame, traj: pd.DataFrame,
	norm: Normalizer, names, kinds, keep_mask=None):
	mm = meta.set_index("sample_id")
	self.sids = list(sids)
	idx = {int(s): i for i, s in enumerate(meta.sample_id)}
	Xraw = np.stack([_static_row(meta, idx[s]) for s in self.sids])
	Z = norm.transform_static(Xraw, names, kinds).astype(np.float32)
	if keep_mask is not None:
	# select the retained columns: dropping a feature must shrink the
	# input width (train.py builds the encoder with n_static=km.sum()),
	# not pad it with a constant zero.
	Z = Z[:, np.asarray(keep_mask, dtype=bool)]
	self.static = torch.from_numpy(Z)

	xs, ys, ms = [], [], []
	for s in self.sids:
	sub = traj[traj.sample_id == s].sort_values("strain")
	eps = sub.strain.to_numpy(np.float32)
	de = np.zeros_like(eps)
	de[1:] = np.diff(eps)
	rate = np.log10(max(float(mm.loc[s, "strain_rate"]), 1.0)) / 10.0
	T0 = float(mm.loc[s, "T0"]) / 1000.0
	sign = 1.0 if str(mm.loc[s, "load_mode"]).upper().startswith("T") else -1.0
	x = np.stack([eps / 0.2, de / 5e-4,
	np.full_like(eps, rate), np.full_like(eps, T0),
	np.full_like(eps, sign)], axis=1)
	Y, M = norm.transform_targets(sub)
	xs.append(torch.from_numpy(x.astype(np.float32)))
	ys.append(torch.from_numpy(Y))
	ms.append(torch.from_numpy(M))
	self.x = xs
	self.Y = ys
	self.M = ms

	def __len__(self):
	return len(self.sids)

	def __getitem__(self, i):
	return self.static[i], self.x[i], self.Y[i], self.M[i], self.sids[i]


	_STATIC_CACHE = {}


	def _static_row(meta: pd.DataFrame, i: int):
	key = id(meta)
	if key not in _STATIC_CACHE:
	_STATIC_CACHE[key] = build_static_frame(meta)[0]
	return _STATIC_CACHE[key][i]


	def collate(batch):
	statics, xs, ys, ms, sids = zip(*batch)
	return (torch.stack(statics), torch.stack(xs), torch.stack(ys),
	torch.stack(ms), list(sids))


	# ---------------------------------------------------------------------------
	# splits
	# ---------------------------------------------------------------------------
	def random_split(alloys: List[str], meta: pd.DataFrame, seed: int,
	test_frac: float = 0.2) -> Tuple[List[int], List[int]]:
	"""Sample-level split stratified by alloy (a held-out alloy never appears)."""
	rng = np.random.default_rng(seed)
	sids = meta.sample_id.tolist()
	by_alloy: Dict[str, List[int]] = {}
	for sid, al in zip(sids, alloys):
	by_alloy.setdefault(al, []).append(sid)
	test = []
	for al, ids in by_alloy.items():
	k = max(1, int(round(len(ids) * test_frac))) if len(ids) > 1 else 0
	if len(ids) == 1:
	k = 1 if rng.random() < test_frac else 0
	test += list(rng.choice(ids, size=k, replace=False))
	test = sorted(set(int(x) for x in test))
	train = sorted(set(sids) - set(test))
	return train, test


	def kfold_split(alloys: List[str], meta: pd.DataFrame, seed: int, k: int,
	fold: int) -> Tuple[List[int], List[int]]:
	"""Alloy-stratified K-fold over samples."""
	rng = np.random.default_rng(seed)
	by_alloy: Dict[str, List[int]] = {}
	for sid, al in zip(meta.sample_id.tolist(), alloys):
	by_alloy.setdefault(al, []).append(int(sid))
	assign = {}
	counter = 0
	for al in sorted(by_alloy):
	ids = list(by_alloy[al])
	rng.shuffle(ids)
	for sid in ids:
	assign[sid] = counter % k
	counter += 1
	test = sorted(s for s, f in assign.items() if f == fold)
	train = sorted(s for s, f in assign.items() if f != fold)
	return train, test


	def loao_split(alloys: List[str], meta: pd.DataFrame, held: str):
	sids = meta.sample_id.tolist()
	test = [int(s) for s, a in zip(sids, alloys) if a == held]
	train = [int(s) for s in sids if s not in test]
	return train, test