diag: H 段（老师 oracle 走 rollout / 前缀消融 / 子目标越过顶点规则 / 分轴与分类别指标）；训练：EMA、选模不落在 p_neq 预热、闭环分数选模、24000 步余弦、p_neq 0.5 + p_edge 0.1、子目标头切断抄输入、前缀/dq 增广；仿真：last 记真正提交的候选、碰撞与到达按每题时限、回放门禁读 pass+指纹并走 rollout；数据：动作标签按 1.25·STEP 归一化（act_scale 随 meta/ckpt/ONNX 传递，旧模型 1.0）、收回亏空结转、DAgger 带 qPrev 与起步速度、打包签名变更自动重打；ik-policy.js 同步（actScale、子目标规则、DLS 时清 lastPlan）；本机执行清单与 README 更新
This commit is contained in:
Hark
+44
-43
@@ -3,68 +3,69 @@
|
||||
本文件是 Hark 对本机计算的唯一要求清单。按顺序执行，每一步把「回传」里的文件或输出原样交给用户，不要跳步，不要自行改代码。
|
||||
所有命令在仓库根目录（G:\Robot_v2\机器人手臂）的 Git Bash 里运行。完成的条目由 Hark 在下一次提交里删掉。
|
||||
|
||||
## 已知结论（截至 2026-10-19 03:37 回传）
|
||||
## 已知结论（截至 2026-10-19 05:35 回传）
|
||||
|
||||
- 特征口径 Python 与 JS 一致；子目标、抄上一帧速度、起步都已排除；gaps 显存已过。
|
||||
- 一步采样残留噪声真实（抖动 42×、残差-噪声相关 −0.86），2 段以上基本修掉；4 段闭环碰撞 99.6%→93%、2 s 误差比 0.815→0.610，到达仍 0%。零噪声 0%/100%（均值样本偏老师 ~4°）。
|
||||
- 新发现的错误：闭环一致性打分错位一步（对齐上一计划的第 3 个点，应为第 4 个），等于每次重规划奖励「比上一计划慢一步」的候选。Python 闭环和浏览器部署已同时修正。第 1 步的 C 段和 G 段都按修正后口径跑。
|
||||
- 现有模型 `ml/runs/base/last.pt` 闭环 0% 到达：1 段采样碰撞 99.6%；4 段采样 94%；4 段 + 仿真安全层碰撞 0.78%，到达仍 0%。consist / value / first 三种选法结果几乎一样，问题出在候选本身，不在挑哪条。
|
||||
- 三份代码审查逐行核对了滚动索引、前缀、提交、标签与执行的对齐，没有找到错位；但之前没有任何测试真正走过 `rollout()`。下面第 1 步的 H 段把「仿真错了」「前缀照抄」「子目标切换规则」「多峰」几种解释逐个分开。
|
||||
- 之前「前 1 s 速度比 2.31×」按 6 轴角度直接相加，被 J5/J6 抖动和 pos 任务冻结的 J6 放大。H 段改为分轴、净位移、TCP 三种口径。
|
||||
|
||||
## 第 0 步：同步代码
|
||||
|
||||
```bash
|
||||
git status --short # 有未提交改动就先 commit，不要丢
|
||||
git status --short # 有未提交的改动先 commit（git add -A && git commit -m "本机改动"），不要丢
|
||||
git pull --rebase gitea main
|
||||
git log --oneline -1 # 应是 Hark 的「fix(closed_loop): 一致性打分错位 …」
|
||||
git log --oneline -1 # 应是 Hark 的「diag: H 段（老师 oracle / 前缀消融 / 子目标规则 / 分轴指标）…」
|
||||
```
|
||||
|
||||
- 训练控制台若开着先点「停止」，确认没有 python 训练进程在跑。
|
||||
- 不要启动训练 / DAgger / M5，等 Hark 看完第 1 步结果再定。
|
||||
- 训练控制台若开着，先点「停止」，确认没有 python 训练进程在跑。
|
||||
- 不要启动训练、DAgger、M5。
|
||||
|
||||
## 第 1 步：闭环失败定位（含新加的 G 段，约 10–15 分钟）
|
||||
## 第 1 步：闭环失败定位 H 段（约 35–50 分钟）
|
||||
|
||||
```bash
|
||||
PYTHONUTF8=1 python -m ml.eval.diag_cl --ckpt ml/runs/base/last.pt --n 256 --out ml/runs/diag_cl.json
|
||||
```
|
||||
|
||||
- 专用显存超过 22 GB 就 Ctrl+C 并回传终端输出。
|
||||
- 新增输出：`G_1step_consist`、`G_4step_consist`、`G_4step_value`、`G_4step_first`、`G_4step_consist_safety`，每项含到达、碰撞、2 s 目标误差比、末端误差、首次碰撞时刻、前 1 s 速度比、刹停次数。F 段已删。
|
||||
- 专用显存超过 22 GB 就 Ctrl+C，回传终端最后 30 行和已写出的 `ml/runs/diag_cl.json`（每段跑完就写一次，中断也保留已完成的段）。
|
||||
- 现有 checkpoint 没有 EMA、没有 `act_scale`：脚本按原始权重、动作尺度 1.0 载入（输出里 `weights`=`model`、`act_scale_ckpt`=1.0），与之前各轮同口径。
|
||||
- 回传：`ml/runs/diag_cl.json`。
|
||||
|
||||
### 输出键
|
||||
|
||||
| 键 | 内容 |
|
||||
|---|---|
|
||||
| `A_*`、`B_act_diff_deg` | 起点特征 Python 与数据集逐组差；两份特征下的动作差（与之前相同） |
|
||||
| `C` | 旧部署口径（1 段采样、子目标旧规则 timeout）的失败形态。到达与碰撞改为只计每题自己的时限内，数字可能比上一轮略低 |
|
||||
| `H1_oracle` | 老师当策略走完整 `rollout()`。`oracle` 字段：`max_dev_deg_before_dls`（DLS 接管前与老师轨迹的最大关节偏差，p50 / p99 / max）、`reach`、`collision`、`finish_minus_teacher_s`（完成时刻 − 老师时长）、`dls_used` |
|
||||
| `H1_oracle_noise_0.05` / `_0.1` / `_0.2` | 老师动作每次规划加 N(0, σ²)（σ 以 STEP 为单位） |
|
||||
| `H2_open_loop` | r = 3 的 val 行：`s{1,4}_prefix_orig`（前缀原样，执行窗口 3..5 的误差，另含 `prefix_copy_err_deg_mean`）vs `s{1,4}_prefix_zeroed`（前缀置零） |
|
||||
| `H2_replan_empty_s1` / `_s4` | 队列空了才规划（每次 r = 0），其余同新部署默认 |
|
||||
| `H3_headsub_cross_s{1,4}` | 子目标头 + 越过顶点规则（新部署默认） |
|
||||
| `H3_headsub_timeout_s{1,4}` | 子目标头 + 旧规则（< 5° 或 1.5 s 超时，旧部署） |
|
||||
| `H3_teachersub_cross_s{1,4}` / `H3_teachersub_timeout_s{1,4}` | 老师真实途经点全表，两种切换规则 |
|
||||
| `H3_nosub_s{1,4}` | 不用子目标 |
|
||||
| `H4_open_loop` | 按前缀长度 r = 0..3 分组的执行窗口误差 \|Σ(act − Y)·STEP\|（度），1 段与 4 段采样 |
|
||||
|
||||
每个闭环变体（H1–H3）都带同一组指标：`reach`、`collision`（cat ≠ D、时限内）、`goal_ratio_2s_p50`、`end_goal_err_mm_p50`、`first_hit_s_p50`、`t_done_over_teacher_p50`、`brakes_p50`、`joint_amp_ratio`（6 轴前 1 s 关节行程 策略/老师）、`joint_net_ratio`（6 轴前 1 s 净位移 策略/老师）、`j6_pos_amp_deg_p50`、`tcp_path_ratio_p50`、`tcp_net_ratio_p50`、`sign_flip_rate` 与 `sign_flip_rate_teacher`（6 轴前 2 s 相邻 3 步块变号比例）、`by_cat_mode`（各类别 n / reach / collision / goal_ratio_2s_p50）、`D`（D 类单列）。`_s1` = 1 段采样（部署），`_s4` = 4 段采样。
|
||||
|
||||
### 判读
|
||||
|
||||
| 现象 | 结论 |
|
||||
|---|---|
|
||||
| `H1_oracle` 的 reach < 0.95、collision > 0.01、或 `max_dev_deg_before_dls.p99` > 0.1° | 仿真 / 滚动本身有错，之前所有闭环 0% 都不可信。先修仿真，不看下面各项 |
|
||||
| `H1_oracle` 全部正常 | 仿真没问题，失败在策略输出。再对照 `H1_oracle_noise_*`：σ = 0.05 时 reach 就大幅下降，说明闭环对残差噪声极其敏感，单靠降噪不够 |
|
||||
| `H2_open_loop` 的 `prefix_zeroed` 执行窗口误差明显小于 `prefix_orig`，或 `H2_replan_empty` 明显好于同段数的 `H3_headsub_cross`（reach > 0，或 `goal_ratio_2s_p50` 明显更低、`sign_flip_rate` 明显更低） | 前缀照抄（copycat）是主因 |
|
||||
| `H3_teachersub_cross` 明显好于 `H3_teachersub_timeout`（或 `H3_headsub_cross` 好于 `H3_headsub_timeout`） | 子目标切换规则是主因之一 |
|
||||
| `H3_teachersub_*` 明显好于 `H3_headsub_*` | 子目标头给的途经点不可用 |
|
||||
| `H3_nosub` 不比 `H3_headsub_cross` 差 | 子目标通道可以整体去掉 |
|
||||
| `by_cat_mode` 里 `A/pos`（老师就是一条直线）reach 也是 0 | 失败与多峰无关 |
|
||||
| `joint_amp_ratio` 远大于 `joint_net_ratio`，且 `sign_flip_rate` 远高于 `sign_flip_rate_teacher` | 「动得多、走得少」是来回抖，不是速度律学快了 |
|
||||
|
||||
重新打包和重训（`FRESH_FROM=prep`）要等 Hark 看完这一步的结果再定，这一步之后不要自行启动。
|
||||
|
||||
## 回传汇总
|
||||
|
||||
| 步骤 | 回传内容 |
|
||||
|---|---|
|
||||
| 1 | ml/runs/diag_cl.json |
|
||||
| 任一步出错 | 终端最后 30 行输出 |
|
||||
|
||||
---
|
||||
|
||||
## 执行回传（2026-10-19 05:35，本地 AI）
|
||||
|
||||
### 第 0 步：同步代码
|
||||
|
||||
pull 前无未提交 tracked 改动；两个 untracked 文件原位保留。log 顶部 = `0f5b84b`「fix(closed_loop): 一致性打分错位 …」✓。无训练进程。
|
||||
|
||||
### 第 1 步：闭环失败定位（G 段；完整 JSON 已更新到 ml/runs/diag_cl.json）
|
||||
|
||||
**C 段（修正后同口径）**：到达 **0%** / 碰撞 **99.6%** / 2 s 误差比 **0.755**（修正前 0.815）；首撞 p50 1.42 s、主碰撞对 J3-J5 95 次——**一致性错位修复没有改变闭环结果**（数值微动但形态不变）。
|
||||
|
||||
**G 段（5 个变体，n=256）**：
|
||||
|
||||
| 变体 | 到达 | 碰撞 | 2s 误差比 | 末端误差 mm | 首撞 s | 前 1s 速度比 | 刹停 |
|
||||
|---|---|---|---|---|---|---|---|
|
||||
| G_1step_consist（部署口径） | 0% | 99.6% | 0.755 | 420 | 1.42 | **2.31** | 0 |
|
||||
| G_4step_consist | 0% | 94.1% | 0.591 | 430 | 1.80 | 1.26 | 0 |
|
||||
| G_4step_value | 0% | 94.5% | 0.580 | 410 | 1.66 | 1.31 | 0 |
|
||||
| G_4step_first | 0% | 96.1% | 0.762 | 465 | 1.98 | 1.17 | 0 |
|
||||
| G_4step_consist_safety | 0% | **0.78%** | 0.720 | 458 | 0.54 | 1.17 | 9 |
|
||||
|
||||
三个要点：
|
||||
|
||||
1. **候选选择机制无关紧要**：consist / value / first（完全不选）三者到达都是 0%、碰撞 94–96%、误差比 0.58–0.76——换选择器救不了，问题在候选本身（模型输出），不在「挑哪条」。
|
||||
2. **1step 闭环速度比 2.31×**：策略前 1 s 走出老师的 2.3 倍速度（4 段采样后降到 1.26×），但 2 s 目标误差只缩 25%——「动得多、走得少」在修掉一致性错位后依然成立。
|
||||
3. **4step + 安全层：碰撞几乎归零（0.78%，对比基线 safety 6.6%）但到达仍 0%**、刹停中位 9 次——能防撞，到不了目标。
|
||||
|
||||
### 本轮无出错，无终端报错段。
|
||||
|
||||
---
|
||||
|
||||
+24
-12
@@ -24,7 +24,7 @@
|
||||
| 3 老师门禁 | `bash ml/pipeline.sh gate1` | 25–30 分钟（单核） | `ml/data/consistency.json` |
|
||||
| 4 生成数据 | `bash ml/pipeline.sh gen` | 不共识约 1 小时；共识约 4–5 小时 | `ml/data/shard_*.jsonl`、`stats.json` |
|
||||
| 5 打包样本 | `bash ml/pipeline.sh prep` | 15–30 分钟 | `ml/data/samples/`、`ml/data/r2.json` |
|
||||
| 6 预训练 | `bash ml/pipeline.sh train` | 测速 2000 步约 6 分钟，正式约 3 小时 | `ml/runs/base/best.pt` |
|
||||
| 6 预训练 | `bash ml/pipeline.sh train` | 测速 2000 步约 6 分钟，正式 24000 步约 1.5–2.5 小时（未实测：fp32 MF 分支后的吞吐以测速为准） | `ml/runs/base/best.pt` |
|
||||
| 6′ DAgger 纠偏 | `bash ml/pipeline.sh dagger` | 未实测，估 3–4 小时：2 轮 ×（采起点 5 分钟 + 老师重规划约 30 分钟 + 打包 + 微调 15000 步） | `ml/runs/base_dagger.ckpt`、`ml/runs/base_dag2/best.pt` |
|
||||
| 7 M5 门禁 | `bash ml/pipeline.sh m5` | 估算 10–20 分钟 | `ml/runs/m5_gate_base.json` |
|
||||
| 8 APG 微调 | `bash ml/pipeline.sh apg` | 未实测：展开长度 60–150 次推理随批变化，以监控页前 50 步换算的 ETA 为准 | `ml/runs/apg/best.pt` |
|
||||
@@ -115,7 +115,9 @@ bash ml/pipeline.sh gen # 默认 5 万条、进程数 = CPU
|
||||
bash ml/pipeline.sh prep
|
||||
```
|
||||
|
||||
每条轨迹按 50 Hz 时间律重放，每 3 步取一个样本（特征与部署同一份 JS 代码计算），30% 样本加 σ = 1° 噪声增广（加噪后间隙 < 3 mm 的不用）。
|
||||
每条轨迹按 50 Hz 时间律重放，每 3 步取一个样本（特征与部署同一份 JS 代码计算）。40% 样本对 q 加 σ = 3° 噪声增广，标签改为 12 步内线性收回老师轨迹（加噪后间隙 < 3 mm 或收回途中有碰撞的不用）。
|
||||
- **动作标签**：Y = 每步增量 / (act_scale · STEP)，夹在 ±1，`act_scale` = 1.25（`ACT_SCALE`）。老师巡航时主导轴每步正好 1 个 STEP，标签最大 0.8，执行端的 ±1 只防越界；被 ±1 截掉的收回量在下一步补上。运行时增量 = clamp(act, ±1) · act_scale · STEP，`act_scale` 写在 checkpoint 和 ONNX meta 里，仿真、APG、浏览器运行时都按它反归一化；没有这个字段的旧模型按 1.0 处理。
|
||||
- 每个 shard 打包产物带 `<shard>.meta.json`（数据版本 `data_ver`=2、`act_scale`、增广参数、签名 `sig`）。`ACT_SCALE`、`AUG_P`、`AUG_SIGMA`、`AUG_BACK`、`MIN_GAP_MM` 任一变化，签名就变，`run_prep.sh` 只重打签名不符的 shard；没有 meta 的旧打包一律重打。训练读 meta 取 `act_scale`，同一次训练的各目录（主数据 + DAgger）必须一致，否则报错。
|
||||
认证最小间隙 < 3 mm 的老师轨迹不进训练集（`MIN_GAP_MM=3`，与 `stats.json` 的 `gapDrop` 同一口径）：模型只学离障碍 ≥ 3 mm 的走法，运行时投影护栏仍保持 5 mm。
|
||||
检查 `ml/data/samples/index.json`：`train_samples` 约 170 万、`val_samples` 约 9 万（5% 任务划为 val）。
|
||||
`MIN_GAP_MM` 必须与生成阶段相同（`stats.json` 的 `minGapFilterMm`），不一致时这一步直接报错（返回码 8）。
|
||||
@@ -128,15 +130,22 @@ bash ml/pipeline.sh prep
|
||||
bash ml/pipeline.sh train # MeanFlow 头 → ml/runs/bench_base/、ml/runs/base/
|
||||
```
|
||||
|
||||
开训前先跑老师轨迹回放自检（`ml/runs/replay_teacher.json`，约 1 分钟）：老师轨迹放进 PyTorch 仿真口径，到达 ≥ 95%、碰撞 ≤ 1% 才开训，否则 rc 5 停——口径对不上时闭环指标不可信。
|
||||
闭环指标长期 0% 而开环（ol_fk_mm / ol_best_mm / ol_div）正常时，跑 `PYTHONUTF8=1 python -m ml.eval.diag_cl --ckpt ml/runs/base/last.pt --n 256`（约 2–4 分钟，可与训练并行）→ `ml/runs/diag_cl.json`：A 起点特征 Python 与 JS 逐组差、B 两份特征下动作差、C 首次碰撞时刻 / 组对 / 最小目标误差 / 开安全层到达率。
|
||||
开训前先跑老师轨迹回放自检（`ml/runs/replay_teacher.json`，约 1–3 分钟），两部分都过才开训：
|
||||
- 运动学口径：老师 50 Hz 轨迹直接放进 PyTorch 运动学 / 碰撞 / 到达判据，到达 ≥ 95%、碰撞 ≤ 1%；
|
||||
- 滚动口径：老师当策略（`TeacherOracle`）走完整的闭环仿真 `rollout()`（队列、前缀、提交 3 步、标签 clamp、DLS、时限都与策略同一条路径），时限内到达 ≥ 95%、碰撞 ≤ 1%、DLS 接管前与老师轨迹的最大关节偏差 p99 ≤ 0.1°。
|
||||
流程读 json 的 `pass` 字段，并核对 `fp`（当前 `kin.json`）与 `data_fp`（数据 shard 记录的碰撞模型指纹）；任一不符就重跑一次回放，仍不过 rc 5 停。
|
||||
|
||||
先跑 2000 步测吞吐（`ml/runs/bench_base/log.jsonl` 的 `samples_per_s`，`eta_h` 是剩余小时数），再正式训练到 60000 步或闭环到达率连续 5 次不升为止。
|
||||
闭环指标长期 0% 而开环正常时，跑 `PYTHONUTF8=1 python -m ml.eval.diag_cl --ckpt ml/runs/base/last.pt --n 256`（约 35–50 分钟）→ `ml/runs/diag_cl.json`：A 起点特征 Python 与 JS 逐组差、B 两份特征下动作差、C 旧部署口径的失败形态、H 老师 oracle / 前缀消融 / 子目标规则 / 分轴与分类别指标（各键含义见 `ml/eval/diag_cl.py` 文件头与 `docs/本机执行清单.md`）。
|
||||
|
||||
- **通过线（R10）：`samples_per_s` ≥ 5000，即 60000 步 ≤ 3.5 小时**。参考：3090、batch 1024 实测 6.2 k 样本/s ≈ 2.8 小时。MeanFlow 的 JVP 双前向使训练受算力限制，加大 batch 不会提高样本/s；低于通过线时把 `configs/base.json` 的 `fk_caps` 从 96 降到 48，仍不够再把 `steps` 降到 40000
|
||||
- 训练中每 2000 步打印一行 `EVAL {...}`：val 任务闭环（部署节奏、不开安全层）`success`、`collision_rate`、`time_ok_1p3`、`start_fail`。时限 = 老师时长 × 2（至少 3 s）；另有开环三项（val 样本、老师状态上）：`ol_fk_mm` 候选 0 的 16 步末端误差、`ol_best_mm` 8 个候选里最好的一条、`ol_div` 候选多样性（候选间标准差 / 动作幅度，塌成单峰时接近 0）。best.pt 与早停按「到达率 − 0.001 × ol_fk_mm」
|
||||
- 损失（2026-10-18 首次正式预训练后改）：FK / 平滑只加在 MF 分支 r = t 且 t ≤ 0.3 的配对去噪估计 x̂ = z − t·u 上（原来加在随机噪声的一步采样上，等于回归条件均值，多峰塌成单峰）；时间嵌入最高角频率 50（原 1000）；MF 分支与 JVP 走 fp32（TF32 矩阵乘）；前 5000 步 p_neq = 0。fp32 会让吞吐低于原 6.2 k/s，R10 以新实测为准
|
||||
- 数据增广：40% 样本加 σ = 3° 噪声、12 步收回（原 30% / 1° / 8 步），收回途中须无碰
|
||||
先跑 2000 步测吞吐（`ml/runs/bench_base/log.jsonl` 的 `samples_per_s`，`eta_h` 是剩余小时数），再正式训练 24000 步（`configs/base.json` 的 `steps`，余弦学习率按这个预算走完）。
|
||||
|
||||
- **通过线（R10）：`samples_per_s` ≥ 5000**（24000 步 × batch 1024 ≈ 1.4 小时）。MeanFlow 的 JVP 双前向使训练受算力限制，加大 batch 不会提高样本/s；低于通过线时把 `configs/base.json` 的 `fk_caps` 从 96 降到 48
|
||||
- **EMA**：训练同时维护权重的指数滑动平均（`ema` 0.999），checkpoint 里存 `model`（原始权重）与 `ema`。评估、DAgger、APG 起点、M5、挖错、验收、导出一律用 EMA 权重（没有 `ema` 的旧 checkpoint 用 `model`）
|
||||
- 训练中每 2000 步用 EMA 权重打印一行 `EVAL {...}`：val 任务闭环（部署节奏、不开安全层）`success`、`collision_rate`、`goal_ratio_2s`（2 s 时目标误差 / 起点误差的中位数）、`time_ok_1p3`、`start_fail`，时限 = 老师时长 × 2（至少 3 s），碰撞与到达只计时限内；开环三项（val 样本、老师状态上）：`ol_fk_mm` 候选 0 的 16 步末端误差、`ol_best_mm` 8 个候选里最好的一条、`ol_div` 候选多样性。
|
||||
- **选模**：`score` = success + 0.05·(1 − collision_rate) + 0.05·(1 − min(1, goal_ratio_2s)) − 1e-4·min(ol_best_mm, 500)，到达率全 0 时闭环指标仍能排序。p_neq 预热期内和预热后第一次评估之前不存 best.pt（一步映射还没训过）；早停只在 max(预热 + 2 次评估, 总步数一半) 之后计数，连续 5 次不升即停
|
||||
- 损失：FK / 平滑只加在 MF 分支 r = t 且 t ≤ 0.3 的配对去噪估计 x̂ = z − t·u 上；时间嵌入最高角频率 50；MF 分支与 JVP 走 fp32（TF32 矩阵乘）；前 5000 步 p_neq = 0，之后 p_neq = 0.5，另有 10% 样本固定在部署用的 (r = 0, t = 1)（`p_edge`）
|
||||
- 子目标头只用把 sub 特征置零的输入训练（sub 存在时子目标标签与输入是同一个量，原样抄就能答对）；运行时子目标头只在冷启动、sub 为空时使用，口径一致。价值头用完整输入
|
||||
- 条件输入增广（训练时现做，`aug_pre_drop` 0.15 / `aug_pre_sigma` 0.1 / `aug_dq_sigma` 0.3）：前缀随机清空（变成 r = 0 样本，标签不变）；前缀加噪声，标签前 r 步同步加、第 r 步扣回；速度特征 dq 加噪声。目的是让模型不能靠照抄上一块和上一帧速度出动作
|
||||
|
||||
## 6′. DAgger 纠偏
|
||||
|
||||
@@ -144,7 +153,8 @@ bash ml/pipeline.sh train # MeanFlow 头 → ml/runs/b
|
||||
bash ml/pipeline.sh dagger
|
||||
```
|
||||
|
||||
用预训练 best.pt 在 train 任务上闭环跑（关安全层），每题取「首次碰撞前 0.2 s」和一个随机时刻的状态做起点（须无碰、间隙 > `MIN_GAP_MM`、离目标 > 5 mm），老师从这些起点重新规划（`gen_dataset.cjs --tasks`，与主数据同认证、同时间律），打包后与主数据一起微调。默认 2 轮（`DAG_ROUNDS`），每轮 8000 题（`DAG_N`）、微调 15000 步（`DAG_STEPS`，lr 3e-4）。老师只用于训练标注，部署仍无老师。M5 门禁读 `ml/runs/<头>_dagger.ckpt` 指向的模型；APG / 挖错的 BC 项也用 DAgger 样本。可断点续跑（采集、老师 shard、打包、微调各有完成标记）。
|
||||
起点模型：预训练 best.pt 的闭环 success > 0 时用它，否则用 last.pt（`python -m ml.common.ckpt pick ml/runs/<头>`），都取 EMA 权重；之后每轮按同一规则取上一轮的结果。微调时只有起点已走过自己的 p_neq 预热才不再预热。
|
||||
用起点模型在 train 任务上闭环跑（关安全层），每题取「首次碰撞前 0.2 s」和一个随机时刻的状态做起点（须无碰、间隙 > `MIN_GAP_MM`、离目标 > 5 mm），同时记下该时刻的上一帧。老师从这些起点重新规划（`gen_dataset.cjs --tasks`，与主数据同认证），时间律从当前速度在首段方向上的分量起步（`v0`），t = 0 样本的速度特征用真实上一帧；打包后与主数据一起微调。微调的 val 只取主数据，DAgger 样本全部算 train。默认 2 轮（`DAG_ROUNDS`），每轮 8000 题（`DAG_N`）、微调 15000 步（`DAG_STEPS`，lr 3e-4）。老师只用于训练标注，部署仍无老师。M5 门禁读 `ml/runs/<头>_dagger.ckpt` 指向的模型；APG / 挖错的 BC 项也用 DAgger 样本。可断点续跑（采集、老师 shard、打包、微调各有完成标记）。
|
||||
- 显存预算**浮动**：整卡留 1 GB 给系统（`VRAM_RESERVE_GIB`，默认 1），训练与 APG 进程启动时按"整卡 − nvidia-smi 已用 − 余量"和"CUDA 空闲 − 余量"两者取小自设本进程上限（`ml/common/vram.py`）。占显存的应用多，上限就自动变小，不用改配置；想按定值对拍给 `VRAM_FRAC`（旧口径 0.78）。日志 `vram` 字段记峰值；预训练 `batch=1024` 实测峰值 2.76 GiB、APG `batch=48` 13.08 GiB。显存不够把 `batch` 改成 512。中断后再跑 `bash ml/pipeline.sh train`（或 `all`）会自动从 `ml/runs/<头>/last.pt` 续训（每 10 分钟存一次），测速那 2000 步做过就跳过。训练发散时不会用发散的权重覆盖 `last.pt` / `best.pt`。
|
||||
|
||||
## 7. M5 门禁：选定动作头
|
||||
@@ -191,7 +201,7 @@ bash ml/pipeline.sh mine # 默认 6 轮；ROUNDS=3 APG_STEPS=1000 MIN
|
||||
## 10. 导出
|
||||
|
||||
```bash
|
||||
bash ml/pipeline.sh export # fp32 ONNX + meta.json → webapp/models/（约 20 MB）
|
||||
bash ml/pipeline.sh export # fp32 ONNX + meta.json（含 act_scale）→ webapp/models/（约 20 MB），导出 EMA 权重
|
||||
```
|
||||
|
||||
默认 fp32：部署走 wasm 与 Node CPU，fp16 在 CPU 后端上不保证更快。只有第 13 步用 `&ep=webgpu` 实测 `__POLICY.latency()` 明显受益时，才另导出 fp16 做对比：
|
||||
@@ -234,6 +244,7 @@ python ml/serve.py # 带跨源隔离头的本地服务，wasm
|
||||
- 控制台 `__POLICY.latency()` 查看推理、前瞻、安全层、整次规划的 P50/P99 与节拍；`__POLICY.stats()` 查看刹停、换向、精修次数
|
||||
- `&autotest=30` 自动跑与 bench 同一批贴柱题，结果在 `__POLICY.autotest`
|
||||
- 运行时投影护栏 5 mm：候选动作离障碍 < 5 mm 时沿间隙梯度外推（训练数据的过滤线是 3 mm，护栏比数据更保守）
|
||||
- 动作尺度读模型 meta 的 `act_scale`；子目标按「越过顶点」切换（与训练标签同口径：沿拐角平分面越过当前途经点即换下一个，没有超时），与仿真 `closed_loop.sub_advance` 同一规则
|
||||
- 工具偏移 ≠ 0 时自动交回原规划器
|
||||
- 离线环境：`bash ml/prep/vendor_ort.sh` 把 onnxruntime-web 放到 `webapp/vendor/ort/`，地址加 `&ortLocal=1`（WebGPU 同样可用）
|
||||
|
||||
@@ -314,7 +325,8 @@ ml/
|
||||
sim/closed_loop.py 部署节奏闭环仿真（验证 / 挖错 / 门禁）
|
||||
apg/apg_finetune.py APG 可微微调
|
||||
mining/ tasks.py（无老师出题）、mine_round.py、gate.py（含 R7）、loop.sh
|
||||
eval/ dump_parity.cjs + check_parity.py（JS↔PyTorch 对拍）、check_r2.py（R2）、r4_probe.py（R4 无头浏览器探针）、acceptance.py（验收汇总）
|
||||
eval/ dump_parity.cjs + check_parity.py（JS↔PyTorch 对拍）、check_r2.py（R2）、r4_probe.py（R4 无头浏览器探针）、acceptance.py（验收汇总）、
|
||||
replay_teacher.py（开训前回放自检，含老师 oracle 走 rollout）、diag_cl.py（闭环失败定位 A/B/C/H）
|
||||
toy/toy_bimodal.py 2D 双模态对照实验（动作头选型依据）
|
||||
export_onnx.py serve.py
|
||||
configs/ base.json（MeanFlow）、wta.json（回退）、small.json（R4 不过时的 d=128）、apg.json
|
||||
|
||||
+26
-20
@@ -6,7 +6,10 @@
|
||||
2026-10-18：展开长度不再定长 60 次推理（3.6 s，会截掉老师时长 > 3.6 s 的绕远题），改为覆盖本批 exec_s p90×1.2，上限 plans_max；
|
||||
"到达"仍是每 seg_plans 段末的距离项（无到达即停），属有意设计：段末项给出持续的接近梯度。
|
||||
margin_train 3 mm：与训练数据过滤线一致（认证最小间隙 < 3 mm 的老师轨迹不进训练集），碰撞项不与 BC 标签对抗；
|
||||
运行时投影护栏独立保持 5 mm。端点与中点两个铰链取均值，与只查端点同量纲，w_col 无需重标。"""
|
||||
运行时投影护栏独立保持 5 mm。端点与中点两个铰链取均值，与只查端点同量纲，w_col 无需重标。
|
||||
2026-10-19：起点取 EMA 权重（ckpt.load_policy）；动作反归一化乘 act_scale（与数据同一尺度，不一致报错），产物存 act_scale；
|
||||
子目标推进改用 closed_loop.sub_advance（默认「越过顶点」，与标签同口径）；子目标头 BC 项用 sub 特征置零的输入（同 train.py）；
|
||||
val 只取主数据目录（第一个 --samples）。"""
|
||||
import argparse, json, math, os, random, sys, time
|
||||
import torch
|
||||
|
||||
@@ -15,7 +18,7 @@ from ml.common.features import features, STEP, H, wrap180
|
||||
from ml.data import Samples, load_tasks
|
||||
from ml.model.policy import build, wta_loss
|
||||
from ml.model.meanflow import meanflow_loss
|
||||
from ml.sim.closed_loop import evaluate, tasks_to_tensors, goal_err
|
||||
from ml.sim.closed_loop import evaluate, tasks_to_tensors, goal_err, sub_advance
|
||||
from ml.common.ckpt import Saver, atomic_save, rng_state, set_rng_state
|
||||
from ml.common import vram
|
||||
|
||||
@@ -41,18 +44,23 @@ def main():
|
||||
dev = a.device; torch.manual_seed(a.seed); random.seed(a.seed)
|
||||
vram.limit()
|
||||
os.makedirs(a.out, exist_ok=True)
|
||||
ck = torch.load(a.init, map_location=dev)
|
||||
mcfg = ck['cfg']
|
||||
model = build(mcfg).to(dev); model.load_state_dict(ck['model'])
|
||||
from ml.common.ckpt import load_policy
|
||||
model, ck = load_policy(a.init, dev); mcfg = ck['cfg']
|
||||
kin = Kin(device=dev)
|
||||
data = Samples(a.samples, device=dev, split='train')
|
||||
data = Samples(a.samples, device=dev, split='train', val_dirs=a.samples[:1])
|
||||
act_scale = float(ck.get('act_scale', 1.0))
|
||||
if abs(act_scale - data.act_scale) > 1e-9:
|
||||
raise SystemExit(f'起点 act_scale={act_scale} 与样本 act_scale={data.act_scale} 不一致（BC 项标签尺度不同），换同一版数据训练的模型')
|
||||
model.act_scale = act_scale
|
||||
all_tasks = load_tasks(a.samples)
|
||||
train_tasks = [t for t in all_tasks if t['split'] == 'train'] + load_pool(a.pool)
|
||||
val_tasks = [t for t in all_tasks if t['split'] == 'val'][:C['eval_tasks']]
|
||||
main_tid = {t['tid'] for t in load_tasks(a.samples[:1]) if t['split'] == 'val'}
|
||||
train_tasks = [t for t in all_tasks if t['tid'] not in main_tid] + load_pool(a.pool)
|
||||
val_tasks = [t for t in load_tasks(a.samples[:1]) if t['split'] == 'val'][:C['eval_tasks']]
|
||||
w = [C['cat_weights'].get(t.get('cat', 'A'), 1.0) * (2.0 if t.get('hard') else 1.0) for t in train_tasks]
|
||||
opt = torch.optim.AdamW(model.parameters(), lr=C['lr'], betas=(0.9, 0.95), weight_decay=0.0)
|
||||
amp = dev.startswith('cuda') and C.get('amp') == 'bf16'
|
||||
step = torch.tensor(STEP, device=dev)
|
||||
astep = step * act_scale # 动作 → 度
|
||||
it0 = 0
|
||||
if a.resume and os.path.exists(a.resume):
|
||||
rk = torch.load(a.resume, map_location=dev); model.load_state_dict(rk['model'])
|
||||
@@ -68,11 +76,11 @@ def main():
|
||||
base, _ = evaluate(model.eval(), kin, val_tasks, dev)
|
||||
print('EVAL0', json.dumps(base), flush=True); log.write(json.dumps({'eval': base, 'step': 0}) + '\n')
|
||||
best = base['success']
|
||||
atomic_save({'model': model.state_dict(), 'cfg': mcfg, 'step': 0, 'fp': kin.fp, 'eval': base}, os.path.join(a.out, 'best.pt'))
|
||||
atomic_save({'model': model.state_dict(), 'cfg': mcfg, 'step': 0, 'fp': kin.fp, 'eval': base, 'act_scale': act_scale}, os.path.join(a.out, 'best.pt'))
|
||||
M = C['margin_train_mm']; t0 = time.time()
|
||||
saver = Saver(C.get('ckpt_min', 10)) # 2026-10-18：每 10 分钟 + 收到停止请求时存 last.pt（不再只在每 500 次验证时存）
|
||||
def save_last(n, ev=None):
|
||||
atomic_save({'model': model.state_dict(), 'opt': opt.state_dict(), 'cfg': mcfg, 'step': n, 'fp': kin.fp, 'eval': ev, 'rng': rng_state()}, os.path.join(a.out, 'last.pt')); saver.mark()
|
||||
atomic_save({'model': model.state_dict(), 'opt': opt.state_dict(), 'cfg': mcfg, 'step': n, 'fp': kin.fp, 'eval': ev, 'rng': rng_state(), 'act_scale': act_scale}, os.path.join(a.out, 'last.pt')); saver.mark()
|
||||
for it in range(it0, C['steps']):
|
||||
model.train()
|
||||
batch = random.choices(train_tasks, weights=w, k=C['batch'])
|
||||
@@ -81,7 +89,7 @@ def main():
|
||||
z = torch.randn(B, H, 6, device=dev)
|
||||
q, qp = q0.clone(), q0.clone()
|
||||
queue = torch.zeros(B, 0, 6, device=dev)
|
||||
subs = torch.zeros(B, 2, 6, device=dev); nsub = torch.zeros(B, dtype=torch.long, device=dev); sub_t = torch.zeros(B, device=dev)
|
||||
subs = torch.zeros(B, 2, 6, device=dev); nsub = torch.zeros(B, dtype=torch.long, device=dev); sub_t = torch.zeros(B, device=dev); sub_prev = q0.clone()
|
||||
opt.zero_grad(set_to_none=True)
|
||||
stats = {'col': 0.0, 'tgt': 0.0, 'smooth': 0.0}
|
||||
# 展开长度随本批任务时长：覆盖本批 exec_s 的 p90 × 1.2（无老师参考题按 6 s），夹在 [plans, plans_max]
|
||||
@@ -95,11 +103,7 @@ def main():
|
||||
pre = torch.zeros(B, 3, 6, device=dev); pre[:, :r] = queue[:, :r]
|
||||
qe = q + queue.sum(1)
|
||||
with torch.no_grad():
|
||||
if (nsub > 0).any():
|
||||
cur = subs[:, 0]; dd = torch.where(kin.cont, wrap180(cur - qe), cur - qe).abs().max(-1).values
|
||||
adv = (nsub > 0) & ((dd < 5) | (tnow - sub_t > 1.5))
|
||||
subs = torch.where(adv[:, None, None], torch.cat([subs[:, 1:], subs[:, 1:]], 1), subs)
|
||||
nsub = torch.where(adv, nsub - 1, nsub); sub_t = torch.where(adv, torch.full_like(sub_t, tnow), sub_t)
|
||||
subs, nsub, sub_prev, sub_t = sub_advance(kin, subs, nsub, sub_prev, sub_t, qe.detach(), tnow)
|
||||
feat = features(kin, q, qp, T, R, pre, torch.full((B,), r, device=dev), subs[:, 0], (nsub > 0).float())
|
||||
with torch.autocast('cuda', dtype=torch.bfloat16, enabled=amp):
|
||||
act, val, sub = model.sample_k(feat, 1, z)
|
||||
@@ -108,8 +112,8 @@ def main():
|
||||
with torch.no_grad():
|
||||
need = sub[:, 12].float() > 0.5
|
||||
subs = q.detach()[:, None] + sub[:, :12].float().view(B, 2, 6) * 180
|
||||
nsub = torch.where(need, torch.full_like(nsub, 2), torch.zeros_like(nsub))
|
||||
inc = act.clamp(-1, 1) * step # [B,16,6]
|
||||
nsub = torch.where(need, torch.full_like(nsub, 2), torch.zeros_like(nsub)); sub_prev = q.detach().clone()
|
||||
inc = act.clamp(-1, 1) * astep # [B,16,6]
|
||||
commit = inc[:, r:r + 3]
|
||||
if r == 0: # 冷启动：先提交一块，下一轮才开始执行
|
||||
queue = commit; continue
|
||||
@@ -141,7 +145,9 @@ def main():
|
||||
with torch.autocast('cuda', dtype=torch.bfloat16, enabled=amp):
|
||||
mem = model.encode(X)
|
||||
l_bc = wta_loss(model, mem, Y)[0] if model.head == 'wta' else meanflow_loss(model, mem, Y)[0]
|
||||
v, s = model.heads(mem)
|
||||
v, _ = model.heads(mem)
|
||||
Xs = X.clone(); Xs[:, 68:75] = 0
|
||||
_, s = model.heads(model.encode(Xs))
|
||||
l_bc = l_bc + 0.1 * (v.float() - V).abs().mean() + 0.1 * (s.float() - SG).abs().mean()
|
||||
(C['w_bc'] * l_bc).backward()
|
||||
gn = torch.nn.utils.clip_grad_norm_(model.parameters(), C['grad_clip'])
|
||||
@@ -160,7 +166,7 @@ def main():
|
||||
res, _ = evaluate(model.eval(), kin, val_tasks, dev)
|
||||
res['it'] = it + 1; res['t'] = time.time()
|
||||
print('EVAL', json.dumps(res), flush=True); log.write(json.dumps({'eval': res}) + '\n'); log.flush()
|
||||
sd = {'model': model.state_dict(), 'cfg': mcfg, 'step': it + 1, 'fp': kin.fp, 'eval': res}
|
||||
sd = {'model': model.state_dict(), 'cfg': mcfg, 'step': it + 1, 'fp': kin.fp, 'eval': res, 'act_scale': act_scale}
|
||||
save_last(it + 1, res) # last 带优化器状态供续跑；best 不带（导出/门禁用）
|
||||
if res['success'] > best + 1e-4:
|
||||
best = res['success']; atomic_save(sd, os.path.join(a.out, 'best.pt'))
|
||||
|
||||
@@ -60,3 +60,33 @@ def set_rng_state(d):
|
||||
try: torch.cuda.set_rng_state_all([t.cpu() for t in d['cuda']])
|
||||
except Exception: pass
|
||||
return True
|
||||
|
||||
|
||||
def load_policy(path, device, prefer_ema=True):
|
||||
"""载入策略（2026-10-19，审查 review_model_train P0-2）：优先取 EMA 权重 ck['ema']（train.py 起存），没有就用 ck['model']（旧 checkpoint、APG 产物）。
|
||||
model.act_scale = ck['act_scale']（动作标签归一化倍数，见 ml/prep/build_dataset.cjs ACT_SCALE）；旧 checkpoint 缺省 1.0 = 原口径。
|
||||
闭环仿真 / DAgger / APG 起点 / 挖错 / 门禁 / 验收 / 导出都经这里载入，保证同一份权重、同一个动作尺度。返回 (model.eval(), ck)。"""
|
||||
from ml.model.policy import build
|
||||
ck = torch.load(path, map_location=device)
|
||||
m = build(ck['cfg']).to(device)
|
||||
sd = ck.get('ema') if prefer_ema and ck.get('ema') is not None else ck['model']
|
||||
m.load_state_dict(sd)
|
||||
m.act_scale = float(ck.get('act_scale', 1.0))
|
||||
return m.eval(), ck
|
||||
|
||||
|
||||
def pick_start(run_dir):
|
||||
"""DAgger 起点（2026-10-19，审查 P0-2）：best.pt 的闭环 success > 0 才用 best.pt；否则用 last.pt
|
||||
（success 全 0 时 best.pt 只由开环误差决定，可能落在 p_neq 预热期，一步映射没训过）。载入时取 EMA。"""
|
||||
best, last = os.path.join(run_dir, 'best.pt'), os.path.join(run_dir, 'last.pt')
|
||||
if os.path.exists(best):
|
||||
ev = torch.load(best, map_location='cpu').get('eval') or {}
|
||||
if (ev.get('success') or 0) > 0 or not os.path.exists(last): return best
|
||||
return last if os.path.exists(last) else best
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
# python -m ml.common.ckpt pick <运行目录> → 打印 DAgger 起点 checkpoint 路径
|
||||
import sys
|
||||
if len(sys.argv) == 3 and sys.argv[1] == 'pick': print(pick_start(sys.argv[2]))
|
||||
else: raise SystemExit('usage: python -m ml.common.ckpt pick <run_dir>')
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
{
|
||||
"model": {"d": 192, "heads": 8, "ff": 768, "enc": 4, "dec": 4},
|
||||
"train": {
|
||||
"batch": 1024, "lr": 1e-3, "warmup": 1000, "steps": 60000, "wd": 0.01, "betas": [0.9, 0.95],
|
||||
"batch": 1024, "lr": 1e-3, "warmup": 1000, "steps": 24000, "wd": 0.01, "betas": [0.9, 0.95],
|
||||
"amp": "bf16", "grad_clip": 1.0,
|
||||
"w_mf": 1.0, "w_fk": 0.5, "w_smooth": 0.05, "w_value": 0.1, "w_sub": 0.1,
|
||||
"p_neq": 0.25, "p_neq_warm": 5000, "fk_tmax": 0.3, "fk_caps": 96,
|
||||
"p_neq": 0.5, "p_edge": 0.1, "p_neq_warm": 5000, "fk_tmax": 0.3, "fk_caps": 96,
|
||||
"ema": 0.999, "aug_pre_drop": 0.15, "aug_pre_sigma": 0.1, "aug_dq_sigma": 0.3,
|
||||
"ckpt_min": 10, "eval_every": 2000, "eval_tasks": 512, "log_every": 50, "patience_evals": 5
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
{
|
||||
"model": {"d": 128, "heads": 8, "ff": 512, "enc": 4, "dec": 4},
|
||||
"train": {
|
||||
"batch": 1024, "lr": 1e-3, "warmup": 1000, "steps": 60000, "wd": 0.01, "betas": [0.9, 0.95],
|
||||
"batch": 1024, "lr": 1e-3, "warmup": 1000, "steps": 24000, "wd": 0.01, "betas": [0.9, 0.95],
|
||||
"amp": "bf16", "grad_clip": 1.0,
|
||||
"w_mf": 1.0, "w_fk": 0.5, "w_smooth": 0.05, "w_value": 0.1, "w_sub": 0.1,
|
||||
"p_neq": 0.25, "p_neq_warm": 5000, "fk_tmax": 0.3, "fk_caps": 96,
|
||||
"p_neq": 0.5, "p_edge": 0.1, "p_neq_warm": 5000, "fk_tmax": 0.3, "fk_caps": 96,
|
||||
"ema": 0.999, "aug_pre_drop": 0.15, "aug_pre_sigma": 0.1, "aug_dq_sigma": 0.3,
|
||||
"ckpt_min": 10, "eval_every": 2000, "eval_tasks": 512, "log_every": 50, "patience_evals": 5
|
||||
}
|
||||
}
|
||||
|
||||
+3
-2
@@ -1,10 +1,11 @@
|
||||
{
|
||||
"model": {"d": 192, "heads": 8, "ff": 768, "enc": 4, "dec": 4, "head": "wta", "K": 8},
|
||||
"train": {
|
||||
"batch": 1024, "lr": 1e-3, "warmup": 1000, "steps": 60000, "wd": 0.01, "betas": [0.9, 0.95],
|
||||
"batch": 1024, "lr": 1e-3, "warmup": 1000, "steps": 24000, "wd": 0.01, "betas": [0.9, 0.95],
|
||||
"amp": "bf16", "grad_clip": 1.0,
|
||||
"w_mf": 1.0, "w_fk": 0.5, "w_smooth": 0.05, "w_value": 0.1, "w_sub": 0.1,
|
||||
"p_neq": 0.25, "p_neq_warm": 5000, "fk_tmax": 0.3, "fk_caps": 96,
|
||||
"p_neq": 0.5, "p_edge": 0.1, "p_neq_warm": 5000, "fk_tmax": 0.3, "fk_caps": 96,
|
||||
"ema": 0.999, "aug_pre_drop": 0.15, "aug_pre_sigma": 0.1, "aug_dq_sigma": 0.3,
|
||||
"ckpt_min": 10, "eval_every": 2000, "eval_tasks": 512, "log_every": 50, "patience_evals": 5
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,7 +5,9 @@
|
||||
- 撞了的题：首次碰撞前 0.2 s 的状态（策略"快要撞上"的地方，最有用）；
|
||||
- 另取一个 [0.3 s, 首撞前或结束] 内均匀随机时刻的状态（偏离老师的一般状态）。
|
||||
起点必须无碰且间隙 > MIN_GAP_MM（老师从碰撞态出发规划不出来，与 build_dataset 的增广接受同一地板），且离目标 > 5 mm（否则 DLS 接管，不需要老师）。
|
||||
输出 tasks_XX.jsonl（按 --parts 均分，供 gen_dataset.cjs --tasks 并行），每行 {q0, T, R, cat, src}。
|
||||
输出 tasks_XX.jsonl（按 --parts 均分，供 gen_dataset.cjs --tasks 并行），每行 {q0, qPrev, T, R, cat, src}。
|
||||
2026-10-19（审查 F7 / C10）：同时记录策略在该时刻的上一帧 qPrev；老师重规划的时间律从当前速度（v0）起步，
|
||||
t=0 样本的 dq 特征用真实上一帧——原来一律按静止起步标注，DAgger 样本不是策略真正到过的 (q, dq) 状态。
|
||||
为什么需要：纯行为克隆在闭环里会偏出老师分布（首次 21850 步闭环到达 0%），原方案指望 APG/挖错修，但它们没法从 0% 起步。
|
||||
老师只用于训练标注，部署仍然无老师。"""
|
||||
import argparse, json, os, random
|
||||
@@ -30,9 +32,9 @@ def main():
|
||||
gap_min = float(os.environ.get('MIN_GAP_MM') or 3)
|
||||
os.makedirs(a.out, exist_ok=True)
|
||||
kin = Kin(device=a.device)
|
||||
ck = torch.load(a.ckpt, map_location=a.device)
|
||||
from ml.common.ckpt import load_policy # 2026-10-19：EMA 权重 + act_scale
|
||||
model, ck = load_policy(a.ckpt, a.device)
|
||||
assert ck.get('fp') in (None, kin.fp), '碰撞模型指纹与 checkpoint 不符'
|
||||
model = build(ck['cfg']).to(a.device); model.load_state_dict(ck['model']); model.eval()
|
||||
pool = [t for t in load_tasks(a.samples[:1]) if t['split'] == 'train' and t.get('cat') not in ('D',)]
|
||||
rng = random.Random(a.seed); rng.shuffle(pool); tasks = pool[:a.n]
|
||||
out, stat = [], {'tasks': len(tasks), 'collided': 0, 'states': 0, 'rej_gap': 0, 'rej_near': 0}
|
||||
@@ -61,10 +63,10 @@ def main():
|
||||
if c - 1 > lo: cand.append(rng.randint(lo, c - 1))
|
||||
for k in cand:
|
||||
if g[b, k] <= gap_min: stat['rej_gap'] += 1; continue
|
||||
q = tr[b, k:k + 1]
|
||||
q = tr[b, k:k + 1]; qprev = tr[b, max(0, k - 1)]
|
||||
e, oe = goal_err(kin, q, T[b:b + 1], R[b:b + 1])
|
||||
if e.item() < 5 and (not t.get('R') or oe.item() < 5): stat['rej_near'] += 1; continue
|
||||
out.append({'q0': [round(v, 3) for v in q[0].tolist()], 'T': t['T'], 'R': t.get('R'), 'cat': t.get('cat', 'A'),
|
||||
out.append({'q0': [round(v, 3) for v in q[0].tolist()], 'qPrev': [round(v, 3) for v in qprev.tolist()], 'T': t['T'], 'R': t.get('R'), 'cat': t.get('cat', 'A'),
|
||||
'src': {'tid': t['tid'], 'k': k, 'col': bool(hit.numel())}})
|
||||
del tr, g, per
|
||||
if a.device.startswith('cuda'): torch.cuda.empty_cache()
|
||||
|
||||
+7
-3
@@ -8,6 +8,9 @@
|
||||
# 最终模型路径写进 ml/runs/<tag>_dagger.ckpt（m5 读它）。
|
||||
# 断点续跑：采集以 collect.json 为完成标记；老师 shard 先写 .part 再改名、未写完的从断点续写；打包以 .tasks.jsonl 为完成标记；
|
||||
# 微调用该轮 last.pt 续训；整轮完成打 ml/runs/<tag>_dag<k>/done。
|
||||
# 2026-10-19（审查 review_model_train P0-2）：每轮起点 = python -m ml.common.ckpt pick <目录>：best.pt 的闭环 success > 0 才用它，
|
||||
# 否则用 last.pt（success 全 0 时 best.pt 只由开环误差决定、可能落在 p_neq 预热期）；train.py --init 载入 EMA 权重，
|
||||
# 只有起点已走过自己的 p_neq 预热时才不再预热。微调的 val 只取主数据（DAgger 样本全部算 train）。
|
||||
set -e -o pipefail
|
||||
cd "$(dirname "$0")/../.."
|
||||
PY=${PYTHON:-python}
|
||||
@@ -19,7 +22,7 @@ SAMPLES="ml/data/samples"
|
||||
for ((r=1; r<=R; r++)); do
|
||||
D=ml/data/dag_${TAG}_r$r; SD=ml/data/samples_dag_${TAG}_r$r; OUT=ml/runs/${TAG}_dag$r
|
||||
SAMPLES="$SAMPLES $SD"
|
||||
if [ -f $OUT/done ]; then echo "[dagger] 第 $r 轮已完成，跳过"; CK=$OUT/best.pt; continue; fi
|
||||
if [ -f $OUT/done ]; then echo "[dagger] 第 $r 轮已完成，跳过"; CK=$($PY -m ml.common.ckpt pick $OUT); continue; fi
|
||||
if [ -f $D/collect.json ]; then echo "[dagger] 第 $r 轮起点已采集，跳过"
|
||||
else echo "[dagger] 第 $r 轮：用 $CK 闭环采起点（$N 题）"; $PY -m ml.dagger.collect --ckpt $CK --samples ml/data/samples --n $N --seed $r --parts $P --out $D; fi
|
||||
cat $D/collect.json
|
||||
@@ -49,13 +52,14 @@ for ((r=1; r<=R; r++)); do
|
||||
done
|
||||
fi
|
||||
mkdir -p $SD
|
||||
todo=(); for sh in $D/shard_dag_*.jsonl; do [ -e "$sh" ] || continue; b=$(basename $sh .jsonl); [ -f $SD/$b.tasks.jsonl ] || todo+=("$sh"); done
|
||||
SIG=$(node ml/prep/build_dataset.cjs --sig) # 2026-10-19：与主数据同一套打包签名，参数变了重打（见 run_prep.sh）
|
||||
todo=(); for sh in $D/shard_dag_*.jsonl; do [ -e "$sh" ] || continue; b=$(basename $sh .jsonl); grep -qF "\"sig\":\"$SIG\"" $SD/$b.meta.json 2>/dev/null && [ -f $SD/$b.tasks.jsonl ] || todo+=("$sh"); done
|
||||
[ ${#todo[@]} = 0 ] || printf '%s\n' "${todo[@]}" | xargs -P "$P" -I{} node ml/prep/build_dataset.cjs {} $SD
|
||||
$PY -m ml.data --index $SD | tail -n 3
|
||||
res=""; [ -f $OUT/last.pt ] && res="--resume $OUT/last.pt"
|
||||
echo "[dagger] 第 $r 轮：微调 $STEPS 步（样本：$SAMPLES）"
|
||||
$PY -m ml.train --samples $SAMPLES --out $OUT --config $CFGF --init $CK --steps $STEPS --lr $LR --warmup 500 $res
|
||||
touch $OUT/done; CK=$OUT/best.pt
|
||||
touch $OUT/done; CK=$($PY -m ml.common.ckpt pick $OUT)
|
||||
done
|
||||
echo "$CK" > ml/runs/${TAG}_dagger.ckpt
|
||||
echo "[dagger] 完成：后续阶段使用 $CK"
|
||||
|
||||
+66
-7
@@ -1,12 +1,17 @@
|
||||
"""样本加载：ml/data/samples/*.{X,Y,V,SG,TID}.npy + *.tasks.jsonl（ml/prep/build_dataset.cjs 产出）
|
||||
"""样本加载：ml/data/samples/*.{X,Y,V,SG,TID}.npy + *.tasks.jsonl + *.meta.json（ml/prep/build_dataset.cjs 产出）
|
||||
python -m ml.data --index ml/data/samples # 汇总样本/任务数，写 index.json
|
||||
全部载入内存（200 万样本约 1.5 GB），按任务 split 字段划分 train / val。"""
|
||||
全部载入内存（200 万样本约 1.5 GB），按任务 split 字段划分 train / val。
|
||||
动作尺度（2026-10-19）：Y = 每步增量 / (act_scale·STEP)。act_scale 取自各 shard 的 meta.json（DATA_VER 2 起写；
|
||||
旧数据没有 meta → act_scale 1.0、data_ver 1，即原口径）。同一次训练的所有目录（主数据 + DAgger）必须同一个 act_scale。"""
|
||||
import argparse, glob, json, os
|
||||
import numpy as np
|
||||
import torch
|
||||
|
||||
PREFIX_SL, MASK_SL, DQ_SL, SUB_SL = slice(47, 65), slice(65, 68), slice(15, 21), slice(68, 75) # 特征分组（features.py 拼接顺序）
|
||||
|
||||
|
||||
def load_tasks(dirs):
|
||||
if isinstance(dirs, str): dirs = [dirs]
|
||||
tasks = []
|
||||
for d in dirs:
|
||||
for f in sorted(glob.glob(os.path.join(d, '*.tasks.jsonl'))):
|
||||
@@ -16,10 +21,28 @@ def load_tasks(dirs):
|
||||
return tasks
|
||||
|
||||
|
||||
def read_meta(d):
|
||||
"""目录内各 shard 的打包参数（data_ver、act_scale、增广参数、sig）。没有 meta 的旧打包 → {'data_ver': 1, 'act_scale': 1.0}。
|
||||
一部分有、一部分没有，或 act_scale 不一致 → 拒绝（新旧标签尺度混在一起会让动作幅度错 25%）。"""
|
||||
xs = sorted(glob.glob(os.path.join(d, '*.X.npy')))
|
||||
ms = [json.load(open(f[:-6] + '.meta.json', encoding='utf-8')) for f in xs if os.path.exists(f[:-6] + '.meta.json')]
|
||||
if not ms: return {'data_ver': 1, 'act_scale': 1.0}
|
||||
if len(ms) != len(xs): raise SystemExit(f'{d}：{len(xs) - len(ms)} 个 shard 缺 meta.json（新旧打包混在一起），重跑 prep')
|
||||
sc = {float(m.get('act_scale', 1.0)) for m in ms}
|
||||
if len(sc) != 1: raise SystemExit(f'{d}：各 shard 的 act_scale 不一致 {sorted(sc)}，重跑 prep')
|
||||
return ms[0]
|
||||
|
||||
|
||||
class Samples:
|
||||
def __init__(self, dirs, device='cpu', split=None):
|
||||
def __init__(self, dirs, device='cpu', split=None, val_dirs=None):
|
||||
"""val_dirs：只用这些目录的 val 任务划 val（默认 = 全部 dirs）。2026-10-19（审查 review_closedloop F11）：
|
||||
DAgger 目录的任务起点带速度、来自策略状态，不该混进预训练的 val；train.py / apg 传主数据目录，DAgger 样本全部算 train。"""
|
||||
if isinstance(dirs, str): dirs = [dirs]
|
||||
xs, ys, vs, ss, ts = [], [], [], [], []
|
||||
metas = [read_meta(d) for d in dirs]
|
||||
sc = {float(m['act_scale']) for m in metas}
|
||||
if len(sc) > 1: raise SystemExit(f'样本目录的 act_scale 不一致 {sorted(sc)}（{dirs}）：DAgger 样本须与主数据同一版打包')
|
||||
self.act_scale = sc.pop(); self.data_ver = int(metas[0].get('data_ver', 1)) if metas else 1
|
||||
for d in dirs:
|
||||
for fx in sorted(glob.glob(os.path.join(d, '*.X.npy'))):
|
||||
b = fx[:-6]
|
||||
@@ -27,7 +50,7 @@ class Samples:
|
||||
ss.append(np.load(b + '.SG.npy')); ts.append(np.load(b + '.TID.npy'))
|
||||
if not xs: raise SystemExit(f'没有样本：{dirs}（先跑 ml/prep/run_prep.sh）')
|
||||
self.tasks = load_tasks(dirs)
|
||||
val_tid = {t['tid'] for t in self.tasks if t['split'] == 'val'}
|
||||
val_tid = {t['tid'] for t in load_tasks(val_dirs if val_dirs is not None else dirs) if t['split'] == 'val'}
|
||||
X, Y, V, SG, TID = map(np.concatenate, (xs, ys, vs, ss, ts))
|
||||
is_val = np.isin(TID, np.fromiter(val_tid, dtype=np.int64)) if val_tid else np.zeros(len(TID), bool)
|
||||
sel = {'train': ~is_val, 'val': is_val, None: np.ones(len(TID), bool)}[split]
|
||||
@@ -35,9 +58,43 @@ class Samples:
|
||||
self.X, self.Y, self.V, self.SG, self.TID = t(X), t(Y), t(V), t(SG), t(TID)
|
||||
self.n = self.X.shape[0]
|
||||
|
||||
def batch(self, bs, gen=None):
|
||||
def batch(self, bs, gen=None, aug=None):
|
||||
"""aug：训练配置（train 段），按 aug_pre_drop / aug_pre_sigma / aug_dq_sigma 做条件输入增广（见 augment）；None = 原样。"""
|
||||
i = torch.randint(0, self.n, (bs,), device=self.X.device, generator=gen)
|
||||
return self.X[i], self.Y[i], self.V[i], self.SG[i]
|
||||
X, Y = self.X[i], self.Y[i]
|
||||
if aug: X, Y = self.augment(X.clone(), Y.clone(), aug, gen)
|
||||
return X, Y, self.V[i], self.SG[i]
|
||||
|
||||
def augment(self, X, Y, cfg, gen=None):
|
||||
"""条件输入增广（2026-10-19，审查 review_data_actions C3 / review_model_train P1-4：前缀与 dq 的 copycat 捷径）。
|
||||
训练集里 r=3 时要执行的 Y[3:6] 几乎就是前缀第 3 步的延续，dq 又永远是老师的干净速度，模型容易学成「照抄上一块」，
|
||||
闭环里自己的误差经前缀 / dq 原样带回。三种扰动，标签都保持自洽：
|
||||
- 前缀丢弃（aug_pre_drop）：r>0 的行以该概率清空前缀与掩码 → 变成 r=0 样本。Y 本来就从当前 q 起算，r=0 时标签不变；
|
||||
- 前缀噪声（aug_pre_sigma，STEP 为单位）：r>0 的行一半加噪声 ε。前缀 = 已提交、一定会执行的步，所以标签前 r 步同样 +ε，
|
||||
第 r 步减去 Σε 把位置拉回老师轨迹（亏空在下一步补齐，与增广收回同理）；
|
||||
- dq 噪声（aug_dq_sigma，STEP 为单位）：一半的行给速度特征加噪声，状态与标签不变。"""
|
||||
B, dev = X.shape[0], X.device
|
||||
rnd = lambda *s: torch.rand(*s, device=dev, generator=gen)
|
||||
rn = lambda *s: torch.randn(*s, device=dev, generator=gen)
|
||||
pl = X[:, MASK_SL].sum(-1).round().long()
|
||||
pd = float(cfg.get('aug_pre_drop', 0.0))
|
||||
if pd > 0:
|
||||
m = (rnd(B) < pd) & (pl > 0)
|
||||
X[:, 47:68] = torch.where(m[:, None], torch.zeros_like(X[:, 47:68]), X[:, 47:68]); pl = torch.where(m, torch.zeros_like(pl), pl)
|
||||
ps = float(cfg.get('aug_pre_sigma', 0.0))
|
||||
if ps > 0:
|
||||
m = (rnd(B) < 0.5) & (pl > 0)
|
||||
km = (torch.arange(3, device=dev)[None] < pl[:, None]) & m[:, None] # [B,3] 前缀有效步
|
||||
eps = rn(B, 3, 6) * ps * km[..., None].to(X.dtype) # STEP 为单位
|
||||
X[:, PREFIX_SL] = X[:, PREFIX_SL] + eps.reshape(B, 18)
|
||||
Y[:, :3] = Y[:, :3] + eps / self.act_scale # Y 以 act_scale·STEP 为单位
|
||||
Y[torch.arange(B, device=dev), pl.clamp(max=Y.shape[1] - 1)] -= eps.sum(1) / self.act_scale
|
||||
Y.clamp_(-1, 1)
|
||||
ds = float(cfg.get('aug_dq_sigma', 0.0))
|
||||
if ds > 0:
|
||||
m = (rnd(B) < 0.5).to(X.dtype)
|
||||
X[:, DQ_SL] = X[:, DQ_SL] + rn(B, 6) * ds * m[:, None]
|
||||
return X, Y
|
||||
|
||||
|
||||
def main():
|
||||
@@ -46,7 +103,9 @@ def main():
|
||||
tasks = load_tasks([a.index])
|
||||
cats = {}
|
||||
for t in tasks: cats[t['cat'] + '/' + t['mode']] = cats.get(t['cat'] + '/' + t['mode'], 0) + 1
|
||||
info = {'train_samples': tr.n, 'val_samples': va.n, 'tasks': len(tasks), 'val_tasks': sum(t['split'] == 'val' for t in tasks), 'by_cat_mode': cats}
|
||||
meta = read_meta(a.index)
|
||||
info = {'train_samples': tr.n, 'val_samples': va.n, 'tasks': len(tasks), 'val_tasks': sum(t['split'] == 'val' for t in tasks), 'by_cat_mode': cats,
|
||||
'data_ver': int(meta.get('data_ver', 1)), 'act_scale': float(meta.get('act_scale', 1.0)), 'sig': meta.get('sig')}
|
||||
json.dump(info, open(os.path.join(a.index, 'index.json'), 'w'), indent=1)
|
||||
print(json.dumps(info, indent=1))
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
其余项读已有文件（缺文件记为 missing，不算通过）：
|
||||
ml/runs/policy_bench.json 部署形态：各集合穿模帧 = 0；near 30/30（pos、pose）；route 全部到达；nc1000 0 失败；刹停率 < 2%；R8 恢复 ≥ 95%、活锁 = 0
|
||||
ml/data/r2.json R2 近邻标签 std < 10% 步长
|
||||
ml/runs/bench_*/log.jsonl R10 吞吐 ≥ 5000 样本/s（≈ 60000 步 ≤ 3.5 h）
|
||||
ml/runs/bench_*/log.jsonl R10 吞吐 ≥ 5000 样本/s（24000 步 batch 1024 ≈ 1.4 h）
|
||||
ml/runs/m5_gate_*.json M5 头门禁
|
||||
ml/runs/mine/r*/gate.json R7 最后一轮左右比例 / 行程门禁
|
||||
ml/runs/r4.json R4 浏览器推理 batch=8 P99 < 15 ms（r4 探针）
|
||||
@@ -37,8 +37,8 @@ def main():
|
||||
items.append({'item': name, 'value': value, 'pass': (None if ok is None else bool(ok)), 'rule': rule})
|
||||
|
||||
# 1) held-out 闭环（仿真安全层）
|
||||
ck = torch.load(a.ckpt, map_location=a.device)
|
||||
model = build(ck['cfg']).to(a.device); model.load_state_dict(ck['model']); model.eval()
|
||||
from ml.common.ckpt import load_policy # 2026-10-19：EMA 权重 + act_scale
|
||||
model, ck = load_policy(a.ckpt, a.device)
|
||||
kin = Kin(device=a.device)
|
||||
val = [t for t in load_tasks([a.samples]) if t['split'] == 'val']
|
||||
reach = [t for t in val if t.get('reached') and t['cat'] != 'D']
|
||||
@@ -97,7 +97,7 @@ def main():
|
||||
for f in sorted(glob.glob('ml/runs/bench_*/log.jsonl')):
|
||||
recs = [json.loads(l) for l in open(f) if '"samples_per_s"' in l]
|
||||
if recs: sps = max(sps or 0, recs[-1]['samples_per_s'])
|
||||
add('R10 训练吞吐（样本/s）', sps, sps is not None and sps >= 5000, '≥ 5000（≈ 60000 步 ≤ 3.5 h）')
|
||||
add('R10 训练吞吐（样本/s）', sps, sps is not None and sps >= 5000, '≥ 5000（24000 步 ≈ 1.4 h）')
|
||||
m5 = [jload(f) for f in sorted(glob.glob('ml/runs/m5_gate_*.json'))]
|
||||
m5 = [m for m in m5 if m]
|
||||
add('M5 头门禁', [{'head': m['head'], 'collision_rate': m['policy_only']['collision_rate']} for m in m5] or 'missing',
|
||||
|
||||
+3
-2
@@ -60,14 +60,15 @@ def measure(d, a, pool):
|
||||
# 与池无关的口径：全部有效近邻对（取距离较近的一半，排除远处非线性段）上回归 std ~ a + b·dist，截距 a
|
||||
dd = best_d[fin]; jj = best_j[fin]; qf = torch.nonzero(fin).squeeze(1)
|
||||
half = dd <= torch.quantile(dd, 0.5)
|
||||
Ya, Yb = d.Y[qi][qf[half], :3].float(), d.Y[pi][jj[half], :3].float()
|
||||
# 2026-10-19：Y 以 act_scale·STEP 为单位（DATA_VER 2 起 1.25），乘回 act_scale 让判据仍是「STEP 的比例」，与旧数据可比
|
||||
Ya, Yb = d.Y[qi][qf[half], :3].float() * d.act_scale, d.Y[pi][jj[half], :3].float() * d.act_scale
|
||||
sa = (Ya - Yb).pow(2).mean(-1).mean(-1).sqrt() / math.sqrt(2)
|
||||
A = torch.stack([torch.ones_like(dd[half]), dd[half]], 1)
|
||||
coef = torch.linalg.lstsq(A.cpu(), sa.cpu()[:, None]).solution.squeeze(1)
|
||||
std_norm = max(0.0, coef[0].item())
|
||||
thr = torch.quantile(best_d[fin], a.frac)
|
||||
m = fin & (best_d <= thr)
|
||||
Yq, Yp = d.Y[qi][m, :3].float(), d.Y[pi][best_j[m], :3].float()
|
||||
Yq, Yp = d.Y[qi][m, :3].float() * d.act_scale, d.Y[pi][best_j[m], :3].float() * d.act_scale
|
||||
rms = (Yq - Yp).pow(2).mean(-1).mean(-1).sqrt() # 每对、6 轴 × 3 步平均
|
||||
std = (rms / math.sqrt(2))
|
||||
return {'pairs': int(m.sum()), 'pool': P, 'queries': Q, 'nn_dist_threshold': thr.item(),
|
||||
|
||||
+217
-69
@@ -1,26 +1,34 @@
|
||||
#!/usr/bin/env python
|
||||
"""闭环失败定位（只读，手动运行，约 5–8 分钟；训练进行中也可以另开终端跑，显存约 2–3 GB）。
|
||||
|
||||
2026-10-19 新增：第二次预训练（979a581）开环已经正常（候选0 末端误差 ~6 mm、K 中最好 ~2.9 mm、多样性 0.65），
|
||||
闭环却仍 100% 碰撞、0% 到达。开环用的是 JS 生成的特征 X，闭环用的是 Python features() 现算的特征，
|
||||
两者之间只要有一处口径不同，模型在闭环里看到的就是没见过的输入。本脚本回答三件事：
|
||||
A. 特征口径：val 任务起点（非增广、老师状态）上，Python features() 与数据集 X 的逐组最大差；
|
||||
B. 同一噪声下，用两份特征得到的动作差（16 步末端关节差，度）——A 有差但 B 很小说明差异无害；
|
||||
C. 闭环失败形态：首次碰撞时刻分布、碰撞步数、首次碰撞的组对、全程最小目标误差、目标误差进度比；
|
||||
以及同一批题开安全层（safety=True，近似部署）的到达率 / 刹停次数。
|
||||
G. 候选选择与采样段数：一致性打分错位修正后，1 段/4 段采样 × consist/value/first 三种选法，以及 4 段 + 安全层的闭环对照。
|
||||
用法（仓库根目录）：
|
||||
"""闭环失败定位（只读，手动运行，n=256 约 35–50 分钟，显存约 3–6 GB）。
|
||||
PYTHONUTF8=1 python -m ml.eval.diag_cl --ckpt ml/runs/base/last.pt --n 256 --out ml/runs/diag_cl.json
|
||||
"""
|
||||
import argparse, json, os
|
||||
任务 = val 集前 n 题；老师轨迹按任务 id 从 ml/data/shard_*.jsonl 取（取不到的题不进 H 段，数量记在 H_tasks_missing_teacher）。
|
||||
模型经 ckpt.load_policy 载入（有 EMA 用 EMA；act_scale 随 checkpoint，旧 checkpoint = 1.0）。
|
||||
|
||||
段落：
|
||||
A. 特征口径：val 任务起点（非增广、老师状态）上，Python features() 与数据集 X 的逐组最大差 / 平均差。
|
||||
B. 同一噪声下两份特征得到的动作差（16 步末端关节差，度）。
|
||||
C. 旧部署口径（1 段采样、一致性选择、子目标旧规则 timeout）的失败形态：首撞时刻、碰撞步数、首撞组对、最小目标误差、
|
||||
目标误差进度比、开安全层的到达 / 碰撞 / 刹停。到达 = 时限内到达，碰撞只计时限内（2026-10-19 起）。
|
||||
H（2026-10-19，三份审查 review_closedloop / review_model_train / review_data_actions 的决定性实验）：
|
||||
H1 老师 oracle 走完整 rollout()（closed_loop.TeacherOracle；select='first'、use_sub=False）：
|
||||
H1_oracle：额外含 oracle 字段——DLS 接管前与老师轨迹的最大关节偏差、到达 / 碰撞、完成时刻 − 老师时长；
|
||||
H1_oracle_noise_<σ>（σ = 0.05 / 0.1 / 0.2，STEP 为单位，每次规划重采）：闭环对残差噪声的敏感度。
|
||||
H2 前缀消融：H2_open_loop（r=3 的 val 行，前缀 47:68 原样 vs 置零，执行窗口 3..5 的误差）；
|
||||
H2_replan_empty_s{1,4}：队列空了才规划（每次 r=0、提交 3 步），其余同部署。
|
||||
H3 子目标：H3_headsub_cross_s{1,4}（子目标头 + 越过顶点规则 = 新部署默认）、H3_headsub_timeout_s{1,4}（旧规则 = 旧部署）、
|
||||
H3_teachersub_cross_s{1,4} / H3_teachersub_timeout_s{1,4}（老师真实途经点全表）、H3_nosub_s{1,4}（不用子目标）。
|
||||
H4 指标（上面每个闭环变体都输出同一组键，见 metrics()）；H4_open_loop：按前缀长度 r=0..3 的执行窗口误差。
|
||||
_s1 / _s4 = MeanFlow 1 段（部署）/ 4 段采样。"""
|
||||
import argparse, json, math, os
|
||||
|
||||
import torch
|
||||
|
||||
from ml.common.ckpt import load_policy
|
||||
from ml.common.kin_torch import Kin
|
||||
from ml.common.features import features, STEP, H
|
||||
from ml.data import Samples, load_tasks
|
||||
from ml.model.policy import build
|
||||
from ml.sim.closed_loop import rollout, goal_err, DT
|
||||
from ml.data import Samples, load_tasks, read_meta
|
||||
from ml.sim.closed_loop import rollout, goal_err, DT, TeacherOracle
|
||||
from ml.eval.replay_teacher import load_teacher, pad_traj, oracle_raw, oracle_summary
|
||||
|
||||
# 83 维特征分组（与 features.py 拼接顺序一致）
|
||||
GROUPS = [('sincos', 0, 12), ('joint_norm', 12, 15), ('dq', 15, 21), ('p', 21, 24), ('Rq', 24, 30), ('T', 30, 33),
|
||||
@@ -29,26 +37,134 @@ GROUPS = [('sincos', 0, 12), ('joint_norm', 12, 15), ('dq', 15, 21), ('p', 21, 2
|
||||
|
||||
|
||||
PROG_T = (0.5, 1.0, 2.0) # 目标误差 / 起点误差 的取样时刻（s）
|
||||
K1, K2 = int(round(1.0 / DT)), int(round(2.0 / DT)) # 1 s / 2 s 对应的步数
|
||||
|
||||
|
||||
def pct(v, p):
|
||||
v = sorted(v)
|
||||
v = sorted(x for x in v if x is not None and x == x)
|
||||
return v[min(len(v) - 1, int(len(v) * p))] if v else None
|
||||
|
||||
|
||||
def qt(t, p):
|
||||
t = t[torch.isfinite(t)]
|
||||
return round(float(t.kthvalue(max(1, min(len(t), int(math.ceil(p * len(t)))))).values), 4) if len(t) else None
|
||||
|
||||
|
||||
def rnd(x, n=4):
|
||||
if isinstance(x, list): return [rnd(v, n) for v in x]
|
||||
return None if x is None or x != x else round(float(x), n)
|
||||
|
||||
|
||||
def pad_len(tr, n):
|
||||
"""轨迹 [B,T,6] 末帧重复补到至少 n 帧（到达后冻结，补帧与冻结等价）。"""
|
||||
if tr.shape[1] >= n: return tr
|
||||
return torch.cat([tr, tr[:, -1:].expand(-1, n - tr.shape[1], -1)], 1)
|
||||
|
||||
|
||||
def batch_stats(kin, ch, per, TR):
|
||||
"""一批的逐题量（CPU）。窗口：幅度 / 净位移 / TCP 用前 1 s，变号率用前 2 s 的 3 步块。"""
|
||||
dev = TR.device
|
||||
stp = torch.tensor(STEP, device=dev)
|
||||
tr = pad_len(per['traj'].to(dev), K2 + 1); te = pad_len(TR, K2 + 1)
|
||||
B = tr.shape[0]
|
||||
amp = lambda x: (x[:, 1:K1 + 1] - x[:, :K1]).abs().sum(1) # [B,6] 前 1 s 关节行程
|
||||
net = lambda x: (x[:, K1] - x[:, 0]).abs() # [B,6] 前 1 s 净位移
|
||||
def tcp(x):
|
||||
p = kin.fk(x[:, :K1 + 1].reshape(-1, 6)).view(B, K1 + 1, 3)
|
||||
return (p[:, 1:] - p[:, :-1]).norm(dim=-1).sum(1), (p[:, -1] - p[:, 0]).norm(dim=-1)
|
||||
def flips(x):
|
||||
idx = torch.arange(0, K2 + 1, 3, device=dev)
|
||||
b = x[:, idx[1:]] - x[:, idx[:-1]] # [B,nb,6] 3 步块增量
|
||||
big = b.abs() > 0.1 * stp
|
||||
v = big[:, 1:] & big[:, :-1]
|
||||
f = v & (torch.sign(b[:, 1:]) != torch.sign(b[:, :-1]))
|
||||
return f.sum(1).float(), v.sum(1).float()
|
||||
tl_p, tn_p = tcp(tr); tl_t, tn_t = tcp(te)
|
||||
fp_, vp_ = flips(tr); ft_, vt_ = flips(te)
|
||||
ex = torch.tensor([t.get('exec_s') or float('nan') for t in ch])
|
||||
return {'ok': per['ok'], 'col': per['col'] > 0, 'isD': torch.tensor([t.get('cat') == 'D' for t in ch]),
|
||||
'pose': torch.tensor([bool(t.get('R')) for t in ch]), 'key': [t.get('cat', '?') + '/' + t.get('mode', '?') for t in ch],
|
||||
'r2': per['goal_ratio_2s'], 'err': per['err'], 'first_hit': per['first_hit'], 'brakes': per['brakes'],
|
||||
'tratio': per['t_done'] / ex,
|
||||
'amp_p': amp(tr).cpu(), 'amp_t': amp(te).cpu(), 'net_p': net(tr).cpu(), 'net_t': net(te).cpu(),
|
||||
'tl_p': tl_p.cpu(), 'tl_t': tl_t.cpu(), 'tn_p': tn_p.cpu(), 'tn_t': tn_t.cpu(),
|
||||
'fl_p': fp_.cpu(), 'fv_p': vp_.cpu(), 'fl_t': ft_.cpu(), 'fv_t': vt_.cpu()}
|
||||
|
||||
|
||||
def metrics(stats):
|
||||
"""H4 指标（每个闭环变体同一组键）：
|
||||
reach / collision：cat≠D、时限内（D 类目标不可达，单列在 D）；
|
||||
goal_ratio_2s_p50：2 s 时目标误差 / 起点误差；end_goal_err_mm_p50；first_hit_s_p50（撞了的题）；t_done_over_teacher_p50（到达的题）；
|
||||
joint_amp_ratio[6]：前 1 s 各轴关节行程 Σ|Δq| 策略 / 老师（全体题合计；J6 只算 pose 题，pos 题老师冻结 J6）；
|
||||
joint_net_ratio[6]：前 1 s 各轴净位移 |q(1s) − q(0)| 策略 / 老师（同上）；j6_pos_amp_deg_p50：pos 题策略 J6 前 1 s 行程（度，老师为 0）；
|
||||
tcp_path_ratio_p50 / tcp_net_ratio_p50：前 1 s TCP 路程 / 净位移 策略 / 老师（逐题比，老师 > 1 mm 的题）；
|
||||
sign_flip_rate[6] / sign_flip_rate_teacher[6]：前 2 s 相邻 3 步块增量变号的比例（两块都 > 0.1·STEP 才计）；
|
||||
by_cat_mode：各 cat/mode 的 n、reach、collision、goal_ratio_2s_p50（不含 D）；D：n、collision、end_goal_err_mm_p50、goal_ratio_2s_p50。"""
|
||||
c = {k: (sum((s[k] for s in stats), []) if isinstance(stats[0][k], list) else torch.cat([s[k] for s in stats])) for k in stats[0]}
|
||||
keys = c['key']
|
||||
m = ~c['isD']; pose = c['pose']
|
||||
def jr(a, b):
|
||||
out = []
|
||||
for j in range(6):
|
||||
sel = m & pose if j == 5 else m
|
||||
den = float(b[sel, j].sum()); out.append(float(a[sel, j].sum()) / den if den > 1e-6 else None)
|
||||
return rnd(out)
|
||||
tl_ok = m & (c['tl_t'] > 1); tn_ok = m & (c['tn_t'] > 1)
|
||||
out = {'n': int(m.sum()),
|
||||
'reach': rnd(c['ok'][m].float().mean()) if m.any() else None,
|
||||
'collision': rnd(c['col'][m].float().mean()) if m.any() else None,
|
||||
'goal_ratio_2s_p50': qt(c['r2'][m], .5), 'end_goal_err_mm_p50': qt(c['err'][m], .5),
|
||||
'first_hit_s_p50': qt(c['first_hit'][m], .5), 't_done_over_teacher_p50': qt(c['tratio'][m & c['ok']], .5),
|
||||
'brakes_p50': qt(c['brakes'][m], .5),
|
||||
'joint_amp_ratio': jr(c['amp_p'], c['amp_t']), 'joint_net_ratio': jr(c['net_p'], c['net_t']),
|
||||
'j6_pos_amp_deg_p50': qt(c['amp_p'][m & ~pose, 5], .5),
|
||||
'tcp_path_ratio_p50': qt(c['tl_p'][tl_ok] / c['tl_t'][tl_ok], .5), 'tcp_net_ratio_p50': qt(c['tn_p'][tn_ok] / c['tn_t'][tn_ok], .5),
|
||||
'sign_flip_rate': rnd((c['fl_p'][m].sum(0) / c['fv_p'][m].sum(0).clamp(min=1)).tolist()),
|
||||
'sign_flip_rate_teacher': rnd((c['fl_t'][m].sum(0) / c['fv_t'][m].sum(0).clamp(min=1)).tolist())}
|
||||
by = {}
|
||||
for i, k in enumerate(keys):
|
||||
if not bool(m[i]): continue
|
||||
by.setdefault(k, []).append(i)
|
||||
out['by_cat_mode'] = {k: {'n': len(ix), 'reach': rnd(c['ok'][ix].float().mean()), 'collision': rnd(c['col'][ix].float().mean()),
|
||||
'goal_ratio_2s_p50': qt(c['r2'][ix], .5)} for k, ix in sorted(by.items())}
|
||||
d = c['isD']
|
||||
out['D'] = {'n': int(d.sum()), 'collision': rnd(c['col'][d].float().mean()) if d.any() else None,
|
||||
'end_goal_err_mm_p50': qt(c['err'][d], .5), 'goal_ratio_2s_p50': qt(c['r2'][d], .5)}
|
||||
return out
|
||||
|
||||
|
||||
def teacher_subs(recs, device):
|
||||
"""老师真实途经点全表（path 去掉起终点）→ (subs [B,M,6], n [B])，供 rollout(sub_override=...)。"""
|
||||
vs = [r['path'][1:-1] for r in recs]
|
||||
M = max(1, max(len(v) for v in vs))
|
||||
subs = torch.zeros(len(vs), M, 6, device=device); n = torch.zeros(len(vs), dtype=torch.long, device=device)
|
||||
for i, v in enumerate(vs):
|
||||
if v:
|
||||
x = torch.tensor(v, dtype=torch.float32, device=device); subs[i, :len(v)] = x; subs[i, len(v):] = x[-1]; n[i] = len(v)
|
||||
return subs, n
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument('--ckpt', required=True); ap.add_argument('--samples', default='ml/data/samples')
|
||||
ap.add_argument('--shards', default='ml/data/shard_*.jsonl')
|
||||
ap.add_argument('--n', type=int, default=256); ap.add_argument('--bs', type=int, default=64)
|
||||
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu'); ap.add_argument('--out', default='ml/runs/diag_cl.json')
|
||||
a = ap.parse_args()
|
||||
dev = a.device
|
||||
ck = torch.load(a.ckpt, map_location=dev)
|
||||
model = build(ck['cfg']).to(dev); model.load_state_dict(ck['model']); model.eval()
|
||||
model, ck = load_policy(a.ckpt, dev)
|
||||
kin = Kin(device=dev)
|
||||
out = {'ckpt': a.ckpt, 'step': ck.get('step')}
|
||||
astep = torch.tensor(STEP, device=dev) * model.act_scale # 动作 → 度
|
||||
data_scale = float(read_meta(a.samples).get('act_scale', 1.0))
|
||||
out = {'ckpt': a.ckpt, 'step': ck.get('step'), 'weights': 'ema' if ck.get('ema') is not None else 'model',
|
||||
'act_scale_ckpt': model.act_scale, 'act_scale_data': data_scale}
|
||||
tasks = [t for t in load_tasks([a.samples]) if t['split'] == 'val'][:a.n]
|
||||
by_tid = {t['tid']: t for t in tasks}
|
||||
def save():
|
||||
s = json.dumps(out, indent=1, ensure_ascii=False)
|
||||
os.makedirs(os.path.dirname(a.out) or '.', exist_ok=True)
|
||||
open(a.out + '.tmp', 'w', encoding='utf-8').write(s); os.replace(a.out + '.tmp', a.out)
|
||||
return s
|
||||
|
||||
# ---------- A / B：起点特征口径 ----------
|
||||
vd = Samples(a.samples, device=dev, split='val')
|
||||
@@ -67,35 +183,69 @@ def main():
|
||||
T = torch.tensor([t['T'] for t in tc], dtype=torch.float32, device=dev)
|
||||
R = torch.tensor([t['R'] if t.get('R') else [0.] * 9 for t in tc], dtype=torch.float32, device=dev)
|
||||
B = qc.shape[0]
|
||||
qpc = torch.tensor([t.get('qp0') or t['q0'] for t in tc], dtype=torch.float32, device=dev)
|
||||
pre = Xc[:, 47:65].view(B, 3, 6) * torch.tensor(STEP, device=dev) # 前缀 / 子目标直接取数据集里的，只比状态相关部分
|
||||
pl = Xc[:, 65:68].sum(-1).round()
|
||||
sf = Xc[:, 74]
|
||||
sub = qc + Xc[:, 68:74] * 180
|
||||
Fp = features(kin, qc, qc, T, R, pre, pl, sub, sf)
|
||||
Fp = features(kin, qc, qpc, T, R, pre, pl, sub, sf)
|
||||
out['A_maxdiff'] = {g: (Fp[:, s:e] - Xc[:, s:e]).abs().max().item() for g, s, e in GROUPS}
|
||||
out['A_meandiff'] = {g: (Fp[:, s:e] - Xc[:, s:e]).abs().mean().item() for g, s, e in GROUPS}
|
||||
with torch.no_grad():
|
||||
z = torch.randn(B * 8, H, 6, device=dev, generator=torch.Generator(device=dev).manual_seed(7))
|
||||
a1, _, _ = model.sample_k(Xc, 8, z); a2, _, _ = model.sample_k(Fp, 8, z)
|
||||
stepv = torch.tensor(STEP, device=dev)
|
||||
d = ((a1.clamp(-1, 1) - a2.clamp(-1, 1)) * stepv).sum(2).abs().max(-1).values # [B,K] 16 步末端关节差（度）
|
||||
mag = (a1.clamp(-1, 1) * stepv).sum(2).abs().max(-1).values
|
||||
d = ((a1.clamp(-1, 1) - a2.clamp(-1, 1)) * astep).sum(2).abs().max(-1).values # [B,K] 16 步末端关节差（度）
|
||||
mag = (a1.clamp(-1, 1) * astep).sum(2).abs().max(-1).values
|
||||
out['B_act_diff_deg'] = {'mean': d.mean().item(), 'p90': d.flatten().kthvalue(max(1, int(0.9 * d.numel()))).values.item(),
|
||||
'ref_motion_deg_mean': mag.mean().item()}
|
||||
|
||||
# ---------- C：闭环失败形态 ----------
|
||||
# ---------- H4 / H2 开环：执行窗口误差（val 行，老师状态） ----------
|
||||
# 闭环稳态 r=3，真正执行的是 act[r:r+3]；原来的 ol_fk_mm 是 16 步终点误差，前缀那几步几乎不会错，看不出执行窗口。
|
||||
with torch.no_grad():
|
||||
pl_all = vd.X[:, 65:68].sum(-1).round().long()
|
||||
gsel = torch.Generator(device=dev); gsel.manual_seed(321)
|
||||
def rows_with(r, n=1024):
|
||||
ix = (pl_all == r).nonzero().flatten()
|
||||
return ix[torch.randperm(len(ix), device=dev, generator=gsel)[:n]] if len(ix) else ix
|
||||
def win_err(X, Y, r, steps, k0=None):
|
||||
k0 = r if k0 is None else k0
|
||||
z = torch.randn(X.shape[0] * 8, H, 6, device=dev, generator=torch.Generator(device=dev).manual_seed(11))
|
||||
act, _, _ = model.sample_k(X, 8, z, steps=steps); act = act.float().clamp(-1, 1)
|
||||
e = ((act[:, :, k0:k0 + 3] - Y[:, None, k0:k0 + 3]) * astep).sum(2).abs() # [N,K,6] 窗口累计误差（度）
|
||||
emax = e.max(-1).values.flatten()
|
||||
res = {'n_rows': int(X.shape[0]), 'deg_mean': rnd(emax.mean()), 'deg_p90': qt(emax, .9), 'per_joint_deg_mean': rnd(e.mean((0, 1)).tolist())}
|
||||
if r > 0 and k0 == r:
|
||||
ce = ((act[:, :, :r] - Y[:, None, :r]) * astep).abs().max(-1).values.max(-1).values.flatten()
|
||||
res['prefix_copy_err_deg_mean'] = rnd(ce.mean())
|
||||
return res
|
||||
ol4, ol2 = {}, {}
|
||||
for steps in (1, 4):
|
||||
for r in range(4):
|
||||
ix = rows_with(r)
|
||||
if len(ix): ol4['s%d_r%d' % (steps, r)] = win_err(vd.X[ix].float(), vd.Y[ix].float(), r, steps)
|
||||
ix = rows_with(3)
|
||||
if len(ix):
|
||||
X3 = vd.X[ix].float(); Y3 = vd.Y[ix].float(); X3z = X3.clone(); X3z[:, 47:68] = 0
|
||||
ol2['s%d_prefix_orig' % steps] = win_err(X3, Y3, 3, steps)
|
||||
ol2['s%d_prefix_zeroed' % steps] = win_err(X3z, Y3, 0, steps, k0=3)
|
||||
out['H4_open_loop'] = ol4; out['H2_open_loop'] = ol2
|
||||
del vd
|
||||
if dev.startswith('cuda'): torch.cuda.empty_cache()
|
||||
|
||||
# ---------- C：旧部署口径的闭环失败形态（子目标旧规则，便于与前几轮对比） ----------
|
||||
first_t, col_steps, pairs, min_err, reach = [], [], {}, [], 0
|
||||
prog = {ts: [] for ts in PROG_T}
|
||||
reach_s, brakes_s, col_s = 0, [], 0
|
||||
for i in range(0, len(tasks), a.bs):
|
||||
ch = tasks[i:i + a.bs]
|
||||
with torch.no_grad():
|
||||
_, per = rollout(model, kin, ch, dev, K=8, safety=False, seed=i, return_traj=True)
|
||||
_, per = rollout(model, kin, ch, dev, K=8, safety=False, seed=i, return_traj=True, sub_rule='timeout')
|
||||
tr = per['traj'].to(dev) # [B,Tn,6]
|
||||
B, Tn, _ = tr.shape
|
||||
flat = tr.reshape(-1, 6) # 分块 ≤1024 点（同 dagger/collect.py 的显存修复）
|
||||
gm = torch.cat([kin.gaps(flat[s:s + 1024], 0.5)['gm'] for s in range(0, flat.shape[0], 1024)]).view(B, Tn, 49)
|
||||
hit = gm.min(-1).values <= 0 # [B,Tn]
|
||||
inlim = (torch.arange(Tn, device=dev)[None] * DT) <= per['limit'].to(dev)[:, None] + 1e-6
|
||||
hit = (gm.min(-1).values <= 0) & inlim # [B,Tn] 只计时限内
|
||||
Tt = torch.tensor([t['T'] for t in ch], dtype=torch.float32, device=dev)
|
||||
Rt = torch.tensor([t['R'] if t.get('R') else [0.] * 9 for t in ch], dtype=torch.float32, device=dev)
|
||||
e, _ = goal_err(kin, tr.reshape(-1, 6), Tt.repeat_interleave(Tn, 0), Rt.repeat_interleave(Tn, 0))
|
||||
@@ -103,16 +253,15 @@ def main():
|
||||
for b in range(B):
|
||||
for ts in PROG_T:
|
||||
k = min(Tn - 1, int(round(ts / DT))); prog[ts].append((e[b, k] / e[b, 0].clamp(min=1e-3)).item())
|
||||
# 到达后轨迹被冻结（d=0），之后不再计
|
||||
for b in range(B):
|
||||
if per['done'][b]: reach += 1
|
||||
if per['ok'][b]: reach += 1
|
||||
min_err.append(e[b].min().item()); col_steps.append(int(per['col'][b]))
|
||||
h = hit[b].nonzero().flatten()
|
||||
if len(h):
|
||||
k = int(h[0]); first_t.append(k * DT)
|
||||
pr = int(gm[b, k].argmin()); key = '%d-%d' % (pr // 7, pr % 7); pairs[key] = pairs.get(key, 0) + 1
|
||||
rs, ps = rollout(model, kin, ch, dev, K=8, safety=True, seed=i)
|
||||
reach_s += int(ps['done'].sum()); col_s += int((ps['col'] > 0).sum()); brakes_s += ps['brakes'].tolist()
|
||||
rs, ps = rollout(model, kin, ch, dev, K=8, safety=True, seed=i, sub_rule='timeout')
|
||||
reach_s += int(ps['ok'].sum()); col_s += int((ps['col'] > 0).sum()); brakes_s += ps['brakes'].tolist()
|
||||
n = len(tasks)
|
||||
out['C'] = {'n': n, 'reach': reach / n, 'collided': len(first_t) / n,
|
||||
'first_hit_s': {'p10': pct(first_t, .1), 'p50': pct(first_t, .5), 'p90': pct(first_t, .9),
|
||||
@@ -122,46 +271,45 @@ def main():
|
||||
'min_goal_err_mm': {'p10': pct(min_err, .1), 'p50': pct(min_err, .5), 'p90': pct(min_err, .9)},
|
||||
'safety_on': {'reach': reach_s / n, 'collided': col_s / n, 'brakes_p50': pct(brakes_s, .5)}}
|
||||
out['C']['goal_err_ratio_p50'] = {'%.1fs' % ts: pct(v, .5) for ts, v in prog.items()} # <1 = 在靠近目标
|
||||
print(save(), flush=True)
|
||||
|
||||
# ---------- G：候选选择与采样段数（2026-10-19 加） ----------
|
||||
# 第四轮 F 段：一步采样残留噪声真实（抖动 42×、残差-噪声相关 −0.86），4 段采样闭环碰撞 99.6%→93%，但到达仍 0%；
|
||||
# 零噪声（8 条候选完全相同，选择不起作用）0%/100%——均值样本本身偏老师 ~4°（多峰平均）。
|
||||
# 复查闭环发现一致性打分错位一步（对齐 last[3]，应为 last[4]），等于每次重规划奖励「比上一计划慢一步」的候选；
|
||||
# 已在 closed_loop.py 与 ik-policy.js 修正，上面 C 段即修正后的一步采样基线。
|
||||
# G 段在同一批题上比较：4 段采样 × 三种选法（consist 部署口径 / value 每次价值前瞻 / first 不选），以及 4 段 + 安全层。
|
||||
# 若 consist≈first，说明选择不是主因；若 value 明显好，说明一致性选法本身把闭环带偏；三者都 0% 则问题在策略本身（转向协变量偏移）。
|
||||
def variant(**kw):
|
||||
rc = cc_ = 0; me, r2, fh, sp, br = [], [], [], [], []
|
||||
for i in range(0, len(tasks), a.bs):
|
||||
ch = tasks[i:i + a.bs]
|
||||
# ---------- H：闭环变体（同一批 val 题，老师轨迹按 id 取） ----------
|
||||
teach = load_teacher(a.shards, [t['id'] for t in tasks])
|
||||
tH = [t for t in tasks if t['id'] in teach]
|
||||
out['H_tasks'] = len(tH); out['H_tasks_missing_teacher'] = len(tasks) - len(tH)
|
||||
|
||||
def variant(oracle_sigma=None, teacher_sub=False, **kw):
|
||||
stats, raws = [], []
|
||||
for i in range(0, len(tH), a.bs):
|
||||
ch = tH[i:i + a.bs]; recs = [teach[t['id']] for t in ch]
|
||||
TR = pad_traj([r['traj'] for r in recs], dev)
|
||||
kw2 = dict(kw)
|
||||
if oracle_sigma is not None:
|
||||
kw2.update(oracle=TeacherOracle(TR, act_scale=data_scale, sigma=oracle_sigma), select='first', use_sub=False)
|
||||
if teacher_sub: kw2['sub_override'] = teacher_subs(recs, dev)
|
||||
with torch.no_grad():
|
||||
_, pp = rollout(model, kin, ch, dev, K=8, seed=i, return_traj=True, **kw)
|
||||
tr = pp['traj'].to(dev); B, Tn, _ = tr.shape
|
||||
k2 = min(Tn - 1, int(round(2.0 / DT))); k1 = min(Tn - 1, int(round(1.0 / DT)))
|
||||
Tt = torch.tensor([t['T'] for t in ch], dtype=torch.float32, device=dev)
|
||||
Rt = torch.tensor([t['R'] if t.get('R') else [0.] * 9 for t in ch], dtype=torch.float32, device=dev)
|
||||
e0, _ = goal_err(kin, tr[:, 0], Tt, Rt); e2, _ = goal_err(kin, tr[:, k2], Tt, Rt)
|
||||
r2 += (e2 / e0.clamp(min=1e-3)).tolist()
|
||||
# 前 1 s 关节行程速度 / 老师平均速度（travel/exec_s）
|
||||
v1 = (tr[:, 1:k1 + 1] - tr[:, :k1]).abs().sum((1, 2)) / (k1 * DT)
|
||||
sp += [float(v1[b]) / max(1e-6, ch[b]['travel'] / ch[b]['exec_s']) for b in range(B) if ch[b].get('travel') and ch[b].get('exec_s')]
|
||||
flat = tr.reshape(-1, 6)
|
||||
gm = torch.cat([kin.gaps(flat[s0:s0 + 1024], 0.5)['gm'] for s0 in range(0, flat.shape[0], 1024)]).view(B, Tn, 49)
|
||||
hit = gm.min(-1).values <= 0
|
||||
for b in range(B):
|
||||
h = hit[b].nonzero().flatten()
|
||||
if len(h): fh.append(int(h[0]) * DT)
|
||||
rc += int(pp['done'].sum()); cc_ += int((pp['col'] > 0).sum()); me += pp['err'].tolist(); br += pp['brakes'].tolist()
|
||||
return {'reach': rc / n, 'collided': cc_ / n, 'goal_err_ratio_2s_p50': pct(r2, .5), 'end_goal_err_mm_p50': pct(me, .5),
|
||||
'first_hit_s_p50': pct(fh, .5), 'speed_ratio_1s_p50': pct(sp, .5), 'brakes_p50': pct(br, .5)}
|
||||
out['G_1step_consist'] = variant(steps=1, select='consist')
|
||||
out['G_4step_consist'] = variant(steps=4, select='consist')
|
||||
out['G_4step_value'] = variant(steps=4, select='value')
|
||||
out['G_4step_first'] = variant(steps=4, select='first')
|
||||
out['G_4step_consist_safety'] = variant(steps=4, select='consist', safety=True)
|
||||
s = json.dumps(out, indent=1, ensure_ascii=False); print(s)
|
||||
os.makedirs(os.path.dirname(a.out) or '.', exist_ok=True)
|
||||
open(a.out, 'w', encoding='utf-8').write(s)
|
||||
_, per = rollout(None if oracle_sigma is not None else model, kin, ch, dev, K=8, seed=i, return_traj=True, **kw2)
|
||||
stats.append(batch_stats(kin, ch, per, TR))
|
||||
if oracle_sigma is not None: raws.append(oracle_raw(per, TR, [len(r['traj']) for r in recs], ch))
|
||||
del per
|
||||
res = metrics(stats)
|
||||
if oracle_sigma is not None and oracle_sigma == 0: res['oracle'] = oracle_summary(raws)
|
||||
if dev.startswith('cuda'): torch.cuda.empty_cache()
|
||||
return res
|
||||
|
||||
plan = [('H1_oracle', dict(oracle_sigma=0.0))]
|
||||
plan += [('H1_oracle_noise_%g' % s, dict(oracle_sigma=s)) for s in (0.05, 0.1, 0.2)]
|
||||
for st in (1, 4):
|
||||
plan += [('H3_headsub_cross_s%d' % st, dict(steps=st, sub_rule='cross')),
|
||||
('H3_headsub_timeout_s%d' % st, dict(steps=st, sub_rule='timeout')),
|
||||
('H3_teachersub_cross_s%d' % st, dict(steps=st, sub_rule='cross', teacher_sub=True)),
|
||||
('H3_teachersub_timeout_s%d' % st, dict(steps=st, sub_rule='timeout', teacher_sub=True)),
|
||||
('H3_nosub_s%d' % st, dict(steps=st, use_sub=False)),
|
||||
('H2_replan_empty_s%d' % st, dict(steps=st, sub_rule='cross', replan='empty'))]
|
||||
for name, kw in plan:
|
||||
out[name] = variant(**kw)
|
||||
save(); print('[diag] %s 完成' % name, flush=True)
|
||||
print(save(), flush=True)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -43,10 +43,8 @@ def main():
|
||||
from ml.model.policy import build
|
||||
from ml.sim.closed_loop import rollout, goal_err
|
||||
|
||||
ck = torch.load(a.ckpt, map_location=a.device)
|
||||
model = build(ck['cfg']).to(a.device)
|
||||
model.load_state_dict(ck['model'])
|
||||
model.eval()
|
||||
from ml.common.ckpt import load_policy # 2026-10-19：EMA 权重 + act_scale
|
||||
model, ck = load_policy(a.ckpt, a.device)
|
||||
kin = Kin(device=a.device)
|
||||
if ck.get('fp') and ck['fp'] != kin.fp:
|
||||
sys.exit('checkpoint 的碰撞模型指纹 %s 与当前 kin.json %s 不符' % (ck['fp'], kin.fp))
|
||||
|
||||
+106
-11
@@ -1,19 +1,90 @@
|
||||
"""老师轨迹回放自检（2026-10-18 首次正式预训练后新增；train 阶段开训前自动跑，约 1 分钟）：
|
||||
把 gen 写出的老师 50 Hz 轨迹（keep=true）直接放进闭环仿真用的 PyTorch 运动学 / 碰撞 / 到达判据里检查。
|
||||
老师轨迹在 JS 侧已认证无碰、已到达；如果这里判出碰撞或未到达，说明仿真口径（kin.json、间隙、到达门槛）和数据对不上，
|
||||
那么闭环指标本身不可信，训练多少步都没用 —— 直接停下（rc 5）。
|
||||
"""老师轨迹回放自检（train 阶段开训前自动跑，约 1–3 分钟）：
|
||||
python -m ml.eval.replay_teacher --n 512 --out ml/runs/replay_teacher.json
|
||||
判据：到达率（cat≠D）≥ 0.95，碰撞率 ≤ 0.01。"""
|
||||
import argparse, glob, json, os, sys
|
||||
两部分，都过才 pass（pipeline.sh 读 pass 字段与指纹，不过就停 rc 5）：
|
||||
1. 运动学口径（2026-10-18）：gen 写出的老师 50 Hz 轨迹（keep=true、cat≠D）直接放进 PyTorch 运动学 / 碰撞 / 到达判据：
|
||||
到达率 ≥ 0.95、碰撞率 ≤ 0.01。验证的是「仿真口径（kin.json、间隙、到达门槛）与 JS 认证过的数据一致」。
|
||||
2. 滚动口径（2026-10-19，审查 review_closedloop F1/D1、review_data_actions C1）：上面那条完全不经过 rollout()，
|
||||
队列 / 前缀 / 提交 3 步 / qe / 标签 clamp / DLS / done / 时限上的错位它都发现不了。这里让老师当策略（closed_loop.TeacherOracle：
|
||||
每次规划从当前时间下标取老师 16 步增量，按标签口径 clamp）原样走 rollout()（select='first'、use_sub=False）：
|
||||
到达（时限内）≥ 0.95、碰撞 ≤ 0.01、DLS 接管前与老师轨迹的最大关节偏差 p99 ≤ 0.1°（shard 轨迹按 1e-3° 取整，标签 clamp 会截掉取整的余量）。
|
||||
输出另带 fp（当前 kin.json）、data_fp（shard 里记录的碰撞模型指纹）、ver=2；pipeline 三者都核对。
|
||||
load_teacher / pad_traj / oracle_raw / oracle_summary 供 ml/eval/diag_cl.py 的 H1 段复用。"""
|
||||
import argparse, glob, json, math, os, sys
|
||||
import torch
|
||||
|
||||
from ml.common.kin_torch import Kin
|
||||
from ml.sim.closed_loop import goal_err
|
||||
from ml.sim.closed_loop import goal_err, rollout, TeacherOracle, DT
|
||||
|
||||
DEV_TOL_DEG = 0.1
|
||||
|
||||
|
||||
def load_teacher(shards, ids):
|
||||
"""按任务 id 从 shard jsonl 取老师记录（traj、path、exec_s…）。只解析 id 命中的行。"""
|
||||
want, out = set(ids), {}
|
||||
for f in sorted(glob.glob(shards)):
|
||||
for line in open(f, encoding='utf-8'):
|
||||
k = line.find('"id":"')
|
||||
if k < 0: continue
|
||||
rid = line[k + 6:line.find('"', k + 6)]
|
||||
if rid in want and rid not in out:
|
||||
r = json.loads(line)
|
||||
if r.get('traj'): out[rid] = r
|
||||
if len(out) == len(want): break
|
||||
return out
|
||||
|
||||
|
||||
def pad_traj(trajs, device, extra=20):
|
||||
"""[B,Tmax+extra,6]：各题老师轨迹末帧重复补齐（oracle 在轨迹末尾之后给零增量）。"""
|
||||
Tm = max(len(t) for t in trajs) + extra
|
||||
out = torch.zeros(len(trajs), Tm, 6, device=device)
|
||||
for i, t in enumerate(trajs):
|
||||
x = torch.tensor(t, dtype=torch.float32, device=device)
|
||||
out[i, :len(t)] = x; out[i, len(t):] = x[-1]
|
||||
return out
|
||||
|
||||
|
||||
def oracle_raw(per, TR, lens, tasks):
|
||||
"""oracle 滚动的逐题量：DLS 接管前（且到达前、老师轨迹结束前）与老师的最大关节偏差 mdev（度）、时限内到达 ok、
|
||||
时限内碰撞 col、是否计入到达统计（cat≠D）、完成时刻 − 老师时长 dt（s）、是否用过 DLS、2 s 目标误差比。"""
|
||||
tr = per['traj'].to(TR.device); B, Tn, _ = tr.shape
|
||||
L = min(Tn, TR.shape[1])
|
||||
dev = (tr[:, :L] - TR[:, :L]).abs().max(-1).values # [B,L]
|
||||
k = torch.arange(L, device=TR.device)[None]
|
||||
kd = torch.tensor(lens, device=TR.device)[:, None] - 1
|
||||
dls = per['dls_it'].to(TR.device)[:, None]
|
||||
td = per['t_done'].to(TR.device)
|
||||
kdone = torch.where(torch.isfinite(td), (td / DT).round(), torch.full_like(td, 1e9)).long()[:, None]
|
||||
valid = (k <= kd) & ((dls < 0) | (k <= dls)) & (k <= kdone)
|
||||
ex = torch.tensor([t.get('exec_s') or float('nan') for t in tasks])
|
||||
return {'mdev': torch.where(valid, dev, torch.zeros_like(dev)).max(-1).values.cpu(), 'ok': per['ok'], 'col': per['col'] > 0,
|
||||
'reach_m': torch.tensor([t.get('cat') != 'D' for t in tasks]), 'dt': per['t_done'] - ex,
|
||||
'dls': per['dls_it'] >= 0, 'r2': per['goal_ratio_2s']}
|
||||
|
||||
|
||||
def _q(v, p):
|
||||
v = v[torch.isfinite(v)]
|
||||
return float(v.kthvalue(max(1, min(len(v), int(math.ceil(p * len(v)))))).values) if len(v) else None
|
||||
|
||||
|
||||
def oracle_summary(raws):
|
||||
c = {k: torch.cat([r[k] for r in raws]) for k in raws[0]}
|
||||
m = c['reach_m']; ok = c['ok']
|
||||
dt = c['dt'][ok & m]
|
||||
return {'n': int(len(m)), 'n_reach_tasks': int(m.sum()),
|
||||
'reach': float(ok[m].float().mean()) if m.any() else None,
|
||||
'collision': float(c['col'][m].float().mean()) if m.any() else None,
|
||||
'D': {'n': int((~m).sum()), 'collision': float(c['col'][~m].float().mean()) if (~m).any() else None},
|
||||
'max_dev_deg_before_dls': {'p50': _q(c['mdev'], .5), 'p99': _q(c['mdev'], .99), 'max': float(c['mdev'].max())},
|
||||
'dls_used': float(c['dls'].float().mean()),
|
||||
'finish_minus_teacher_s': {'p50': _q(dt, .5), 'p90': _q(dt, .9), 'max': float(dt.max()) if len(dt) else None},
|
||||
'goal_ratio_2s_p50': _q(c['r2'], .5)}
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument('--shards', default='ml/data/shard_*.jsonl'); ap.add_argument('--n', type=int, default=512)
|
||||
ap.add_argument('--samples', default='ml/data/samples', help='读打包 meta 的 act_scale（oracle 按同一标签口径 clamp）；没有就按 1.0')
|
||||
ap.add_argument('--bs', type=int, default=128)
|
||||
ap.add_argument('--out', default='ml/runs/replay_teacher.json')
|
||||
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu')
|
||||
a = ap.parse_args()
|
||||
@@ -26,6 +97,7 @@ def main():
|
||||
if len(recs) >= a.n: break
|
||||
if len(recs) >= a.n: break
|
||||
if not recs: sys.exit('没有可回放的老师轨迹（先跑 gen）')
|
||||
# ---- 1. 运动学口径
|
||||
reach = col = 0; worst_gap = []
|
||||
for r in recs:
|
||||
q = torch.tensor(r['traj'], dtype=torch.float32, device=a.device)
|
||||
@@ -37,11 +109,34 @@ def main():
|
||||
e, oe = goal_err(kin, q[-1:], T, R)
|
||||
reach += bool((e < 1).item() and (oe < 0.5).item())
|
||||
n = len(recs)
|
||||
res = {'n': n, 'reach': reach / n, 'collision': col / n, 'min_gap_mm_p10': sorted(worst_gap)[n // 10],
|
||||
'pass': reach / n >= 0.95 and col / n <= 0.01, 'fp': kin.fp}
|
||||
kin_ok = reach / n >= 0.95 and col / n <= 0.01
|
||||
# ---- 2. 滚动口径：老师 oracle 走完整 rollout()
|
||||
try:
|
||||
from ml.data import read_meta
|
||||
act_scale = float(read_meta(a.samples).get('act_scale', 1.0)) if os.path.isdir(a.samples) else 1.0
|
||||
except SystemExit:
|
||||
act_scale = 1.0
|
||||
tasks = [{'q0': r['q0'], 'T': r['T'], 'R': r.get('R'), 'exec_s': r.get('exec_s') or (len(r['traj']) - 1) * DT,
|
||||
'travel': r.get('travel_deg'), 'cat': r.get('cat')} for r in recs]
|
||||
raws = []
|
||||
for i in range(0, n, a.bs):
|
||||
tb, rb = tasks[i:i + a.bs], recs[i:i + a.bs]
|
||||
TR = pad_traj([r['traj'] for r in rb], a.device)
|
||||
_, per = rollout(None, kin, tb, a.device, K=1, select='first', use_sub=False, return_traj=True, seed=i,
|
||||
oracle=TeacherOracle(TR, act_scale=act_scale))
|
||||
raws.append(oracle_raw(per, TR, [len(r['traj']) for r in rb], tb))
|
||||
orc = oracle_summary(raws); orc['act_scale'] = act_scale
|
||||
orc_ok = (orc['reach'] or 0) >= 0.95 and (orc['collision'] or 0) <= 0.01 and orc['max_dev_deg_before_dls']['p99'] <= DEV_TOL_DEG
|
||||
data_fps = {r.get('fp') for r in recs}
|
||||
data_fp = data_fps.pop() if len(data_fps) == 1 else 'mixed'
|
||||
res = {'ver': 2, 'n': n, 'reach': reach / n, 'collision': col / n, 'min_gap_mm_p10': sorted(worst_gap)[n // 10], 'kin_pass': kin_ok,
|
||||
'oracle': orc, 'oracle_pass': orc_ok, 'fp': kin.fp, 'data_fp': data_fp,
|
||||
'pass': bool(kin_ok and orc_ok and data_fp in (None, kin.fp))}
|
||||
os.makedirs(os.path.dirname(a.out) or '.', exist_ok=True)
|
||||
json.dump(res, open(a.out, 'w', encoding='utf-8'), indent=1)
|
||||
print('老师轨迹回放：到达 %.1f%%、碰撞 %.1f%%（%d 条）' % (100 * res['reach'], 100 * res['collision'], n), flush=True)
|
||||
json.dump(res, open(a.out, 'w', encoding='utf-8'), indent=1, ensure_ascii=False)
|
||||
print('老师轨迹回放：到达 %.1f%%、碰撞 %.1f%%（%d 条）；oracle 走 rollout：到达 %.1f%%、碰撞 %.1f%%、DLS 前最大偏差 p99 %.4f°；指纹 %s' % (
|
||||
100 * res['reach'], 100 * res['collision'], n, 100 * orc['reach'], 100 * orc['collision'],
|
||||
orc['max_dev_deg_before_dls']['p99'], '一致' if data_fp in (None, kin.fp) else '不符'), flush=True)
|
||||
sys.exit(0 if res['pass'] else 5)
|
||||
|
||||
|
||||
|
||||
+6
-4
@@ -1,7 +1,7 @@
|
||||
"""导出部署包（方案 §8.4）：
|
||||
python -m ml.export_onnx --ckpt ml/runs/current.pt --out webapp/models/traj_policy.onnx [--fp16]
|
||||
输出 traj_policy.onnx（输入 feat[1 或 K,83]、z[K,16,6]；输出 act[K,16,6] 归一化增量、value[K]、sub[K,13]）
|
||||
与 traj_policy.meta.json（碰撞模型指纹、特征版本、维度、enc_once）。导出后用 onnxruntime 与 PyTorch 对拍。
|
||||
与 traj_policy.meta.json（碰撞模型指纹、特征版本、维度、enc_once、act_scale）。导出后用 onnxruntime 与 PyTorch 对拍。
|
||||
2026-10-18 第五轮：改为"编码一次、解码 K 次"（Policy.sample_shared），meta.enc_once=true；运行时据此只送 1 行特征。
|
||||
2026-10-18 第六轮：feat 轴改为动态（1 行 = 主推理编码一次；K 行 = 前瞻逐行编码），meta.feat_dyn=true。
|
||||
第五轮的 enc_once 模型 feat 固定 1 行，运行时前瞻只能逐行推（ik-policy.js ortInfer 已兼容），重新导出即可。
|
||||
@@ -32,8 +32,8 @@ def main():
|
||||
torch.manual_seed(0); ck = {'cfg': json.load(open(a.random)), 'random_init': True}
|
||||
m = build(ck['cfg']); m.eval()
|
||||
elif a.ckpt:
|
||||
ck = torch.load(a.ckpt, map_location='cpu')
|
||||
m = build(ck['cfg']); m.load_state_dict(ck['model']); m.eval()
|
||||
from ml.common.ckpt import load_policy # 2026-10-19：导出 EMA 权重（审查 P1-5：原来导的是原始权重）
|
||||
m, ck = load_policy(a.ckpt, 'cpu')
|
||||
else: raise SystemExit('需要 --ckpt 或 --random <配置>')
|
||||
kin = Kin()
|
||||
if ck.get('fp') and ck['fp'] != kin.fp: raise SystemExit(f"checkpoint 指纹 {ck['fp']} ≠ 当前碰撞模型 {kin.fp}：须重训")
|
||||
@@ -62,8 +62,10 @@ def main():
|
||||
err_rows = max(float(np.abs(o8[i] - r8[i].numpy()).max()) for i in range(3))
|
||||
assert err_rows < 1e-3, f'feat 为 K 行时与 sample 不一致：{err_rows}'
|
||||
err = max(err, err_rows)
|
||||
# 2026-10-19：act_scale = 动作标签归一化倍数，运行时 inc = clamp(act, ±1)·act_scale·STEP（ik-policy.js Runner 的 actScale 读它）
|
||||
meta = {'fp': kin.fp, 'tcp0': kin.tcp0.tolist(), 'head': m.head, 'feat_ver': FEAT_VER, 'f_dim': F_DIM, 'h': H, 'step': STEP, 'fp16': a.fp16,
|
||||
'ckpt': os.path.abspath(a.ckpt) if a.ckpt else None, 'random_init': bool(a.random), 'enc_once': True, 'feat_dyn': True, 'eval': ck.get('eval'), 'max_abs_err_vs_torch': err}
|
||||
'ckpt': os.path.abspath(a.ckpt) if a.ckpt else None, 'random_init': bool(a.random), 'enc_once': True, 'feat_dyn': True,
|
||||
'act_scale': float(ck.get('act_scale', 1.0)), 'eval': ck.get('eval'), 'max_abs_err_vs_torch': err}
|
||||
json.dump(meta, open(a.out.replace('.onnx', '.meta.json'), 'w'), indent=1)
|
||||
print(json.dumps({'onnx': a.out, 'MB': os.path.getsize(a.out) / 1e6, 'max_abs_err_vs_torch': err}))
|
||||
|
||||
|
||||
@@ -5,7 +5,9 @@
|
||||
* 每行一条任务：采样 → 老师 → 距离下界认证过滤 → 局部时间律（50 Hz）→ 写出。
|
||||
* 认证不过的样本也写出（keep=false + 原因），供 stats 统计丢弃率；训练只用 keep=true。
|
||||
* 2026-10-18 断点续写：第 i 条任务的随机数只由 (seed, i) 决定（sampler.reseed）；输出文件已存在时保留其中完整的行、
|
||||
* 截掉写了一半的最后一行，从下一条接着写 —— 生成几小时被中断，重跑只补剩下的，不重来、不重复。 */
|
||||
* 截掉写了一半的最后一行，从下一条接着写 —— 生成几小时被中断，重跑只补剩下的，不重来、不重复。
|
||||
* 2026-10-19：--tasks 的任务带 qPrev（DAgger 采集时策略的上一帧）时，记录 qPrev 与起步速度 v0（timelaw.initSpeed），
|
||||
* 时间律从 v0 起步；build_dataset.cjs 用它们做 t=0 样本的 dq 特征与标签。 */
|
||||
'use strict';
|
||||
const fs = require('fs'), path = require('path');
|
||||
const args = {}; for (let i = 2; i < process.argv.length; i += 2) args[process.argv[i].replace(/^--/, '')] = process.argv[i + 1];
|
||||
@@ -19,7 +21,7 @@ const K_CONS = +args.consensus || 0;
|
||||
const GIVEN = args.tasks ? fs.readFileSync(args.tasks, 'utf8').split('\n').filter(Boolean).map(l => JSON.parse(l)) : null;
|
||||
const NT = GIVEN ? GIVEN.length : N;
|
||||
const cert = require('./cert.cjs')(S, {});
|
||||
const { timeParam } = require('./timelaw.cjs');
|
||||
const { timeParam, initSpeed } = require('./timelaw.cjs');
|
||||
const fp = S.modelFingerprint ? S.modelFingerprint() : null;
|
||||
fs.mkdirSync(path.dirname(OUT), { recursive: true });
|
||||
let done = 0;
|
||||
@@ -63,7 +65,11 @@ for (let i = done; i < NT; i++) {
|
||||
if (valid >= 2 && agree * 2 < valid) { rec.keep = false; rec.why = 'consensus'; }
|
||||
}
|
||||
if (t.poseRelaxed && task.mode === 'pose') { rec.mode = 'pos'; rec.R = null; rec.demoted = true; rec.reached = t.err < 1; }
|
||||
if (rec.keep) { const tp = timeParam(t.pts); rec.traj = tp.traj.map(q => q.map(r3)); rec.exec_s = r3(tp.steps * 0.02); }
|
||||
if (rec.keep && task.qPrev) {
|
||||
rec.qPrev = task.qPrev.map(r3);
|
||||
rec.v0 = r3(initSpeed(t.pts, task.qPrev, S.wrap180, S.ORDER.map(id => !!S.LIM[id].cont)));
|
||||
}
|
||||
if (rec.keep) { const tp = timeParam(t.pts, { v0: rec.v0 || 0 }); rec.traj = tp.traj.map(q => q.map(r3)); rec.exec_s = r3(tp.steps * 0.02); }
|
||||
fs.writeSync(fd, JSON.stringify(rec) + '\n');
|
||||
if ((i + 1) % 25 === 0) process.stderr.write(`[seed ${SEED}] ${i + 1}/${NT} ${((performance.now() - t00) / 1000 / (i + 1 - done)).toFixed(2)} s/条\n`);
|
||||
}
|
||||
|
||||
+20
-3
@@ -1,7 +1,10 @@
|
||||
/* 局部可观测时间律（2026-10-17，方案 §4.5）
|
||||
* 折线按"巡航时间" τ 参数化：每段 τ = max_j |Δq_j| / VMAX_j（各轴同步、主导轴满速）。
|
||||
* 归一化速度 v∈[0,1]（1 = 巡航）：v ← min(1, v + A·dt, sqrt(2·A·剩余 τ))，只依赖当前速度与剩余路程。
|
||||
* 输出 50 Hz（dt = 20 ms）状态序列，末点精确落在终点。 */
|
||||
* 输出 50 Hz（dt = 20 ms）状态序列，末点精确落在终点。
|
||||
* 2026-10-19（审查 review_closedloop F7 / review_data_actions C10）：opt.v0 = 起步归一化速度（默认 0 = 静止起步）。
|
||||
* DAgger 重新标注的起点来自策略闭环、本来就在运动，原来一律从静止加速，标签与策略真正到达的 (q, dq) 状态不符。
|
||||
* initSpeed(P, qPrev) 把当前速度投影到首段方向上得到 v0（gen_dataset.cjs 用）。 */
|
||||
'use strict';
|
||||
const VMAX = [60, 60, 90, 90, 120, 180]; // °/s，与 tests/route_bench.cjs 同（轴速比 0.6/0.6/0.9/0.9/1.2/1.8）
|
||||
const A = 5.0; // 1/s²：0→巡航约 0.2 s（a_max 待真机参数）
|
||||
@@ -19,7 +22,7 @@ function timeParam(P, opt) {
|
||||
const u = segT[i] > 0 ? (tau - cum[i]) / segT[i] : 1;
|
||||
return P[i].map((v, j) => v + (P[i + 1][j] - v) * u);
|
||||
};
|
||||
const out = [P[0].slice()], taus = [0]; let tau = 0, v = 0, guard = 0;
|
||||
const out = [P[0].slice()], taus = [0]; let tau = 0, v = Math.max(0, Math.min(1, opt.v0 || 0)), guard = 0;
|
||||
while (tau < total - 1e-9 && guard++ < 100000) {
|
||||
const rem = total - tau;
|
||||
const v1 = Math.min(1, v + a * dt, Math.sqrt(2 * a * Math.max(0, rem - 0.5 * v * dt)) + 1e-9);
|
||||
@@ -30,4 +33,18 @@ function timeParam(P, opt) {
|
||||
}
|
||||
return { traj: out, taus, cum, total, steps: out.length - 1 };
|
||||
}
|
||||
module.exports = { timeParam, VMAX, A, DT };
|
||||
/* 起步速度：w_j = 当前每步增量 / STEP_j（qPrev → P[0]），u_j = 巡航时首段每步增量 / STEP_j（max|u_j| = 1），
|
||||
v0 = clamp(⟨w,u⟩/⟨u,u⟩, 0, 1)——当前速度在首段方向上的分量；反向或首段为零时 0。wrap：连续轴差值的最短弧函数（可缺省）。 */
|
||||
function initSpeed(P, qPrev, wrap, cont) {
|
||||
if (!qPrev || !P || P.length < 2) return 0;
|
||||
const dd = (a, b, j) => (wrap && cont && cont[j]) ? wrap(a - b) : a - b;
|
||||
let seg = 0; for (let j = 0; j < 6; j++) seg = Math.max(seg, Math.abs(P[1][j] - P[0][j]) / VMAX[j]);
|
||||
if (seg < 1e-9) return 0;
|
||||
let wu = 0, uu = 0;
|
||||
for (let j = 0; j < 6; j++) {
|
||||
const u = (P[1][j] - P[0][j]) / VMAX[j] / seg, w = dd(P[0][j], qPrev[j], j) / (VMAX[j] * DT);
|
||||
wu += w * u; uu += u * u;
|
||||
}
|
||||
return Math.max(0, Math.min(1, wu / uu));
|
||||
}
|
||||
module.exports = { timeParam, initSpeed, VMAX, A, DT };
|
||||
|
||||
+2
-2
@@ -12,8 +12,8 @@ from ml.sim.closed_loop import evaluate
|
||||
|
||||
|
||||
def load(path, dev):
|
||||
ck = torch.load(path, map_location=dev)
|
||||
m = build(ck['cfg']).to(dev); m.load_state_dict(ck['model']); return m.eval()
|
||||
from ml.common.ckpt import load_policy # 2026-10-19：EMA 权重 + act_scale
|
||||
return load_policy(path, dev)[0]
|
||||
|
||||
|
||||
def per_task_success(pers):
|
||||
|
||||
@@ -28,8 +28,8 @@ def main():
|
||||
with open(os.path.join(a.out, a.name), 'w') as f:
|
||||
for t in ts: f.write(json.dumps(t) + '\n')
|
||||
print('gate tasks', len(ts)); return
|
||||
ck = torch.load(a.ckpt, map_location=a.device)
|
||||
model = build(ck['cfg']).to(a.device); model.load_state_dict(ck['model']); model.eval()
|
||||
from ml.common.ckpt import load_policy # 2026-10-19：EMA 权重 + act_scale
|
||||
model, ck = load_policy(a.ckpt, a.device)
|
||||
tasks = sample_tasks(kin, a.n, a.seed)
|
||||
g = torch.Generator(); g.manual_seed(a.seed)
|
||||
cls = {k: [] for k in ('E1', 'E2', 'E3', 'E4', 'E5', 'ok')}
|
||||
|
||||
@@ -11,20 +11,26 @@ import torch
|
||||
from torch.func import jvp
|
||||
|
||||
|
||||
def sample_rt(B, device, dtype, p_neq=0.25, mu=-0.4, sigma=1.0):
|
||||
def sample_rt(B, device, dtype, p_neq=0.25, mu=-0.4, sigma=1.0, p_edge=0.0):
|
||||
"""2026-10-19（审查 review_model_train P0-3）：部署只在 (r=0, t=1) 推理一次，而 logit-normal 取 max/min 后
|
||||
P(t>0.95) 约 0.08%、P(r<0.05) 约 0.5%，这个角几乎从未被训练到（一步残差与噪声相关 −0.86 即外推失准）。
|
||||
p_neq > 0 时另以 p_edge 的概率把样本直接放在 (r=0, t=1)；预热期（p_neq=0）不放，那时一步映射本就不训。"""
|
||||
t = torch.sigmoid(torch.randn(B, device=device, dtype=dtype) * sigma + mu)
|
||||
r = torch.sigmoid(torch.randn(B, device=device, dtype=dtype) * sigma + mu)
|
||||
t, r = torch.maximum(t, r), torch.minimum(t, r)
|
||||
eq = torch.rand(B, device=device) >= p_neq
|
||||
r = torch.where(eq, t, r)
|
||||
if p_neq > 0 and p_edge > 0:
|
||||
edge = torch.rand(B, device=device) < p_edge
|
||||
t = torch.where(edge, torch.ones_like(t), t); r = torch.where(edge, torch.zeros_like(r), r)
|
||||
return r, t
|
||||
|
||||
|
||||
def meanflow_loss(model, mem, x, p_neq=0.25, ada_p=1.0, ada_c=1e-3, return_aux=False):
|
||||
def meanflow_loss(model, mem, x, p_neq=0.25, ada_p=1.0, ada_c=1e-3, return_aux=False, p_edge=0.0):
|
||||
mem, x = mem.float(), x.float()
|
||||
with torch.autocast('cuda', enabled=False):
|
||||
B = x.shape[0]
|
||||
r, t = sample_rt(B, x.device, x.dtype, p_neq)
|
||||
r, t = sample_rt(B, x.device, x.dtype, p_neq, p_edge=p_edge)
|
||||
e = torch.randn_like(x)
|
||||
z = (1 - t)[:, None, None] * x + t[:, None, None] * e
|
||||
v = e - x
|
||||
|
||||
+2
-1
@@ -276,7 +276,8 @@ def stage_progress(st, s):
|
||||
if m and m.get('total'):
|
||||
return {'frac': (bs + m['step']) / (bs + m['total']), 'label': f'正式训练 {m["step"]:,} / {m["total"]:,} 步', 'run': tag,
|
||||
'eta_s': m['eta_h'] * 3600 if m.get('eta_h') else None} # 训练脚本自己按实测样本/s 算的
|
||||
if b: return {'frac': b['step'] / (bs + 60000), 'label': f'测速 {b["step"]:,} / {bs:,} 步', 'run': f'bench_{tag}'}
|
||||
if b: return {'frac': b['step'] / (bs + 24000), # 2026-10-19：正式步数按 configs/base.json 的 24000 估
|
||||
'label': f'测速 {b["step"]:,} / {bs:,} 步', 'run': f'bench_{tag}'}
|
||||
return {'frac': 0, 'label': '加载数据中'}
|
||||
if st == 'dagger': # 2026-10-18 新增：每轮 = 采起点 → 老师重规划 → 打包 → 微调（微调占大头，进度按 0.1/0.25/0.05/0.6 分）
|
||||
tag, R = info.get('tag', 'base'), int(info.get('rounds', 2))
|
||||
|
||||
+19
-5
@@ -78,19 +78,33 @@ on_exit() {
|
||||
trap on_exit EXIT
|
||||
trap 'exit 143' TERM INT HUP # 被停止 / 超时：先走 on_exit 记返回码、放锁
|
||||
# ---- 训练与门禁的单元（m5 自动分支要对两种头各调一次）
|
||||
replay_ok() { # 回放自检结果有效：pass 为真、版本含 oracle 滚动（ver ≥ 2）、指纹 = 当前 kin.json 且 = 数据 shard 的指纹
|
||||
$PY - <<'PY'
|
||||
import json, sys
|
||||
try:
|
||||
r = json.load(open('ml/runs/replay_teacher.json', encoding='utf-8')); k = json.load(open('ml/assets/kin.json', encoding='utf-8'))['fp']
|
||||
except Exception: sys.exit(1)
|
||||
sys.exit(0 if r.get('pass') is True and r.get('ver', 1) >= 2 and r.get('fp') == k and r.get('data_fp') in (None, k) else 1)
|
||||
PY
|
||||
}
|
||||
train_one() { # $1 = 配置文件
|
||||
local cfg=$1 tag; tag=$(basename "$1" .json)
|
||||
# 2026-10-18：开训前先把老师轨迹放进 PyTorch 仿真口径里回放——口径对不上时闭环指标不可信，训多少步都白训（rc 5 停）
|
||||
[ -f ml/runs/replay_teacher.json ] || run $PY -m ml.eval.replay_teacher --n 512 --out ml/runs/replay_teacher.json
|
||||
# 2026-10-19（审查 review_closedloop F6）：原来只看文件在不在——replay 失败时也写了文件（pass=false）再 rc 5，用户直接重跑 train 门禁就被跳过。
|
||||
# 现在读 pass 字段 + 指纹（kin.json、数据 shard），不过就重跑一次，仍不过 rc 5；回放同时走完整 rollout()（老师 oracle），覆盖滚动路径。
|
||||
replay_ok || run $PY -m ml.eval.replay_teacher --n 512 --out ml/runs/replay_teacher.json || true
|
||||
replay_ok || { echo "老师回放自检未通过（ml/runs/replay_teacher.json 的 pass / 指纹），闭环指标不可信，不开训"; exit 5; }
|
||||
if [ -f ml/runs/bench_$tag/last.pt ]; then echo "吞吐摸底 ml/runs/bench_$tag 已有，跳过"
|
||||
else run $PY -m ml.train --samples ml/data/samples --out ml/runs/bench_$tag --steps ${BENCH_STEPS:-2000} --no-eval --config $cfg; fi
|
||||
local res=""; [ -f ml/runs/$tag/last.pt ] && { res="--resume ml/runs/$tag/last.pt"; echo "发现 ml/runs/$tag/last.pt → 续训"; }
|
||||
run $PY -m ml.train --samples ml/data/samples --out ml/runs/$tag --config $cfg $res
|
||||
}
|
||||
dagger_one() { # $1 = 头标签：从该头的预训练 best.pt 起做 DAgger，最终模型路径写进 ml/runs/<tag>_dagger.ckpt
|
||||
local tag=$1
|
||||
[ -f ml/runs/$tag/best.pt ] || { echo "DAgger：ml/runs/$tag/best.pt 不存在（预训练没完成）"; return 3; }
|
||||
run bash ml/dagger/run.sh $tag ml/runs/$tag/best.pt
|
||||
dagger_one() { # $1 = 头标签：从该头的预训练结果起做 DAgger，最终模型路径写进 ml/runs/<tag>_dagger.ckpt
|
||||
local tag=$1 ck
|
||||
[ -f ml/runs/$tag/best.pt ] || [ -f ml/runs/$tag/last.pt ] || { echo "DAgger：ml/runs/$tag/ 下没有 checkpoint（预训练没完成）"; return 3; }
|
||||
# 2026-10-19（审查 P0-2）：闭环 success > 0 用 best.pt，否则 last.pt（都取 EMA 权重）
|
||||
ck=$($PY -m ml.common.ckpt pick ml/runs/$tag)
|
||||
run bash ml/dagger/run.sh $tag $ck
|
||||
}
|
||||
m5_one() { # $1 = 头标签；返回 0 通过 / 3 不通过。起点模型：CKPT > DAgger 结果 > 预训练 best.pt
|
||||
local tag=$1 ck o
|
||||
|
||||
+34
-13
@@ -2,18 +2,33 @@
|
||||
* node ml/prep/build_dataset.cjs ml/data/shard_0001.jsonl [outDir=ml/data/samples]
|
||||
* 每条 keep=true 的轨迹按 50 Hz 时间律重放，每 3 步取一个样本：
|
||||
* X [N,83] 特征（webapp/js/ik-policy.js features()，与部署同一份代码）
|
||||
* Y [N,16,6] 未来 16 步每步增量 / STEP（到终点后补 0）
|
||||
* Y [N,16,6] 未来 16 步每步增量 / (ACT_SCALE·STEP)，夹在 ±1（到终点后补 0）
|
||||
* V [N] 剩余时间（s）/ 5
|
||||
* SG [N,13] 子目标标签：剩余两个途经点相对当前 q 的差 / 180（不足用终点补）+ 是否需要
|
||||
* TID[N] 任务编号（tasks.jsonl 行号所在的全局 id，用于划分与闭环验证）
|
||||
* 增广（2026-10-18 首次正式预训练后加大）：40% 样本对 q_t 加 σ=AUG_SIGMA（默认 3°）噪声，标签改为 AUG_BACK（默认 12）步内线性收回老师轨迹；
|
||||
* 噪声态须无干涉且间隙 > MIN_GAP_MM，收回途中第 3/6/9/12 步也须无干涉（σ 加大后直接线性拉回可能穿过障碍）。
|
||||
* 原为 30%、σ=1°、8 步：闭环一偏出 1° 就是没见过的状态，首次 21850 步闭环到达 0%。更大的偏离由 DAgger 阶段补（ml/dagger）。
|
||||
* 已提交前缀长度 r ∈ {0..3} 均匀随机，前缀取老师接下来 r 步的增量。 */
|
||||
* 已提交前缀长度 r ∈ {0..3} 均匀随机，前缀取老师接下来 r 步的增量。
|
||||
* meta [<shard>.meta.json] 打包参数：data_ver、act_scale、增广参数、sig（run_prep.sh 据 sig 判断要不要重新打包）。
|
||||
* 2026-10-19（审查 review_data_actions C2）：
|
||||
* - 标签按 ACT_SCALE·STEP 归一化（默认 1.25，DATA_VER 2）。原来按 STEP 归一化，巡航时主导轴标签恰好 = ±1、执行端又夹在 ±1，
|
||||
* 模型在 ±1 附近的对称误差有一半被截掉，主导轴系统性偏慢；留 25% 余量后老师标签最大 0.8，执行端的 ±1 只防越界。
|
||||
* 运行时 inc = clamp(act, ±1)·act_scale·STEP（closed_loop.py / apg / ik-policy.js 同口径，act_scale 经 checkpoint 与 ONNX meta 传递）；
|
||||
* - 增广收回标签的亏空结转：被 ±1 截掉的部分记在 prevP 里、下一步补，原来 prevP = 目标点，截掉就丢了（教的是「落后了别追」）；
|
||||
* - DAgger 任务带 qPrev / v0（gen_dataset.cjs 写入）：t=0 样本用真实上一帧，时间律从当前速度起步。
|
||||
* 特征（83 维）定义不变，FEAT_VER 不变；数据版本由 meta.data_ver 区分，旧打包没有 meta → 训练按 act_scale 1.0 读。 */
|
||||
'use strict';
|
||||
const fs = require('fs'), path = require('path');
|
||||
/* 打包参数（环境变量）与签名：run_prep.sh 用 `node build_dataset.cjs --sig` 取当前签名，与已打包 shard 的 meta.sig 不同就重新打包 */
|
||||
const DATA_VER = 2;
|
||||
const MIN_GAP_MM = +(process.env.MIN_GAP_MM || 3);
|
||||
const AUG_P = +(process.env.AUG_P || 0.4), AUG_SIGMA = +(process.env.AUG_SIGMA || 3), AUG_BACK = +(process.env.AUG_BACK || 12);
|
||||
const ACT_SCALE = +(process.env.ACT_SCALE || 1.25);
|
||||
const SIG = ['v' + DATA_VER, 's' + ACT_SCALE, 'p' + AUG_P, 'sg' + AUG_SIGMA, 'b' + AUG_BACK, 'g' + MIN_GAP_MM].join('|');
|
||||
if (process.argv[2] === '--sig') { console.log(SIG); process.exit(0); }
|
||||
const IN = process.argv[2], OUTDIR = process.argv[3] || path.join(__dirname, '../data/samples');
|
||||
if (!IN) { console.error('usage: build_dataset.cjs <shard.jsonl> [outDir]'); process.exit(1); }
|
||||
if (!IN) { console.error('usage: build_dataset.cjs <shard.jsonl> [outDir] | --sig'); process.exit(1); }
|
||||
const { S } = require('../../tests/route_bench_setup.cjs')();
|
||||
const POL = require('../../webapp/js/ik-policy.js');
|
||||
const { timeParam } = require('../gen/timelaw.cjs');
|
||||
@@ -28,9 +43,8 @@ const hash = s => { let h = 2166136261; for (const c of s) h = Math.imul(h ^ c.c
|
||||
const X = [], Y = [], V = [], SG = [], TID = [], tasks = [];
|
||||
const lines = fs.readFileSync(IN, 'utf8').split('\n').filter(Boolean);
|
||||
let nAug = 0, nAugRej = 0, nGapDrop = 0;
|
||||
/* 2026-10-18：认证最小间隙 < 3 mm 的老师轨迹不进训练集；噪声增广接受地板同步为 3 mm（原 1 mm）。 */
|
||||
const MIN_GAP_MM = +(process.env.MIN_GAP_MM || 3);
|
||||
const AUG_P = +(process.env.AUG_P || 0.4), AUG_SIGMA = +(process.env.AUG_SIGMA || 3), AUG_BACK = +(process.env.AUG_BACK || 12);
|
||||
/* 2026-10-18：认证最小间隙 < 3 mm 的老师轨迹不进训练集（MIN_GAP_MM）；噪声增广接受地板同步为 3 mm（原 1 mm）。 */
|
||||
const ASTEP = STEP.map(v => v * ACT_SCALE); // 每单位动作对应的度数
|
||||
const NT = lines.length, PSTEP = Math.max(1, Math.floor(NT / 10));
|
||||
for (let li = 0; li < NT; li++) {
|
||||
if (li % PSTEP === 0) console.log(`[prep] ${base} ${li}/${NT}`); // 每 10% 一行，28 个分片并行也看得见进度
|
||||
@@ -41,13 +55,13 @@ for (let li = 0; li < NT; li++) {
|
||||
const tid = hash(r.id) & 0x7fffffff;
|
||||
const split = (hash(r.id + '#split') % 100) < 5 ? 'val' : 'train';
|
||||
const P = r.path;
|
||||
const tp = timeParam(P);
|
||||
const tp = timeParam(P, { v0: r.v0 || 0 }); // DAgger 起点带速度：时间律从 v0 起步（gen_dataset.cjs 写 v0）
|
||||
const traj = tp.traj, taus = tp.taus, N = traj.length - 1;
|
||||
tasks.push({ tid, id: r.id, cat: r.cat, mode: r.mode, q0: r.q0, T: r.T, R: r.R, exec_s: N * POL.DT, travel: r.travel_deg, reached: r.reached, err: r.err, split });
|
||||
tasks.push({ tid, id: r.id, cat: r.cat, mode: r.mode, q0: r.q0, qp0: r.qPrev || null, T: r.T, R: r.R, exec_s: N * POL.DT, travel: r.travel_deg, reached: r.reached, err: r.err, split });
|
||||
const vt = tp.cum; // 顶点 τ
|
||||
const inter = P.slice(1, -1).map((p, i) => ({ p, tau: vt[i + 1] }));
|
||||
for (let t = 0; t <= N; t += 3) {
|
||||
let q = traj[t].slice(), qPrev = (t > 0 ? traj[t - 1] : traj[0]).slice();
|
||||
let q = traj[t].slice(), qPrev = (t > 0 ? traj[t - 1] : (r.qPrev || traj[0])).slice();
|
||||
let off = [0, 0, 0, 0, 0, 0], aug = false;
|
||||
if (rnd() < AUG_P) {
|
||||
const qn = q.map((v, j) => { let x = v + AUG_SIGMA * gauss(); const t2 = L[O[j]]; if (!t2.cont) x = Math.max(t2.lo, Math.min(t2.hi, x)); return x; });
|
||||
@@ -60,10 +74,14 @@ for (let li = 0; li < NT; li++) {
|
||||
}
|
||||
const pos = k => { const i = Math.min(N, t + k); const w = aug ? Math.max(0, 1 - k / AUG_BACK) : 0; return traj[i].map((v, j) => v + off[j] * w); };
|
||||
const y = new Float32Array(H * 6);
|
||||
let prevP = q;
|
||||
for (let k = 1; k <= H; k++) { const pk = pos(k); for (let j = 0; j < 6; j++) y[(k - 1) * 6 + j] = Math.max(-1, Math.min(1, (pk[j] - prevP[j]) / STEP[j])); prevP = pk; }
|
||||
/* prevP = 按标签实际会走到的位置：被 ±1 截掉的亏空留在 prevP 与目标之差里，下一步接着补（2026-10-19，C2） */
|
||||
let prevP = q.slice();
|
||||
for (let k = 1; k <= H; k++) {
|
||||
const pk = pos(k);
|
||||
for (let j = 0; j < 6; j++) { const v = Math.max(-1, Math.min(1, (pk[j] - prevP[j]) / ASTEP[j])); y[(k - 1) * 6 + j] = v; prevP[j] += v * ASTEP[j]; }
|
||||
}
|
||||
const rr = Math.floor(rnd() * 4), prefix = [];
|
||||
for (let k = 0; k < rr; k++) { const row = []; for (let j = 0; j < 6; j++) row.push(y[k * 6 + j] * STEP[j]); prefix.push(row); }
|
||||
for (let k = 0; k < rr; k++) { const row = []; for (let j = 0; j < 6; j++) row.push(y[k * 6 + j] * ASTEP[j]); prefix.push(row); }
|
||||
const remain = inter.filter(v => v.tau > taus[t] + 0.02);
|
||||
const sub = remain.length && rnd() < 0.8 ? remain[0].p : null;
|
||||
const gm = S.gapMatrix(q, POL.GAP_CAP);
|
||||
@@ -83,7 +101,10 @@ writeNpy(path.join(OUTDIR, base + '.Y.npy'), cat(Y, H * 6), [n, H, 6]);
|
||||
writeNpy(path.join(OUTDIR, base + '.V.npy'), Float32Array.from(V), [n]);
|
||||
writeNpy(path.join(OUTDIR, base + '.SG.npy'), cat(SG, 13), [n, 13]);
|
||||
writeNpy(path.join(OUTDIR, base + '.TID.npy'), TID, [n], 'int32');
|
||||
/* meta 在 tasks.jsonl 之前写：tasks.jsonl 仍是「本 shard 打包完成」的标记 */
|
||||
fs.writeFileSync(path.join(OUTDIR, base + '.meta.json'), JSON.stringify({ data_ver: DATA_VER, act_scale: ACT_SCALE, aug_p: AUG_P, aug_sigma: AUG_SIGMA,
|
||||
aug_back: AUG_BACK, min_gap_mm: MIN_GAP_MM, aug_carry: true, sig: SIG }));
|
||||
// 2026-10-18 断点续跑：tasks.jsonl 最后写、先写 .tmp 再改名 —— 它存在就代表这个 shard 的 5 个 npy 都已写完，run_prep.sh 据此跳过
|
||||
const tf = path.join(OUTDIR, base + '.tasks.jsonl');
|
||||
fs.writeFileSync(tf + '.tmp', tasks.map(t => JSON.stringify(t)).join('\n') + '\n'); fs.renameSync(tf + '.tmp', tf);
|
||||
console.log(JSON.stringify({ shard: base, tasks: tasks.length, samples: n, aug: nAug, augRejected: nAugRej, gapDrop: nGapDrop, featVer: POL.FEAT_VER }));
|
||||
console.log(JSON.stringify({ shard: base, tasks: tasks.length, samples: n, aug: nAug, augRejected: nAugRej, gapDrop: nGapDrop, featVer: POL.FEAT_VER, dataVer: DATA_VER, actScale: ACT_SCALE }));
|
||||
|
||||
+6
-1
@@ -2,6 +2,8 @@
|
||||
# 并行打包样本：bash ml/prep/run_prep.sh [进程数=CPU 核数]
|
||||
# 2026-10-18 断点续跑：samples/<shard>.tasks.jsonl 存在且比 shard 新 → 该 shard 已打包完，跳过；
|
||||
# shard 已不存在的旧打包结果删掉（不让上一批数据混进来）。中断后重跑只补没打完的 shard。
|
||||
# 2026-10-19（审查 review_closedloop F11）：打包参数（数据版本、ACT_SCALE、AUG_P/AUG_SIGMA/AUG_BACK、MIN_GAP_MM）变了也要重打：
|
||||
# build_dataset.cjs --sig 给出当前签名，已打包 shard 的 <shard>.meta.json 里 sig 不同（或没有 meta 的旧打包）→ 重新打包。
|
||||
set -e
|
||||
cd "$(dirname "$0")/../.."
|
||||
P=${1:-$(nproc)}
|
||||
@@ -11,10 +13,13 @@ for t in $D/*.tasks.jsonl; do
|
||||
[ -e "$t" ] || continue; b=$(basename "$t" .tasks.jsonl)
|
||||
[ -f ml/data/$b.jsonl ] || { echo "[prep] 删除旧打包 $b（对应 shard 已不存在）"; rm -f $D/$b.*; }
|
||||
done
|
||||
SIG=$(node ml/prep/build_dataset.cjs --sig)
|
||||
echo "[prep] 打包签名 $SIG"
|
||||
todo=()
|
||||
for f in ml/data/shard_*.jsonl; do
|
||||
b=$(basename "$f" .jsonl)
|
||||
if [ -f $D/$b.tasks.jsonl ] && [ $D/$b.tasks.jsonl -nt "$f" ]; then continue; fi
|
||||
if [ -f $D/$b.tasks.jsonl ] && [ $D/$b.tasks.jsonl -nt "$f" ] && grep -qF "\"sig\":\"$SIG\"" $D/$b.meta.json 2>/dev/null; then continue; fi
|
||||
rm -f $D/$b.tasks.jsonl # 先撤完成标记：重打中途断了不会被当成已完成
|
||||
todo+=("$f")
|
||||
done
|
||||
echo "[prep] 共 $(ls ml/data/shard_*.jsonl | wc -l) 个 shard，待打包 ${#todo[@]} 个"
|
||||
|
||||
@@ -40,6 +40,8 @@ AFFECTS = {**{k: _from('gen') for k in ('N_TASKS', 'NPROC', 'CONSENSUS', 'MIN_GA
|
||||
# TARGET_SAMPLES 只决定"补量到多少"：不作废 gen 的已有分片（重跑 gen 会跳过写完的 shard、按差额补量），
|
||||
# 但样本集会变，所以 prep 及之后作废。2026-10-18 实测：把它当"从 gen 作废"会让 5 小时的 5 万条分片白跑。
|
||||
'TARGET_SAMPLES': ['gen'] + _from('prep'),
|
||||
# 2026-10-19：打包参数（标签尺度、增广）变了 → prep 起作废；run_prep.sh 另按 meta.sig 只重打参数不符的 shard
|
||||
**{k: _from('prep') for k in ('ACT_SCALE', 'AUG_P', 'AUG_SIGMA', 'AUG_BACK')},
|
||||
'CFG': ['r4'] + _from('train'), **{k: _from('dagger') for k in ('DAG_ROUNDS', 'DAG_N', 'DAG_STEPS')},
|
||||
**{k: _from('mine') for k in ('ROUNDS', 'APG_STEPS', 'MINE_N')}}
|
||||
PARAM_KEYS = list(AFFECTS)
|
||||
|
||||
+153
-47
@@ -1,19 +1,23 @@
|
||||
"""闭环仿真（验证 / 挖错 / 门禁共用，PyTorch 批量，无梯度）——按部署节奏运行：
|
||||
50 Hz 执行；队列 ≤ 3 步时推理一次（已提交前缀 r = 队列长度），提交接下来 3 步；
|
||||
冷启动用价值头对候选末态打分（短前瞻），之后按与上一计划的一致性选候选；
|
||||
接近目标 < 5 mm 时用局部 DLS 精修；子目标头在新目标时给出途经点（到达 < 5° 或 1.5 s 超时后切下一个）。
|
||||
冷启动用价值头对候选末态打分（短前瞻），之后按与上一条**真正提交**的计划的一致性选候选；
|
||||
接近目标 < 5 mm 时用局部 DLS 精修；子目标头在新目标时给出途经点，按「越过顶点」规则切下一个（与标签同口径，见 sub_advance）。
|
||||
safety=False 时不做任何碰撞拦截（暴露真实错误，挖错用）；safety=True 时近似部署安全层（候选提交步有干涉则换下一条，全不过则停一步）。
|
||||
动作反归一化：inc = clamp(act, −1, 1) · act_scale · STEP；act_scale 来自 checkpoint（旧模型缺省 1.0，见 ml/common/ckpt.load_policy）。
|
||||
碰撞与到达只在每题自己的时限内计（短题与长题同批时不把超时后的部分算进去）。
|
||||
python -m ml.sim.closed_loop --ckpt ml/runs/base/best.pt --samples ml/data/samples --split val --n 1000 [--safety]"""
|
||||
import argparse, json, math, os
|
||||
import torch
|
||||
|
||||
from ml.common.kin_torch import Kin
|
||||
from ml.common.features import features, STEP, H, GAP_CAP, D2R, wrap180
|
||||
from ml.common.features import features, STEP, VMAX, H, GAP_CAP, D2R, wrap180
|
||||
|
||||
DT = 0.02
|
||||
|
||||
|
||||
FIRST_DEG = 5.0 # R7 首次方向判定阈值（度）：小于它的抖动不算选边
|
||||
SUB_LEAD_S = 0.02 # 子目标「越过顶点」提前量（s）：标签在老师 τ > τ_顶点 − 0.02 时就换到下一个顶点（build_dataset.cjs remain 过滤）
|
||||
SUB_REACH_DEG, SUB_TIMEOUT_S = 5.0, 1.5 # 旧规则（sub_rule='timeout'）：到达 < 5° 或 1.5 s 超时
|
||||
|
||||
def tasks_to_tensors(tasks, device):
|
||||
q0 = torch.tensor([t['q0'] for t in tasks], dtype=torch.float32, device=device)
|
||||
@@ -28,6 +32,12 @@ def tasks_to_tensors(tasks, device):
|
||||
NOREF_SEC = 6.0 # 无老师参考题的定长时限（s）
|
||||
|
||||
|
||||
def time_limit(ex, max_sec=None):
|
||||
"""每题时限（s）：有老师 = 老师时长 × 2（至少 3 s）；无老师 = NOREF_SEC；max_sec 覆盖全部。"""
|
||||
if max_sec is not None: return torch.full_like(ex, max_sec)
|
||||
return torch.where(torch.isfinite(ex), torch.clamp(2 * ex, min=3.0), torch.full_like(ex, NOREF_SEC))
|
||||
|
||||
|
||||
def goal_err(kin, q, T, R):
|
||||
xf = kin.cum_xf(q)
|
||||
p = kin.fk(q, xf); Rq = kin.orient(q, xf).reshape(-1, 9)
|
||||
@@ -64,58 +74,139 @@ def dls_steps(kin, q, T, R, n=3, scale=0.3, lam=0.5):
|
||||
return torch.stack(out, 1)
|
||||
|
||||
|
||||
def jdiff(kin, a, b):
|
||||
"""a − b（度），连续轴取最短弧。"""
|
||||
d = a - b
|
||||
return torch.where(kin.cont, wrap180(d), d)
|
||||
|
||||
|
||||
def sub_advance(kin, subs, nsub, sub_prev, sub_t, qe, tnow, rule='cross'):
|
||||
"""子目标推进（每次规划前调用，每次最多推进一个）。subs [B,M,6] 待走途经点（绝对角），nsub [B] 剩余个数，
|
||||
sub_prev [B,6] 上一个已越过的点（冷启动时 = 起点），sub_t [B] 当前子目标开始时刻。返回 (subs, nsub, sub_prev, sub_t)。
|
||||
rule='cross'（默认）：qe 沿拐角平分面法向越过当前顶点（提前 SUB_LEAD_S 秒）即切到下一个。
|
||||
2026-10-19（审查 review_data_actions C5 / review_model_train P0-1）：标签里 sub = 老师「下一个尚未经过的顶点」，
|
||||
老师 τ 一过顶点（−0.02 s）立刻换；旧规则要等最大关节差 < 5° 或 1.5 s 超时，策略在顶点附近 5–10° 进不去时
|
||||
sub 一直指着身后的点，这种「sub 已在身后」的特征序列训练里从未出现。运行时没有老师 τ，用几何等价物：
|
||||
进入方向 a = 顶点 − 上一点、离开方向 b = 下一顶点 − 顶点（最后一个顶点取 a），各轴按 VMAX 折成秒（与 τ 同量纲），
|
||||
法向 n = â + b̂；(qe − 顶点)·n̂ ≥ −SUB_LEAD_S 判为越过。没有超时（标签也没有）。
|
||||
rule='timeout'：旧部署口径，到达 < 5° 或 1.5 s 超时（诊断对照用）。
|
||||
ik-policy.js Runner（subRule）与 apg_finetune.py 用同一规则，三处同步改。"""
|
||||
has = nsub > 0
|
||||
if not bool(has.any()): return subs, nsub, sub_prev, sub_t
|
||||
cur = subs[:, 0]
|
||||
if rule == 'timeout':
|
||||
dd = jdiff(kin, cur, qe).abs().max(-1).values
|
||||
adv = has & ((dd < SUB_REACH_DEG) | (tnow - sub_t > SUB_TIMEOUT_S))
|
||||
elif rule == 'cross':
|
||||
vmax = torch.tensor(VMAX, device=qe.device, dtype=qe.dtype)
|
||||
un = lambda v: v / v.norm(dim=-1, keepdim=True).clamp(min=1e-9)
|
||||
a = jdiff(kin, cur, sub_prev) / vmax
|
||||
nxt = subs[:, 1] if subs.shape[1] > 1 else cur
|
||||
b = torch.where((nsub > 1)[:, None], jdiff(kin, nxt, cur) / vmax, a)
|
||||
n = un(un(a) + un(b))
|
||||
proj = (jdiff(kin, qe, cur) / vmax * n).sum(-1)
|
||||
adv = has & (proj >= -SUB_LEAD_S)
|
||||
else:
|
||||
raise ValueError('sub_rule: ' + str(rule))
|
||||
subs = torch.where(adv[:, None, None], torch.cat([subs[:, 1:], subs[:, -1:]], 1), subs)
|
||||
sub_prev = torch.where(adv[:, None], cur, sub_prev)
|
||||
nsub = torch.where(adv, nsub - 1, nsub); sub_t = torch.where(adv, torch.full_like(sub_t, tnow), sub_t)
|
||||
return subs, nsub, sub_prev, sub_t
|
||||
|
||||
|
||||
class TeacherOracle:
|
||||
"""老师当策略（2026-10-19，审查 review_closedloop D1 / review_data_actions §4.1）：
|
||||
规划时从当前时间下标 it 取老师 50 Hz 轨迹的 16 步增量，按与 build_dataset.cjs 相同的标签口径
|
||||
act = clamp(Δ / (act_scale·STEP), −1, 1) 交给 rollout()，其余（队列、前缀、提交、qe、DLS、done、碰撞、时限）一行不改。
|
||||
traj [B,Tmax,6]：每题老师轨迹，末帧重复补齐（按 id 从 ml/data/shard_*.jsonl 取）。
|
||||
sigma > 0：每次规划给 act 加 N(0, σ²)（σ 以 STEP 为单位，各候选独立），测闭环对残差噪声的敏感度。
|
||||
跟随时第 it 步的 q 应等于 traj[:, it]（DLS 接管或到达冻结之后除外）。"""
|
||||
head = 'oracle'
|
||||
|
||||
def __init__(self, traj, act_scale=1.0, sigma=0.0):
|
||||
self.traj, self.act_scale, self.sigma = traj, float(act_scale), float(sigma)
|
||||
|
||||
def plan(self, it, K, g):
|
||||
B, Tm, _ = self.traj.shape
|
||||
dev = self.traj.device
|
||||
idx = (it + torch.arange(H + 1, device=dev)).clamp(max=Tm - 1)
|
||||
seg = self.traj[:, idx]
|
||||
astep = torch.tensor(STEP, device=dev) * self.act_scale
|
||||
act = ((seg[:, 1:] - seg[:, :-1]) / astep).clamp(-1, 1)
|
||||
act = act[:, None].expand(B, K, H, 6).contiguous()
|
||||
if self.sigma > 0:
|
||||
act = act + torch.randn(B, K, H, 6, device=dev, generator=g) * (self.sigma / self.act_scale)
|
||||
return act
|
||||
|
||||
|
||||
@torch.no_grad()
|
||||
def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None, return_traj=False, use_sub=True, sub_override=None, qp0=None, steps=1, z_scale=1.0, select='consist'):
|
||||
"""use_sub=False：不用子目标（sf=0）；sub_override=(subs [B,2,6] 绝对关节角, need [B] bool)：冷启动时用给定途经点代替子目标头；qp0 [B,6]：起点的上一帧（默认 = q0，即静止起步）。steps：MeanFlow 采样段数；z_scale：噪声缩放（0 = 只取「均值」样本）；select：consist（部署口径：冷启动价值前瞻、之后一致性）/ value（每次都价值前瞻）/ first（不选，取第 0 条）。均为诊断用"""
|
||||
def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None, return_traj=False, use_sub=True, sub_override=None,
|
||||
qp0=None, steps=1, z_scale=1.0, select='consist', oracle=None, replan='r3', sub_rule='cross'):
|
||||
"""use_sub=False：不用子目标（sf=0）；sub_override=(subs [B,M,6] 绝对关节角, n [B] 个数 或 need [B] bool)：冷启动时用给定途经点代替子目标头；
|
||||
qp0 [B,6]：起点的上一帧（默认 = q0，即静止起步）。steps：MeanFlow 采样段数；z_scale：噪声缩放；
|
||||
select：consist（部署口径：冷启动价值前瞻、之后与上一条已提交计划的一致性）/ value（每次都价值前瞻）/ first（不选，取第 0 条）。
|
||||
oracle：TeacherOracle，代替 model 出动作（model 可为 None，须配 select='first'、use_sub=False）。
|
||||
replan：'r3'（部署：队列 ≤ 3 步就规划，稳态 r=3）/ 'empty'（队列空了才规划，每次 r=0，前缀消融用）。
|
||||
sub_rule：子目标推进规则，见 sub_advance。除默认值外均为诊断用。"""
|
||||
g = torch.Generator(device=device); g.manual_seed(seed)
|
||||
q0, T, R, ex, tr = tasks_to_tensors(tasks, device)
|
||||
B = q0.shape[0]
|
||||
step = torch.tensor(STEP, device=device)
|
||||
act_scale = oracle.act_scale if oracle is not None else float(getattr(model, 'act_scale', 1.0))
|
||||
astep = step * act_scale # 动作反归一化：每单位 act 对应的度数
|
||||
has_ref = torch.isfinite(ex)
|
||||
limit = torch.where(has_ref, torch.clamp(2 * ex, min=3.0), torch.full_like(ex, NOREF_SEC)) if max_sec is None else torch.full_like(ex, max_sec)
|
||||
limit = time_limit(ex, max_sec)
|
||||
nmax = int(math.ceil(limit.max().item() / DT))
|
||||
q, qp = q0.clone(), (qp0.to(device) if qp0 is not None else q0.clone())
|
||||
queue = torch.zeros(B, 0, 6, device=device)
|
||||
last = None
|
||||
subs = torch.zeros(B, 2, 6, device=device); nsub = torch.zeros(B, dtype=torch.long, device=device); sub_t = torch.zeros(B, device=device)
|
||||
last = None; last_ok = torch.zeros(B, dtype=torch.bool, device=device)
|
||||
subs = torch.zeros(B, 2, 6, device=device); nsub = torch.zeros(B, dtype=torch.long, device=device)
|
||||
sub_t = torch.zeros(B, device=device); sub_prev = q0.clone()
|
||||
done = torch.zeros(B, dtype=torch.bool, device=device); t_done = torch.full((B,), float('nan'), device=device)
|
||||
col = torch.zeros(B, device=device); travel = torch.zeros(B, device=device); brakes = torch.zeros(B, device=device)
|
||||
first_hit = torch.full((B,), float('nan'), device=device); dls_it = torch.full((B,), -1, dtype=torch.long, device=device)
|
||||
traj = [q.clone()] if return_traj else None
|
||||
n_start = int(round(0.5 / DT)); moved_start = None # R2 起步失败：0.5 s 内关节总行程 < 1°
|
||||
k2s = int(round(2.0 / DT)); e2 = None
|
||||
e0, _ = goal_err(kin, q0, T, R)
|
||||
j1_acc = torch.zeros(B, device=device); j1_max = torch.zeros(B, device=device); j1_min = torch.zeros(B, device=device)
|
||||
j1_first = torch.zeros(B, device=device) # 2026-10-18 第五轮（审查 N-3）：J1 累计偏离首次超过 FIRST_DEG 时的方向（真正的"首次方向"）
|
||||
cold = True
|
||||
ar = torch.arange(B, device=device)
|
||||
for it in range(nmax):
|
||||
tnow = it * DT
|
||||
if queue.shape[1] <= 3:
|
||||
if (queue.shape[1] <= 3) if replan == 'r3' else (queue.shape[1] == 0):
|
||||
r = queue.shape[1]
|
||||
pre = torch.zeros(B, 3, 6, device=device); pre[:, :r] = queue[:, :r]
|
||||
qe = q + queue.sum(1)
|
||||
e, oe = goal_err(kin, qe, T, R)
|
||||
near = (e < 5) & ((R.abs().sum(-1) == 0) | (oe < 5))
|
||||
# 子目标推进
|
||||
if (nsub > 0).any():
|
||||
cur = subs[:, 0]
|
||||
dd = torch.where(kin.cont, wrap180(cur - qe), cur - qe).abs().max(-1).values
|
||||
adv = (nsub > 0) & ((dd < 5) | (tnow - sub_t > 1.5))
|
||||
subs = torch.where(adv[:, None, None], torch.cat([subs[:, 1:], subs[:, 1:]], 1), subs)
|
||||
nsub = torch.where(adv, nsub - 1, nsub); sub_t = torch.where(adv, torch.full_like(sub_t, tnow), sub_t)
|
||||
subs, nsub, sub_prev, sub_t = sub_advance(kin, subs, nsub, sub_prev, sub_t, qe, tnow, sub_rule)
|
||||
sf = (nsub > 0).float()
|
||||
feat = features(kin, q, qp, T, R, pre, torch.full((B,), r, device=device), subs[:, 0], sf)
|
||||
z = torch.randn(B * K, H, 6, device=device, generator=g) * z_scale
|
||||
act, val, sub = model.sample_k(feat, K, z, steps=steps)
|
||||
inc = act.clamp(-1, 1) * step
|
||||
if oracle is not None:
|
||||
act = oracle.plan(it, K, g); sub = torch.zeros(B, 13, device=device)
|
||||
else:
|
||||
z = torch.randn(B * K, H, 6, device=device, generator=g) * z_scale
|
||||
act, val, sub = model.sample_k(feat, K, z, steps=steps)
|
||||
inc = act.float().clamp(-1, 1) * astep
|
||||
if cold:
|
||||
sub0 = sub
|
||||
need = sub0[:, 12] > 0.5
|
||||
subs = q[:, None] + sub0[:, :12].view(B, 2, 6) * 180
|
||||
if sub_override is not None: subs, need = sub_override[0].to(device), sub_override[1].to(device)
|
||||
if not use_sub: need = torch.zeros_like(need)
|
||||
nsub = torch.where(need, torch.full_like(nsub, 2), torch.zeros_like(nsub)); sub_t.fill_(tnow)
|
||||
need = sub[:, 12] > 0.5
|
||||
subs = q[:, None] + sub[:, :12].float().view(B, 2, 6) * 180
|
||||
if sub_override is not None:
|
||||
subs = sub_override[0].to(device).float()
|
||||
n_ov = sub_override[1].to(device)
|
||||
nsub_ov = n_ov.long() if n_ov.dtype != torch.bool else n_ov.long() * subs.shape[1]
|
||||
need = nsub_ov > 0
|
||||
nsub = nsub_ov
|
||||
else:
|
||||
nsub = torch.where(need, torch.full_like(nsub, 2), torch.zeros_like(nsub))
|
||||
if not use_sub: nsub = torch.zeros_like(nsub)
|
||||
sub_t.fill_(tnow); sub_prev = q.clone()
|
||||
fut = qe[:, None, None] + torch.cumsum(inc[:, :, r:], 2) # [B,K,H-r,6]
|
||||
if select == 'first':
|
||||
score = torch.zeros(B, K, device=device); score[:, 0] = 1
|
||||
elif last is None or select == 'value':
|
||||
elif cold or select == 'value':
|
||||
# 短前瞻：候选末态的价值
|
||||
qa = fut[:, :, -1].reshape(B * K, 6); qb = fut[:, :, -2].reshape(B * K, 6)
|
||||
f2 = features(kin, qa, qb, T.repeat_interleave(K, 0), R.repeat_interleave(K, 0), torch.zeros(B * K, 3, 6, device=device),
|
||||
@@ -124,32 +215,38 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
|
||||
score = -v2.view(B, K)
|
||||
else:
|
||||
# 2026-10-19 修错位：last[i] = 上一计划从 qe_old 走 i 步后的位置；提交 3 步后 qe_new = last[3]，
|
||||
# 新候选 fut[0] 是 qe_new 再走 1 步 = 对应 last[4]。原来对齐 last[3]，等于奖励「比上一计划慢一步」的候选，
|
||||
# 每次重规划都挑最拖的那条，闭环越走越慢。JS 部署（ik-policy.js）同一处同样修正。
|
||||
# 新候选 fut[0] 是 qe_new 再走 1 步 = 对应 last[4]。JS 部署（ik-policy.js）同一处同样修正。
|
||||
n = min(fut.shape[2], last.shape[1] - 4)
|
||||
w = 0.85 ** torch.arange(n, device=device, dtype=torch.float32)
|
||||
d2 = (((fut[:, :, :n] - last[:, None, 4:4 + n]) / step) ** 2).sum(-1)
|
||||
score = -(d2 * w).sum(-1)
|
||||
order = score.argsort(-1, descending=True)
|
||||
# 2026-10-19（审查 review_closedloop F5）：上一次是刹停或 DLS 接管的行没有「已提交计划」，
|
||||
# 与 JS（lastPlan = null → 一致性项缺席、各候选同分 → 取第 0 条）一致：同分，稳定排序取第 0 条
|
||||
score = torch.where(last_ok[:, None], -(d2 * w).sum(-1), torch.zeros_like(d2[..., 0]))
|
||||
order = torch.sort(score, dim=-1, descending=True, stable=True).indices
|
||||
pick = order[:, 0]
|
||||
commit = inc[torch.arange(B), pick, r:r + 3]
|
||||
commit = inc[ar, pick, r:r + 3]
|
||||
committed = torch.ones(B, dtype=torch.bool, device=device)
|
||||
if safety:
|
||||
ok_any = torch.zeros(B, dtype=torch.bool, device=device)
|
||||
chosen = torch.zeros(B, 3, 6, device=device)
|
||||
chosen = torch.zeros(B, 3, 6, device=device); chosen_k = pick.clone()
|
||||
for kk in range(K):
|
||||
ck = inc[torch.arange(B), order[:, kk], r:r + 3]
|
||||
ck = inc[ar, order[:, kk], r:r + 3]
|
||||
pts = qe[:, None] + torch.cumsum(ck, 1)
|
||||
mids = torch.cat([qe[:, None], pts[:, :-1]], 1) + 0.5 * ck
|
||||
allq = torch.cat([pts, mids], 1).reshape(-1, 6)
|
||||
okk = (kin.gaps(allq, 0.5)['gm'].min(-1).values > 0).view(B, 6).all(-1)
|
||||
take = okk & ~ok_any
|
||||
chosen = torch.where(take[:, None, None], ck, chosen); ok_any |= okk
|
||||
chosen = torch.where(take[:, None, None], ck, chosen); chosen_k = torch.where(take, order[:, kk], chosen_k); ok_any |= okk
|
||||
commit = torch.where(ok_any[:, None, None], chosen, torch.zeros_like(chosen))
|
||||
brakes += (~ok_any).float()
|
||||
pick = chosen_k; committed = ok_any
|
||||
if near.any():
|
||||
ref = dls_steps(kin, qe, T, R)
|
||||
commit = torch.where(near[:, None, None], ref, commit)
|
||||
last = torch.cat([qe[:, None], fut[torch.arange(B), pick]], 1)
|
||||
dls_it = torch.where(near & (dls_it < 0), torch.full_like(dls_it, it), dls_it)
|
||||
committed = committed & ~near
|
||||
# 2026-10-19（F5）：last 记真正提交的那条候选（安全层换了候选时是换后的那条）；刹停 / DLS 接管的行无效
|
||||
last = torch.cat([qe[:, None], fut[ar, pick]], 1); last_ok = committed
|
||||
queue = torch.cat([queue, commit], 1)
|
||||
cold = False
|
||||
d = queue[:, 0]; queue = queue[:, 1:]
|
||||
@@ -162,15 +259,21 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
|
||||
if return_traj: traj.append(q.clone())
|
||||
mid = qp + 0.5 * (q - qp)
|
||||
gm = kin.gaps(torch.cat([q, mid], 0), 0.5)['gm'].min(-1).values
|
||||
hit = ((gm[:B] <= 0) | (gm[B:] <= 0)) & ~done
|
||||
tn = (it + 1) * DT
|
||||
# 2026-10-19（审查 review_closedloop F4）：只计每题自己时限内的碰撞（同批长题会把短题多仿真几秒）
|
||||
hit = ((gm[:B] <= 0) | (gm[B:] <= 0)) & ~done & (tn <= limit + 1e-6)
|
||||
col += hit.float()
|
||||
first_hit = torch.where(hit & torch.isnan(first_hit), torch.full_like(first_hit, tn), first_hit)
|
||||
e, oe = goal_err(kin, q, T, R)
|
||||
if it + 1 == k2s: e2 = e.clone()
|
||||
newly = (~done) & (e < 1) & (oe < 0.5)
|
||||
t_done = torch.where(newly, torch.full_like(t_done, (it + 1) * DT), t_done); done |= newly
|
||||
t_done = torch.where(newly, torch.full_like(t_done, tn), t_done); done |= newly
|
||||
if done.all(): break
|
||||
ok = done & (t_done <= limit)
|
||||
ok = done & (t_done <= limit + 1e-6)
|
||||
if moved_start is None: moved_start = travel.clone()
|
||||
e_end, _ = goal_err(kin, q, T, R)
|
||||
if e2 is None: e2 = e_end
|
||||
ratio2 = e2 / e0.clamp(min=1e-3)
|
||||
start_fail = (moved_start < 1.0) & ~(done & (t_done <= 0.5))
|
||||
okr = ok & has_ref & torch.isfinite(tr)
|
||||
res = {'n': B, 'n_ref': int(has_ref.sum()), 'success': ok.float().mean().item(),
|
||||
@@ -178,20 +281,22 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
|
||||
'collision_rate': (col > 0).float().mean().item(), 'collision_steps_mean': col.mean().item(),
|
||||
'travel_ratio_median': (travel[okr] / tr[okr].clamp(min=1)).median().item() if okr.any() else None,
|
||||
'time_mean_s': t_done[ok].mean().item() if ok.any() else None, 'brakes_mean': brakes.mean().item(),
|
||||
'start_fail': start_fail.float().mean().item(),
|
||||
'start_fail': start_fail.float().mean().item(), 'goal_ratio_2s': ratio2.median().item(),
|
||||
'time_budget': 'teacher×2(≥3 s)' if bool(has_ref.all()) else ('fixed %.0f s' % (max_sec or NOREF_SEC) if not has_ref.any() else 'mixed')}
|
||||
# 绕行侧：J1 累计位移的正向/负向极值哪个更大（+1 / −1），供 R7 左右比例门禁
|
||||
# 首次方向；全程没偏离到 FIRST_DEG 的（基本不绕 J1）退回净方向
|
||||
side = torch.where(j1_first != 0, j1_first, torch.where(j1_max >= -j1_min, torch.ones_like(j1_max), -torch.ones_like(j1_max)))
|
||||
per = {'done': done.cpu(), 't_done': t_done.cpu(), 'col': col.cpu(), 'travel': travel.cpu(), 'err': e_end.cpu(),
|
||||
'side': side.cpu(), 'start_fail': start_fail.cpu(), 'brakes': brakes.cpu()}
|
||||
per = {'done': done.cpu(), 'ok': ok.cpu(), 't_done': t_done.cpu(), 'limit': limit.cpu(), 'col': col.cpu(), 'travel': travel.cpu(), 'err': e_end.cpu(),
|
||||
'side': side.cpu(), 'start_fail': start_fail.cpu(), 'brakes': brakes.cpu(), 'first_hit': first_hit.cpu(), 'dls_it': dls_it.cpu(),
|
||||
'goal_ratio_2s': ratio2.cpu()}
|
||||
if return_traj: per['traj'] = torch.stack(traj, 1).cpu()
|
||||
return res, per
|
||||
|
||||
|
||||
def evaluate(model, kin, tasks, device, K=8, safety=False, bs=256, seed=0):
|
||||
if not tasks: # 小样本摸底时 val 可能为空
|
||||
return {'n': 0, 'success': float('nan'), 'collision_rate': float('nan'), 'start_fail': float('nan'), 'brakes_mean': float('nan')}, []
|
||||
return {'n': 0, 'success': float('nan'), 'collision_rate': float('nan'), 'start_fail': float('nan'), 'brakes_mean': float('nan'),
|
||||
'goal_ratio_2s': float('nan')}, []
|
||||
agg, pers = {}, []
|
||||
for i in range(0, len(tasks), bs):
|
||||
r, p = rollout(model, kin, tasks[i:i + bs], device, K=K, safety=safety, seed=seed + i)
|
||||
@@ -202,12 +307,14 @@ def evaluate(model, kin, tasks, device, K=8, safety=False, bs=256, seed=0):
|
||||
n = sum(r['n'] for r, _ in pers)
|
||||
out = {k: v / n for k, v in agg.items()}; out['n'] = n
|
||||
out['n_ref'] = sum(r['n_ref'] for r, _ in pers)
|
||||
# 中位数不能按批加权平均：全体任务重算（2026-10-19，选模分数用它）
|
||||
out['goal_ratio_2s'] = torch.cat([p['goal_ratio_2s'] for _, p in pers]).median().item()
|
||||
out['time_budget'] = pers[0][0]['time_budget'] if len({r['time_budget'] for r, _ in pers}) == 1 else 'mixed'
|
||||
return out, pers
|
||||
|
||||
|
||||
def main():
|
||||
from ml.model.policy import build
|
||||
from ml.common.ckpt import load_policy
|
||||
from ml.data import load_tasks
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument('--ckpt', required=True); ap.add_argument('--samples', default='ml/data/samples')
|
||||
@@ -216,8 +323,7 @@ def main():
|
||||
ap.add_argument('--safety', action='store_true'); ap.add_argument('--K', type=int, default=8)
|
||||
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu'); ap.add_argument('--out', default=None)
|
||||
a = ap.parse_args()
|
||||
ck = torch.load(a.ckpt, map_location=a.device)
|
||||
model = build(ck['cfg']).to(a.device); model.load_state_dict(ck['model']); model.eval()
|
||||
model, ck = load_policy(a.ckpt, a.device)
|
||||
kin = Kin(device=a.device)
|
||||
assert ck.get('fp') in (None, kin.fp), '碰撞模型指纹与 checkpoint 不符'
|
||||
if a.tasks: tasks = [json.loads(l) for l in open(a.tasks, encoding='utf-8') if l.strip()]
|
||||
@@ -225,8 +331,8 @@ def main():
|
||||
tasks = tasks[:a.n]
|
||||
res, pers = evaluate(model, kin, tasks, a.device, K=a.K, safety=a.safety)
|
||||
by = {}
|
||||
flat_done = torch.cat([p['done'] for _, p in pers]); flat_col = torch.cat([p['col'] for _, p in pers])
|
||||
for t, d, c in zip(tasks, flat_done.tolist(), flat_col.tolist()):
|
||||
flat_ok = torch.cat([p['ok'] for _, p in pers]); flat_col = torch.cat([p['col'] for _, p in pers])
|
||||
for t, d, c in zip(tasks, flat_ok.tolist(), flat_col.tolist()):
|
||||
k = t.get('cat', '?') + '/' + t.get('mode', '?'); b = by.setdefault(k, [0, 0, 0]); b[0] += 1; b[1] += int(d); b[2] += int(c > 0)
|
||||
res['by_cat_mode'] = {k: {'n': v[0], 'success': v[1] / v[0], 'collision': v[2] / v[0]} for k, v in by.items()}
|
||||
s = json.dumps(res, indent=1); print(s)
|
||||
|
||||
+77
-34
@@ -1,15 +1,27 @@
|
||||
"""预训练（方案 §6）：MeanFlow 一步头 + FK 损失 + 平滑 + 价值头 + 子目标头。
|
||||
python -m ml.train --samples ml/data/samples --out ml/runs/base [--config ml/configs/base.json]
|
||||
吞吐摸底：python -m ml.train --samples ml/data/samples --out ml/runs/bench_base --steps 2000 --no-eval
|
||||
通过线（方案 R10）：全程 60000 步 ≤ 3.5 h，即 samples_per_s ≥ 5000（3090 实测 6.2 k/s ≈ 2.8 h）；日志 eta_h 为剩余小时数。
|
||||
每 eval_every 步做一次闭环验证（ml/sim/closed_loop.py，部署节奏），按 success 存 best.pt；连续 patience_evals 次不升即停。
|
||||
通过线（方案 R10）：samples_per_s ≥ 5000；日志 eta_h 为剩余小时数。
|
||||
每 eval_every 步用 EMA 权重做一次闭环验证（ml/sim/closed_loop.py，部署节奏），按选模分数存 best.pt；min_step 之后连续 patience_evals 次不升即停。
|
||||
2026-10-18 首次正式预训练（21850 步，闭环到达 0–0.2%、穿柱 77–97%）后改：
|
||||
- FK / 平滑损失不再加在 one_step(随机噪声) 上（那样等于对任意噪声回归同一个 Y → 条件均值，多峰头塌成单峰），
|
||||
改加在 MF 分支里 r==t 且 t ≤ fk_tmax 的样本的配对去噪估计 x̂ = z − t·u 上（见 ml/model/meanflow.py）；
|
||||
- p_neq 前 p_neq_warm 步为 0（纯 flow matching 先把瞬时速度场学稳，再开 r≠t 的自举目标）；
|
||||
- 每次评估加开环指标（val 样本上一步采样的 16 步末端 FK 误差 mm、K 个候选的多样性），
|
||||
塌缩或学偏当场可见；best / 早停按 success 为主、开环误差为次（success 同为 0 时也能分出好坏，不会 10000 步就误停）。"""
|
||||
import argparse, json, math, os, sys, time
|
||||
塌缩或学偏当场可见。
|
||||
2026-10-19（审查 review_model_train P0-2/P0-3、review_data_actions C3）：
|
||||
- EMA（train.ema，默认 0.999，前期按 (1+s)/(10+s) 放宽）：评估、best/last 里的 'ema' 都是 EMA 权重；下游一律经 ckpt.load_policy 取 ck.get('ema', ck['model'])；
|
||||
- 选模：p_neq 预热期内及预热后第一次评估之前不存 best.pt（那时一步映射 u(z,0,1) 还没训过）；
|
||||
分数 = success + 0.05·(1 − collision_rate) + 0.05·(1 − min(1, goal_ratio_2s)) − 1e-4·min(ol_best_mm, 500)，success 全 0 时闭环指标仍能排序；
|
||||
早停只在 min_step = max(预热 + 2·eval_every, steps/2) 之后计数；
|
||||
- 余弦学习率按真实预算走完（configs 的 steps 改为 24000，原 60000 从来跑不到，14k 步早停时学习率还有 0.87×）；
|
||||
- MeanFlow 采样：p_neq 0.5、p_edge 0.1（固定 (r=0,t=1) 的部署点，见 meanflow.sample_rt）；
|
||||
- 子目标头只看 sub 特征（68:75）置零的输入：sub 存在时 SG[0:6] 与输入 sd 是同一个量，原来 80% 的样本可以直接抄（标签泄露）；
|
||||
运行时子目标头只在冷启动 sf=0 时用，这样训练与使用同口径。价值头仍用完整输入（稳态推理时带 sub）；
|
||||
- 条件输入增广 aug_pre_drop / aug_pre_sigma / aug_dq_sigma（见 ml/data.Samples.augment）；
|
||||
- 动作尺度 act_scale 取自数据（ml/data.read_meta），存进 checkpoint；续训 / 微调起点与数据不一致直接报错。
|
||||
- DAgger 微调（--init）：只有起点 checkpoint 已走过自己的 p_neq 预热时才把预热置 0；起点优先取 EMA 权重。"""
|
||||
import argparse, copy, json, math, os, sys, time
|
||||
import torch
|
||||
|
||||
from ml.common.kin_torch import Kin
|
||||
@@ -36,6 +48,7 @@ def q_from_feat(X):
|
||||
|
||||
@torch.no_grad()
|
||||
def open_loop(model, kin, vdata, stepv, fk_idx, n=1024, K=8):
|
||||
"""stepv：每单位动作对应的度数（= act_scale·STEP）。"""
|
||||
"""开环指标（val 样本，老师状态上）：
|
||||
ol_fk_mm 候选 0 的 16 步末端与老师 Y 末端的胶囊点平均距离（mm）；
|
||||
ol_best_mm K 个候选里最接近老师的那条的同一误差（多峰时它应明显小于 ol_fk_mm）；
|
||||
@@ -59,7 +72,7 @@ def main():
|
||||
ap.add_argument('--samples', nargs='+', default=['ml/data/samples']); ap.add_argument('--out', default='ml/runs/base')
|
||||
ap.add_argument('--config', default='ml/configs/base.json'); ap.add_argument('--steps', type=int, default=None)
|
||||
ap.add_argument('--resume', default=None); ap.add_argument('--no-eval', action='store_true')
|
||||
ap.add_argument('--init', default=None, help='只载入权重、优化器与步数从 0 开始（DAgger 微调用）')
|
||||
ap.add_argument('--init', default=None, help='只载入权重（优先 EMA）、优化器与步数从 0 开始（DAgger 微调用）')
|
||||
ap.add_argument('--lr', type=float, default=None); ap.add_argument('--warmup', type=int, default=None)
|
||||
ap.add_argument('--stop-at', type=int, default=0, help='自检用：跑到第 N 步按停止请求处理（存 last.pt、rc 143）')
|
||||
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu'); ap.add_argument('--seed', type=int, default=0)
|
||||
@@ -68,7 +81,14 @@ def main():
|
||||
if a.steps: tc['steps'] = a.steps
|
||||
if a.lr: tc['lr'] = a.lr
|
||||
if a.warmup is not None: tc['warmup'] = a.warmup
|
||||
if a.init: tc['p_neq_warm'] = 0 # 微调起点已训过 r≠t，不再预热
|
||||
init_ck = None
|
||||
if a.init:
|
||||
init_ck = torch.load(a.init, map_location='cpu')
|
||||
# 2026-10-19（审查 P0-2）：原来 --init 一律置 p_neq_warm=0，前提「起点已训过 r≠t」；best.pt 落在预热期（第 4000 步）时前提不成立，
|
||||
# DAgger 一上来就用没训过的场做 JVP 自举。现在只有起点已走过它自己的预热才置 0。
|
||||
init_warm = (init_ck.get('cfg') or {}).get('train', {}).get('p_neq_warm', 5000)
|
||||
if init_ck.get('step', 0) >= init_warm: tc['p_neq_warm'] = 0
|
||||
print(f'微调起点第 {init_ck.get("step")} 步（其预热 {init_warm} 步）→ 本次 p_neq_warm = {tc.get("p_neq_warm", 5000)}', flush=True)
|
||||
os.makedirs(a.out, exist_ok=True)
|
||||
torch.manual_seed(a.seed)
|
||||
dev = a.device
|
||||
@@ -76,37 +96,55 @@ def main():
|
||||
if dev.startswith('cuda'):
|
||||
torch.backends.cuda.matmul.allow_tf32 = True; torch.backends.cudnn.allow_tf32 = True # MF 分支改 fp32 后用 TF32 保吞吐
|
||||
kin = Kin(device=dev)
|
||||
data = Samples(a.samples, device=dev, split='train')
|
||||
val_tasks = [t for t in load_tasks(a.samples) if t['split'] == 'val'][:tc['eval_tasks']]
|
||||
try: vdata = Samples(a.samples, device=dev, split='val')
|
||||
# 2026-10-19（审查 F11）：val 只取主数据目录（第一个 --samples）；DAgger 目录的样本全部当 train
|
||||
data = Samples(a.samples, device=dev, split='train', val_dirs=a.samples[:1])
|
||||
act_scale = data.act_scale
|
||||
val_tasks = [t for t in load_tasks(a.samples[:1]) if t['split'] == 'val'][:tc['eval_tasks']]
|
||||
try: vdata = Samples(a.samples[:1], device=dev, split='val')
|
||||
except SystemExit: vdata = None
|
||||
if vdata is not None and vdata.n == 0: vdata = None
|
||||
print(f'train samples {data.n}, val tasks {len(val_tasks)}, device {dev}', flush=True)
|
||||
model = build(cfg).to(dev)
|
||||
print(f'train samples {data.n}, val tasks {len(val_tasks)}, act_scale {act_scale}, data_ver {data.data_ver}, device {dev}', flush=True)
|
||||
model = build(cfg).to(dev); model.act_scale = act_scale
|
||||
print(f'params {sum(p.numel() for p in model.parameters()) / 1e6:.2f} M', flush=True)
|
||||
opt = torch.optim.AdamW(model.parameters(), lr=tc['lr'], betas=tuple(tc['betas']), weight_decay=tc['wd'])
|
||||
step0, best, bad_evals = 0, -1.0, 0
|
||||
if a.init and not a.resume:
|
||||
ck = torch.load(a.init, map_location=dev); model.load_state_dict(ck['model'])
|
||||
print(f'微调：权重取自 {a.init}（第 {ck.get("step")} 步），优化器重置', flush=True)
|
||||
def check_scale(ck, src):
|
||||
s0 = float(ck.get('act_scale', 1.0))
|
||||
if abs(s0 - act_scale) > 1e-9:
|
||||
raise SystemExit(f'{src} 的 act_scale={s0} 与样本 act_scale={act_scale} 不一致：标签尺度变了，须从头训练（FRESH_FROM=prep）')
|
||||
if init_ck is not None and not a.resume:
|
||||
check_scale(init_ck, a.init)
|
||||
model.load_state_dict(init_ck.get('ema') if init_ck.get('ema') is not None else init_ck['model'])
|
||||
print(f'微调：权重取自 {a.init}（{"EMA" if init_ck.get("ema") is not None else "原始"}权重），优化器重置', flush=True)
|
||||
ema = copy.deepcopy(model).eval(); ema.act_scale = act_scale
|
||||
for p_ in ema.parameters(): p_.requires_grad_(False)
|
||||
if a.resume:
|
||||
ck = torch.load(a.resume, map_location=dev); model.load_state_dict(ck['model'])
|
||||
ck = torch.load(a.resume, map_location=dev); check_scale(ck, a.resume)
|
||||
model.load_state_dict(ck['model'])
|
||||
ema.load_state_dict(ck['ema'] if ck.get('ema') is not None else ck['model'])
|
||||
if 'opt' in ck: opt.load_state_dict(ck['opt'])
|
||||
step0, best, bad_evals = ck.get('step', 0), ck.get('best', -1.0), ck.get('bad_evals', 0)
|
||||
if set_rng_state(ck.get('rng')): print('续训：随机数状态已恢复（batch 顺序与不断点一致）', flush=True)
|
||||
print(f'续训：从第 {step0} 步继续（共 {tc["steps"]} 步），当前最好 success {best:.4f}', flush=True)
|
||||
print(f'续训：从第 {step0} 步继续（共 {tc["steps"]} 步），当前最好分数 {best:.4f}', flush=True)
|
||||
del init_ck
|
||||
total = tc['steps']
|
||||
lr_at = lambda s: tc['lr'] * (s / tc['warmup'] if s < tc['warmup'] else 0.5 * (1 + math.cos(math.pi * (s - tc['warmup']) / max(1, total - tc['warmup']))))
|
||||
amp = dev.startswith('cuda') and tc.get('amp') == 'bf16'
|
||||
stepv = torch.tensor(STEP, device=dev)
|
||||
astep = stepv * act_scale # 动作 → 度
|
||||
fk_idx = torch.linspace(0, kin.cap_a.shape[0] - 1, tc['fk_caps'], device=dev).long()
|
||||
ema_d = float(tc.get('ema', 0.999))
|
||||
warm = 0 if model.head == 'wta' else int(tc.get('p_neq_warm', 5000))
|
||||
sel_from = warm + tc['eval_every'] # 第一次可以存 best.pt 的步数：预热结束后的第一次评估
|
||||
min_step = max(warm + 2 * tc['eval_every'], total // 2) # 早停计数起点
|
||||
log = open(os.path.join(a.out, 'log.jsonl'), 'a' if a.resume else 'w') # 新训练覆盖旧日志，续训才追加
|
||||
if not val_tasks and not a.no_eval:
|
||||
print('没有 val 任务（样本太少），本次跳过闭环验证', flush=True); a.no_eval = True
|
||||
t0, seen, diverged = time.time(), 0, False
|
||||
saver = Saver(tc.get('ckpt_min', 10)) # 2026-10-18：每 10 分钟 + 收到停止请求时存 last.pt（原子写）
|
||||
def save(name, step, extra=None):
|
||||
d = {'model': model.state_dict(), 'opt': opt.state_dict(), 'cfg': cfg, 'step': step, 'best': best, 'bad_evals': bad_evals, 'fp': kin.fp}
|
||||
d = {'model': model.state_dict(), 'ema': ema.state_dict(), 'opt': opt.state_dict(), 'cfg': cfg, 'step': step, 'best': best,
|
||||
'bad_evals': bad_evals, 'fp': kin.fp, 'act_scale': act_scale, 'data_ver': data.data_ver}
|
||||
if name == 'last.pt': d['rng'] = rng_state()
|
||||
if extra: d.update(extra)
|
||||
atomic_save(d, os.path.join(a.out, name))
|
||||
@@ -114,19 +152,21 @@ def main():
|
||||
step = step0 - 1 # 续训时已训满：循环一次不跑，下面照常收尾
|
||||
for step in range(step0, total):
|
||||
for gpar in opt.param_groups: gpar['lr'] = lr_at(step)
|
||||
X, Y, V, SG = data.batch(tc['batch'])
|
||||
X, Y, V, SG = data.batch(tc['batch'], aug=tc)
|
||||
model.train()
|
||||
with torch.autocast('cuda', dtype=torch.bfloat16, enabled=amp):
|
||||
mem = model.encode(X)
|
||||
if model.head == 'wta':
|
||||
l_mf, xh = wta_loss(model, mem, Y); mf_raw = l_mf.detach(); xh = xh.float()
|
||||
else:
|
||||
p_neq = tc['p_neq'] if step >= tc.get('p_neq_warm', 5000) else 0.0
|
||||
l_mf, mf_raw, aux = meanflow_loss(model, mem, Y, p_neq=p_neq, return_aux=True)
|
||||
p_neq = tc['p_neq'] if step >= warm else 0.0
|
||||
l_mf, mf_raw, aux = meanflow_loss(model, mem, Y, p_neq=p_neq, return_aux=True, p_edge=tc.get('p_edge', 0.0))
|
||||
sel = ((aux['r'] == aux['t']) & (aux['t'] <= tc.get('fk_tmax', 0.3))).nonzero(as_tuple=True)[0]
|
||||
tt = aux['t'][sel][:, None, None]
|
||||
xh = aux['z'][sel] - tt * aux['u'][sel] # 配对去噪估计（fp32）
|
||||
v, s = model.heads(mem)
|
||||
v, _ = model.heads(mem)
|
||||
Xs = X.clone(); Xs[:, 68:75] = 0 # 子目标头：sub 特征置零（切断抄输入的捷径，见文件头）
|
||||
_, s = model.heads(model.encode(Xs))
|
||||
l_val = (v.float() - V).abs().mean(); l_sub = (s.float() - SG).abs().mean()
|
||||
Xf, Yf = (X, Y) if model.head == 'wta' else (X[sel], Y[sel])
|
||||
l_sm = torch.zeros((), device=dev); l_fk = torch.zeros((), device=dev)
|
||||
@@ -136,8 +176,8 @@ def main():
|
||||
if tc['w_fk'] > 0 and xh.shape[0] > 0:
|
||||
q = q_from_feat(Xf)
|
||||
ks = torch.tensor([3, 7, 11, 15], device=dev)
|
||||
qh = q[:, None] + torch.cumsum(xh.clamp(-1, 1) * stepv, 1)[:, ks]
|
||||
qt = q[:, None] + torch.cumsum(Yf * stepv, 1)[:, ks]
|
||||
qh = q[:, None] + torch.cumsum(xh.clamp(-1, 1) * astep, 1)[:, ks]
|
||||
qt = q[:, None] + torch.cumsum(Yf * astep, 1)[:, ks]
|
||||
B4 = qh.shape[0] * 4
|
||||
ph = fk_points(kin, qh.reshape(B4, 6), fk_idx); pt = fk_points(kin, qt.reshape(B4, 6), fk_idx)
|
||||
l_fk = ((ph - pt).norm(dim=-1) / 10).mean()
|
||||
@@ -148,6 +188,9 @@ def main():
|
||||
if not torch.isfinite(loss):
|
||||
print('非有限损失 → 训练发散（M5 门禁：触发 WTA 回退条件）', flush=True); save('diverged.pt', step); diverged = True; break
|
||||
opt.step(); seen += X.shape[0]
|
||||
with torch.no_grad(): # EMA；前期按 (1+s)/(10+s) 放宽，避免随机初值占权重
|
||||
dk = min(ema_d, (1 + step) / (10 + step))
|
||||
for pe, pm in zip(ema.parameters(), model.parameters()): pe.lerp_(pm.detach(), 1 - dk)
|
||||
if saver.stop() or (a.stop_at and step + 1 >= a.stop_at):
|
||||
save('last.pt', step + 1); log.close()
|
||||
print(f'收到停止请求：已存档 last.pt（第 {step + 1} 步），下次运行自动续训', flush=True); sys.exit(143)
|
||||
@@ -159,25 +202,25 @@ def main():
|
||||
'eta_h': (total - step - 1) * tc['batch'] / max(seen / max(el, 1e-6), 1e-6) / 3600, 'vram': vram.peak_gib()}
|
||||
print(json.dumps(rec), flush=True); log.write(json.dumps(rec) + '\n'); log.flush()
|
||||
if not a.no_eval and (step + 1) % tc['eval_every'] == 0:
|
||||
model.eval()
|
||||
# bs=64 + 归还缓存池：WDDM 卡满时 15.9 GiB 的评估峰值会被驱动换出到内存，eval 从 2 分钟变 1 小时
|
||||
res, _ = evaluate(model, kin, val_tasks, dev, bs=64)
|
||||
if vdata is not None: res.update(open_loop(model, kin, vdata, stepv, fk_idx))
|
||||
res, _ = evaluate(ema, kin, val_tasks, dev, bs=64)
|
||||
if vdata is not None: res.update(open_loop(ema, kin, vdata, astep, fk_idx))
|
||||
torch.cuda.empty_cache()
|
||||
res['step'] = step + 1; res['t'] = time.time()
|
||||
sc = res['success'] + 0.05 * (1 - res['collision_rate']) + 0.05 * (1 - min(1.0, res.get('goal_ratio_2s', 1.0))) \
|
||||
- 1e-4 * min(res.get('ol_best_mm', 0.0), 500.0)
|
||||
res['step'] = step + 1; res['t'] = time.time(); res['score'] = sc; res['weights'] = 'ema'
|
||||
print('EVAL', json.dumps(res), flush=True); log.write(json.dumps({'eval': res}) + '\n'); log.flush()
|
||||
save('last.pt', step + 1)
|
||||
sc = res['success'] - 1e-3 * min(res.get('ol_fk_mm', 0.0), 500.0) # 到达率为主，开环误差（mm）只在到达率打平时起作用
|
||||
if sc > best + 1e-5:
|
||||
if step + 1 >= sel_from and sc > best + 1e-5:
|
||||
best = sc; bad_evals = 0; save('best.pt', step + 1, {'eval': res})
|
||||
else:
|
||||
elif step + 1 >= min_step:
|
||||
bad_evals += 1
|
||||
if bad_evals >= tc['patience_evals']: print('闭环到达率不再上升，停止', flush=True); break
|
||||
if bad_evals >= tc['patience_evals']: save('last.pt', step + 1); print('闭环分数不再上升，停止', flush=True); break
|
||||
save('last.pt', step + 1)
|
||||
if diverged: # 发散的权重不能覆盖 last.pt / best.pt：last.pt 保留发散前最后一次存档，M5 门禁会因此判不过 → 自动 WTA
|
||||
print('训练发散，last.pt / best.pt 保留发散前的存档', flush=True); return
|
||||
save('last.pt', step + 1)
|
||||
if a.no_eval: save('best.pt', step + 1)
|
||||
print(f'done, best score（到达率 − 0.001×开环 mm）{best:.4f}, {(time.time() - t0) / 3600:.2f} h', flush=True)
|
||||
if a.no_eval or best <= -1.0: save('best.pt', step + 1) # 没评估过 / 总步数不到 sel_from：best = last
|
||||
print(f'done, best score {best:.4f}, {(time.time() - t0) / 3600:.2f} h', flush=True)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -71,7 +71,7 @@ const pct = (a, p) => { if (!a.length) return null; const s = a.slice().sort((x,
|
||||
for (let ci = 0; ci < cases.length; ci++) {
|
||||
const c = cases[ci];
|
||||
const R = mode === 'pose' ? c.R : null;
|
||||
const r = new POL.Runner(S, infer, { seed: 1000 + ci });
|
||||
const r = new POL.Runner(S, infer, { seed: 1000 + ci, actScale: meta.act_scale || 1 }); // 2026-10-19：动作尺度随模型
|
||||
r.reset(c.q0); r.setGoal(c.T, R);
|
||||
let prev = c.q0.slice(), cf = 0, tLock = null;
|
||||
for (let k = 0; k < 500 && !r.done; k++) {
|
||||
|
||||
@@ -55,7 +55,7 @@ async function boot() {
|
||||
}
|
||||
if (!sess) sess = await ort.InferenceSession.create(MODEL, { executionProviders: ep, graphOptimizationLevel: 'all' });
|
||||
const infer = ArmPolicy.ortInfer(ort, sess, { encOnce: !!meta.enc_once, featDyn: !!meta.feat_dyn });
|
||||
runner = new ArmPolicy.Runner(S, infer, {});
|
||||
runner = new ArmPolicy.Runner(S, infer, { actScale: meta.act_scale || 1 }); // 2026-10-19：动作尺度随模型（旧模型无此字段 = 1）
|
||||
/* 预热：首次推理有编译开销 */
|
||||
await infer(new Float32Array(8 * ArmPolicy.F_DIM), new Float32Array(8 * ArmPolicy.H * 6), 8);
|
||||
const tick = URL.createObjectURL(new Blob(['let h=null;onmessage=e=>{clearInterval(h);if(e.data>0)h=setInterval(()=>postMessage(0),e.data)}'], { type: 'text/javascript' }));
|
||||
|
||||
+35
-11
@@ -178,8 +178,10 @@ class Runner {
|
||||
this.S = S; this.infer = infer;
|
||||
this.o = Object.assign({ K: 8, commit: 3, margin: 5, /* 2026-10-18：运行时投影余量保持 5 mm（真机护栏，不迁就数据分布）；数据侧另行过滤认证间隙 < 3 mm 的老师轨迹，APG 训练余量 3 mm */
|
||||
projMax: 0.5, refineMm: 5, arriveMm: 1, arriveDeg: 0.5,
|
||||
stuckPlans: 5, lockSec: 1.0, subReachDeg: 5, subTimeout: 1.5, seed: 12345, lookahead: true,
|
||||
certBudget: 40, safetyMs: 30, firstMs: 45 }, opts || {}); // 每条候选最多 40 次距离查询；安全层总预算 30 ms，第 1 条候选可用到 45 ms（超出按刹停处理）
|
||||
stuckPlans: 5, lockSec: 1.0, subReachDeg: 5, subTimeout: 1.5, subRule: 'cross', subLeadSec: 0.02, seed: 12345, lookahead: true,
|
||||
actScale: 1, certBudget: 40, safetyMs: 30, firstMs: 45 }, opts || {});
|
||||
/* 2026-10-19：actScale = 模型 meta.act_scale（动作标签按 act_scale·STEP 归一化，旧模型 1）；增量 = clamp(act, ±1)·actScale·STEP，
|
||||
与 ml/sim/closed_loop.py 同口径。subRule：'cross'（默认，越过顶点即切，与训练标签同口径；见 _subAdvance）/ 'timeout'（旧：< subReachDeg 或 subTimeout 超时）。 */ // 每条候选最多 40 次距离查询；安全层总预算 30 ms，第 1 条候选可用到 45 ms（超出按刹停处理）
|
||||
this.cert = makeCert(S, { leverTable: this.o.leverTable, cap: 20 });
|
||||
this.rng = makeRng(this.o.seed);
|
||||
/* 2026-10-18 第六轮（审查 B-1/B-2）：耗时拆开记——inferMs 主推理、lookaheadMs 前瞻（第二次推理 + 8 份特征）、safetyMs 只含认证、
|
||||
@@ -190,7 +192,7 @@ class Runner {
|
||||
reset(q0) {
|
||||
this.q = q0 ? q0.slice() : null; this.qPrev = this.q ? this.q.slice() : null;
|
||||
this.queue = []; this.brakeTail = []; this.lastPlan = null; this.goal = null;
|
||||
this.subs = []; this.subT = 0; this.vals = []; this.brakeRun = 0; this.lock = null; this.t = 0; this.cold = true; this.done = false;
|
||||
this.subs = []; this.subT = 0; this.subPrev = null; this.vals = []; this.brakeRun = 0; this.lock = null; this.t = 0; this.cold = true; this.done = false;
|
||||
}
|
||||
setGoal(T, R) {
|
||||
const jump = !this.goal || Math.hypot(T[0] - this.goal.T[0], T[1] - this.goal.T[1], T[2] - this.goal.T[2]) > 50 || (!!R !== !!this.goal.R);
|
||||
@@ -220,10 +222,34 @@ class Runner {
|
||||
return this.q;
|
||||
}
|
||||
_cand(act, k, r) { // 第 k 条候选：增量（°），丢掉模型的前 r 步（已提交前缀），取接下来的步
|
||||
const inc = [];
|
||||
for (let s = 0; s < H; s++) { const row = []; for (let j = 0; j < 6; j++) row.push(Math.max(-1, Math.min(1, act[(k * H + s) * 6 + j])) * STEP[j]); inc.push(row); }
|
||||
const inc = [], sc = this.o.actScale || 1;
|
||||
for (let s = 0; s < H; s++) { const row = []; for (let j = 0; j < 6; j++) row.push(Math.max(-1, Math.min(1, act[(k * H + s) * 6 + j])) * sc * STEP[j]); inc.push(row); }
|
||||
return inc;
|
||||
}
|
||||
/* 子目标推进（与 ml/sim/closed_loop.py sub_advance 同一规则，三处同步改）。
|
||||
2026-10-19（审查 C5 / P0-1）：训练标签里 sub = 老师「下一个尚未经过的顶点」，老师 τ 一过顶点（−0.02 s）就换；
|
||||
旧规则要 < 5° 或 1.5 s 超时，策略在顶点附近进不去时 sub 一直指着身后的点（训练里从未出现的特征序列）。
|
||||
'cross'：进入方向 a = 顶点 − 上一点，离开方向 b = 下一顶点 − 顶点（最后一个取 a），各轴 /VMAX 折成秒；
|
||||
法向 n = â + b̂，(qe − 顶点)·n̂ ≥ −subLeadSec 即越过。没有超时（标签也没有）。 */
|
||||
_subAdvance(qe) {
|
||||
if (!this.subs.length) return;
|
||||
const S = this.S, o = this.o, sg = this.subs[0];
|
||||
const df = (a, b, j) => (S.LIM[S.ORDER[j]].cont ? wrap180(a - b) : a - b);
|
||||
let adv = false;
|
||||
if (o.subRule === 'timeout') {
|
||||
let m = 0; for (let j = 0; j < 6; j++) m = Math.max(m, Math.abs(df(sg[j], qe[j], j)));
|
||||
adv = m < o.subReachDeg || this.t - this.subT > o.subTimeout;
|
||||
} else {
|
||||
const unit = v => { const n = Math.hypot.apply(null, v); return n > 1e-9 ? v.map(x => x / n) : v.map(() => 0); };
|
||||
const prev = this.subPrev || this.q;
|
||||
const a = [0, 1, 2, 3, 4, 5].map(j => df(sg[j], prev[j], j) / VMAX[j]);
|
||||
const b = this.subs.length > 1 ? [0, 1, 2, 3, 4, 5].map(j => df(this.subs[1][j], sg[j], j) / VMAX[j]) : a;
|
||||
const ua = unit(a), ub = unit(b), n = unit(ua.map((x, j) => x + ub[j]));
|
||||
let proj = 0; for (let j = 0; j < 6; j++) proj += df(qe[j], sg[j], j) / VMAX[j] * n[j];
|
||||
adv = proj >= -o.subLeadSec;
|
||||
}
|
||||
if (adv) { this.subPrev = this.subs.shift(); this.subT = this.t; }
|
||||
}
|
||||
_certCommit(qe, steps) { // 认证：提交步 + 刹停段（先用离散判定快速剔除，再做距离下界认证）
|
||||
const pts = [qe.slice()]; let q = qe.slice();
|
||||
for (const d of steps) { q = q.map((v, j) => v + d[j]); pts.push(q.slice()); }
|
||||
@@ -257,13 +283,11 @@ class Runner {
|
||||
const steps = []; let q = qe.slice();
|
||||
for (let k = 0; k < o.commit; k++) { const rs = refineStep(S, q, this.goal.T, this.goal.R, 0.3); steps.push(rs.dq); q = q.map((v, j) => v + rs.dq[j]); }
|
||||
const c = this._certCommit(qe, steps);
|
||||
if (c.ok) { this.queue.push(...steps); this.brakeTail = c.tail; this.stats.refine++; return; }
|
||||
/* 2026-10-19（审查 F5）：DLS 接管时没有「已提交的模型计划」，lastPlan 置空（原来保留上一条，下次一致性去对齐一条没执行的轨迹；仿真同步） */
|
||||
if (c.ok) { this.queue.push(...steps); this.brakeTail = c.tail; this.stats.refine++; this.lastPlan = null; return; }
|
||||
}
|
||||
/* 子目标推进 */
|
||||
if (this.subs.length) {
|
||||
const sg = this.subs[0]; let m = 0; for (let j = 0; j < 6; j++) m = Math.max(m, Math.abs((S.LIM[S.ORDER[j]].cont ? wrap180(sg[j] - qe[j]) : sg[j] - qe[j])));
|
||||
if (m < o.subReachDeg || this.t - this.subT > o.subTimeout) { this.subs.shift(); this.subT = this.t; }
|
||||
}
|
||||
this._subAdvance(qe);
|
||||
const gm = S.gapMatrix(this.q, GAP_CAP);
|
||||
const st = { q: this.q, qPrev: this.qPrev, T: this.goal.T, R: this.goal.R, prefix, sub: this.subs[0] || null };
|
||||
const f = features(S, st, gm);
|
||||
@@ -279,7 +303,7 @@ class Runner {
|
||||
if (this.needSub) {
|
||||
this.needSub = false; this.subT = this.t;
|
||||
const sb = out.sub.subarray(best * 13, best * 13 + 13);
|
||||
if (sb[12] > 0.5) this.subs = [0, 1].map(v => this.q.map((x, j) => x + sb[v * 6 + j] * 180));
|
||||
if (sb[12] > 0.5) { this.subs = [0, 1].map(v => this.q.map((x, j) => x + sb[v * 6 + j] * 180)); this.subPrev = this.q.slice(); }
|
||||
}
|
||||
/* 候选：去掉前缀后的提交步，投影，打分 */
|
||||
const cands = [], near = S.criticalPairs(qe, o.margin + 10).slice(0, 64);
|
||||
|
||||
Reference in New Issue
Block a user