dsh-eval-guard 0.6.1 → 0.7.0

package/assets/neural-pendulum/TASK.md

@@ -0,0 +1,358 @@
+# Neural-Pendulum：从零神经网络基础设施与双驱动三阶摆控制
+
+## 任务目标
+
+从零实现一套纯 C++17、仅 CPU、fp32 的神经网络基础设施，并用它训练一个神经网络控制器，控制预编译的双驱动三节摆。
+
+目标：
+
+- 从三杆全部向下的固定初始状态起摆
+- 保持三根杆全部向上至少 t_tgt = 10.0 秒
+- 同时保证神经网络基础设施全部通过公开测试
+
+允许使用 PyTorch 做开发阶段的自查和数值对照。最终提交源码中不得出现 torch，评测环境不提供 Python/torch。
+
+## 环境
+
+工作区提供预编译仿真器：
+
+~~~
+tools/sim
+~~~
+
+不提供仿真器源码和物理参数。
+
+### 初始状态
+
+训练时每次 reset：
+
+- 三根杆接近全向下
+- 角度以全向下为中心，只加小范围随机噪声
+- 不添加固定角度偏差
+- 带小范围随机初始角速度
+
+评测时：
+
+- 使用固定初始状态
+- 三个固定角度互不相同
+- 三个固定角度的绝对值也互不相同
+- 初始角速度为 0
+- 不加任何随机扰动
+
+### 驱动结构
+
+~~~text
+joint 1：驱动
+joint 2：被动
+joint 3：驱动
+~~~
+
+第一关节和第三关节各有一个归一化力矩输入。
+
+### 观测
+
+控制器每一步只获得三个关节角度：
+
+~~~text
+a_i = wrap_to_pi(theta_i - pi)     i = 1,2,3
+obs = [a1, a2, a3]  (rad)
+~~~
+
+即 3 维观测，单位 rad，不除以 pi。
+
+- theta_i 是第 i 根杆的绝对角度
+- a_i 是相对竖直向上的角度误差
+- 不提供角速度
+- 不提供第三杆末端位置
+- 不提供杆长、质量、惯量等物理参数
+
+控制器的内部结构和训练方法由你自行设计。
+
+### 动作
+
+控制器输出两个归一化力矩：
+
+~~~text
+[u1, u3] ∈ [-1, 1]^2
+~~~
+
+分别作用于第一关节和第三关节。第二关节始终无驱动。
+
+非有限值、超范围或格式错误会判为控制器失败。
+
+### 控制与仿真
+
+~~~
+控制频率 = 100 Hz
+控制周期 = 0.01 s
+最大仿真时间 = 30.0 s
+t_tgt = 10.0 s
+全向上容差 = 每根杆与竖直方向夹角 <= 0.05 rad
+~~~
+
+评测会计算：
+
+~~~
+t_can = 三根杆同时处于全向上容差内的最长连续时间
+~~~
+
+当：
+
+~~~
+t_can >= t_tgt
+且基础设施测试全部通过
+~~~
+
+任务完成，计时停止。
+
+## 训练用仿真接口
+
+tools/sim 使用 JSONL 协议。
+
+输入：
+
+~~~json
+{"cmd":"reset"}
+{"cmd":"step","torque":[0.5,-0.5]}
+~~~
+
+输出：
+
+~~~json
+{"obs":[3 floats]}
+~~~
+
+每个 episode 最多 3000 步（30.0 s）。
+
+达到最大步数后再发送 step：
+
+~~~json
+{"error":"episode_finished"}
+~~~
+
+此时不返回新观测，也不会继续推进仿真。  
+必须 reset 后才能开始新 episode；reset 前的 step 都返回该错误。
+
+可以反复 reset / step 进行数据采集、模型训练和自测。
+
+环境只返回状态，不提供 reward、loss、cost 或 done 信号。  
+训练信号由你自行构造。
+
+## 交付内容
+
+只提交源码，不提交编译产物。
+
+源码根目录必须支持：
+
+~~~
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j4
+~~~
+
+必须产出两个入口：
+
+~~~
+build/nn_selftest
+build/control
+~~~
+
+### 1. 基础设施入口
+
+build/nn_selftest 必须运行公开基础设施测试并返回 0 表示通过。
+
+必须包含的基础设施：
+
+- fp32 tensor，形状检查与广播
+- elementwise add/sub/mul/div
+- matmul / linear
+- relu / softmax
+- layernorm
+- conv2d，支持 stride/padding/dilation/groups
+- MSE
+- matmul/linear/relu/layernorm/conv2d/MSE 反向
+- SGD momentum
+- AdamW
+- 模型保存/加载
+- 线程池
+
+占位符或空实现会被判为基础设施错误。
+
+公开测试文件在工作区中，评测时使用评测侧的干净副本。
+
+### 2. 控制器入口
+
+build/control 是一个常驻进程，通过 stdin/stdout 使用 JSONL 通信。
+
+输入：
+
+~~~json
+{"type":"reset"}
+{"type":"step","step":0,"state":[3 floats]}
+~~~
+
+输出：
+
+~~~json
+{"type":"ready"}
+{"type":"action","torque":[0.5,-0.5]}
+~~~
+
+规则：
+
+- 每次评测启动一个新进程
+- 先收到 reset，必须回复 ready
+- 每个 step 必须在 100 ms 内回复
+- 控制器可以保存内部历史状态
+- 崩溃、超时、非法输出会判为控制器失败
+
+## 提交与测试
+
+使用宿主工具：
+
+~~~text
+eval_submit
+eval_test
+~~~
+
+### eval_submit
+
+把当前工作区源码快照提交到宿主侧不可读目录。每次提交独立保留，不覆盖旧提交。提交本身不改变分数。
+
+### eval_test
+
+由宿主对最新提交快照进行构建和隐藏仿真评估，返回：
+
+~~~text
+stage
+t_can
+completed
+error
+~~~
+
+只有 eval_test 会更新分数。第一次 eval_test 之前必须先 eval_submit，否则 stage = no_submission。
+
+阶段枚举：
+
+~~~text
+no_submission
+compile
+infra
+controller
+simulation
+scoring
+completed
+busy
+~~~
+
+最终排行分数不会返回给你，只用于赛后排名。
+
+## 完成条件
+
+当测试返回：
+
+~~~
+stage = completed
+t_can >= 10.0
+~~~
+
+即任务完成。
+
+完成后：
+
+- 立即停止修改
+- 立即总结你的实现
+- 之后的提交和测试请求都会被拒绝
+
+## 约束
+
+- 只允许 C++17 + CMake + C++ 标准库
+- 仅 CPU，fp32
+- 提交源码中不得出现 torch
+- 评测环境无 Python/torch
+- 无网络
+- 不得修改仿真器或公开测试
+- 不得提交编译产物
+- 赛后人工审核：控制器必须是神经网络，且必须实际调用你实现的神经网络基础设施；手写控制律、查表、固定轨迹或外部依赖会被判无效
+
+## 优化目标
+
+从接近全向下的初始状态起摆，使三根杆全部进入竖直向上容差，并尽可能长时间保持。
+
+这是一个控制目标，不是固定损失函数。环境不提供 reward/loss；你需要自己决定训练信号、损失、奖励或优化方式。
+
+## 评分规则
+
+任务从会话开始时刻计时。
+
+### 测试请求与分数
+
+提交源码本身不改变分数。
+
+只有申请测试会更新当前分数：
+
+~~~
+无效测试 / 编译失败 / 基础设施失败 / 控制器失败 / 仿真失败 / 无提交：
+score(t) = -1
+
+有效测试：
+score(t) = (min(t_can, t_tgt) - t_tgt) / t_tgt
+~~~
+
+其中：
+
+~~~
+t_tgt = 10.0 s
+score(t) 的范围是 [-1, 0]
+t_can = 0 时 score = -1
+t_can >= t_tgt 时 score = 0
+~~~
+
+分数从测试请求时刻开始生效，直到下一次测试请求。
+
+第一次测试请求之前，score = -1。
+
+### 最终分数
+
+最终分数是时间积分，不除以总时长：
+
+~~~
+final = integral_0^T_done score(t) dt
+~~~
+
+T_done 是第一次返回 completed 的测试请求时间。
+
+因此：
+
+- 越早达到完成条件，负分区间越短，最终分数越高
+- 拖得越久，负分区间越长
+- 完成后停止积分
+- 未完成不参与最终排名
+
+### 完成时
+
+当测试返回 completed 时：
+
+- 当前 score 固定为 0
+- 时间积分立即停止
+- 之后的提交和测试全部拒绝
+- 不会再有新的分数变化
+
+### 测试结果与最终分数
+
+测试结果会返回：
+
+- stage
+- t_can
+- completed
+- error
+
+最终排行分数不会返回给你，只用于赛后排名。
+
+## 建议工作顺序
+
+1. 阅读公开测试和 tools/sim 协议
+2. 先实现最小可用的 tensor/算子/反向/优化器
+3. 跑通 nn_selftest
+4. 用 tools/sim 采集数据并训练控制器
+5. 反复提交和测试，优先把 t_can 提升到 10 秒
+6. 完成后立即总结

