dsh-eval-guard 0.7.3 → 0.7.4

package/assets/neural-pendulum/rl-feasibility/results/table.md

@@ -0,0 +1,39 @@
+# Fixed-env experiment table (auto-generated)
+
+| exp | algo | init | obs | dim | reward | steps | wall min | steps/s | final t_can | best t_can | final succ | final ever_up | final ret | final err | first succ @ steps | final robust succ | final robust t_can | best robust succ | best robust t_can |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+| ppo_angle_base_rand | ppo | rand | angle | 24 | base | 31.76M | 40.6 | 13047 | 0.04 | 0.97 | 0 | 1 | 2697.0 | 0.9751 | - | 0.00 | 0.06 | 0.00 | 0.24 |
+| ppo_angle_h1_rand | ppo | rand | angle_h1 | 6 | base | 20.97M | 30.4 | 11493 | 0.00 | 0.00 | 0 | 0 | -3526.7 | 2.9346 | - | 0.00 | 0.00 | 0.00 | 0.00 |
+| ppo_angle_h8_rand | ppo | rand | angle_h8 | 48 | base | 30.11M | 40.4 | 12417 | 0.05 | 1.31 | 0 | 1 | 2629.5 | 0.8636 | - | 0.00 | 0.05 | 0.00 | 0.15 |
+| ppo_angle_mix | ppo | mix | angle | 24 | base | 23.50M | 30.5 | 12847 | 0.00 | 0.25 | 0 | 1 | -13092.4 | 2.8925 | - | 0.00 | 0.00 | 0.00 | 0.10 |
+| ppo_full_base_fixed | ppo | fixed | full | 36 | base | 21.93M | 30.5 | 11978 | 0.00 | 1.19 | 0 | 0 | 260.7 | 0.7154 | - | 0.00 | 0.00 | 0.00 | 1.03 |
+| ppo_full_base_rand | ppo | rand | full | 36 | base | 35.98M | 45.1 | 13307 | 26.61 | 26.85 | 1 | 1 | 16772.5 | 0.0220 | 11.33M | 1.00 | 25.57 | 1.00 | 26.86 |
+| ppo_full_base_rand_s1 | ppo | rand | full | 36 | base | 29.03M | 40.8 | 11872 | 0.23 | 27.17 | 0 | 1 | 5034.6 | 0.2765 | 13.63M | 0.00 | 0.21 | 1.00 | 26.78 |
+| ppo_full_base_rand_s2 | ppo | rand | full | 36 | base | 34.21M | 40.3 | 14135 | 0.00 | 28.46 | 0 | 0 | 4804.4 | 0.0820 | 14.40M | 0.00 | 0.00 | 1.00 | 28.03 |
+| ppo_full_energy_rand | ppo | rand | full | 36 | energy | 24.50M | 35.5 | 11503 | 0.00 | 0.00 | 0 | 0 | -1948.3 | 2.8125 | - | 0.00 | 0.00 | 0.00 | 0.00 |
+| ppo_full_h1_mix | ppo | mix | full_h1 | 9 | base | 21.39M | 30.5 | 11703 | 0.00 | 0.02 | 0 | 0 | -552.6 | 2.2633 | - | 0.00 | 0.00 | 0.00 | 0.00 |
+| ppo_full_h1_rand | ppo | rand | full_h1 | 9 | base | 25.42M | 35.3 | 11988 | 0.00 | 0.06 | 0 | 0 | -1701.9 | 2.6674 | - | 0.00 | 0.00 | 0.00 | 0.06 |
+| ppo_full_sparse_rand | ppo | rand | full | 36 | sparse | 19.12M | 30.5 | 10445 | 0.00 | 0.00 | 0 | 0 | -0.4 | 3.1021 | - | 0.00 | 0.00 | 0.00 | 0.00 |
+| sac_angle_base_rand | sac | rand | angle | 24 | base | 1.42M | 50.6 | 469 | 0.00 | 0.04 | 0 | 0 | -581.4 | 0.6124 | - | 0.00 | 0.01 | 0.00 | 0.00 |
+| sac_full_base_fixed | sac | fixed | full | 36 | base | 1.41M | 50.4 | 466 | 27.62 | 28.86 | 1 | 1 | 17697.1 | 0.0324 | 0.52M | 1.00 | 27.49 | 1.00 | 23.45 |
+| sac_full_base_rand | sac | rand | full | 36 | base | 1.42M | 50.6 | 470 | 28.21 | 28.75 | 1 | 1 | 17607.2 | 0.0293 | 0.70M | 1.00 | 26.39 | 0.75 | 20.89 |
+
+## TensorBoard coverage
+
+| exp | tags | required missing | last global_steps | last elapsed min |
+|---|---|---|---|---|
+| ppo_angle_base_rand | 62 | none | 31756800 | 40.04 |
+| ppo_angle_h1_rand | 62 | none | 20966400 | 30.02 |
+| ppo_angle_h8_rand | 62 | none | 30105600 | 40.04 |
+| ppo_angle_mix | 62 | none | 23500800 | 30.02 |
+| ppo_full_base_fixed | 62 | none | 21926400 | 30.01 |
+| ppo_full_base_rand | 53 | none | 35980800 | 45.06 |
+| ppo_full_base_rand_s1 | 62 | none | 29030400 | 40.02 |
+| ppo_full_base_rand_s2 | 62 | none | 34214400 | 40.02 |
+| ppo_full_energy_rand | 62 | none | 24499200 | 35.02 |
+| ppo_full_h1_mix | 62 | none | 21388800 | 30.04 |
+| ppo_full_h1_rand | 62 | none | 25420800 | 35.00 |
+| ppo_full_sparse_rand | 61 | none | 19123200 | 30.05 |
+| sac_angle_base_rand | 66 | none | 1423040 | 49.99 |
+| sac_full_base_fixed | 66 | none | 1407680 | 49.99 |
+| sac_full_base_rand | 66 | none | 1424320 | 50.00 |

