dsh-eval-guard 0.7.3 → 0.7.4

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

@@ -0,0 +1,406 @@
+"""SAC + 2x256 tanh MLP + sin/cos H=4 observation, angle-only simulator.
+
+Experiments:
+  --init rand   : theta_i ~ U(-.05,.05), omega_i ~ U(-.02,.02), no bias
+  --init fixed  : training reset is exactly theta=[0.013,-0.008,0.021], omega=0
+
+32 vectorised environments by default, replay buffer, auto entropy tuning,
+shared-trunk twin Q, UTD = 0.25 (8 gradient steps per 32-env vector step).
+The simulator exposes angles only; observation, reward, termination, success
+and t_can all live in trainer-side code (obs.py / task.py).
+
+TensorBoard scalars (tb/<exp>/):
+  train/episode_return, train/episode_length, train/t_can, train/t_can_max,
+  train/success_rate, train/ever_up_frac, train/first_up_time, train/up_frac,
+  train/action_abs_mean, train/replay_size, train/steps_per_s, train/alpha,
+  train/entropy, train/q_mean, train/q_target_mean,
+  loss/actor, loss/critic, loss/alpha, loss/policy, loss/value, loss/entropy,
+  eval/t_can, eval/success, eval/ep_return, eval/ever_up, eval/final_ang_err,
+  eval/first_up_t, eval/up_frac, eval_final/*, time/elapsed_min
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import os
+import time
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.tensorboard import SummaryWriter
+
+torch.set_num_threads(int(os.environ.get("TORCH_THREADS", "4")))
+
+from evaluate import evaluate, evaluate_starts, make_sac_policy
+from models import SquashedGaussianActor, TwinQ
+from obs import OBS_MODES, obs_spec
+from sim import EPISODE_STEPS, Params, TorchVecSim
+from task import (TORCH_REWARD_NOTE, TorchTask, get_reward_preset, make_init,
+                  sample_train_init)
+
+
+class Replay:
+    def __init__(self, cap, dim, act_dim=2):
+        self.cap = int(cap)
+        self.obs = np.zeros((cap, dim), np.float32)
+        self.act = np.zeros((cap, act_dim), np.float32)
+        self.rew = np.zeros((cap, 1), np.float32)
+        self.nobs = np.zeros((cap, dim), np.float32)
+        self.done = np.zeros((cap, 1), np.float32)
+        self.ptr = 0
+        self.size = 0
+
+    def push(self, obs, act, rew, nobs, done):
+        n = obs.shape[0]
+        idx = (self.ptr + np.arange(n)) % self.cap
+        self.obs[idx] = obs
+        self.act[idx] = act
+        self.rew[idx] = np.asarray(rew).reshape(n, 1)
+        self.nobs[idx] = nobs
+        self.done[idx] = np.asarray(done).reshape(n, 1)
+        self.ptr = (self.ptr + n) % self.cap
+        self.size = min(self.cap, self.size + n)
+
+    def sample(self, batch):
+        idx = np.random.randint(0, self.size, size=batch)
+        return (torch.from_numpy(self.obs[idx]),
+                torch.from_numpy(self.act[idx]),
+                torch.from_numpy(self.rew[idx]),
+                torch.from_numpy(self.nobs[idx]),
+                torch.from_numpy(self.done[idx]))
+
+
+def soft_update(tgt, src, tau):
+    with torch.no_grad():
+        for a, b in zip(tgt.parameters(), src.parameters()):
+            a.mul_(1 - tau).add_(tau * b)
+
+
+def sac_update(actor, q, qt, act_opt, q_opt, log_alpha, alpha_opt, replay, args):
+    o, ac, r, no, d = replay.sample(args.batch)
+    with torch.no_grad():
+        na, nlogp = actor.sample(no)
+        q_next = qt(no, na).min(dim=1).values
+        target = r.squeeze(-1) + args.gamma * (1.0 - d.squeeze(-1)) * (
+            q_next - log_alpha.exp() * nlogp)
+    q_pred = q(o, ac)
+    critic_loss = 0.5 * F.mse_loss(q_pred, target.unsqueeze(1).expand(-1, 2))
+    q_opt.zero_grad()
+    critic_loss.backward()
+    nn.utils.clip_grad_norm_(q.parameters(), 10.0)
+    q_opt.step()
+
+    for p_ in q.parameters():
+        p_.requires_grad_(False)
+    pa, logp = actor.sample(o)
+    q_pi = q(o, pa).min(dim=1).values
+    actor_loss = (log_alpha.exp().detach() * logp - q_pi).mean()
+    act_opt.zero_grad()
+    actor_loss.backward()
+    nn.utils.clip_grad_norm_(actor.parameters(), 10.0)
+    act_opt.step()
+    for p_ in q.parameters():
+        p_.requires_grad_(True)
+
+    alpha_loss = -(log_alpha.exp() * (logp.detach() + args.target_entropy)).mean()
+    alpha_opt.zero_grad()
+    alpha_loss.backward()
+    alpha_opt.step()
+
+    soft_update(qt, q, args.tau)
+    return dict(actor=float(actor_loss), critic=float(critic_loss),
+                alpha=float(alpha_loss),
+                q=float(q_pred.mean()), qt=float(target.mean()),
+                entropy=float(-logp.detach().mean()))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--exp", type=str, required=True)
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--init", type=str, default="rand",
+                    choices=["rand", "fixed", "mix"],
+                    help="rand=down noise, fixed=eval state, "
+                         "mix=curriculum with up_frac near upright")
+    ap.add_argument("--up-frac", type=float, default=0.5,
+                    help="fraction of resets near upright when --init mix")
+    ap.add_argument("--obs", type=str, default="full",
+                    choices=sorted(OBS_MODES),
+                    help="observation mode (see obs.py)")
+    ap.add_argument("--reward", type=str, default="base",
+                    choices=["base", "sparse", "energy"],
+                    help="reward preset (see task.py REWARD_PRESETS)")
+    ap.add_argument("--envs", type=int, default=32)
+    ap.add_argument("--minutes", type=float, default=30.0)
+    ap.add_argument("--steps", type=int, default=10 ** 12)
+    ap.add_argument("--hidden", type=int, default=256)
+    ap.add_argument("--depth", type=int, default=2)
+    ap.add_argument("--lr", type=float, default=3e-4)
+    ap.add_argument("--gamma", type=float, default=0.99)
+    ap.add_argument("--tau", type=float, default=0.005)
+    ap.add_argument("--batch", type=int, default=256)
+    ap.add_argument("--warmup", type=int, default=5000)
+    ap.add_argument("--buffer", type=int, default=300000)
+    ap.add_argument("--utd", type=float, default=0.25,
+                    help="gradient steps per environment step")
+    ap.add_argument("--target-entropy", type=float, default=-2.0)
+    ap.add_argument("--alpha-init", type=float, default=0.2)
+    ap.add_argument("--episode-steps", type=int, default=EPISODE_STEPS)
+    ap.add_argument("--eval-every", type=int, default=20000)
+    ap.add_argument("--eval-start", type=int, default=20000)
+    ap.add_argument("--tb-root", type=str, default="tb")
+    ap.add_argument("--ckpt-dir", type=str, default="checkpoints")
+    ap.add_argument("--out", type=str, default="results")
+    ap.add_argument("--tau-max", type=float, default=18.0)
+    ap.add_argument("--damping", type=float, default=0.01)
+    ap.add_argument("--log-every", type=int, default=10,
+                    help="log every N vector steps")
+    ap.add_argument("--robust-starts", type=int, default=8,
+                    help="deterministic extra rollouts from the training "
+                         "reset distribution at the end (0 disables)")
+    args = ap.parse_args()
+
+    torch.manual_seed(args.seed)
+    np.random.seed(args.seed)
+    for d in (args.tb_root, args.ckpt_dir, args.out):
+        os.makedirs(d, exist_ok=True)
+    exp = args.exp
+    writer = SummaryWriter(os.path.join(args.tb_root, exp))
+    p = Params(tau_max=args.tau_max, b=args.damping)
+    spec = obs_spec(args.obs)
+    obs_dim = spec["dim"]
+    reward_w = get_reward_preset(args.reward)
+    sim = TorchVecSim(p, n=args.envs, episode_steps=args.episode_steps)
+    task = TorchTask(p, n=args.envs, reward_w=reward_w, obs_mode=args.obs)
+    gen = torch.Generator().manual_seed(args.seed * 1000 + 11)
+    updates_per_vec = max(1, int(round(args.utd * args.envs)))
+    eff_utd = updates_per_vec / args.envs
+
+    init_meta = dict(mode=args.init,
+                     training=("theta_i ~ U(-0.05,0.05), omega_i ~ U(-0.02,0.02); no bias"
+                               if args.init == "rand" else
+                               ("theta=[0.013,-0.008,0.021], omega=0 (same as eval)"
+                                if args.init == "fixed" else
+                                f"curriculum: {args.up_frac:.2f} near upright "
+                                f"(pi + U(-0.05,0.05)), rest near down")),
+                     eval="theta=[0.013,-0.008,0.021], omega=0 (fixed, no noise)")
+    meta = dict(algo="sac", exp=exp, seed=args.seed, envs=args.envs,
+                obs=spec, obs_dim=obs_dim, init=init_meta,
+                reward=reward_w, reward_preset=args.reward,
+                reward_note=TORCH_REWARD_NOTE,
+                updates_per_vector=updates_per_vec, effective_utd=eff_utd,
+                args=vars(args))
+    writer.add_text("config", json.dumps(meta, indent=2), 0)
+    print(json.dumps(meta, indent=2), flush=True)
+
+    actor = SquashedGaussianActor(obs_dim, 2, hidden=args.hidden, depth=args.depth)
+    q = TwinQ(obs_dim, 2, hidden=args.hidden, depth=args.depth)
+    qt = copy.deepcopy(q)
+    act_opt = torch.optim.Adam(actor.parameters(), lr=args.lr)
+    q_opt = torch.optim.Adam(q.parameters(), lr=args.lr)
+    log_alpha = torch.log(torch.tensor(args.alpha_init)).clone().detach().requires_grad_(True)
+    alpha_opt = torch.optim.Adam([log_alpha], lr=args.lr)
+
+    replay = Replay(args.buffer, obs_dim, 2)
+    th, om = make_init(args.envs, args.init, gen, up_frac=args.up_frac)
+    theta = sim.reset(th, om)
+    obs = task.reset(theta)
+
+    t_start = time.time()
+    total = 0
+    n_updates = 0
+    vec_steps = 0
+    next_eval = args.eval_start
+    best_t_can = -1.0
+    best_eval = None
+    best_path = None
+    last_path = None
+    eval_curve = []
+    last = dict(actor=float("nan"), critic=float("nan"), alpha=float("nan"),
+                q=float("nan"), qt=float("nan"), entropy=float("nan"))
+    ep = {k: [] for k in ("return", "t_can", "ever_up", "first_up", "up_frac", "length")}
+
+    def save_ckpt(path, ev):
+        torch.save(dict(model=actor.state_dict(), q=q.state_dict(),
+                        log_alpha=log_alpha.detach(), obs=spec,
+                        obs_dim=obs_dim, init=init_meta, reward=reward_w,
+                        reward_preset=args.reward,
+                        args=vars(args), global_steps=total,
+                        n_updates=n_updates, eval=ev, algo="sac"),
+                   os.path.join(args.ckpt_dir, path))
+
+    def log_eval(ev):
+        nonlocal best_t_can, best_eval, best_path, last_path
+        eval_curve.append(dict(global_steps=total, n_updates=n_updates, **ev))
+        for k, v in ev.items():
+            if isinstance(v, (int, float)):
+                writer.add_scalar(f"eval/{k}", v, total)
+        if (ev["t_can"] > best_t_can
+                or (ev["t_can"] == best_t_can and best_eval is not None
+                    and ev["ep_return"] > best_eval["ep_return"])):
+            best_t_can = ev["t_can"]
+            best_eval = dict(ev)
+            best_path = exp + "_best.pt"
+            save_ckpt(best_path, ev)
+        last_path = exp + "_last.pt"
+        save_ckpt(last_path, ev)
+
+    while total < args.steps:
+        if (time.time() - t_start) / 60.0 > args.minutes:
+            print("time budget reached", flush=True)
+            break
+        if replay.size < args.warmup:
+            u = torch.rand(args.envs, 2) * 2.0 - 1.0
+        else:
+            with torch.no_grad():
+                u, _ = actor.sample(obs)
+            u = torch.clamp(u, -1.0, 1.0)
+        theta = sim.step(u)
+        nobs, rew = task.step(theta, u)
+        done = sim.steps >= sim.episode_steps
+        replay.push(obs.detach().cpu().numpy(), u.detach().cpu().numpy(),
+                    rew.detach().cpu().numpy(), nobs.detach().cpu().numpy(),
+                    done.detach().cpu().numpy())
+        if bool(done.any()):
+            idx = done.nonzero().flatten()
+            summ = task.summary(idx)
+            ep["return"] += summ["ep_return"].tolist()
+            ep["t_can"] += summ["t_can"].tolist()
+            ep["ever_up"] += summ["ever_up"].tolist()
+            ep["first_up"] += summ["first_up_t"].tolist()
+            ep["up_frac"] += summ["up_frac"].tolist()
+            ep["length"] += summ["length"].tolist()
+            th, om = make_init(idx.numel(), args.init, gen, up_frac=args.up_frac)
+            reset_theta = sim.reset(th, om, idx)
+            task.reset(reset_theta, idx)
+            nobs = task.obs
+        obs = nobs
+        total += args.envs
+        vec_steps += 1
+
+        if replay.size >= args.warmup:
+            for _ in range(updates_per_vec):
+                last = sac_update(actor, q, qt, act_opt, q_opt, log_alpha,
+                                  alpha_opt, replay, args)
+                n_updates += 1
+
+        if vec_steps % args.log_every == 0:
+            elapsed = time.time() - t_start
+            if ep["return"]:
+                writer.add_scalar("train/episode_return",
+                                  float(np.mean(ep["return"])), total)
+                writer.add_scalar("train/episode_length",
+                                  float(np.mean(ep["length"])), total)
+                writer.add_scalar("train/t_can", float(np.mean(ep["t_can"])), total)
+                writer.add_scalar("train/t_can_max", float(np.max(ep["t_can"])), total)
+                writer.add_scalar("train/success_rate",
+                                  float(np.mean(np.asarray(ep["t_can"]) >= 10.0)), total)
+                writer.add_scalar("train/ever_up_frac",
+                                  float(np.mean(ep["ever_up"])), total)
+                writer.add_scalar("train/up_frac",
+                                  float(np.mean(ep["up_frac"])), total)
+                fu = [x for x in ep["first_up"] if x > 0]
+                if fu:
+                    writer.add_scalar("train/first_up_time", float(np.mean(fu)), total)
+                ep = {k: [] for k in ep}
+            writer.add_scalar("train/replay_size", replay.size, total)
+            writer.add_scalar("train/steps_per_s", total / max(elapsed, 1e-9), total)
+            writer.add_scalar("train/alpha", float(log_alpha.detach().exp()), total)
+            writer.add_scalar("train/action_abs_mean", float(u.abs().mean()), total)
+            writer.add_scalar("train/action_std", float(u.std()), total)
+            writer.add_scalar("loss/actor", last["actor"], total)
+            writer.add_scalar("loss/critic", last["critic"], total)
+            writer.add_scalar("loss/alpha", last["alpha"], total)
+            writer.add_scalar("loss/policy", last["actor"], total)
+            writer.add_scalar("loss/value", last["critic"], total)
+            writer.add_scalar("loss/entropy", last["entropy"], total)
+            writer.add_scalar("train/entropy", last["entropy"], total)
+            writer.add_scalar("train/q_mean", last["q"], total)
+            writer.add_scalar("train/q_target_mean", last["qt"], total)
+            writer.add_scalar("train/global_steps", total, total)
+            writer.add_scalar("time/elapsed_min", elapsed / 60.0, total)
+            writer.flush()
+
+        if total >= next_eval:
+            next_eval += args.eval_every
+            ev = evaluate(make_sac_policy(actor), p, args.episode_steps,
+                          reward_w=reward_w, obs_mode=args.obs)
+            log_eval(ev)
+            print(f"steps {total/1e3:7.1f}k upd {n_updates:6d}  "
+                  f"EVAL tc {ev['t_can']:6.2f} succ {ev['success']:.0f} "
+                  f"everup {ev['ever_up']:.0f} angerr {ev['final_ang_err']:.3f} "
+                  f"ret {ev['ep_return']:8.1f}  q {last['q']:8.2f} "
+                  f"a {float(log_alpha.detach().exp()):.2f} "
+                  f"({time.time()-t_start:.0f}s)", flush=True)
+            writer.flush()
+
+    ev_final = evaluate(make_sac_policy(actor), p, args.episode_steps,
+                        reward_w=reward_w, obs_mode=args.obs)
+    eval_curve.append(dict(global_steps=total, n_updates=n_updates, **ev_final))
+    for k, v in ev_final.items():
+        if isinstance(v, (int, float)):
+            writer.add_scalar(f"eval_final/{k}", v, total)
+    final_path = exp + "_final.pt"
+    save_ckpt(final_path, ev_final)
+    last_path = exp + "_last.pt"
+    save_ckpt(last_path, ev_final)
+
+    # Extra deterministic rollouts from the training reset distribution.  This
+    # is NOT the mandated fixed-state eval; it checks generalisation.
+    rob = None
+    rob_best = None
+    if args.robust_starts > 0:
+        g = torch.Generator().manual_seed(args.seed * 1000 + 123)
+        th_r, om_r = sample_train_init(args.robust_starts, gen=g)
+        starts = list(zip(th_r.numpy(), om_r.numpy()))
+        rob = evaluate_starts(make_sac_policy(actor), p, starts,
+                              args.episode_steps, reward_w=reward_w,
+                              obs_mode=args.obs)
+        for k, v in rob.items():
+            if isinstance(v, (int, float)):
+                writer.add_scalar(f"robust/{k}", v, total)
+        if best_path is not None:
+            ck = torch.load(os.path.join(args.ckpt_dir, best_path),
+                            map_location="cpu")
+            actor_best = SquashedGaussianActor(obs_dim, 2, hidden=args.hidden,
+                                               depth=args.depth)
+            actor_best.load_state_dict(ck["model"])
+            rob_best = evaluate_starts(make_sac_policy(actor_best), p, starts,
+                                       args.episode_steps, reward_w=reward_w,
+                                       obs_mode=args.obs)
+            for k, v in rob_best.items():
+                if isinstance(v, (int, float)):
+                    writer.add_scalar(f"robust_best/{k}", v, total)
+
+    wall = time.time() - t_start
+    out = dict(algo="sac", exp=exp, seed=args.seed, envs=args.envs,
+               obs=spec, obs_dim=obs_dim, init=init_meta,
+               reward=reward_w, reward_preset=args.reward,
+               reward_note=TORCH_REWARD_NOTE,
+               args=vars(args), updates_per_vector=updates_per_vec,
+               effective_utd=eff_utd, minutes_budget=args.minutes,
+               global_steps=total, gradient_steps=n_updates,
+               wall_time_s=wall, steps_per_s=total / max(wall, 1e-9),
+               updates_per_s=n_updates / max(wall, 1e-9),
+               final_eval=ev_final, best_eval=best_eval, best_t_can=best_t_can,
+               eval_curve=eval_curve, robust=rob, robust_best=rob_best,
+               final_train=last,
+               checkpoints=dict(best=best_path, last=last_path,
+                                final=final_path))
+    with open(os.path.join(args.out, exp + ".json"), "w") as f:
+        json.dump(out, f, indent=2)
+    writer.flush()
+    writer.close()
+    print("DONE " + json.dumps(dict(
+        exp=exp, init=args.init, seed=args.seed, envs=args.envs,
+        global_steps=total, gradient_steps=n_updates, wall_s=round(wall, 1),
+        steps_per_s=round(out["steps_per_s"], 1),
+        eval_t_can=ev_final["t_can"], best_t_can=best_t_can,
+        eval_return=ev_final["ep_return"])), flush=True)
+
+
+if __name__ == "__main__":
+    main()

package/assets/neural-pendulum/sim.cpp

@@ -65,7 +65,13 @@ static void deriv(const State& s, const std::array<double,N>& tau, State& out) {
   std::array<double,N> C{}, G{}, Q{}, rhs{};
   for(int i=0;i<N;i++){
     double ci=0;
-    for(int j=0;j<N;j++) if(j!=i) ci += M[i][j] * std::sin(s.theta[i]-s.theta[j]) * s.omega[j]*s.omega[j];
+    for(int j=0;j<N;j++) if(j!=i) {
+      // Coriolis coefficient: d(M_ij)/d(theta_j) = LEN[min] * GCOEF[max] * sin(...);
+      // M_ij itself already contains cos(...), so multiplying M_ij by sin would
+      // add an extra cos factor and inject energy at high speed (NaN after ~7 s).
+      const int a=std::min(i,j), b=std::max(i,j);
+      ci += LEN[a] * GCOEF[b] * std::sin(s.theta[i]-s.theta[j]) * s.omega[j]*s.omega[j];
+    }
     C[i]=ci;
     G[i]=GRAV*std::sin(s.theta[i])*GCOEF[i];
   }
@@ -101,7 +107,12 @@ int main(int argc, char** argv) {
       // parse torque array
       double u1=0,u3=0; auto p=line.find('['); if(p!=std::string::npos){ char* end=nullptr; u1=std::strtod(line.c_str()+p+1,&end); if(end){ const char* q=end; while(*q && (*q==','||*q==' ')) q++; u3=std::strtod(q,&end); } }
       u1=std::max(-1.0,std::min(1.0,u1)); u3=std::max(-1.0,std::min(1.0,u3));
-      std::array<double,N> tau{{u1*TAU_MAX,0.0,u3*TAU_MAX}};
+      // Joint 3 is an internal motor between link 2 and link 3. In absolute
+      // coordinates its generalized force is (tau1, -tau3, tau3): the reaction
+      // on link 2 is part of the same joint torque. (tau1, 0, tau3) would be a
+      // reactionless external torque on link 3 and would contradict joint 2
+      // being passive.
+      std::array<double,N> tau{{u1*TAU_MAX,-u3*TAU_MAX,u3*TAU_MAX}};
       // one control step with 4 RK4 substeps
       double h=DT/SUB;
       for(int sub=0;sub<SUB;sub++){

package/lib/index.js

@@ -887,6 +887,8 @@ function bwrapArgs(workspace, rules, runtime) {
 	args.push("--setenv", "LC_ALL", "C.UTF-8");
 	args.push("--setenv", "TERM", "dumb");
 	args.push("--setenv", "UV_USE_IO_URING", "0");
+	args.push("--setenv", "PIP_DISABLE_PIP_VERSION_CHECK", "1");
+	args.push("--setenv", "PIP_NO_INPUT", "1");
 	return args;
 }
 /**
@@ -2480,10 +2482,12 @@ const NEURAL_PENDULUM_DEFINITION = {
 			"",
 			"请先完整阅读 TASK.md；它是权威规则。硬约束：仅 C++17 标准库、仅 CPU、fp32；不使用 Python/OpenCL/CUDA/BLAS/Eigen/第三方库；必须从提交源码构建出 build/nn_task 与 build/control。",
 			"",
-			"环境细节：joint1 与 joint3 驱动，joint2 被动；控制频率 100 Hz；每回合最多 3000 步（30 s），达到上限后继续 step 返回 {\"error\":\"episode_finished\"}，必须 reset。环境只返回三个关节角度（弧度，不除 pi），不返回 reward/loss/cost/done；环境不提供杆长、质量、惯量、角速度或 tip。训练 reset 带小范围随机初始角度和角速度；评测使用固定初始状态，无随机扰动。",
+			"环境细节：joint1 与 joint3 驱动，joint2 被动；控制频率 100 Hz；每回合最多 3000 步（30 s），达到上限后继续 step 返回 {\"error\":\"episode_finished\"}，必须 reset。theta=0 表示竖直向下、theta=pi 表示竖直向上；观测 a_i=wrap(theta_i-pi)，即三个关节角度（弧度，不除 pi）。环境不返回 reward/loss/cost/done；不提供杆长、质量、惯量、角速度或 tip。训练 reset 带小范围随机初始角度和角速度；评测使用固定初始状态，无随机扰动。",
 			"",
 			"优化目标：从接近全向下起摆，使三根杆全部进入 0.05 rad 的竖直向上容差，并尽可能长时间保持；评测指标为 t_can。损失函数、奖励、优化器、网络结构和训练方法由你自行设计，不规定任何训练方案。",
 			"",
+			"注意：评测侧用 PyTorch 计算算子参考值，但工作区/候选运行时不提供 PyTorch 或 numpy，也没有网络，无法 pip 安装；开发阶段请用 C++ 或 Python 标准库/独立 double 实现做数值对照。",
+			"",
 			"评测会从干净副本重新构建提交源码，先运行与 Neural-FP32/Neural-CIFAR 相同的算子数值评测：评测侧用 PyTorch 在相同数据上计算参考值，逐操作比较加权平均相对误差并对照阈值，任一算子不可执行、崩溃、超时、输出缺失或误差超阈值即判为基础设施失败；然后在固定初始状态上驱动 build/control，统计连续全向上保持时间 t_can。不要把任何未提交的二进制、临时构建产物或外部进程当作交付依赖。",
 			"使用宿主工具 eval_submit 提交当前源码快照，使用 eval_test 请求宿主评测最新提交。提交快照、事件、测试结果和最终分数全部保存在工作区之外的宿主目录；不要尝试读取或修改这些数据，也不要依赖任何工作区内的测试结果文件。最终评测使用最新提交快照，按宿主事件时间积分计算分数。",
 			"",

package/native/supervisor.c

@@ -3,8 +3,9 @@
  *
  * Installs a seccomp user-notification filter before exec'ing bwrap and enforces
  * a path policy on file-access and network syscalls. Normal syscalls are not
- * logged; only denied operations are appended to the audit file and cause the
- * whole process group to be killed.
+ * logged. File-policy violations are audited and kill the process group;
+ * AF_INET/AF_INET6 connect/bind/sendto are audited and soft-denied with EPERM
+ * so local software checks (pip version probe, NSS fallback) can continue.
  *
  * Usage:
  *   dsh-eval-supervisor --policy <policy-file> --audit <audit-file> -- <program> [args...]
@@ -87,6 +88,7 @@ static int g_dev_count;
 static Rule g_rules[MAX_RULES];
 static int g_rule_count;
 static int g_audit_fd = -1;
+static int g_soft_deny; /* network-family denial: EPERM, do not kill the group */
 static volatile sig_atomic_t g_stop;
 /* The sandbox mounted a private tmpfs at /tmp (workspace under host /tmp). */
 static int g_tmpfs_tmp;
@@ -555,6 +557,7 @@ static int check_notification(pid_t pid, const struct seccomp_notif *req, int *w
 
   path_out[0] = '\0';
   g_current_pid = pid;
+  g_soft_deny = 0;
   if (nr == SYS_execve || nr == SYS_execveat) {
     char executable[MAX_PATH];
     executable[0] = '\0';
@@ -567,20 +570,43 @@ static int check_notification(pid_t pid, const struct seccomp_notif *req, int *w
     return 1;
   }
   if (nr == SYS_socket) {
-    int domain = (int)a0;
+    /* Creating a socket does not transmit anything. bwrap already put the
+     * command in a private network namespace; tools such as pip create an
+     * AF_INET socket for local/version checks without connecting. All the
+     * operations that can actually reach a peer (connect/bind/listen/accept/
+     * sendto/recvfrom) remain denied below. */
     *write_access = 0;
     snprintf(path_out, MAX_PATH, "<network:socket>");
-    /* AF_UNIX/AF_NETLINK stay inside the private network namespace and are
-     * needed by NSS, Python and the dynamic loader. AF_INET/AF_INET6 and raw
-     * sockets are still blocked. */
-    if (domain == AF_UNIX || domain == AF_NETLINK) return 1;
-    return 0;
+    return 1;
   }
   if (is_network_syscall(nr)) {
     *write_access = 0;
     snprintf(path_out, MAX_PATH, "<network:%s>", syscall_name(nr));
-    /* Only AF_UNIX/AF_NETLINK sockets can exist now; their traffic is local
-     * to the private namespace and cannot reach the host network. */
+    /* bwrap itself needs AF_UNIX bind/listen/connect while it sets up the
+     * namespace; only the target's traffic is checked. */
+    if (!g_command_started || (g_current_pid > 0 && is_bwrap(g_current_pid))) return 1;
+    if (nr == SYS_listen || nr == SYS_accept || nr == SYS_accept4 || nr == SYS_recvfrom) {
+      /* No peer can appear outside the private netns; these operate on an
+       * already-authorized local socket. */
+      return 1;
+    }
+    if (nr == SYS_connect || nr == SYS_bind || nr == SYS_sendto) {
+      unsigned long addr_ptr = nr == SYS_sendto ? (unsigned long)req->data.args[4] : a1;
+      unsigned short family = 0;
+      if (addr_ptr != 0 && read_remote(pid, addr_ptr, &family, sizeof(family)) == 0) {
+        if (family == AF_UNIX || family == AF_NETLINK) return 1;
+        if (family == AF_INET || family == AF_INET6) {
+          /* A version check or NSS probe may create the socket and attempt a
+           * connection; return EPERM instead of killing the whole group. The
+           * private netns is the hard boundary; this is the graceful denial. */
+          g_soft_deny = 1;
+          snprintf(path_out, MAX_PATH, "<network:%s:inet>", syscall_name(nr));
+          return 0;
+        }
+      }
+      g_soft_deny = 1;
+      return 0;
+    }
     return 1;
   }
   if (nr == SYS_io_uring_setup || nr == SYS_ptrace || nr == SYS_open_by_handle_at) {
@@ -817,6 +843,12 @@ static void reply_loop(int fd) {
         char syscall_buf[64];
         snprintf(syscall_buf, sizeof(syscall_buf), "%s", syscall_name((long)req.data.nr));
         audit_record((pid_t)req.pid, syscall_buf, path, write_access);
+        if (g_soft_deny) {
+          /* A software check (pip version probe, NSS lookup fallback) gets a
+           * normal EPERM and can continue; file-policy violations still kill. */
+          respond(fd, &req, 0);
+          continue;
+        }
         /* io_uring is a soft denial: libuv probes it despite UV_USE_IO_URING=0
          * and must receive EPERM and fall back to epoll instead of taking the
          * whole command group down. No io_uring instance can exist, so the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-eval-guard",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "type": "module",
   "description": "Evaluation guard for DSH: workspace-only filesystem, no network/subagents, wall-clock limits, and task installation for meow-ai-arena and benchmark tasks.",
   "license": "MIT",
@@ -48,7 +48,7 @@
     "build": "tsdown && node scripts/build-native.mjs",
     "build:native": "node scripts/build-native.mjs",
     "prepare": "tsdown",
-    "test": "node test/simulate.ts && node test/scoring.ts && node test/jobs.ts",
+    "test": "node test/simulate.ts && node test/scoring.ts && node test/jobs.ts && node test/pendulum-sim.ts",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dsh": {