package/assets/neural-pendulum/sim.cpp

@@ -0,0 +1,126 @@
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <random>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace {
+constexpr int N = 3;
+constexpr double DT = 0.01;
+constexpr int SUB = 4;
+constexpr int MAX_STEPS = 3000;
+constexpr double PI = 3.14159265358979323846;
+constexpr double GRAV = 9.81;
+constexpr double DAMP = 0.01;
+constexpr double TAU_MAX = 18.0;
+const std::array<double, N> MASS{{1.0, 1.0, 1.0}};
+const std::array<double, N> LEN{{0.5, 0.5, 0.5}};
+const std::array<double, N> R{{0.25, 0.25, 0.25}};
+const std::array<double, N> INERTIA{{MASS[0]*LEN[0]*LEN[0]/12.0, MASS[1]*LEN[1]*LEN[1]/12.0, MASS[2]*LEN[2]*LEN[2]/12.0}};
+const std::array<double, N> GCOEF{{MASS[0]*R[0] + LEN[0]*(MASS[1]+MASS[2]),
+                                   MASS[1]*R[1] + LEN[1]*MASS[2],
+                                   MASS[2]*R[2]}};
+
+struct Vec { std::array<double,N> v{}; };
+struct State { std::array<double,N> theta{}; std::array<double,N> omega{}; };
+
+double wrap(double x) {
+  while (x <= -PI) x += 2*PI;
+  while (x > PI) x -= 2*PI;
+  return x;
+}
+
+static std::array<std::array<double,N>,N> mass_matrix(const std::array<double,N>& q) {
+  std::array<std::array<double,N>,N> M{};
+  for (int i=0;i<N;i++) for (int j=0;j<N;j++) {
+    if (i==j) {
+      double tail=0; for (int k=i+1;k<N;k++) tail += MASS[k];
+      M[i][j] = INERTIA[i] + MASS[i]*R[i]*R[i] + LEN[i]*LEN[i]*tail;
+    } else {
+      int a=std::min(i,j), b=std::max(i,j);
+      M[i][j] = LEN[a] * GCOEF[b] * std::cos(q[i]-q[j]);
+    }
+  }
+  return M;
+}
+static void solve3(const std::array<std::array<double,N>,N>& A, const std::array<double,N>& b, std::array<double,N>& x) {
+  double a[3][4];
+  for(int i=0;i<3;i++){ for(int j=0;j<3;j++) a[i][j]=A[i][j]; a[i][3]=b[i]; }
+  for(int c=0;c<3;c++){
+    int p=c; for(int r=c+1;r<3;r++) if(std::fabs(a[r][c])>std::fabs(a[p][c])) p=r;
+    if(p!=c) for(int j=0;j<4;j++) std::swap(a[c][j],a[p][j]);
+    double d=a[c][c]; if(std::fabs(d)<1e-15) d=(d<0?-1e-15:1e-15);
+    for(int j=c;j<4;j++) a[c][j]/=d;
+    for(int r=0;r<3;r++) if(r!=c){ double f=a[r][c]; for(int j=c;j<4;j++) a[r][j]-=f*a[c][j]; }
+  }
+  for(int i=0;i<3;i++) x[i]=a[i][3];
+}
+static void deriv(const State& s, const std::array<double,N>& tau, State& out) {
+  auto M = mass_matrix(s.theta);
+  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];
+    C[i]=ci;
+    G[i]=GRAV*std::sin(s.theta[i])*GCOEF[i];
+  }
+  // joint damping: b * D^T D omega, D lower bidiagonal with -1 previous
+  for(int i=0;i<N;i++){
+    double e=s.omega[i] - (i>0?s.omega[i-1]:0.0);
+    Q[i] -= DAMP*e;
+  }
+  for(int i=0;i<N;i++) rhs[i]=tau[i]-C[i]-G[i]+Q[i];
+  solve3(M, rhs, out.omega);
+  out.theta = s.omega;
+}
+} // namespace
+
+int main(int argc, char** argv) {
+  bool eval=false; int seed=0;
+  for(int i=1;i<argc;i++){ std::string a=argv[i]; if(a=="--eval") eval=true; else if(a=="--seed" && i+1<argc) seed=std::atoi(argv[++i]); }
+  std::mt19937 rng(seed);
+  std::uniform_real_distribution<double> u(-1.0,1.0);
+  State s;
+  int steps=0; bool ready=false;
+  auto reset=[&](){ steps=0; ready=true; if(eval){ s.theta={0.013,-0.008,0.021}; s.omega={0,0,0}; } else { s.theta={u(rng)*0.05,u(rng)*0.05,u(rng)*0.05}; s.omega={u(rng)*0.02,u(rng)*0.02,u(rng)*0.02}; } };
+  // zero state
+  s.theta={0,0,0}; s.omega={0,0,0};
+  std::string line;
+  while(std::getline(std::cin,line)){
+    if(line.empty()) continue;
+    if(line.find("reset")!=std::string::npos){ reset(); std::cout << "{\"obs\":[" << wrap(s.theta[0]-PI) << "," << wrap(s.theta[1]-PI) << "," << wrap(s.theta[2]-PI) << "]}\n" << std::flush; continue; }
+    if(line.find("step")!=std::string::npos){
+      if(!ready || steps>=MAX_STEPS){ std::cout << "{\"error\":\"episode_finished\"}\n" << std::flush; continue; }
+      // 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}};
+      // one control step with 4 RK4 substeps
+      double h=DT/SUB;
+      for(int sub=0;sub<SUB;sub++){
+        State k1=s,k2=s,k3=s,k4=s; State d{};
+        deriv(k1,tau,d); for(int i=0;i<N;i++){ k2.theta[i]=s.theta[i]+0.5*h*d.theta[i]; k2.omega[i]=s.omega[i]+0.5*h*d.omega[i]; }
+        deriv(k2,tau,d); for(int i=0;i<N;i++){ k3.theta[i]=s.theta[i]+0.5*h*d.theta[i]; k3.omega[i]=s.omega[i]+0.5*h*d.omega[i]; }
+        deriv(k3,tau,d); for(int i=0;i<N;i++){ k4.theta[i]=s.theta[i]+h*d.theta[i]; k4.omega[i]=s.omega[i]+h*d.omega[i]; }
+        deriv(k4,tau,d);
+        // need derivatives at all; use helper recompute arrays
+        State ds1{},ds2{},ds3{},ds4{};
+        deriv(k1,tau,ds1); deriv(k2,tau,ds2); deriv(k3,tau,ds3); deriv(k4,tau,ds4);
+        for(int i=0;i<N;i++){
+          s.theta[i] += h/6.0*(ds1.theta[i]+2*ds2.theta[i]+2*ds3.theta[i]+ds4.theta[i]);
+          s.omega[i] += h/6.0*(ds1.omega[i]+2*ds2.omega[i]+2*ds3.omega[i]+ds4.omega[i]);
+        }
+      }
+      steps++;
+      std::cout << "{\"obs\":[" << wrap(s.theta[0]-PI) << "," << wrap(s.theta[1]-PI) << "," << wrap(s.theta[2]-PI) << "]}\n" << std::flush;
+      continue;
+    }
+    std::cout << "{\"error\":\"bad_command\"}\n" << std::flush;
+  }
+  return 0;
+}