package/assets/neural-pendulum/rl-feasibility/sim.py

@@ -0,0 +1,324 @@
+"""3-link planar pendulum simulator with a strict angle-only API.
+
+Physical model (verified in the sibling rounds):
+  * 3 links, joints 1 and 3 actuated, joint 2 passive.
+  * tau_max = 18 N m at each actuated joint, action u in [-1, 1]^2.
+  * 100 Hz zero-order-hold control, RK4 with 4 substeps (dt = 2.5 ms).
+  * 30 s episode = 3000 control steps.
+  * theta_i is the absolute link angle from the DOWNWARD vertical
+    (0 = down, +-pi = up); angles are NOT divided by pi anywhere.
+
+Environment contract (deliberate, so that no training signal lives in the
+simulator):
+  reset(theta, omega) -> theta   (only the three angles)
+  step(u)             -> theta   (only the three angles)
+  There is no reward, loss, done, info, terminal flag, tip or omega in any
+  return value.  A public theta property exists only for diagnostics and
+  returns the same three angles.
+  An episode is exactly episode_steps (default 3000) control steps.
+  Calling step() when any environment in the batch has already used its
+  budget raises EpisodeLengthError; reset() must be called first.
+
+The internal omega is advanced by the physics and is deliberately not part
+of the public API.  Training code that wants a velocity signal must derive it
+from the returned angle stream (see obs.py).
+"""
+from __future__ import annotations
+
+import numpy as np
+
+N_LINKS = 3
+DRIVE_JOINTS = (0, 2)          # zero-based: joint 1 and joint 3 actuated
+DT = 0.01                      # control period (100 Hz)
+N_ACT = 2
+EPISODE_STEPS = 3000           # 30 s
+UP_TOL = 0.05                  # success tolerance (rad)
+BONUS_TOL = 0.15               # reward bonus tolerance (rad)
+
+
+class Params:
+    """Physical parameters of the 3-link pendulum (defaults = task spec)."""
+
+    def __init__(self, m=(1.0, 1.0, 1.0), l=(0.5, 0.5, 0.5), g=9.81, b=0.01,
+                 tau_max=18.0, r=None, I=None, drive=DRIVE_JOINTS):
+        self.m = np.asarray(m, dtype=np.float64)
+        self.l = np.asarray(l, dtype=np.float64)
+        self.g = float(g)
+        self.b = float(b)
+        self.tau_max = float(tau_max)
+        self.drive = tuple(drive)
+        self.r = np.asarray(r, dtype=np.float64) if r is not None else 0.5 * self.l
+        self.I = (np.asarray(I, dtype=np.float64) if I is not None
+                  else self.m * self.l ** 2 / 12.0)
+
+        n = N_LINKS
+        self.gvec = np.array([self.m[i] * self.r[i] + self.l[i] * self.m[i + 1:].sum()
+                              for i in range(n)])
+
+        self.A = np.zeros((n, n))
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    self.A[i, i] = (self.I[i] + self.m[i] * self.r[i] ** 2
+                                    + self.l[i] ** 2 * self.m[i + 1:].sum())
+                else:
+                    a, bb = min(i, j), max(i, j)
+                    self.A[i, j] = self.l[a] * self.gvec[bb]
+
+        self.vcoef = self.gvec.copy()
+
+        # Rayleigh damping matrix D^T D, eps_i = omega_i - omega_{i-1}
+        D = np.zeros((n, n))
+        for i in range(n):
+            D[i, i] = 1.0
+            if i > 0:
+                D[i, i - 1] = -1.0
+        self.Ldamp = D.T @ D
+        self.L_total = float(self.l.sum())
+
+    def tip_position(self, theta):
+        return float(np.dot(self.l, np.sin(theta))), float(-np.dot(self.l, np.cos(theta)))
+
+    def potential(self, theta):
+        return -self.g * float(np.dot(self.vcoef, np.cos(theta)))
+
+    def as_dict(self):
+        return dict(m=self.m.tolist(), l=self.l.tolist(), r=self.r.tolist(),
+                    I=self.I.tolist(), g=self.g, b=self.b,
+                    tau_max=self.tau_max, drive=list(self.drive))
+
+
+# ---------------------------------------------------------------------------
+# numpy float64 physics
+# ---------------------------------------------------------------------------
+def generalized_torque(u, p: Params):
+    """Physical joint-motor torques mapped to absolute-angle generalized forces.
+
+    Joint 1 is external to ground, so its generalized force is +u1*tau_max.
+    Joint 3 is an internal motor between links 2 and 3: its torque acts on the
+    relative angle theta3-theta2, giving generalized force
+        (tau1, -tau3, tau3)
+    with tau2=0.  Do NOT use (tau1, 0, tau3): that would be a reactionless
+    external torque on link 3 and contradicts joint 2 being passive.
+    """
+    tau = np.zeros(N_LINKS)
+    u = np.asarray(u, dtype=np.float64)
+    # Fixed mapping for this task: drive=(0,2), tau2=0.
+    tau[0] = float(u[0]) * p.tau_max
+    tau[1] = -float(u[1]) * p.tau_max
+    tau[2] = float(u[1]) * p.tau_max
+    return tau
+
+
+def rhs(theta, omega, u, p: Params):
+    d = theta[:, None] - theta[None, :]
+    M = p.A * np.cos(d)
+    C = (p.A * np.sin(d) * (omega[None, :] ** 2)).sum(axis=1)
+    G = p.g * np.sin(theta) * p.gvec
+    tau = generalized_torque(u, p) - p.b * (p.Ldamp @ omega)
+    qdd = np.linalg.solve(M, tau - C - G)
+    return omega, qdd
+
+
+def rk4_step(theta, omega, u, p: Params, dt):
+    k1t, k1w = rhs(theta, omega, u, p)
+    k2t, k2w = rhs(theta + 0.5 * dt * k1t, omega + 0.5 * dt * k1w, u, p)
+    k3t, k3w = rhs(theta + 0.5 * dt * k2t, omega + 0.5 * dt * k2w, u, p)
+    k4t, k4w = rhs(theta + dt * k3t, omega + dt * k3w, u, p)
+    theta = theta + (dt / 6.0) * (k1t + 2 * k2t + 2 * k3t + k4t)
+    omega = omega + (dt / 6.0) * (k1w + 2 * k2w + 2 * k3w + k4w)
+    return theta, omega
+
+
+def integrate(theta, omega, u, p: Params, dt_ctrl=DT, n_sub=4):
+    h = dt_ctrl / n_sub
+    for _ in range(n_sub):
+        theta, omega = rk4_step(theta, omega, u, p, h)
+    return theta, omega
+
+
+def total_energy(theta, omega, p: Params):
+    d = theta[:, None] - theta[None, :]
+    M = p.A * np.cos(d)
+    T = 0.5 * float(omega @ M @ omega)
+    V = -p.g * float(np.dot(p.vcoef, np.cos(theta)))
+    return T + V, T, V
+
+
+def energy_up(p: Params):
+    return p.g * float(np.dot(p.vcoef, np.ones(N_LINKS)))
+
+
+def energy_down(p: Params):
+    return -p.g * float(np.dot(p.vcoef, np.ones(N_LINKS)))
+
+
+def wrap_to_pi(a):
+    return (a + np.pi) % (2.0 * np.pi) - np.pi
+
+
+def upright_error(theta):
+    return wrap_to_pi(theta - np.pi)
+
+
+def tip_pos(theta, p: Params):
+    return p.tip_position(theta)
+
+
+# ---------------------------------------------------------------------------
+# batched torch float32 physics (training)
+# ---------------------------------------------------------------------------
+def make_torch_consts(p: Params, device="cpu"):
+    import torch
+    # u @ tau_map must produce the absolute generalized force (tau1,-tau3,tau3).
+    tau_map = torch.zeros(2, N_LINKS, dtype=torch.float32, device=device)
+    tau_map[0, 0] = 1.0    # joint 1: +tau1
+    tau_map[1, 1] = -1.0   # joint 3 reaction on link 2: -tau3
+    tau_map[1, 2] = 1.0    # joint 3 on link 3: +tau3
+    return dict(
+        A=torch.tensor(p.A, dtype=torch.float32, device=device),
+        gvec=torch.tensor(p.gvec, dtype=torch.float32, device=device),
+        vcoef=torch.tensor(p.vcoef, dtype=torch.float32, device=device),
+        Ldamp=torch.tensor(p.Ldamp, dtype=torch.float32, device=device),
+        lt=torch.tensor(p.l, dtype=torch.float32, device=device),
+        tau_map=tau_map,
+        g=p.g, b=p.b, tau_max=p.tau_max,
+    )
+
+
+def torch_rhs(theta, omega, u, c):
+    import torch
+    d = theta.unsqueeze(2) - theta.unsqueeze(1)
+    M = c["A"] * torch.cos(d)
+    C = (c["A"] * torch.sin(d) * omega.unsqueeze(1) ** 2).sum(dim=2)
+    G = c["g"] * torch.sin(theta) * c["gvec"]
+    tau = u @ c["tau_map"] * c["tau_max"]
+    tau = tau - c["b"] * (omega @ c["Ldamp"].t())
+    qdd = torch.linalg.solve(M, (tau - C - G).unsqueeze(-1)).squeeze(-1)
+    return omega, qdd
+
+
+def torch_rk4_step(theta, omega, u, c, dt):
+    k1t, k1w = torch_rhs(theta, omega, u, c)
+    k2t, k2w = torch_rhs(theta + 0.5 * dt * k1t, omega + 0.5 * dt * k1w, u, c)
+    k3t, k3w = torch_rhs(theta + 0.5 * dt * k2t, omega + 0.5 * dt * k2w, u, c)
+    k4t, k4w = torch_rhs(theta + dt * k3t, omega + dt * k3w, u, c)
+    theta = theta + (dt / 6.0) * (k1t + 2 * k2t + 2 * k3t + k4t)
+    omega = omega + (dt / 6.0) * (k1w + 2 * k2w + 2 * k3w + k4w)
+    return theta, omega
+
+
+def torch_integrate(theta, omega, u, c, dt_ctrl=DT, n_sub=4):
+    h = dt_ctrl / n_sub
+    for _ in range(n_sub):
+        theta, omega = torch_rk4_step(theta, omega, u, c, h)
+    return theta, omega
+
+
+def torch_tip(theta, c):
+    import torch
+    x = (torch.sin(theta) * c["lt"]).sum(-1)
+    y = -(torch.cos(theta) * c["lt"]).sum(-1)
+    return torch.stack([x, y], dim=-1)
+
+
+# ---------------------------------------------------------------------------
+# public simulator API
+# ---------------------------------------------------------------------------
+class EpisodeLengthError(RuntimeError):
+    """Raised when step() is called after the 3000-step budget is used up."""
+
+
+class PendulumSim:
+    """Single float64 simulator.  Returns angles only."""
+
+    def __init__(self, p=None, episode_steps: int = EPISODE_STEPS,
+                 dt: float = DT, n_sub: int = 4):
+        self.p = Params() if p is None else p
+        self.episode_steps = int(episode_steps)
+        self.dt = float(dt)
+        self.n_sub = int(n_sub)
+        self._theta = np.zeros(N_LINKS)
+        self._omega = np.zeros(N_LINKS)
+        self._steps = 0
+
+    @property
+    def steps(self):
+        return self._steps
+
+    @property
+    def theta(self):
+        return self._theta.copy()
+
+    def reset(self, theta, omega):
+        theta = np.asarray(theta, dtype=np.float64).reshape(N_LINKS)
+        omega = np.asarray(omega, dtype=np.float64).reshape(N_LINKS)
+        if not (np.isfinite(theta).all() and np.isfinite(omega).all()):
+            raise ValueError("non-finite initial state")
+        self._theta = theta.copy()
+        self._omega = omega.copy()
+        self._steps = 0
+        return self._theta.copy()
+
+    def step(self, u):
+        if self._steps >= self.episode_steps:
+            raise EpisodeLengthError(
+                f"episode budget exhausted ({self.episode_steps} steps); call reset()")
+        u = np.clip(np.asarray(u, dtype=np.float64).reshape(N_ACT), -1.0, 1.0)
+        self._theta, self._omega = integrate(self._theta, self._omega, u,
+                                             self.p, self.dt, self.n_sub)
+        self._steps += 1
+        return self._theta.copy()
+
+
+class TorchVecSim:
+    """Batched float32 simulator.  Returns angles only; no reward/done."""
+
+    def __init__(self, p: Params, n: int, episode_steps: int = EPISODE_STEPS,
+                 device="cpu", dt: float = DT, n_sub: int = 4):
+        import torch
+        self.torch = torch
+        self.p = p
+        self.n = int(n)
+        self.episode_steps = int(episode_steps)
+        self.device = device
+        self.dt = float(dt)
+        self.n_sub = int(n_sub)
+        self.c = make_torch_consts(p, device)
+        self.theta = torch.zeros(n, N_LINKS, device=device)
+        self._omega = torch.zeros(n, N_LINKS, device=device)
+        self.steps = torch.zeros(n, dtype=torch.long, device=device)
+
+    def reset(self, theta, omega, idx=None):
+        t = self.torch
+        theta = t.as_tensor(theta, dtype=t.float32, device=self.device).reshape(-1, N_LINKS)
+        omega = t.as_tensor(omega, dtype=t.float32, device=self.device).reshape(-1, N_LINKS)
+        if idx is None:
+            if theta.shape[0] != self.n:
+                raise ValueError(f"expected {self.n} initial states, got {theta.shape[0]}")
+            self.theta = theta.clone()
+            self._omega = omega.clone()
+            self.steps = t.zeros(self.n, dtype=t.long, device=self.device)
+            return self.theta.clone()
+        idx = t.as_tensor(idx, dtype=t.long, device=self.device).flatten()
+        if theta.shape[0] != idx.numel():
+            raise ValueError("theta subset size does not match idx")
+        self.theta[idx] = theta
+        self._omega[idx] = omega
+        self.steps[idx] = 0
+        return self.theta[idx].clone()
+
+    def step(self, u):
+        t = self.torch
+        exhausted = self.steps >= self.episode_steps
+        if bool(exhausted.any()):
+            bad = exhausted.nonzero().flatten().tolist()
+            raise EpisodeLengthError(
+                "episode budget exhausted for envs "
+                f"{bad[:8]}{'...' if len(bad) > 8 else ''} "
+                f"({self.episode_steps} steps); call reset() first")
+        u = t.clamp(t.as_tensor(u, dtype=t.float32, device=self.device), -1.0, 1.0)
+        self.theta, self._omega = torch_integrate(self.theta, self._omega, u,
+                                                 self.c, self.dt, self.n_sub)
+        self.steps = self.steps + 1
+        return self.theta.clone()

