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