package/eval/neural-pendulum.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Plugin wrapper for the standalone Neural-Pendulum evaluator."""
+from __future__ import annotations
+import os
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+STANDALONE = HERE.parent / 'neural-pendulum-eval' / 'run_eval.py'
+
+if not STANDALONE.is_file():
+    print('neural-pendulum-eval/run_eval.py missing; copy the standalone evaluator folder first', file=sys.stderr)
+    raise SystemExit(1)
+
+os.execv(sys.executable, [sys.executable, '-X', 'utf8', str(STANDALONE), *sys.argv[1:]])

package/lib/client/index.js

@@ -94,7 +94,9 @@ window.__ModuleLoader__.load({
 			pipProxyUrl: "",
 			cifarProxyUrl: "",
 			cifarMirror: "toronto",
-			customCifarUrl: ""
+			customCifarUrl: "",
+			parallelEval: false,
+			taskId: ""
 		};
 		const box = {
 			border: "1px solid var(--vscode-panel-border, #3c3c3c)",
@@ -159,7 +161,9 @@ window.__ModuleLoader__.load({
 				pipProxyUrl: typeof value?.pipProxyUrl === "string" ? value.pipProxyUrl : "",
 				cifarProxyUrl: typeof value?.cifarProxyUrl === "string" ? value.cifarProxyUrl : "",
 				cifarMirror: typeof value?.cifarMirror === "string" && value.cifarMirror !== "" ? value.cifarMirror : "toronto",
-				customCifarUrl: typeof value?.customCifarUrl === "string" ? value.customCifarUrl : ""
+				customCifarUrl: typeof value?.customCifarUrl === "string" ? value.customCifarUrl : "",
+				parallelEval: value?.parallelEval === true,
+				taskId: typeof value?.taskId === "string" ? value.taskId : ""
 			};
 		}
 		/** The settings card. */
@@ -237,8 +241,15 @@ window.__ModuleLoader__.load({
 				return () => clearInterval(timer);
 			}, []);
 			(0, react.useEffect)(() => {
-				if (state !== null && state.tasks.length > 0 && (taskId === "" || !state.tasks.some((task) => task.id === taskId))) setTaskId(state.tasks[0].id);
-			}, [state, taskId]);
+				if (state !== null && state.tasks.length > 0 && (taskId === "" || !state.tasks.some((task) => task.id === taskId))) {
+					if (draft.taskId !== "" && state.tasks.some((task) => task.id === draft.taskId)) setTaskId(draft.taskId);
+					else setTaskId(state.tasks[0].id);
+				}
+			}, [
+				state,
+				taskId,
+				draft.taskId
+			]);
 			const ready = snapshot.status === "ready" && snapshot.writable;
 			const save = async (patch) => {
 				if (!ready || snapshot.revision === void 0) return;
@@ -274,6 +285,7 @@ window.__ModuleLoader__.load({
 			};
 			const selectTask = (next) => {
 				setTaskId(next);
+				save({ taskId: next });
 				try {
 					localStorage.setItem("evalGuard.taskId", next);
 				} catch {}
@@ -332,6 +344,7 @@ window.__ModuleLoader__.load({
 			};
 			const install = async () => {
 				if (workspaceId === "" || taskId === "") return;
+				await save({ taskId });
 				setError("");
 				setNotice("");
 				setJobNotice("");
@@ -368,6 +381,7 @@ window.__ModuleLoader__.load({
 			};
 			const evaluate = async () => {
 				if (workspaceId === "" || taskId === "") return;
+				await save({ taskId });
 				setError("");
 				setNotice("");
 				setJobNotice("");
@@ -814,6 +828,23 @@ window.__ModuleLoader__.load({
 								" ",
 								t("settings.timeLimit")
 							] }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
+								style: { marginLeft: 16 },
+								children: [
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+										type: "checkbox",
+										checked: draft.parallelEval,
+										disabled: !ready,
+										onChange: (event) => void save({ parallelEval: event.target.checked })
+									}),
+									" ",
+									t("settings.parallelEval")
+								]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								style: note,
+								children: t("settings.parallelEvalHint")
+							}),
 							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
 								type: "number",
 								min: 1,
@@ -998,6 +1029,8 @@ window.__ModuleLoader__.load({
 			"settings.runningForce": "强行开启",
 			"settings.timeLimit": "开启最长时长",
 			"settings.timeLimitHint": "从每条用户消息发送时开始计时；到点只终止当前轮次，并递归清理子代理与后台任务。",
+			"settings.parallelEval": "多 agent 并行评测",
+			"settings.parallelEvalHint": "启用后，安装任务时会在提示词中提醒 agent：运行环境可能因其他 agent 的行为而波动，需要自行适应。",
 			"settings.minutes": "分钟",
 			"settings.forbidden": "额外禁止路径",
 			"settings.forbiddenHint": "每行一个绝对路径；# 开头为注释；! 开头表示在禁止范围内放开该子路径；按行顺序生效。默认空。",
@@ -1041,6 +1074,8 @@ window.__ModuleLoader__.load({
 			"settings.recent": "最近事件",
 			"settings.none": "暂无。",
 			"settings.warningTitle": "评测守护警告",
+			"settings.cifarProxy": "CIFAR 下载代理",
+			"settings.cifarMirror": "CIFAR 下载镜像",
 			"settings.close": "关闭"
 		};
 		const en = {
@@ -1053,6 +1088,8 @@ window.__ModuleLoader__.load({
 			"settings.runningForce": "Force enable",
 			"settings.timeLimit": "Enable time limit",
 			"settings.timeLimitHint": "The clock starts at each user message; at the deadline only the current turn is cancelled, and subagents/jobs are cleaned up recursively.",
+			"settings.parallelEval": "Parallel agent evaluation",
+			"settings.parallelEvalHint": "When enabled, install prompts warn the agent that the runtime may fluctuate because other agents share the machine; it must adapt.",
 			"settings.minutes": "minutes",
 			"settings.forbidden": "Extra forbidden paths",
 			"settings.forbiddenHint": "One absolute path per line; # comments; ! re-allows a subpath; later lines win. Empty by default.",