| """Physical interpretability of the next-generation backbones. |
| |
| Every architecture is probed on the same held-out trajectories, and each probe |
| is chosen to expose the *physics* the model claims to represent: |
| |
| koopman eigen-spectrum of the linear latent operator -> memory time constants |
| gdn norm of the delta-rule fast-weight matrix -> "memory written at yield" |
| xlstm forget-gate value -> memory horizon vs strain |
| node ||dz/dt|| of the learned vector field -> where the dynamics change |
| rssm prior std of the stochastic latent -> model uncertainty vs strain |
| flow spread of K sampled curves -> predictive interval quality |
| |
| Outputs land in ``results/tables/interpret_*.csv`` and |
| ``results/figures/fig_interpret_*.png``. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
| from typing import Dict, List |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| from .data import (PROC, TARGETS, Normalizer, PackedDataset, build_static_frame, |
| collate) |
| from .models import build_model |
|
|
| ROOT = Path(__file__).resolve().parents[2] |
| RUNS = ROOT / "results" / "runs" |
| TABLES = ROOT / "results" / "tables" |
| FIGS = ROOT / "results" / "figures" |
| EPS = np.linspace(0.0, 0.2, 401) |
|
|
|
|
| def _plt(): |
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| return plt |
|
|
|
|
| def load(tag: str, device="cpu"): |
| import torch |
| d = RUNS / tag |
| ck = torch.load(d / "model.pt", map_location=device, weights_only=False) |
| meta = json.loads((d / "metrics.json").read_text()) |
| cfg = ck["cfg"] |
| m = build_model(cfg["model"], n_static=int(np.sum(ck["keep_mask"])), |
| n_out=len(TARGETS), d_model=cfg["d_model"], |
| n_layers=cfg["n_layers"], d_state=cfg["d_state"], |
| dropout=cfg["dropout"], coupling=cfg["coupling"]).to(device) |
| m.load_state_dict(ck["state"]) |
| m.eval() |
| return m, cfg, meta, ck |
|
|
|
|
| def _loader(tag, meta, ck, device="cpu", batch=2): |
| import torch |
| mtab = pd.read_csv(PROC / "samples_meta.csv") |
| traj = pd.read_csv(PROC / "trajectories.csv") |
| names = ck["names"] |
| km = np.asarray(ck["keep_mask"], dtype=bool) |
| kinds = build_static_frame(mtab)[2] |
| norm = Normalizer.from_json(meta["normalizer"]) |
| ids = [int(s) for s in meta["test_ids"]] |
| ds = PackedDataset(ids, mtab, traj, norm, names, kinds, km) |
| dl = torch.utils.data.DataLoader(ds, batch_size=batch, shuffle=False, |
| collate_fn=collate) |
| return dl, norm, ids |
|
|
|
|
| def _collect_trace(model, dl, device="cpu", per_sample=False) -> np.ndarray: |
| """Run the model with recording enabled; returns (T,) or (T, C) mean trace. |
| |
| Each block appends one entry per timestep (a scalar or a tuple of scalars), |
| already averaged over the batch. Entries of the same block therefore stack |
| to ``(T, C)``; blocks of one architecture share ``C``. |
| """ |
| import torch |
| blocks = list(getattr(model, "blocks", [])) |
| for b in blocks: |
| if hasattr(b, "record"): |
| b.record = True |
| b.trace = [] |
| if hasattr(model, "record"): |
| model.record = True |
| model.trace = [] |
| rows = [] |
| with torch.no_grad(): |
| for st, x, _Y, _M, _s in dl: |
| model(st.to(device), x.to(device)) |
| per = [np.asarray(getattr(b, "trace", [])) for b in blocks |
| if len(getattr(b, "trace", []))] |
| if not per and len(getattr(model, "trace", [])): |
| |
| per = [np.asarray(model.trace)] |
| if per: |
| ps = [p if p.ndim >= 2 else p[:, None] for p in per] |
| L = min(p.shape[0] for p in ps) |
| rows.append(np.mean(np.stack([p[:L] for p in ps], 0), 0)) |
| for b in blocks: |
| if hasattr(b, "trace"): |
| b.trace = [] |
| if hasattr(model, "trace"): |
| model.trace = [] |
| for b in blocks: |
| if hasattr(b, "record"): |
| b.record = False |
| if not rows: |
| return np.zeros((0, 401)) |
| return np.mean(np.stack(rows, 0), 0) |
|
|
|
|
| |
| |
| |
| def koopman_spectrum(tag: str) -> pd.DataFrame: |
| m, cfg, meta, ck = load(tag) |
| r, th = m.spectrum() |
| r = r.detach().numpy() |
| th = th.detach().numpy() |
| d_eps = 0.2 / 400.0 |
| tau = -d_eps / np.log(np.clip(r, 1e-6, 1 - 1e-9)) |
| df = pd.DataFrame({"mode": np.arange(len(r)), "radius": r, |
| "angle": th, "tau_strain": tau, |
| "period_strain": 2 * np.pi * d_eps / np.maximum(th, 1e-6)}) |
| TABLES.mkdir(parents=True, exist_ok=True) |
| df.to_csv(TABLES / "interpret_koopman.csv", index=False) |
| return df |
|
|
|
|
| def trace_probe(tag: str, kind: str) -> pd.DataFrame: |
| m, cfg, meta, ck = load(tag) |
| dl, norm, ids = _loader(tag, meta, ck) |
| tr = _collect_trace(m, dl) |
| if tr.size == 0: |
| return pd.DataFrame() |
| if tr.ndim == 1: |
| tr = tr[:, None] |
| if kind == "gdn": |
| names = ["mem_norm", "decay_alpha", "write_beta"] |
| elif kind == "xlstm": |
| names = ["mem_norm", "forget_gate"] |
| elif kind == "node": |
| names = ["dz_dt_norm"] |
| elif kind == "rssm": |
| names = ["prior_std"] |
| else: |
| names = [f"c{i}" for i in range(tr.shape[1])] |
| names = names[:tr.shape[1]] |
| T = tr.shape[0] |
| df = pd.DataFrame(tr, columns=names) |
| df.insert(0, "strain", np.linspace(0, 0.2, T)) |
| df.to_csv(TABLES / f"interpret_{kind}.csv", index=False) |
| return df |
|
|
|
|
| def flow_uncertainty(tag: str, k: int = 16) -> Dict[str, float]: |
| import torch |
| m, cfg, meta, ck = load(tag) |
| dl, norm, ids = _loader(tag, meta, ck, batch=8) |
| S, Y, M = [], [], [] |
| with torch.no_grad(): |
| for st, x, y, msk, _ in dl: |
| z = m.sample(st, x, k=k) |
| S.append(z.numpy()) |
| Y.append(y.numpy()) |
| M.append(msk.numpy()) |
| S = np.concatenate(S, 1) |
| Y = np.concatenate(Y, 0) |
| M = np.concatenate(M, 0) |
| raw = norm.inverse_targets(S) |
| raww = norm.inverse_targets(Y) |
| mu = raw.mean(0) |
| sd = raw.std(0) |
| j = 0 |
| mask = M[..., j] > 0 |
| if mask.sum() < 10: |
| return {} |
| lo, hi = mu[..., j] - 1.645 * sd[..., j], mu[..., j] + 1.645 * sd[..., j] |
| cov = float(((raww[..., j] >= lo) & (raww[..., j] <= hi))[mask].mean()) |
| err = np.abs(mu[..., j] - raww[..., j])[mask] |
| width = (hi - lo)[mask] |
| out = {"coverage90": cov, "mean_width": float(width.mean()), |
| "mean_abs_err": float(err.mean()), |
| "sharpness_ratio": float(err.mean() / max(width.mean(), 1e-9)), |
| "n_samples": int(mask.sum())} |
| pd.DataFrame([out]).to_csv(TABLES / "interpret_flow.csv", index=False) |
| return out |
|
|
|
|
| |
| |
| |
| def fig_memory(traces: Dict[str, pd.DataFrame], fname="fig_interpret_memory.png"): |
| plt = _plt() |
| panels = [("xlstm", "forget_gate", "xLSTM forget gate $f_t$"), |
| ("gdn", "mem_norm", r"Gated DeltaNet $\|S_t\|_F$"), |
| ("node", "dz_dt_norm", r"Neural ODE $\|dz/dt\|$"), |
| ("rssm", "prior_std", r"RSSM prior std $\sigma_t$")] |
| fig, axes = plt.subplots(2, 2, figsize=(7.2, 4.4), sharex=True) |
| for ax, (k, col, title) in zip(axes.ravel(), panels): |
| df = traces.get(k) |
| if df is None or col not in df: |
| ax.axis("off") |
| continue |
| v = df[col].to_numpy(dtype=float) |
| eps = df["strain"].to_numpy(dtype=float) |
| |
| |
| |
| ax.plot(eps, v, lw=1.2, color="C0") |
| ax.set_title(f"{title}\n{v[eps < 0.02].mean():.4g} → {v[eps > 0.15].mean():.4g}", |
| fontsize=7.5) |
| ax.axvline(0.02, color="0.6", ls=":", lw=0.8) |
| ax.grid(alpha=0.2) |
| for ax in axes[-1]: |
| ax.set_xlabel("true strain") |
| fig.tight_layout() |
| FIGS.mkdir(parents=True, exist_ok=True) |
| fig.savefig(FIGS / fname, bbox_inches="tight") |
| plt.close(fig) |
| return FIGS / fname |
|
|
|
|
| def fig_koopman(df: pd.DataFrame, fname="fig_interpret_koopman.png"): |
| plt = _plt() |
| fig, ax = plt.subplots(1, 2, figsize=(6.4, 2.6)) |
| th = np.linspace(0, 2 * np.pi, 200) |
| ax[0].plot(np.cos(th), np.sin(th), color="0.8", lw=0.8) |
| ax[0].scatter(df.radius * np.cos(df.angle), df.radius * np.sin(df.angle), |
| c=df.tau_strain, cmap="viridis", s=18) |
| ax[0].set_aspect("equal") |
| ax[0].set_title("Koopman eigenvalues", fontsize=8) |
| ax[1].bar(np.arange(len(df)), df.tau_strain, color="C0") |
| ax[1].set_yscale("log") |
| ax[1].set_xlabel("mode") |
| ax[1].set_ylabel(r"memory time $\tau_\varepsilon$") |
| ax[1].set_title("decay time per mode", fontsize=8) |
| fig.tight_layout() |
| fig.savefig(FIGS / fname, bbox_inches="tight") |
| plt.close(fig) |
| return FIGS / fname |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser("pimamba.interpret") |
| ap.add_argument("--koopman", default=None) |
| ap.add_argument("--gdn", default=None) |
| ap.add_argument("--xlstm", default=None) |
| ap.add_argument("--node", default=None) |
| ap.add_argument("--rssm", default=None) |
| ap.add_argument("--flow", default=None) |
| ap.add_argument("--device", default="cpu") |
| a = ap.parse_args() |
|
|
| traces: Dict[str, pd.DataFrame] = {} |
| if a.koopman: |
| df = koopman_spectrum(a.koopman) |
| print(fig_koopman(df)) |
| print(df.describe().to_string()) |
| for kind, tag in [("gdn", a.gdn), ("xlstm", a.xlstm), ("node", a.node), |
| ("rssm", a.rssm)]: |
| if tag: |
| df = trace_probe(tag, kind) |
| traces[kind] = df |
| print(f"{kind}: {df.shape}") |
| if traces: |
| print(fig_memory(traces)) |
| if a.flow: |
| print(flow_uncertainty(a.flow)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
