dsh-eval-guard 0.7.4 → 0.7.5

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

@@ -1,342 +0,0 @@
-"""Trainer-side task wrapper: observation, reward, episode bookkeeping.
-
-Nothing in this file is part of the simulator API.  The simulator returns only
-the three angles; this module turns that angle stream into
-
-  * the policy observation (obs.py),
-  * the training reward,
-  * success / t_can / ever_up / episode-return bookkeeping,
-  * reset initial-state distributions.
-
-Reward (entirely constructed here, never in the environment):
-    a      = wrap_to_pi(theta - pi)
-    s2     = sum_i a_i^2
-    upf    = 1[max_i |a_i| < 0.15]
-    tip_y  = -sum_i l_i cos(theta_i)                  (function of theta)
-    E      ~ 0.5 da^T M(theta) da - g sum_i gvec_i cos(theta_i)
-             (da is the manual finite-difference velocity from obs.py)
-    r = exp(-2 s2) + 2 exp(-50 s2) - 0.05 s2
-        - 0.001 sum da^2 - 0.01 sum u^2 + 3 upf
-        + 0.3 (tip_y + L)/(2L) - 0.01 |E - E_up|/(E_up - E_down)
-
-The last two shaping terms are functions of the angle stream (and da), not
-privileged simulator outputs.  Because the simulator exposes no omega, da is
-used wherever the reference reward used omega; this is documented in
-RESULTS.md.
-
-Reset distributions:
-  training random : theta_i ~ U(-0.05, 0.05), omega_i ~ U(-0.02, 0.02)
-                    (no fixed bias of any kind)
-  training fixed  : theta = [0.013, -0.008, 0.021], omega = 0
-  evaluation      : theta = [0.013, -0.008, 0.021], omega = 0 (no noise)
-"""
-from __future__ import annotations
-
-import numpy as np
-import torch
-
-from obs import (DT, H, NumpyAngleObs, OBS_MODES, TorchAngleObs,
-                 make_numpy_obs, make_torch_obs, obs_spec, wrap_to_pi)
-from sim import (BONUS_TOL, N_ACT, N_LINKS, Params, UP_TOL, energy_down,
-                 energy_up, make_torch_consts, tip_pos, torch_tip, total_energy)
-
-TRAIN_THETA_HALF = 0.05
-TRAIN_OMEGA_HALF = 0.02
-EVAL_THETA0 = np.array([0.013, -0.008, 0.021], dtype=np.float64)
-EVAL_OMEGA0 = np.zeros(N_LINKS, dtype=np.float64)
-
-DEFAULT_W = dict(exp=1.0, sharp=2.0, ang=0.05, vel=0.001, act=0.01, up=3.0,
-                 tip=0.3, energy=0.01)
-
-# Reward presets.  Every term is a trainer-side function of theta, the manual
-# difference da and the action; the keys map 1:1 onto the reward formula in
-# reward_np / TorchReward.  No simulator omega is read.
-#
-# base   : the original dense shaping above.
-# sparse : up-focused, almost no dense shaping:
-#            r = 0.2 exp(-2 s2) + 3.0 1[max|a| < 0.15]
-#                - 0.001 sum da^2 - 0.01 sum u^2
-#          (no angle-progress, tip or energy terms)
-# energy : strong energy shaping toward the upright energy, weaker angle and
-#          velocity penalties:
-#            r = 0.2 exp(-2 s2) + 0.5 exp(-50 s2) - 0.01 s2
-#                - 0.0002 sum da^2 - 0.005 sum u^2
-#                + 3.0 1[max|a| < 0.15]
-#                - 0.5 |E - E_up| / (E_up - E_down)
-#          E is the trainer-side mechanical energy using da as velocity.
-SPARSE_W = dict(exp=0.2, sharp=0.0, ang=0.0, vel=0.001, act=0.01, up=3.0,
-                tip=0.0, energy=0.0)
-ENERGY_W = dict(exp=1.0, sharp=2.0, ang=0.05, vel=0.0, act=0.005, up=3.0,
-                tip=0.0, energy=0.5)
-
-REWARD_PRESETS = {
-    "base": dict(DEFAULT_W),
-    "sparse": dict(SPARSE_W),
-    "energy": dict(ENERGY_W),
-}
-
-
-# The energy error is |E-E_up|/span.  At high spin rates E grows without bound,
-# and with weight 0.5 (energy preset) the raw term produced huge negative
-# rewards and value-loss blow-up (~5e7).  Clamp it: the gradient near upright
-# is unchanged, but violent spins cannot dominate the return.
-E_ERR_CLAMP = 3.0
-
-
-def get_reward_preset(name: str) -> dict:
-    if name not in REWARD_PRESETS:
-        raise ValueError(f"unknown reward preset {name!r}; "
-                         f"choose from {sorted(REWARD_PRESETS)}")
-    return dict(REWARD_PRESETS[name])
-
-OBS_SPEC = obs_spec("full")
-
-TORCH_REWARD_NOTE = (
-    "Reward is built in task.py from theta and the manual difference da only. "
-    "The simulator returns angles only (no reward/done/omega/tip). tip_y and "
-    "the energy-like term are trainer-side functions of theta (and da), not "
-    "simulator outputs.")
-
-
-def reward_np(theta, da, u, p: Params, w=None):
-    w = DEFAULT_W if w is None else w
-    theta = np.asarray(theta, dtype=np.float64).reshape(N_LINKS)
-    da = np.asarray(da, dtype=np.float64).reshape(N_LINKS)
-    u = np.asarray(u, dtype=np.float64).reshape(N_ACT)
-    a = wrap_to_pi(theta - np.pi)
-    s2 = float(a @ a)
-    upf = float(np.abs(a).max() < BONUS_TOL)
-    y = tip_pos(theta, p)[1]
-    L = p.L_total
-    e = total_energy(theta, da, p)[0]
-    e_err = min(E_ERR_CLAMP,
-                abs(e - energy_up(p)) / max(1e-6, energy_up(p) - energy_down(p)))
-    return (w["exp"] * np.exp(-2.0 * s2)
-            + w["sharp"] * np.exp(-50.0 * s2)
-            - w["ang"] * s2
-            - w["vel"] * float(da @ da)
-            - w["act"] * float(u @ u)
-            + w["up"] * upf
-            + w["tip"] * (y + L) / (2.0 * L)
-            - w["energy"] * e_err)
-
-
-class TorchReward:
-    def __init__(self, p: Params, w=None, device="cpu"):
-        self.p = p
-        self.w = dict(DEFAULT_W if w is None else w)
-        self.c = make_torch_consts(p, device)
-        self.e_up = energy_up(p)
-        self.e_span = max(1e-6, energy_up(p) - energy_down(p))
-        self.L = p.L_total
-
-    def __call__(self, theta, da, u):
-        t = torch
-        a = t.remainder(theta - np.pi + np.pi, 2 * np.pi) - np.pi
-        s2 = (a * a).sum(1)
-        upf = (a.abs().amax(1) < BONUS_TOL).float()
-        y = torch_tip(theta, self.c)[:, 1]
-        M = self.c["A"] * t.cos(theta.unsqueeze(2) - theta.unsqueeze(1))
-        E = 0.5 * (da * t.linalg.solve(M, da.unsqueeze(-1)).squeeze(-1)).sum(1)
-        E = E - self.c["g"] * (t.cos(theta) * self.c["vcoef"]).sum(1)
-        e_err = ((E - self.e_up).abs() / self.e_span).clamp(max=E_ERR_CLAMP)
-        w = self.w
-        return (w["exp"] * t.exp(-2.0 * s2)
-                + w["sharp"] * t.exp(-50.0 * s2)
-                - w["ang"] * s2
-                - w["vel"] * (da * da).sum(1)
-                - w["act"] * (u * u).sum(1)
-                + w["up"] * upf
-                + w["tip"] * (y + self.L) / (2.0 * self.L)
-                - w["energy"] * e_err)
-
-
-class NumpyTracker:
-    def __init__(self, up_tol=UP_TOL):
-        self.up_tol = up_tol
-        self.t = 0.0
-        self.ep_return = 0.0
-        self.cur_up_start = -1.0
-        self.t_can = 0.0
-        self.ever_up = False
-        self.first_up_t = -1.0
-        self.up_steps = 0
-
-    def reset(self):
-        self.t = 0.0
-        self.ep_return = 0.0
-        self.cur_up_start = -1.0
-        self.t_can = 0.0
-        self.ever_up = False
-        self.first_up_t = -1.0
-        self.up_steps = 0
-
-    def update(self, theta, r):
-        a = wrap_to_pi(np.asarray(theta, dtype=np.float64).reshape(N_LINKS) - np.pi)
-        up = bool(np.abs(a).max() < self.up_tol)
-        self.t += DT
-        self.ep_return += float(r)
-        if up and not self.ever_up:
-            self.ever_up = True
-            self.first_up_t = self.t
-        if up:
-            self.up_steps += 1
-            if self.cur_up_start < 0:
-                self.cur_up_start = self.t
-            self.t_can = max(self.t_can, self.t - self.cur_up_start)
-        else:
-            self.cur_up_start = -1.0
-
-    def summary(self):
-        return dict(ep_return=float(self.ep_return), t_can=float(self.t_can),
-                    ever_up=float(self.ever_up),
-                    first_up_t=float(self.first_up_t),
-                    up_frac=float(self.up_steps * DT / max(self.t, 1e-6)),
-                    length=int(round(self.t / DT)))
-
-
-class TorchTracker:
-    def __init__(self, n, up_tol=UP_TOL, device="cpu"):
-        self.torch = torch
-        self.n = int(n)
-        self.up_tol = up_tol
-        self.device = device
-        self.t = torch.zeros(n, device=device)
-        self.ep_return = torch.zeros(n, device=device)
-        self.cur_up_start = torch.full((n,), -1.0, device=device)
-        self.t_can = torch.zeros(n, device=device)
-        self.ever_up = torch.zeros(n, dtype=torch.bool, device=device)
-        self.first_up_t = torch.full((n,), -1.0, device=device)
-        self.up_steps = torch.zeros(n, device=device)
-
-    def reset(self, idx=None):
-        t = self.torch
-        if idx is None:
-            idx = t.arange(self.n, device=self.device)
-        idx = t.as_tensor(idx, dtype=t.long, device=self.device).flatten()
-        self.t[idx] = 0.0
-        self.ep_return[idx] = 0.0
-        self.cur_up_start[idx] = -1.0
-        self.t_can[idx] = 0.0
-        self.ever_up[idx] = False
-        self.first_up_t[idx] = -1.0
-        self.up_steps[idx] = 0.0
-
-    def update(self, theta, r):
-        t = self.torch
-        a = t.remainder(theta - np.pi + np.pi, 2 * np.pi) - np.pi
-        up = a.abs().amax(1) < self.up_tol
-        self.t = self.t + DT
-        self.ep_return = self.ep_return + r
-        newly = up & (~self.ever_up)
-        self.ever_up = self.ever_up | up
-        self.first_up_t = t.where(newly, self.t, self.first_up_t)
-        self.up_steps = self.up_steps + up.float()
-        start = t.where(up & (self.cur_up_start < 0), self.t, self.cur_up_start)
-        self.cur_up_start = t.where(up, start, t.full_like(start, -1.0))
-        streak = t.where(self.cur_up_start >= 0, self.t - self.cur_up_start,
-                         t.zeros_like(self.t))
-        self.t_can = t.maximum(self.t_can, streak)
-
-    def summary(self, idx):
-        t = self.torch
-        idx = t.as_tensor(idx, dtype=t.long, device=self.device).flatten()
-        return dict(ep_return=self.ep_return[idx].clone(),
-                    t_can=self.t_can[idx].clone(),
-                    ever_up=self.ever_up[idx].float().clone(),
-                    first_up_t=self.first_up_t[idx].clone(),
-                    up_frac=self.up_steps[idx] * DT / self.t[idx].clamp(min=1e-6),
-                    length=(self.t[idx] / DT).round().long())
-
-
-def sample_train_init(n, gen=None, device="cpu"):
-    """Pure uniform noise, no fixed bias: theta U(-.05,.05), omega U(-.02,.02)."""
-    t = torch
-    theta = (t.rand(n, N_LINKS, generator=gen, device=device) * 2.0 - 1.0) * TRAIN_THETA_HALF
-    omega = (t.rand(n, N_LINKS, generator=gen, device=device) * 2.0 - 1.0) * TRAIN_OMEGA_HALF
-    return theta, omega
-
-
-def sample_upright_init(n, gen=None, device="cpu"):
-    """Curriculum-only: small perturbation around upright (theta = pi)."""
-    t = torch
-    theta = np.pi + (t.rand(n, N_LINKS, generator=gen, device=device) * 2.0 - 1.0) * TRAIN_THETA_HALF
-    omega = (t.rand(n, N_LINKS, generator=gen, device=device) * 2.0 - 1.0) * TRAIN_OMEGA_HALF
-    return theta, omega
-
-
-def fixed_init(n, device="cpu"):
-    theta = torch.tensor(EVAL_THETA0, dtype=torch.float32, device=device).repeat(n, 1)
-    omega = torch.zeros(n, N_LINKS, dtype=torch.float32, device=device)
-    return theta, omega
-
-
-def make_init(n, mode="rand", gen=None, device="cpu", up_frac=0.5):
-    if mode == "rand":
-        return sample_train_init(n, gen=gen, device=device)
-    if mode == "fixed":
-        return fixed_init(n, device=device)
-    if mode == "mix":
-        # Curriculum: a fraction up_frac of resets start near upright so the
-        # balance phase is actually visited; the rest start near down.
-        n_up = int(round(float(up_frac) * n))
-        n_down = n - n_up
-        th_d, om_d = sample_train_init(n_down, gen=gen, device=device)
-        th_u, om_u = sample_upright_init(n_up, gen=gen, device=device)
-        theta = torch.cat([th_d, th_u], dim=0)
-        omega = torch.cat([om_d, om_u], dim=0)
-        perm = torch.randperm(n, generator=gen, device=device)
-        return theta[perm], omega[perm]
-    raise ValueError(mode)
-
-
-class NumpyTask:
-    def __init__(self, p: Params, reward_w=None, obs_mode="full"):
-        self.p = p
-        self.w = dict(DEFAULT_W if reward_w is None else reward_w)
-        self.obs_mode = obs_mode
-        self.builder = make_numpy_obs(obs_mode)
-        self.tracker = NumpyTracker()
-
-    def reset(self, theta):
-        self.tracker.reset()
-        return self.builder.reset(theta)
-
-    def step(self, theta, u):
-        obs = self.builder.update(theta)
-        r = reward_np(theta, self.builder.da, u, self.p, self.w)
-        self.tracker.update(theta, r)
-        return obs, r
-
-    @property
-    def obs(self):
-        return self.builder.obs
-
-
-class TorchTask:
-    def __init__(self, p: Params, n: int, reward_w=None, device="cpu",
-                 obs_mode="full"):
-        self.p = p
-        self.n = int(n)
-        self.w = dict(DEFAULT_W if reward_w is None else reward_w)
-        self.obs_mode = obs_mode
-        self.builder = make_torch_obs(n, obs_mode, device=device)
-        self.reward = TorchReward(p, self.w, device)
-        self.tracker = TorchTracker(n, device=device)
-
-    def reset(self, theta, idx=None):
-        self.tracker.reset(idx)
-        return self.builder.reset(theta, idx)
-
-    def step(self, theta, u):
-        obs = self.builder.update(theta)
-        r = self.reward(theta, self.builder.da, u)
-        self.tracker.update(theta, r)
-        return obs, r
-
-    @property
-    def obs(self):
-        return self.builder.obs()
-
-    def summary(self, idx):
-        return self.tracker.summary(idx)

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

