| """Evaluation metrics in physical units.""" |
| from __future__ import annotations |
|
|
| from typing import Dict, List |
|
|
| import numpy as np |
|
|
| from .data import TARGETS, TARGET_KEYS |
|
|
| |
| |
| |
| |
| PRIMARY = ("sigma", "xi_BCC", "xi_FCC", "xi_HCP", "xi_other", "rho_total", "twin") |
|
|
|
|
| def _r2(y, p): |
| if len(y) < 2: |
| return float("nan") |
| ss_res = float(np.sum((y - p) ** 2)) |
| ss_tot = float(np.sum((y - y.mean()) ** 2)) |
| if ss_tot < 1e-12: |
| return float("nan") |
| return 1.0 - ss_res / ss_tot |
|
|
|
|
| def regression_metrics(raw_true: np.ndarray, raw_pred: np.ndarray, |
| mask: np.ndarray) -> Dict[str, Dict[str, float]]: |
| """raw_*: (N, Ft) physical units; mask: (N, Ft) 0/1.""" |
| out = {} |
| for j, t in enumerate(TARGETS): |
| m = mask[:, j] > 0 |
| n = int(m.sum()) |
| if n == 0: |
| out[t.key] = {"n": 0, "r2": float("nan"), "mae": float("nan"), |
| "rmse": float("nan"), "unit": t.unit, "group": t.group} |
| continue |
| y, p = raw_true[m, j], raw_pred[m, j] |
| sd = float(np.std(y)) |
| mae = float(np.mean(np.abs(y - p))) |
| r2_log = float("nan") |
| if t.group in ("dislocation", "twin") or t.transform == "asinh": |
| ly, lp = np.log1p(np.maximum(y, 0)), np.log1p(np.maximum(p, 0)) |
| r2_log = _r2(ly, lp) |
| out[t.key] = { |
| "n": n, |
| "r2": _r2(y, p), |
| "r2_log": r2_log, |
| "mae": mae, |
| "nmae": mae / sd if sd > 1e-12 else float("nan"), |
| "rmse": float(np.sqrt(np.mean((y - p) ** 2))), |
| "bias": float(np.mean(p - y)), |
| "y_std": sd, |
| "unit": t.unit, |
| "group": t.group, |
| } |
| return out |
|
|
|
|
| def curve_metrics(strain: np.ndarray, sig_true: np.ndarray, sig_pred: np.ndarray, |
| eps_list=(0.02, 0.05, 0.10)) -> Dict[str, float]: |
| """Per-sample macroscopic curve descriptors.""" |
| out = {} |
| pk_t = float(np.max(sig_true)) |
| pk_p = float(np.max(sig_pred)) |
| out["peak_true"] = pk_t |
| out["peak_pred"] = pk_p |
| out["peak_rel_err"] = abs(pk_p - pk_t) / max(abs(pk_t), 1e-6) |
| for e in eps_list: |
| i = int(np.argmin(np.abs(strain - e))) |
| out[f"sig@{e:g}_true"] = float(sig_true[i]) |
| out[f"sig@{e:g}_pred"] = float(sig_pred[i]) |
| out[f"sig@{e:g}_rel_err"] = abs(sig_pred[i] - sig_true[i]) / max(abs(sig_true[i]), 1e-6) |
| out["curve_rmse"] = float(np.sqrt(np.mean((sig_pred - sig_true) ** 2))) |
| return out |
|
|
|
|
| def summarise(per_target: Dict[str, Dict[str, float]]) -> Dict[str, float]: |
| """Macro-average R2 / MAE over the targets that actually have labels.""" |
| r2s = [v["r2"] for v in per_target.values() if v["n"] > 0 and np.isfinite(v["r2"])] |
| r2l = [v["r2_log"] for v in per_target.values() |
| if v["n"] > 0 and np.isfinite(v.get("r2_log", float("nan")))] |
| nm = [v["nmae"] for v in per_target.values() |
| if v["n"] > 0 and np.isfinite(v.get("nmae", float("nan")))] |
| core = [v["r2"] for v in per_target.values() |
| if v["n"] >= 1500 and np.isfinite(v["r2"])] |
| prim = [per_target[k]["r2"] for k in PRIMARY |
| if k in per_target and per_target[k]["n"] > 0 |
| and np.isfinite(per_target[k]["r2"])] |
| return { |
| "macro_r2": float(np.mean(r2s)) if r2s else float("nan"), |
| "macro_r2_primary": float(np.mean(prim)) if prim else float("nan"), |
| "n_primary": len(prim), |
| "core_r2": float(np.mean(core)) if core else float("nan"), |
| "median_r2": float(np.median(r2s)) if r2s else float("nan"), |
| "macro_r2_log": float(np.mean(r2l)) if r2l else float("nan"), |
| "macro_nmae": float(np.mean(nm)) if nm else float("nan"), |
| "n_targets_scored": len(r2s), |
| } |
|
|
| def sigma_decomposition(raw_true, raw_pred, mask, sid, j=0): |
| """Split stress accuracy into an alloy-level term and a curve-shape term. |
| |
| level_oracle_r2 : R2 of a predictor that knows each sample's *mean* stress |
| exactly but has no shape -> upper bound of a level-only model. |
| shape_r2 : R2 after removing each sample's own mean from both curves |
| -> how well the *shape* (hardening/softening) is captured. |
| """ |
| m = mask[:, :, j] > 0 |
| y, p = raw_true[:, :, j], raw_pred[:, :, j] |
| yv, pv = y[m], p[m] |
| if len(yv) < 4: |
| return {} |
| r2 = _r2(yv, pv) |
| lv_t, lv_p = [], [] |
| ys, ps = [], [] |
| for i in range(y.shape[0]): |
| s = m[i] |
| if s.sum() < 4: |
| continue |
| lv_t.append(y[i, s].mean()); lv_p.append(p[i, s].mean()) |
| ys.append(y[i, s] - y[i, s].mean()); ps.append(p[i, s] - p[i, s].mean()) |
| lv_t, lv_p = np.array(lv_t), np.array(lv_p) |
| ys, ps = np.concatenate(ys), np.concatenate(ps) |
| return { |
| "r2": r2, |
| "level_oracle_r2": _r2(yv, np.concatenate([np.full(int(m[i].sum()), y[i, m[i]].mean()) |
| for i in range(y.shape[0]) if m[i].sum() >= 4])), |
| "shape_r2": _r2(ys, ps), |
| "level_corr": float(np.corrcoef(lv_t, lv_p)[0, 1]) if len(lv_t) > 2 else float("nan"), |
| "level_mae_GPa": float(np.mean(np.abs(lv_t - lv_p))), |
| "level_bias_GPa": float(np.mean(lv_p - lv_t)), |
| "n_samples": len(lv_t), |
| } |
|
|