package/assets/neural-pendulum/rl-feasibility/summarize.py

@@ -0,0 +1,175 @@
+"""Aggregate results/*.json and tb/<exp> into results/summary.json,
+results/table.md and results/curves.png.  Missing runs simply do not appear.
+
+Usage: python3 summarize.py [--tb-root tb] [--out results]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+ROOT = Path(__file__).resolve().parent
+REQUIRED_TAGS = ["train/episode_return", "train/episode_length", "train/t_can",
+                 "train/success_rate", "eval/t_can", "eval/success",
+                 "eval/final_ang_err", "time/elapsed_min"]
+
+
+def tb_status(tb_root, exp):
+    from tensorboard.backend.event_processing.event_accumulator import (
+        EventAccumulator)
+    d = Path(tb_root) / exp
+    if not d.is_dir():
+        return dict(exp=exp, exists=False, tags=[], missing=REQUIRED_TAGS,
+                    last=dict())
+    ea = EventAccumulator(str(d), size_guidance={"scalars": 0})
+    ea.Reload()
+    tags = ea.Tags().get("scalars", [])
+    last = {}
+    for k in ("train/global_steps", "time/elapsed_min", "train/t_can",
+              "train/success_rate", "eval/t_can", "eval/success"):
+        if k in tags:
+            last[k] = ea.Scalars(k)[-1].value
+    return dict(exp=exp, exists=True, tags=sorted(tags),
+                missing=[t for t in REQUIRED_TAGS if t not in tags],
+                n_points=len(tags), last=last)
+
+
+def load_results(res_dir):
+    out = []
+    for path in sorted(Path(res_dir).glob("*.json")):
+        if path.name in ("summary.json", "tb_coverage.json", "robustness.json",
+                          "reference_controller.json"):
+            continue
+        with open(path) as f:
+            out.append(json.load(f))
+    return out
+
+
+def fmt(x, nd=2):
+    if x is None:
+        return "-"
+    if isinstance(x, float):
+        if not np.isfinite(x):
+            return "nan"
+        return f"{x:.{nd}f}"
+    return str(x)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--tb-root", default="tb")
+    ap.add_argument("--out", default="results")
+    args = ap.parse_args()
+    results = load_results(args.out)
+    rows, cov = [], []
+    for r in results:
+        ev = r.get("final_eval") or {}
+        best = r.get("best_eval") or {}
+        ck = r.get("checkpoints") or {}
+        obs = r.get("obs") or {}
+        init = r.get("init") or {}
+        init_mode = init.get("mode") if isinstance(init, dict) else str(init)
+        curve = r.get("eval_curve") or []
+        first_succ = next((c["global_steps"] for c in curve
+                           if c.get("t_can", 0.0) >= 10.0), None)
+        rob = r.get("robust") or {}
+        rob_best = r.get("robust_best") or {}
+        c = tb_status(args.tb_root, r["exp"])
+        cov.append(c)
+        rows.append(dict(
+            exp=r["exp"], algo=r.get("algo"), init=init_mode,
+            obs=obs.get("mode", "-"), obs_dim=r.get("obs_dim"),
+            reward=r.get("reward_preset", "-"),
+            envs=r.get("envs"), global_steps=r.get("global_steps"),
+            wall_min=(r.get("wall_time_s") or 0.0) / 60.0,
+            steps_per_s=r.get("steps_per_s"),
+            final_t_can=ev.get("t_can"), best_t_can=best.get("t_can"),
+            final_success=ev.get("success"), final_ever_up=ev.get("ever_up"),
+            final_return=ev.get("ep_return"), best_return=best.get("ep_return"),
+            final_ang_err=ev.get("final_ang_err"),
+            first_success_steps=first_succ,
+            robust_success=rob.get("success_rate"),
+            robust_mean_t_can=rob.get("mean_t_can"),
+            robust_best_success=rob_best.get("success_rate"),
+            robust_best_mean_t_can=rob_best.get("mean_t_can"),
+            best_ckpt=ck.get("best"), final_ckpt=ck.get("final"),
+            tb_tags=len(c.get("tags", [])), tb_missing=c.get("missing", []),
+        ))
+
+    table = ["# Fixed-env experiment table (auto-generated)",
+             "",
+             "| exp | algo | init | obs | dim | reward | steps | wall min | "
+             "steps/s | final t_can | best t_can | final succ | final ever_up | "
+             "final ret | final err | first succ @ steps | final robust succ | "
+             "final robust t_can | best robust succ | best robust t_can |",
+             "|" + "---|" * 20]
+    for x in rows:
+        fs = (f"{x['first_success_steps']/1e6:.2f}M"
+              if x["first_success_steps"] else "-")
+        table.append(
+            f"| {x['exp']} | {x['algo']} | {x['init']} | {x['obs']} | "
+            f"{x['obs_dim']} | {x['reward']} | "
+            f"{(x['global_steps'] or 0)/1e6:.2f}M | {x['wall_min']:.1f} | "
+            f"{fmt(x['steps_per_s'],0)} | {fmt(x['final_t_can'])} | "
+            f"{fmt(x['best_t_can'])} | {fmt(x['final_success'],0)} | "
+            f"{fmt(x['final_ever_up'],0)} | {fmt(x['final_return'],1)} | "
+            f"{fmt(x['final_ang_err'],4)} | {fs} | "
+            f"{fmt(x['robust_success'],2)} | {fmt(x['robust_mean_t_can'])} | "
+            f"{fmt(x['robust_best_success'],2)} | "
+            f"{fmt(x['robust_best_mean_t_can'])} |")
+    table += ["", "## TensorBoard coverage", "",
+              "| exp | tags | required missing | last global_steps | last elapsed min |",
+              "|---|---|---|---|---|"]
+    for c in cov:
+        last = c.get("last") or {}
+        table.append(f"| {c['exp']} | {len(c.get('tags', []))} | "
+                     f"{', '.join(c.get('missing', [])) or 'none'} | "
+                     f"{fmt(last.get('train/global_steps'),0)} | "
+                     f"{fmt(last.get('time/elapsed_min'))} |")
+    Path(args.out, "table.md").write_text("\n".join(table) + "\n")
+
+    if results:
+        fig, axes = plt.subplots(1, 2, figsize=(13, 4.6))
+        for r in results:
+            curve = r.get("eval_curve") or []
+            if not curve:
+                continue
+            steps = [c["global_steps"] / 1e6 for c in curve]
+            tcan = [c["t_can"] for c in curve]
+            ret = [c["ep_return"] for c in curve]
+            lab = r["exp"]
+            axes[0].plot(steps, tcan, lw=1.2, label=lab)
+            axes[1].plot(steps, ret, lw=1.2, label=lab)
+        axes[0].axhline(10.0, color="k", ls=":", lw=1)
+        axes[0].set_xlabel("env steps (M)")
+        axes[0].set_ylabel("eval t_can (s)")
+        axes[0].set_title("fixed-initial deterministic eval: t_can")
+        axes[0].grid(alpha=0.3)
+        axes[1].set_xlabel("env steps (M)")
+        axes[1].set_ylabel("eval return (symlog)")
+        axes[1].set_title("fixed-initial deterministic eval: return")
+        axes[1].set_yscale("symlog", linthresh=1000.0)
+        axes[1].grid(alpha=0.3, which="both")
+        for ax in axes:
+            ax.legend(fontsize=6, ncol=1)
+        fig.tight_layout()
+        fig.savefig(Path(args.out, "curves.png"), dpi=130)
+        plt.close(fig)
+
+    summary = dict(n_runs=len(rows), runs=rows, tb_coverage=cov)
+    with open(Path(args.out, "summary.json"), "w") as f:
+        json.dump(summary, f, indent=2)
+    print(json.dumps(dict(n_runs=len(rows),
+                          runs=[(x["exp"], x["final_t_can"], x["best_t_can"])
+                                for x in rows]), indent=2))
+
+
+if __name__ == "__main__":
+    main()