| """NdFeB SPS physics-model tool: predict, p_meets_spec, eig, condition. |
| |
| Evidence class: owner-built conditional executable physics model (Dynamical's model fitted to RPI's released records |
| and declared literature priors; not an RPI or collaborator model); not a physical observation; does not calibrate |
| current-body coercivity. The fit's assumptions about those records are listed in the README ("Fitted assumptions"). |
| |
| Dependencies: Python standard library + numpy. No JAX. Loads hash-bound artifacts: |
| physics.py - schedule discretisation and rate laws (identical bytes to the fitted model) |
| forward.py - mechanism forward equations (the fitted model's, plus the C4 feedstock particle-size layer, a declared |
| and uncalibrated hook that the fit never reached) |
| posterior - .npz of thinned posterior and prior draws + metadata |
| manifest - TOOL_MANIFEST.json with the sha256 of this module and the three files above (verified on load) |
| |
| Usage inside a science workspace (files are mounted by sha256, without names or extensions): |
| import importlib.util |
| from importlib.machinery import SourceFileLoader |
| raw = '/workspace/raw/' |
| loader = SourceFileLoader('ndfeb_physics_tool', raw + TOOL_SHA) |
| spec = importlib.util.spec_from_loader('ndfeb_physics_tool', loader) |
| tool = importlib.util.module_from_spec(spec); loader.exec_module(tool) |
| pm = tool.load(physics=raw + PHYSICS_SHA, forward=raw + FORWARD_SHA, posterior=raw + POSTERIOR_SHA, |
| manifest=raw + MANIFEST_SHA) |
| pm.predict({'T_peak_C': 800, 'pressure_mode': 'cooling', 'P_MPa': 60}) |
| |
| Units: deg C, minutes, MPa, relative density (fraction of 7.62 g/cm3), kOe, kGs, MGOe, um. |
| """ |
| from __future__ import annotations |
|
|
| import hashlib |
| import importlib.util |
| import json |
| import math |
| import sys |
| import types |
| from importlib.machinery import SourceFileLoader |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| TOOL_VERSION = "ndfeb-sps-physics-tool-20261013.5.0" |
| EVIDENCE_CLASS = ("owner-built conditional executable physics model (Dynamical's model fitted to RPI's released records " |
| "and declared literature priors; not an RPI or collaborator model); not a physical observation; does " |
| "not calibrate current-body coercivity") |
| OBJECTIVE = {"Hci_kOe_min": 20.0, "BHmax_MGOe_min": 45.0, "note": "Dy/Tb-free, verified at operating temperature; " |
| "10 kOe / 11 MGOe is a historical simulated benchmark from sample E, not the objective"} |
| RHO_TD = 7.62 |
| HERE = Path(__file__).resolve().parent |
| _PKG = "ndfeb_physics_model" |
|
|
| QUANTILE_LEVELS = (0.01, 0.025, 0.05, 0.10, 0.25, 0.50, 0.75, 0.90, 0.95, 0.975, 0.99) |
| QUANTILE_KEYS = ("q01", "q025", "q05", "q10", "q25", "q50", "q75", "q90", "q95", "q975", "q99") |
| H_MEASUREMENT_LOG_SD = 0.25 |
| H_DETECTION_INDEX = 0.01 |
| |
| |
| |
| |
| ROUTE_DEFAULTS = dict(T_peak_C=None, heating_rate_C_per_min=10.0, dwell_min=5.0, P_MPa=60.0, pressure_mode="cooling", |
| cooling_rate_C_per_min=100.0, load_ramp_min=0.3, degas=1.0, anneal="none", alignment_cos=0.5, |
| T_measure_C=20.0, prep="new", degas_completeness=1.0, current_path="compact", |
| feedstock_d50_um=4.0) |
| |
| |
| FEEDSTOCK_KEY = "feedstock_d50_um" |
| FEEDSTOCK_REF_UM = 4.0 |
| FEEDSTOCK_RANGE_UM = (0.5, 8.0) |
| FEEDSTOCK_PARAMS = ("fd_beta", "fd_sg", "fd_dox", "fd_gox", "fd_kH") |
| STATUS_FITTED = "fitted_feedstock" |
| STATUS_DECLARED = "declared_extrapolation_uncalibrated" |
| OUTPUTS = ("density_rel", "grain_um", "Hci_kOe", "Br_kGs", "Hk_over_Hci", "BHmax_MGOe") |
| PRESSURE_MODES = ("heating", "cooling", "dwell") |
| ANNEALS = ("none", "900", "900+520") |
| CURRENT_PATHS = ("compact", "insulated") |
| LT_LEVELS = ("trap", "load", "current") |
| SPEC_KEYS = ("Hci_kOe_min", "BHmax_MGOe_min", "Br_kGs_min", "density_rel_min", "T_operating_C") |
|
|
|
|
| def _validate_spec(spec): |
| """Reject unknown or non-numeric spec keys (a misspelled key must not silently drop a requirement).""" |
| if not isinstance(spec, dict) or not spec: |
| raise ValueError(f"spec must be a non-empty dict with keys from {SPEC_KEYS}") |
| bad = sorted(k for k in spec if k not in SPEC_KEYS) |
| if bad: |
| raise ValueError(f"unknown spec keys {bad}; allowed: {list(SPEC_KEYS)}") |
| for k, v in spec.items(): |
| if not _is_number(v): |
| raise ValueError(f"spec[{k!r}] must be a number") |
| return spec |
|
|
|
|
| def _sha256(path) -> str: |
| return hashlib.sha256(Path(path).read_bytes()).hexdigest() |
|
|
|
|
| def _load_module(name, path): |
| loader = SourceFileLoader(name, str(path)) |
| spec = importlib.util.spec_from_loader(name, loader) |
| mod = importlib.util.module_from_spec(spec) |
| sys.modules[name] = mod |
| loader.exec_module(mod) |
| return mod |
|
|
|
|
| def _compose(physics_path, forward_path): |
| """Compose physics.py and forward.py into a synthetic package (forward does `from . import physics`).""" |
| pkg = types.ModuleType(_PKG) |
| pkg.__path__ = [] |
| sys.modules[_PKG] = pkg |
| ph = _load_module(_PKG + ".physics", physics_path) |
| pkg.physics = ph |
| fw = _load_module(_PKG + ".forward", forward_path) |
| return ph, fw |
|
|
|
|
| def load(physics=None, forward=None, posterior=None, manifest=None, verify=True): |
| """Load the tool. With a manifest (default: TOOL_MANIFEST.json next to this file) every artifact's sha256 is |
| checked and a mismatch raises. Without one the model loads with `verified = False`, reported in every output.""" |
| physics = physics or HERE / "physics.py" |
| forward = forward or HERE / "forward.py" |
| posterior = posterior or HERE / "posterior_tool.npz" |
| if manifest is None and (HERE / "TOOL_MANIFEST.json").exists(): |
| manifest = HERE / "TOOL_MANIFEST.json" |
| hashes = {"physics": _sha256(physics), "forward": _sha256(forward), "posterior": _sha256(posterior), |
| "tool": _sha256(Path(__file__))} |
| verified = False |
| if verify and manifest is not None: |
| man = json.loads(Path(manifest).read_text()) |
| missing = [k for k in ("physics", "forward", "posterior", "tool") if k not in man.get("files", {})] |
| if missing: |
| raise ValueError(f"manifest lacks entries {missing}; a v3.1 manifest lists physics, forward, posterior and tool") |
| if man.get("tool_version") != TOOL_VERSION: |
| raise ValueError(f"manifest is for {man.get('tool_version')}, this module is {TOOL_VERSION}") |
| want = {k: man["files"][k]["sha256"] for k in ("physics", "forward", "posterior", "tool")} |
| bad = {k: (hashes[k], want[k]) for k in want if hashes[k] != want[k]} |
| if bad: |
| raise ValueError(f"artifact hashes differ from the manifest: {bad}") |
| verified = True |
| ph, fw = _compose(physics, forward) |
| return PhysicsModel(ph, fw, posterior, hashes, verified=verified) |
|
|
|
|
| def _n_logpdf(y, mu, s): |
| return -0.5 * ((y - mu) / s) ** 2 - np.log(s) - 0.5 * math.log(2 * math.pi) |
|
|
|
|
| def _t_logpdf(y, mu, s, nu=5.0): |
| z = (y - mu) / s |
| return (math.lgamma((nu + 1) / 2) - math.lgamma(nu / 2) - 0.5 * math.log(nu * math.pi) - np.log(s) |
| - (nu + 1) / 2 * np.log1p(z ** 2 / nu)) |
|
|
|
|
| def _lse(a, axis=None): |
| a = np.asarray(a, float) |
| m = np.max(a, axis=axis, keepdims=True) |
| m = np.where(np.isfinite(m), m, 0.0) |
| out = m + np.log(np.sum(np.exp(a - m), axis=axis, keepdims=True)) |
| return np.squeeze(out, axis=axis) if axis is not None else float(np.squeeze(out)) |
|
|
|
|
| def _lme(a, axis): |
| a = np.asarray(a, float) |
| return _lse(a, axis) - math.log(a.shape[axis]) |
|
|
|
|
| def _iqr(x): |
| q25, q75 = np.quantile(x, [0.25, 0.75]) |
| return float(q75 - q25) |
|
|
|
|
| def _distribution(x): |
| """Quantiles (the primary summary) and a quantile-matched log-normal approximation of a predictive sample |
| (mu_ln = ln median, sd_ln = half the 15.9-84.1 % log spread, over the positive draws), with its adequacy: |
| lognormal_max_log_error is the largest |ln q - (mu_ln + z_q sd_ln)| over q05..q95, and lognormal_adequate is true |
| when it is below 0.25. Mixtures over mechanisms and degassing states are often not log-normal.""" |
| from statistics import NormalDist |
| x = np.asarray(x, float) |
| qs = np.quantile(x, QUANTILE_LEVELS) |
| pos = x[x > 0] |
| mu = sd = worst = None |
| if len(pos) >= 10: |
| l16, l50, l84 = np.log(np.quantile(pos, [0.158655, 0.5, 0.841345])) |
| mu, sd = float(l50), float((l84 - l16) / 2.0) |
| central = [(q, lv) for q, lv in zip(qs, QUANTILE_LEVELS) if 0.05 <= lv <= 0.95] |
| if sd > 0 and all(q > 0 for q, _ in central): |
| worst = float(max(abs(math.log(q) - (mu + NormalDist().inv_cdf(lv) * sd)) for q, lv in central)) |
| return dict(quantiles={k: float(v) for k, v in zip(QUANTILE_KEYS, qs)}, mu_ln=mu, sd_ln=sd, |
| lognormal_max_log_error=worst, lognormal_adequate=bool(worst is not None and worst < 0.25), |
| frac_nonpositive=float(np.mean(x <= 0))) |
|
|
|
|
| def _load_on_cooling(r): |
| """Hull feature: 1 load on cooling, 0 load in heating, 0.5 load from the start of the dwell (declared scenario).""" |
| return {"cooling": 1.0, "heating": 0.0, "dwell": 0.5}[r["pressure_mode"]] |
|
|
|
|
| def _is_number(v): |
| import numbers |
| return isinstance(v, numbers.Real) and not isinstance(v, bool) |
|
|
|
|
| def _check_prep_feedstock(seen, r, what="routes"): |
| """Routes (or observations) sharing a preparation share one powder batch, hence one feedstock size.""" |
| v = float(r.get(FEEDSTOCK_KEY, FEEDSTOCK_REF_UM)) |
| if seen.setdefault(r["prep"], v) != v: |
| raise ValueError(f"{what} sharing preparation {r['prep']!r} must share {FEEDSTOCK_KEY} (one powder batch)") |
|
|
|
|
| def _scenarios(r): |
| dc = r["degas_completeness"] |
| dc_num = float(dc) if _is_number(dc) else None |
| complete = dc == "complete" |
| extrap = complete or (dc_num is not None and dc_num > 1.0) or (isinstance(dc, dict) and ( |
| (dc.get("distribution") == "uniform" and float(dc.get("high", 0)) > 1.0))) |
| calibrated = bool(abs(float(r["alignment_cos"]) - 0.5) < 1e-9 and abs(float(r["T_measure_C"]) - 20) < 1e-9 |
| and dc_num is not None and dc_num in (0.0, 1.0) and r["current_path"] == "compact" |
| and r["pressure_mode"] in ("heating", "cooling") |
| and float(r.get(FEEDSTOCK_KEY, FEEDSTOCK_REF_UM)) == FEEDSTOCK_REF_UM) |
| return {"alignment_cos": float(r["alignment_cos"]), "T_measure_C": float(r["T_measure_C"]), |
| "degas_occurrence_probability": float(r["degas"]), "degas_completeness": dc, |
| "degas_extrapolation_beyond_fitted_state": bool(extrap), |
| "degas_complete_declared": bool(complete), "current_path": r["current_path"], |
| "pressure_mode_dwell_declared": r["pressure_mode"] == "dwell", |
| FEEDSTOCK_KEY: float(r.get(FEEDSTOCK_KEY, FEEDSTOCK_REF_UM)), |
| "feedstock_declared": float(r.get(FEEDSTOCK_KEY, FEEDSTOCK_REF_UM)) != FEEDSTOCK_REF_UM, |
| "feedstock_note": ("feedstock_d50_um other than 4 um (the feedstock of every fitted record) is a declared, " |
| "uncalibrated extrapolation: grain size, coercivity (an empirical grain-size factor in " |
| "every mechanism, an oxidation term and a hydrogen term) and the flags change; density " |
| "is the current feedstock's density model, unchanged"), |
| "calibrated": calibrated, |
| "note": "model assumptions, not records: calibrated only at isotropic alignment, room temperature, the " |
| "two degassing states the fit assigns (the model assumes A-C correspond to completeness 0 and D/E " |
| "to completeness 1; RPI's record does not state A-C's dehydrogenation), a current-carrying compact " |
| "(conductive graphite die) and load in heating or on cooling. Alignment, temperature, intermediate " |
| "completeness (interpolated), completeness above 1 (extrapolated), complete degassing " |
| "(no residual hydrogen; generic degassing terms held at the fitted D/E state), an insulated " |
| "compact and load from the start of the dwell are declared scenarios; batch records or a hydrogen " |
| "measurement would pin the completeness."} |
|
|
|
|
| |
| EIG_METHOD_V4 = "bracketed-ba-v4" |
| EIG_QUANTITIES = ("Hci", "Br", "sq", "density", "grain", "H_ppm", "Hci_ratio_T") |
| EIG_EPS = 0.01 |
| EIG_ESS_POOL = (20.0, 200.0) |
| EIG_QUAD_DIMS = 36 |
| GOAL_BODIES_POOL, GOAL_BODIES_OUTER = 4, 32 |
| GOAL_QUANTILES = (0.05, 0.25, 0.5, 0.75, 0.95) |
|
|
|
|
| def _eig_spec_check(spec): |
| """Same keys and checks as p_meets_spec; unknown keys raise (a misspelled key must not drop a requirement).""" |
| v = globals().get("_validate_spec") |
| if v is not None: |
| return v(spec) |
| allowed = ("Hci_kOe_min", "BHmax_MGOe_min", "Br_kGs_min", "density_rel_min", "T_operating_C") |
| if not isinstance(spec, dict) or not spec: |
| raise ValueError(f"spec must be a non-empty dict with keys from {allowed}") |
| bad = sorted(k for k in spec if k not in allowed) |
| if bad: |
| raise ValueError(f"unknown spec keys {bad}; allowed: {list(allowed)}") |
| for k, val in spec.items(): |
| if not _is_number(val): |
| raise ValueError(f"spec[{k!r}] must be a number") |
| return spec |
|
|
|
|
| def _lbfgs(fg, x0, iters=200, m=10, tol=1e-8): |
| """Minimise a smooth convex f given fg(x) -> (f, grad): two-loop L-BFGS with a backtracking Armijo search.""" |
| x = np.array(x0, float) |
| f, g = fg(x) |
| S, Y = [], [] |
| for _ in range(iters): |
| q = g.copy() |
| hist = [] |
| for s, y in reversed(list(zip(S, Y))): |
| r = 1.0 / (y @ s) |
| a = r * (s @ q) |
| q -= a * y |
| hist.append((r, a, s, y)) |
| if S: |
| q *= (S[-1] @ Y[-1]) / (Y[-1] @ Y[-1]) |
| for r, a, s, y in reversed(hist): |
| q += s * (a - r * (y @ q)) |
| d = -q |
| gd = g @ d |
| if not gd < 0: |
| d, gd, S, Y = -g, -(g @ g), [], [] |
| t = 1.0 |
| while True: |
| xn = x + t * d |
| fn, gn = fg(xn) |
| if fn <= f + 1e-4 * t * gd or t < 1e-12: |
| break |
| t *= 0.5 |
| s, y = xn - x, gn - g |
| done = abs(f - fn) <= tol * max(1.0, abs(f)) |
| if y @ s > 1e-14: |
| S.append(s) |
| Y.append(y) |
| if len(S) > m: |
| S.pop(0) |
| Y.pop(0) |
| x, f, g = xn, fn, gn |
| if done: |
| break |
| return x |
|
|
|
|
| class _Features: |
| """Classifier / regression inputs: standardised summaries (clipped at 6 sd) and quadratic terms of the leading |
| EIG_QUAD_DIMS principal components of the first n_quad columns (the per-latent means). Fitted on training rows.""" |
|
|
| def __init__(self, X, n_quad): |
| self.mu, self.sd = X.mean(0), X.std(0) + 1e-9 |
| Z = np.clip((X - self.mu) / self.sd, -6.0, 6.0)[:, :n_quad] |
| k = min(EIG_QUAD_DIMS, Z.shape[1]) |
| if k: |
| lam, V = np.linalg.eigh(np.cov(Z.T).reshape(Z.shape[1], Z.shape[1])) |
| self.V = V[:, ::-1][:, :k] |
| else: |
| self.V = np.zeros((Z.shape[1], 0)) |
| self.n_quad = n_quad |
|
|
| def __call__(self, X): |
| Z = np.clip((X - self.mu) / self.sd, -6.0, 6.0) |
| P = Z[:, :self.n_quad] @ self.V |
| k = P.shape[1] |
| iu = np.triu_indices(k) |
| quad = (P[:, :, None] * P[:, None, :])[:, iu[0], iu[1]] / math.sqrt(2.0) if k else np.zeros((len(Z), 0)) |
| return np.concatenate([Z, np.clip(quad, -36.0, 36.0)], 1) |
|
|
|
|
| class _Softmax: |
| """Weighted multinomial logistic regression on _Features, fitted by L-BFGS with a small L2 penalty. Targets may |
| be soft (rows of class probabilities).""" |
|
|
| def __init__(self, X, T, sw, n_quad, l2=1e-4, iters=200): |
| self.feat = _Features(X, n_quad) |
| Phi = self.feat(X) |
| n, p = Phi.shape |
| K = T.shape[1] |
| swn = sw / sw.sum() |
|
|
| def fg(x): |
| W, b = x[:p * K].reshape(p, K), x[p * K:] |
| A = Phi @ W + b |
| A -= A.max(1, keepdims=True) |
| E = np.exp(A) |
| Ssum = E.sum(1, keepdims=True) |
| G = (E / Ssum - T) * swn[:, None] |
| f = -float(np.sum(swn[:, None] * T * (A - np.log(Ssum)))) + 0.5 * l2 * float(np.sum(W * W)) |
| return f, np.concatenate([(Phi.T @ G + l2 * W).ravel(), G.sum(0)]) |
| x = _lbfgs(fg, np.zeros(p * K + K), iters=iters) |
| self.W, self.b = x[:p * K].reshape(p, K), x[p * K:] |
|
|
| def log_prob(self, X): |
| A = self.feat(X) @ self.W + self.b |
| return A - _lse(A, 1)[:, None] |
|
|
|
|
| def _ridge(X, t, sw, Xnew, n_quad, l2=1e-3): |
| """Weighted ridge regression of t on [1, _Features(X)]; returns predictions at Xnew.""" |
| feat = _Features(X, n_quad) |
| Phi = np.concatenate([np.ones((len(X), 1)), feat(X)], 1) |
| w = sw / sw.sum() |
| beta = np.linalg.solve(Phi.T @ (Phi * w[:, None]) + l2 * np.eye(Phi.shape[1]), Phi.T @ (w * t)) |
| return np.concatenate([np.ones((len(Xnew), 1)), feat(Xnew)], 1) @ beta |
|
|
|
|
| def _systematic(p, n, rng): |
| """n indices drawn by systematic resampling with probabilities p (every index appears floor/ceil(n p) times).""" |
| if n <= 0: |
| return np.zeros(0, int) |
| c = np.cumsum(p / p.sum()) |
| u = (rng.random() + np.arange(n)) / n |
| return np.minimum(np.searchsorted(c, u), len(p) - 1) |
|
|
|
|
| def _alloc(w, n, balanced): |
| """Label counts summing to n: equal shares (balanced) or proportional to w (largest remainder).""" |
| k = len(w) |
| if balanced: |
| c = np.full(k, n // k) |
| c[: n - c.sum()] += 1 |
| return c |
| raw = n * w / w.sum() |
| c = np.floor(raw).astype(int) |
| c[np.argsort(-(raw - c))[: n - c.sum()]] += 1 |
| return c |
|
|
|
|
| def _eig_halves(contrib, fold, offset): |
| """Lower bound from each half of the simulated experiments and whether they agree within 2 combined SE.""" |
| est, var = [], [] |
| for f in (0, 1): |
| c = contrib[fold == f] |
| est.append(offset + float(c.mean())) |
| var.append(float(c.var(ddof=1)) / len(c) if len(c) > 1 else float("inf")) |
| return est, bool(abs(est[0] - est[1]) <= 2.0 * math.sqrt(var[0] + var[1])) |
|
|
|
|
| def _bern_entropy(p): |
| p = np.clip(np.asarray(p, float), 1e-12, 1 - 1e-12) |
| return -(p * np.log(p) + (1 - p) * np.log1p(-p)) |
|
|
|
|
| |
| class PhysicsModel: |
| def __init__(self, ph, fw, posterior_path, hashes, verified=False, weights=None): |
| self.ph, self.fw, self.hashes, self.verified = ph, fw, hashes, verified |
| z = np.load(posterior_path, allow_pickle=False) |
| self.meta = json.loads(str(z["__meta__"])) |
| self.post, self.prior = {}, {} |
| for key in z.files: |
| if key == "__meta__": |
| continue |
| grp, mech, par = key.split("__", 2) |
| tgt = self.post if grp == "post" else self.prior |
| tgt.setdefault(mech, {})[par] = np.asarray(z[key], dtype=float) |
| |
| self.w = {k: dict(v) for k, v in self.meta["weights"].items()} |
| |
| self.ltp = {} |
| for m, v in self.post.items(): |
| if all(f"ltp_{k}" in v for k in LT_LEVELS): |
| P = np.stack([v.pop(f"ltp_{k}") for k in LT_LEVELS], 1) |
| self.ltp[m] = P / P.sum(1, keepdims=True) |
| self.dw = weights or {m: np.ones(len(next(iter(v.values())))) for m, v in self.post.items()} |
| self.preps = self.meta["density_preps"] |
| self.conditioning = None |
|
|
| def _stamp(self, res): |
| res.update(tool_version=TOOL_VERSION, evidence_class=EVIDENCE_CLASS, artifact_sha256=self.hashes, |
| artifact_verified=self.verified) |
| if self.conditioning is not None: |
| res["conditioned_on"] = self.conditioning |
| return res |
|
|
| |
| def _route(self, route): |
| r = dict(ROUTE_DEFAULTS) |
| r.update(self.meta.get("route_defaults", {})) |
| r.update(route or {}) |
| if r["T_peak_C"] is None: |
| raise ValueError("route needs T_peak_C") |
| if r["pressure_mode"] not in PRESSURE_MODES: |
| raise ValueError(f"pressure_mode must be one of {PRESSURE_MODES}") |
| if r["anneal"] not in ANNEALS: |
| raise ValueError(f"anneal must be one of {ANNEALS} (a 520 C step without the 900 C anneal is not modelled)") |
| if r["current_path"] not in CURRENT_PATHS: |
| raise ValueError(f"current_path must be one of {CURRENT_PATHS}") |
| dc = r["degas_completeness"] |
| if dc == "complete": |
| pass |
| elif _is_number(dc): |
| if not 0.0 <= float(dc) <= 1.5: |
| raise ValueError("degas_completeness must lie in [0, 1.5] (values above 1 are a declared extrapolation)") |
| r["degas_completeness"] = float(dc) |
| elif isinstance(dc, dict): |
| kind = dc.get("distribution") |
| if kind == "uniform": |
| lo, hi = dc.get("low"), dc.get("high") |
| if not (_is_number(lo) and _is_number(hi) and 0.0 <= float(lo) <= float(hi) <= 1.5): |
| raise ValueError("uniform degas_completeness needs numeric 0 <= low <= high <= 1.5") |
| elif kind == "beta": |
| a, b = dc.get("a"), dc.get("b") |
| if not (_is_number(a) and _is_number(b) and float(a) > 0 and float(b) > 0): |
| raise ValueError("beta degas_completeness needs numeric a > 0 and b > 0") |
| else: |
| raise ValueError("degas_completeness dict needs distribution 'uniform' (low, high) or 'beta' (a, b)") |
| else: |
| raise ValueError("degas_completeness must be a number in [0, 1.5], a distribution dict " |
| "({'distribution': 'uniform', 'low', 'high'} or {'distribution': 'beta', 'a', 'b'}) " |
| "or 'complete'") |
| fd = r[FEEDSTOCK_KEY] |
| lo, hi = FEEDSTOCK_RANGE_UM |
| if not (_is_number(fd) and lo <= float(fd) <= hi): |
| raise ValueError(f"{FEEDSTOCK_KEY} must be a number in [{lo:g}, {hi:g}] (um; {FEEDSTOCK_REF_UM:g} = the " |
| "fitted feedstock; other values are a declared, uncalibrated extrapolation)") |
| r[FEEDSTOCK_KEY] = float(fd) |
| if r[FEEDSTOCK_KEY] != FEEDSTOCK_REF_UM and r["prep"] in self.preps: |
| raise ValueError(f"fitted preparation {r['prep']!r} is the {FEEDSTOCK_REF_UM:g} um feedstock: a body made " |
| f"from other feedstock needs prep 'new' or another new label") |
| return r |
|
|
| @staticmethod |
| def _feedstock_declared(r): |
| return float(r.get(FEEDSTOCK_KEY, FEEDSTOCK_REF_UM)) != FEEDSTOCK_REF_UM |
|
|
| def _feedstock_info(self, r): |
| dec = self._feedstock_declared(r) |
| return {FEEDSTOCK_KEY: float(r.get(FEEDSTOCK_KEY, FEEDSTOCK_REF_UM)), "declared": dec, |
| "status": STATUS_DECLARED if dec else STATUS_FITTED, |
| "note": ("declared feedstock particle size: grain size, an empirical grain-size factor on every " |
| "mechanism's coercivity, an oxidation penalty and a residual-hydrogen term follow uncalibrated " |
| "priors (README, 'Feedstock particle size'); no record constrains them") if dec else |
| "the fitted feedstock (about 4 um); the feedstock layer is inactive"} |
|
|
| @staticmethod |
| def _completeness_is_default(r): |
| dc = r["degas_completeness"] |
| return _is_number(dc) and float(dc) == 1.0 |
|
|
| @staticmethod |
| def _sample_completeness(dc, size, rng): |
| """Draws of the degassing completeness d (fraction of the fitted D/E state; > 1 = declared extrapolation). |
| "complete" returns 1 (the generic degassing terms are held at the D/E state; hydrogen is zeroed separately).""" |
| if dc == "complete": |
| return np.ones(size) |
| if _is_number(dc): |
| return np.full(size, float(dc)) |
| if dc["distribution"] == "uniform": |
| return rng.uniform(float(dc["low"]), float(dc["high"]), size) |
| return rng.beta(float(dc["a"]), float(dc["b"]), size) |
|
|
| def _expected_state(self, r): |
| """Expected degassing state E[occurrence x min(d, 1)], used only for the hull distance.""" |
| dc = r["degas_completeness"] |
| if dc == "complete": |
| m = 1.0 |
| elif _is_number(dc): |
| m = min(float(dc), 1.0) |
| else: |
| m = float(np.mean(np.minimum(self._sample_completeness(dc, 4000, np.random.default_rng(0)), 1.0))) |
| return float(r["degas"]) * m |
|
|
| def _degas_state(self, r, occ_uniform, rng_extra): |
| """Per-draw degassing state (occurrence x completeness) and the extrapolation multiplier eps (only used where |
| the state exceeds 1). occ_uniform: the uniforms v3 already drew for occurrence, so default inputs reproduce v3 |
| exactly; rng_extra is consulted only for non-default completeness.""" |
| occ = (occ_uniform < float(r["degas"])).astype(float) |
| if self._completeness_is_default(r) or r["degas_completeness"] == "complete": |
| return occ, None |
| d = self._sample_completeness(r["degas_completeness"], occ_uniform.shape, rng_extra) |
| eps = rng_extra.uniform(0.0, 1.0, occ_uniform.shape) |
| return occ * d, eps |
|
|
| def _arrays(self, r): |
| R = self.ph.Route(T_peak_C=float(r["T_peak_C"]), heating_rate_C_per_min=float(r["heating_rate_C_per_min"]), |
| dwell_min=float(r["dwell_min"]), P_MPa=float(r["P_MPa"]), pressure_mode=r["pressure_mode"], |
| cooling_rate_C_per_min=float(r["cooling_rate_C_per_min"]), |
| load_ramp_min=float(r["load_ramp_min"]), degas=1.0, anneal=r["anneal"], |
| alignment_cos=float(r["alignment_cos"]), T_measure_C=float(r["T_measure_C"]), |
| current_path=r["current_path"]) |
| S = self.ph.stack([self.ph.schedule(R)]) |
| return dict(S=S, T_peak=np.array([R.T_peak_C]), rate=np.array([R.heating_rate_C_per_min]), |
| dwell=np.array([R.dwell_min]), P=np.array([R.P_MPa]), |
| cooling=np.array([1.0 if R.pressure_mode == "cooling" else 0.0]), degas=np.array([1.0]), |
| mode_dwell=np.array([1.0 if R.pressure_mode == "dwell" else 0.0]), |
| path=np.array([0.0 if R.current_path == "insulated" else 1.0]), hfac=np.array([1.0]), |
| a900=np.array([1.0 if R.anneal in ("900", "900+520") else 0.0]), |
| a520=np.array([1.0 if R.anneal == "900+520" else 0.0]), align=np.array([R.alignment_cos]), |
| Tmeas=np.array([R.T_measure_C])) |
|
|
| def hull(self, r, rho=None): |
| """Nearest-neighbour distance to the fitted routes in standardised process space; out_of_hull if the distance |
| exceeds 1 or a feature leaves the fitted range by more than a quarter of its scale. The magnetic distance is the |
| one H0's discrepancy uses (forward.mag_hull_distance).""" |
| out = {} |
| for module in ("density", "magnetic"): |
| H = self.meta["hull"][module] |
| feats = H["features"] |
| x = self._features(r, rho, feats) |
| pts = np.asarray(H["points"], float) |
| sc = np.asarray(H["scales"], float) |
| d = float(np.sqrt((((pts - x) / sc) ** 2).sum(1)).min()) |
| lo, hi = pts.min(0), pts.max(0) |
| outside = [f for f, xi, l, h, s in zip(feats, x, lo, hi, sc) if xi < l - 0.25 * s or xi > h + 0.25 * s] |
| if r["pressure_mode"] == "dwell": |
| outside.append("pressure_mode=dwell") |
| if module == "magnetic" and r.get("current_path") == "insulated": |
| outside.append("current_path=insulated") |
| if module == "magnetic" and r.get("degas_completeness") == "complete": |
| outside.append("degas_completeness=complete") |
| if self._feedstock_declared(r): |
| outside.append(f"{FEEDSTOCK_KEY}={float(r[FEEDSTOCK_KEY]):g}") |
| out[module] = dict(distance=d, out_of_hull=bool(d > 1.0 or outside), outside_features=outside) |
| return out |
|
|
| @staticmethod |
| def _features(r, rho, feats): |
| val = dict(T_peak_C=float(r["T_peak_C"]), log10_rate=math.log10(float(r["heating_rate_C_per_min"])), |
| dwell_min=float(r["dwell_min"]), P_MPa=float(r["P_MPa"]), |
| load_on_cooling=_load_on_cooling(r), |
| degas=float(r.get("_degas_expected", r["degas"])), rel_density=float(rho if rho is not None else 0.98)) |
| return np.array([val[f] for f in feats], float) |
|
|
| def _hull_distance(self, r, rho): |
| d = self.fw.mag_hull_distance(float(r["T_peak_C"]), float(rho), _load_on_cooling(r), |
| float(r.get("_degas_expected", r["degas"])), |
| float(r["heating_rate_C_per_min"])) |
| if self._feedstock_declared(r): |
| |
| |
| d = math.sqrt(d * d + (math.log(float(r[FEEDSTOCK_KEY]) / FEEDSTOCK_REF_UM) / math.log(2.0)) ** 2) |
| return d |
|
|
| |
| def _mechs(self, kind, group="post"): |
| src = self.post if group == "post" else self.prior |
| return [m for m in self.w[kind] if m in src] |
|
|
| def _assign_bma(self, kind, n, rng, group="post"): |
| """n draws from the model average: mechanism labels by weight, parameter indices by the per-draw weights.""" |
| src = self.post if group == "post" else self.prior |
| mechs = self._mechs(kind, group) |
| wm = np.array([self.w[kind][m] for m in mechs], float) if group == "post" else np.ones(len(mechs)) |
| counts = rng.multinomial(n, wm / wm.sum()) |
| labels, idx = [], [] |
| for m, c in zip(mechs, counts): |
| if c == 0: |
| continue |
| K = len(next(iter(src[m].values()))) |
| p = self.dw[m] / self.dw[m].sum() if group == "post" else np.full(K, 1.0 / K) |
| labels += [m] * c |
| idx.append(rng.choice(K, size=c, p=p)) |
| labels, idx = np.array(labels), np.concatenate(idx) |
| perm = rng.permutation(n) |
| return labels[perm], idx[perm] |
|
|
| def _assign_strata(self, kind, n_per, rng): |
| """n_per draws from every mechanism with non-zero weight (stratified inner sets for eig).""" |
| labels, idx = [], [] |
| for m in self._mechs(kind): |
| if self.w[kind][m] <= 0: |
| continue |
| K = len(next(iter(self.post[m].values()))) |
| p = self.dw[m] / self.dw[m].sum() |
| labels += [m] * n_per |
| idx.append(rng.choice(K, size=n_per, p=p)) |
| return np.array(labels), np.concatenate(idx) |
|
|
| def _params(self, src, m, idx): |
| return {k: v[idx][:, None] for k, v in src[m].items()} |
|
|
| |
| def _indicators(self): |
| """Indicators whose labels are drawn conditionally on the magnetic draw (no parameter arrays of their own).""" |
| return ["load_timing"] if self.ltp else [] |
|
|
| def _assign_indicator(self, name, mlab, midx, rng, group="post"): |
| """Per-draw labels of a conditional indicator, aligned with (mlab, midx): load_timing labels are drawn from |
| the draw's own posterior probabilities p(LT | theta, data) (posterior group) or uniformly (prior group).""" |
| if name != "load_timing": |
| raise ValueError(f"unknown conditional indicator {name!r}") |
| n = len(mlab) |
| u = rng.random(n) |
| out = np.empty(n, dtype=object) |
| for m in np.unique(mlab): |
| pos = np.where(mlab == m)[0] |
| if group == "post" and m in self.ltp: |
| P = self.ltp[m][midx[pos]] |
| else: |
| P = np.full((len(pos), len(LT_LEVELS)), 1.0 / len(LT_LEVELS)) |
| c = np.cumsum(P, 1) |
| k = np.minimum((u[pos][:, None] > c).sum(1), len(LT_LEVELS) - 1) |
| out[pos] = np.array(LT_LEVELS, dtype=object)[k] |
| return out.astype(str) |
|
|
| def _assign_strata_indicator(self, name, n_per, rng): |
| """n_per joint draws (mlab, midx, labels) per level of a conditional indicator: (m, i) sampled with |
| probability proportional to w_m * dw_m[i] / sum(dw_m) * p_m[i, level] (exactly p(m, i | level)).""" |
| if name != "load_timing": |
| raise ValueError(f"unknown conditional indicator {name!r}") |
| mechs = [m for m in self._mechs("magnetic") if self.w["magnetic"][m] > 0] |
| blocks = [] |
| for m in mechs: |
| base = self.w["magnetic"][m] * self.dw[m] / self.dw[m].sum() |
| blocks.append(base[:, None] * self.ltp[m]) |
| Wt = np.concatenate(blocks, 0) |
| offs = np.cumsum([0] + [len(b) for b in blocks]) |
| labs, idxs, lts = [], [], [] |
| for k, lvl in enumerate(LT_LEVELS): |
| pk = Wt[:, k] / Wt[:, k].sum() |
| j = rng.choice(len(pk), size=n_per, p=pk) |
| mi = np.searchsorted(offs, j, side="right") - 1 |
| labs.append(np.array(mechs, dtype=object)[mi]) |
| idxs.append(j - offs[mi]) |
| lts.append(np.full(n_per, lvl, dtype=object)) |
| return (np.concatenate(labs).astype(str), np.concatenate(idxs).astype(int), |
| np.concatenate(lts).astype(str)) |
|
|
| |
| def _density_mean(self, A, r, dlab, didx, prep_z, group="post"): |
| """Per-draw route-level relative density (before specimen scatter) and its scatter scale.""" |
| src = self.post if group == "post" else self.prior |
| n = len(dlab) |
| mu, sig = np.empty(n), np.empty(n) |
| for m in np.unique(dlab): |
| pos = np.where(dlab == m)[0] |
| p = self._params(src, m, didx[pos]) |
| if r["prep"] in self.preps and group == "post": |
| off = p["tau_prep"] * p[f"z_prep_{self.preps.index(r['prep'])}"] |
| else: |
| off = p["tau_prep"] * prep_z[pos] |
| mu[pos] = self.fw.density(p, m, A, lnk_offset=off, xp=np)[:, 0] |
| sig[pos] = p["sig_rho"][:, 0] |
| return mu, sig |
|
|
| def _magnetic_latent(self, A, r, mlab, midx, rho, degas_ind, z_hull, u_spec=None, group="post", eps=None, |
| indicators=None): |
| """Per-draw latent magnetic quantities. rho, degas_ind, z_hull, u_spec: (n,) arrays aligned with the draws. |
| ln Hci includes u_spec (the body's specimen effect) when given; otherwise it is the route-level value. |
| degas_ind is the continuous degassing state (occurrence x completeness). Where it exceeds 1 (a declared |
| extrapolation beyond the fitted D/E state) the forward model is evaluated at 1 and ln Hci gains |
| eps * (state - 1) * [ln Hci(state 1) - ln Hci(state 0)] for the same draw, eps ~ U(0, 1); the residual-hydrogen |
| index is reduced by the factor 1 - eps * (state - 1). With degas_completeness "complete" a degassed draw has |
| state 1 for the generic degassing terms and no hydrogen (H1 and the trap alternative see h0 = 0). |
| indicators: {"load_timing": labels (n,)} aligned with the draws (required when the posterior carries LT; the |
| same labels must be used for every route of a joint draw). lh_res is the physical residual-hydrogen index of |
| the sintered body (pore closure by the load mode), floored at the declared detection limit H_DETECTION_INDEX.""" |
| src = self.post if group == "post" else self.prior |
| n = len(mlab) |
| if self.ltp: |
| if not indicators or "load_timing" not in indicators: |
| raise ValueError("this posterior carries the load-timing indicator: pass " |
| "indicators={'load_timing': labels} from _assign_indicator") |
| ltlab = np.asarray(indicators["load_timing"]).astype(str) |
| if ltlab.shape != (n,): |
| raise ValueError("load_timing labels must be aligned with the draws") |
| else: |
| ltlab = np.full(n, "load") |
| complete = r.get("degas_completeness") == "complete" |
| fd = float(r.get(FEEDSTOCK_KEY, FEEDSTOCK_REF_UM)) |
| milled = fd != FEEDSTOCK_REF_UM |
| keys = ("lh", "lbr", "sq", "lgrain", "lh_res", "sig_spec", "sig_piece", "sig_Br", "sig_sq", "Js", "HA", "nB", |
| "dB", "HR", "kR", "grain") |
| out = {k: np.empty(n) for k in keys} |
| for m in np.unique(mlab): |
| pos = np.where(mlab == m)[0] |
| p = self._params(src, m, midx[pos]) |
| rr = rho[pos][:, None] |
| state = degas_ind[pos][:, None] |
| over = np.maximum(state - 1.0, 0.0) |
| Ad = dict(A) |
| Ad["degas"] = np.minimum(state, 1.0) |
| Ad["hfac"] = np.where(state >= 1.0, 0.0, 1.0) if complete else np.ones_like(state) |
| if milled: |
| miss = [k for k in FEEDSTOCK_PARAMS if k not in p] |
| if miss: |
| raise ValueError(f"this posterior carries no feedstock-layer draws {miss}: {FEEDSTOCK_KEY} other " |
| f"than {FEEDSTOCK_REF_UM:g} needs a package that declares the layer") |
| |
| |
| Ad["degas"] = np.where(Ad["hfac"] > 0, self.fw.feedstock_degas_equivalent(p, Ad["degas"], fd, np), |
| Ad["degas"]) |
| |
| |
| |
| g_fd = self.fw.grain(p, dict(A, fd_d0_factor=self.fw.feedstock_d0_factor(p, fd, np)), xp=np) |
| g_ref = self.fw.grain(p, A, xp=np) |
| fshift = (np.log(self.fw.feedstock_grain_factor(p, g_fd, g_ref, np)) |
| - self.fw.feedstock_oxidation_penalty(p, fd, np)) |
| hd = np.array([self._hull_distance(r, x) for x in rho[pos]])[:, None] if m == "H0" else 0.0 |
| u = u_spec[pos][:, None] if u_spec is not None else 0.0 |
| zh = z_hull[pos][:, None] |
| lt = ltlab[pos] |
| if np.any(over > 0): |
| e = eps[pos][:, None] |
| raw = self.fw._log_hci_raw(p, m, Ad, rr, u, hd, zh, np, lt) |
| one = dict(Ad, degas=np.ones_like(state), hfac=np.ones_like(state)) |
| zero = dict(Ad, degas=np.zeros_like(state), hfac=np.ones_like(state)) |
| slope = (self.fw._log_hci_raw(p, m, one, rr, 0.0, hd, zh, np, lt) |
| - self.fw._log_hci_raw(p, m, zero, rr, 0.0, hd, zh, np, lt)) |
| tot = raw + e * over * slope |
| lh = self.fw.cap_log_hci(tot + fshift if milled else tot, np) |
| else: |
| raw = self.fw._log_hci_raw(p, m, Ad, rr, u, hd, zh, np, lt) |
| lh = self.fw.cap_log_hci(raw + fshift if milled else raw, np) |
| out["lh"][pos] = lh[:, 0] |
| out["lbr"][pos] = np.log(self.fw.remanence(p, A, rr, np.exp(lh), xp=np))[:, 0] |
| out["sq"][pos] = (self.fw.squareness_logit(p, A, xp=np) * np.ones((len(pos), 1)))[:, 0] |
| g = (g_fd if milled else self.fw.grain(p, A, xp=np))[:, 0] |
| out["grain"][pos], out["lgrain"][pos] = g, np.log(g) |
| hres = self.ph.desorption(A["S"], A["cooling"], Ad["degas"], p, mode_dwell=A.get("mode_dwell")) * Ad["hfac"] |
| if np.any(over > 0): |
| hres = hres * np.maximum(1.0 - eps[pos][:, None] * over, 1e-6) |
| out["lh_res"][pos] = np.log(np.maximum(hres, H_DETECTION_INDEX))[:, 0] |
| for k in ("sig_spec", "sig_piece", "sig_Br", "sig_sq", "Js", "HR", "kR"): |
| out[k][pos] = p[k][:, 0] |
| for k, default in (("HA", 75.0), ("nB", 0.17), ("dB", 0.004)): |
| out[k][pos] = p[k][:, 0] if k in p else default |
| return out |
|
|
| |
| def _temperature(self, lat, hci, br, T_C, rng): |
| """Declared temperature scenario (not calibrated): Kuz'min Js(T), linear HA(T), Neff = nB ln(D/dB), alpha from |
| the room-temperature Hci; remanence retention R(Hci) re-evaluated at temperature.""" |
| if abs(T_C - 20.0) < 1e-9: |
| return hci, br |
| n = len(hci) |
| s = rng.uniform(0.5, 0.6, n) |
| cHA = rng.uniform(0.0026, 0.0032, n) |
| raw, rJ = self._temperature_map(lat, hci, T_C, s, cHA) |
| hci_T = np.maximum(raw, 0.0) |
| R = lambda h: 1.0 / (1.0 + (lat["HR"] / np.maximum(h, 1e-3)) ** lat["kR"]) |
| return hci_T, br * rJ * R(hci_T) / R(hci) |
|
|
| def _temperature_map(self, lat, hci, T_C, s, cHA): |
| """Deterministic part of the temperature scenario: unfloored Hci(T) for a body whose room-temperature Hci is |
| `hci` (alpha is derived from it, so the ratio Hci(T)/Hci(20 C) depends on the body's own Hci), and the Js ratio.""" |
| rJ = self.ph.kuzmin_js(T_C + 273.15, 1.0, s=s) / self.ph.kuzmin_js(293.15, 1.0, s=s) |
| rH = np.clip(1.0 - cHA * (T_C - 20.0), 0.05, None) |
| neff = lat["nB"] * np.log(np.maximum(lat["grain"], 0.01) / lat["dB"]) |
| alpha = (hci + neff * lat["Js"]) / lat["HA"] |
| return alpha * lat["HA"] * rH - neff * lat["Js"] * rJ, rJ |
|
|
| def _bh(self, br, hci, sq, rng): |
| cal = self.meta["bhmax_shape"] |
| f = cal["shape_factor"] * np.exp(cal["log_sd"] * rng.standard_normal(len(br))) |
| raw = np.asarray(self.ph.bhmax(np.asarray(br), np.maximum(np.asarray(hci), 1e-3), np.asarray(sq), shape=1.0)) |
| return np.minimum(raw * f, np.asarray(br) ** 2 / 4.0) |
|
|
| @staticmethod |
| def _rho_scenario(rs): |
| """Validate a declared density scenario {"mean": .., "sd": ..} (g/cm3 if mean > 1.5, else relative).""" |
| if not (isinstance(rs, dict) and _is_number(rs.get("mean")) and _is_number(rs.get("sd")) |
| and float(rs["mean"]) > 0 and float(rs["sd"]) >= 0): |
| raise ValueError("rho_scenario must be {'mean': number > 0, 'sd': number >= 0} (g/cm3 or relative)") |
| scale = RHO_TD if float(rs["mean"]) > 1.5 else 1.0 |
| return float(rs["mean"]) / scale, float(rs["sd"]) / scale |
|
|
| def _simulate(self, route, n, seed, group="post", rho_observed=None, rho_scenario=None): |
| r = self._route(route) |
| r["_degas_expected"] = self._expected_state(r) |
| rng = np.random.default_rng(seed) |
| A = self._arrays(r) |
| hull = self.hull(r) |
| if rho_observed is not None and rho_scenario is not None: |
| raise ValueError("pass either rho_observed (a measured body) or rho_scenario (an assumed density), not both") |
| if rho_observed is not None: |
| rho_obs = float(rho_observed) |
| rho_obs = rho_obs / RHO_TD if rho_obs > 1.5 else rho_obs |
| rho = np.full(n, rho_obs) + 0.005 * rng.standard_normal(n) |
| dlab = np.array(["observed"] * n) |
| elif rho_scenario is not None: |
| mu, sd = self._rho_scenario(rho_scenario) |
| rho = np.clip(mu + sd * rng.standard_normal(n), 0.3, 1.02) |
| dlab = np.array(["scenario"] * n) |
| else: |
| dlab, didx = self._assign_bma("density", n, rng, group) |
| mu, sig = self._density_mean(A, r, dlab, didx, rng.standard_normal((n, 1)), group) |
| rho = np.clip(mu + sig * rng.standard_t(5.0, n), 0.3, 1.02) |
| mlab, midx = self._assign_bma("magnetic", n, rng, group) |
| ind = {k: self._assign_indicator(k, mlab, midx, np.random.default_rng([int(seed), 47]), group) |
| for k in self._indicators()} |
| degas_ind, eps = self._degas_state(r, rng.random(n), np.random.default_rng([int(seed), 31])) |
| z_hull = rng.standard_normal(n) |
| sig_spec = np.array([self.post[m]["sig_spec"][i] if group == "post" else self.prior[m]["sig_spec"][i] |
| for m, i in zip(mlab, midx)]) |
| u = sig_spec * rng.standard_normal(n) |
| lat = self._magnetic_latent(A, r, mlab, midx, rho, degas_ind, z_hull, u, group, eps=eps, indicators=ind) |
| hci_meas = np.exp(lat["lh"]) * np.exp(lat["sig_piece"] * rng.standard_normal(n)) |
| br = np.exp(lat["lbr"] + lat["sig_Br"] * rng.standard_normal(n)) |
| sq = 1.0 / (1.0 + np.exp(-(lat["sq"] + lat["sig_sq"] * rng.standard_normal(n)))) |
| hci_T, br_T = self._temperature(lat, hci_meas, br, float(r["T_measure_C"]), rng) |
| bh = self._bh(br_T, hci_T, sq, rng) |
| sims = dict(density_rel=rho, grain_um=lat["grain"], Hci_kOe=hci_T, Br_kGs=br_T, Hk_over_Hci=sq, BHmax_MGOe=bh) |
| hull_m = self.hull(r, rho=float(np.median(rho)))["magnetic"] |
| r.pop("_degas_expected", None) |
| return r, sims, dlab, mlab, dict(density=hull["density"], magnetic=hull_m), ind |
|
|
| |
| def predict(self, route, n_draws=4000, seed=0, rho_observed=None, include_draws=False, rho_scenario=None): |
| """Posterior predictive of a *measured* as-processed body (specimen-to-specimen and measurement scatter |
| included). rho_observed (g/cm3 or relative): condition the magnetics on a measured density (an existing body). |
| rho_scenario {"mean", "sd"}: an assumed density with its uncertainty, for a body not yet made.""" |
| r, sims, dlab, mlab, hull, ind = self._simulate(route, n_draws, seed, "post", rho_observed, rho_scenario) |
| _, prs, _, _, _, _ = self._simulate(route, max(1000, n_draws // 2), seed + 1, "prior", rho_observed, |
| rho_scenario) |
| res = {"route": r, "mechanism_weights": self.w, "out_of_hull": hull, "outputs": {}} |
| for k in OUTPUTS: |
| x = np.asarray(sims[k], float) |
| logk = k not in ("density_rel", "Hk_over_Hci") |
| tr = (lambda v: np.log(np.maximum(v, 1e-6))) if logk else (lambda v: v) |
| lab = dlab if k == "density_rel" else mlab |
| groups = {m: x[lab == m] for m in np.unique(lab)} |
| tx, tp = tr(x), tr(np.asarray(prs[k], float)) |
| v_post = float(np.var(tx)) |
| between = float(np.var(np.concatenate([np.full(len(g), np.mean(tr(g))) for g in groups.values()]))) \ |
| if len(groups) > 1 else 0.0 |
| share = between / v_post if v_post > 0 else 0.0 |
| ratio = (_iqr(tx) / _iqr(tp)) ** 2 if _iqr(tp) > 0 else 1.0 |
| module = "density" if k == "density_rel" else "magnetic" |
| observed = k == "density_rel" and rho_observed is not None |
| extra = {} |
| if module == "magnetic" and "load_timing" in ind: |
| lt = ind["load_timing"] |
| extra["by_load_timing"] = {L: dict(median=float(np.median(x[lt == L])), |
| q05=float(np.quantile(x[lt == L], 0.05)), |
| q95=float(np.quantile(x[lt == L], 0.95)), n=int((lt == L).sum())) |
| for L in LT_LEVELS if (lt == L).any()} |
| res["outputs"][k] = dict( |
| mean=float(np.mean(x)), median=float(np.median(x)), sd=float(np.std(x)), |
| q05=float(np.quantile(x, 0.05)), q25=float(np.quantile(x, 0.25)), q75=float(np.quantile(x, 0.75)), |
| q95=float(np.quantile(x, 0.95)), |
| by_mechanism={m: dict(median=float(np.median(g)), q05=float(np.quantile(g, 0.05)), |
| q95=float(np.quantile(g, 0.95)), n=int(len(g))) for m, g in groups.items()}, |
| posterior_to_prior_spread_ratio=ratio, between_mechanism_share=share, |
| prior_dominated=bool(False if observed else (ratio > 0.5 or hull[module]["out_of_hull"])), |
| mechanism_dominated=bool(share > 0.5), conditioned_on_observed_density=observed, |
| density_scenario_declared=bool(rho_scenario is not None), **extra, **_distribution(x), |
| status=self._feedstock_info(r)["status"]) |
| d = res["outputs"]["density_rel"] |
| res["outputs"]["density_g_cm3"] = {k: d[k] * RHO_TD for k in ("mean", "median", "sd", "q05", "q25", "q75", "q95")} |
| res["outputs"]["density_g_cm3"]["quantiles"] = {k: v * RHO_TD for k, v in d["quantiles"].items()} |
| js = 16.1 |
| br_iso = js * d["median"] * float(r["alignment_cos"]) |
| res["ceilings"] = {"Br_ideal_kGs_Js_rho_cos": br_iso, |
| "BHmax_bound_MGOe_Br2_over_4": br_iso ** 2 / 4.0, |
| "isotropic_full_density_BHmax_MGOe": (js * 0.5) ** 2 / 4.0, |
| "Br_needed_for_45_MGOe_kGs": math.sqrt(4 * 45.0), |
| "note": "ideal values use Js = 16.1 kG; RPI's E sits ~2 % above (kappa); isotropic " |
| "<cos>=0.5 caps Br near Js/2; 45 MGOe needs Br >= 13.4 kG, i.e. alignment"} |
| res["scenarios"] = _scenarios(r) |
| res["feedstock"] = self._feedstock_info(r) |
| res["flag_rules"] = ("prior_dominated: posterior-to-prior predictive spread ratio (IQR^2 on the transformed " |
| "scale) > 0.5, or the output's module is out of its data hull; mechanism_dominated: > 50 % " |
| "of the predictive variance lies between mechanism-conditional means") |
| res["objective"] = OBJECTIVE |
| if rho_observed is not None: |
| res["rho_observed_note"] = ("magnetics conditioned on rho_observed as a MEASURED density (fixed 0.005 relative " |
| "spread); for a body not yet made pass rho_scenario={'mean', 'sd'} instead") |
| res["recording_note"] = ("record a forecast with its quantiles, not mean +/- sd: the magnetic predictives are " |
| "skewed mixtures; mu_ln / sd_ln summarise them only where lognormal_adequate is true; " |
| "forecast_record() returns a ready-to-store record") |
| if include_draws: |
| res["draws"] = {k: np.asarray(v).tolist() for k, v in sims.items()} |
| return self._stamp(res) |
|
|
| def p_meets_spec(self, route, spec, n_draws=6000, seed=0, rho_observed=None, rho_scenario=None): |
| """Posterior probability that one body made by `route` meets `spec`, scored on *measured* values (the same |
| measurement scatter as the RPI curves). spec keys (all optional): Hci_kOe_min, BHmax_MGOe_min, Br_kGs_min, |
| density_rel_min, T_operating_C (evaluates Hci/Br/BHmax at that temperature as a declared scenario).""" |
| _validate_spec(spec) |
| route = dict(route) |
| if "T_operating_C" in spec: |
| route["T_measure_C"] = float(spec["T_operating_C"]) |
| r, sims, dlab, mlab, hull, ind = self._simulate(route, n_draws, seed, "post", rho_observed, rho_scenario) |
| keys = (("Hci_kOe_min", "Hci_kOe"), ("BHmax_MGOe_min", "BHmax_MGOe"), ("Br_kGs_min", "Br_kGs"), |
| ("density_rel_min", "density_rel")) |
| ok = np.ones(n_draws, bool) |
| checks = {} |
| for key, out in keys: |
| if key in spec: |
| c = np.asarray(sims[out]) >= float(spec[key]) |
| checks[key] = float(c.mean()) |
| ok &= c |
| p = float(ok.mean()) |
| by_m = {m: float(ok[mlab == m].mean()) for m in np.unique(mlab)} |
| _, prs, _, _, _, _ = self._simulate(route, max(2000, n_draws // 2), seed + 1, "prior", rho_observed, |
| rho_scenario) |
| okp = np.ones(len(prs["Hci_kOe"]), bool) |
| for key, out in keys: |
| if key in spec: |
| okp &= np.asarray(prs[out]) >= float(spec[key]) |
| mag_spec = any(k in spec for k in ("Hci_kOe_min", "BHmax_MGOe_min", "Br_kGs_min")) |
| spread = max(by_m.values()) - min(by_m.values()) if by_m else 0.0 |
| res = {"route": r, "spec": spec, "p_meets_spec": p, |
| "monte_carlo_se": math.sqrt(max(p * (1 - p), 1e-12) / n_draws), "marginals": checks, |
| "by_magnetic_mechanism": by_m, "mechanism_weights": self.w["magnetic"], |
| "by_load_timing": ({L: float(ok[ind["load_timing"] == L].mean()) for L in LT_LEVELS |
| if (ind["load_timing"] == L).any()} if "load_timing" in ind else None), |
| "load_timing_weights": self.w.get("load_timing"), |
| "prior_predictive_p": float(okp.mean()), |
| "prior_dominated": bool((mag_spec and hull["magnetic"]["out_of_hull"]) |
| or (hull["density"]["out_of_hull"] and "density_rel_min" in spec) |
| or (abs(p - okp.mean()) < 0.02 and 0.0 < p < 1.0) or spread > 0.3), |
| "no_draw_meets_spec": bool(p == 0.0 and float(okp.mean()) == 0.0), |
| "p_upper_95": (3.0 / n_draws) if p == 0.0 else None, |
| "out_of_hull": hull, "scenario_not_calibrated": not _scenarios(r)["calibrated"], |
| "feedstock": self._feedstock_info(r), |
| "scenarios": _scenarios(r), |
| "scored_on": "measured values (piece, Br, squareness and curve-shape scatter included)"} |
| return self._stamp(res) |
|
|
| def forecast_record(self, route, body_id=None, rho_observed=None, n_draws=8000, seed=0, |
| outputs=("density_rel", "Hci_kOe", "Br_kGs", "BHmax_MGOe", "Hk_over_Hci"), rho_scenario=None): |
| """A schema-ready committed-forecast record for one body (deterministic for a given seed, so it can be stored |
| and reproduced). body_id: a neutral caller-supplied identifier. Contains, per output, the quantile set and |
| log-normal parameters with the flags; the resolved route and scenario keys; the conditioning; and the tool |
| and artifact hashes. The scoring harness reads this record directly.""" |
| res = self.predict(route, n_draws=n_draws, seed=seed, rho_observed=rho_observed, rho_scenario=rho_scenario) |
| rec_out = {} |
| for k in outputs: |
| o = res["outputs"][k] |
| rec_out[k] = {"quantiles": o["quantiles"], "mu_ln": o["mu_ln"], "sd_ln": o["sd_ln"], |
| "lognormal_adequate": o["lognormal_adequate"], |
| "lognormal_max_log_error": o["lognormal_max_log_error"], "median": o["median"], |
| "frac_nonpositive": o["frac_nonpositive"], "prior_dominated": o["prior_dominated"], |
| "mechanism_dominated": o["mechanism_dominated"], |
| "posterior_to_prior_spread_ratio": o["posterior_to_prior_spread_ratio"], |
| "conditioned_on_observed_density": o["conditioned_on_observed_density"], |
| "status": o["status"]} |
| return {"schema": "ndfeb-forecast-record-v1", "body_id": body_id, "route": res["route"], |
| "status": res["feedstock"]["status"], "feedstock": res["feedstock"], |
| "scenarios": res["scenarios"], "conditioning": {"rho_observed": rho_observed, |
| "rho_scenario": rho_scenario}, |
| "outputs": rec_out, "out_of_hull": res["out_of_hull"], "mechanism_weights": res["mechanism_weights"], |
| "n_draws": int(n_draws), "seed": int(seed), "quantile_levels": list(QUANTILE_LEVELS), |
| "units": {"density_rel": "fraction of 7.62 g/cm3", "Hci_kOe": "kOe", "Br_kGs": "kG", |
| "BHmax_MGOe": "MGOe", "Hk_over_Hci": "ratio"}, |
| "scoring": "score from the quantiles (interpolated predictive on the log scale for positive quantities); " |
| "mu_ln / sd_ln only where lognormal_adequate; 50/90 % interval coverage", |
| "tool_version": TOOL_VERSION, "evidence_class": EVIDENCE_CLASS, "artifact_sha256": self.hashes, |
| "artifact_verified": self.verified, "conditioned_on": self.conditioning} |
|
|
| def _latents(self, meas, target, dlab, didx, mlab, midx, rng, indicators=None): |
| """Per-route latent means and noise scales for a set of joint draws (aligned arrays of length n). Shared across |
| routes within a draw: new-preparation effects, the degas state of each preparation, H0's discrepancy direction.""" |
| n = len(mlab) |
| routes = [mm["route"] for mm in meas] + [target] |
| rho_obs = [mm.get("rho_observed") for mm in meas] + [None] |
| prep_z, degas, eps, prep_dc, prep_fd = {}, {}, {}, {}, {} |
| z_hull = rng.standard_normal(n) |
| rows = [] |
| extra = None |
| for j, route in enumerate(routes): |
| r = self._route(route) |
| r["_degas_expected"] = self._expected_state(r) |
| A = self._arrays(r) |
| if r["prep"] in prep_dc and prep_dc[r["prep"]] != json.dumps(r["degas_completeness"], sort_keys=True): |
| raise ValueError(f"routes sharing preparation {r['prep']!r} must share degas_completeness") |
| prep_dc[r["prep"]] = json.dumps(r["degas_completeness"], sort_keys=True) |
| _check_prep_feedstock(prep_fd, r) |
| if r["prep"] not in prep_z: |
| prep_z[r["prep"]] = rng.standard_normal((n, 1)) |
| u = rng.random(n) |
| if not self._completeness_is_default(r) and extra is None: |
| extra = rng.spawn(1)[0] |
| degas[r["prep"]], eps[r["prep"]] = self._degas_state(r, u, extra) |
| mu, sig = self._density_mean(A, r, dlab, didx, prep_z[r["prep"]]) |
| ro = rho_obs[j] |
| rho = np.full(n, (ro / RHO_TD if ro > 1.5 else ro)) if ro else np.clip(mu, 0.3, 1.0) |
| lat = self._magnetic_latent(A, r, mlab, midx, rho, degas[r["prep"]], z_hull, eps=eps[r["prep"]], |
| indicators=indicators) |
| row = dict(mu_rho=mu, sig_rho=sig, rho_known=ro is not None, **lat) |
| if j < len(meas) and "Hci_ratio_T" in meas[j].get("quantities", []): |
| if extra is None: |
| extra = rng.spawn(1)[0] |
| row["lratioT"], row["lratioT_g"] = self._ln_hci_ratio_T(lat, float(meas[j].get("T2_C", 120.0)), extra) |
| rows.append(row) |
| return rows |
|
|
| def _ln_hci_ratio_T(self, lat, T2_C, rng): |
| """Declared measurement hook (uncalibrated): ln[Hci(T2) / Hci(20 C)] at the route-level latent under the tool's |
| temperature scenario (the same map as predict), with per-draw Kuz'min s and HA(T) slope; floored at ln(0.01) |
| (a loop whose coercivity collapses is field-limited, not exact). Returns the ratio and its sensitivity |
| g = d ln(ratio) / d ln(Hci): the specimen effect does not cancel, because alpha follows the body's own Hci, so |
| the eig noise adds (g * sig_spec)^2 to 2 * sig_piece^2.""" |
| n = len(lat["lh"]) |
| s = rng.uniform(0.5, 0.6, n) |
| cHA = rng.uniform(0.0026, 0.0032, n) |
|
|
| def ln_ratio(lh): |
| hci = np.exp(lh) |
| raw, _ = self._temperature_map(lat, hci, T2_C, s, cHA) |
| return np.log(np.maximum(raw, 0.01 * hci) / hci) |
| r0 = ln_ratio(lat["lh"]) |
| g = (ln_ratio(lat["lh"] + 0.01) - r0) / 0.01 |
| return r0, g |
|
|
| |
| def _eig_v31(self, candidates, n_outer=1500, n_inner_per_mechanism=6000, seed=0, target=None): |
| """The v3.1-r3 estimator, unchanged (eig(..., method="nmc-v3.1")). Rank candidate measurements by expected |
| information gain (nats). |
| candidates: list of {"name": str, "measurements": [ {"route": {...}, "rho_observed": optional, |
| "quantities": ["Hci","Br","sq","density","grain","H_ppm","Hci_ratio_T"], "replicates": 1, |
| "T2_C": 120 (only for Hci_ratio_T)} ]} |
| H_ppm and Hci_ratio_T use declared, uncalibrated measurement models (H_MEASUREMENT_LOG_SD; the temperature |
| scenario), so their EIG is conditional on those assumptions. |
| Mechanism EIG is estimated two ways from the same draws: nested Monte Carlo with the outer draw excluded |
| (consistent; biased low when the inner set is small) and with the outer draw included in its own stratum |
| (biased high for informative designs). The reported value is the midpoint of that bracket; `*_converged` is |
| False when the bracket is wider than max(0.05 nats, 2 SE): then increase n_inner_per_mechanism. The |
| all-parameter EIG is a prior-contrastive-style estimate (outer draw included; cf. Foster et al. 2019). The |
| density-mechanism EIG counts the density measurements only (0 when no density is measured; a lower bound when |
| magnetics are measured on a body of unknown density, which also carries density information). The midpoint |
| uses max(low, 0), since a negative lower estimate is small-sample bias. p_identify is bracketed the same way; |
| expected posterior weights come from the outer-draw-included estimator. Also: the |
| expected posterior mechanism weights, the probability that the MAP mechanism is the generating one, and the |
| expected change of the predictive sd of ln Hci at `target` (a route; default the first measurement's).""" |
| out = [] |
| for ci, cand in enumerate(candidates): |
| out.append(self._eig_one_v31(cand, n_outer, n_inner_per_mechanism, |
| np.random.default_rng(seed + 7919 * (ci + 1)), target)) |
| for d in out: |
| d["ln_Hci_sd_reduction_target"] = d["ln_Hci_sd_target_now"] - d["ln_Hci_sd_target_expected_after"] |
| orderings = {key: [d["name"] for d in sorted(out, key=lambda d: -d[key])] |
| for key in ("eig_magnetic_mechanism_nats", "eig_density_mechanism_nats", "eig_all_parameters_nats", |
| "ln_Hci_sd_reduction_target")} |
| out.sort(key=lambda d: (-d["eig_magnetic_mechanism_nats"], -d["eig_all_parameters_nats"])) |
| for i, d in enumerate(out): |
| d["rank"] = i + 1 |
| return self._stamp({"ranking": out, "ranking_rule": "primary: EIG on the magnetic mechanism indicator " |
| "(bracket midpoint); tie-break: EIG on all parameters; see orderings for every metric", |
| "orderings": orderings, |
| "all_converged": bool(all(d["eig_magnetic_mechanism_converged"] |
| and d["eig_density_mechanism_converged"] for d in out)), |
| "method": "nested Monte Carlo, stratified inner sets per magnetic mechanism; mechanism " |
| "EIG bracketed by excluding / including the outer draw in its stratum; Gaussian " |
| "measurement models in log space (Student-t(5) for density); per-body specimen " |
| "effects integrated; H0 discrepancy direction, new-preparation effects and " |
| "degas state shared across routes within a draw"}) |
|
|
| def _eig_one_v31(self, cand, n_outer, n_per, rng, target, chunk=6000): |
| meas = cand["measurements"] |
| tgt = target or meas[0]["route"] |
| dl_o, di_o = self._assign_bma("density", n_outer, rng) |
| ml_o, mi_o = self._assign_bma("magnetic", n_outer, rng) |
| ml_i, mi_i = self._assign_strata("magnetic", n_per, rng) |
| n_inner = len(ml_i) |
| dl_i, di_i = self._assign_bma("density", n_inner, rng) |
| dlab, didx = np.concatenate([dl_o, dl_i]), np.concatenate([di_o, di_i]) |
| mlab, midx = np.concatenate([ml_o, ml_i]), np.concatenate([mi_o, mi_i]) |
| ind = {k: self._assign_indicator(k, mlab, midx, rng) for k in self._indicators()} |
| rows = self._latents(meas, tgt, dlab, didx, mlab, midx, rng, indicators=ind) |
| o = slice(0, n_outer) |
| H_SD = H_MEASUREMENT_LOG_SD |
| |
| terms, own, own_d = [], np.zeros(n_outer), np.zeros(n_outer) |
| for j, mm in enumerate(meas): |
| R = rows[j] |
| q = set(mm.get("quantities", ["Hci", "Br", "sq"])) |
| reps = int(mm.get("replicates", 1)) |
| if "density" in q and not R["rho_known"]: |
| y = R["mu_rho"][o] + R["sig_rho"][o] * rng.standard_t(5.0, n_outer) |
| terms.append((_t_logpdf, y, R["mu_rho"][n_outer:], R["sig_rho"][n_outer:], True)) |
| own += _t_logpdf(y, R["mu_rho"][o], R["sig_rho"][o]) |
| own_d += _t_logpdf(y, R["mu_rho"][o], R["sig_rho"][o]) |
| spec = [] |
| if "Hci" in q: |
| spec.append(("lh", np.sqrt(R["sig_spec"] ** 2 + R["sig_piece"] ** 2 / reps))) |
| if "Br" in q: |
| spec.append(("lbr", R["sig_Br"] / math.sqrt(reps))) |
| if "sq" in q: |
| spec.append(("sq", R["sig_sq"] / math.sqrt(reps))) |
| if "grain" in q: |
| spec.append(("lgrain", np.full(len(R["lh"]), 0.15))) |
| if "H_ppm" in q: |
| spec.append(("lh_res", np.full(len(R["lh"]), H_SD))) |
| if "Hci_ratio_T" in q: |
| spec.append(("lratioT", np.sqrt(2.0 * R["sig_piece"] ** 2 / reps + (R["lratioT_g"] * R["sig_spec"]) ** 2))) |
| ys = {} |
| for key, sd in spec: |
| if key == "lratioT" and "lh" in ys: |
| |
| |
| |
| v1 = R["sig_spec"] ** 2 + R["sig_piece"] ** 2 / reps |
| cov = R["lratioT_g"] * R["sig_spec"] ** 2 - R["sig_piece"] ** 2 / reps |
| cslope = cov / v1 |
| sdc = np.sqrt(np.maximum(sd ** 2 - cov ** 2 / v1, 1e-12)) |
| y1 = ys["lh"] |
| y = R[key][o] + cslope[o] * (y1 - R["lh"][o]) + sdc[o] * rng.standard_normal(n_outer) |
| terms.append((_n_logpdf, y, R[key][n_outer:], sdc[n_outer:], False, |
| (y1, R["lh"][n_outer:], cslope[n_outer:]))) |
| own += _n_logpdf(y, R[key][o] + cslope[o] * (y1 - R["lh"][o]), sdc[o]) |
| continue |
| y = R[key][o] + sd[o] * rng.standard_normal(n_outer) |
| ys[key] = y |
| terms.append((_n_logpdf, y, R[key][n_outer:], sd[n_outer:], False)) |
| own += _n_logpdf(y, R[key][o], sd[o]) |
| res = {"name": cand.get("name", ""), "measurements": meas, "cost": cand.get("cost"), |
| "n_outer": n_outer, "n_inner_per_magnetic_mechanism": n_per} |
| kinds = {} |
| for kind, lab_o, lab_i in (("magnetic", ml_o, ml_i), ("density", dl_o, dl_i)): |
| mechs = [m for m in self._mechs(kind) if self.w[kind][m] > 0] |
| w = np.array([self.w[kind][m] for m in mechs]) |
| kinds[kind] = (mechs, w / w.sum(), lab_o, lab_i, np.full((n_outer, len(mechs)), -np.inf)) |
| |
| T = rows[-1] |
| wbase = np.array([self.w["magnetic"][m] / (ml_i == m).sum() for m in ml_i]) |
| tgt_inner = T["lh"][n_outer:] |
| M = np.full(n_outer, -np.inf) |
| S0, S1, S2, Sq = (np.zeros(n_outer) for _ in range(4)) |
| for c0 in range(0, n_inner, chunk): |
| c1 = min(n_inner, c0 + chunk) |
| ll = np.zeros((n_outer, c1 - c0)) |
| ll_d = np.zeros((n_outer, c1 - c0)) |
| for tm in terms: |
| f, y, mu, sd, is_density = tm[:5] |
| if len(tm) > 5: |
| y1, mu1, cs = tm[5] |
| mu_eff = mu[None, c0:c1] + cs[None, c0:c1] * (y1[:, None] - mu1[None, c0:c1]) |
| term = f(y[:, None], mu_eff, sd[None, c0:c1]) |
| else: |
| term = f(y[:, None], mu[None, c0:c1], sd[None, c0:c1]) |
| ll += term |
| if is_density: |
| ll_d += term |
| for kind, (mechs, w, lab_o, lab_i, acc) in kinds.items(): |
| lab = lab_i[c0:c1] |
| src = ll if kind == "magnetic" else ll_d |
| for k, m in enumerate(mechs): |
| cols = lab == m |
| if cols.any(): |
| acc[:, k] = np.logaddexp(acc[:, k], _lse(src[:, cols], 1)) |
| lw = ll + np.log(wbase[c0:c1])[None, :] |
| cmax = np.max(lw, 1) |
| newM = np.maximum(M, cmax) |
| scale = np.exp(np.where(np.isfinite(M), M - newM, -np.inf)) |
| ew = np.exp(lw - newM[:, None]) |
| tt = tgt_inner[c0:c1] |
| S0 = S0 * scale + ew.sum(1) |
| S1 = S1 * scale + ew @ tt |
| S2 = S2 * scale + ew @ (tt ** 2) |
| Sq = Sq * scale ** 2 + (ew ** 2).sum(1) |
| M = newM |
| lpy_mag = None |
| has_density = any(term[4] for term in terms) |
| for kind, (mechs, w, lab_o, lab_i, acc) in kinds.items(): |
| idx = np.array([mechs.index(l) for l in lab_o]) |
| own_k = own if kind == "magnetic" else own_d |
| est = {} |
| for include_own in (False, True): |
| logp = np.empty((n_outer, len(mechs))) |
| for k, m in enumerate(mechs): |
| n_m = int((lab_i == m).sum()) |
| mine = lab_o == m |
| if include_own: |
| logp[:, k] = (np.where(mine, np.logaddexp(acc[:, k], own_k), acc[:, k]) |
| - np.log(np.maximum(n_m + mine, 1))) |
| else: |
| logp[:, k] = acc[:, k] - math.log(max(n_m, 1)) |
| lpy = _lse(logp + np.log(w)[None, :], 1) |
| contrib = logp[np.arange(n_outer), idx] - lpy |
| ok = np.isfinite(contrib) |
| n_ok = max(int(ok.sum()), 2) |
| post = np.exp(logp + np.log(w)[None, :] - lpy[:, None]) |
| pid = float(np.mean((np.argmax(post, 1) == idx)[ok])) if ok.any() else float("nan") |
| est[include_own] = (float(contrib[ok].mean()) if ok.any() else float("nan"), |
| float(contrib[ok].std(ddof=1) / math.sqrt(n_ok)) if ok.sum() > 1 else float("nan"), |
| post, lpy, pid, int((~ok).sum())) |
| lo, hi = est[False][0], est[True][0] |
| se = max(est[False][1], est[True][1]) |
| pid_lo, pid_hi = est[False][4], est[True][4] |
| if kind == "density" and not has_density: |
| lo = hi = se = 0.0 |
| |
| res[f"eig_{kind}_mechanism_nats"] = 0.5 * (max(lo, 0.0) + hi) |
| res[f"eig_{kind}_mechanism_bracket"] = [lo, hi] |
| res[f"eig_{kind}_mechanism_se"] = se |
| res[f"eig_{kind}_mechanism_converged"] = bool(abs(hi - lo) <= max(0.05, 2 * se)) |
| res[f"n_nonfinite_outer_{kind}"] = max(est[False][5], est[True][5]) |
| post = est[True][2] |
| res[f"expected_posterior_{kind}_weights"] = {m: float(post[:, k].mean()) for k, m in enumerate(mechs)} |
| res[f"p_identify_{kind}_mechanism_map"] = 0.5 * (pid_lo + pid_hi) |
| res[f"p_identify_{kind}_mechanism_bracket"] = [pid_lo, pid_hi] |
| if kind == "magnetic": |
| lpy_mag = est[True][3] |
| contrib = own - lpy_mag |
| res["eig_all_parameters_nats"] = float(contrib.mean()) |
| res["eig_all_parameters_se"] = float(contrib.std(ddof=1) / math.sqrt(n_outer)) |
| w0 = wbase / wbase.sum() |
| now_var = float(w0 @ tgt_inner ** 2 - (w0 @ tgt_inner) ** 2) |
| spec_var = float(w0 @ T["sig_spec"][n_outer:] ** 2) |
| m1, m2 = S1 / S0, S2 / S0 |
| res["target_route"] = tgt |
| res["ln_Hci_sd_target_now"] = math.sqrt(now_var + spec_var) |
| res["ln_Hci_sd_target_expected_after"] = float(np.mean(np.sqrt(np.maximum(m2 - m1 ** 2, 0) + spec_var))) |
| res["ess_inner_median"] = float(np.median(S0 ** 2 / Sq)) |
| return res |
|
|
| |
| def eig(self, candidates, n_outer=1500, n_inner_per_mechanism=None, seed=0, target=None, goal=None, |
| method="v4"): |
| """Rank candidate measurements by expected information gain (nats); see the eig section of the README. |
| candidates: list of {"name": str, "measurements": [ {"route": {...}, "rho_observed": optional, |
| "quantities": ["Hci","Br","sq","density","grain","H_ppm","Hci_ratio_T"], "replicates": 1, |
| "T2_C": 120 (only for Hci_ratio_T)} ]}; each measurement is one body. |
| For every per-draw discrete indicator the model carries (self.w: magnetic and density mechanisms, and any |
| other, e.g. load timing) the EIG is bracketed by two estimates from the same simulated experiments: |
| lower: a Barber-Agakov bound, H(prior weights) + E[log q(true label | y)], where q pools the exact nested |
| posterior over an inner set of stored draws that shares no stored draw with the simulated experiment |
| (weight rising with its effective sample size) with a classifier trained on simulated experiments |
| from the other half of the stored draws (cross-fitted), mixed with the prior at EIG_EPS. It is a |
| lower bound on the EIG in expectation whatever the quality of q; |
| upper: the nested estimate with the generating draw included in its own stratum (as in v3.1, biased high |
| when the stored draws cannot resolve the design). |
| The value (`*_nats`) is max(lower, 0): the design gains at least this much information about the indicator. |
| `*_lower_bound_stable` (= `*_converged`): the two halves (independent simulated experiments, each scored by a |
| classifier trained on the other half's stored draws) agree within 2 combined SE. `*_bracket_closed`: upper - |
| lower <= max(0.05, 2 SE), so the value is the EIG itself (single-body designs); for multi-body designs the |
| upper end stays loose because the stored posterior holds about 2,000 draws per mechanism. |
| goal: optional {"route": {...}, "spec": {...p_meets_spec keys...}, "rho_observed": optional} adds the |
| information about reaching the spec at that route (see `_eig_goal`). |
| method="nmc-v3.1" runs the v3.1-r3 estimator unchanged (no goal, magnetic and density only).""" |
| if method == "nmc-v3.1": |
| if goal is not None: |
| raise ValueError("goal needs method='v4'") |
| extra = self._eig_indicator_names()[1] |
| if extra: |
| raise ValueError(f"method='nmc-v3.1' predates per-draw indicators beyond the mechanisms ({extra}); " |
| "use method='v4'") |
| return self._eig_v31(candidates, n_outer, n_inner_per_mechanism or 6000, seed, target) |
| n_inner_per_mechanism = n_inner_per_mechanism or 4000 |
| if method != "v4": |
| raise ValueError("method must be 'v4' (default) or 'nmc-v3.1' (the v3.1-r3 estimator, for comparison)") |
| if not candidates: |
| raise ValueError("eig needs at least one candidate") |
| goal = self._eig_goal_parse(goal) if goal is not None else None |
| out = [self._eig_one(cand, n_outer, n_inner_per_mechanism, np.random.default_rng(seed + 7919 * (ci + 1)), |
| target, goal) for ci, cand in enumerate(candidates)] |
| names = list(out[0]["eig_indicators"]) |
| keys = [self._eig_key(n) + "_nats" for n in names] + ["eig_all_parameters_nats", "ln_Hci_sd_reduction_target"] |
| if goal is not None: |
| keys += ["eig_goal_event_nats", "goal_p_success_sd_reduction"] |
| orderings = {k: [d["name"] for d in sorted(out, key=lambda d, k=k: -d[k])] for k in keys} |
| out.sort(key=lambda d: (-d["eig_magnetic_mechanism_nats"], -d["eig_all_parameters_nats"])) |
| for i, d in enumerate(out): |
| d["rank"] = i + 1 |
| return self._stamp({ |
| "ranking": out, "orderings": orderings, "indicators": names, |
| "ranking_rule": "primary: EIG on the magnetic mechanism indicator; tie-break: EIG on all parameters; see " |
| "orderings for every metric", |
| "all_converged": bool(all(d["eig_indicators"][n]["lower_bound_stable"] for d in out for n in names)), |
| "converged_rule": "value = the nested estimate H(prior) - E[H(posterior)], clipped into [lower bound, " |
| "upper], when the bracket is closed, " |
| "else max(lower bound, 0); lower_bound_stable (= converged, and all_converged over " |
| "every indicator and candidate): the two independent halves agree within 2 combined SE; " |
| "bracket_closed: upper - lower <= max(0.05 nats, 2 SE), i.e. the value is the EIG itself; " |
| "rank differences smaller than about 3 lower-bound SE are not resolved", |
| "method": EIG_METHOD_V4 + ": simulated experiments from the stored posterior draws (two halves by stored-" |
| "draw parity); exact likelihoods of each simulated experiment under an inner set that excludes " |
| "its own stored draws (Gaussian measurement models in log space, Student-t(5) for density, " |
| "per-body specimen effects integrated; new-preparation effects, degas state, H0 discrepancy " |
| "direction and conditional indicators shared across routes within a draw); per indicator a " |
| "Barber-Agakov lower bound with the pooled posterior (exact nested posterior where its effective " |
| "sample size allows, cross-fitted classifier elsewhere) and the outer-draw-included nested " |
| "estimate as the upper end"}) |
|
|
| @staticmethod |
| def _eig_key(name): |
| return f"eig_{name}_mechanism" if name in ("magnetic", "density") else f"eig_{name}" |
|
|
| def _eig_indicator_names(self): |
| """(base, conditional) indicators. Base: every positive-weight label has stored parameter arrays (magnetic, |
| density); eig assigns them. Conditional: labels drawn per magnetic draw by self._assign_indicator.""" |
| base, cond = [], [] |
| for name, wd in self.w.items(): |
| labs = [l for l, v in wd.items() if v > 0] |
| (base if labs and all(l in self.post for l in labs) else cond).append(name) |
| if "magnetic" not in base or "density" not in base: |
| raise ValueError("eig needs the magnetic and density indicators with stored draws") |
| base.sort(key=lambda n: (n != "magnetic", n != "density", n)) |
| return base, cond |
|
|
| def _eig_labels(self, name): |
| return [l for l, v in self.w[name].items() if v > 0] |
|
|
| def _eig_draws(self, n, rng, balanced): |
| """n joint draws. Base indicators: labels in equal shares (balanced, the inner set) or in proportion to the |
| weights (the simulated experiments), each carrying the log importance weight log(w / share); stored indices by |
| systematic resampling on the per-draw weights, restricted to one parity ("fold") per joint draw so the two |
| halves share no stored draw. Conditional indicators: self._assign_indicator(name, mlab, midx, rng).""" |
| base, cond = self._eig_indicator_names() |
| fold = rng.permutation(np.arange(n) % 2) |
| D = {"n": n, "fold": fold, "lab": {}, "idx": {}, "logw_own": {}, "logw": np.zeros(n)} |
| for name in base: |
| labs = self._eig_labels(name) |
| w = np.array([self.w[name][l] for l in labs], float) |
| w = w / w.sum() |
| cnt = _alloc(w, n, balanced) |
| code = np.repeat(np.arange(len(labs)), cnt)[rng.permutation(n)] |
| lw = np.log(w)[code] - np.log(np.maximum(cnt, 1) / n)[code] |
| idx = np.zeros(n, int) |
| for k, l in enumerate(labs): |
| K = len(next(iter(self.post[l].values()))) |
| for f in (0, 1): |
| pos = np.where((code == k) & (fold == f))[0] |
| if not len(pos): |
| continue |
| cand = np.arange(f, K, 2) if K > 1 else np.arange(K) |
| p = np.asarray(self.dw[l], float)[cand] |
| p = p if p.sum() > 0 else np.ones(len(cand)) |
| idx[pos] = cand[_systematic(p, len(pos), rng)][rng.permutation(len(pos))] |
| D["lab"][name], D["idx"][name], D["logw_own"][name] = np.array(labs)[code], idx, lw |
| D["logw"] = D["logw"] + lw |
| for name in cond: |
| D["lab"][name] = np.asarray(self._assign_indicator(name, D["lab"]["magnetic"], D["idx"]["magnetic"], rng) |
| ).astype(str) |
| D["logw_own"][name] = np.zeros(n) |
| return D |
|
|
| @staticmethod |
| def _eig_cat(A, B): |
| cat = lambda a, b: np.concatenate([a, b]) |
| return {"n": A["n"] + B["n"], "fold": cat(A["fold"], B["fold"]), "logw": cat(A["logw"], B["logw"]), |
| "lab": {k: cat(A["lab"][k], B["lab"][k]) for k in A["lab"]}, |
| "idx": {k: cat(A["idx"][k], B["idx"][k]) for k in A["idx"]}, |
| "logw_own": {k: cat(A["logw_own"][k], B["logw_own"][k]) for k in A["logw_own"]}} |
|
|
| def _eig_measurements(self, cand): |
| meas = cand.get("measurements") if isinstance(cand, dict) else None |
| if not meas: |
| raise ValueError("each candidate needs a non-empty 'measurements' list") |
| out = [] |
| for mm in meas: |
| q = list(mm.get("quantities", ["Hci", "Br", "sq"])) |
| bad = [x for x in q if x not in EIG_QUANTITIES] |
| if bad or not q: |
| raise ValueError(f"unknown or empty quantities {bad}; allowed: {list(EIG_QUANTITIES)}") |
| reps = mm.get("replicates", 1) |
| if not (_is_number(reps) and int(reps) == reps and reps >= 1): |
| raise ValueError("replicates must be a positive integer") |
| r = self._route(mm["route"]) |
| if abs(float(r["T_measure_C"]) - 20.0) > 1e-9 and set(q) & {"Hci", "Br", "sq", "Hci_ratio_T"}: |
| raise ValueError("eig models Hci, Br and Hk/Hci measured at 20 C: a route with T_measure_C != 20 is " |
| "not supported for these quantities; measure the hot loop with Hci_ratio_T and T2_C") |
| out.append(dict(mm, quantities=q, replicates=int(reps))) |
| return out |
|
|
| def _eig_latents(self, meas, extra_routes, D, rng): |
| """Latent rows for the draws in D, one row per distinct (route, rho_observed); shared within a draw across |
| routes: new-preparation effects, the degas state of each preparation, H0's discrepancy direction and the |
| conditional indicators. Hci_ratio_T hooks are per measurement (as in v3.1).""" |
| n = D["n"] |
| mlab, midx = D["lab"]["magnetic"], D["idx"]["magnetic"] |
| dlab, didx = D["lab"]["density"], D["idx"]["density"] |
| cond = self._eig_indicator_names()[1] |
| kw = {"indicators": {k: D["lab"][k] for k in cond}} if cond else {} |
| z_hull = rng.standard_normal(n) |
| prep_z, degas, eps, prep_dc, prep_fd = {}, {}, {}, {}, {} |
| extra = None |
| rows, rkey, mrow, xrow, ratio, rres = [], {}, [], [], {}, [] |
| items = [(mm["route"], mm.get("rho_observed")) for mm in meas] + [(rt, None) for rt in extra_routes] |
| for j, (route, ro) in enumerate(items): |
| r = self._route(route) |
| key = json.dumps([r, ro], sort_keys=True, default=str) |
| if key not in rkey: |
| dc = json.dumps(r["degas_completeness"], sort_keys=True, default=str) |
| if prep_dc.setdefault(r["prep"], dc) != dc: |
| raise ValueError(f"routes sharing preparation {r['prep']!r} must share degas_completeness") |
| _check_prep_feedstock(prep_fd, r) |
| r["_degas_expected"] = self._expected_state(r) |
| A = self._arrays(r) |
| if r["prep"] not in prep_z: |
| prep_z[r["prep"]] = rng.standard_normal((n, 1)) |
| u = rng.random(n) |
| if not self._completeness_is_default(r) and extra is None: |
| extra = rng.spawn(1)[0] |
| degas[r["prep"]], eps[r["prep"]] = self._degas_state(r, u, extra) |
| mu, sig = self._density_mean(A, r, dlab, didx, prep_z[r["prep"]]) |
| rho = np.full(n, (ro / RHO_TD if ro > 1.5 else ro)) if ro else np.clip(mu, 0.3, 1.0) |
| lat = self._magnetic_latent(A, r, mlab, midx, rho, degas[r["prep"]], z_hull, eps=eps[r["prep"]], **kw) |
| rkey[key] = len(rows) |
| rows.append(dict(mu_rho=mu, sig_rho=sig, rho_known=ro is not None, **lat)) |
| rres.append(r) |
| (mrow if j < len(meas) else xrow).append(rkey[key]) |
| for j, mm in enumerate(meas): |
| if "Hci_ratio_T" in mm["quantities"]: |
| if extra is None: |
| extra = rng.spawn(1)[0] |
| ratio[j] = self._ln_hci_ratio_T(rows[mrow[j]], float(mm.get("T2_C", 120.0)), extra) |
| return {"rows": rows, "routes": rres, "mrow": mrow, "xrow": xrow, "ratio": ratio, "kw": kw, |
| "nuis": {"z_hull": z_hull, "prep_z": prep_z, "degas": degas, "eps": eps}} |
|
|
| @staticmethod |
| def _eig_obs(meas, L): |
| """Observation models, one entry per measured quantity per body (arrays over all draws): |
| kind "g": Gaussian in log space (mean mu, sd), optionally conditional on the same body's Hci (pair, cs); |
| kind "t": Student-t(5) density. col groups observations of one latent for the summaries.""" |
| obs = [] |
| for j, mm in enumerate(meas): |
| rk = L["mrow"][j] |
| R = L["rows"][rk] |
| q, reps = set(mm["quantities"]), mm["replicates"] |
| if "density" in q and not R["rho_known"]: |
| obs.append(dict(kind="t", mu=R["mu_rho"], sd=R["sig_rho"], pair=-1, cs=None, col=(rk, "density"))) |
| hci = -1 |
| for qn, key, sd in (("Hci", "lh", lambda: np.sqrt(R["sig_spec"] ** 2 + R["sig_piece"] ** 2 / reps)), |
| ("Br", "lbr", lambda: R["sig_Br"] / math.sqrt(reps)), |
| ("sq", "sq", lambda: R["sig_sq"] / math.sqrt(reps)), |
| ("grain", "lgrain", lambda: np.full(len(R["lh"]), 0.15)), |
| ("H_ppm", "lh_res", lambda: np.full(len(R["lh"]), H_MEASUREMENT_LOG_SD))): |
| if qn in q: |
| obs.append(dict(kind="g", mu=R[key], sd=sd(), pair=-1, cs=None, col=(rk, key))) |
| if qn == "Hci": |
| hci = len(obs) - 1 |
| if "Hci_ratio_T" in q: |
| r0, g = L["ratio"][j] |
| sd = np.sqrt(2.0 * R["sig_piece"] ** 2 / reps + (g * R["sig_spec"]) ** 2) |
| if hci >= 0: |
| v1 = R["sig_spec"] ** 2 + R["sig_piece"] ** 2 / reps |
| cov = g * R["sig_spec"] ** 2 - R["sig_piece"] ** 2 / reps |
| obs.append(dict(kind="g", mu=r0, sd=np.sqrt(np.maximum(sd ** 2 - cov ** 2 / v1, 1e-12)), |
| pair=hci, cs=cov / v1, col=("ratio", j))) |
| else: |
| obs.append(dict(kind="g", mu=r0, sd=sd, pair=-1, cs=None, col=("ratio", j))) |
| return obs |
|
|
| @staticmethod |
| def _eig_simulate(obs, sel, rng): |
| n = sel.stop - sel.start |
| Y = np.empty((n, len(obs))) |
| for t, ob in enumerate(obs): |
| mu, sd = ob["mu"][sel], ob["sd"][sel] |
| if ob["kind"] == "t": |
| Y[:, t] = mu + sd * rng.standard_t(5.0, n) |
| elif ob["pair"] >= 0: |
| p = ob["pair"] |
| Y[:, t] = mu + ob["cs"][sel] * (Y[:, p] - obs[p]["mu"][sel]) + sd * rng.standard_normal(n) |
| else: |
| Y[:, t] = mu + sd * rng.standard_normal(n) |
| return Y |
|
|
| @staticmethod |
| def _eig_loglik_own(obs, sel, Y): |
| """Log-likelihood of each simulated outcome under its own draw (the rows of Y align with sel).""" |
| ll = np.zeros(sel.stop - sel.start) |
| for t, ob in enumerate(obs): |
| mu, sd = ob["mu"][sel], ob["sd"][sel] |
| if ob["kind"] == "t": |
| ll += _t_logpdf(Y[:, t], mu, sd) |
| else: |
| m = mu + (ob["cs"][sel] * (Y[:, ob["pair"]] - obs[ob["pair"]]["mu"][sel]) if ob["pair"] >= 0 else 0.0) |
| ll += _n_logpdf(Y[:, t], m, sd) |
| return ll |
|
|
| @staticmethod |
| def _eig_summaries(obs, Y): |
| """Classifier inputs: per latent, the mean of its body observations; where >= 2 bodies, the log sd.""" |
| cols = {} |
| for t, ob in enumerate(obs): |
| cols.setdefault(ob["col"], []).append(t) |
| M = [Y[:, ts].mean(1) for ts in cols.values()] |
| V = [np.log(Y[:, ts].std(1, ddof=1) + 1e-3) for ts in cols.values() if len(ts) >= 2] |
| return np.stack(M + V, 1), len(M) |
|
|
| @staticmethod |
| def _eig_gauss_terms(obs, sp, center): |
| """Gaussian log densities of outcomes under the draws in sp as feat(Y) @ C + c0, where feat(Y) = |
| [Y - c, (Y - c)^2, cross products of conditional pairs] over the Gaussian observations (one matrix product).""" |
| gi = [t for t, ob in enumerate(obs) if ob["kind"] == "g"] |
| pos = {t: k for k, t in enumerate(gi)} |
| pairs = [t for t in gi if obs[t]["pair"] >= 0] |
| G, n = len(gi), sp.stop - sp.start |
| C, c0 = np.zeros((2 * G + len(pairs), n)), np.zeros(n) |
| for k, t in enumerate(gi): |
| ob = obs[t] |
| w = 1.0 / ob["sd"][sp] ** 2 |
| kap = ob["mu"][sp] - center[t] |
| if ob["pair"] >= 0: |
| p, cs = ob["pair"], ob["cs"][sp] |
| kap = kap - cs * (obs[p]["mu"][sp] - center[p]) |
| C[G + pos[p]] += -0.5 * cs * cs * w |
| C[2 * G + pairs.index(t)] += cs * w |
| C[pos[p]] += -cs * kap * w |
| C[k] += kap * w |
| C[G + k] += -0.5 * w |
| c0 += -0.5 * kap * kap * w - np.log(ob["sd"][sp]) - 0.5 * math.log(2 * math.pi) |
|
|
| def feat(Y): |
| Yc = Y[:, gi] - center[gi] |
| cr = [((Y[:, t] - center[t]) * (Y[:, obs[t]["pair"]] - center[obs[t]["pair"]]))[:, None] for t in pairs] |
| return np.concatenate([Yc, Yc ** 2] + cr, 1) |
| return feat, C, c0 |
|
|
| def _eig_nmc(self, obs, YO, sp, keysO, keysP, logwP, H, X, chunk_o=400, chunk_p=4000): |
| """Exact likelihood of every simulated outcome (rows of YO) under every inner draw (sp), leaving out inner |
| draws that share a stored draw with the outcome's own draw (keys). Returns log sums of w f per label column of |
| H, of (w f)^2 per column, of w f over all inner draws, and posterior means of the columns of X.""" |
| no, npool = YO.shape[0], sp.stop - sp.start |
| center = YO.mean(0) |
| feat, C, c0 = self._eig_gauss_terms(obs, sp, center) |
| F = feat(YO) |
| ti = [t for t, ob in enumerate(obs) if ob["kind"] == "t"] |
| tmu = [obs[t]["mu"][sp] for t in ti] |
| tinv = [1.0 / obs[t]["sd"][sp] for t in ti] |
| tc = math.lgamma(3.0) - math.lgamma(2.5) - 0.5 * math.log(5.0 * math.pi) |
| c0 = c0 + sum(tc - np.log(obs[t]["sd"][sp]) for t in ti) |
| L, nx = H.shape[1], X.shape[1] |
| out = {"logS": np.empty((no, L)), "logS2": np.empty((no, L)), "logSall": np.empty(no), |
| "mean_x": np.empty((no, nx))} |
| |
| |
| mo, mp, mv = [], [], [] |
| with np.errstate(divide="ignore", invalid="ignore", over="ignore"): |
| for o0 in range(0, no, chunk_o): |
| os_ = slice(o0, min(no, o0 + chunk_o)) |
| m = os_.stop - os_.start |
| M = np.full(m, -np.inf) |
| S, S2, SX, Sall = np.zeros((m, L)), np.zeros((m, L)), np.zeros((m, nx)), np.zeros(m) |
| for p0 in range(0, npool, chunk_p): |
| ps = slice(p0, min(npool, p0 + chunk_p)) |
| ll = F[os_] @ C[:, ps] + c0[ps] |
| for k, t in enumerate(ti): |
| z = (YO[os_, t][:, None] - tmu[k][ps][None]) * tinv[k][ps][None] |
| z *= z |
| z *= 0.2 |
| ll -= 3.0 * np.log1p(z) |
| mask = np.zeros(ll.shape, bool) |
| for kO, kP in zip(keysO, keysP): |
| mask |= kO[os_][:, None] == kP[ps][None, :] |
| r_, c_ = np.nonzero(mask) |
| if len(r_): |
| mo.append(r_ + o0) |
| mp.append(c_ + p0) |
| mv.append(ll[r_, c_] + logwP[ps][c_]) |
| ll[mask] = -np.inf |
| ll += logwP[ps][None] |
| newM = np.maximum(M, ll.max(1)) |
| shift = np.where(np.isfinite(newM), newM, 0.0) |
| sc = np.where(np.isfinite(M), np.exp(M - shift), 0.0) |
| E = np.exp(ll - shift[:, None]) |
| S = S * sc[:, None] + E @ H[ps] |
| S2 = S2 * (sc * sc)[:, None] + (E * E) @ H[ps] |
| SX = SX * sc[:, None] + E @ X[ps] |
| Sall = Sall * sc + E.sum(1) |
| M = newM |
| out["logS"][os_] = np.log(S) + M[:, None] |
| out["logS2"][os_] = np.log(S2) + 2 * M[:, None] |
| out["logSall"][os_] = np.log(Sall) + M |
| out["mean_x"][os_] = SX / Sall[:, None] |
| logSm, logSm_all = np.full((no, L), -np.inf), np.full(no, -np.inf) |
| if mo: |
| mo, mp, mv = np.concatenate(mo), np.concatenate(mp), np.concatenate(mv) |
| np.logaddexp.at(logSm_all, mo, mv) |
| Hb = H[mp] > 0 |
| for j in range(L): |
| sel = Hb[:, j] |
| np.logaddexp.at(logSm[:, j], mo[sel], mv[sel]) |
| out["logS_copies"], out["logSall_copies"] = logSm, logSm_all |
| return out |
|
|
| def _eig_structural_zero(self, name, meas, extra_routes, rng_seed): |
| """True when no measured quantity depends on the indicator: latents recomputed for 64 draws with only this |
| indicator's labels (and, for a base indicator, its stored draw) changed are identical.""" |
| D = self._eig_draws(64, np.random.default_rng(rng_seed), balanced=True) |
| labs = self._eig_labels(name) |
| if len(labs) < 2: |
| return True |
| D2 = {**D, "lab": dict(D["lab"]), "idx": dict(D["idx"])} |
| new = np.array([labs[(labs.index(l) + 1) % len(labs)] for l in D["lab"][name]]) |
| D2["lab"][name] = new |
| if name in D["idx"]: |
| r = np.random.default_rng(rng_seed + 1) |
| D2["idx"][name] = np.array([r.integers(len(next(iter(self.post[l].values())))) for l in new]) |
| o1 = self._eig_obs(meas, self._eig_latents(meas, extra_routes, D, np.random.default_rng(rng_seed + 2))) |
| o2 = self._eig_obs(meas, self._eig_latents(meas, extra_routes, D2, np.random.default_rng(rng_seed + 2))) |
| return all(np.array_equal(a["mu"], b["mu"]) and np.array_equal(a["sd"], b["sd"]) for a, b in zip(o1, o2)) |
|
|
| def _eig_one(self, cand, n_outer, n_per, rng, target, goal=None): |
| meas = self._eig_measurements(cand) |
| tgt = target or meas[0]["route"] |
| base, cond = self._eig_indicator_names() |
| names = base + cond |
| n_mag = len(self._eig_labels("magnetic")) |
| N, n_outer = max(4, int(n_per)) * n_mag, max(40, int(n_outer)) |
| extra_routes = [tgt] + ([goal["route"]] if goal is not None else []) |
| zero = {nm: self._eig_structural_zero(nm, meas, extra_routes, int(rng.integers(2 ** 31))) for nm in names} |
| DP, DO = self._eig_draws(N, rng, balanced=True), self._eig_draws(n_outer, rng, balanced=False) |
| D = self._eig_cat(DP, DO) |
| L = self._eig_latents(meas, extra_routes, D, rng) |
| obs = self._eig_obs(meas, L) |
| sp, so = slice(0, N), slice(N, N + n_outer) |
| YO, YP = self._eig_simulate(obs, so, rng), self._eig_simulate(obs, sp, rng) |
| own = self._eig_loglik_own(obs, so, YO) |
| |
| cols, H = {}, [] |
| for nm in names: |
| labs = self._eig_labels(nm) |
| start = sum(h.shape[1] for h in H) |
| H.append((D["lab"][nm][sp][:, None] == np.array(labs)[None, :]).astype(float)) |
| cols[nm] = list(range(start, start + len(labs))) |
| H = np.concatenate(H, 1) |
| keys = [] |
| for nm in base: |
| labs = self._eig_labels(nm) |
| code = np.array([labs.index(l) for l in D["lab"][nm]], np.int64) |
| keys.append(code * 10 ** 7 + D["idx"][nm]) |
| T = L["rows"][L["xrow"][0]] |
| X = [T["lh"][sp]] |
| gp = None |
| if goal is not None: |
| kb = np.concatenate([np.full(N, GOAL_BODIES_POOL), np.full(n_outer, GOAL_BODIES_OUTER)]) |
| gp = self._eig_goal_success(goal, L, D, kb, rng) |
| X.append(gp["p"][sp]) |
| X = np.stack(X, 1) |
| nm_ = self._eig_nmc(obs, YO, sp, [k[so] for k in keys], [k[sp] for k in keys], D["logw"][sp], H, X) |
| ess = np.exp(2 * nm_["logSall"] - _lse(nm_["logS2"][:, cols["magnetic"]], 1)) |
| lo_, hi_ = (math.log(v) for v in EIG_ESS_POOL) |
| lam = np.clip((np.log(np.maximum(ess, 1e-300)) - lo_) / (hi_ - lo_), 0.0, 1.0) |
| (ZP, nq), (ZO, _) = self._eig_summaries(obs, YP), self._eig_summaries(obs, YO) |
| fP, fO = DP["fold"], DO["fold"] |
| res = {"name": cand.get("name", ""), "measurements": cand["measurements"], "cost": cand.get("cost"), |
| "n_outer": n_outer, "n_inner_per_magnetic_mechanism": int(N // n_mag), "n_inner": N, |
| "eig_indicators": {}} |
| ar = np.arange(n_outer) |
| wpool = np.exp(DP["logw"] - DP["logw"].max()) |
| for nm in names: |
| labs = self._eig_labels(nm) |
| w = np.array([self.w[nm][l] for l in labs], float) |
| if nm in cond: |
| w = np.array([wpool[DP["lab"][nm] == l].sum() for l in labs]) + 1e-12 |
| w = w / w.sum() |
| HM = float(-(w * np.log(w)).sum()) |
| y = np.array([labs.index(l) for l in DO["lab"][nm]]) |
| r = {"labels": labs, "prior_weights": dict(zip(labs, w.tolist())), "prior_entropy_nats": HM} |
| if zero[nm]: |
| r.update(stored_draw_bracket=[0.0, 0.0], stored_draw_se=0.0, stored_draw_closed=True, stored_draw_nats=0.0) |
| r.update(lower_bound_source="structural zero", lower_pooled=0.0) |
| r.update(nats=0.0, value_se=0.0, value_kind="structural zero", nested_estimate=0.0, |
| nested_estimate_se=0.0, lower=0.0, upper=0.0, se=0.0, lower_bound_halves=[0.0, 0.0], |
| lower_bound_stable=True, |
| bracket_closed=True, converged=True, structural_zero=True, lower_nested=0.0, |
| lower_classifier=0.0, |
| expected_posterior_weights=dict(zip(labs, w.tolist())), |
| p_identify_map=float(np.mean(np.argmax(w) == y)), p_identify_map_bracket=[ |
| float(np.mean(np.argmax(w) == y))] * 2, n_nonfinite_outer=0) |
| res["eig_indicators"][nm] = r |
| continue |
| lS = nm_["logS"][:, cols[nm]] |
| with np.errstate(divide="ignore", invalid="ignore"): |
| q_nmc = np.exp(lS - nm_["logSall"][:, None]) |
| q_nmc = np.where(np.isfinite(q_nmc), q_nmc, 0.0) |
| q_clf = np.empty((n_outer, len(labs))) |
| sw = np.exp(DP["logw"] - DP["logw_own"][nm]) |
| yP = np.array([labs.index(l) for l in DP["lab"][nm]]) |
| for f in (0, 1): |
| tr, ev = fP == f, fO != f |
| if not ev.any(): |
| continue |
| Tt = np.eye(len(labs))[yP[tr]] |
| clf = _Softmax(ZP[tr], Tt, sw[tr], nq) |
| prior_tr = np.maximum((Tt * sw[tr][:, None]).sum(0) / sw[tr].sum(), 1e-12) |
| lp = clf.log_prob(ZO[ev]) + np.log(w)[None] - np.log(prior_tr)[None] |
| q_clf[ev] = np.exp(lp - _lse(lp, 1)[:, None]) |
| qp = (1 - EIG_EPS) * (lam[:, None] * q_nmc + (1 - lam[:, None]) * q_clf) + EIG_EPS * w[None] |
| qn = (1 - EIG_EPS) * q_nmc + EIG_EPS * w[None] |
| qc = (1 - EIG_EPS) * q_clf + EIG_EPS * w[None] |
| |
| |
| |
| cands = {"pooled": qp, "nested": qn, "classifier": qc} |
| lqs = {k: np.log(v[ar, y]) for k, v in cands.items()} |
| bounds = {k: HM + float(v.mean()) for k, v in lqs.items()} |
| src = max(bounds, key=bounds.get) |
| q, lq, lower = cands[src], lqs[src], bounds[src] |
| se = float(lq.std(ddof=1) / math.sqrt(n_outer)) |
| |
| logp = lS - np.log(N * w)[None] |
| logp[ar, y] = np.logaddexp(lS[ar, y], own) - np.log(N * w[y] + 1) |
| lpi = logp + np.log(w)[None] |
| q_in = np.exp(lpi - _lse(lpi, 1)[:, None]) |
| upper = HM + float(np.mean(np.log(np.maximum(q_in[ar, y], 1e-300)))) |
| |
| lSf = np.logaddexp(lS, nm_["logS_copies"][:, cols[nm]]) |
| lq_sd = np.clip(lSf[ar, y] - np.logaddexp(nm_["logSall"], nm_["logSall_copies"]), -50.0, 0.0) |
| sd_lower, sd_se = HM + float(lq_sd.mean()), float(lq_sd.std(ddof=1) / math.sqrt(n_outer)) |
| sd_closed = bool(abs(upper - sd_lower) <= max(0.05, 2 * sd_se)) |
| halves, stable = _eig_halves(lq, fO, HM) |
| closed = bool(abs(upper - lower) <= max(0.05, 2 * se)) |
| |
| |
| ent = -(qn * np.log(qn)).sum(1) |
| nested_val, nested_se = HM - float(ent.mean()), float(ent.std(ddof=1) / math.sqrt(n_outer)) |
| clipped = bool(closed and not (lower <= nested_val <= upper)) |
| r.update(nats=min(max(nested_val, lower), upper) if closed else max(lower, 0.0), |
| value_se=nested_se if closed else se, |
| value_kind=("nested estimate (bracket closed)" + (", clipped to the bracket" if clipped else "")) |
| if closed else "lower bound", value_clipped_to_bracket=clipped, |
| nested_estimate=nested_val, nested_estimate_se=nested_se, |
| lower=lower, upper=upper, se=se, lower_bound_source=src, lower_bound_halves=halves, |
| lower_bound_stable=stable, bracket_closed=closed, |
| converged=stable, structural_zero=False, |
| stored_draw_bracket=[sd_lower, upper], stored_draw_se=sd_se, stored_draw_closed=sd_closed, |
| stored_draw_nats=0.5 * (max(sd_lower, 0.0) + upper) if sd_closed else None, |
| lower_pooled=bounds["pooled"], lower_nested=bounds["nested"], |
| lower_classifier=bounds["classifier"], |
| expected_posterior_weights=dict(zip(labs, q.mean(0).tolist())), |
| p_identify_map=float(np.mean(np.argmax(q, 1) == y)), |
| p_identify_map_bracket=[float(np.mean(np.argmax(q, 1) == y)), |
| float(np.mean(np.argmax(q_in, 1) == y))], |
| n_nonfinite_outer=int((~np.isfinite(lq)).sum())) |
| res["eig_indicators"][nm] = r |
| for nm, r in res["eig_indicators"].items(): |
| k = self._eig_key(nm) |
| res[k + "_nats"], res[k + "_bracket"] = r["nats"], [r["lower"], r["upper"]] |
| res[k + "_se"], res[k + "_converged"] = r["value_se"], r["converged"] |
| res[k + "_lower_bound"], res[k + "_lower_bound_se"] = r["lower"], r["se"] |
| res[k + "_lower_bound_stable"], res[k + "_bracket_closed"] = r["lower_bound_stable"], r["bracket_closed"] |
| res[k + "_value_se"] = r["value_se"] |
| if nm in ("magnetic", "density"): |
| res[f"n_nonfinite_outer_{nm}"] = r["n_nonfinite_outer"] |
| res[f"expected_posterior_{nm}_weights"] = r["expected_posterior_weights"] |
| res[f"p_identify_{nm}_mechanism_map"] = r["p_identify_map"] |
| res[f"p_identify_{nm}_mechanism_bracket"] = r["p_identify_map_bracket"] |
| |
| c = own - (np.logaddexp(own, nm_["logSall"]) - math.log(N + 1)) |
| res["eig_all_parameters_nats"] = float(c.mean()) |
| res["eig_all_parameters_se"] = float(c.std(ddof=1) / math.sqrt(n_outer)) |
| |
| wP = np.exp(DP["logw"] - DP["logw"].max()) |
| wP /= wP.sum() |
| tP, tO = T["lh"][sp], T["lh"][so] |
| spec_var = float(wP @ T["sig_spec"][sp] ** 2) |
| pred = np.empty(n_outer) |
| for f in (0, 1): |
| tr, ev = fP == f, fO != f |
| if ev.any(): |
| pred[ev] = _ridge(ZP[tr], tP[tr], wP[tr], ZO[ev], nq) |
| mean_nmc = np.where(np.isfinite(nm_["mean_x"][:, 0]), nm_["mean_x"][:, 0], pred) |
| pred = lam * mean_nmc + (1 - lam) * pred |
| res["target_route"] = tgt |
| res["ln_Hci_sd_target_now"] = math.sqrt(float(wP @ tP ** 2 - (wP @ tP) ** 2) + spec_var) |
| res["ln_Hci_sd_target_expected_after"] = math.sqrt(float(np.mean((tO - pred) ** 2)) + spec_var) |
| res["ln_Hci_sd_reduction_target"] = res["ln_Hci_sd_target_now"] - res["ln_Hci_sd_target_expected_after"] |
| res["ess_inner_median"] = float(np.median(ess)) |
| res["ess_inner_q10"] = float(np.quantile(ess, 0.10)) |
| res["pooling_weight_nested_mean"] = float(lam.mean()) |
| if goal is not None: |
| res["goal"] = self._eig_goal_summary(goal, gp, nm_["mean_x"][:, 1], lam, ZP, ZO, nq, fP, fO, DP, sp, so) |
| res["eig_goal_event_nats"] = res["goal"]["eig_event_nats"] |
| res["goal_p_success_sd_reduction"] = (res["goal"]["p_success_epistemic_sd_now"] |
| - res["goal"]["p_success_epistemic_sd_expected_after"]) |
| return res |
|
|
| |
| def _eig_goal_parse(self, goal): |
| if not isinstance(goal, dict) or "route" not in goal or "spec" not in goal: |
| raise ValueError('goal needs {"route": {...}, "spec": {...}, "rho_observed": optional}') |
| bad = sorted(set(goal) - {"route", "spec", "rho_observed"}) |
| if bad: |
| raise ValueError(f"unknown goal keys {bad}; allowed: route, spec, rho_observed") |
| spec = dict(_eig_spec_check(dict(goal["spec"]))) |
| route = dict(goal["route"]) |
| if "T_operating_C" in spec: |
| route["T_measure_C"] = float(spec["T_operating_C"]) |
| self._route(route) |
| ro = goal.get("rho_observed") |
| if ro is not None and not (_is_number(ro) and ro > 0): |
| raise ValueError("goal rho_observed must be a positive number (g/cm3 or relative)") |
| return {"route": route, "spec": spec, "rho_observed": ro} |
|
|
| def _eig_goal_success(self, goal, L, D, kb, rng): |
| """p(goal | draw): the fraction of kb[i] simulated bodies made by the goal route that meet the spec, scored as |
| in p_meets_spec (measured values: body density scatter, specimen, piece, Br, squareness and curve-shape scatter; |
| the temperature scenario at T_operating_C), with the draw's parameters and its shared latents (preparation |
| effect, degas state, H0 direction, conditional indicators) held fixed. This is the aleatoric success |
| probability given the draw; its spread over draws is the epistemic uncertainty.""" |
| xi = L["xrow"][-1] |
| R, r = L["rows"][xi], dict(L["routes"][xi]) |
| A = self._arrays(r) |
| rep = np.repeat(np.arange(D["n"]), kb) |
| nb = len(rep) |
| if goal["rho_observed"] is not None: |
| ro = float(goal["rho_observed"]) |
| rho = (ro / RHO_TD if ro > 1.5 else ro) + 0.005 * rng.standard_normal(nb) |
| else: |
| rho = np.clip(R["mu_rho"][rep] + R["sig_rho"][rep] * rng.standard_t(5.0, nb), 0.3, 1.02) |
| nu = L["nuis"] |
| eps = nu["eps"][r["prep"]] |
| kw = {"indicators": {k: v[rep] for k, v in L["kw"]["indicators"].items()}} if L["kw"] else {} |
| u = R["sig_spec"][rep] * rng.standard_normal(nb) |
| lat = self._magnetic_latent(A, r, D["lab"]["magnetic"][rep], D["idx"]["magnetic"][rep], rho, |
| nu["degas"][r["prep"]][rep], nu["z_hull"][rep], u_spec=u, |
| eps=None if eps is None else eps[rep], **kw) |
| hci = np.exp(lat["lh"]) * np.exp(lat["sig_piece"] * rng.standard_normal(nb)) |
| br = np.exp(lat["lbr"] + lat["sig_Br"] * rng.standard_normal(nb)) |
| sq = 1.0 / (1.0 + np.exp(-(lat["sq"] + lat["sig_sq"] * rng.standard_normal(nb)))) |
| hci_T, br_T = self._temperature(lat, hci, br, float(r["T_measure_C"]), rng) |
| bh = self._bh(br_T, hci_T, sq, rng) |
| vals = {"Hci_kOe_min": hci_T, "BHmax_MGOe_min": bh, "Br_kGs_min": br_T, "density_rel_min": rho} |
| ok = np.ones(nb, bool) |
| for k, v in vals.items(): |
| if k in goal["spec"]: |
| ok &= np.asarray(v) >= float(goal["spec"][k]) |
| return {"p": np.bincount(rep, weights=ok.astype(float), minlength=D["n"]) / np.asarray(kb, float), |
| "kb": np.asarray(kb)} |
|
|
| def _eig_goal_summary(self, goal, gp, p_nmc, lam, ZP, ZO, nq, fP, fO, DP, sp, so): |
| """Information about reaching the goal. G = 1 if the next body made by the goal route meets the spec. |
| theta = a joint draw (parameters and shared latents). p(theta) = P(G = 1 | theta) is aleatoric (body-to-body |
| and measurement scatter); its spread over the posterior is epistemic and is what an experiment can reduce.""" |
| pP, pO = gp["p"][sp], gp["p"][so] |
| kP, kO = float(GOAL_BODIES_POOL), float(GOAL_BODIES_OUTER) |
| wP = np.exp(DP["logw"] - DP["logw"].max()) |
| wP /= wP.sum() |
| pbar = float(wP @ pP) |
| res = {"route": self._route(goal["route"]), "spec": goal["spec"], "rho_observed": goal["rho_observed"], |
| "p_success_now": pbar, |
| "p_success_now_se": float(math.sqrt(max(wP @ (pP - pbar) ** 2, 1e-30) / max(1.0 / (wP @ wP), 1.0)))} |
| var_now = max(float(wP @ (pP - pbar) ** 2 - wP @ (pP * (1 - pP)) / (kP - 1)), 0.0) |
| H_event = float(_bern_entropy(pbar)) |
| h_ale = _bern_entropy(pO) + np.where((pO > 0) & (pO < 1), 1.0 / (2 * kO), 0.0) |
| aleatoric = float(min(np.mean(np.minimum(h_ale, math.log(2))), H_event)) |
| if pbar <= 1e-12 or pbar >= 1 - 1e-12: |
| res.update(no_draw_meets_spec=bool(pbar <= 1e-12), all_draws_meet_spec=bool(pbar >= 1 - 1e-12), |
| event_entropy_nats=0.0, aleatoric_entropy_nats=0.0, epistemic_entropy_nats=0.0, |
| eig_event_nats=0.0, eig_event_bracket=[0.0, 0.0], eig_event_se=0.0, eig_event_converged=True, |
| eig_event_lower_bound_stable=True, eig_event_bracket_closed=True, |
| p_success_epistemic_sd_now=0.0, p_success_epistemic_sd_expected_after=0.0, |
| expected_posterior_p_success_quantiles={f"q{int(100 * q):02d}": pbar for q in GOAL_QUANTILES}) |
| return res |
| pred = np.empty(len(pO)) |
| for f in (0, 1): |
| tr, ev = fP == f, fO != f |
| if ev.any(): |
| Tt = np.stack([1 - pP[tr], pP[tr]], 1) |
| clf = _Softmax(ZP[tr], Tt, wP[tr], nq) |
| pred[ev] = np.exp(clf.log_prob(ZO[ev])[:, 1]) |
| p_nmc = np.where(np.isfinite(p_nmc), p_nmc, pred) |
| m = (1 - EIG_EPS) * (lam * p_nmc + (1 - lam) * pred) + EIG_EPS * pbar |
| m = np.clip(m, 1e-12, 1 - 1e-12) |
| c = pO * np.log(m) + (1 - pO) * np.log1p(-m) |
| lower = H_event + float(c.mean()) |
| se = float(c.std(ddof=1) / math.sqrt(len(c))) |
| upper = max(H_event - aleatoric, 0.0) |
| halves, stable = _eig_halves(c, fO, H_event) |
| after = max(float(np.mean((pO - m) ** 2) - np.mean(pO * (1 - pO)) / (kO - 1)), 0.0) |
| res.update(no_draw_meets_spec=False, all_draws_meet_spec=False, |
| event_entropy_nats=H_event, aleatoric_entropy_nats=aleatoric, |
| epistemic_entropy_nats=upper, |
| eig_event_nats=max(lower, 0.0), eig_event_bracket=[lower, upper], eig_event_se=se, |
| eig_event_lower_bound_halves=halves, eig_event_lower_bound_stable=stable, |
| eig_event_converged=stable, eig_event_bracket_closed=bool(upper - lower <= max(0.05, 2 * se)), |
| p_success_epistemic_sd_now=math.sqrt(var_now), |
| p_success_epistemic_sd_expected_after=min(math.sqrt(after), math.sqrt(var_now)), |
| expected_posterior_p_success_quantiles={f"q{int(round(100 * q)):02d}": float(np.quantile(m, q)) |
| for q in GOAL_QUANTILES}, |
| expected_posterior_p_success_mean=float(m.mean()), |
| bodies_per_draw={"inner": int(kP), "outer": int(kO)}, |
| definitions="G = 1 if the next body made by the goal route meets every spec key (scored on measured " |
| "values as p_meets_spec). theta = a joint posterior draw (parameters and shared latents); " |
| "p(theta) = P(G = 1 | theta). event_entropy = H(E[p]); aleatoric = E[H(p(theta))] " |
| "(scatter no experiment removes); epistemic = event - aleatoric = I(G; theta), the most " |
| "any experiment can gain about G. eig_event: I(G; y) bracketed by a Barber-Agakov lower " |
| "bound and I(G; theta). p_success_epistemic_sd: sd of p(theta) now and the expected " |
| "posterior sd after the experiment (an upper bound: held-out prediction error). " |
| "expected_posterior_p_success_quantiles: the distribution over simulated outcomes of the " |
| "updated success probability (approximate; shrunk toward the mean where the approximation " |
| "is weak)") |
| return res |
|
|
| |
| def condition(self, observations, k_latent=32, seed=12345): |
| """Importance-reweight the stored draws by new observations; returns (updated model, info). |
| observations: list of {"route": {...}, "rho_observed": optional, "Hci_kOe", "Br_kGs", "Hk_kOe", |
| "density_rel", "grain_um" (each optional)}; each observation is one new body (its own specimen effect). |
| Shared latents are integrated numerically with k_latent samples per draw: new-preparation effects (shared by |
| observations naming the same prep), the degas state per preparation (route["degas"] occurrence probability |
| times route["degas_completeness"]) and H0's discrepancy direction. Mechanism weights are updated by each mechanism's marginal likelihood.""" |
| rng = np.random.default_rng(seed) |
| logw = {m: np.zeros(len(v["sig_rho" if m.startswith("D") else "sig_spec"])) for m, v in self.post.items()} |
| obs = [dict(o, route=self._route(o["route"])) for o in observations] |
| dc_by_prep = {} |
| for o in obs: |
| key = json.dumps(o["route"]["degas_completeness"], sort_keys=True) |
| if dc_by_prep.setdefault(o["route"]["prep"], key) != key: |
| raise ValueError(f"observations sharing preparation {o['route']['prep']!r} must share degas_completeness") |
| fd_by_prep = {} |
| for o in obs: |
| _check_prep_feedstock(fd_by_prep, o["route"], "observations") |
| dens_obs = [o for o in obs if "density_rel" in o] |
| mag_obs = [o for o in obs if any(k in o for k in ("Hci_kOe", "Br_kGs", "Hk_kOe", "grain_um"))] |
| preps = sorted({o["route"]["prep"] for o in obs}) |
| K = k_latent |
| if dens_obs: |
| for m in self._mechs("density"): |
| Kd = len(self.post[m]["lnk"]) |
| zs = {p: rng.standard_normal((Kd, K)) for p in preps} |
| acc = np.zeros((Kd, K)) |
| p = {k: v[:, None] for k, v in self.post[m].items()} |
| for o in dens_obs: |
| y = float(o["density_rel"]) |
| y = y / RHO_TD if y > 1.5 else y |
| A = self._arrays(o["route"]) |
| if o["route"]["prep"] in self.preps: |
| off = p["tau_prep"] * p[f"z_prep_{self.preps.index(o['route']['prep'])}"] |
| mu = self.fw.density(p, m, A, lnk_offset=off, xp=np)[:, 0] |
| acc += _t_logpdf(y, mu, p["sig_rho"][:, 0])[:, None] |
| else: |
| for k in range(K): |
| off = p["tau_prep"] * zs[o["route"]["prep"]][:, k:k + 1] |
| mu = self.fw.density(p, m, A, lnk_offset=off, xp=np)[:, 0] |
| acc[:, k] += _t_logpdf(y, mu, p["sig_rho"][:, 0]) |
| logw[m] += _lme(acc, 1) |
| new_ltp = {} |
| if mag_obs: |
| for o in mag_obs: |
| if o.get("rho_observed", o.get("density_rel")) is None: |
| raise ValueError("a magnetic observation needs the body's measured density: pass rho_observed " |
| "(g/cm3 or relative) or density_rel") |
| for m in self._mechs("magnetic"): |
| Km = len(self.post[m]["sig_spec"]) |
| idx = np.arange(Km) |
| lab = np.array([m] * Km) |
| levels = LT_LEVELS if m in self.ltp else ("load",) |
| acc = {L: np.zeros((Km, K)) for L in levels} |
| zh = rng.standard_normal((Km, K)) if m == "H0" else np.zeros((Km, K)) |
| dz = {p: rng.random((Km, K)) for p in preps} |
| nondefault = [o for o in mag_obs if not self._completeness_is_default(o["route"]) |
| and o["route"]["degas_completeness"] != "complete"] |
| dstate, deps = {}, {} |
| if nondefault: |
| extra = rng.spawn(1)[0] |
| for pr in preps: |
| ro = next((o["route"] for o in mag_obs if o["route"]["prep"] == pr), None) |
| if ro is not None and not self._completeness_is_default(ro) \ |
| and ro["degas_completeness"] != "complete": |
| dstate[pr] = self._sample_completeness(ro["degas_completeness"], (Km, K), extra) |
| deps[pr] = extra.uniform(0.0, 1.0, (Km, K)) |
| for o in mag_obs: |
| r = o["route"] |
| A = self._arrays(r) |
| rho_v = o.get("rho_observed", o.get("density_rel")) |
| rho_v = float(rho_v) / RHO_TD if float(rho_v) > 1.5 else float(rho_v) |
| rho = np.full(Km, rho_v) |
| shared = m == "H0" or 0.0 < float(r["degas"]) < 1.0 or r["prep"] in dstate |
| r = dict(r, _degas_expected=self._expected_state(r)) |
| for k in (range(K) if shared else [0]): |
| degas_ind = (dz[r["prep"]][:, k] < float(r["degas"])).astype(float) |
| e = None |
| if r["prep"] in dstate: |
| degas_ind = degas_ind * dstate[r["prep"]][:, k] |
| e = deps[r["prep"]][:, k] |
| for L in levels: |
| ind = {"load_timing": np.full(Km, L)} if m in self.ltp else None |
| lat = self._magnetic_latent(A, r, lab, idx, rho, degas_ind, zh[:, k], eps=e, indicators=ind) |
| ll = np.zeros(Km) |
| if "Hci_kOe" in o: |
| ll += _n_logpdf(math.log(o["Hci_kOe"]), lat["lh"], |
| np.sqrt(lat["sig_spec"] ** 2 + lat["sig_piece"] ** 2)) |
| if "Br_kGs" in o: |
| ll += _n_logpdf(math.log(o["Br_kGs"]), lat["lbr"], lat["sig_Br"]) |
| if "Hk_kOe" in o and "Hci_kOe" in o and 0 < o["Hk_kOe"] < o["Hci_kOe"]: |
| ratio = o["Hk_kOe"] / o["Hci_kOe"] |
| ll += _n_logpdf(math.log(ratio / (1 - ratio)), lat["sq"], lat["sig_sq"]) |
| if "grain_um" in o: |
| ll += _n_logpdf(math.log(o["grain_um"]), lat["lgrain"], 0.15) |
| if shared: |
| acc[L][:, k] += ll |
| else: |
| acc[L] += ll[:, None] |
| lik = np.stack([_lme(acc[L], 1) for L in levels], 1) |
| if m in self.ltp: |
| lp = np.log(np.maximum(self.ltp[m], 1e-300)) + lik |
| tot = _lse(lp, 1) |
| new_ltp[m] = np.exp(lp - tot[:, None]) |
| logw[m] += tot |
| else: |
| logw[m] += lik[:, 0] |
| new_dw, newW, ess = {}, {}, {} |
| for kind in ("density", "magnetic"): |
| lm = {} |
| for m in self._mechs(kind): |
| base = np.log(self.dw[m] / self.dw[m].sum()) |
| tot = _lse(base + logw[m]) |
| lm[m] = tot |
| wv = np.exp(base + logw[m] - tot) |
| new_dw[m] = wv |
| ess[m] = float(1.0 / np.sum(wv ** 2)) |
| z = _lse(np.array([math.log(max(self.w[kind][m], 1e-300)) + lm[m] for m in self._mechs(kind)])) |
| newW[kind] = {m: math.exp(math.log(max(self.w[kind][m], 1e-300)) + lm[m] - z) for m in self._mechs(kind)} |
| ltp = {m: new_ltp.get(m, v) for m, v in self.ltp.items()} |
| if ltp: |
| tot = np.zeros(len(LT_LEVELS)) |
| for m in self._mechs("magnetic"): |
| tot += newW["magnetic"][m] * (new_dw[m] @ ltp[m]) |
| newW["load_timing"] = {L: float(x) for L, x in zip(LT_LEVELS, tot / tot.sum())} |
| for k in self.w: |
| newW.setdefault(k, dict(self.w[k])) |
| clone = object.__new__(PhysicsModel) |
| clone.__dict__.update(self.__dict__) |
| clone.dw, clone.w, clone.ltp = new_dw, newW, ltp |
| info = {"mechanism_weights": newW, "ess_per_mechanism": ess, |
| "warning": "ESS below ~200 for a mechanism that still carries weight means the stored draws no longer " |
| "represent its posterior; refit owner-side (NumPyro) instead. Shared latents of a new " |
| "preparation are integrated for the reweighting but redrawn in later predictions."} |
| clone.conditioning = {"observations": observations, **info} |
| return clone, info |
|
|
|
|
| _DEFAULT = None |
|
|
|
|
| def _default(): |
| global _DEFAULT |
| if _DEFAULT is None: |
| _DEFAULT = load() |
| return _DEFAULT |
|
|
|
|
| def predict(route, **kw): |
| return _default().predict(route, **kw) |
|
|
|
|
| def p_meets_spec(route, spec, **kw): |
| return _default().p_meets_spec(route, spec, **kw) |
|
|
|
|
| def eig(candidates, **kw): |
| return _default().eig(candidates, **kw) |
|
|
|
|
| def forecast_record(route, **kw): |
| return _default().forecast_record(route, **kw) |
|
|