@@ -1,188 +0,0 @@
-"""Contract checks for the v2 random-init / SAC feasibility round.
-
-Checks, in order:
-  1. simulator API returns three angles only -- no reward/loss/done/info;
-  2. the 3000-step budget raises EpisodeLengthError and reset() restores it
-     (single and batched simulators, including partial resets);
-  3. training reset is pure noise U(-.05,.05) / U(-.02,.02) with no bias;
-     the fixed control and the evaluation use [0.013,-0.008,0.021], omega=0;
-  4. observation definition: a=wrap(theta-pi), da=wrap(a-a_prev)/dt with
-     da(0)=0, frame=[cos a, sin a, da/5], H=4, 36 dims, theta not /pi;
-  5. the observation builder cannot see omega (signature check) and the torch
-     builder matches numpy;
-  6. t_can/success bookkeeping holds a streak and resets on leaving upright;
-  7. trainer-side reward is finite and the fixed-init evaluation runs.
-"""
-from __future__ import annotations
-
-import inspect
-
-import numpy as np
-import torch
-
-from evaluate import evaluate
-from obs import DT, H, NumpyAngleObs, OBS_DIM, TorchAngleObs, wrap_to_pi
-from sim import (EPISODE_STEPS, EpisodeLengthError, Params, PendulumSim,
-                 TorchVecSim)
-from task import (EVAL_THETA0, NumpyTask, TorchTracker, make_init,
-                  sample_train_init)
-
-p = Params()
-
-
-def frame(a, da):
-    cs = np.empty(6)
-    cs[0::2] = np.cos(a)
-    cs[1::2] = np.sin(a)
-    return np.concatenate([cs, np.asarray(da) / 5.0])
-
-
-print("obs_dim", OBS_DIM)
-assert OBS_DIM == 36 and H == 4
-
-# --- 1. angle-only API ------------------------------------------------------
-sim = PendulumSim(p)
-th0 = np.array([0.013, -0.008, 0.021])
-out = sim.reset(th0, np.zeros(3))
-assert isinstance(out, np.ndarray) and out.shape == (3,)
-assert np.allclose(out, th0)
-out = sim.step(np.array([0.1, -0.2]))
-assert isinstance(out, np.ndarray) and out.shape == (3,)
-assert len(inspect.signature(PendulumSim.step).parameters) == 2
-assert "reward" not in inspect.getsource(PendulumSim.step).lower()
-assert not hasattr(sim, "omega") and not hasattr(sim, "done")
-print("single sim step returns only 3 angles; no public omega/done")
-
-# --- 2. episode budget ------------------------------------------------------
-short = PendulumSim(p, episode_steps=5)
-short.reset(th0, np.zeros(3))
-for _ in range(5):
-    short.step(np.zeros(2))
-try:
-    short.step(np.zeros(2))
-    raise AssertionError("expected EpisodeLengthError")
-except EpisodeLengthError as e:
-    print("single sim budget error:", str(e)[:60])
-short.reset(th0, np.zeros(3))
-short.step(np.zeros(2))
-
-vec = TorchVecSim(p, n=2, episode_steps=5)
-assert not hasattr(vec, "omega") and not hasattr(vec, "done")
-vec.reset(torch.tensor([th0, th0]), torch.zeros(2, 3))
-for _ in range(5):
-    vec.step(torch.zeros(2, 2))
-try:
-    vec.step(torch.zeros(2, 2))
-    raise AssertionError("expected batched EpisodeLengthError")
-except EpisodeLengthError as e:
-    print("vec sim budget error:", str(e)[:70])
-# resetting only one env must still raise because env 1 is exhausted
-vec.reset(torch.tensor([th0]), torch.zeros(1, 3), idx=torch.tensor([0]))
-try:
-    vec.step(torch.zeros(2, 2))
-    raise AssertionError("expected error while env 1 exhausted")
-except EpisodeLengthError:
-    pass
-vec.reset(torch.tensor([th0, th0]), torch.zeros(2, 3))
-vec.step(torch.zeros(2, 2))
-print("batched sim budget + partial reset contract OK")
-
-# --- 3. reset distributions -------------------------------------------------
-gen = torch.Generator().manual_seed(0)
-th, om = sample_train_init(20000, gen)
-assert th.abs().max() <= 0.05 + 1e-6 and om.abs().max() <= 0.02 + 1e-6
-assert th.abs().max() > 0.049 and om.abs().max() > 0.019
-assert th.mean().abs() < 0.002 and om.mean().abs() < 0.001, (th.mean(), om.mean())
-print("random init ranges", float(th.min()), float(th.max()),
-      float(om.min()), float(om.max()), "means", float(th.mean()), float(om.mean()))
-
-thf, omf = make_init(4, "fixed")
-assert np.allclose(thf.numpy(), np.tile(EVAL_THETA0, (4, 1)))
-assert np.allclose(omf.numpy(), 0.0)
-thf2, omf2 = make_init(4, "rand", gen)
-print("fixed init", thf[0].tolist(), "eval", EVAL_THETA0.tolist())
-
-# --- 4. observation definition ---------------------------------------------
-th0 = np.array([0.013, -0.008, 0.021])
-th1 = np.array([0.063, -0.048, 0.001])
-b = NumpyAngleObs()
-o0 = b.reset(th0)
-a0 = wrap_to_pi(th0 - np.pi)
-want0 = np.tile(frame(a0, np.zeros(3)), H)
-assert np.allclose(o0, want0, atol=1e-6)
-o1 = b.update(th1)
-a1 = wrap_to_pi(th1 - np.pi)
-da = wrap_to_pi(a1 - a0) / DT
-want_last = frame(a1, da)
-mat = o1.reshape(H, 9)
-assert np.allclose(mat[-1], want_last, atol=1e-6)
-assert np.allclose(mat[:-1], np.tile(want0.reshape(H, 9)[0], (H - 1, 1)), atol=1e-6)
-# theta is not divided by pi: a=theta-pi, not theta/pi-pi
-assert np.allclose(mat[-1, :2], [np.cos(a1[0]), np.sin(a1[0])], atol=1e-6)
-assert not np.allclose(mat[-1, :2], [np.cos(th1[0] / np.pi - np.pi),
-                                     np.sin(th1[0] / np.pi - np.pi)], atol=1e-3)
-# da initialisation is exactly zero
-assert np.allclose(o0.reshape(H, 9)[:, 6:], 0.0)
-print("obs frame(last)", np.round(mat[-1], 4), "da", np.round(da, 4))
-
-# wrap in the difference: crossing the -pi/pi boundary must not spike
-b.reset(np.array([np.pi - 0.01, 0.0, 0.0]))
-o = b.update(np.array([-np.pi + 0.01, 0.0, 0.0])).reshape(H, 9)
-assert abs(o[-1, 6] - (0.02 / DT) / 5.0) < 1e-5, o[-1, 6]
-print("da wrap OK")
-
-# --- 5. no omega in observation API; torch matches numpy --------------------
-assert list(inspect.signature(NumpyAngleObs.update).parameters) == ["self", "theta"]
-assert list(inspect.signature(NumpyAngleObs.reset).parameters) == ["self", "theta"]
-assert list(inspect.signature(TorchAngleObs.update).parameters) == ["self", "theta"]
-tb = TorchAngleObs(1)
-ot = tb.reset(torch.tensor(th0, dtype=torch.float32).unsqueeze(0))
-assert np.allclose(ot.numpy().reshape(-1), o0, atol=1e-5)
-ot = tb.update(torch.tensor(th1, dtype=torch.float32).unsqueeze(0))
-assert np.allclose(ot.numpy().reshape(H, 9), mat, atol=1e-5)
-print("numpy/torch obs builders match; no omega argument")
-
-# --- 6. success / t_can bookkeeping ----------------------------------------
-tr = TorchTracker(1)
-tr.reset()
-up_theta = torch.tensor([[np.pi + 0.01, np.pi - 0.01, np.pi + 0.02]])
-for _ in range(1500):
-    tr.update(up_theta, torch.zeros(1))
-s = tr.summary(torch.tensor([0]))
-assert abs(float(s["t_can"]) - 14.99) < 1e-2, float(s["t_can"])
-assert abs(float(s["up_frac"]) - 1.0) < 1e-2, float(s["up_frac"])  # all steps up
-assert float(s["ever_up"]) == 1.0 and abs(float(s["first_up_t"]) - 0.01) < 1e-3
-tr.update(torch.tensor([[0.0, 0.0, 0.0]]), torch.zeros(1))  # leave upright
-for _ in range(500):
-    tr.update(up_theta, torch.zeros(1))
-s = tr.summary(torch.tensor([0]))
-assert abs(float(s["t_can"]) - 14.99) < 1e-2, float(s["t_can"])
-print("tracker t_can", float(s["t_can"]), "ever_up", float(s["ever_up"]),
-      "first_up_t", float(s["first_up_t"]))
-
-# --- 7. trainer reward + fixed-init evaluation ------------------------------
-task = NumpyTask(p)
-theta = np.array([0.013, -0.008, 0.021])
-_ = task.reset(theta)
-_, r = task.step(theta, np.array([0.0, 0.0]))
-assert np.isfinite(r)
-print("initial trainer reward", float(r))
-
-ev = evaluate(lambda obs: np.zeros(2), p, episode_steps=200)
-assert ev["steps"] == 200 and np.isfinite(ev["ep_return"])
-assert ev["t_can"] == 0.0 and ev["ever_up"] == 0.0
-print("fixed-init eval (200 steps)", {k: ev[k] for k in
-      ("t_can", "success", "ever_up", "ep_return", "final_ang_err")})
-
-# torch/numpy physics agreement on a short rollout
-s1 = PendulumSim(p)
-t1 = s1.reset(th0, np.zeros(3))
-s2 = TorchVecSim(p, n=1)
-s2.reset(torch.tensor(th0, dtype=torch.float32).unsqueeze(0), torch.zeros(1, 3))
-u = np.array([0.3, -0.4])
-for _ in range(20):
-    t1 = s1.step(u)
-    t2 = s2.step(torch.tensor(u, dtype=torch.float32).unsqueeze(0)).numpy()[0]
-assert np.allclose(t1, t2, atol=1e-4), (t1, t2)
-print("numpy/torch physics agree after 20 steps:", np.round(t1, 6), np.round(t2, 6))
-print("ALL CONTRACT CHECKS PASSED")