88 Commits
Author SHA1 Message Date
cbb d3cd167eb5 exp: 补提交轮次40 的 K 成本探针产物(此前漏在未跟踪文件里,是候选档位成本-收益曲线的一手数据) 2026-10-21 02:03:49 +08:00
cbb 22d203ee80 docs: 日志整体倒序——候选表之后的 75 个小节全部按轮次号降序重排
之前的"倒序"只在 ## 轮次 NN 之间成立:记分板/续篇/按 issue 号命名的条目(如 #27、#24、判别定案)
各有自己的位置,所以打开后第 4 屏才看到新轮次,且 轮次 39 那一族曾压在 52 上面。
现在规则统一:文件头 + 轮次统计 + 算法优化候选常驻最前,其后所有小节按轮次号降序,
无轮次号的行政/教训类(分支清理、事故记录)按约定放最后。

轮次号取自标题里的"轮次 NN";标题没有的从正文找(#27 那种),正文也没有的走显式定年表
(两条 #21 的条目按 round40 产物定为轮次 40)。同轮次内保持原有相对顺序,不乱改。

脚本 ml/runs/_sort_log_reverse.py(默认 dry-run,--apply 才写盘),带三重守恒断言:
字符数相同、逐行多重集相同、排序前后 diff -q 与 HEAD 完全一致 ⇒ 这次改动是纯重排
(72 增/72 删只是块边界)。LF 未被整体改写成 CRLF。
2026-10-21 01:59:29 +08:00
cbb b03c96982d docs: 修正轮次49/50 那处说过头的措辞——门控不是时限收益"塌了",是吃掉约四成(合并 +17 对 pre 的 +28),损失集中在 seed=1 2026-10-21 01:57:18 +08:00
cbb 54fb50a9f1 docs: 排序修正+轮次53——把压在最新轮次之上的"轮次39"块移回它的位置;§9.2 记分板换到 K16+pre 现状
排序:倒序约定此前只在各轮之间成立,旧的"轮次 39"及其 4 个续篇块卡在候选表下面、
轮次 52 上面 ⇒ 打开日志第一眼是 39,看起来像"没再更新"。整块 67 行移到 轮次38 之前,
纯移动不改内容(字节数 188223 不变,LF 保持)。

轮次53(seed=1 逐题配对):pre 在 §9.2 自己的 1.3x 口径上复现——s0 22新增/5失去 p=0.0015,
s1 17/6 净+11 p=0.035,合并 39/11 p=9.0e-5 ⇒ "打分地平线=执行地平线"确实买到时限这一栏。
门控20mm 在 s1 只有 12/11 净+1 (p=1.0),合并 +17 p=0.024 ⇒ 修正轮次50 说过头的"塌了",
准确说法是"门控吃掉约四成时限收益,损失集中在 seed=1"。

记分板更新(最好合法口径 = inc_cap+K16+pre,轮次51):碰撞 0 / 超VMAX 0 达标;
可达到达 0.5967(差 38.3pp,相对控制净+11 题 p=0.061 未确立);时限内 0.3594(唯一被配对证明);
行程比 2.414(超 1.3 倍);brake_rate mean 7.28% 但 p50=0.0%、p90 27.4%(长尾, stuck_share 17.2%)。
2026-10-21 01:55:57 +08:00
cbb 219ed19de4 exp+eval: 轮次51-52——2x2 补全 + 逐题老师用时落盘;1.3x 口径的时限收益其实是显著的
轮次51 (2x2 缺失格 K16+pre):最好格 到达 0.5664 / 时限内 0.3594 / 2s误差比 0.1382 /
行程比 2.4142 / 碰撞 0 / 超VMAX 0。主效应:pre 在 K8 +6.64pp、K16 +6.25pp(时限),
K16 在 endpoint +3.13pp、pre +2.73pp ⇒ 时限可加无交互;到达饱和(pre 在 K16 上净+1题 p=1.0)。
最好格 vs 历史控制逐题赢20丢9 净+11,McNemar p=0.061 ⇒ 到达仍未确立。

轮次52 (仪表):dump 补 t_exp/tr_ref(题目属性,与臂无关 ⇒ 一条臂即可给全部历史臂补配对)。
改完落盘代码先自证行为未动:同配方控制臂 22/22 老键逐位相同;limit=2*t_exp 实测对上
⇒ "到达率自带 2x 时限"从推断变成实测。

逐题配对(vs K8 endpoint, 判据=ok 且 t_done<=1.3*t_exp):
K16pre 27赢3丢 净+24 p=8.4e-6;K8pre 22/5 净+17 p=0.0015;门控5 23/6 p=0.0023;
门控20 22/6 p=0.0037;h=4 15/5 p=0.041;K16endpoint 17/9 p=0.169;h=8 11/7 p=0.481;
tie=1 3/0 p=0.25。
⇒ 自我纠正:轮次46-51 我一直拿 success(那道 2x 门)做配对,把"时限内"写成没有配对支持。
现在两栏分开:到达未确立(p>=0.06),时限内已确立(p=0.0015/8.4e-6)。
副产物:K16+endpoint 的 +3.1pp 时限当初没有配对检验,实测 p=0.169 不显著,已在轮次52记下。
2026-10-21 01:48:46 +08:00
cbb af856ca728 exp: 轮次50——门控20mm 的 seed=1 复现失败于幅度:时限收益 +6.25pp→+0.39pp,精度代价减小但未消除
两 seed 合并后必须更正轮次49 的一句话:到达题组内末态误差 vs 控制的符号检验 s0 67/57(p=0.419)、
s1 74/51(p=0.049)、合并 141差/108好 p=0.042 ⇒ 是"大幅减小"而不是"与控制不可分"。
中位数(+3.4%/+2.6%)与逐题分布给出相反印象,因为门控把尾部拉近中位、却把大量题各推一点。
到达两 seed 合并赢24丢21 净+3 p=0.766 ⇒ 这条轴上到达没有可用信号。

稳的部分:goal_ratio_2s 两 seed 都改善(0.170/0.201 vs 0.279/0.275) ⇒ "打分地平线=执行地平线"
买路上进度是唯一稳健效应。可推荐形态是 ungated pre,门控留给末态余量优先的场景。

统计自纠:精确 McNemar/符号检验原写法 2*Σ_{i<=min(k,n-k)}C(n,i)/2^n 在 k=n/2 中间点会算出 1.168>1;
改成 p=min(1,2*min(P(X<=k),P(X>=k))) 后重算本轮全部已上报 p 值,除中间点那例外数值不变
(0.125/0.424/0.678/0.455/0.327/0.042/4.9e-16/1.8e-12/2.4e-6 都对得上),中间点正确值 p=1.0。

下一轮补 2×2 的缺失格 K16+pre 量可加性(已在盘三格),判读规则预注册。
2026-10-21 01:31:11 +08:00
cbb 97f746077a exp: 轮次49——#31 门控地平线成立:终端段 20 mm 时时限收益与精度代价解耦
预注册判据(err_success_med 回到 ~0.22mm 且 time_ok>=0.31)由 20mm 臂满足:
0.2248 mm / 0.3281;到达题组内末态误差符号检验 67差/57好 p=0.42 ⇒ 与控制不可分
(pre h=2 是 82/42 p=4.2e-4,门控5mm 是 79/45 p=0.0029 仍显著变差)。
5→20mm 的分级响应是机理证据:病名是"终端代价的作用区间不够长",不是"缺终端代价"。

不许只报好的那半:不存在同时占优的阈值——20mm 把 A 类到达打到 94/128(控制与5mm 都是 96),
5mm 到达最高 0.5469 且行程比最好 2.4218 但精度仍显著变差。到达率在整条轴上都没跨过显著
(净 +3/+6/+5 题,McNemar p=0.68/0.33/0.42),所以主口径仍写控制值。

四列 collision_rate/over_vmax_rate 全 0、n_plans_mean 全 195.0 ⇒ 没有放松判据、规划次数不变。
下一步 seed=1 复现(控制臂复用 round47_ep_s1),判读规则已预注册。
2026-10-21 01:24:21 +08:00
cbb 801724bda2 exp+test: #31 机制落库——门控地平线 select=pre --pre_near(远端短前瞻、近终段用整条地平线)
轮次 48 的曲线给出:时限收益随 h 缩短单调上升,而末态精度代价集中在 h<=4 ⇒ 假设病因是
"近终段没有终端代价"而不是"前瞻短"。本参数把两者分开:当前误差<=pre_near(mm) 时打分退回
整条地平线,远端保持 commit 窗口口径。代价多一次 goal_err(B×K 点),只在门控开启时发生。

单测按夹具手算:起点 e=900 ⇒ pre_near=950 必须在第一次规划就翻回 endpoint 的选择,
pre_near=100/0 必须保持 pre 的选择(三条断言彼此可分,门控若没接上会直接红)。
52 项测试绿;ast 复核新局部名(qa_pre/qa_full/e_pre/e_full)未遮蔽任何 rollout 形参。
判读规则预注册写在 ml/runs/_r49_gate.sh 顶部:成立=err_success_med 回到 ~0.22mm 且
time_ok 保住 >=0.31;只满足一半则记为机理负结论。两个阈值(5/20mm)都报,不挑最好。
2026-10-21 01:12:56 +08:00
cbb 36150242f2 exp: 轮次48——打分地平线四点曲线(h=2/4/8/16):进度单调、精度代价阶跃在 h<=4、h=8 是坏点
时限内 0.2656/0.2813/0.3047/0.3320;2 s 误差比逐题符号检验随 h 缩短单调增强
(h=8 166:90 p=2.4e-6、h=4 184:72 p=1.8e-12、h=2 192:64 p=4.9e-16);
到达四点全在噪声内(净 -1/+4/+5,McNemar p>=0.42)。
末态到达误差 0.2175/0.2255/0.3301/0.4151 mm ⇒ 代价集中在 h<=4,病因是"近终段没有终端代价"
而不是"前瞻短",故派生 #31(门控地平线)、按预注册规则作废 #26。
h=8 行程比 2.6749 反而比控制 2.6158 更差 ⇒ "地平线砍一半"的渐进方案被中间点自己否掉。

判据与成本(实测非推算):四点 collision_rate=0、over_vmax_rate=0、start_fail=0,
speed_ratio/accel_ratio 四点逐位相同,n_plans_mean 全为 195.0 ⇒ 规划次数与认证调用数不变。
2026-10-21 01:11:18 +08:00
cbb b3c6ad995a exp+test: #30 机制落库——select=pre 的打分步长做成参数 pre_h(h=4/8 两臂排队)
pre_h=0 保持"0=commit_n"的轮次46 口径逐位不变;pre_h>0 按绝对步数取 fut 的该步终点误差。
新增两条可手算的期望值:夹具交叉点 h=4 选候选0(0.343 vs 0.20)、h=12 选候选1(0.114 vs 0.60)、
h=16 必须与 endpoint 同选;再加一条不变式 pre_h=0 与 pre_h=commit_n 的轨迹逐位相同。
51 项测试绿;ast 枚举确认新局部名没有遮蔽任何 rollout 形参(上一轮 nmax 那类事故的自查)。
判读规则已预注册,写在 ml/runs/_r48_horizon.sh 顶部。
2026-10-21 00:58:37 +08:00
cbb 3c250c7df3 exp: 轮次46-47——select=pre(打分地平线=被执行前缀终点)正向,两 seed 复现
2 s 误差比逐题符号检验 s0 192好/64差 p=4.9e-16、s1 191/65 p=1.5e-15;时限内(≤1.3×老师)
0.2656→0.3320(+6.64pp)、0.2969→0.3398(+4.30pp);行程比 −0.171/−0.171;碰撞仍 0、超 VMAX 仍 0。
到达只 +5/+3 题(McNemar p=0.42/0.68 ⇒ 噪声),故不改默认口径、作可选口径入库。
代价:到达题末态误差 0.22→0.42 mm(判据壳 1 mm 内,余量 4.6×→2.4×),两 seed 都涨。

对照可比性先证:控制臂 tie0 与轮次42 round42_K8cb1 的 22/22 键逐位相同 ⇒ 该配方跨窗口确定性
复现,本轮起新杠杆可用单臂对已落盘控制。

实现:select='pre' 用 fut[:,:,commit_n-1] 的终点误差(同一次 goal_err 只换点集);两条可手算正对照
(前缀好/末端差 vs 末端好/前缀差 ⇒ 两口径必须选相反候选) + 不变式(commit_n=16 时与 endpoint 同选);
49 项测试绿;n=16 冒烟证非惰性。候选表同步修准:backoff/ep_waste 两行状态改判掉,#29/#30 登记。
2026-10-21 00:57:08 +08:00
cbb 72c8835229 exp: 轮次45——tie(等长安全前缀按沿路最小间隙定夺)判掉
两臂 n=256 同 seed 背靠背(配方=轮次42 K8+cert_batch=1+inc_cap=1):到达 0.5234→0.5039
(-1.95pp,逐题配对丢6赢1净-5,McNemar 精确 p=0.125 与零不可分),时限内 +1.17pp、
刹停 -9%、行程比 -0.076、执行碰撞仍为 0(判据未放松)。丢的 6 题 5 题在 A 类(开阔区)
=买余量卖进度的签名。

仪表与离线数交叉验证:改选率 5.58% 对上轮次44 独立测得的"执行点间隙落在 0.2–0.5mm 占
5.6%",并列率 79.0% 对上"满前缀 79.4%" ⇒ 分辨率上界被宽相位截顶 gcap=max(0.5,margin+0.5)
锁死,5.6% 是这个家族在 cap=0.5 下的天花板,不是实现没调好。

结构性发现:#24 作用在错的人群——tie 只在 maxlen>0 触发,而失败主人群是全拒(maxlen=0,
未到达题 22% 的规划);全拒那条已由 backoff(轮次43)判掉。前置条件记为 #28(gcap 与
gap_margin 解耦)。

实现账:新增 tie 与触发计数器(生产端 per 数组+dump 键、消费端汇总 tie_* 同批改完,
tie=0 时 22/22 老键逐位复现);修掉 tie 分支局部名 nmax 顶掉主循环总步数的遮蔽 bug,
守卫单测做过变异检查;计数器正对照可手算(tie_opp=tie_changed=n_plans)。47 项测试绿。
2026-10-21 00:33:44 +08:00
cbb 350f386c02 exp: #27——K16增益不集中在B/C(总体+3.9pp/净10题,B仅+4题不显著);B刹停-29%但到达仅27→32%,证明B/C缺口是策略不产绕行而非闸门 2026-10-21 00:04:32 +08:00
cbb 1b301cc58e exp: 分层指标三重交叉验证通过——success_reachable 0.5514/by_cat(B27%,C34%)/brake_rate p50 0.5%但p90 31.5%、stuck_share 23.4%;老22键逐位不变 2026-10-20 23:51:51 +08:00
cbb a982b0755d feat: 评估加分层读数——success_reachable(排除不可达D类)/by_cat 到达率/brake_rate_p90/stuck_share/n_plans_mean;CPU 冒烟全键产出、43 项测试绿 2026-10-20 23:44:59 +08:00
cbb 1a6840fc66 exp: backoff四臂判掉——转化率7.7→37%但到达/时限不赚(0.5234→0.5156);且它单独改善brake_rate达16%而行为未变好=可绕过§9.2判据 2026-10-20 23:42:50 +08:00
cbb abd66d6124 exp: 控制臂22/22键逐位复现+reverse_p50离线预测0.247精确命中;brake_rate首读mean10.03%/p50 0.51%(§9.2差5倍但中位已达标) 2026-10-20 23:23:50 +08:00
cbb 1bb74e4b00 docs: 冻住形态定案——B/C是每题~30次×1.8步的反复试探(零步29%)而非堵死;backoff预期=省停步不省通路,B类到达要靠#24排序避死路 2026-10-20 23:19:48 +08:00
cbb 309169a4ed exp: ep_waste三臂负结论(行程比不随权重单调、w=1纯亏);原因=罚在16步地平线而每拍只提交2步;刹停率与brakes/n_plans逐位对表 2026-10-20 23:18:25 +08:00
cbb 4b871a5f67 docs: 缺口按类别定位——A(无障碍)75%但B(直线被挡)27%/C(贴立柱)34%;纠正D类(不可达)混入到达分母的口径(+2.8pp) 2026-10-20 23:06:28 +08:00
cbb c89105996d docs: 刹停长尾定量化——48.8%题零刹停、前20%题占72.4%事件;杠杆必须分层报(brake_rate_p90/stuck_share),否则对尾巴有效的改动在均值上看不出来 2026-10-20 23:03:51 +08:00
cbb 27c8cbf111 exp: 轮次41——K16串行/批量决策逐位相同(等价性扩到K=16)+墙钟-18%;brake_rate首读mean7.06%但p50=0,刹停集中在一小撮卡住的题 2026-10-20 23:03:06 +08:00
cbb fb836e699a docs: #24 设计定稿——先算全候选间隙矩阵同时供打分与认证(零额外几何调用),口径强制走批量认证 2026-10-20 22:55:49 +08:00
cbb 274e916352 docs+fix: 代价探针第一版把整次调用当一次规划(绝对值大四倍);改为两长度解固定开销,并记清串行早停/批量随K两种相反响应 2026-10-20 22:55:24 +08:00
cbb ebd4c20a28 docs: 到达率上限框架(可拿区间0.5234→0.7773,全部是被拒的活路);#24 间隙进打分列入候选首位 2026-10-20 22:54:08 +08:00
cbb 00602f3f0b exp: #21定案——关闸后两段每格都不更差(碰撞步58.3→45.1),主因是候选塌缩35倍;安全层值25.4pp到达但净收益为正(纯策略无碰撞到达仅0.359) 2026-10-20 22:53:07 +08:00
cbb 04fe4a007b docs: 补 §9.2 记分板——碰撞/超VMAX 已达标,到达差41.8pp、行程超1.4倍、P99差2~3倍、刹停率估≈9.9%(判据互相拉扯,单格变好必须同报其他格) 2026-10-20 22:51:30 +08:00
cbb c9344599af exp: 多段推理代价实测(2段+5.97ms/4段+17.7ms/8段+42ms,B=1 K=8)——靠段数补偏差不进 20ms 预算 2026-10-20 22:50:41 +08:00
cbb b30c271896 exp+fix: 候选塌缩定案(steps=2 把K条候选抹平35倍)+z_scale反例;补 n_plans/brake_rate 核算§9.2刹停率;记录我在链式作业排队期间改库导致两臂未跑的事故 2026-10-20 22:48:51 +08:00
cbb 4597569dd8 exp: 轮次39——试候选数四档成本-收益曲线:到达0.402→0.562、刹车60.4→13.8、串行认证墙钟×5.1,碰撞全程0 2026-10-20 22:43:12 +08:00
cbb ea762a331f exp+fix: try3 反向档位(刹车+93%/到达-6.6pp)与 K16 构成试候选数的单调轴;reverse 指标补动步口径+可手算负对照 2026-10-20 22:42:11 +08:00
cbb c5fccf1e48 docs: 候选清单按实测重排——K=16 升到第1(正向),ep_len 降为负结论,ep_waste 补位 2026-10-20 22:38:47 +08:00
cbb 671f1bdc89 exp: 轮次39——K=16 正向结果:到达+3.9pp/时限+3.1pp/刹车-30%且碰撞仍0;仪表对表 1.575/6=0.2625 vs 离线预测0.247 2026-10-20 22:37:40 +08:00
cbb b2cf03016b exp: 轮次39(续)——四个新指标端到端到达产物(CPU冒烟,真实运动学);对backoff四臂预注册判读规则(转化率13%量级的两种解释) 2026-10-20 22:35:57 +08:00
cbb a159723e5b docs+exp: 第二次纠正换向分组——按与rollout同窗口重算后两组差不多(0.247全体/到达0.265/未到达0.233),换向是全局现象而非失败特征;给出backoff对照臂的可证伪预测0.247 2026-10-20 22:33:29 +08:00
cbb a34a3c0bb5 docs: 撤回换向分组结论(旧口径漏计停住再反向,净/行程与线上口径都给反向);len_w 的单调改写成噪声量级说明 2026-10-20 22:30:52 +08:00
cbb 585c50dbb9 exp: 轮次39(续)——ep_len 三臂:时限内单调+2.4pp 但行程比单调变差,负结论;改上 ep_waste 2026-10-20 22:28:45 +08:00
cbb 27414bfae7 fix+test: reverse_rate 口径改为换向(步,轴)对/活动(步,轴)对,与离线分解同分母;正对照改成可手算的 2/18 2026-10-20 22:28:10 +08:00
cbb 3e015b7485 feat+test: 换向率 reverse_rate 进闭环指标(按轴方向翻转/活动步,站住不重置),带正对照单测 2026-10-20 22:26:34 +08:00
cbb 078f7cd451 feat+test: select=ep_waste 白费比例惩罚(罚度按当前误差缩放);单测抓到我把净位移对时间轴求和写成了对轴求和(frac 恒 0) 2026-10-20 22:24:49 +08:00
cbb d632924446 exp: 轮次39(续)——行程超出2.4倍的成因是换向抖动(23.5%步换向、净位移只占44.5%);len_w=0.1 罚不动量级不匹配 2026-10-20 22:19:21 +08:00
cbb 95b55fe69d exp: 轮次39(续)——执行余量审计:91%执行点≥0.5mm但每题最险点中位仅0.029mm;到达题全拒0.88% vs 未到达22% 2026-10-20 22:13:44 +08:00
cbb 422fb8b72f exp+fix: 轮次39——backoff=0+cert_batch1 与轮次33 cap 逐项相同(重写批量分支无行为变化);修 backoff 指标被 eval_cl 显式键列表丢掉 2026-10-20 22:10:44 +08:00
cbb cd6913b136 feat+exp: 轮次39——候选档位开关 --z_scale 与行程惩罚 select=ep_len/--len_w(零权重与 endpoint 逐位相同,2 条机制单测) 2026-10-20 22:05:12 +08:00
cbb cad8bb44f0 exp: 轮次38(补)——steps=8 时限0.324/行程比1.87继续变好但到达仍0.41;顶部摘要刷新到当前口径并加候选清单 2026-10-20 21:59:19 +08:00
cbb f42d3d756f exp: 轮次38(补)——steps=4 末态误差0.135mm最优但仍被拒80次/题;失败分类证明缺口是走一半被冻住(63/109) 2026-10-20 21:57:02 +08:00
cbb b9548d6cb1 docs: 探索日志改为倒序——最新一轮在最上面(内容守恒断言:除说明行外一行不许多或丢) 2026-10-20 21:55:15 +08:00
cbb 2079164cac docs: 轮次38——改正我自己写的(B)假设:线上安全层只做点检不含位移界;并记下 DAgger 采集同样是一步口径 2026-10-20 21:52:46 +08:00
cbb e7d1a39519 exp: 轮次38——两段推理开环更贴老师、行程比更近1,但闭环到达降14.8pp:瓶颈移到安全层拒绝率 2026-10-20 21:51:54 +08:00
cbb 3b8682a345 feat: 目标写法开关 mf_target(mf/lin/sq/mid),默认 mf 且原地路径逐位不变;float32 接线用解析高斯场自证 2026-10-20 21:48:28 +08:00
cbb 78786881e7 test: 轮次37(补)——解析高斯场给目标写法做不动点判决:sq 权重只线性收敛(结构性少修一半),lin/mid 二次收敛 2026-10-20 21:44:50 +08:00
cbb a4cac354ea exp: 轮次37——K-MF 方案核查:Eq.7 抄法不动点不自洽(1.87×),一步输出比自身2段采样离老师远10倍 2026-10-20 21:38:40 +08:00
cbb 349814db7e exp+feat: 轮次36(续)——时间账证明限幅后的损失是"站住"不是巡航;全拒缩步顶上(backoff,默认关) 2026-10-20 21:25:47 +08:00
cbb f23f6fc93f exp: 轮次36——规划起点 r 分布实测,循环内共享 FK(#19) 在部署 r3 口径只值 0.03 ms/次,判掉 2026-10-20 21:16:27 +08:00
cbb ee7fe829ac fix+exp: 轮次35(补)——gaps/gm_groups 拒绝行数不符的 xf;撤回两次不存在的"合并调用"收益
- 探测脚本把认证点当成与特征无关的已知量,据此测出的 共享cum_xf −4.3ms / 合并一次调用 −8.1ms
  都不成立:真实顺序是 特征(q)→推理→候选→认证点,同一次规划内既不能共享 xf 也不能合并 gaps
  只有轮次34 已落地的 gm_groups 复用同姿态 xf(−3.4ms,22项指标逐位不变)是真的
- 守卫:xf 行数与 q 不符时抛错(之前会静默按别的行做宽相位,实测触发 CUDA device-side assert)
- 测试 34→35 项;check_parity 仍 PASS(2000样本,间隙差 2.52e-13 mm、碰撞布尔差 0、特征差 5.96e-08)
2026-10-20 21:06:35 +08:00
cbb 296cd17f98 exp: 轮次35——FP16/BF16与流水线复用都被实测否掉,f32认证需先抬eps到2e-4
- 显卡精度档(B=1,K=8,steps=1):推理 FP32 7.68 / FP16 8.31 / BF16 8.58 ms,整周期不变而FP16 P99 46.6→55.6;
  动作偏差 FP16 0.0050°、BF16 0.0377° ⇒ 该批量下不是算力受限,保持 FP32
- float32 认证:48段×9点×15组对的间隙差 max 1.32e-4 mm(有1例高估)→ 现 eps=1e-4 已被越界,要用需 ≥2e-4;
  判据结果两边一致(各24接受、0 仅f32安全、0 符号翻转),暂不放宽 dtype 守卫
- 流水线复用特征间隙:第一版42.1→31.8ms 但等价性检查不过(我取缓存行索引取错,差3.19mm);
  修正后只剩 −3.1ms 且缓存行与新算差 6.3e-5mm(不同 batch 的结合序)⇒ 放弃
- 顺带修掉轮次34日志里重复的章节标题
2026-10-20 21:01:04 +08:00
cbb 34019c1a34 perf+exp: 轮次34——复用cum_xf进库(22项指标逐位不变)、批量认证压最坏尾部(80→37ms)、FP16/BF16实测无收益
- 撤回一条自己的假收益:先前"合并几何查询→24.5ms"不成立。①第一版把 xf= 传给含5行的 gaps,
  只有第0行走完宽相位,认证点全部退回截顶40.0(少干活);②真实顺序 特征→推理→候选→认证,
  认证点依赖网络输出,故"特征间隙与认证点合并一次调用"实现上做不到
- 可实现并已落地:gm_groups(..., xf=) 复用 features 已算的 cum_xf,B=1 交错实测 P50 −3.4ms;
  256题重跑 22 项指标与轮次33 base 逐项相同
- 新增 --cert_batch(默认0不变):K条候选并成1次 gaps 调用。合成夹具(B=2)断言选择/轨迹/证书逐位一致,
  变异检查(换回错误索引)2项测试立即失败;256题重跑同样 22 项指标逐位相同
  实测交换:典型 33.5→37.6ms,最坏(前面候选被拒)80.2→37.1ms,P99 64.7→48.3ms
- FP16/BF16 实测不比 FP32 快(推理 7.68→8.31→8.58ms),整周期不变而 P99 更差,动作偏差 0.005°/0.038°
  → 小批量下不是算力受限,半精度不划算,推理保持 FP32
- 仍不达 20ms:下一刀是流水线复用(下次规划的特征间隙=本次已认证的末点),可整块省掉特征 ~13ms
- 测试 32→34 项
2026-10-20 20:53:43 +08:00
cbb 48cc566c3f exp: 轮次33——限幅实测要付5.1pp到达(57.4→52.3%);GPU真实周期36.7ms≈27Hz,瓶颈是重复几何而非推理
- 四组单变量对照(同256题同seed):base / inc_cap / gap_margin 0.5 / 两者同开
  限幅后 到达 0.5742→0.5234、time_ok 0.3906→0.2656、2s误差比 0.210→0.279、超VMAX 1.0→0.0、刹停几乎不变
  → 之前那部分到达率是超速换来的;损失在逼近末段,不在刹停
- 0.5mm 余量门只付 3 题(0.5742→0.5625);但 plans['gaps'] 在 0.5mm 截顶,5mm 护栏可达性需抬 cap 重算
- 前提更正:eval_cl 不传 steps、rollout 默认 steps=1(policy.py:156 一步生成),先前按 steps=16 得到的
  "当前配方 116ms≈8.6Hz" 作废;真实配方 36.68ms P50 / 49.17ms P99 ≈ 27.3Hz
- 归因更正:空算子 0.028ms、空 sync 0.005ms、encode 2.27ms → 不是启动/同步地板;
  单步推理仅 7.2ms 且 K=1→8 免费,周期里 ~27ms 是 cum_xf+宽相位的重复计算
- certify_uniform 挂上后 36.7→45.3ms(n=8)/49.6ms(n=16)
- kin_torch 补 a/b 形状守卫(脚本里广播不一致会算错 view),测试 30→31 项
2026-10-20 20:32:19 +08:00
cbb 6ecd33db0c exp: 轮次33(上)——实际执行速度做成一等指标并自证;默认路径逐位复现第30轮,256题全部超VMAX
- rollout 逐题记录 max|Δq|/STEP(1.0=VMAX)与每步速度变化比;eval_cl 汇总 p50/p95/max、over_vmax_rate
- 自证:用 round30_after trace 独立重算得 1.660004×VMAX、超速度占比 1.0,与新指标逐位一致
- 默认参数下 base 复现第30轮 after 的每个旧指标(0.57421875/0.390625/19.25/2.444952726/0.209975064 等)
- 新开关 inc_cap(反馈叠加后再按每轴 VMAX·DT 限幅)、gap_margin(余量门限+自动抬宽相位 cap,
  否则现 cap=0.5 会让 >0.5 的余量恒假);col 仍按 gap<=0 判真实碰撞,不与余量混用
- 只读核查:ik-policy.js:355 同样在 ±1·STEP 之后叠加反馈;JS 的 5 mm 余量是投影式护栏,非同机制
- 口径提醒:round30 plans['gaps'] 在 cap=0.5 截顶,不能据此算"≥1mm 占比";中位最小间隙 0.046 mm 可用
- 测试 26→30 项(限幅灵敏度、余量拒/受、cap 抬升生效)
2026-10-20 19:48:23 +08:00
cbb c6b46b8bb1 exp: 轮次32——均匀细分认证一次调用可证段内碰撞,界经720项检验未证伪,但P50≤20ms的档只能证出54~63%
- certify_uniform:固定 n 个子段一次 gaps 调用,判据与二分同源(子段界=整段界/n),证不出即拒
- 确定界反证:48段×121点×15组对=720项检验 0 违例;有信息量仅 61 项,最紧仍高出 0.035 mm
  (是"未能在真实运动上证伪",不是证明;浮点误差仍未形式化)
- 第180题 1.08-1.10s 漏检段在每个 n>=8 均判碰撞;二次加密(2n+1)反证 0 误放行
- 更正轮次31的"自适应cap无收益":旧公式 bound/2+eps 会把本可通过的子段钳成不可证;
  改为 bound+2eps 后交错实测决策不变、快 1.36~1.65x(n=8 13.13→9.68,n=128 98.46→59.76 ms)
- 负结论:只有 n<=16 能把认证压进 20 ms,但该档仅证出 26-30/48 根,其余必须刹停;
  成本=log(bound/间隙) 决定,故下一步要在反馈后限幅并让安全层要求正余量(现 cap=0.5 会截掉余量)
- 测试 23→26 项:n=5拒/n=6受的解析对照、cap_required 公式、n 张量类型门
2026-10-20 19:30:02 +08:00
cbb 6de085fd37 exp+fix: 轮次31——确定界连续认证抓到段内碰撞,但单段P50 22.9ms进不了20ms;自适应cap收益经交错复测撤回
- Kin.cert_lever 用三角不等式给全姿态位移界(替代 JS 随机采样×1.05),界量级 5.93–48.86 mm/整步
- Kin.certify_segments 批量前沿二分+每根查询预算:48 固定段中预算32判安全37/碰撞1/未知拒10,
  第180题1.08–1.10s漏检段以5次查询判碰撞;未知只拒不放
- 修 seg_seg_dist 第二条退化成点不投影(模型内退化胶囊686受影响);但7586个加密点的组最小间隙
  逐位不变、2000样本JS对拍仍 PASS → 不解释轮次30漏检、不改既有成绩
- 负结论:B=1 单段认证 P50 22.93/P90 58.43/P99 101.57 ms,432次中225次>20ms;
  自适应宽相位 cap 交错复测耗时无收益,先前1.6×为GPU顺序漂移,已在日志撤回
- 成本模型 L=ceil(log2(bound/(ga+gb)))、查询=2^L+1 与实测对齐(安全段2–17次,未知段33–65次)
- 新增8项段认证测试+1项回放测试(14→23项通过);变异实测证明张量 max_depth 回绕会误放行
2026-10-20 19:13:40 +08:00
cbb 95da49193f fix+exp: 轮次30——统一认证与执行限位,到达57.4%不变;加密回放仍检出段内碰撞 2026-10-20 17:26:20 +08:00
cbb 9eaff7341f exp: 轮次29——全拒后减半反馈到达55.1%,补齐无碰撞指标与首撞回放
512题无碰撞到达54.7%、碰撞1.8%;9次首撞均在J5限位且双精度复现。保留小样本消融,撤回未经实际调度验证的50Hz达标结论,附六项回归测试及完整配置结果。
2026-10-20 17:06:53 +08:00
cbb ce9edd7934 exp: 端点进度选择——commit2 到达 52.1%/time_ok 35.2%(n=512),ratio2s 0.343→0.285;附带 50Hz 饥饿实测
- select='endpoint'(候选块末态离目标最近)优于 consist:n=512 到达 +1.3pp、time_ok +6.3pp、ratio −0.058
- 负结论:safety_try 1/2(41.4/44.9%)、K=4(47.3%)、DLS 兜底(52.3%/碰撞+1.1pp)、增益调度(47.3%)
- JS Runner:endpoint 选择落地、冷启动跳前瞻;starveTicks 指标;commit2 平均空转 0.8–1.3 tick,commit3 可覆盖
- route40 endpoint:12/20 ok、13/20 到达、刹车 40.4%
2026-10-20 15:48:31 +08:00
cbb d977be321b exp+fix: commit2 增益重扫(gain2.2 到达 50.8%,n=512)+ 浏览器安全层三点修复(限位夹紧/部分前缀/离散认证)
- gain 1.8/2.2/2.5/2.8 = 50.4/52.0/49.6/47.7%(n=256),2.2 最佳;n=512 复核 50.8%/1.4% 碰撞
- 积分反馈与反馈隔次复用均为负结论(−4.0/−5.1 pp)
- JS:tick/候选投影夹 LIM(原越限后 inBox 永久拒绝→刹停);safety_partial 移植;segCert 开关(默认严格)
- bench nc10 --seg 0:刹车率 79.5→48.1%、planP50 56.1→33.5ms、ok 0→5/10
2026-10-20 14:23:59 +08:00
cbb 46fe24365b perf+exp(closed_loop): 解析雅可比 DLS(消除 float32 差分数值噪声)——commit3 到达 36.3→46.5%,commit2 49.2%(n=512),DLS n1 9.3→7.1ms
- Kin.jac 几何雅可比,与 autograd 逐项一致(FD 自身 rel 误差 3.58%)
- dls_steps(analytic=True) 默认;每步少 6 次批量 FK
- 新增 ml/eval/eval_cl.py(部署口径小规模评估)与 check_dls.py(对拍+延迟)
- 积分反馈 fb_ki 脚手架(默认 0,未启用)
2026-10-20 13:33:23 +08:00
cbb 7e99b333ea exp: 轮次25——实时节奏(commit3)准确率:候选平均29.7%/冻结编码器34.4%/commit4 28.9%,均低于基线36.3%;效率:ORT CPU推理3.9ms+gm_groups,单次规划~32ms,50Hz异步可行 2026-10-20 12:49:37 +08:00
cbb 79519b042c perf+exp: gm_groups 只算特征 8 组(数值一致,features 10.4→7.1ms);混合节奏负结论(执行反馈无提升);浏览器部署 dag2 ONNX + fbGain/commit 参数(bench 刹车 47% 待调);实时口径改为异步规划+tick 2026-10-20 12:38:56 +08:00
cbb 3b748c811c perf(closed_loop): DLS 批量雅可比(25→10-17ms,数值差≤0.013°)+ 单题安全层早停;实时评估:单次规划 40-80ms 超 50Hz 预算 2-4 倍;实时节奏下每3步 36.3%、每6步 14.8%(每步 42.2% 不可实时) 2026-10-20 12:20:31 +08:00
cbb 26eb0815c2 exp(dagger-deploy): 轮次22——冻结编码器微调(开环保住15.8mm vs 19.5)但部署到达41.8%仍低于dag2 43.8%;训练侧四种方法均未超基线,训练探索到此平台 2026-10-20 10:10:25 +08:00
cbb 7a8e5aab63 exp(dagger-deploy): 轮次21——DAgger-3(部署配置采集500题+15000步微调)负结论:部署口径 39.5% vs dag2 43.8%,开环退化到19.5mm;下一步试冻结编码器只调解码器 2026-10-20 09:41:44 +08:00
cbb bb919d33c9 exp(dagger-deploy): 轮次20——反馈蒸馏(17.7万样本+3000步微调)负结论:gain=0 时到达仅0.8%(反馈未内化),gain1.8 与基线持平(43.4 vs 43.8) 2026-10-20 08:42:29 +08:00
cbb ff160f576e exp(dagger-deploy): 轮次19——APG 修复两个既有 bug(_cat_gaps in-place、段边界 queue.detach 无梯度)后可跑,但碰撞铰链尺度失控(40万)且与部署形态不一致,暂不采用;转反馈蒸馏 2026-10-20 07:56:58 +08:00
cbb 5675159987 docs(探索日志): 分支清理记录——fb-mix 已并入 exp/dagger-deploy 后删除;abs-target 打 archive tag 后删远端分支 2026-10-20 07:40:16 +08:00
cbb 39c870c1cf exp(dagger-deploy): 轮次18收尾——n=512 gain1.8 到达42.2%/碰撞2.9%/ratio0.270/time_ok29.1%/870ms(历史最佳);保守版 gain1.5 40.8%/2.1%;探索日志统计更新 2026-10-20 07:23:16 +08:00
cbb 7be41cb1ad exp(dagger-deploy): 轮次17——每步规划下 gain1.8 到达 43.8%/碰撞1.6%/ratio0.216/time_ok28.9%(新最佳);gain2.2/3.0 时间效率更高但到达降、刹停暴涨(3.0:123次/题过冲) 2026-10-20 07:12:59 +08:00
cbb 6c2af53d18 exp(dagger-deploy): 轮次16——n=512 稳定:每步规划+部分前缀 到达40.8%/碰撞2.1%/ratio0.309/time_ok25.0%/852ms(历史最佳,较基线 0% +40.8pp) 2026-10-20 06:57:25 +08:00
cbb f5f394a4bf exp(dagger-deploy): 轮次15——每步规划(commit_n=1):到达 41.8%、time_ok 21.5%(+57%)、ratio 0.259、碰撞 2.3%、967ms(新历史最佳);修复 ok6 视图硬编码 2026-10-20 06:47:00 +08:00
cbb 76ac563d21 exp(dagger-deploy): 部分安全前缀(执行到首个不安全步)——刹停 27.4→8.6、到达 38.3%、碰撞 1.6%;新增 commit_n 参数(每步规划实验);更正 replan=empty 实为 r=0 规划非每步 2026-10-20 06:26:31 +08:00
cbb de009bd516 exp(dagger-deploy): 轮次12——n=512 稳定:gain1.5+每步重规划 到达33.4%/碰撞1.0%/ratio0.399/刹停28.1/738ms(历史最佳);gain1.2 保守版 32.6%/1.0%/18.6 刹停;监控页回写已验证 2026-10-20 05:51:11 +08:00
cbb 29f3887be1 feat(monitor): 控制台新增「闭环探索日志」卡片——/api/explore 读取 docs/探索日志.md,Edge headless 截图验证渲染正常(http://127.0.0.1:8100) 2026-10-20 05:35:42 +08:00
cbb fe48b4e777 exp(dagger-deploy): 轮次11——n=256 复核(前128题偏难):gain1.5+每步重规划 到达36.7%/碰撞1.6%/ratio0.323/刹停27.4/760ms(新最佳);gain1.0 更保守 31.6%/0.8% 2026-10-20 05:34:40 +08:00
cbb 4de5e03a0b exp(dagger-deploy): 轮次10——每步重规划下 gain1.5 达 28.9%/0.8%/0.411/刹停28.5/844ms(新最佳);gain1.0 碰撞 0.0% 但到达 22.7%;待 n=256 复核 2026-10-20 05:24:20 +08:00
cbb 5f2cbd5179 exp(dagger-deploy): 轮次9新历史最佳——每步重规划+gain1.2:到达 26.6%、碰撞 0.8%、ratio 0.453、刹停 20.6、845ms(K=16 无益淘汰) 2026-10-20 05:15:01 +08:00
cbb 2ff02eb9a8 exp(dagger-deploy): 轮次8——部署分布 DAgger 把刹停降 18-40%、时延 953→922ms,到达 22.7%(未破 23% 平台);历史最佳到达仍 dag1+gain1.2 23.4% 2026-10-20 05:05:47 +08:00
cbb dc27781a72 exp(dagger-deploy): 采集支持 fb_gain+safety(训练分布=部署分布);新增 base_dag2 配置(同 base) 2026-10-20 03:40:15 +08:00
cbb 8e5431c460 exp(fb-mix): 轮次7负结论——衰减增益到达 23.4→9.4%、刹停兜底碰撞 1.6→57.8%(绕过安全层);参数默认关闭,历史最佳仍为 gain1.2 无衰减无兜底(23.4%/1.6%/0.454/973ms) 2026-10-20 03:09:21 +08:00
cbb b06662c152 exp(fb-mix): 目标反馈混合(inc += gain·DLS 朝目标)——DAgger 模型 + gain 1.0 + 安全层 reach 20.3%/碰撞 2.3%(历史最佳,此前 0%);建立 docs/探索日志.md 2026-10-20 02:40:12 +08:00
106 changed files with 20088 additions and 89 deletions
+62
View File
@@ -0,0 +1,62 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 512,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round29_rows.json",
"out": "docs/experiment_round29.json",
"trace": "ml/runs/round29_trace.pt",
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "1fd72f71eaf8170b45782beede0d91544e1f7142e98c0642560af814382f01ef",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 512,
"n_ref": 512,
"success": 0.55078125,
"collision_free_success": 0.546875,
"time_ok_1p3": 0.361328125,
"collision_rate": 0.017578125,
"collision_steps_mean": 0.1015625,
"travel_ratio_median": 2.425084352493286,
"time_mean_s": 2.322056770324707,
"brakes_mean": 19.228515625,
"start_fail": 0.0,
"goal_ratio_2s": 0.25053170323371887,
"err_fail_med": 194.51763916015625,
"err_success_med": 0.1961677223443985,
"dls_share": 0.634765625,
"time_budget": "teacher×2(≥3 s)"
},
"simulation_wall_s": 488.4280448999925
}
+779
View File
@@ -0,0 +1,779 @@
{
"trace": "ml/runs/round29_trace.pt",
"n": 512,
"reported_collision_tasks": 9,
"replayed_first_hits32": 9,
"replayed_first_hits64": 9,
"scope": "Replay reported first hits only; same geometry kernel at float32/float64, not a full safety audit.",
"rows": [
{
"i": 21,
"task": {
"tid": 1223280991,
"id": "s0001_000564",
"cat": "A",
"mode": "pose",
"q0": [
178.767,
101.917,
25.283,
31.588,
-12.179,
-6.464
],
"T": [
320.779,
79.294,
350.853
],
"R": [
-0.5548626629953249,
-0.1382477148217311,
-0.820374910976869,
-0.29956278115972873,
-0.8867511636570162,
0.35204334093514156,
-0.7761375943462505,
0.44108949556693955,
0.4506112421399604
],
"exec_s": 2.86,
"travel": 581.023,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 5.659999847412109,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.35770511627197266,
-0.3957242965698242
],
"gap64_mm": [
0.5,
0.5,
0.3577231796451059,
-0.39572636491366353
],
"pair32": [
0,
0,
5,
5
],
"pair64": [
0,
0,
5,
5
],
"boundary_joints": [
5
],
"previous": [
139.78468322753906,
87.256591796875,
6.928672790527344,
103.78778839111328,
-94.0,
19.4688720703125
],
"endpoint": [
139.50450134277344,
87.4175796508789,
6.71871280670166,
104.29376983642578,
-94.0,
21.218488693237305
],
"dense_nsegments": 175,
"dense_gap64_min_mm": -0.39572636491366353
},
{
"i": 84,
"task": {
"tid": 1268963905,
"id": "s0002_000538",
"cat": "B",
"mode": "pose",
"q0": [
-49.198,
52.395,
108.796,
75.534,
82.302,
-121.823
],
"T": [
-85.062,
275.378,
888.929
],
"R": [
0.5139412462799992,
-0.4285630099475821,
-0.7431003578769356,
-0.5533754886400825,
-0.8275489878032067,
0.09454227286372051,
-0.6554692700230204,
0.36262435010704513,
-0.6624678231921397
],
"exec_s": 3.2600000000000002,
"travel": 349.09,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 5.980000019073486,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.030836105346679688,
-0.1565418243408203,
-0.11790847778320312
],
"gap64_mm": [
0.5,
0.030838235678215753,
-0.15655898804830848,
-0.11791701257236653
],
"pair32": [
0,
6,
6,
6
],
"pair64": [
0,
6,
6,
6
],
"boundary_joints": [
5
],
"previous": [
-69.87329864501953,
36.559112548828125,
2.094588279724121,
102.22724151611328,
89.0,
-212.1793212890625
],
"endpoint": [
-69.79582214355469,
37.351837158203125,
-0.033895254135131836,
102.45509338378906,
89.0,
-214.75440979003906
],
"dense_nsegments": 258,
"dense_gap64_min_mm": -0.16882067924099076
},
{
"i": 145,
"task": {
"tid": 593213945,
"id": "s0003_000414",
"cat": "B",
"mode": "pose",
"q0": [
-49.395,
84.783,
2.744,
14.841,
-86.783,
81.932
],
"T": [
5.391,
506.723,
383.367
],
"R": [
-0.5269859333114162,
-0.7554822816510317,
-0.38927156099983334,
0.6402732880654818,
-0.05172298162073713,
-0.7664038424760652,
0.5588702377848656,
-0.6531242265324508,
0.5109724082909718
],
"exec_s": 2.96,
"travel": 560.55,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 5.599999904632568,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.3180522918701172,
-0.19827747344970703
],
"gap64_mm": [
0.5,
0.5,
0.318071359587325,
-0.19825289671655533
],
"pair32": [
0,
0,
5,
5
],
"pair64": [
0,
0,
5,
5
],
"boundary_joints": [
5
],
"previous": [
-36.05080032348633,
49.852294921875,
22.054914474487305,
67.3380126953125,
-94.0,
79.87274932861328
],
"endpoint": [
-35.60316848754883,
48.9223747253418,
21.386226654052734,
67.87915802001953,
-94.0,
79.27398681640625
],
"dense_nsegments": 93,
"dense_gap64_min_mm": -0.19825289671655533
},
{
"i": 164,
"task": {
"tid": 1743026973,
"id": "s0003_000814",
"cat": "C",
"mode": "pos",
"q0": [
-65.982,
5.595,
-64.669,
-72.912,
85.732,
-86.377
],
"T": [
-189.354,
221.034,
302.457
],
"R": null,
"exec_s": 2.3000000000000003,
"travel": 306.824,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 3.0399999618530273,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.5,
-0.12672901153564453
],
"gap64_mm": [
0.5,
0.5,
0.5,
-0.12673094091899273
],
"pair32": [
0,
0,
0,
5
],
"pair64": [
0,
0,
0,
5
],
"boundary_joints": [
5
],
"previous": [
-33.6672248840332,
39.63850021362305,
-60.174774169921875,
-108.2870864868164,
88.27082061767578,
-74.56200408935547
],
"endpoint": [
-32.8936882019043,
39.478729248046875,
-58.639915466308594,
-107.65913391113281,
89.0,
-74.92655944824219
],
"dense_nsegments": 154,
"dense_gap64_min_mm": -0.12673094091899273
},
{
"i": 175,
"task": {
"tid": 444406422,
"id": "s0003_001100",
"cat": "B",
"mode": "pos",
"q0": [
-28.854,
43.33,
-137.874,
-6.895,
-88.001,
-43.745
],
"T": [
379.105,
293.88,
653.541
],
"R": null,
"exec_s": 2.58,
"travel": 465.057,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 0.8399999737739563,
"dls_it": 144,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.4698514938354492,
-0.6612262725830078,
-0.9359521865844727
],
"gap64_mm": [
0.5,
0.4698356780126254,
-0.6612412101671552,
-0.9359581587234
],
"pair32": [
0,
6,
6,
6
],
"pair64": [
0,
6,
6,
6
],
"boundary_joints": [
5
],
"previous": [
-42.48794937133789,
11.756612777709961,
-124.7530288696289,
-46.12489700317383,
-94.0,
-54.57075500488281
],
"endpoint": [
-42.73639678955078,
10.6148681640625,
-124.47537231445312,
-48.52891159057617,
-94.0,
-55.451263427734375
],
"dense_nsegments": 241,
"dense_gap64_min_mm": -0.9544276230224238
},
{
"i": 180,
"task": {
"tid": 737760595,
"id": "s0003_001280",
"cat": "B",
"mode": "pos",
"q0": [
41.213,
49.353,
-149.808,
-8.981,
-88.566,
83.45
],
"T": [
118.145,
2.733,
266.082
],
"R": null,
"exec_s": 1.78,
"travel": 228.67,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 1.1399999856948853,
"dls_it": 102,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.06517887115478516,
-0.0172576904296875,
0.013133049011230469
],
"gap64_mm": [
0.5,
0.06521150921177998,
-0.017227151210720493,
0.013145878955246104
],
"pair32": [
0,
5,
5,
5
],
"pair64": [
0,
5,
5,
5
],
"boundary_joints": [
5
],
"previous": [
1.8212896585464478,
-9.327469825744629,
-150.87704467773438,
-23.00735855102539,
-94.0,
93.73664855957031
],
"endpoint": [
1.3598560094833374,
-9.66404914855957,
-150.52992248535156,
-23.200042724609375,
-94.0,
92.69589233398438
],
"dense_nsegments": 105,
"dense_gap64_min_mm": -0.020246891242656773
},
{
"i": 215,
"task": {
"tid": 169730876,
"id": "s0004_000544",
"cat": "B",
"mode": "pos",
"q0": [
47.051,
-1.179,
-94.31,
-43.128,
67.067,
-119.867
],
"T": [
-142.696,
-139.159,
726.163
],
"R": null,
"exec_s": 2.16,
"travel": 461.684,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 3.5399999618530273,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.5,
-0.08817481994628906
],
"gap64_mm": [
0.5,
0.5,
0.5,
-0.08817155079043282
],
"pair32": [
0,
0,
0,
6
],
"pair64": [
0,
0,
0,
6
],
"boundary_joints": [
5
],
"previous": [
34.57734298706055,
32.23564910888672,
-71.76512908935547,
10.783411979675293,
88.44934844970703,
-105.16633605957031
],
"endpoint": [
34.31901931762695,
33.24732208251953,
-72.12022399902344,
10.171412467956543,
89.0,
-106.89080810546875
],
"dense_nsegments": 173,
"dense_gap64_min_mm": -0.08817155079043282
},
{
"i": 266,
"task": {
"tid": 458057184,
"id": "s0005_000271",
"cat": "B",
"mode": "pos",
"q0": [
44.394,
32.402,
-145.074,
-48.37,
-85.543,
13.576
],
"T": [
184.38,
-306.445,
433.207
],
"R": null,
"exec_s": 2.52,
"travel": 376.205,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 1.2200000286102295,
"dls_it": 304,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.2372283935546875,
-0.05915641784667969
],
"gap64_mm": [
0.5,
0.5,
0.23719947210205383,
-0.05918908805933398
],
"pair32": [
0,
0,
5,
5
],
"pair64": [
0,
0,
5,
5
],
"boundary_joints": [
5
],
"previous": [
20.49032974243164,
10.35391902923584,
-172.87489318847656,
-73.93492126464844,
-93.70915985107422,
14.725995063781738
],
"endpoint": [
20.34522819519043,
10.012239456176758,
-172.91363525390625,
-74.4600601196289,
-94.0,
13.266871452331543
],
"dense_nsegments": 146,
"dense_gap64_min_mm": -0.05918908805933398
},
{
"i": 325,
"task": {
"tid": 1206824904,
"id": "s0005_001755",
"cat": "B",
"mode": "pose",
"q0": [
-68.225,
58.481,
-31.386,
57.2,
-31.831,
-80.259
],
"T": [
30.805,
353.752,
661.419
],
"R": [
0.5493387160259536,
0.13571391775309405,
0.8245051289125273,
-0.09525700289583322,
-0.9701190077749987,
0.22314841283987508,
0.8301524429129026,
-0.2011239500451364,
-0.5199962290670785
],
"exec_s": 2.34,
"travel": 659.756,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 3.0999999046325684,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.3628082275390625,
0.004294395446777344,
-0.6861848831176758
],
"gap64_mm": [
0.5,
0.3628058862147938,
0.004307730814957722,
-0.686172816414107
],
"pair32": [
0,
18,
5,
5
],
"pair64": [
0,
18,
5,
5
],
"boundary_joints": [
5
],
"previous": [
-39.524147033691406,
54.68175506591797,
-18.574026107788086,
103.78845977783203,
-94.0,
-53.657958984375
],
"endpoint": [
-39.42676544189453,
55.778987884521484,
-18.88759994506836,
103.97470092773438,
-94.0,
-54.84250259399414
],
"dense_nsegments": 119,
"dense_gap64_min_mm": -0.686172816414107
}
]
}
+62
View File
@@ -0,0 +1,62 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round30_after_rows.json",
"out": "docs/experiment_round30_after.json",
"trace": "ml/runs/round30_after.pt",
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.57421875,
"collision_free_success": 0.57421875,
"time_ok_1p3": 0.390625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.4449527263641357,
"time_mean_s": 2.3076188564300537,
"brakes_mean": 19.25,
"start_fail": 0.0,
"goal_ratio_2s": 0.20997506380081177,
"err_fail_med": 229.68746948242188,
"err_success_med": 0.18899640440940857,
"dls_share": 0.625,
"time_budget": "teacher×2(≥3 s)"
},
"simulation_wall_s": 248.83432349999202
}
+62
View File
@@ -0,0 +1,62 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round30_before_rows.json",
"out": "docs/experiment_round30_before.json",
"trace": "ml/runs/round30_before.pt",
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.57421875,
"collision_free_success": 0.56640625,
"time_ok_1p3": 0.390625,
"collision_rate": 0.02734375,
"collision_steps_mean": 0.0625,
"travel_ratio_median": 2.4449527263641357,
"time_mean_s": 2.2993197441101074,
"brakes_mean": 19.23828125,
"start_fail": 0.0,
"goal_ratio_2s": 0.20997506380081177,
"err_fail_med": 229.68746948242188,
"err_success_med": 0.1950554996728897,
"dls_share": 0.625,
"time_budget": "teacher×2(≥3 s)"
},
"simulation_wall_s": 247.51454629999353
}
+880
View File
@@ -0,0 +1,880 @@
{
"trace": "ml/runs/round30_before.pt",
"n": 256,
"reported_collision_tasks": 7,
"replayed_first_hits32": 7,
"replayed_first_hits64": 7,
"scope": "Replay reported first hits only; same geometry kernel at float32/float64, not a full safety audit.",
"rows": [
{
"i": 21,
"task": {
"tid": 1223280991,
"id": "s0001_000564",
"cat": "A",
"mode": "pose",
"q0": [
178.767,
101.917,
25.283,
31.588,
-12.179,
-6.464
],
"T": [
320.779,
79.294,
350.853
],
"R": [
-0.5548626629953249,
-0.1382477148217311,
-0.820374910976869,
-0.29956278115972873,
-0.8867511636570162,
0.35204334093514156,
-0.7761375943462505,
0.44108949556693955,
0.4506112421399604
],
"exec_s": 2.86,
"travel": 581.023,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 5.659999847412109,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.35770511627197266,
-0.3957242965698242
],
"gap64_mm": [
0.5,
0.5,
0.3577231796451059,
-0.39572636491366353
],
"pair32": [
0,
0,
5,
5
],
"pair64": [
0,
0,
5,
5
],
"boundary_joints": [
5
],
"previous": [
139.78468322753906,
87.256591796875,
6.928672790527344,
103.78778839111328,
-94.0,
19.4688720703125
],
"endpoint": [
139.50450134277344,
87.4175796508789,
6.71871280670166,
104.29376983642578,
-94.0,
21.218488693237305
],
"dense_nsegments": 175,
"dense_gap64_min_mm": -0.39572636491366353,
"certificate": {
"plan_start_it": 282,
"step": 0,
"checked": true,
"endpoint": [
139.50450134277344,
87.4175796508789,
6.71871280670166,
104.29376983642578,
-95.717529296875,
21.218488693237305
],
"midpoint": [
139.64459228515625,
87.33708190917969,
6.823692798614502,
104.04077911376953,
-94.8587646484375,
20.34368133544922
],
"recorded_gap32_mm": [
0.1606760025024414,
0.5
],
"replayed_gap64_mm": [
0.16066912536394184,
0.5
],
"command_delta": [
-0.2801789343357086,
0.16098570823669434,
-0.20995977520942688,
0.5059784054756165,
-1.717526912689209,
1.7496168613433838
],
"clamped_reconstruction_max_abs_deg": 0.0,
"certified_vs_executed_max_abs_deg": 1.717529296875
}
},
{
"i": 84,
"task": {
"tid": 1268963905,
"id": "s0002_000538",
"cat": "B",
"mode": "pose",
"q0": [
-49.198,
52.395,
108.796,
75.534,
82.302,
-121.823
],
"T": [
-85.062,
275.378,
888.929
],
"R": [
0.5139412462799992,
-0.4285630099475821,
-0.7431003578769356,
-0.5533754886400825,
-0.8275489878032067,
0.09454227286372051,
-0.6554692700230204,
0.36262435010704513,
-0.6624678231921397
],
"exec_s": 3.2600000000000002,
"travel": 349.09,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 5.980000019073486,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.030836105346679688,
-0.1565418243408203,
-0.11790847778320312
],
"gap64_mm": [
0.5,
0.030838235678215753,
-0.15655898804830848,
-0.11791701257236653
],
"pair32": [
0,
6,
6,
6
],
"pair64": [
0,
6,
6,
6
],
"boundary_joints": [
5
],
"previous": [
-69.87329864501953,
36.559112548828125,
2.094588279724121,
102.22724151611328,
89.0,
-212.1793212890625
],
"endpoint": [
-69.79582214355469,
37.351837158203125,
-0.033895254135131836,
102.45509338378906,
89.0,
-214.75440979003906
],
"dense_nsegments": 258,
"dense_gap64_min_mm": -0.16882067924099076,
"certificate": {
"plan_start_it": 298,
"step": 0,
"checked": true,
"endpoint": [
-69.79582214355469,
37.351837158203125,
-0.033895254135131836,
102.45509338378906,
89.79981231689453,
-214.75440979003906
],
"midpoint": [
-69.83456420898438,
36.955474853515625,
1.0303465127944946,
102.34117126464844,
89.39990234375,
-213.4668731689453
],
"recorded_gap32_mm": [
0.5,
0.20721912384033203
],
"replayed_gap64_mm": [
0.5,
0.2071966639119509
],
"command_delta": [
0.07747504115104675,
0.7927232980728149,
-2.128483533859253,
0.22785267233848572,
0.7998088598251343,
-2.5750951766967773
],
"clamped_reconstruction_max_abs_deg": 0.0,
"certified_vs_executed_max_abs_deg": 0.7998123168945312
}
},
{
"i": 145,
"task": {
"tid": 593213945,
"id": "s0003_000414",
"cat": "B",
"mode": "pose",
"q0": [
-49.395,
84.783,
2.744,
14.841,
-86.783,
81.932
],
"T": [
5.391,
506.723,
383.367
],
"R": [
-0.5269859333114162,
-0.7554822816510317,
-0.38927156099983334,
0.6402732880654818,
-0.05172298162073713,
-0.7664038424760652,
0.5588702377848656,
-0.6531242265324508,
0.5109724082909718
],
"exec_s": 2.96,
"travel": 560.55,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 5.599999904632568,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.3180522918701172,
-0.19827747344970703
],
"gap64_mm": [
0.5,
0.5,
0.318071359587325,
-0.19825289671655533
],
"pair32": [
0,
0,
5,
5
],
"pair64": [
0,
0,
5,
5
],
"boundary_joints": [
5
],
"previous": [
-36.05080032348633,
49.852294921875,
22.054914474487305,
67.3380126953125,
-94.0,
79.87274932861328
],
"endpoint": [
-35.60316848754883,
48.9223747253418,
21.386226654052734,
67.87915802001953,
-94.0,
79.27398681640625
],
"dense_nsegments": 93,
"dense_gap64_min_mm": -0.19825289671655533,
"certificate": {
"plan_start_it": 278,
"step": 1,
"checked": true,
"endpoint": [
-35.60316848754883,
48.9223747253418,
21.3862247467041,
67.87915802001953,
-97.17477416992188,
79.27399444580078
],
"midpoint": [
-35.82698440551758,
49.387332916259766,
21.720569610595703,
67.60858154296875,
-96.70620727539062,
79.57337188720703
],
"recorded_gap32_mm": [
0.2614564895629883,
0.5
],
"replayed_gap64_mm": [
0.2614702651611598,
0.5
],
"command_delta": [
0.4476320445537567,
-0.929920494556427,
-0.6686887741088867,
0.5411425828933716,
-0.9371238946914673,
-0.5987589359283447
],
"clamped_reconstruction_max_abs_deg": 0.0,
"certified_vs_executed_max_abs_deg": 3.174774169921875
}
},
{
"i": 164,
"task": {
"tid": 1743026973,
"id": "s0003_000814",
"cat": "C",
"mode": "pos",
"q0": [
-65.982,
5.595,
-64.669,
-72.912,
85.732,
-86.377
],
"T": [
-189.354,
221.034,
302.457
],
"R": null,
"exec_s": 2.3000000000000003,
"travel": 306.824,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 3.0399999618530273,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.5,
-0.12672901153564453
],
"gap64_mm": [
0.5,
0.5,
0.5,
-0.12673094091899273
],
"pair32": [
0,
0,
0,
5
],
"pair64": [
0,
0,
0,
5
],
"boundary_joints": [
5
],
"previous": [
-33.6672248840332,
39.63850021362305,
-60.174774169921875,
-108.2870864868164,
88.27082061767578,
-74.56200408935547
],
"endpoint": [
-32.8936882019043,
39.478729248046875,
-58.639915466308594,
-107.65913391113281,
89.0,
-74.92655944824219
],
"dense_nsegments": 154,
"dense_gap64_min_mm": -0.12673094091899273,
"certificate": {
"plan_start_it": 150,
"step": 1,
"checked": true,
"endpoint": [
-32.89369201660156,
39.478729248046875,
-58.639915466308594,
-107.65913391113281,
89.33978271484375,
-74.92655944824219
],
"midpoint": [
-33.28045654296875,
39.55861282348633,
-59.407344818115234,
-107.97311401367188,
88.8052978515625,
-74.7442855834961
],
"recorded_gap32_mm": [
0.1356372833251953,
0.5
],
"replayed_gap64_mm": [
0.13560383338968585,
0.5
],
"command_delta": [
0.773534893989563,
-0.15977251529693604,
1.534859299659729,
0.6279491186141968,
1.068959355354309,
-0.3645569384098053
],
"clamped_reconstruction_max_abs_deg": 0.0,
"certified_vs_executed_max_abs_deg": 0.33978271484375
}
},
{
"i": 175,
"task": {
"tid": 444406422,
"id": "s0003_001100",
"cat": "B",
"mode": "pos",
"q0": [
-28.854,
43.33,
-137.874,
-6.895,
-88.001,
-43.745
],
"T": [
379.105,
293.88,
653.541
],
"R": null,
"exec_s": 2.58,
"travel": 465.057,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 0.8399999737739563,
"dls_it": 144,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.4698514938354492,
-0.6612262725830078,
-0.9359521865844727
],
"gap64_mm": [
0.5,
0.4698356780126254,
-0.6612412101671552,
-0.9359581587234
],
"pair32": [
0,
6,
6,
6
],
"pair64": [
0,
6,
6,
6
],
"boundary_joints": [
5
],
"previous": [
-42.48794937133789,
11.756612777709961,
-124.7530288696289,
-46.12489700317383,
-94.0,
-54.57075500488281
],
"endpoint": [
-42.73639678955078,
10.6148681640625,
-124.47537231445312,
-48.52891159057617,
-94.0,
-55.451263427734375
],
"dense_nsegments": 241,
"dense_gap64_min_mm": -0.9544276230224238,
"certificate": {
"plan_start_it": 40,
"step": 1,
"checked": true,
"endpoint": [
-42.73639678955078,
10.6148681640625,
-124.47537231445312,
-48.52891159057617,
-98.31655883789062,
-55.45126724243164
],
"midpoint": [
-42.61217498779297,
11.18574047088623,
-124.61420440673828,
-47.326904296875,
-97.59821319580078,
-55.011009216308594
],
"recorded_gap32_mm": [
0.5,
0.5
],
"replayed_gap64_mm": [
0.5,
0.5
],
"command_delta": [
-0.24844767153263092,
-1.1417450904846191,
0.27765607833862305,
-2.4040162563323975,
-1.4366930723190308,
-0.8805096745491028
],
"clamped_reconstruction_max_abs_deg": 0.0,
"certified_vs_executed_max_abs_deg": 4.316558837890625
}
},
{
"i": 180,
"task": {
"tid": 737760595,
"id": "s0003_001280",
"cat": "B",
"mode": "pos",
"q0": [
41.213,
49.353,
-149.808,
-8.981,
-88.566,
83.45
],
"T": [
118.145,
2.733,
266.082
],
"R": null,
"exec_s": 1.78,
"travel": 228.67,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 1.1399999856948853,
"dls_it": 102,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.06517887115478516,
-0.0172576904296875,
0.013133049011230469
],
"gap64_mm": [
0.5,
0.06521150921177998,
-0.017227151210720493,
0.013145878955246104
],
"pair32": [
0,
5,
5,
5
],
"pair64": [
0,
5,
5,
5
],
"boundary_joints": [
5
],
"previous": [
1.8212896585464478,
-9.327469825744629,
-150.87704467773438,
-23.00735855102539,
-94.0,
93.73664855957031
],
"endpoint": [
1.3598560094833374,
-9.66404914855957,
-150.52992248535156,
-23.200042724609375,
-94.0,
92.69589233398438
],
"dense_nsegments": 105,
"dense_gap64_min_mm": -0.020246891242656773,
"certificate": {
"plan_start_it": 56,
"step": 0,
"checked": true,
"endpoint": [
1.3598560094833374,
-9.66404914855957,
-150.52992248535156,
-23.200042724609375,
-95.86970520019531,
92.69589233398438
],
"midpoint": [
1.5905728340148926,
-9.495759010314941,
-150.70347595214844,
-23.103700637817383,
-94.93485260009766,
93.21627044677734
],
"recorded_gap32_mm": [
0.5,
0.20821666717529297
],
"replayed_gap64_mm": [
0.5,
0.20822553884000428
],
"command_delta": [
-0.46143364906311035,
-0.33657926321029663,
0.3471294939517975,
-0.19268345832824707,
-1.8697090148925781,
-1.0407572984695435
],
"clamped_reconstruction_max_abs_deg": 0.0,
"certified_vs_executed_max_abs_deg": 1.8697052001953125
}
},
{
"i": 215,
"task": {
"tid": 169730876,
"id": "s0004_000544",
"cat": "B",
"mode": "pos",
"q0": [
47.051,
-1.179,
-94.31,
-43.128,
67.067,
-119.867
],
"T": [
-142.696,
-139.159,
726.163
],
"R": null,
"exec_s": 2.16,
"travel": 461.684,
"reached": true,
"err": 0,
"split": "val"
},
"first_hit_s": 3.5399999618530273,
"dls_it": -1,
"point_order": [
"q0",
"previous",
"midpoint",
"endpoint"
],
"gap32_mm": [
0.5,
0.5,
0.5,
-0.08817481994628906
],
"gap64_mm": [
0.5,
0.5,
0.5,
-0.08817155079043282
],
"pair32": [
0,
0,
0,
6
],
"pair64": [
0,
0,
0,
6
],
"boundary_joints": [
5
],
"previous": [
34.57734298706055,
32.23564910888672,
-71.76512908935547,
10.783411979675293,
88.44934844970703,
-105.16633605957031
],
"endpoint": [
34.31901931762695,
33.24732208251953,
-72.12022399902344,
10.171412467956543,
89.0,
-106.89080810546875
],
"dense_nsegments": 173,
"dense_gap64_min_mm": -0.08817155079043282,
"certificate": {
"plan_start_it": 176,
"step": 0,
"checked": true,
"endpoint": [
34.31901931762695,
33.24732208251953,
-72.12022399902344,
10.171412467956543,
89.79435729980469,
-106.89080810546875
],
"midpoint": [
34.44818115234375,
32.741485595703125,
-71.94267272949219,
10.477412223815918,
89.12185668945312,
-106.02857208251953
],
"recorded_gap32_mm": [
0.2809743881225586,
0.5
],
"replayed_gap64_mm": [
0.28098007564065064,
0.5
],
"command_delta": [
-0.2583238482475281,
1.011674404144287,
-0.3550943434238434,
-0.6119998693466187,
1.3450126647949219,
-1.7244750261306763
],
"clamped_reconstruction_max_abs_deg": 0.0,
"certified_vs_executed_max_abs_deg": 0.7943572998046875
}
}
]
}
+65
View File
@@ -0,0 +1,65 @@
{
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"same_config_except_output_paths": true,
"instrumentation_vs_round29_first_batch_max_abs_deg": 0.0,
"reached_only_after": [],
"reached_only_before": [],
"collision_tasks_before": [
21,
84,
145,
164,
175,
180,
215
],
"collision_tasks_after": [],
"statistics": {
"before": {
"active_certified_steps": 34069,
"certificate_endpoint_mismatch_gt_0p001deg": 5298,
"certificate_endpoint_max_abs_deg": 7.587158203125,
"certificate_midpoint_max_abs_deg": 5.78558349609375,
"uncertified_moving_steps": 0,
"executed_speed_ratio_max": 1.660003662109375,
"executed_speed_limit_violating_tasks": 256,
"executed_speed_max_deg_s": [
99.6002197265625,
99.60002899169922,
149.40032958984375,
149.400146484375,
199.20005798339844,
298.80029296875
],
"executed_travel_ratio_median_success": 2.4250845909118652,
"commanded_travel_ratio_median_success": 2.4449527263641357
},
"after": {
"active_certified_steps": 34107,
"certificate_endpoint_mismatch_gt_0p001deg": 0,
"certificate_endpoint_max_abs_deg": 0.0,
"certificate_midpoint_max_abs_deg": 0.0,
"uncertified_moving_steps": 0,
"executed_speed_ratio_max": 1.660003662109375,
"executed_speed_limit_violating_tasks": 256,
"executed_speed_max_deg_s": [
99.6002197265625,
99.60002899169922,
149.40032958984375,
149.400146484375,
199.20005798339844,
298.80029296875
],
"executed_travel_ratio_median_success": 2.4250845909118652,
"commanded_travel_ratio_median_success": 2.4449527263641357
}
},
"cpu_prediction_microbenchmark": {
"scope": "B=1, commit=2, 100 warmups then 1000 serial calls, CPU one thread; not full planning latency",
"before_p50_ms": 0.0388,
"before_p99_ms": 0.069102,
"after_p50_ms": 0.0518,
"after_p99_ms": 0.093933
}
}
+485
View File
@@ -0,0 +1,485 @@
{
"trace": "ml/runs/round30_after.pt",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"indices": [
0,
21,
84,
128,
145,
164,
175,
180,
197,
215,
224,
255
],
"max_step_deg": 0.05,
"dtype": "float64",
"device": "cuda",
"scope": "Executed trajectory through each task deadline or arrival, including initial state; finite sampling, not continuous certification.",
"collision_tasks": 1,
"rows": [
{
"i": 0,
"task": {
"tid": 919549409,
"id": "s0001_000001",
"cat": "B",
"mode": "pos",
"q0": [
-129.897,
46.68,
43.494,
-97.461,
-85.102,
-139.71
],
"T": [
-116.172,
268.408,
179.282
],
"R": null,
"exec_s": 3.48,
"travel": 345.324,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 174,
"sampled_points": 6211,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.02673023799951224,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 21,
"task": {
"tid": 1223280991,
"id": "s0001_000564",
"cat": "A",
"mode": "pose",
"q0": [
178.767,
101.917,
25.283,
31.588,
-12.179,
-6.464
],
"T": [
320.779,
79.294,
350.853
],
"R": [
-0.5548626629953249,
-0.1382477148217311,
-0.820374910976869,
-0.29956278115972873,
-0.8867511636570162,
0.35204334093514156,
-0.7761375943462505,
0.44108949556693955,
0.4506112421399604
],
"exec_s": 2.86,
"travel": 581.023,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 286,
"sampled_points": 6059,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.009057896844284485,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 84,
"task": {
"tid": 1268963905,
"id": "s0002_000538",
"cat": "B",
"mode": "pose",
"q0": [
-49.198,
52.395,
108.796,
75.534,
82.302,
-121.823
],
"T": [
-85.062,
275.378,
888.929
],
"R": [
0.5139412462799992,
-0.4285630099475821,
-0.7431003578769356,
-0.5533754886400825,
-0.8275489878032067,
0.09454227286372051,
-0.6554692700230204,
0.36262435010704513,
-0.6624678231921397
],
"exec_s": 3.2600000000000002,
"travel": 349.09,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 326,
"sampled_points": 6251,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.006206321604070197,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 128,
"task": {
"tid": 408952743,
"id": "s0002_001588",
"cat": "A",
"mode": "pos",
"q0": [
-153.539,
100.454,
108.434,
3.379,
70.254,
-179.848
],
"T": [
-324.009,
70.778,
919.477
],
"R": null,
"exec_s": 0.8200000000000001,
"travel": 121.056,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 63,
"sampled_points": 2403,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.5,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 145,
"task": {
"tid": 593213945,
"id": "s0003_000414",
"cat": "B",
"mode": "pose",
"q0": [
-49.395,
84.783,
2.744,
14.841,
-86.783,
81.932
],
"T": [
5.391,
506.723,
383.367
],
"R": [
-0.5269859333114162,
-0.7554822816510317,
-0.38927156099983334,
0.6402732880654818,
-0.05172298162073713,
-0.7664038424760652,
0.5588702377848656,
-0.6531242265324508,
0.5109724082909718
],
"exec_s": 2.96,
"travel": 560.55,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 296,
"sampled_points": 4509,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.002145835308116517,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 164,
"task": {
"tid": 1743026973,
"id": "s0003_000814",
"cat": "C",
"mode": "pos",
"q0": [
-65.982,
5.595,
-64.669,
-72.912,
85.732,
-86.377
],
"T": [
-189.354,
221.034,
302.457
],
"R": null,
"exec_s": 2.3000000000000003,
"travel": 306.824,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 230,
"sampled_points": 3985,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.008857213584009926,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 175,
"task": {
"tid": 444406422,
"id": "s0003_001100",
"cat": "B",
"mode": "pos",
"q0": [
-28.854,
43.33,
-137.874,
-6.895,
-88.001,
-43.745
],
"T": [
379.105,
293.88,
653.541
],
"R": null,
"exec_s": 2.58,
"travel": 465.057,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 143,
"sampled_points": 5547,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.18812628629569694,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 180,
"task": {
"tid": 737760595,
"id": "s0003_001280",
"cat": "B",
"mode": "pos",
"q0": [
41.213,
49.353,
-149.808,
-8.981,
-88.566,
83.45
],
"T": [
118.145,
2.733,
266.082
],
"R": null,
"exec_s": 1.78,
"travel": 228.67,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 95,
"sampled_points": 3153,
"initial_gap64_mm": 0.5,
"min_gap64_mm": -0.1492959159660998,
"collision_segments": 1,
"first_collision_s": 1.0915789473684212
},
{
"i": 197,
"task": {
"tid": 1433345185,
"id": "s0004_000020",
"cat": "B",
"mode": "pose",
"q0": [
20.112,
-20.013,
-177.85,
32.746,
-70.888,
-30.111
],
"T": [
-288.364,
63.606,
672.54
],
"R": [
-0.5335375732231524,
-0.7509294450860695,
0.38915630081225366,
-0.8443344656004893,
0.4997538915602813,
-0.19324947107169785,
-0.049365657681080755,
-0.4316839311036288,
-0.9006730902323173
],
"exec_s": 2.14,
"travel": 634.022,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 214,
"sampled_points": 4641,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.0010684324191032601,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 215,
"task": {
"tid": 169730876,
"id": "s0004_000544",
"cat": "B",
"mode": "pos",
"q0": [
47.051,
-1.179,
-94.31,
-43.128,
67.067,
-119.867
],
"T": [
-142.696,
-139.159,
726.163
],
"R": null,
"exec_s": 2.16,
"travel": 461.684,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 216,
"sampled_points": 6605,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.2112382958686112,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 224,
"task": {
"tid": 1884410379,
"id": "s0004_000721",
"cat": "A",
"mode": "pose",
"q0": [
-127.447,
7.845,
-124.228,
-20.968,
-21.51,
-35.505
],
"T": [
-233.158,
-59.78,
648.987
],
"R": [
0.3964618999442966,
-0.020495209950317686,
0.9178223729358808,
-0.8179090164279511,
0.4461640898622928,
0.3632663564978371,
-0.41694460392049726,
-0.8947164641865291,
0.1601238457417738
],
"exec_s": 1.48,
"travel": 356.988,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 128,
"sampled_points": 4707,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.0041216155493710716,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 255,
"task": {
"tid": 712677274,
"id": "s0004_001686",
"cat": "C",
"mode": "pos",
"q0": [
-65.548,
71.865,
27.462,
-75.048,
60.325,
151.872
],
"T": [
-53.154,
50.204,
397.489
],
"R": null,
"exec_s": 1.84,
"travel": 238.182,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 184,
"sampled_points": 2495,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.004616787795093558,
"collision_segments": 0,
"first_collision_s": null
}
],
"audit_wall_s": 15.056756100006169
}
+485
View File
@@ -0,0 +1,485 @@
{
"trace": "ml/runs/round30_before.pt",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"indices": [
0,
21,
84,
128,
145,
164,
175,
180,
197,
215,
224,
255
],
"max_step_deg": 0.05,
"dtype": "float64",
"device": "cuda",
"scope": "Executed trajectory through each task deadline or arrival, including initial state; finite sampling, not continuous certification.",
"collision_tasks": 7,
"rows": [
{
"i": 0,
"task": {
"tid": 919549409,
"id": "s0001_000001",
"cat": "B",
"mode": "pos",
"q0": [
-129.897,
46.68,
43.494,
-97.461,
-85.102,
-139.71
],
"T": [
-116.172,
268.408,
179.282
],
"R": null,
"exec_s": 3.48,
"travel": 345.324,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 174,
"sampled_points": 6211,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.02673023799951224,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 21,
"task": {
"tid": 1223280991,
"id": "s0001_000564",
"cat": "A",
"mode": "pose",
"q0": [
178.767,
101.917,
25.283,
31.588,
-12.179,
-6.464
],
"T": [
320.779,
79.294,
350.853
],
"R": [
-0.5548626629953249,
-0.1382477148217311,
-0.820374910976869,
-0.29956278115972873,
-0.8867511636570162,
0.35204334093514156,
-0.7761375943462505,
0.44108949556693955,
0.4506112421399604
],
"exec_s": 2.86,
"travel": 581.023,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 286,
"sampled_points": 6099,
"initial_gap64_mm": 0.5,
"min_gap64_mm": -0.39572636491366353,
"collision_segments": 2,
"first_collision_s": 5.655
},
{
"i": 84,
"task": {
"tid": 1268963905,
"id": "s0002_000538",
"cat": "B",
"mode": "pose",
"q0": [
-49.198,
52.395,
108.796,
75.534,
82.302,
-121.823
],
"T": [
-85.062,
275.378,
888.929
],
"R": [
0.5139412462799992,
-0.4285630099475821,
-0.7431003578769356,
-0.5533754886400825,
-0.8275489878032067,
0.09454227286372051,
-0.6554692700230204,
0.36262435010704513,
-0.6624678231921397
],
"exec_s": 3.2600000000000002,
"travel": 349.09,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 326,
"sampled_points": 6037,
"initial_gap64_mm": 0.5,
"min_gap64_mm": -0.16878710314368206,
"collision_segments": 3,
"first_collision_s": 5.961153846153847
},
{
"i": 128,
"task": {
"tid": 408952743,
"id": "s0002_001588",
"cat": "A",
"mode": "pos",
"q0": [
-153.539,
100.454,
108.434,
3.379,
70.254,
-179.848
],
"T": [
-324.009,
70.778,
919.477
],
"R": null,
"exec_s": 0.8200000000000001,
"travel": 121.056,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 63,
"sampled_points": 2403,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.5,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 145,
"task": {
"tid": 593213945,
"id": "s0003_000414",
"cat": "B",
"mode": "pose",
"q0": [
-49.395,
84.783,
2.744,
14.841,
-86.783,
81.932
],
"T": [
5.391,
506.723,
383.367
],
"R": [
-0.5269859333114162,
-0.7554822816510317,
-0.38927156099983334,
0.6402732880654818,
-0.05172298162073713,
-0.7664038424760652,
0.5588702377848656,
-0.6531242265324508,
0.5109724082909718
],
"exec_s": 2.96,
"travel": 560.55,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 296,
"sampled_points": 4489,
"initial_gap64_mm": 0.5,
"min_gap64_mm": -0.19825289671655533,
"collision_segments": 5,
"first_collision_s": 5.597
},
{
"i": 164,
"task": {
"tid": 1743026973,
"id": "s0003_000814",
"cat": "C",
"mode": "pos",
"q0": [
-65.982,
5.595,
-64.669,
-72.912,
85.732,
-86.377
],
"T": [
-189.354,
221.034,
302.457
],
"R": null,
"exec_s": 2.3000000000000003,
"travel": 306.824,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 230,
"sampled_points": 3865,
"initial_gap64_mm": 0.5,
"min_gap64_mm": -0.12673094091895543,
"collision_segments": 4,
"first_collision_s": 3.0387500000000003
},
{
"i": 175,
"task": {
"tid": 444406422,
"id": "s0003_001100",
"cat": "B",
"mode": "pos",
"q0": [
-28.854,
43.33,
-137.874,
-6.895,
-88.001,
-43.745
],
"T": [
379.105,
293.88,
653.541
],
"R": null,
"exec_s": 2.58,
"travel": 465.057,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 145,
"sampled_points": 5769,
"initial_gap64_mm": 0.5,
"min_gap64_mm": -0.954427674326439,
"collision_segments": 2,
"first_collision_s": 0.8236
},
{
"i": 180,
"task": {
"tid": 737760595,
"id": "s0003_001280",
"cat": "B",
"mode": "pos",
"q0": [
41.213,
49.353,
-149.808,
-8.981,
-88.566,
83.45
],
"T": [
118.145,
2.733,
266.082
],
"R": null,
"exec_s": 1.78,
"travel": 228.67,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 103,
"sampled_points": 3385,
"initial_gap64_mm": 0.5,
"min_gap64_mm": -0.1492959159660998,
"collision_segments": 2,
"first_collision_s": 1.0915789473684212
},
{
"i": 197,
"task": {
"tid": 1433345185,
"id": "s0004_000020",
"cat": "B",
"mode": "pose",
"q0": [
20.112,
-20.013,
-177.85,
32.746,
-70.888,
-30.111
],
"T": [
-288.364,
63.606,
672.54
],
"R": [
-0.5335375732231524,
-0.7509294450860695,
0.38915630081225366,
-0.8443344656004893,
0.4997538915602813,
-0.19324947107169785,
-0.049365657681080755,
-0.4316839311036288,
-0.9006730902323173
],
"exec_s": 2.14,
"travel": 634.022,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 214,
"sampled_points": 4317,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.0010684324191032601,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 215,
"task": {
"tid": 169730876,
"id": "s0004_000544",
"cat": "B",
"mode": "pos",
"q0": [
47.051,
-1.179,
-94.31,
-43.128,
67.067,
-119.867
],
"T": [
-142.696,
-139.159,
726.163
],
"R": null,
"exec_s": 2.16,
"travel": 461.684,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 216,
"sampled_points": 6341,
"initial_gap64_mm": 0.5,
"min_gap64_mm": -0.08817155079042394,
"collision_segments": 3,
"first_collision_s": 3.538888888888889
},
{
"i": 224,
"task": {
"tid": 1884410379,
"id": "s0004_000721",
"cat": "A",
"mode": "pose",
"q0": [
-127.447,
7.845,
-124.228,
-20.968,
-21.51,
-35.505
],
"T": [
-233.158,
-59.78,
648.987
],
"R": [
0.3964618999442966,
-0.020495209950317686,
0.9178223729358808,
-0.8179090164279511,
0.4461640898622928,
0.3632663564978371,
-0.41694460392049726,
-0.8947164641865291,
0.1601238457417738
],
"exec_s": 1.48,
"travel": 356.988,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 128,
"sampled_points": 4707,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.0041216155493710716,
"collision_segments": 0,
"first_collision_s": null
},
{
"i": 255,
"task": {
"tid": 712677274,
"id": "s0004_001686",
"cat": "C",
"mode": "pos",
"q0": [
-65.548,
71.865,
27.462,
-75.048,
60.325,
151.872
],
"T": [
-53.154,
50.204,
397.489
],
"R": null,
"exec_s": 1.84,
"travel": 238.182,
"reached": true,
"err": 0,
"split": "val"
},
"steps": 184,
"sampled_points": 2495,
"initial_gap64_mm": 0.5,
"min_gap64_mm": 0.004616787795093558,
"collision_segments": 0,
"first_collision_s": null
}
],
"audit_wall_s": 14.869853199998033
}
@@ -0,0 +1,71 @@
{
"task_index": 180,
"task": {
"tid": 737760595,
"id": "s0003_001280",
"cat": "B",
"mode": "pos",
"q0": [
41.213,
49.353,
-149.808,
-8.981,
-88.566,
83.45
],
"T": [
118.145,
2.733,
266.082
],
"R": null,
"exec_s": 1.78,
"travel": 228.67,
"reached": true,
"err": 0,
"split": "val"
},
"segment_start_it": 54,
"start_s": 1.08,
"end_s": 1.1,
"original_discrete_col": 0,
"certified": true,
"recorded_endpoint_midpoint_gap32_mm": [
0.0651998519897461,
0.11720466613769531
],
"previous_midpoint_endpoint_gap64_mm": [
0.5,
0.11723191087430074,
0.06521150921177998
],
"previous": [
3.0118656158447266,
-7.4926042556762695,
-151.498291015625,
-22.7498836517334,
-94.0,
93.50477600097656
],
"endpoint": [
1.8212896585464478,
-9.327469825744629,
-150.87704467773438,
-23.00735855102539,
-94.0,
93.73664855957031
],
"dense_max_step_deg": 0.01,
"dense_points": 185,
"min_gap64_mm": -0.14927288174659914,
"min_at_fraction": 0.7663043478260869,
"min_at_q": [
2.09952208334985,
-8.898669719696045,
-151.0222272458284,
-22.947187786516935,
-94.0,
93.68246095076852
],
"scope": "One executed segment; finite sampling demonstrates a collision between certified checkpoints."
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,658 @@
{
"segments": 48,
"kin_fp": "2ebcbf17",
"root_gap_cap_mm": 20.0,
"formula": "L = ceil(log2(bound_pair/(ga+gb)))\uff0c\u67e5\u8be2\u6570 = 2^L + 1\uff1bbound_pair \u53d6\u6700\u7d27\u7ec4\u5bf9\uff0c\u4e0d\u7528\u5168\u7ec4\u5bf9\u6700\u5927\u503c",
"levels_needed_by_status": {
"safe": [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
2,
2,
2,
2,
3,
3,
3,
3,
3,
4,
4,
4,
4,
4
],
"unresolved": [
5,
5,
5,
5,
5,
6,
6,
6,
6,
6
],
"collision": [
4
]
},
"queries_needed_safe": [
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
3,
3,
3,
5,
5,
5,
5,
9,
9,
9,
9,
9,
17,
17,
17,
17,
17
],
"model_vs_measured_max_excess": 20,
"unresolved_needed_queries": [
33,
33,
33,
33,
33,
65,
65,
65,
65,
65
],
"collision_dense_check": [
{
"i": 180,
"start_it": 54,
"status": "collision",
"tight_group_pair": 5,
"bound_pair_mm": 29.09,
"endpoint_gap_sum_mm": 1.98854,
"levels_needed": 4,
"queries_needed": 17,
"queries_used_batch32": 5
}
],
"note": "\u6a21\u578b\u662f\u201c\u754c\u53ea\u968f\u4e8c\u5206\u51cf\u534a\u201d\u4e0b\u7684\u4e0b\u754c\uff1b\u5b9e\u6d4b\u67e5\u8be2\u53ef\u80fd\u66f4\u5c0f\uff08\u591a\u5c42\u91cc\u6709\u7684\u7ec4\u5bf9\u5148\u6ee1\u8db3\uff09\u6216\u66f4\u5927\uff08\u78b0\u649e\u6bb5\u63d0\u524d\u7ec8\u6b62\uff09\u3002",
"rows": [
{
"i": 0,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 2.382,
"endpoint_gap_sum_mm": 17.77168,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 0,
"start_it": 8,
"status": "unresolved",
"tight_group_pair": 13,
"bound_pair_mm": 8.2833,
"endpoint_gap_sum_mm": 0.25216,
"levels_needed": 6,
"queries_needed": 65,
"queries_used_batch32": 17
},
{
"i": 0,
"start_it": 91,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 2.459,
"endpoint_gap_sum_mm": 14.45459,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 0,
"start_it": 173,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 6.8776,
"endpoint_gap_sum_mm": 15.48695,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 21,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 4.7095,
"endpoint_gap_sum_mm": 12.81844,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 21,
"start_it": 100,
"status": "unresolved",
"tight_group_pair": 18,
"bound_pair_mm": 1.3371,
"endpoint_gap_sum_mm": 0.03365,
"levels_needed": 6,
"queries_needed": 65,
"queries_used_batch32": 17
},
{
"i": 21,
"start_it": 127,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 1.5104,
"endpoint_gap_sum_mm": 0.68046,
"levels_needed": 2,
"queries_needed": 5,
"queries_used_batch32": 4
},
{
"i": 21,
"start_it": 282,
"status": "safe",
"tight_group_pair": 5,
"bound_pair_mm": 3.5692,
"endpoint_gap_sum_mm": 1.72327,
"levels_needed": 2,
"queries_needed": 5,
"queries_used_batch32": 4
},
{
"i": 84,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 11.7042,
"endpoint_gap_sum_mm": 13.79742,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 84,
"start_it": 170,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 4.9891,
"endpoint_gap_sum_mm": 0.3999,
"levels_needed": 4,
"queries_needed": 17,
"queries_used_batch32": 18
},
{
"i": 84,
"start_it": 234,
"status": "unresolved",
"tight_group_pair": 18,
"bound_pair_mm": 7.5939,
"endpoint_gap_sum_mm": 0.28698,
"levels_needed": 5,
"queries_needed": 33,
"queries_used_batch32": 31
},
{
"i": 84,
"start_it": 325,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 3.5738,
"endpoint_gap_sum_mm": 10.95173,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 128,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 4.4648,
"endpoint_gap_sum_mm": 16.52712,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 128,
"start_it": 31,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 2.1155,
"endpoint_gap_sum_mm": 14.24909,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 128,
"start_it": 62,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 0.3619,
"endpoint_gap_sum_mm": 12.62201,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 145,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 1.5691,
"endpoint_gap_sum_mm": 11.60111,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 145,
"start_it": 32,
"status": "safe",
"tight_group_pair": 4,
"bound_pair_mm": 4.6053,
"endpoint_gap_sum_mm": 0.67129,
"levels_needed": 3,
"queries_needed": 9,
"queries_used_batch32": 28
},
{
"i": 145,
"start_it": 138,
"status": "safe",
"tight_group_pair": 4,
"bound_pair_mm": 9.6062,
"endpoint_gap_sum_mm": 1.11765,
"levels_needed": 4,
"queries_needed": 17,
"queries_used_batch32": 15
},
{
"i": 145,
"start_it": 294,
"status": "safe",
"tight_group_pair": 5,
"bound_pair_mm": 8.2956,
"endpoint_gap_sum_mm": 0.61574,
"levels_needed": 4,
"queries_needed": 17,
"queries_used_batch32": 17
},
{
"i": 164,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 12.0298,
"endpoint_gap_sum_mm": 11.50625,
"levels_needed": 1,
"queries_needed": 3,
"queries_used_batch32": 3
},
{
"i": 164,
"start_it": 84,
"status": "safe",
"tight_group_pair": 5,
"bound_pair_mm": 18.0143,
"endpoint_gap_sum_mm": 1.7857,
"levels_needed": 4,
"queries_needed": 17,
"queries_used_batch32": 18
},
{
"i": 164,
"start_it": 182,
"status": "unresolved",
"tight_group_pair": 5,
"bound_pair_mm": 14.1522,
"endpoint_gap_sum_mm": 0.38976,
"levels_needed": 6,
"queries_needed": 65,
"queries_used_batch32": 17
},
{
"i": 164,
"start_it": 227,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 5.6457,
"endpoint_gap_sum_mm": 1.13586,
"levels_needed": 3,
"queries_needed": 9,
"queries_used_batch32": 10
},
{
"i": 175,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 6.5456,
"endpoint_gap_sum_mm": 15.18067,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 175,
"start_it": 46,
"status": "unresolved",
"tight_group_pair": 6,
"bound_pair_mm": 30.8668,
"endpoint_gap_sum_mm": 1.26529,
"levels_needed": 5,
"queries_needed": 33,
"queries_used_batch32": 32
},
{
"i": 175,
"start_it": 75,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 17.8885,
"endpoint_gap_sum_mm": 10.74989,
"levels_needed": 1,
"queries_needed": 3,
"queries_used_batch32": 3
},
{
"i": 175,
"start_it": 142,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 0.8185,
"endpoint_gap_sum_mm": 10.77208,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 180,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 3.4654,
"endpoint_gap_sum_mm": 14.04707,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 180,
"start_it": 14,
"status": "unresolved",
"tight_group_pair": 4,
"bound_pair_mm": 17.6609,
"endpoint_gap_sum_mm": 0.46562,
"levels_needed": 6,
"queries_needed": 65,
"queries_used_batch32": 17
},
{
"i": 180,
"start_it": 52,
"status": "safe",
"tight_group_pair": 5,
"bound_pair_mm": 27.7231,
"endpoint_gap_sum_mm": 3.97272,
"levels_needed": 3,
"queries_needed": 9,
"queries_used_batch32": 15
},
{
"i": 180,
"start_it": 54,
"status": "collision",
"tight_group_pair": 5,
"bound_pair_mm": 29.09,
"endpoint_gap_sum_mm": 1.98854,
"levels_needed": 4,
"queries_needed": 17,
"queries_used_batch32": 5
},
{
"i": 180,
"start_it": 94,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 1.1032,
"endpoint_gap_sum_mm": 12.22495,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 197,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 1.0839,
"endpoint_gap_sum_mm": 6.87225,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 197,
"start_it": 80,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 3.3325,
"endpoint_gap_sum_mm": 0.50053,
"levels_needed": 3,
"queries_needed": 9,
"queries_used_batch32": 29
},
{
"i": 197,
"start_it": 82,
"status": "unresolved",
"tight_group_pair": 18,
"bound_pair_mm": 5.7899,
"endpoint_gap_sum_mm": 0.16354,
"levels_needed": 6,
"queries_needed": 65,
"queries_used_batch32": 17
},
{
"i": 197,
"start_it": 211,
"status": "safe",
"tight_group_pair": 5,
"bound_pair_mm": 18.6183,
"endpoint_gap_sum_mm": 5.55945,
"levels_needed": 2,
"queries_needed": 5,
"queries_used_batch32": 11
},
{
"i": 215,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 2.4256,
"endpoint_gap_sum_mm": 12.47554,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 215,
"start_it": 104,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 4.7208,
"endpoint_gap_sum_mm": 14.00267,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 215,
"start_it": 178,
"status": "unresolved",
"tight_group_pair": 6,
"bound_pair_mm": 25.7963,
"endpoint_gap_sum_mm": 1.07014,
"levels_needed": 5,
"queries_needed": 33,
"queries_used_batch32": 30
},
{
"i": 215,
"start_it": 215,
"status": "safe",
"tight_group_pair": 6,
"bound_pair_mm": 9.2152,
"endpoint_gap_sum_mm": 8.57509,
"levels_needed": 1,
"queries_needed": 3,
"queries_used_batch32": 3
},
{
"i": 224,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 6.492,
"endpoint_gap_sum_mm": 10.02154,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 224,
"start_it": 52,
"status": "unresolved",
"tight_group_pair": 18,
"bound_pair_mm": 3.5989,
"endpoint_gap_sum_mm": 0.12354,
"levels_needed": 5,
"queries_needed": 33,
"queries_used_batch32": 32
},
{
"i": 224,
"start_it": 61,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 2.7788,
"endpoint_gap_sum_mm": 0.78961,
"levels_needed": 2,
"queries_needed": 5,
"queries_used_batch32": 5
},
{
"i": 224,
"start_it": 127,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 1.4884,
"endpoint_gap_sum_mm": 7.29024,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 255,
"start_it": 0,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 1.5332,
"endpoint_gap_sum_mm": 11.184,
"levels_needed": 0,
"queries_needed": 2,
"queries_used_batch32": 2
},
{
"i": 255,
"start_it": 25,
"status": "unresolved",
"tight_group_pair": 18,
"bound_pair_mm": 2.9831,
"endpoint_gap_sum_mm": 0.14423,
"levels_needed": 5,
"queries_needed": 33,
"queries_used_batch32": 29
},
{
"i": 255,
"start_it": 50,
"status": "safe",
"tight_group_pair": 4,
"bound_pair_mm": 7.2365,
"endpoint_gap_sum_mm": 0.61112,
"levels_needed": 4,
"queries_needed": 17,
"queries_used_batch32": 25
},
{
"i": 255,
"start_it": 181,
"status": "safe",
"tight_group_pair": 18,
"bound_pair_mm": 4.2961,
"endpoint_gap_sum_mm": 0.74979,
"levels_needed": 3,
"queries_needed": 9,
"queries_used_batch32": 12
}
]
}
File diff suppressed because it is too large Load Diff
+24
View File
@@ -0,0 +1,24 @@
{
"baseline_commit": "95da491",
"poses": "first 64 existing parity poses",
"n_poses": 64,
"kin_fp": "2ebcbf17",
"dtype": "float64",
"degenerate_capsules": [
686
],
"pairs_with_second_degenerate": 670,
"evaluated_pairs": 42880,
"changed_pairs_over_1e_8": 20661,
"old_minus_new_min_mm": 0.0,
"old_minus_new_max_mm": 86.00309853133399,
"new_reverse_max_abs_mm": 0.0,
"worst": {
"pose": 29,
"first_capsule": 430,
"second_capsule": 686,
"old_distance_mm": 493.354753665718,
"new_distance_mm": 407.35165513438403
},
"scope": "Raw capsule distances; does not imply these pairs win the group minimum."
}
@@ -0,0 +1,16 @@
{
"baseline_commit": "95da491",
"sample_source": "docs/experiment_round31_certificates.json",
"segments": 48,
"dense_points": 7586,
"max_step_deg": 0.01,
"cap_mm": 0.5,
"dtype": "float64",
"device": "cuda",
"kin_fp": "2ebcbf17",
"max_group_gap_difference_mm": 0.0,
"group_gaps_changed_over_1e_8": 0,
"minimum_gaps_changed_over_1e_8": 0,
"collision_bool_mismatches": 0,
"wall_s": 4.18259759999637
}
+10
View File
@@ -0,0 +1,10 @@
{
"n": 2000,
"fk_max_abs_mm": 4.547473508864641e-13,
"orient_max_abs": 3.3306690738754696e-16,
"gap_max_abs_mm": 2.5224267119483557e-13,
"collide_bool_mismatch": 0,
"feat_max_abs": 5.960463655974024e-08,
"grad_rel_err_max": 1.8474076070450906e-06,
"PASS": true
}
@@ -0,0 +1,22 @@
{
"scope": "全部 48 段 × 15 组对 = 720 项检验;观察值按 cap=2.0 mm 钳制,故可检验命题取 min(预测下限, cap)。违例=实测最小间隙低于该下限。",
"checks": 720,
"violations": [],
"worst_margin_mm": 0.0,
"min_slack_mm": 1e-06,
"dense_cap_mm": 2.0,
"grid_points_per_segment": 121,
"supersedes": "docs/experiment_round32_uniform_validation.json 里 bound_checks=61 的部分覆盖版本",
"kin_fp": "2ebcbf17",
"wall_s": 1.66,
"nontrivial": {
"definition": "只有预测下限 < 观察 cap 才是有信息量的检验;其余组对被钳制恒等式自动满足",
"checks": 61,
"min_slack_mm": 0.035347,
"p10_slack_mm": 0.544274,
"violations": 0,
"pred_mm_median_all": 15.8639,
"pred_mm_max_all": 19.9582
},
"note": "720 项总检验 0 违例,其中有信息量的是 61 项;预测下限的中位数 15.9 mm 远大于观察 cap 2 mm,所以大部分组对无法在本网格上证伪"
}
@@ -0,0 +1,190 @@
{
"device": "cuda float64",
"torch": "2.10.0+cu130",
"kin_fp": "2ebcbf17",
"roots_per_call": 2,
"pairs": 24,
"warm": 3,
"reps": 7,
"segment_sample": "docs/experiment_round31_certificates.json 的 48 段两两成对",
"design": "每对根轮流按正序/逆序测完全部配置(3次预热+7次计时);uniform_auto 的宽相位=最大子段界+2eps,uniform_cap20 固定 20 mm,bisect 为第31轮逐层二分口径",
"results": [
{
"kind": "uniform_auto",
"n_or_budget": 8,
"points": 18,
"cap_used_mm": 5.9191,
"calls": 168,
"p50_ms": 9.684,
"p90_ms": 13.027,
"p99_ms": 15.157,
"max_ms": 17.537,
"over_20ms": 0,
"roots": 48,
"safe": 26,
"collision": 1,
"rejected": 21
},
{
"kind": "uniform_auto",
"n_or_budget": 16,
"points": 34,
"cap_used_mm": 2.9597,
"calls": 168,
"p50_ms": 14.137,
"p90_ms": 18.454,
"p99_ms": 20.866,
"max_ms": 21.632,
"over_20ms": 5,
"roots": 48,
"safe": 30,
"collision": 1,
"rejected": 17
},
{
"kind": "uniform_auto",
"n_or_budget": 32,
"points": 66,
"cap_used_mm": 1.4799,
"calls": 168,
"p50_ms": 20.209,
"p90_ms": 27.88,
"p99_ms": 32.268,
"max_ms": 35.563,
"over_20ms": 87,
"roots": 48,
"safe": 34,
"collision": 1,
"rejected": 13
},
{
"kind": "uniform_auto",
"n_or_budget": 64,
"points": 130,
"cap_used_mm": 0.7401,
"calls": 168,
"p50_ms": 31.429,
"p90_ms": 48.751,
"p99_ms": 57.697,
"max_ms": 62.084,
"over_20ms": 165,
"roots": 48,
"safe": 36,
"collision": 1,
"rejected": 11
},
{
"kind": "uniform_auto",
"n_or_budget": 128,
"points": 258,
"cap_used_mm": 0.3701,
"calls": 168,
"p50_ms": 59.761,
"p90_ms": 89.063,
"p99_ms": 109.086,
"max_ms": 117.345,
"over_20ms": 168,
"roots": 48,
"safe": 38,
"collision": 1,
"rejected": 9
},
{
"kind": "uniform_cap20",
"n_or_budget": 8,
"points": 18,
"cap_used_mm": 20.0,
"calls": 168,
"p50_ms": 13.129,
"p90_ms": 16.44,
"p99_ms": 20.963,
"max_ms": 24.67,
"over_20ms": 3,
"roots": 48,
"safe": 26,
"collision": 1,
"rejected": 21
},
{
"kind": "uniform_cap20",
"n_or_budget": 32,
"points": 66,
"cap_used_mm": 20.0,
"calls": 168,
"p50_ms": 28.415,
"p90_ms": 39.579,
"p99_ms": 53.023,
"max_ms": 59.983,
"over_20ms": 153,
"roots": 48,
"safe": 34,
"collision": 1,
"rejected": 13
},
{
"kind": "uniform_cap20",
"n_or_budget": 64,
"points": 130,
"cap_used_mm": 20.0,
"calls": 168,
"p50_ms": 50.85,
"p90_ms": 75.512,
"p99_ms": 88.355,
"max_ms": 91.492,
"over_20ms": 168,
"roots": 48,
"safe": 36,
"collision": 1,
"rejected": 11
},
{
"kind": "uniform_cap20",
"n_or_budget": 128,
"points": 258,
"cap_used_mm": 20.0,
"calls": 168,
"p50_ms": 98.46,
"p90_ms": 139.982,
"p99_ms": 167.042,
"max_ms": 177.743,
"over_20ms": 168,
"roots": 48,
"safe": 38,
"collision": 1,
"rejected": 9
},
{
"kind": "bisect",
"n_or_budget": 32,
"points": null,
"cap_used_mm": 20.0,
"calls": 168,
"p50_ms": 54.885,
"p90_ms": 82.151,
"p99_ms": 117.205,
"max_ms": 118.716,
"over_20ms": 133,
"roots": 48,
"safe": 37,
"collision": 1,
"rejected": 10
},
{
"kind": "bisect",
"n_or_budget": 65,
"points": null,
"cap_used_mm": 20.0,
"calls": 168,
"p50_ms": 71.825,
"p90_ms": 108.559,
"p99_ms": 122.533,
"max_ms": 127.319,
"over_20ms": 133,
"roots": 48,
"safe": 41,
"collision": 1,
"rejected": 6
}
],
"wall_s": 108.63
}
@@ -0,0 +1,62 @@
{
"segments": 48,
"kin_fp": "2ebcbf17",
"dense_cap_mm": 2.0,
"eps_mm": 0.0001,
"bound_falsification": "每条组对:预测下限 (ga+gb-bound)/2 应 ≤ 网格上该组对的最小实测间隙",
"per_segment": [
{
"n": 8,
"safe": 26,
"collision": 1,
"unproven": 21,
"outside_box": 0,
"false_accept_vs_dense": 0,
"cap_required_mm": 5.919107314806348,
"known_missed_segment_collision": true
},
{
"n": 16,
"safe": 30,
"collision": 1,
"unproven": 17,
"outside_box": 0,
"false_accept_vs_dense": 0,
"cap_required_mm": 2.959653657403174,
"known_missed_segment_collision": true
},
{
"n": 32,
"safe": 34,
"collision": 1,
"unproven": 13,
"outside_box": 0,
"false_accept_vs_dense": 0,
"cap_required_mm": 1.479926828701587,
"known_missed_segment_collision": true
},
{
"n": 64,
"safe": 36,
"collision": 1,
"unproven": 11,
"outside_box": 0,
"false_accept_vs_dense": 0,
"cap_required_mm": 0.7400634143507935,
"known_missed_segment_collision": true
},
{
"n": 128,
"safe": 38,
"collision": 1,
"unproven": 9,
"outside_box": 0,
"false_accept_vs_dense": 0,
"cap_required_mm": 0.37013170717539673,
"known_missed_segment_collision": true
}
],
"bound_checks": 61,
"bound_violations": [],
"worst_margin_mm": 0.0
}
+70
View File
@@ -0,0 +1,70 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round33_base_rows.json",
"out": "docs/experiment_round33_base.json",
"trace": "ml/runs/round33_base.pt",
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 0,
"gap_margin": 0.0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.57421875,
"collision_free_success": 0.57421875,
"time_ok_1p3": 0.390625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.4449527263641357,
"time_mean_s": 2.3076188564300537,
"brakes_mean": 19.25,
"start_fail": 0.0,
"goal_ratio_2s": 0.20997506380081177,
"err_fail_med": 229.68746948242188,
"err_success_med": 0.18899640440940857,
"dls_share": 0.625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.6600004434585571,
"speed_ratio_p95": 1.6600035429000854,
"speed_ratio_max": 1.660003662109375,
"over_vmax_rate": 1.0,
"accel_ratio_p95": 1.5835107564926147,
"accel_ratio_max": 1.6600004434585571
},
"simulation_wall_s": 296.2702505999914
}
+70
View File
@@ -0,0 +1,70 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round33_both_rows.json",
"out": "docs/experiment_round33_both.json",
"trace": "ml/runs/round33_both.pt",
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.5,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.51953125,
"collision_free_success": 0.51953125,
"time_ok_1p3": 0.26171875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.5444939136505127,
"time_mean_s": 2.4729323387145996,
"brakes_mean": 19.97265625,
"start_fail": 0.0,
"goal_ratio_2s": 0.2868920564651489,
"err_fail_med": 202.12567138671875,
"err_success_med": 0.22085000574588776,
"dls_share": 0.62109375,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118
},
"simulation_wall_s": 277.54961390000244
}
+70
View File
@@ -0,0 +1,70 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round33_cap_rows.json",
"out": "docs/experiment_round33_cap.json",
"trace": "ml/runs/round33_cap.pt",
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5234375,
"collision_free_success": 0.5234375,
"time_ok_1p3": 0.265625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.615795850753784,
"time_mean_s": 2.486567258834839,
"brakes_mean": 19.5546875,
"start_fail": 0.0,
"goal_ratio_2s": 0.27920001745224,
"err_fail_med": 204.71360778808594,
"err_success_med": 0.21751396358013153,
"dls_share": 0.61328125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118
},
"simulation_wall_s": 325.18856850000157
}
+202
View File
@@ -0,0 +1,202 @@
{
"device": "NVIDIA GeForce RTX 3090",
"torch": "2.10.0+cu130",
"act_scale": 1.0,
"cfg": {},
"B": 1,
"commit_n": 2,
"fp64_note": "3090 fp64 \u541e\u5410\u7ea6 fp32 \u7684 1/54\uff1b\u8ba4\u8bc1\u76ee\u524d\u8981\u6c42 fp64",
"inference": {
"sample_K1_steps1": {
"p50": 7.453,
"p95": 9.912,
"p99": 10.766,
"max": 11.109,
"reps": 120
},
"sample_K8_steps1": {
"p50": 8.208,
"p95": 10.685,
"p99": 11.22,
"max": 15.224,
"reps": 120
},
"sample_K1_steps2": {
"p50": 13.149,
"p95": 17.621,
"p99": 18.438,
"max": 19.296,
"reps": 120
},
"sample_K8_steps2": {
"p50": 14.167,
"p95": 19.241,
"p99": 24.77,
"max": 25.703,
"reps": 120
},
"sample_K1_steps4": {
"p50": 19.193,
"p95": 22.338,
"p99": 23.666,
"max": 25.787,
"reps": 120
},
"sample_K8_steps4": {
"p50": 21.509,
"p95": 24.732,
"p99": 35.655,
"max": 41.514,
"reps": 120
},
"sample_K1_steps8": {
"p50": 40.658,
"p95": 55.162,
"p99": 60.394,
"max": 60.398,
"reps": 120
},
"sample_K8_steps8": {
"p50": 40.416,
"p95": 47.997,
"p99": 62.49,
"max": 71.976,
"reps": 120
},
"sample_K1_steps16": {
"p50": 72.429,
"p95": 90.188,
"p99": 107.536,
"max": 112.674,
"reps": 120
},
"sample_K8_steps16": {
"p50": 79.893,
"p95": 99.933,
"p99": 105.746,
"max": 106.078,
"reps": 120
}
},
"encode_once": {
"p50": 2.265,
"p95": 4.001,
"p99": 6.086,
"max": 6.136,
"reps": 120
},
"tiny_op_ms": 0.028,
"sync_only_ms": 0.005,
"components": {
"features_f32": {
"p50": 12.443,
"p95": 14.227,
"p99": 19.678,
"max": 20.531,
"reps": 120
},
"endpoint_score_K8_f32": {
"p50": 4.278,
"p95": 5.841,
"p99": 6.322,
"max": 8.883,
"reps": 120
},
"dls_fb_1step_f64": {
"p50": 7.191,
"p95": 12.26,
"p99": 14.642,
"max": 15.384,
"reps": 120
},
"dls_fb_1step_f32": {
"p50": 7.619,
"p95": 10.142,
"p99": 11.597,
"max": 12.022,
"reps": 120
},
"discrete_cert_4pts_f32": {
"p50": 8.214,
"p95": 13.365,
"p99": 14.235,
"max": 14.991,
"reps": 120
},
"cert_n8_f64_2roots": {
"p50": 11.265,
"p95": 14.64,
"p99": 16.788,
"max": 17.761,
"reps": 120
},
"cert_n16_f64_2roots": {
"p50": 14.574,
"p95": 16.731,
"p99": 18.459,
"max": 22.346,
"reps": 120
},
"cert_n32_f64_2roots": {
"p50": 21.528,
"p95": 24.746,
"p99": 28.037,
"max": 28.066,
"reps": 120
}
},
"cycle_K8_steps16_discrete": {
"p50": 116.474,
"p95": 134.474,
"p99": 142.593,
"max": 152.768,
"reps": 120
},
"cycle_K8_steps4_discrete": {
"p50": 55.919,
"p95": 65.767,
"p99": 74.809,
"max": 78.059,
"reps": 120
},
"cycle_K1_steps4_discrete": {
"p50": 51.087,
"p95": 58.614,
"p99": 62.326,
"max": 63.919,
"reps": 120
},
"cycle_K1_steps1_discrete": {
"p50": 34.493,
"p95": 42.078,
"p99": 43.906,
"max": 50.268,
"reps": 120
},
"cycle_K8_steps16_cert_n8": {
"p50": 132.027,
"p95": 150.463,
"p99": 160.83,
"max": 192.586,
"reps": 120
},
"cycle_K8_steps4_cert_n8": {
"p50": 64.812,
"p95": 79.192,
"p99": 89.629,
"max": 95.837,
"reps": 120
},
"cycle_K1_steps4_cert_n16": {
"p50": 61.967,
"p95": 73.219,
"p99": 79.053,
"max": 83.18,
"reps": 120
},
"f32_vs_f64": {
"points": 3,
"max_abs_err_mm": 0.0,
"sign_flips": 0
}
}
@@ -0,0 +1,143 @@
{
"device": "NVIDIA GeForce RTX 3090",
"B": 1,
"steps_used_by_eval": 1,
"note": "eval_cl \u4ece\u4e0d\u4f20 steps\uff0crollout \u9ed8\u8ba4 steps=1\uff08MeanFlow \u4e00\u6b65\u751f\u6210\uff09\uff1b\u6240\u4ee5\u771f\u5b9e\u5468\u671f\u6309 steps=1 \u6d4b",
"parts": {
"features_total": {
"p50": 12.589,
"p95": 18.334,
"p99": 20.217,
"max": 23.649,
"reps": 120
},
"features_gm_groups_only": {
"p50": 6.817,
"p95": 8.771,
"p99": 10.254,
"max": 17.169,
"reps": 120
},
"features_gaps40_all_groups": {
"p50": 7.245,
"p95": 10.501,
"p99": 13.794,
"max": 14.508,
"reps": 120
},
"features_fk_only": {
"p50": 3.708,
"p95": 5.024,
"p99": 5.991,
"max": 6.301,
"reps": 120
},
"sample_k_K8_steps1": {
"p50": 7.799,
"p95": 11.655,
"p99": 13.342,
"max": 16.212,
"reps": 120
},
"sample_k_K1_steps1": {
"p50": 7.205,
"p95": 8.935,
"p99": 9.615,
"max": 13.92,
"reps": 120
},
"sample_k_K4_steps1": {
"p50": 7.834,
"p95": 10.354,
"p99": 14.744,
"max": 15.241,
"reps": 120
},
"dls_fb_f64": {
"p50": 6.729,
"p95": 9.297,
"p99": 11.186,
"max": 12.064,
"reps": 120
},
"discrete_cert_4pts": {
"p50": 8.603,
"p95": 11.181,
"p99": 12.464,
"max": 15.799,
"reps": 120
},
"cert_uniform_n8_2roots_f64": {
"p50": 11.479,
"p95": 19.221,
"p99": 20.942,
"max": 21.183,
"reps": 120
},
"cert_uniform_n16_2roots_f64": {
"p50": 16.138,
"p95": 21.972,
"p99": 23.898,
"max": 25.793,
"reps": 120
}
},
"cycles": {
"cycle_K8_full_discrete": {
"p50": 40.676,
"p95": 51.742,
"p99": 59.782,
"max": 62.074,
"reps": 120
},
"cycle_K4_full_discrete": {
"p50": 43.997,
"p95": 56.145,
"p99": 59.905,
"max": 65.882,
"reps": 120
},
"cycle_K1_full_discrete": {
"p50": 37.87,
"p95": 45.754,
"p99": 49.394,
"max": 53.139,
"reps": 120
},
"cycle_K8_noscore_discrete": {
"p50": 37.427,
"p95": 49.602,
"p99": 60.777,
"max": 70.139,
"reps": 120
},
"cycle_K8_full_cert_n8": {
"p50": 43.984,
"p95": 65.795,
"p99": 75.53,
"max": 95.452,
"reps": 120
},
"cycle_K8_full_cert_n16": {
"p50": 51.054,
"p95": 74.862,
"p99": 95.768,
"max": 106.48,
"reps": 120
},
"cycle_K8_fused_estimate": {
"p50": 24.054,
"p95": 26.595,
"p99": 30.17,
"max": 33.284,
"reps": 120
},
"cycle_K8_fused_cert_n8": {
"p50": 34.274,
"p95": 46.329,
"p99": 72.737,
"max": 79.022,
"reps": 120
}
}
}
+70
View File
@@ -0,0 +1,70 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round33_margin_rows.json",
"out": "docs/experiment_round33_margin.json",
"trace": "ml/runs/round33_margin.pt",
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 0,
"gap_margin": 0.5,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5625,
"collision_free_success": 0.5625,
"time_ok_1p3": 0.37890625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.448458433151245,
"time_mean_s": 2.2555553913116455,
"brakes_mean": 20.046875,
"start_fail": 0.0,
"goal_ratio_2s": 0.18239997327327728,
"err_fail_med": 225.54278564453125,
"err_success_med": 0.18544802069664001,
"dls_share": 0.62890625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.6600004434585571,
"speed_ratio_p95": 1.660003662109375,
"speed_ratio_max": 1.660003662109375,
"over_vmax_rate": 1.0,
"accel_ratio_p95": 1.5889430046081543,
"accel_ratio_max": 1.6600035429000854
},
"simulation_wall_s": 298.24517190000915
}
@@ -0,0 +1,71 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round34_cert_batch_check.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 0,
"gap_margin": 0.0,
"cert_batch": 1,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.57421875,
"collision_free_success": 0.57421875,
"time_ok_1p3": 0.390625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.4449527263641357,
"time_mean_s": 2.3076188564300537,
"brakes_mean": 19.25,
"start_fail": 0.0,
"goal_ratio_2s": 0.20997506380081177,
"err_fail_med": 229.68746948242188,
"err_success_med": 0.18899640440940857,
"dls_share": 0.625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.6600004434585571,
"speed_ratio_p95": 1.6600035429000854,
"speed_ratio_max": 1.660003662109375,
"over_vmax_rate": 1.0,
"accel_ratio_p95": 1.5835107564926147,
"accel_ratio_max": 1.6600004434585571
},
"simulation_wall_s": 306.9490996999957
}
+41
View File
@@ -0,0 +1,41 @@
{
"kin_fp": "2ebcbf17",
"segments": 48,
"n_subsegments": 8,
"wide_cap_mm": 2.0,
"gap_abs_err_mm": {
"p50": 0.0,
"p99": 3.661949063912929e-05,
"p999": 7.4360332600075e-05,
"max": 0.00013247109886016517
},
"signed_err_mm": {
"min": -0.00010937313134817828,
"max": 0.00013247109886016517,
"overestimate_count": 1,
"overestimate_gt_1e-3": 0
},
"sign_flips": 0,
"accepted_f64": 24,
"accepted_f32": 24,
"unsafe_direction_f32_only": 0,
"conservative_f64_only": 0,
"per_group_pair_err_p99": [
0.0,
7.6e-05,
0.0001,
7e-05,
7.1e-05,
0.0,
0.0,
0.0,
0.000132,
6.7e-05,
5.1e-05,
0.0,
0.0,
0.0,
0.0
],
"note": "wide_cap 2.0 mm\uff1a\u8ba4\u8bc1\u5b9e\u9645\u7528 bound+2eps \u7684\u81ea\u9002\u5e94 cap\uff0c\u8fd9\u91cc\u53d6\u56fa\u5b9a 2 mm \u4ee5\u8986\u76d6\u88ab\u68c0\u9a8c\u7684\u6bb5\uff1b\u82e5 max \u8bef\u5dee\u8fdc\u5c0f\u4e8e 1e-4 \u7684 eps\uff0c\u5224\u636e\u5728 f32 \u4e0b\u4ecd\u6210\u7acb\u9700\u518d\u786e\u8ba4 f32 \u7684\u95f4\u9699\u672c\u8eab\u8bef\u5dee\u7b26\u53f7\u65b9\u5411\u3002"
}
+629
View File
@@ -0,0 +1,629 @@
{
"device": "NVIDIA GeForce RTX 3090",
"B": 1,
"K": 8,
"steps": 1,
"reps": 90,
"design": "\u540c\u4e00\u6279 4 \u4e2a\u53d8\u4f53\u9010\u8f6e\u4ea4\u66ff\uff08\u5947\u6570\u8f6e\u53cd\u5e8f\uff09\uff0c\u6d88\u9664 GPU \u65f6\u949f\u6f02\u79fb\uff1b\u539f\u59cb\u8017\u65f6\u5168\u90e8\u843d\u76d8",
"equivalence": {
"features_reuse_bitwise_equal": true,
"gm_groups_vs_full_table_max_abs_mm": 0.0,
"cert_matrix_bitwise_equal_at_same_cap": true,
"shared_xf_cert_bitwise_equal_at_cap1": true,
"max_abs_shared_diff_mm": 0.0,
"max_abs_cert_diff_mm": 0.0,
"decision_equal_by_threshold": {
"thr_0.0": true,
"thr_0.5": true,
"thr_1.0": true
},
"per_point_min_cur_mm": [
8.833421,
8.849185,
8.859405,
8.83829
],
"per_point_min_fused_mm": [
8.833421,
8.849185,
8.859405,
8.83829
]
},
"results": {
"current_discrete": {
"p50": 32.932,
"p95": 42.589,
"p99": 55.568,
"max": 55.568,
"hz_p50": 30.4,
"raw_ms": [
30.458,
30.624,
30.789,
31.17,
31.229,
31.283,
31.371,
31.394,
31.454,
31.473,
31.564,
31.58,
31.719,
31.772,
31.78,
31.785,
31.859,
31.875,
31.906,
31.973,
31.979,
32.002,
32.017,
32.063,
32.099,
32.113,
32.123,
32.127,
32.13,
32.137,
32.191,
32.286,
32.308,
32.324,
32.33,
32.388,
32.48,
32.508,
32.564,
32.63,
32.64,
32.702,
32.78,
32.822,
32.834,
32.932,
32.964,
32.975,
32.996,
33.071,
33.163,
33.191,
33.192,
33.402,
33.477,
33.509,
33.583,
33.956,
34.014,
34.04,
34.047,
34.047,
34.154,
34.302,
34.595,
34.658,
34.943,
35.296,
35.522,
35.67,
35.757,
35.828,
35.859,
36.459,
36.503,
36.562,
36.956,
37.047,
37.067,
37.142,
37.442,
38.632,
39.285,
41.269,
41.932,
42.589,
43.199,
43.329,
54.407,
55.568
]
},
"fused_discrete": {
"p50": 24.515,
"p95": 30.02,
"p99": 42.085,
"max": 42.085,
"hz_p50": 40.8,
"raw_ms": [
22.146,
22.266,
22.409,
22.653,
22.66,
22.695,
22.76,
22.827,
22.848,
23.001,
23.033,
23.087,
23.249,
23.36,
23.488,
23.573,
23.607,
23.625,
23.649,
23.651,
23.652,
23.652,
23.656,
23.676,
23.716,
23.737,
23.745,
23.795,
23.871,
23.883,
23.92,
23.922,
23.945,
23.959,
24.046,
24.13,
24.184,
24.282,
24.291,
24.313,
24.318,
24.319,
24.32,
24.34,
24.399,
24.515,
24.532,
24.541,
24.552,
24.592,
24.618,
24.731,
24.741,
24.745,
24.766,
24.807,
24.813,
24.898,
25.066,
25.088,
25.137,
25.18,
25.223,
25.376,
25.474,
25.603,
25.68,
25.744,
25.82,
25.936,
25.95,
25.953,
26.002,
26.174,
26.312,
26.88,
27.036,
27.209,
27.329,
27.424,
27.715,
28.796,
28.824,
29.427,
29.662,
30.02,
31.515,
31.839,
36.18,
42.085
]
},
"shared_xf_discrete": {
"p50": 26.864,
"p95": 34.544,
"p99": 67.243,
"max": 67.243,
"hz_p50": 37.2,
"raw_ms": [
24.433,
24.441,
24.585,
24.777,
24.862,
24.935,
25.054,
25.08,
25.105,
25.193,
25.313,
25.44,
25.466,
25.483,
25.516,
25.554,
25.577,
25.689,
25.702,
25.708,
25.854,
25.896,
25.898,
26.011,
26.097,
26.175,
26.255,
26.289,
26.297,
26.306,
26.328,
26.336,
26.346,
26.375,
26.397,
26.456,
26.502,
26.523,
26.563,
26.613,
26.634,
26.658,
26.708,
26.752,
26.798,
26.864,
26.869,
26.874,
27.315,
27.341,
27.668,
27.67,
27.732,
27.774,
27.812,
27.84,
27.882,
27.921,
28.24,
28.302,
28.421,
28.694,
28.722,
28.739,
28.817,
28.914,
28.944,
28.998,
29.12,
29.122,
29.259,
29.292,
29.334,
29.658,
29.847,
30.181,
30.206,
30.292,
30.492,
30.782,
31.168,
31.222,
31.607,
31.614,
32.187,
34.544,
35.274,
35.565,
35.915,
67.243
]
},
"current_cert_n8": {
"p50": 42.624,
"p95": 49.434,
"p99": 57.771,
"max": 57.771,
"hz_p50": 23.5,
"raw_ms": [
38.546,
38.666,
39.152,
39.265,
39.344,
39.441,
39.584,
39.626,
39.738,
39.841,
40.228,
40.306,
40.514,
40.805,
40.838,
40.875,
40.884,
40.907,
40.952,
40.971,
41.185,
41.193,
41.193,
41.277,
41.279,
41.422,
41.448,
41.463,
41.465,
41.473,
41.504,
41.551,
41.684,
41.733,
41.841,
41.947,
41.967,
42.011,
42.077,
42.241,
42.249,
42.269,
42.301,
42.314,
42.388,
42.624,
42.661,
42.767,
42.773,
42.837,
42.865,
42.87,
42.913,
43.343,
43.35,
43.356,
43.376,
43.501,
43.695,
43.708,
43.842,
43.923,
43.972,
44.243,
44.476,
44.536,
44.648,
44.745,
44.894,
45.034,
45.144,
45.236,
45.697,
45.859,
45.944,
46.039,
46.126,
46.467,
46.575,
46.887,
46.983,
47.234,
47.621,
47.685,
48.547,
49.434,
49.683,
50.646,
54.754,
57.771
]
},
"fused_cert_n8": {
"p50": 24.826,
"p95": 31.721,
"p99": 49.398,
"max": 49.398,
"hz_p50": 40.3,
"raw_ms": [
22.127,
22.553,
22.598,
22.624,
22.789,
22.798,
22.878,
22.983,
23.002,
23.134,
23.192,
23.273,
23.323,
23.345,
23.377,
23.445,
23.466,
23.549,
23.611,
23.613,
23.861,
23.868,
23.885,
23.885,
23.906,
23.918,
23.919,
23.933,
23.947,
24.052,
24.064,
24.067,
24.08,
24.103,
24.13,
24.164,
24.249,
24.301,
24.429,
24.515,
24.603,
24.609,
24.7,
24.748,
24.812,
24.826,
24.855,
24.858,
24.954,
24.99,
25.052,
25.097,
25.195,
25.209,
25.241,
25.252,
25.264,
25.298,
25.63,
25.659,
25.767,
25.804,
25.928,
25.976,
26.494,
26.871,
26.886,
26.988,
26.995,
27.004,
27.307,
27.322,
27.352,
27.937,
28.144,
28.165,
28.216,
28.288,
28.331,
29.37,
29.611,
30.6,
30.704,
31.026,
31.552,
31.721,
32.875,
34.001,
40.223,
49.398
]
},
"shared_xf_cert_n8": {
"p50": 36.185,
"p95": 41.136,
"p99": 64.287,
"max": 64.287,
"hz_p50": 27.6,
"raw_ms": [
33.051,
33.153,
33.201,
33.406,
33.819,
33.845,
33.94,
34.083,
34.145,
34.235,
34.3,
34.372,
34.605,
34.697,
34.714,
34.755,
34.817,
34.855,
34.925,
34.957,
34.963,
34.967,
34.986,
35.167,
35.239,
35.314,
35.325,
35.402,
35.444,
35.518,
35.544,
35.582,
35.594,
35.662,
35.675,
35.724,
35.775,
35.874,
35.908,
35.929,
35.965,
36.019,
36.04,
36.126,
36.164,
36.185,
36.2,
36.259,
36.263,
36.266,
36.301,
36.324,
36.383,
36.393,
36.609,
36.667,
36.696,
36.779,
36.799,
36.836,
36.881,
36.978,
37.001,
37.033,
37.043,
37.078,
37.183,
37.206,
37.278,
37.3,
37.411,
37.485,
37.722,
37.923,
37.965,
38.197,
38.588,
38.871,
39.082,
39.099,
39.135,
39.351,
39.505,
40.204,
40.892,
41.136,
41.449,
42.611,
44.687,
64.287
]
}
}
}
+630
View File
@@ -0,0 +1,630 @@
{
"device": "NVIDIA GeForce RTX 3090",
"B": 1,
"K": 8,
"commit_n": 2,
"reps": 80,
"design": "5 \u4e2a\u53d8\u4f53\u9010\u8f6e\u4ea4\u66ff\uff08\u5947\u6570\u8f6e\u53cd\u5e8f\uff09\uff1b\u53ea\u6d4b\u53ef\u5b9e\u73b0\u7684\u53e3\u5f84\uff1a\u7279\u5f81/\u63a8\u7406/\u8ba4\u8bc1\u6309\u771f\u5b9e\u987a\u5e8f",
"equivalence": {
"batch_cert_matrix_equal_to_loop": true,
"features_xf_reuse_bitwise_equal": true
},
"results": {
"A_today": {
"p50": 33.494,
"p95": 46.143,
"p99": 64.693,
"max": 64.693,
"raw_ms": [
28.984,
29.251,
29.361,
29.549,
29.899,
29.944,
30.181,
30.605,
30.624,
30.744,
30.815,
30.838,
30.862,
30.9,
31.024,
31.092,
31.115,
31.262,
31.433,
31.463,
31.52,
31.572,
31.642,
31.741,
31.871,
31.902,
31.924,
31.933,
31.976,
32.001,
32.03,
32.06,
32.285,
32.384,
32.624,
32.825,
32.919,
33.063,
33.168,
33.197,
33.494,
33.589,
33.624,
33.632,
33.666,
33.708,
33.727,
33.735,
33.754,
33.773,
33.869,
33.907,
34.116,
34.219,
34.314,
34.337,
34.897,
34.957,
35.436,
35.469,
35.999,
36.106,
36.523,
36.559,
36.846,
36.866,
36.922,
37.354,
37.375,
37.581,
37.933,
38.026,
40.541,
40.882,
44.161,
44.233,
46.143,
54.047,
58.36,
64.693
]
},
"B_xf_reuse": {
"p50": 30.122,
"p95": 42.349,
"p99": 66.368,
"max": 66.368,
"raw_ms": [
26.698,
26.958,
26.984,
27.007,
27.018,
27.158,
27.308,
27.369,
27.987,
28.066,
28.219,
28.288,
28.362,
28.517,
28.537,
28.539,
28.593,
28.611,
28.638,
28.735,
28.828,
28.871,
28.922,
28.945,
28.978,
29.088,
29.202,
29.226,
29.226,
29.31,
29.497,
29.506,
29.531,
29.549,
29.649,
29.875,
29.978,
29.992,
30.025,
30.102,
30.122,
30.243,
30.245,
30.263,
30.407,
30.578,
30.665,
30.717,
30.863,
30.884,
30.889,
30.95,
31.023,
31.314,
31.525,
31.537,
31.543,
31.549,
31.62,
32.011,
32.098,
32.168,
32.188,
32.22,
32.578,
32.818,
32.851,
32.929,
32.991,
33.76,
33.805,
33.831,
33.94,
34.124,
34.891,
39.001,
42.349,
43.636,
62.045,
66.368
]
},
"C_batch_cert": {
"p50": 38.048,
"p95": 50.171,
"p99": 59.86,
"max": 59.86,
"raw_ms": [
33.625,
33.736,
33.848,
34.235,
34.49,
34.917,
34.918,
35.108,
35.407,
35.919,
36.023,
36.035,
36.087,
36.263,
36.318,
36.531,
36.627,
36.638,
36.722,
36.778,
36.791,
36.801,
36.816,
36.859,
36.97,
36.998,
37.029,
37.055,
37.057,
37.093,
37.208,
37.318,
37.408,
37.438,
37.463,
37.501,
37.503,
37.605,
37.63,
37.984,
38.048,
38.283,
38.347,
38.524,
38.547,
38.667,
38.816,
38.995,
39.028,
39.34,
39.617,
39.679,
39.845,
39.852,
39.871,
39.894,
39.923,
40.195,
40.514,
41.421,
41.684,
41.804,
41.879,
41.933,
42.011,
42.127,
42.483,
42.551,
42.656,
43.038,
43.248,
43.269,
45.68,
46.514,
46.755,
48.909,
50.171,
50.906,
55.33,
59.86
]
},
"D_both": {
"p50": 34.87,
"p95": 39.811,
"p99": 48.258,
"max": 48.258,
"raw_ms": [
30.044,
30.934,
31.005,
31.007,
31.064,
31.492,
31.675,
31.758,
32.114,
32.153,
32.338,
32.374,
32.442,
32.494,
32.681,
32.882,
32.942,
32.991,
33.167,
33.18,
33.302,
33.305,
33.342,
33.449,
33.58,
33.694,
33.739,
33.784,
33.832,
33.835,
33.866,
33.961,
34.037,
34.135,
34.315,
34.395,
34.465,
34.556,
34.656,
34.819,
34.87,
34.98,
35.047,
35.176,
35.19,
35.37,
35.461,
35.528,
35.557,
35.59,
35.643,
35.716,
35.742,
35.804,
35.991,
36.018,
36.063,
36.105,
36.293,
36.312,
36.326,
36.537,
36.541,
36.602,
36.717,
36.934,
36.945,
37.088,
37.141,
37.46,
37.561,
37.608,
37.765,
37.904,
37.974,
39.253,
39.811,
40.076,
46.504,
48.258
]
},
"E_both_cont_n8": {
"p50": 43.725,
"p95": 51.084,
"p99": 65.681,
"max": 65.681,
"raw_ms": [
37.733,
39.087,
39.154,
39.238,
39.36,
39.454,
39.514,
40.167,
40.44,
40.837,
40.86,
40.868,
41.237,
41.276,
41.346,
41.408,
41.551,
41.815,
41.824,
41.912,
41.932,
41.973,
42.074,
42.296,
42.341,
42.365,
42.435,
42.505,
42.592,
42.598,
42.637,
42.85,
43.045,
43.048,
43.18,
43.209,
43.359,
43.361,
43.373,
43.411,
43.725,
43.728,
43.787,
43.833,
43.985,
44.133,
44.185,
44.401,
44.458,
44.585,
44.689,
44.819,
44.841,
44.86,
45.081,
45.087,
45.55,
45.701,
45.939,
46.06,
46.128,
46.264,
46.368,
46.43,
46.957,
47.145,
47.231,
47.256,
47.463,
47.637,
47.819,
47.863,
48.382,
48.87,
49.676,
50.884,
51.084,
51.17,
53.859,
65.681
]
},
"F_worst_loop8": {
"p50": 80.224,
"p95": 88.436,
"p99": 89.553,
"max": 89.553,
"raw_ms": [
67.204,
70.008,
70.436,
71.432,
72.454,
72.503,
73.006,
73.12,
73.492,
73.971,
74.203,
74.358,
74.756,
74.816,
74.893,
75.536,
75.98,
76.049,
76.164,
76.25,
76.547,
76.669,
76.843,
77.268,
77.534,
77.658,
77.872,
78.149,
78.343,
78.377,
78.445,
78.483,
78.86,
78.863,
78.905,
79.048,
79.315,
79.857,
80.035,
80.041,
80.224,
80.602,
80.644,
80.677,
80.848,
81.061,
81.094,
81.155,
81.243,
81.384,
81.628,
81.679,
81.75,
82.117,
82.148,
82.363,
82.444,
82.511,
82.651,
82.828,
82.921,
83.371,
83.592,
83.894,
83.926,
84.386,
84.519,
84.608,
85.06,
85.078,
85.094,
85.26,
87.212,
87.744,
87.847,
88.098,
88.436,
88.461,
88.919,
89.553
]
},
"G_worst_batch": {
"p50": 37.139,
"p95": 46.06,
"p99": 52.215,
"max": 52.215,
"raw_ms": [
32.718,
33.447,
33.569,
33.692,
33.81,
34.236,
34.28,
34.475,
34.496,
34.746,
35.19,
35.392,
35.435,
35.564,
35.569,
35.669,
35.693,
35.734,
35.741,
35.812,
35.828,
35.934,
36.015,
36.036,
36.097,
36.144,
36.197,
36.205,
36.487,
36.637,
36.71,
36.775,
36.79,
36.83,
36.831,
36.885,
36.894,
36.903,
36.947,
37.122,
37.139,
37.154,
37.198,
37.225,
37.249,
37.478,
37.615,
37.617,
38.114,
38.164,
38.288,
38.637,
38.651,
38.724,
38.813,
39.108,
39.15,
39.848,
39.866,
39.946,
39.969,
39.992,
40.04,
40.28,
40.35,
40.697,
40.727,
40.893,
40.972,
41.029,
41.138,
41.479,
41.51,
41.711,
45.036,
45.784,
46.06,
48.597,
50.186,
52.215
]
}
}
}
+58
View File
@@ -0,0 +1,58 @@
{
"device": "NVIDIA GeForce RTX 3090",
"torch": "2.10.0+cu130",
"K": 8,
"steps": 1,
"B": 1,
"act_scale": 1.0,
"inference": {
"fp32": {
"p50": 7.681,
"p95": 9.426,
"p99": 10.631,
"max": 15.837
},
"fp16": {
"p50": 8.309,
"p95": 10.791,
"p99": 12.031,
"max": 12.322
},
"bf16": {
"p50": 8.577,
"p95": 11.057,
"p99": 14.174,
"max": 17.1
}
},
"cycle": {
"fp32": {
"p50": 36.507,
"p95": 43.688,
"p99": 46.568,
"max": 50.598
},
"fp16": {
"p50": 36.162,
"p95": 50.43,
"p99": 55.598,
"max": 57.043
}
},
"output_deviation": {
"fp16": {
"act_max_abs": 0.002096,
"act_p99_abs": 0.001059,
"deg_max_abs": 0.005,
"deg_p99_abs": 0.00219,
"would_change_execution_order": false
},
"bf16": {
"act_max_abs": 0.017171,
"act_p99_abs": 0.012661,
"deg_max_abs": 0.03766,
"deg_p99_abs": 0.03008,
"would_change_execution_order": true
}
}
}
@@ -0,0 +1,70 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round34_xf_reuse_check.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 0,
"gap_margin": 0.0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.57421875,
"collision_free_success": 0.57421875,
"time_ok_1p3": 0.390625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.4449527263641357,
"time_mean_s": 2.3076188564300537,
"brakes_mean": 19.25,
"start_fail": 0.0,
"goal_ratio_2s": 0.20997506380081177,
"err_fail_med": 229.68746948242188,
"err_success_med": 0.18899640440940857,
"dls_share": 0.625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.6600004434585571,
"speed_ratio_p95": 1.6600035429000854,
"speed_ratio_max": 1.660003662109375,
"over_vmax_rate": 1.0,
"accel_ratio_p95": 1.5835107564926147,
"accel_ratio_max": 1.6600004434585571
},
"simulation_wall_s": 317.96790459999465
}
@@ -0,0 +1,23 @@
{
"device": "NVIDIA GeForce RTX 3090",
"K": 8,
"commit_n": 2,
"design": "\u4e24\u6b21\u89c4\u5212\u4e3a\u4e00\u4e2a\u5355\u5143\uff0c\u5947\u6570\u8f6e\u53cd\u5e8f\uff1b\u6d41\u6c34\u7ebf\u90a3\u6b21\u7684\u8ba4\u8bc1\u8c03\u7528\u88ab\u8feb\u7528 cap=GAP_CAP(\u7279\u5f81\u9700\u8981)\uff0c\u8fd9\u662f\u590d\u7528\u7684\u771f\u5b9e\u4ee3\u4ef7\uff0c\u4e0d\u662f\u514d\u8d39",
"equivalence": {
"cached_gap_row_bitwise_equal": false,
"features_bitwise_equal": false,
"max_row_diff_mm": 6.29425048828125e-05
},
"fresh": {
"p50_per_plan": 34.779,
"p95": 39.271,
"p99": 40.98,
"reps": 60
},
"pipelined": {
"p50_per_plan": 31.655,
"p95": 34.483,
"p99": 38.208,
"reps": 60
}
}
+337
View File
@@ -0,0 +1,337 @@
{
"checkpoint": "ml/runs/base_dag2_dag1/best.pt",
"n": 256,
"nref_steps": 128,
"reference": "瞬时场 r=t 的流图(与损失无关)",
"per_rt": [
{
"r": 0.0,
"t": 0.05,
"span": 0.05,
"norm_u_true": 4.152298927307129,
"norm_dudt": 156.59774780273438,
"mf_abs": 2.629317283630371,
"mf_rel": 0.6185885667800903,
"mf_cos_true": -0.2586098909378052,
"mf_cos_eps": -0.08821636438369751,
"kmf_sq_abs": 3.808063507080078,
"kmf_lin_abs": 2.105757713317871,
"kmf_lin_rel": 0.4867732524871826,
"kmf_lin_cos_eps": -0.19339147210121155,
"mid_only_abs": 2.467759370803833,
"midstate_abs": 2.475457191467285,
"midstate_rel": 0.5789506435394287,
"heun_abs": 2.465583324432373,
"heun_rel": 0.5782649517059326,
"d1_norm": 157.7960968017578,
"d2_norm": 150.50238037109375,
"d3_norm": 153.35733032226562,
"net_abs": 2.7900571823120117,
"net_rel": 0.686574399471283
},
{
"r": 0.0,
"t": 0.1,
"span": 0.1,
"norm_u_true": 6.895779609680176,
"norm_dudt": 25.08617401123047,
"mf_abs": 2.9073116779327393,
"mf_rel": 0.4195072650909424,
"mf_cos_true": 0.7109781503677368,
"mf_cos_eps": 0.6336730718612671,
"kmf_sq_abs": 1.5212182998657227,
"kmf_lin_abs": 5.014378070831299,
"kmf_lin_rel": 0.7285130023956299,
"kmf_lin_cos_eps": -0.707574188709259,
"mid_only_abs": 11.992480278015137,
"midstate_abs": 2.770589828491211,
"midstate_rel": 0.39942666888237,
"heun_abs": 1.8834517002105713,
"heun_rel": 0.2704611122608185,
"d1_norm": 24.996402740478516,
"d2_norm": 156.59774780273438,
"d3_norm": 59.145477294921875,
"net_abs": 3.2193822860717773,
"net_rel": 0.4677886366844177
},
{
"r": 0.0,
"t": 0.2,
"span": 0.2,
"norm_u_true": 8.788705825805664,
"norm_dudt": 6.331303596496582,
"mf_abs": 2.572011947631836,
"mf_rel": 0.29417163133621216,
"mf_cos_true": 0.8289472460746765,
"mf_cos_eps": 0.795153021812439,
"kmf_sq_abs": 1.7290871143341064,
"kmf_lin_abs": 1.926774501800537,
"kmf_lin_rel": 0.2203272432088852,
"kmf_lin_cos_eps": 0.08155926316976547,
"mid_only_abs": 3.628005266189575,
"midstate_abs": 3.9586117267608643,
"midstate_rel": 0.4504213333129883,
"heun_abs": 1.7300267219543457,
"heun_rel": 0.19759969413280487,
"d1_norm": 4.81895637512207,
"d2_norm": 25.08617401123047,
"d3_norm": 28.122135162353516,
"net_abs": 1.9169456958770752,
"net_rel": 0.2185157686471939
},
{
"r": 0.0,
"t": 0.3,
"span": 0.3,
"norm_u_true": 9.446111679077148,
"norm_dudt": 4.131267547607422,
"mf_abs": 2.354419231414795,
"mf_rel": 0.2489214837551117,
"mf_cos_true": 0.8489015102386475,
"mf_cos_eps": 0.8029109239578247,
"kmf_sq_abs": 1.4227628707885742,
"kmf_lin_abs": 1.530599594116211,
"kmf_lin_rel": 0.16132134199142456,
"kmf_lin_cos_eps": 0.09631951153278351,
"mid_only_abs": 2.57088565826416,
"midstate_abs": 4.304656982421875,
"midstate_rel": 0.4555080831050873,
"heun_abs": 1.8236483335494995,
"heun_rel": 0.1927146017551422,
"d1_norm": 3.2171449661254883,
"d2_norm": 11.126049041748047,
"d3_norm": 18.29114532470703,
"net_abs": 1.3471484184265137,
"net_rel": 0.14259807765483856
},
{
"r": 0.0,
"t": 0.4,
"span": 0.4,
"norm_u_true": 9.78399658203125,
"norm_dudt": 2.373415946960449,
"mf_abs": 1.7019946575164795,
"mf_rel": 0.17237165570259094,
"mf_cos_true": 0.8364542722702026,
"mf_cos_eps": 0.80040043592453,
"kmf_sq_abs": 1.4873857498168945,
"kmf_lin_abs": 1.8382024765014648,
"kmf_lin_rel": 0.18990299105644226,
"kmf_lin_cos_eps": 0.6340612173080444,
"mid_only_abs": 2.7560770511627197,
"midstate_abs": 4.497618675231934,
"midstate_rel": 0.4598080515861511,
"heun_abs": 2.0347068309783936,
"heun_rel": 0.20750463008880615,
"d1_norm": 2.2074503898620605,
"d2_norm": 6.331303596496582,
"d3_norm": 13.588470458984375,
"net_abs": 0.9387868642807007,
"net_rel": 0.09583067893981934
},
{
"r": 0.0,
"t": 0.5,
"span": 0.5,
"norm_u_true": 9.98532772064209,
"norm_dudt": 2.658200263977051,
"mf_abs": 0.8106092214584351,
"mf_rel": 0.0805797278881073,
"mf_cos_true": -0.3406544327735901,
"mf_cos_eps": -0.19956746697425842,
"kmf_sq_abs": 1.2309105396270752,
"kmf_lin_abs": 1.5382835865020752,
"kmf_lin_rel": 0.15414834022521973,
"kmf_lin_cos_eps": 0.5139043927192688,
"mid_only_abs": 2.382789134979248,
"midstate_abs": 5.330208778381348,
"midstate_rel": 0.5345790982246399,
"heun_abs": 2.8818538188934326,
"heun_rel": 0.28885430097579956,
"d1_norm": 1.423255443572998,
"d2_norm": 4.9012861251831055,
"d3_norm": 12.108942031860352,
"net_abs": 0.8207994103431702,
"net_rel": 0.08221843093633652
},
{
"r": 0.0,
"t": 0.6,
"span": 0.6,
"norm_u_true": 10.118559837341309,
"norm_dudt": 4.046132564544678,
"mf_abs": 3.044166088104248,
"mf_rel": 0.3003576099872589,
"mf_cos_true": 0.9172172546386719,
"mf_cos_eps": 0.841435432434082,
"kmf_sq_abs": 1.3112163543701172,
"kmf_lin_abs": 1.7851487398147583,
"kmf_lin_rel": 0.17629936337471008,
"kmf_lin_cos_eps": 0.7054632306098938,
"mid_only_abs": 2.974583625793457,
"midstate_abs": 3.8119943141937256,
"midstate_rel": 0.37495750188827515,
"heun_abs": 0.9826163649559021,
"heun_rel": 0.09552386403083801,
"d1_norm": 1.021875023841858,
"d2_norm": 4.131267547607422,
"d3_norm": 7.380629539489746,
"net_abs": 0.5622822046279907,
"net_rel": 0.0555611215531826
},
{
"r": 0.0,
"t": 0.7,
"span": 0.7,
"norm_u_true": 10.210578918457031,
"norm_dudt": 1.5618565082550049,
"mf_abs": 0.7238559722900391,
"mf_rel": 0.0707138329744339,
"mf_cos_true": 0.01889939233660698,
"mf_cos_eps": 0.0709509551525116,
"kmf_sq_abs": 1.1261842250823975,
"kmf_lin_abs": 1.562591552734375,
"kmf_lin_rel": 0.15248213708400726,
"kmf_lin_cos_eps": 0.6589925289154053,
"mid_only_abs": 2.7245984077453613,
"midstate_abs": 5.200009346008301,
"midstate_rel": 0.509149432182312,
"heun_abs": 2.7610363960266113,
"heun_rel": 0.27028360962867737,
"d1_norm": 0.9923672080039978,
"d2_norm": 3.2669692039489746,
"d3_norm": 8.216880798339844,
"net_abs": 0.6127126216888428,
"net_rel": 0.06004098802804947
},
{
"r": 0.0,
"t": 0.8,
"span": 0.8,
"norm_u_true": 10.280738830566406,
"norm_dudt": 3.559027671813965,
"mf_abs": 3.139580726623535,
"mf_rel": 0.3054307699203491,
"mf_cos_true": 0.841235876083374,
"mf_cos_eps": 0.7405093908309937,
"kmf_sq_abs": 0.9379472732543945,
"kmf_lin_abs": 1.278116226196289,
"kmf_lin_rel": 0.12322138249874115,
"kmf_lin_cos_eps": 0.6785725951194763,
"mid_only_abs": 2.1469192504882812,
"midstate_abs": 3.9412341117858887,
"midstate_rel": 0.3837699890136719,
"heun_abs": 1.2848330736160278,
"heun_rel": 0.12474364042282104,
"d1_norm": 0.6407566070556641,
"d2_norm": 2.373415946960449,
"d3_norm": 5.565019130706787,
"net_abs": 0.544069766998291,
"net_rel": 0.05294711887836456
},
{
"r": 0.0,
"t": 0.9,
"span": 0.9,
"norm_u_true": 10.333314895629883,
"norm_dudt": 17.87816619873047,
"mf_abs": 16.365367889404297,
"mf_rel": 1.5846014022827148,
"mf_cos_true": 0.949444055557251,
"mf_cos_eps": 0.8185906410217285,
"kmf_sq_abs": 0.7964116334915161,
"kmf_lin_abs": 1.5619468688964844,
"kmf_lin_rel": 0.14914938807487488,
"kmf_lin_cos_eps": -0.682485818862915,
"mid_only_abs": 2.9376566410064697,
"midstate_abs": 4.5689287185668945,
"midstate_rel": 0.44398587942123413,
"heun_abs": 10.097332000732422,
"heun_rel": 0.9785149693489075,
"d1_norm": 0.9012945890426636,
"d2_norm": 3.5273427963256836,
"d3_norm": 4.809117794036865,
"net_abs": 0.19002258777618408,
"net_rel": 0.018513960763812065
},
{
"r": 0.0,
"t": 0.95,
"span": 0.95,
"norm_u_true": 10.35672664642334,
"norm_dudt": 64.29971313476562,
"mf_abs": 61.504981994628906,
"mf_rel": 5.942716598510742,
"mf_cos_true": 0.9920964241027832,
"mf_cos_eps": 0.938286304473877,
"kmf_sq_abs": 0.6677861213684082,
"kmf_lin_abs": 1.1961216926574707,
"kmf_lin_rel": 0.1146148070693016,
"kmf_lin_cos_eps": -0.46628355979919434,
"mid_only_abs": 2.5505270957946777,
"midstate_abs": 26.227705001831055,
"midstate_rel": 2.537191390991211,
"heun_abs": 43.71785354614258,
"heun_rel": 4.225504398345947,
"d1_norm": 0.9435088634490967,
"d2_norm": 2.9939303398132324,
"d3_norm": 27.214248657226562,
"net_abs": 2.2616631984710693,
"net_rel": 0.2185918092727661
},
{
"r": 0.0,
"t": 1.0,
"span": 1.0,
"norm_u_true": 10.378573417663574,
"norm_dudt": 4.240537643432617,
"mf_abs": 3.8513689041137695,
"mf_rel": 0.3713422417640686,
"mf_cos_true": -0.9887999892234802,
"mf_cos_eps": -0.916346549987793,
"kmf_sq_abs": 7.18745231628418,
"kmf_lin_abs": 14.660856246948242,
"kmf_lin_rel": 1.412999153137207,
"kmf_lin_cos_eps": -0.8949825167655945,
"mid_only_abs": 2.364427328109741,
"midstate_abs": 4.872905731201172,
"midstate_rel": 0.4697429835796356,
"heun_abs": 4.360708236694336,
"heun_rel": 0.4204045832157135,
"d1_norm": 28.04054832458496,
"d2_norm": 2.658200263977051,
"d3_norm": 5.2787017822265625,
"net_abs": 3.9062576293945312,
"net_rel": 0.3766472339630127
}
],
"ref_discretization": {
"norm_128": 10.378573417663574,
"norm_512": 10.360570907592773,
"diff_mean": 0.018837258219718933,
"diff_rel": 0.0018179214093834162
},
"gate_corner": {
"mf": 3.8513689041137695,
"kmf_sq": 7.18745231628418,
"kmf_lin": 14.660856246948242,
"mid_only": 2.364427328109741,
"midstate": 4.872905731201172,
"heun": 4.360708236694336,
"net_1step": 3.9062576293945312,
"ratio_lin_over_mf": 3.8066611150358813,
"ratio_mid_over_mf": 0.6139186837137884,
"ratio_midstate_over_mf": 1.265239932221571,
"ratio_heun_over_mf": 1.132248908183406
},
"gate_worst_accel": {
"t": 0.05,
"dudt": 156.59774780273438,
"mf": 2.629317283630371,
"kmf_sq": 3.808063507080078,
"kmf_lin": 2.105757713317871,
"mid_only": 2.467759370803833,
"ratio_lin_over_mf": 0.8008762298973645
},
"wall_s": 13.092682200003765
}
+97
View File
@@ -0,0 +1,97 @@
{
"n": 512,
"steps": {
"2": {
"vs_teacher_l2": 0.4342995882034302,
"vs_32step_l2": 0.30502474308013916,
"vs_1step_l2": 4.2227020263671875
},
"3": {
"vs_teacher_l2": 0.43872418999671936,
"vs_32step_l2": 0.29536527395248413,
"vs_1step_l2": 4.216776371002197
},
"4": {
"vs_teacher_l2": 0.42935511469841003,
"vs_32step_l2": 0.29940515756607056,
"vs_1step_l2": 4.232732772827148
},
"8": {
"vs_teacher_l2": 0.4444255232810974,
"vs_32step_l2": 0.2452448457479477,
"vs_1step_l2": 4.195967197418213
},
"16": {
"vs_teacher_l2": 0.5166380405426025,
"vs_32step_l2": 0.12673738598823547,
"vs_1step_l2": 4.085569381713867
},
"32": {
"vs_teacher_l2": 0.6008902192115784,
"vs_32step_l2": 0.0,
"vs_1step_l2": 3.970090866088867
}
},
"vs_teacher": {
"a1_1step": {
"l2_mean": 4.325636386871338,
"l2_p95": 4.9564337730407715,
"per_axis_norm": [
0.3975203335285187,
0.36649173498153687,
0.3425973951816559,
0.3447648882865906,
0.3368167281150818,
0.32962310314178467
]
},
"aU_32step_rneq_t": {
"l2_mean": 0.6008902192115784,
"l2_p95": 1.9733507633209229,
"per_axis_norm": [
0.05318881571292877,
0.04853545129299164,
0.04775547981262207,
0.04531646892428398,
0.0381026417016983,
0.034751877188682556
]
},
"aF_flow_map_r_eq_t": {
"l2_mean": 0.6651337146759033,
"l2_p95": 1.9794291257858276,
"per_axis_norm": [
0.06039007008075714,
0.05440700799226761,
0.05297258496284485,
0.05065540224313736,
0.04315900802612305,
0.03988185524940491
]
}
},
"mutual": [
{
"l2_mean": 3.970090866088867,
"pair": [
"a1",
"aU_32"
]
},
{
"l2_mean": 3.891127109527588,
"pair": [
"a1",
"aF_flow"
]
},
{
"l2_mean": 0.08254596590995789,
"pair": [
"aU_32",
"aF_flow"
]
}
],
"note": "动作块是 ±1 归一化的 16×6;l2_mean 无单位权重,越小越贴老师"
}
+50
View File
@@ -0,0 +1,50 @@
{
"empty/commit2/inc_cap0": {
"plans": 175,
"r_hist": {
"0": 175
},
"frac_r0": 1.0,
"save_ms_per_plan_avg": 3.631,
"success": 0.46875,
"brakes_mean": 24.0625,
"wall_s": 54.74565179999627
},
"r3/commit3/inc_cap0": {
"plans": 118,
"r_hist": {
"0": 1,
"2": 1,
"3": 116
},
"frac_r0": 0.00847457627118644,
"save_ms_per_plan_avg": 0.030771186440677965,
"success": 0.4375,
"brakes_mean": 18.03125,
"wall_s": 49.8360657000012
},
"r3/commit3/inc_cap1": {
"plans": 118,
"r_hist": {
"0": 1,
"2": 1,
"3": 116
},
"frac_r0": 0.00847457627118644,
"save_ms_per_plan_avg": 0.030771186440677965,
"success": 0.40625,
"brakes_mean": 16.9375,
"wall_s": 49.97621490000165
},
"empty/commit3/inc_cap1": {
"plans": 117,
"r_hist": {
"0": 117
},
"frac_r0": 1.0,
"save_ms_per_plan_avg": 3.631,
"success": 0.4375,
"brakes_mean": 15.0625,
"wall_s": 43.831084999997984
}
}
+73
View File
@@ -0,0 +1,73 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round36_steps2_cap0_rows.json",
"out": "docs/experiment_round36_steps2_cap0.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 0,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 2,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.42578125,
"collision_free_success": 0.42578125,
"time_ok_1p3": 0.35546875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 1.5711719989776611,
"time_mean_s": 1.6664220094680786,
"brakes_mean": 86.30859375,
"start_fail": 0.0,
"goal_ratio_2s": 0.29959768056869507,
"err_fail_med": 405.61505126953125,
"err_success_med": 0.24314510822296143,
"dls_share": 0.453125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.6600004434585571,
"speed_ratio_p95": 1.6600035429000854,
"speed_ratio_max": 1.660003662109375,
"over_vmax_rate": 0.91015625,
"accel_ratio_p95": 1.0188239812850952,
"accel_ratio_max": 1.4423871040344238
},
"simulation_wall_s": 304.77464890001283
}
+73
View File
@@ -0,0 +1,73 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round36_steps2_cap1_rows.json",
"out": "docs/experiment_round36_steps2_cap1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 2,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.39453125,
"collision_free_success": 0.39453125,
"time_ok_1p3": 0.296875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 1.8436782360076904,
"time_mean_s": 1.9299010038375854,
"brakes_mean": 86.15625,
"start_fail": 0.0,
"goal_ratio_2s": 0.384182870388031,
"err_fail_med": 376.4237976074219,
"err_success_med": 0.2933140993118286,
"dls_share": 0.4453125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000038146972656,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 0.8507659435272217,
"accel_ratio_max": 0.9923425912857056
},
"simulation_wall_s": 319.5858334999939
}
+73
View File
@@ -0,0 +1,73 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round36_steps4_cap1_rows.json",
"out": "docs/experiment_round36_steps4_cap1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 4,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.40625,
"collision_free_success": 0.40625,
"time_ok_1p3": 0.3046875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 1.8817013502120972,
"time_mean_s": 1.9080770015716553,
"brakes_mean": 79.65234375,
"start_fail": 0.0,
"goal_ratio_2s": 0.3844277262687683,
"err_fail_med": 342.1692810058594,
"err_success_med": 0.1346309632062912,
"dls_share": 0.4609375,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000053644180298,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 0.914295494556427,
"accel_ratio_max": 1.0000005960464478
},
"simulation_wall_s": 347.79689209999924
}
+73
View File
@@ -0,0 +1,73 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round36_steps8_cap1_rows.json",
"out": "docs/experiment_round36_steps8_cap1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 8,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.41015625,
"collision_free_success": 0.41015625,
"time_ok_1p3": 0.32421875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 1.8700296878814697,
"time_mean_s": 1.9293333292007446,
"brakes_mean": 79.69921875,
"start_fail": 0.0,
"goal_ratio_2s": 0.3575941324234009,
"err_fail_med": 330.5984191894531,
"err_success_med": 0.2526792883872986,
"dls_share": 0.46875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000053644180298,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 0.9362331628799438,
"accel_ratio_max": 1.0000005960464478
},
"simulation_wall_s": 316.32940030000464
}
+106
View File
@@ -0,0 +1,106 @@
[
{
"file": "ml/runs/round33_cap.pt",
"n": 256,
"all": {
"n": 256,
"mean_window_s": 3.73765625,
"zero_share": 0.20881234062121148,
"low_share": 0.0812884076752644,
"mid_share": 0.27427783119434807,
"hi_share": 0.435621420509176,
"zero_s_per_task": 0.78046875,
"runs_per_task": 18.5078125,
"run_len_mean": 2.1084845926551288,
"run_len_max": 41
},
"arrived_time_ok": {
"n": 68,
"mean_window_s": 1.9370588235294117,
"zero_share": 0.013817187974491345,
"low_share": 0.033404190707561496,
"mid_share": 0.17901609474643185,
"hi_share": 0.7737625265715153,
"zero_s_per_task": 0.02676470588235294,
"runs_per_task": 0.7647058823529411,
"run_len_mean": 1.75,
"run_len_max": 4
},
"arrived_slow": {
"n": 66,
"mean_window_s": 3.052727272727273,
"zero_share": 0.049632717887631524,
"low_share": 0.06293428628151677,
"mid_share": 0.22553107008139764,
"hi_share": 0.6619019257494541,
"zero_s_per_task": 0.15151515151515152,
"runs_per_task": 4.590909090909091,
"run_len_mean": 1.6501650165016502,
"run_len_max": 7
},
"not_arrived": {
"n": 122,
"mean_window_s": 5.111803278688525,
"zero_share": 0.3014238984029248,
"low_share": 0.09733179398370856,
"mid_share": 0.31014687961003146,
"hi_share": 0.29109742800333527,
"zero_s_per_task": 1.5408196721311478,
"runs_per_task": 35.92622950819672,
"run_len_mean": 2.144421629021218,
"run_len_max": 41
}
},
{
"file": "ml/runs/round33_base.pt",
"n": 256,
"all": {
"n": 256,
"mean_window_s": 3.482578125,
"zero_share": 0.22394957040626332,
"low_share": 0.08179105816901093,
"mid_share": 0.2871435942302084,
"hi_share": 0.4071157771945174,
"zero_s_per_task": 0.779921875,
"runs_per_task": 18.7421875,
"run_len_mean": 2.0806586077532305,
"run_len_max": 21
},
"arrived_time_ok": {
"n": 100,
"mean_window_s": 1.8818000000000001,
"zero_share": 0.019236900839621637,
"low_share": 0.039642895100435754,
"mid_share": 0.19353810181740885,
"hi_share": 0.7475821022425337,
"zero_s_per_task": 0.0362,
"runs_per_task": 1.2,
"run_len_mean": 1.5083333333333333,
"run_len_max": 5
},
"arrived_slow": {
"n": 47,
"mean_window_s": 3.2136170212765958,
"zero_share": 0.10474046610169492,
"low_share": 0.07216631355932204,
"mid_share": 0.25529661016949157,
"hi_share": 0.5677966101694916,
"zero_s_per_task": 0.33659574468085107,
"runs_per_task": 10.063829787234043,
"run_len_mean": 1.6723044397463003,
"run_len_max": 7
},
"not_arrived": {
"n": 109,
"mean_window_s": 5.067155963302753,
"zero_share": 0.3262963499420625,
"low_share": 0.09878331402085747,
"mid_share": 0.32774478563151793,
"hi_share": 0.247175550405562,
"zero_s_per_task": 1.6533944954128441,
"runs_per_task": 38.57798165137615,
"run_len_mean": 2.142925089179548,
"run_len_max": 21
}
}
]
+82
View File
@@ -0,0 +1,82 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round38_backoff0.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5234375,
"collision_free_success": 0.5234375,
"time_ok_1p3": 0.265625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.615795850753784,
"time_mean_s": 2.486567258834839,
"brakes_mean": 19.5546875,
"start_fail": 0.0,
"goal_ratio_2s": 0.27920001745224,
"err_fail_med": 204.71360778808594,
"err_success_med": 0.21751396358013153,
"dls_share": 0.61328125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24741201102733612,
"reverse_mean": 0.25991496443748474,
"reverse_moving_p50": 0.32581019401550293,
"moving_share_p50": 0.9587156176567078,
"brake_rate_mean": 0.10028044879436493,
"brake_rate_p50": 0.0051282052882015705,
"n_plans_mean": 195.0
},
"simulation_wall_s": 319.19268320000265
}
+84
View File
@@ -0,0 +1,84 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round38_backoff1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 1,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.52734375,
"collision_free_success": 0.52734375,
"time_ok_1p3": 0.26953125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.615795850753784,
"time_mean_s": 2.479703664779663,
"brakes_mean": 18.77734375,
"start_fail": 0.0,
"goal_ratio_2s": 0.27920001745224,
"err_fail_med": 212.4702606201172,
"err_success_med": 0.20242473483085632,
"dls_share": 0.6171875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.2482638955116272,
"reverse_mean": 0.2603996992111206,
"reverse_moving_p50": 0.3252427279949188,
"moving_share_p50": 0.9640287756919861,
"brake_rate_mean": 0.09629407525062561,
"brake_rate_p50": 0.0051282052882015705,
"n_plans_mean": 195.0,
"backoff_mean": 1.57421875,
"reject_all_mean": 20.3515625
},
"simulation_wall_s": 334.8870786000043
}
+84
View File
@@ -0,0 +1,84 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round38_backoff2.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 2,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5234375,
"collision_free_success": 0.5234375,
"time_ok_1p3": 0.26171875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.5341429710388184,
"time_mean_s": 2.4558210372924805,
"brakes_mean": 18.1171875,
"start_fail": 0.0,
"goal_ratio_2s": 0.274954229593277,
"err_fail_med": 207.97683715820312,
"err_success_med": 0.19538111984729767,
"dls_share": 0.60546875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24827586114406586,
"reverse_mean": 0.2605503499507904,
"reverse_moving_p50": 0.32248520851135254,
"moving_share_p50": 0.9672130942344666,
"brake_rate_mean": 0.09290865808725357,
"brake_rate_p50": 0.0051282052882015705,
"n_plans_mean": 195.0,
"backoff_mean": 4.99609375,
"reject_all_mean": 23.11328125
},
"simulation_wall_s": 369.2254191000102
}
+84
View File
@@ -0,0 +1,84 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round38_backoff3.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 3,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.515625,
"collision_free_success": 0.515625,
"time_ok_1p3": 0.2578125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.529658794403076,
"time_mean_s": 2.4427273273468018,
"brakes_mean": 16.48046875,
"start_fail": 0.0,
"goal_ratio_2s": 0.2868920564651489,
"err_fail_med": 208.72935485839844,
"err_success_med": 0.20242473483085632,
"dls_share": 0.60546875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.25,
"reverse_mean": 0.26120537519454956,
"reverse_moving_p50": 0.3236245810985565,
"moving_share_p50": 0.9672130942344666,
"brake_rate_mean": 0.08451522886753082,
"brake_rate_p50": 0.0051282052882015705,
"n_plans_mean": 195.0,
"backoff_mean": 9.703125,
"reject_all_mean": 26.18359375
},
"simulation_wall_s": 416.57447530000354
}
+22
View File
@@ -0,0 +1,22 @@
{
"K": 8,
"n": 256,
"steps1": {
"cand_spread": 0.8518,
"first_step_norm": 1.1565,
"clamp_saturated_rate": 0.0516,
"pairwise_mean": 5.3647
},
"steps2": {
"cand_spread": 0.0245,
"first_step_norm": 1.0956,
"clamp_saturated_rate": 0.0385,
"pairwise_mean": 0.3024
},
"steps4": {
"cand_spread": 0.0211,
"first_step_norm": 1.097,
"clamp_saturated_rate": 0.0689,
"pairwise_mean": 0.2861
}
}
@@ -0,0 +1,19 @@
[
{
"label": "steps=1 cap=0",
"n": 256,
"arrived": 147,
"failed": 109,
"buckets": {
"姿态没到位(位置<5mm)": 3,
"位置 5~20mm": 5,
"位置 20~100mm": 15,
"位置 >100mm 且刹车>30(被挡)": 63,
"位置 >100mm 且刹车<=30(方向/绕圈)": 23,
"起步失败": 0
},
"failed_e_p50": 255.333598802122,
"failed_oe_p50": 11.016554443385107,
"failed_still_share_p50": 0.3722222149372101
}
]
+611
View File
@@ -0,0 +1,611 @@
{
"device": "NVIDIA GeForce RTX 3090",
"B": 1,
"K": 8,
"rounds": 24,
"per_round": {
"1": [
{
"p50": 9.198,
"p95": 11.654,
"p99": 12.236,
"max": 12.236
},
{
"p50": 9.211,
"p95": 13.105,
"p99": 13.765,
"max": 13.765
},
{
"p50": 9.188,
"p95": 12.363,
"p99": 15.901,
"max": 15.901
},
{
"p50": 8.894,
"p95": 10.426,
"p99": 11.641,
"max": 11.641
},
{
"p50": 8.968,
"p95": 11.664,
"p99": 11.874,
"max": 11.874
},
{
"p50": 9.456,
"p95": 13.502,
"p99": 13.951,
"max": 13.951
},
{
"p50": 8.683,
"p95": 10.991,
"p99": 11.978,
"max": 11.978
},
{
"p50": 9.599,
"p95": 13.894,
"p99": 17.102,
"max": 17.102
},
{
"p50": 9.405,
"p95": 13.07,
"p99": 13.111,
"max": 13.111
},
{
"p50": 8.947,
"p95": 10.154,
"p99": 10.405,
"max": 10.405
},
{
"p50": 9.019,
"p95": 10.835,
"p99": 12.272,
"max": 12.272
},
{
"p50": 8.824,
"p95": 13.516,
"p99": 15.963,
"max": 15.963
},
{
"p50": 8.819,
"p95": 11.004,
"p99": 11.308,
"max": 11.308
},
{
"p50": 8.777,
"p95": 10.7,
"p99": 11.144,
"max": 11.144
},
{
"p50": 8.926,
"p95": 11.911,
"p99": 12.171,
"max": 12.171
},
{
"p50": 8.924,
"p95": 10.88,
"p99": 11.94,
"max": 11.94
},
{
"p50": 8.508,
"p95": 9.918,
"p99": 11.57,
"max": 11.57
},
{
"p50": 9.351,
"p95": 17.795,
"p99": 17.948,
"max": 17.948
},
{
"p50": 8.779,
"p95": 10.188,
"p99": 11.614,
"max": 11.614
},
{
"p50": 9.389,
"p95": 19.998,
"p99": 25.582,
"max": 25.582
},
{
"p50": 9.344,
"p95": 15.293,
"p99": 16.308,
"max": 16.308
},
{
"p50": 9.67,
"p95": 13.045,
"p99": 13.805,
"max": 13.805
},
{
"p50": 10.331,
"p95": 13.905,
"p99": 21.628,
"max": 21.628
},
{
"p50": 8.96,
"p95": 10.848,
"p99": 11.741,
"max": 11.741
}
],
"2": [
{
"p50": 15.201,
"p95": 18.17,
"p99": 19.766,
"max": 19.766
},
{
"p50": 14.902,
"p95": 17.614,
"p99": 18.457,
"max": 18.457
},
{
"p50": 15.324,
"p95": 18.549,
"p99": 19.078,
"max": 19.078
},
{
"p50": 15.021,
"p95": 19.99,
"p99": 21.951,
"max": 21.951
},
{
"p50": 14.689,
"p95": 18.919,
"p99": 19.926,
"max": 19.926
},
{
"p50": 16.051,
"p95": 32.815,
"p99": 33.077,
"max": 33.077
},
{
"p50": 14.717,
"p95": 17.324,
"p99": 17.522,
"max": 17.522
},
{
"p50": 15.032,
"p95": 18.216,
"p99": 19.497,
"max": 19.497
},
{
"p50": 15.555,
"p95": 19.893,
"p99": 21.052,
"max": 21.052
},
{
"p50": 14.499,
"p95": 16.796,
"p99": 16.882,
"max": 16.882
},
{
"p50": 14.645,
"p95": 17.099,
"p99": 17.543,
"max": 17.543
},
{
"p50": 14.358,
"p95": 21.149,
"p99": 24.103,
"max": 24.103
},
{
"p50": 14.984,
"p95": 18.661,
"p99": 20.683,
"max": 20.683
},
{
"p50": 14.502,
"p95": 17.139,
"p99": 17.798,
"max": 17.798
},
{
"p50": 14.947,
"p95": 16.647,
"p99": 16.766,
"max": 16.766
},
{
"p50": 14.786,
"p95": 17.521,
"p99": 19.179,
"max": 19.179
},
{
"p50": 14.749,
"p95": 19.165,
"p99": 25.119,
"max": 25.119
},
{
"p50": 16.221,
"p95": 28.768,
"p99": 29.582,
"max": 29.582
},
{
"p50": 14.652,
"p95": 28.668,
"p99": 30.074,
"max": 30.074
},
{
"p50": 17.139,
"p95": 32.269,
"p99": 32.377,
"max": 32.377
},
{
"p50": 14.907,
"p95": 20.386,
"p99": 20.81,
"max": 20.81
},
{
"p50": 15.882,
"p95": 17.677,
"p99": 18.192,
"max": 18.192
},
{
"p50": 15.359,
"p95": 18.135,
"p99": 18.531,
"max": 18.531
},
{
"p50": 15.207,
"p95": 17.382,
"p99": 18.529,
"max": 18.529
}
],
"4": [
{
"p50": 26.665,
"p95": 31.215,
"p99": 34.178,
"max": 34.178
},
{
"p50": 27.294,
"p95": 33.673,
"p99": 35.04,
"max": 35.04
},
{
"p50": 27.918,
"p95": 34.553,
"p99": 42.061,
"max": 42.061
},
{
"p50": 26.37,
"p95": 30.528,
"p99": 32.127,
"max": 32.127
},
{
"p50": 25.9,
"p95": 28.742,
"p99": 34.469,
"max": 34.469
},
{
"p50": 27.106,
"p95": 35.303,
"p99": 40.808,
"max": 40.808
},
{
"p50": 26.195,
"p95": 34.707,
"p99": 45.867,
"max": 45.867
},
{
"p50": 26.772,
"p95": 30.526,
"p99": 30.766,
"max": 30.766
},
{
"p50": 26.886,
"p95": 46.087,
"p99": 50.21,
"max": 50.21
},
{
"p50": 26.004,
"p95": 29.001,
"p99": 30.311,
"max": 30.311
},
{
"p50": 27.095,
"p95": 32.363,
"p99": 38.011,
"max": 38.011
},
{
"p50": 25.952,
"p95": 30.357,
"p99": 31.543,
"max": 31.543
},
{
"p50": 26.537,
"p95": 30.396,
"p99": 31.056,
"max": 31.056
},
{
"p50": 26.563,
"p95": 28.768,
"p99": 30.415,
"max": 30.415
},
{
"p50": 26.863,
"p95": 32.136,
"p99": 32.967,
"max": 32.967
},
{
"p50": 28.413,
"p95": 50.4,
"p99": 58.088,
"max": 58.088
},
{
"p50": 26.623,
"p95": 32.801,
"p99": 35.603,
"max": 35.603
},
{
"p50": 27.344,
"p95": 32.779,
"p99": 38.661,
"max": 38.661
},
{
"p50": 26.408,
"p95": 29.565,
"p99": 30.094,
"max": 30.094
},
{
"p50": 26.198,
"p95": 29.741,
"p99": 30.489,
"max": 30.489
},
{
"p50": 27.724,
"p95": 32.174,
"p99": 32.423,
"max": 32.423
},
{
"p50": 26.724,
"p95": 31.253,
"p99": 32.153,
"max": 32.153
},
{
"p50": 26.76,
"p95": 31.054,
"p99": 31.087,
"max": 31.087
},
{
"p50": 26.278,
"p95": 31.043,
"p99": 39.867,
"max": 39.867
}
],
"8": [
{
"p50": 52.266,
"p95": 68.035,
"p99": 74.885,
"max": 74.885
},
{
"p50": 54.125,
"p95": 85.092,
"p99": 96.265,
"max": 96.265
},
{
"p50": 56.176,
"p95": 85.733,
"p99": 87.312,
"max": 87.312
},
{
"p50": 51.069,
"p95": 60.145,
"p99": 62.654,
"max": 62.654
},
{
"p50": 51.07,
"p95": 61.397,
"p99": 65.437,
"max": 65.437
},
{
"p50": 52.133,
"p95": 69.749,
"p99": 79.426,
"max": 79.426
},
{
"p50": 49.955,
"p95": 60.339,
"p99": 60.455,
"max": 60.455
},
{
"p50": 50.468,
"p95": 64.167,
"p99": 66.843,
"max": 66.843
},
{
"p50": 49.244,
"p95": 52.489,
"p99": 54.475,
"max": 54.475
},
{
"p50": 49.644,
"p95": 57.36,
"p99": 58.934,
"max": 58.934
},
{
"p50": 52.186,
"p95": 59.122,
"p99": 68.662,
"max": 68.662
},
{
"p50": 51.393,
"p95": 75.776,
"p99": 83.858,
"max": 83.858
},
{
"p50": 51.953,
"p95": 67.169,
"p99": 69.287,
"max": 69.287
},
{
"p50": 50.324,
"p95": 60.185,
"p99": 68.603,
"max": 68.603
},
{
"p50": 50.893,
"p95": 54.805,
"p99": 58.967,
"max": 58.967
},
{
"p50": 53.696,
"p95": 65.629,
"p99": 72.674,
"max": 72.674
},
{
"p50": 48.672,
"p95": 62.026,
"p99": 62.276,
"max": 62.276
},
{
"p50": 50.777,
"p95": 65.002,
"p99": 66.318,
"max": 66.318
},
{
"p50": 48.835,
"p95": 57.514,
"p99": 69.18,
"max": 69.18
},
{
"p50": 50.785,
"p95": 73.072,
"p99": 75.93,
"max": 75.93
},
{
"p50": 50.684,
"p95": 65.827,
"p99": 75.478,
"max": 75.478
},
{
"p50": 50.341,
"p95": 57.511,
"p99": 58.992,
"max": 58.992
},
{
"p50": 51.567,
"p95": 66.644,
"p99": 67.094,
"max": 67.094
},
{
"p50": 52.094,
"p95": 71.313,
"p99": 73.767,
"max": 73.767
}
]
},
"summary": {
"p501": 9.019,
"p951": 11.911,
"p991": 12.272,
"p502": 14.984,
"p952": 18.549,
"p992": 19.766,
"p504": 26.724,
"p954": 31.253,
"p994": 34.178,
"p508": 51.069,
"p958": 65.002,
"p998": 68.662
},
"delta_vs_1step_ms": {
"d502": 5.965,
"d504": 17.705,
"d508": 42.05
}
}
+77
View File
@@ -0,0 +1,77 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 16,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round39_K16.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5625,
"collision_free_success": 0.5625,
"time_ok_1p3": 0.296875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.6243183612823486,
"time_mean_s": 2.6024999618530273,
"brakes_mean": 13.7734375,
"start_fail": 0.0,
"goal_ratio_2s": 0.2799961566925049,
"err_fail_med": 195.448486328125,
"err_success_med": 0.15947841107845306,
"dls_share": 0.640625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 1.5750000476837158,
"reverse_mean": 1.6161863803863525
},
"simulation_wall_s": 573.4911701000092
}
+75
View File
@@ -0,0 +1,75 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round39_lenw0.1.json",
"trace": null,
"select": "ep_len",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.1,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.51171875,
"collision_free_success": 0.51171875,
"time_ok_1p3": 0.26953125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.621551036834717,
"time_mean_s": 2.4761831760406494,
"brakes_mean": 19.48828125,
"start_fail": 0.0,
"goal_ratio_2s": 0.2874715030193329,
"err_fail_med": 208.0048065185547,
"err_success_med": 0.24376358091831207,
"dls_share": 0.6171875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118
},
"simulation_wall_s": 333.6044210000109
}
+75
View File
@@ -0,0 +1,75 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round39_lenw0.3.json",
"trace": null,
"select": "ep_len",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.3,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.51953125,
"collision_free_success": 0.51953125,
"time_ok_1p3": 0.28515625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.6547701358795166,
"time_mean_s": 2.4798495769500732,
"brakes_mean": 20.00390625,
"start_fail": 0.0,
"goal_ratio_2s": 0.2706023156642914,
"err_fail_med": 208.01719665527344,
"err_success_med": 0.2188246101140976,
"dls_share": 0.62109375,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118
},
"simulation_wall_s": 340.16115129999525
}
+75
View File
@@ -0,0 +1,75 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round39_lenw1.0.json",
"trace": null,
"select": "ep_len",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 1.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.52734375,
"collision_free_success": 0.52734375,
"time_ok_1p3": 0.2890625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.6718690395355225,
"time_mean_s": 2.463407516479492,
"brakes_mean": 19.3515625,
"start_fail": 0.0,
"goal_ratio_2s": 0.2807892858982086,
"err_fail_med": 205.99014282226562,
"err_success_med": 0.23181582987308502,
"dls_share": 0.62890625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118
},
"simulation_wall_s": 368.1434382000007
}
+32
View File
@@ -0,0 +1,32 @@
{
"n_tasks": 256,
"n_plans": 195,
"cap_mm": 0.5,
"run_points": 169216,
"gap_hist_of_run_points": {
"<0.02": 0.0025056733284145594,
"<0.05": 0.0043317414820194244,
"<0.10": 0.008356183767318726,
"<0.20": 0.019064391031861305,
"<0.50": 0.055952154099941254
},
"at_cap_share": 0.9097898602485657,
"min_gap_per_task_p50": 0.02924060821533203,
"plan_kind": {
"full": 0.7935897707939148,
"partial": 0.10769230872392654,
"rejected": 0.09871795028448105
},
"per_task": {
"plans_p50": 195.0,
"committed_steps_share": 0.9871794581413269,
"rejected_share_by_group": {
"arrived": 0.008826094679534435,
"failed": 0.21994824707508087
}
},
"rejected_step_share_by_group": {
"arrived": 0.01765218935906887,
"failed": 0.43989649415016174
}
}
@@ -0,0 +1,16 @@
[
{
"file": "round33_cap.pt",
"reverse_p50": 0.2474,
"reverse_p50_arrived": 0.265,
"reverse_p50_failed": 0.2329,
"nact_p50": 168.0
},
{
"file": "round33_base.pt",
"reverse_p50": 0.257,
"reverse_p50_arrived": 0.2753,
"reverse_p50_failed": 0.2402,
"nact_p50": 152.0
}
]
@@ -0,0 +1,28 @@
{
"n": 256,
"travel_ratio_median": 2.425084623442128,
"travel_ratio_population": "arrived & 有老师参考(与 eval 的 okr 同口径)",
"reverse_rate": {
"p25": 0.15732546150684357,
"p50": 0.23536035418510437,
"p75": 0.3025793731212616
},
"net_over_travel_p50": 0.4447892699092449,
"excursion_over_travel_p50": 0.5067885044066773,
"still_rate_p50": 0.028846153989434242,
"by_group": {
"arrived": {
"n": 147,
"reverse_p50": 0.26143792271614075,
"net_over_travel_p50": 0.47818613856136644,
"excursion_p50": 0.5500977881151917
},
"failed": {
"n": 109,
"reverse_p50": 0.14653243124485016,
"net_over_travel_p50": 0.3515762667187255,
"excursion_p50": 0.39037085057225707
}
},
"note": "net/行程 越接近 1 越\"单向\";越小越来回抖。excursion/行程 = 各轴走过最大幅度的和 / 总行程,绕远时它接近 1、抖动时明显小于 1"
}
+77
View File
@@ -0,0 +1,77 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 1,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round39_try1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.40234375,
"collision_free_success": 0.40234375,
"time_ok_1p3": 0.22265625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.5106539726257324,
"time_mean_s": 2.253203868865967,
"brakes_mean": 60.44140625,
"start_fail": 0.0,
"goal_ratio_2s": 0.4367985725402832,
"err_fail_med": 243.9196319580078,
"err_success_med": 0.21751396358013153,
"dls_share": 0.53125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000038146972656,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.18634259700775146,
"reverse_mean": 0.19426266849040985
},
"simulation_wall_s": 111.52556069999991
}
+77
View File
@@ -0,0 +1,77 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 3,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round39_try3.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.45703125,
"collision_free_success": 0.45703125,
"time_ok_1p3": 0.23828125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.529658794403076,
"time_mean_s": 2.3210256099700928,
"brakes_mean": 37.75390625,
"start_fail": 0.0,
"goal_ratio_2s": 0.3564552068710327,
"err_fail_med": 220.24862670898438,
"err_success_med": 0.23727791011333466,
"dls_share": 0.56640625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.22442243993282318,
"reverse_mean": 0.23038837313652039
},
"simulation_wall_s": 170.3933407000004
}
+79
View File
@@ -0,0 +1,79 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round39_z15.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.5,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.49609375,
"collision_free_success": 0.49609375,
"time_ok_1p3": 0.18359375,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 3.52425217628479,
"time_mean_s": 2.805511713027954,
"brakes_mean": 10.51171875,
"start_fail": 0.0,
"goal_ratio_2s": 0.27530819177627563,
"err_fail_med": 105.35015869140625,
"err_success_med": 0.23657508194446564,
"dls_share": 0.62890625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.32083332538604736,
"reverse_mean": 0.3213125765323639,
"reverse_moving_p50": 0.35158151388168335,
"moving_share_p50": 0.9866666793823242
},
"simulation_wall_s": 311.9796243000019
}
+82
View File
@@ -0,0 +1,82 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 16,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round40_K16cb1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5625,
"collision_free_success": 0.5625,
"time_ok_1p3": 0.296875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.6243183612823486,
"time_mean_s": 2.6024999618530273,
"brakes_mean": 13.7734375,
"start_fail": 0.0,
"goal_ratio_2s": 0.2799961566925049,
"err_fail_med": 195.448486328125,
"err_success_med": 0.15947841107845306,
"dls_share": 0.640625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.26249998807907104,
"reverse_mean": 0.2693643867969513,
"reverse_moving_p50": 0.3194444477558136,
"moving_share_p50": 0.9869565367698669,
"brake_rate_mean": 0.07063301652669907,
"brake_rate_p50": 0.0,
"n_plans_mean": 195.0
},
"simulation_wall_s": 469.2955887999997
}
+226
View File
@@ -0,0 +1,226 @@
{
"device": "NVIDIA GeForce RTX 3090",
"B": 1,
"inc_cap": 1,
"infer": {
"8": [
{
"p50": 9.285,
"p95": 10.62
},
{
"p50": 9.227,
"p95": 15.144
},
{
"p50": 10.015,
"p95": 18.492
},
{
"p50": 10.114,
"p95": 15.477
}
],
"16": [
{
"p50": 9.281,
"p95": 12.2
},
{
"p50": 9.321,
"p95": 15.859
},
{
"p50": 11.673,
"p95": 17.75
},
{
"p50": 9.22,
"p95": 11.764
}
]
},
"plan": {
"8/cb0": [
{
"p50": 134.514,
"p95": 146.198,
"max": 151.847
},
{
"p50": 147.029,
"p95": 180.064,
"max": 191.364
},
{
"p50": 133.562,
"p95": 145.323,
"max": 150.765
},
{
"p50": 141.62,
"p95": 163.992,
"max": 194.319
},
{
"p50": 146.427,
"p95": 186.324,
"max": 189.776
},
{
"p50": 144.785,
"p95": 164.472,
"max": 168.658
},
{
"p50": 144.466,
"p95": 204.952,
"max": 227.804
},
{
"p50": 151.671,
"p95": 189.823,
"max": 241.949
}
],
"16/cb0": [
{
"p50": 133.572,
"p95": 153.984,
"max": 156.276
},
{
"p50": 144.001,
"p95": 170.74,
"max": 185.805
},
{
"p50": 139.492,
"p95": 162.124,
"max": 165.545
},
{
"p50": 139.614,
"p95": 152.373,
"max": 153.8
},
{
"p50": 137.178,
"p95": 158.119,
"max": 161.382
},
{
"p50": 136.955,
"p95": 175.71,
"max": 186.645
},
{
"p50": 143.252,
"p95": 166.76,
"max": 182.599
},
{
"p50": 149.9,
"p95": 200.22,
"max": 201.094
}
],
"8/cb1": [
{
"p50": 151.167,
"p95": 164.805,
"max": 187.036
},
{
"p50": 148.91,
"p95": 168.584,
"max": 177.316
},
{
"p50": 162.24,
"p95": 204.403,
"max": 222.327
},
{
"p50": 158.656,
"p95": 197.649,
"max": 224.336
},
{
"p50": 149.629,
"p95": 176.731,
"max": 187.429
},
{
"p50": 149.44,
"p95": 200.478,
"max": 243.552
},
{
"p50": 150.726,
"p95": 200.097,
"max": 242.956
},
{
"p50": 146.359,
"p95": 165.303,
"max": 165.497
}
],
"16/cb1": [
{
"p50": 156.341,
"p95": 180.399,
"max": 184.267
},
{
"p50": 169.067,
"p95": 206.577,
"max": 218.282
},
{
"p50": 169.66,
"p95": 190.207,
"max": 202.072
},
{
"p50": 163.572,
"p95": 185.455,
"max": 192.382
},
{
"p50": 172.023,
"p95": 204.316,
"max": 225.098
},
{
"p50": 166.825,
"p95": 201.437,
"max": 236.891
},
{
"p50": 171.442,
"p95": 207.533,
"max": 226.472
},
{
"p50": 159.815,
"p95": 198.534,
"max": 207.788
}
]
},
"summary": {
"infer_p50_K8": 10.015,
"infer_p50_K16": 9.321,
"plan_p50_8/cb0": 144.785,
"plan_p50_16/cb0": 139.614,
"plan_p50_8/cb1": 150.726,
"plan_p50_16/cb1": 169.067,
"plan_p95_8/cb0": 180.064,
"plan_p95_16/cb0": 166.76,
"plan_p95_8/cb1": 197.649,
"plan_p95_16/cb1": 201.437
},
"note": "K16/try3 那批臂是串行认证(cert_batch=0),最坏要 K 次 gaps 调用;部署口径应是批量认证=1 次调用,所以两种口径都要量"
}
@@ -0,0 +1,82 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round40_safetyoff_steps1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 0,
"partial": 1,
"inc_cap": 0,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.77734375,
"collision_free_success": 0.359375,
"time_ok_1p3": 0.53515625,
"collision_rate": 0.5859375,
"collision_steps_mean": 58.33984375,
"travel_ratio_median": 2.375220775604248,
"time_mean_s": 2.3642210960388184,
"brakes_mean": 0.0,
"start_fail": 0.0,
"goal_ratio_2s": 0.0402195081114769,
"err_fail_med": 50.388858795166016,
"err_success_med": 0.1961677223443985,
"dls_share": 0.84765625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.6600004434585571,
"speed_ratio_p95": 1.660003662109375,
"speed_ratio_max": 1.660003662109375,
"over_vmax_rate": 1.0,
"accel_ratio_p95": 1.5426017045974731,
"accel_ratio_max": 1.6600004434585571,
"reverse_p50": 0.2846153974533081,
"reverse_mean": 0.2833859324455261,
"reverse_moving_p50": 0.2846153974533081,
"moving_share_p50": 1.0,
"brake_rate_mean": 0.0,
"brake_rate_p50": 0.0,
"n_plans_mean": 195.0
},
"simulation_wall_s": 52.50466950000555
}
@@ -0,0 +1,82 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round40_safetyoff_steps2.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 0,
"partial": 1,
"inc_cap": 0,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 2,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.81640625,
"collision_free_success": 0.375,
"time_ok_1p3": 0.68359375,
"collision_rate": 0.55859375,
"collision_steps_mean": 45.07421875,
"travel_ratio_median": 1.5936355590820312,
"time_mean_s": 2.019808530807495,
"brakes_mean": 0.0,
"start_fail": 0.0,
"goal_ratio_2s": 0.003008240135386586,
"err_fail_med": 48.19245529174805,
"err_success_med": 0.2415877878665924,
"dls_share": 0.8515625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.6600004434585571,
"speed_ratio_p95": 1.660003662109375,
"speed_ratio_max": 1.660003662109375,
"over_vmax_rate": 0.9921875,
"accel_ratio_p95": 1.010289192199707,
"accel_ratio_max": 1.4423871040344238,
"reverse_p50": 0.08469945192337036,
"reverse_mean": 0.09047156572341919,
"reverse_moving_p50": 0.08469945192337036,
"moving_share_p50": 1.0,
"brake_rate_mean": 0.0,
"brake_rate_p50": 0.0,
"n_plans_mean": 195.0
},
"simulation_wall_s": 58.29419349999807
}
+82
View File
@@ -0,0 +1,82 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round40_waste0.1.json",
"trace": null,
"select": "ep_waste",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.1,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.515625,
"collision_free_success": 0.515625,
"time_ok_1p3": 0.26953125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.669708251953125,
"time_mean_s": 2.452272653579712,
"brakes_mean": 19.39453125,
"start_fail": 0.0,
"goal_ratio_2s": 0.28827616572380066,
"err_fail_med": 201.7505645751953,
"err_success_med": 0.20423255860805511,
"dls_share": 0.609375,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.2527472674846649,
"reverse_mean": 0.262615442276001,
"reverse_moving_p50": 0.31912145018577576,
"moving_share_p50": 0.9599999785423279,
"brake_rate_mean": 0.09945914149284363,
"brake_rate_p50": 0.0051282052882015705,
"n_plans_mean": 195.0
},
"simulation_wall_s": 308.12369770000805
}
+82
View File
@@ -0,0 +1,82 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round40_waste0.3.json",
"trace": null,
"select": "ep_waste",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.3,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.515625,
"collision_free_success": 0.515625,
"time_ok_1p3": 0.265625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.5349059104919434,
"time_mean_s": 2.476060628890991,
"brakes_mean": 19.62890625,
"start_fail": 0.0,
"goal_ratio_2s": 0.31392601132392883,
"err_fail_med": 200.5723876953125,
"err_success_med": 0.16847863793373108,
"dls_share": 0.609375,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.25111111998558044,
"reverse_mean": 0.26184794306755066,
"reverse_moving_p50": 0.3268229067325592,
"moving_share_p50": 0.9636363387107849,
"brake_rate_mean": 0.10066106170415878,
"brake_rate_p50": 0.0051282052882015705,
"n_plans_mean": 195.0
},
"simulation_wall_s": 299.3823047999904
}
+82
View File
@@ -0,0 +1,82 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round40_waste1.0.json",
"trace": null,
"select": "ep_waste",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 1.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.48828125,
"collision_free_success": 0.48828125,
"time_ok_1p3": 0.23828125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.708263874053955,
"time_mean_s": 2.5168001651763916,
"brakes_mean": 20.02734375,
"start_fail": 0.0,
"goal_ratio_2s": 0.3584502637386322,
"err_fail_med": 190.41900634765625,
"err_success_med": 0.33570292592048645,
"dls_share": 0.60546875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24899598956108093,
"reverse_mean": 0.2592279314994812,
"reverse_moving_p50": 0.3214285671710968,
"moving_share_p50": 0.9587156176567078,
"brake_rate_mean": 0.10270433127880096,
"brake_rate_p50": 0.010256410576403141,
"n_plans_mean": 195.0
},
"simulation_wall_s": 297.2535624000011
}
+107
View File
@@ -0,0 +1,107 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 16,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round42_K16cb1_rows.json",
"out": "docs/experiment_round42_K16cb1_dump.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5625,
"collision_free_success": 0.5625,
"time_ok_1p3": 0.296875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.6243183612823486,
"time_mean_s": 2.6024999618530273,
"brakes_mean": 13.7734375,
"start_fail": 0.0,
"goal_ratio_2s": 0.2799961566925049,
"err_fail_med": 195.448486328125,
"err_success_med": 0.15947841107845306,
"dls_share": 0.640625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.26249998807907104,
"reverse_mean": 0.2693643867969513,
"reverse_moving_p50": 0.3194444477558136,
"moving_share_p50": 0.9869565367698669,
"brake_rate_mean": 0.07063301652669907,
"brake_rate_p50": 0.0,
"brake_rate_p90": 0.2589743733406067,
"stuck_share": 0.15234375,
"n_plans_mean": 195.0,
"success_reachable": 0.5925925970077515,
"by_cat": {
"A": [
128,
100
],
"B": [
74,
24
],
"C": [
32,
12
],
"D": [
13,
0
],
"Dr": [
9,
8
]
}
},
"simulation_wall_s": 613.4877918999991
}
+107
View File
@@ -0,0 +1,107 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round42_K8cb1_rows.json",
"out": "docs/experiment_round42_K8cb1_dump.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5234375,
"collision_free_success": 0.5234375,
"time_ok_1p3": 0.265625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.615795850753784,
"time_mean_s": 2.486567258834839,
"brakes_mean": 19.5546875,
"start_fail": 0.0,
"goal_ratio_2s": 0.27920001745224,
"err_fail_med": 204.71360778808594,
"err_success_med": 0.21751396358013153,
"dls_share": 0.61328125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24741201102733612,
"reverse_mean": 0.25991496443748474,
"reverse_moving_p50": 0.32581019401550293,
"moving_share_p50": 0.9587156176567078,
"brake_rate_mean": 0.10028044879436493,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.3153846263885498,
"stuck_share": 0.234375,
"n_plans_mean": 195.0,
"success_reachable": 0.5514403581619263,
"by_cat": {
"A": [
128,
96
],
"B": [
74,
20
],
"C": [
32,
11
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 397.44336470001144
}
+107
View File
@@ -0,0 +1,107 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round43_control_strat.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 0,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5234375,
"collision_free_success": 0.5234375,
"time_ok_1p3": 0.265625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.615795850753784,
"time_mean_s": 2.486567258834839,
"brakes_mean": 19.5546875,
"start_fail": 0.0,
"goal_ratio_2s": 0.27920001745224,
"err_fail_med": 204.71360778808594,
"err_success_med": 0.21751396358013153,
"dls_share": 0.61328125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24741201102733612,
"reverse_mean": 0.25991496443748474,
"reverse_moving_p50": 0.32581019401550293,
"moving_share_p50": 0.9587156176567078,
"brake_rate_mean": 0.10028044879436493,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.3153846263885498,
"stuck_share": 0.234375,
"n_plans_mean": 195.0,
"success_reachable": 0.5514403581619263,
"by_cat": {
"A": [
128,
96
],
"B": [
74,
20
],
"C": [
32,
11
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 353.7248780000082
}
+111
View File
@@ -0,0 +1,111 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 64,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round44_tieprobe64_rows.json",
"out": "docs/experiment_round44_tieprobe64.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 1,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "6185a312dbae3bf5b361c4b9ff3aa11b7329d9723cff2be9b9157563d6b6ec1c",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 64,
"n_ref": 64,
"success": 0.40625,
"collision_free_success": 0.40625,
"time_ok_1p3": 0.234375,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.358931303024292,
"time_mean_s": 2.3323075771331787,
"brakes_mean": 18.71875,
"start_fail": 0.0,
"goal_ratio_2s": 0.33309799432754517,
"err_fail_med": 229.02410888671875,
"err_success_med": 0.22094391286373138,
"dls_share": 0.515625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000091791152954,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.25150150060653687,
"reverse_mean": 0.25861242413520813,
"reverse_moving_p50": 0.318452388048172,
"moving_share_p50": 0.9090909361839294,
"brake_rate_mean": 0.10696429014205933,
"brake_rate_p50": 0.017142856493592262,
"brake_rate_p90": 0.33142855763435364,
"stuck_share": 0.21875,
"n_plans_mean": 175.0,
"success_reachable": 0.4262295067310333,
"by_cat": {
"A": [
28,
14
],
"B": [
21,
6
],
"C": [
9,
4
],
"D": [
3,
0
],
"Dr": [
3,
2
]
},
"tie_opp_rate_mean": 0.7484821081161499,
"tie_changed_rate_mean": 0.07437500357627869,
"tie_opp_task_share": 1.0
},
"simulation_wall_s": 78.19308080000337
}
+108
View File
@@ -0,0 +1,108 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round45_tie0_rows.json",
"out": "docs/experiment_round45_tie0.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5234375,
"collision_free_success": 0.5234375,
"time_ok_1p3": 0.265625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.615795850753784,
"time_mean_s": 2.486567258834839,
"brakes_mean": 19.5546875,
"start_fail": 0.0,
"goal_ratio_2s": 0.27920001745224,
"err_fail_med": 204.71360778808594,
"err_success_med": 0.21751396358013153,
"dls_share": 0.61328125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24741201102733612,
"reverse_mean": 0.25991496443748474,
"reverse_moving_p50": 0.32581019401550293,
"moving_share_p50": 0.9587156176567078,
"brake_rate_mean": 0.10028044879436493,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.3153846263885498,
"stuck_share": 0.234375,
"n_plans_mean": 195.0,
"success_reachable": 0.5514403581619263,
"by_cat": {
"A": [
128,
96
],
"B": [
74,
20
],
"C": [
32,
11
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 317.56223549999413
}
+111
View File
@@ -0,0 +1,111 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round45_tie1_rows.json",
"out": "docs/experiment_round45_tie1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 1,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.50390625,
"collision_free_success": 0.50390625,
"time_ok_1p3": 0.27734375,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.53989315032959,
"time_mean_s": 2.3586044311523438,
"brakes_mean": 17.7890625,
"start_fail": 0.0,
"goal_ratio_2s": 0.27920001745224,
"err_fail_med": 213.06358337402344,
"err_success_med": 0.22968679666519165,
"dls_share": 0.62109375,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.25315314531326294,
"reverse_mean": 0.26444095373153687,
"reverse_moving_p50": 0.3198198080062866,
"moving_share_p50": 0.9772727489471436,
"brake_rate_mean": 0.09122596681118011,
"brake_rate_p50": 0.0,
"brake_rate_p90": 0.3282051384449005,
"stuck_share": 0.203125,
"n_plans_mean": 195.0,
"success_reachable": 0.5308641791343689,
"by_cat": {
"A": [
128,
91
],
"B": [
74,
19
],
"C": [
32,
12
],
"D": [
13,
0
],
"Dr": [
9,
7
]
},
"tie_opp_rate_mean": 0.7898838520050049,
"tie_changed_rate_mean": 0.055829327553510666,
"tie_opp_task_share": 1.0
},
"simulation_wall_s": 283.46215640001174
}
+96
View File
@@ -0,0 +1,96 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 16,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round46_ep16_smoke.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "7b7c219c70d15b280682fe0626192b267f0e4dfd843b1e70fb279e148eb6eaa3",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 16,
"n_ref": 16,
"success": 0.375,
"collision_free_success": 0.375,
"time_ok_1p3": 0.25,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.426271438598633,
"time_mean_s": 2.680000066757202,
"brakes_mean": 24.9375,
"start_fail": 0.0,
"goal_ratio_2s": 0.43800246715545654,
"err_fail_med": 231.5127410888672,
"err_success_med": 0.2731371223926544,
"dls_share": 0.5,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000053644180298,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000016689300537,
"reverse_p50": 0.22442243993282318,
"reverse_mean": 0.2425607144832611,
"reverse_moving_p50": 0.30572596192359924,
"moving_share_p50": 0.7567567825317383,
"brake_rate_mean": 0.14249999821186066,
"brake_rate_p50": 0.07428571581840515,
"brake_rate_p90": 0.3571428656578064,
"stuck_share": 0.3125,
"n_plans_mean": 175.0,
"success_reachable": 0.375,
"by_cat": {
"A": [
8,
4
],
"B": [
8,
2
]
}
},
"simulation_wall_s": 35.48499080000329
}
+96
View File
@@ -0,0 +1,96 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 16,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": null,
"out": "docs/experiment_round46_pre16_smoke.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "7b7c219c70d15b280682fe0626192b267f0e4dfd843b1e70fb279e148eb6eaa3",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 16,
"n_ref": 16,
"success": 0.375,
"collision_free_success": 0.375,
"time_ok_1p3": 0.25,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.6735622882843018,
"time_mean_s": 2.763333320617676,
"brakes_mean": 21.9375,
"start_fail": 0.0,
"goal_ratio_2s": 0.4253818392753601,
"err_fail_med": 223.724365234375,
"err_success_med": 0.7986489534378052,
"dls_share": 0.5625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000053644180298,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000016689300537,
"reverse_p50": 0.23239436745643616,
"reverse_mean": 0.22883012890815735,
"reverse_moving_p50": 0.29054054617881775,
"moving_share_p50": 0.9583333134651184,
"brake_rate_mean": 0.12535713613033295,
"brake_rate_p50": 0.0057142856530845165,
"brake_rate_p90": 0.3257142901420593,
"stuck_share": 0.3125,
"n_plans_mean": 175.0,
"success_reachable": 0.375,
"by_cat": {
"A": [
8,
4
],
"B": [
8,
2
]
}
},
"simulation_wall_s": 31.1417752999987
}
+108
View File
@@ -0,0 +1,108 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round46_pre256_rows.json",
"out": "docs/experiment_round46_pre256.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.54296875,
"collision_free_success": 0.54296875,
"time_ok_1p3": 0.33203125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.4448752403259277,
"time_mean_s": 2.342589855194092,
"brakes_mean": 19.83984375,
"start_fail": 0.0,
"goal_ratio_2s": 0.17014972865581512,
"err_fail_med": 185.13986206054688,
"err_success_med": 0.4150978922843933,
"dls_share": 0.63671875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.22891566157341003,
"reverse_mean": 0.23401273787021637,
"reverse_moving_p50": 0.28184282779693604,
"moving_share_p50": 0.9583333134651184,
"brake_rate_mean": 0.10174279659986496,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.35384616255760193,
"stuck_share": 0.24609375,
"n_plans_mean": 195.0,
"success_reachable": 0.5720164775848389,
"by_cat": {
"A": [
128,
95
],
"B": [
74,
22
],
"C": [
32,
14
],
"D": [
13,
0
],
"Dr": [
9,
8
]
}
},
"simulation_wall_s": 319.2378991000005
}
+108
View File
@@ -0,0 +1,108 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round47_ep_s1_rows.json",
"out": "docs/experiment_round47_ep_s1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"backoff": 0,
"max_sec": null,
"seed": 1,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.53125,
"collision_free_success": 0.53125,
"time_ok_1p3": 0.296875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.636941432952881,
"time_mean_s": 2.4600000381469727,
"brakes_mean": 19.265625,
"start_fail": 0.0,
"goal_ratio_2s": 0.2750342786312103,
"err_fail_med": 214.6193084716797,
"err_success_med": 0.22276456654071808,
"dls_share": 0.62890625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.25339367985725403,
"reverse_mean": 0.2575649917125702,
"reverse_moving_p50": 0.3117443919181824,
"moving_share_p50": 0.9636363387107849,
"brake_rate_mean": 0.09879808127880096,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.3384615480899811,
"stuck_share": 0.25390625,
"n_plans_mean": 195.0,
"success_reachable": 0.5596708059310913,
"by_cat": {
"A": [
128,
96
],
"B": [
74,
21
],
"C": [
32,
12
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 315.10028919999604
}
+108
View File
@@ -0,0 +1,108 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round47_pre_s1_rows.json",
"out": "docs/experiment_round47_pre_s1.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"backoff": 0,
"max_sec": null,
"seed": 1,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.54296875,
"collision_free_success": 0.54296875,
"time_ok_1p3": 0.33984375,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.4660637378692627,
"time_mean_s": 2.4476258754730225,
"brakes_mean": 19.703125,
"start_fail": 0.0,
"goal_ratio_2s": 0.20109058916568756,
"err_fail_med": 187.68463134765625,
"err_success_med": 0.3424937129020691,
"dls_share": 0.6484375,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.22884614765644073,
"reverse_mean": 0.23487445712089539,
"reverse_moving_p50": 0.2777777910232544,
"moving_share_p50": 0.9679999947547913,
"brake_rate_mean": 0.10104167461395264,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.35641026496887207,
"stuck_share": 0.2421875,
"n_plans_mean": 195.0,
"success_reachable": 0.5720164775848389,
"by_cat": {
"A": [
128,
95
],
"B": [
74,
23
],
"C": [
32,
14
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 314.3736673000094
}
+109
View File
@@ -0,0 +1,109 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round48_pre_h4_rows.json",
"out": "docs/experiment_round48_pre_h4.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"pre_h": 4,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5390625,
"collision_free_success": 0.5390625,
"time_ok_1p3": 0.3046875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.5618672370910645,
"time_mean_s": 2.4820291996002197,
"brakes_mean": 20.40625,
"start_fail": 0.0,
"goal_ratio_2s": 0.23497404158115387,
"err_fail_med": 199.24868774414062,
"err_success_med": 0.33005011081695557,
"dls_share": 0.62890625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24242424964904785,
"reverse_mean": 0.24662044644355774,
"reverse_moving_p50": 0.30327868461608887,
"moving_share_p50": 0.9583333134651184,
"brake_rate_mean": 0.1046474277973175,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.3589743673801422,
"stuck_share": 0.24609375,
"n_plans_mean": 195.0,
"success_reachable": 0.5679012537002563,
"by_cat": {
"A": [
128,
96
],
"B": [
74,
22
],
"C": [
32,
13
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 349.25640099999146
}
+109
View File
@@ -0,0 +1,109 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round48_pre_h8_rows.json",
"out": "docs/experiment_round48_pre_h8.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"pre_h": 8,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.51953125,
"collision_free_success": 0.51953125,
"time_ok_1p3": 0.28125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.6749093532562256,
"time_mean_s": 2.445413589477539,
"brakes_mean": 20.26953125,
"start_fail": 0.0,
"goal_ratio_2s": 0.2660874128341675,
"err_fail_med": 201.30308532714844,
"err_success_med": 0.22553904354572296,
"dls_share": 0.6328125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.25132274627685547,
"reverse_mean": 0.25476565957069397,
"reverse_moving_p50": 0.31292515993118286,
"moving_share_p50": 0.9629629850387573,
"brake_rate_mean": 0.10394632816314697,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.34871795773506165,
"stuck_share": 0.2578125,
"n_plans_mean": 195.0,
"success_reachable": 0.547325074672699,
"by_cat": {
"A": [
128,
92
],
"B": [
74,
20
],
"C": [
32,
14
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 338.30686029999924
}
+110
View File
@@ -0,0 +1,110 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round49_gate20_rows.json",
"out": "docs/experiment_round49_gate20.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"pre_h": 0,
"pre_near": 20.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.53515625,
"collision_free_success": 0.53515625,
"time_ok_1p3": 0.328125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.5145769119262695,
"time_mean_s": 2.3382482528686523,
"brakes_mean": 19.63671875,
"start_fail": 0.0,
"goal_ratio_2s": 0.17014972865581512,
"err_fail_med": 182.09060668945312,
"err_success_med": 0.2248138189315796,
"dls_share": 0.63671875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24203822016716003,
"reverse_mean": 0.24321714043617249,
"reverse_moving_p50": 0.2936508059501648,
"moving_share_p50": 0.9595959782600403,
"brake_rate_mean": 0.10070113092660904,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.35384616255760193,
"stuck_share": 0.2421875,
"n_plans_mean": 195.0,
"success_reachable": 0.5637860298156738,
"by_cat": {
"A": [
128,
94
],
"B": [
74,
21
],
"C": [
32,
14
],
"D": [
13,
0
],
"Dr": [
9,
8
]
}
},
"simulation_wall_s": 285.5599780000048
}
+110
View File
@@ -0,0 +1,110 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round49_gate5_rows.json",
"out": "docs/experiment_round49_gate5.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"pre_h": 0,
"pre_near": 5.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.546875,
"collision_free_success": 0.546875,
"time_ok_1p3": 0.33203125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.4217512607574463,
"time_mean_s": 2.3379998207092285,
"brakes_mean": 19.83984375,
"start_fail": 0.0,
"goal_ratio_2s": 0.17014972865581512,
"err_fail_med": 185.13986206054688,
"err_success_med": 0.3768002390861511,
"dls_share": 0.63671875,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.23239436745643616,
"reverse_mean": 0.23485617339611053,
"reverse_moving_p50": 0.28134557604789734,
"moving_share_p50": 0.9583333134651184,
"brake_rate_mean": 0.10174278169870377,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.35384616255760193,
"stuck_share": 0.24609375,
"n_plans_mean": 195.0,
"success_reachable": 0.5761317014694214,
"by_cat": {
"A": [
128,
96
],
"B": [
74,
22
],
"C": [
32,
14
],
"D": [
13,
0
],
"Dr": [
9,
8
]
}
},
"simulation_wall_s": 332.8420308999921
}
+110
View File
@@ -0,0 +1,110 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round50_gate20_s1_rows.json",
"out": "docs/experiment_round50_gate20_s1.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"pre_h": 0,
"pre_near": 20.0,
"backoff": 0,
"max_sec": null,
"seed": 1,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.53125,
"collision_free_success": 0.53125,
"time_ok_1p3": 0.30078125,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.6468124389648438,
"time_mean_s": 2.462352752685547,
"brakes_mean": 19.71875,
"start_fail": 0.0,
"goal_ratio_2s": 0.20109058916568756,
"err_fail_med": 177.47691345214844,
"err_success_med": 0.22864246368408203,
"dls_share": 0.6484375,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.2363184094429016,
"reverse_mean": 0.24333104491233826,
"reverse_moving_p50": 0.28763440251350403,
"moving_share_p50": 0.9736841917037964,
"brake_rate_mean": 0.10112179815769196,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.35641026496887207,
"stuck_share": 0.24609375,
"n_plans_mean": 195.0,
"success_reachable": 0.5596708059310913,
"by_cat": {
"A": [
128,
94
],
"B": [
74,
23
],
"C": [
32,
12
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 271.2116083000001
}
+110
View File
@@ -0,0 +1,110 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 16,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round51_k16pre_rows.json",
"out": "docs/experiment_round51_k16pre.json",
"trace": null,
"select": "pre",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"pre_h": 0,
"pre_near": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.56640625,
"collision_free_success": 0.56640625,
"time_ok_1p3": 0.359375,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.414156198501587,
"time_mean_s": 2.265103578567505,
"brakes_mean": 14.1953125,
"start_fail": 0.0,
"goal_ratio_2s": 0.13815215229988098,
"err_fail_med": 184.40463256835938,
"err_success_med": 0.2881776690483093,
"dls_share": 0.64453125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.2373737394809723,
"reverse_mean": 0.2401755303144455,
"reverse_moving_p50": 0.27848100662231445,
"moving_share_p50": 0.9851852059364319,
"brake_rate_mean": 0.07279647886753082,
"brake_rate_p50": 0.0,
"brake_rate_p90": 0.27435898780822754,
"stuck_share": 0.171875,
"n_plans_mean": 195.0,
"success_reachable": 0.596707820892334,
"by_cat": {
"A": [
128,
100
],
"B": [
74,
26
],
"C": [
32,
12
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 486.8652108999959
}
+110
View File
@@ -0,0 +1,110 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round52_ctl_ex_rows.json",
"out": "docs/experiment_round52_ctl_ex.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"pre_h": 0,
"pre_near": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 0,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.5234375,
"collision_free_success": 0.5234375,
"time_ok_1p3": 0.265625,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.615795850753784,
"time_mean_s": 2.486567258834839,
"brakes_mean": 19.5546875,
"start_fail": 0.0,
"goal_ratio_2s": 0.27920001745224,
"err_fail_med": 204.71360778808594,
"err_success_med": 0.21751396358013153,
"dls_share": 0.61328125,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.24741201102733612,
"reverse_mean": 0.25991496443748474,
"reverse_moving_p50": 0.32581019401550293,
"moving_share_p50": 0.9587156176567078,
"brake_rate_mean": 0.10028044879436493,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.3153846263885498,
"stuck_share": 0.234375,
"n_plans_mean": 195.0,
"success_reachable": 0.5514403581619263,
"by_cat": {
"A": [
128,
96
],
"B": [
74,
20
],
"C": [
32,
11
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 296.3142095999938
}
+110
View File
@@ -0,0 +1,110 @@
{
"config": {
"ckpt": "ml/runs/base_dag2_dag1/best.pt",
"samples": "ml/data/samples",
"tasks": null,
"split": "val",
"n": 256,
"K": 8,
"commit": 2,
"fb": 2.2,
"ki": 0.0,
"fb_scale": 0.0,
"fb_near": 0.2,
"fb_fallback": 0.0,
"kdecay": 0.9,
"kimax": 0.5,
"fb_every": 1,
"safety_try": 0,
"sel_w": 0.1,
"dls_safety": 1,
"fb_clear": 0.0,
"fb_cmin": 0.3,
"sub_refresh": 0,
"fb_block_gain": 0.5,
"dump": "ml/runs/round53_ctl_ex_s1_rows.json",
"out": "docs/experiment_round53_ctl_ex_s1.json",
"trace": null,
"select": "endpoint",
"replan": "empty",
"safety": 1,
"partial": 1,
"inc_cap": 1,
"gap_margin": 0.0,
"cert_batch": 1,
"steps": 1,
"z_scale": 1.0,
"len_w": 0.0,
"tie": 0,
"pre_h": 0,
"pre_near": 0.0,
"backoff": 0,
"max_sec": null,
"seed": 1,
"dls": "analytic",
"device": "cuda"
},
"batch_size": 256,
"batch_seed_rule": "same seed per batch",
"checkpoint_sha256": "f7f686fd8ee92fb6948fbcc4ee954636065ad87bb54f661c4f8f575bc16c2ce1",
"tasks_sha256": "249bd93457825cda98c59e64d9a096d3473c69aeb3553de1dea6d9e56be71772",
"kin_fp": "2ebcbf17",
"act_scale": 1.0,
"metrics": {
"n": 256,
"n_ref": 256,
"success": 0.53125,
"collision_free_success": 0.53125,
"time_ok_1p3": 0.296875,
"collision_rate": 0.0,
"collision_steps_mean": 0.0,
"travel_ratio_median": 2.636941432952881,
"time_mean_s": 2.4600000381469727,
"brakes_mean": 19.265625,
"start_fail": 0.0,
"goal_ratio_2s": 0.2750342786312103,
"err_fail_med": 214.6193084716797,
"err_success_med": 0.22276456654071808,
"dls_share": 0.62890625,
"time_budget": "teacher×2(≥3 s)",
"speed_ratio_p50": 1.0000016689300537,
"speed_ratio_p95": 1.0000101327896118,
"speed_ratio_max": 1.0000101327896118,
"over_vmax_rate": 0.0,
"accel_ratio_p95": 1.0000016689300537,
"accel_ratio_max": 1.0000101327896118,
"reverse_p50": 0.25339367985725403,
"reverse_mean": 0.2575649917125702,
"reverse_moving_p50": 0.3117443919181824,
"moving_share_p50": 0.9636363387107849,
"brake_rate_mean": 0.09879808127880096,
"brake_rate_p50": 0.0051282052882015705,
"brake_rate_p90": 0.3384615480899811,
"stuck_share": 0.25390625,
"n_plans_mean": 195.0,
"success_reachable": 0.5596708059310913,
"by_cat": {
"A": [
128,
96
],
"B": [
74,
21
],
"C": [
32,
12
],
"D": [
13,
0
],
"Dr": [
9,
7
]
}
},
"simulation_wall_s": 290.3290144000057
}
+1401
View File
File diff suppressed because it is too large Load Diff
+4 -1
View File
@@ -139,7 +139,10 @@ def main():
stats['tgt'] += lt.mean().item() stats['tgt'] += lt.mean().item()
(seg_loss / nseg).backward() (seg_loss / nseg).backward()
seg_loss = torch.zeros((), device=dev) seg_loss = torch.zeros((), device=dev)
q, qp, queue, prev_d = q.detach(), qp.detach(), queue.detach(), prev_d.detach() # 只 detach 状态并重置队列:段边界下一 plan 走 r=0 重新提交(新图有梯度);
# 沿用旧 queue 会跨过已 backward 的图(二次 backward 报错),也避免整段无梯度
q, qp, prev_d = q.detach(), qp.detach(), prev_d.detach()
queue = torch.zeros(B, 0, 6, device=dev)
# BC 锚定 # BC 锚定
X, Y, V, SG = data.batch(C['batch'] * 4) X, Y, V, SG = data.batch(C['batch'] * 4)
with torch.autocast('cuda', dtype=torch.bfloat16, enabled=amp): with torch.autocast('cuda', dtype=torch.bfloat16, enabled=amp):
+4 -2
View File
@@ -52,8 +52,10 @@ def features(kin, q, q_prev, T, R, prefix, prefix_len, sub, sub_flag, gm=None, x
out.append(sd) out.append(sd)
out.append(sub_flag[:, None].to(dt)) out.append(sub_flag[:, None].to(dt))
if gm is None: if gm is None:
gm = kin.gaps(q, GAP_CAP, xf)['gm'] out.append(kin.gm_groups(q, GP, GAP_CAP, xf=xf) / GAP_CAP) # 2026-10-20:只算特征用到的 8 组;xf 复用不重复算 FK
out.append(torch.stack([gm[:, a * 7 + b].clamp(max=GAP_CAP) / GAP_CAP for a, b in GP], -1)) gm = None
if gm is not None:
out.append(torch.stack([gm[:, a * 7 + b].clamp(max=GAP_CAP) / GAP_CAP for a, b in GP], -1))
f = torch.cat(out, -1) f = torch.cat(out, -1)
assert f.shape[1] == F_DIM, f.shape assert f.shape[1] == F_DIM, f.shape
return f return f
+167 -3
View File
@@ -38,7 +38,8 @@ def seg_seg_dist(p1, q1, p2, q2, eps=1e-12):
s = torch.where(t_lo, (-c / a.clamp_min(eps)).clamp(0, 1), s) s = torch.where(t_lo, (-c / a.clamp_min(eps)).clamp(0, 1), s)
s = torch.where(t_hi, ((b - c) / a.clamp_min(eps)).clamp(0, 1), s) s = torch.where(t_hi, ((b - c) / a.clamp_min(eps)).clamp(0, 1), s)
t = t.clamp(0, 1) t = t.clamp(0, 1)
# 退化(线段长度≈0) # 第二条退化成点时,仍须在第一条上投影,而不是固定取其起点。
s = torch.where(e <= eps, (-c / a.clamp_min(eps)).clamp(0, 1), s)
s = torch.where(a <= eps, torch.zeros_like(s), s) s = torch.where(a <= eps, torch.zeros_like(s), s)
t = torch.where(e <= eps, torch.zeros_like(t), t) t = torch.where(e <= eps, torch.zeros_like(t), t)
c1 = p1 + d1 * s.unsqueeze(-1) c1 = p1 + d1 * s.unsqueeze(-1)
@@ -85,8 +86,36 @@ class Kin:
gi, gj = self.cap_g[self.pi], self.cap_g[self.pj] gi, gj = self.cap_g[self.pi], self.cap_g[self.pj]
self.pair_gp = torch.minimum(gi, gj) * 7 + torch.maximum(gi, gj) self.pair_gp = torch.minimum(gi, gj) * 7 + torch.maximum(gi, gj)
self.lever = T(K['lever']) self.lever = T(K['lever'])
table = [[0.0] * 7 for _ in range(6)]
for group in range(1, 7):
endpoints = [c[key] for c in caps if c['g'] == group for key in ('a', 'b')]
if not endpoints:
continue
pivot, axis = K['P'][group - 1], K['D'][group - 1]
unit = [v / math.hypot(*axis) for v in axis]
relative = [[e[j] - pivot[j] for j in range(3)] for e in endpoints]
radius = max(math.hypot(*v) for v in relative)
radial = max(math.hypot(v[1] * unit[2] - v[2] * unit[1],
v[2] * unit[0] - v[0] * unit[2],
v[0] * unit[1] - v[1] * unit[0]) for v in relative)
for joint in range(group):
chain = sum(math.dist(K['P'][j], K['P'][j + 1]) for j in range(joint, group - 1))
table[joint][group] = (chain + (radial if joint == group - 1 else radius)) * D2R
self.cert_groups = torch.tensor([a * 7 + b for a in range(7) for b in range(a + 2, 7)], device=device)
# 三角不等式给出全姿态界,不用随机姿态最大值冒充上界。
self.cert_lever = T([[table[k][b] if a <= k < b else 0.0 for k in range(6)]
for a in range(7) for b in range(a + 2, 7)])
# ---------------- 运动学 ---------------- # ---------------- 运动学 ----------------
def _checked_xf(self, q, xf):
"""xf 是按行对应 q 的位姿数组,行数不匹配会静默广播出错(宽相位筛到别的行 ⇒ device assert 或错间隙)。"""
if xf is None:
return self.cum_xf(q)
Rs, Ts = xf
if Rs.shape[0] != q.shape[0] or Ts.shape[0] != q.shape[0]:
raise ValueError('xf 的行数 %d 与 q 的行数 %d 不符' % (Rs.shape[0], q.shape[0]))
return xf
def cum_xf(self, q): def cum_xf(self, q):
"""q: [B,6] 度 → Rs [B,7,3,3], Ts [B,7,3]""" """q: [B,6] 度 → Rs [B,7,3,3], Ts [B,7,3]"""
B = q.shape[0] B = q.shape[0]
@@ -110,6 +139,19 @@ class Kin:
Rs, _ = xf if xf is not None else self.cum_xf(q) Rs, _ = xf if xf is not None else self.cum_xf(q)
return Rs[:, 6] return Rs[:, 6]
def jac(self, q, xf=None):
"""几何雅可比(对度):返回 (Jv [B,3,6] mm/deg, Jw [B,3,6] 单位轴/deg)"""
Rs, Ts = xf if xf is not None else self.cum_xf(q)
p = self.fk(q, (Rs, Ts))
Jv, Jw = [], []
for k in range(6):
d = torch.tensor(self.D[k], dtype=q.dtype, device=q.device)
a = Rs[:, k] @ d
o = torch.einsum('bij,j->bi', Rs[:, k], self.P[k].to(q.dtype)) + Ts[:, k]
Jv.append(torch.linalg.cross(a, p - o, dim=-1) * D2R)
Jw.append(a * D2R)
return torch.stack(Jv, -1), torch.stack(Jw, -1)
def caps_world(self, q, xf=None): def caps_world(self, q, xf=None):
Rs, Ts = xf if xf is not None else self.cum_xf(q) Rs, Ts = xf if xf is not None else self.cum_xf(q)
Rg, Tg = Rs[:, self.cap_g], Ts[:, self.cap_g] # [B,C,3,3], [B,C,3] Rg, Tg = Rs[:, self.cap_g], Ts[:, self.cap_g] # [B,C,3,3], [B,C,3]
@@ -131,7 +173,8 @@ class Kin:
def _cat_gaps(parts, starts): def _cat_gaps(parts, starts):
out = {'gm': torch.cat([p.pop('gm') for p in parts], 0)} out = {'gm': torch.cat([p.pop('gm') for p in parts], 0)}
if 'b' in parts[0]: if 'b' in parts[0]:
for p, s in zip(parts, starts): p['b'] += s # 非 in-place:b 会被 autograd 的索引反向图引用(APG 的碰撞铰链梯度路径),+= 会让 backward 报 version 错
for p, s in zip(parts, starts): p['b'] = p['b'] + s
for k in ('b', 'i', 'j', 'gap'): out[k] = torch.cat([p.pop(k) for p in parts]) # 逐键拼、拼完即释放 for k in ('b', 'i', 'j', 'gap'): out[k] = torch.cat([p.pop(k) for p in parts]) # 逐键拼、拼完即释放
return out return out
@@ -142,7 +185,7 @@ class Kin:
2026-10-19(用户实测 4096 点 cap 40 峰值 4.46 GiB 全在拼接 8.6e7 对的 b/i/j/gap): 2026-10-19(用户实测 4096 点 cap 40 峰值 4.46 GiB 全在拼接 8.6e7 对的 b/i/j/gap):
默认只返回 gm,每块算完就丢掉胶囊对,峰值只剩单块。 默认只返回 gm,每块算完就丢掉胶囊对,峰值只剩单块。
""" """
xf = xf if xf is not None else self.cum_xf(q) xf = self._checked_xf(q, xf)
Rs, Ts = xf Rs, Ts = xf
B = q.shape[0] B = q.shape[0]
step = max(1, self.COARSE_ENTRIES // int(self.cp_a.shape[0])) step = max(1, self.COARSE_ENTRIES // int(self.cp_a.shape[0]))
@@ -201,6 +244,127 @@ class Kin:
if not pairs: return {'gm': gm.view(B, 49)} if not pairs: return {'gm': gm.view(B, 49)}
return {'gm': gm.view(B, 49), 'b': rep_b, 'i': pi, 'j': pj, 'gap': gap} return {'gm': gm.view(B, 49), 'b': rep_b, 'i': pi, 'j': pj, 'gap': gap}
def gm_groups(self, q, gp, cap=40.0, xf=None):
"""只算指定组对 gp=[(a,b),...] 的最小间隙 [B,len(gp)](特征用,避免 49 组全量)。
数值与 gaps(q,cap)['gm'][:, a*7+b] 一致;组对在碰撞粗对里不存在时返回 cap。
xf 可传入调用者已算好的 cum_xf(q),避免同一姿态重复算 FK(特征路径每周期省一次)。"""
key = tuple(gp)
if getattr(self, '_gp_key', None) != key:
m = torch.full((49,), -1, dtype=torch.long, device=q.device)
for i, (a_, b_) in enumerate(gp): m[min(a_, b_) * 7 + max(a_, b_)] = i
ga, gb = self.cl_g[self.cp_a], self.cl_g[self.cp_b]
cg = torch.minimum(ga, gb) * 7 + torch.maximum(ga, gb) # 簇对 → 7 连杆组对
sel = torch.isin(cg, torch.tensor([min(a, b) * 7 + max(a, b) for a, b in gp], device=q.device))
self._gp = (m, sel, sel.nonzero(as_tuple=True)[0]); self._gp_key = key
self._gp49, sel, idx = self._gp
xf = self._checked_xf(q, xf); Rs, Ts = xf; B = q.shape[0]
with torch.no_grad():
cc = torch.einsum('bkij,kj->bki', Rs[:, self.cl_g], self.cl_c.to(q.dtype)) + Ts[:, self.cl_g]
d2 = (cc[:, self.cp_a[idx]] - cc[:, self.cp_b[idx]]).pow(2).sum(-1)
keep = d2 <= (self.cp_lim[idx] + cap).pow(2)
bb, mm = keep.nonzero(as_tuple=True)
del keep, d2, cc
cnt = self.cp_cnt[idx][mm]
rep_b = torch.repeat_interleave(bb, cnt)
off = torch.repeat_interleave(self.cp_start[idx][mm] - torch.cumsum(cnt, 0) + cnt, cnt) + torch.arange(int(cnt.sum()), device=q.device)
pidx = off
a, b = self.caps_world(q, xf)
with torch.no_grad():
pi, pj = self.pi[pidx], self.pj[pidx]
mid = 0.5 * (a[rep_b, pi] + b[rep_b, pi] - a[rep_b, pj] - b[rep_b, pj])
k2 = mid.pow(2).sum(-1) <= (self.pair_bl[pidx] + cap).pow(2)
rep_b, pidx, pi, pj = rep_b[k2], pidx[k2], pi[k2], pj[k2]
d = seg_seg_dist(a[rep_b, pi], b[rep_b, pi], a[rep_b, pj], b[rep_b, pj])
gap = d - self.pair_need[pidx].to(q.dtype)
gm = torch.full((B * len(gp),), float(cap), dtype=q.dtype, device=q.device)
gm = gm.scatter_reduce(0, rep_b * len(gp) + self._gp49[self.pair_gp[pidx]], gap.clamp(max=cap), reduce='amin', include_self=True)
return gm.view(B, len(gp))
@torch.no_grad()
def certify_segments(self, a, b, max_queries=32, max_depth=12, eps=1e-4, cap=20.0):
"""逐层二分认证:每根段独立查询预算,未知(超预算/超深度/非有限/越界)一律拒绝。
判据对每条组对:子段两端间隙之和 > 该子段位移界 + 2eps(间隙取 min(gap,cap),钳制只会更保守)。
cap 必须 ≥ 该层子段界 + 2eps 才不会挡住本可通过的判定,故不做自适应收紧——同批其他段会改变
钳制程度、让结果随批次而变(实测也无耗时收益,见探索日志轮次 31)。
"""
if self.dtype != torch.float64 or a.dtype != torch.float64 or b.dtype != torch.float64:
raise ValueError('segment certification requires float64')
if a.shape != b.shape or a.ndim != 2 or a.shape[1] != 6:
raise ValueError('a and b must be [count,6] with identical shape')
# 预算给成张量时 max_depth + 1 会在 uint8 这类窄类型上回绕成 0,循环整个跳过,把碰撞段当安全返回。
if type(max_queries) is not int or type(max_depth) is not int:
raise ValueError('certification budgets must be plain ints')
if max_queries < 2 or max_depth < 0 or eps <= 0 or cap <= eps:
raise ValueError('invalid certification budget or tolerance')
count = a.shape[0]
status = torch.zeros(count, dtype=torch.long, device=a.device)
inside = (((a >= self.lo) & (a <= self.hi) & (b >= self.lo) & (b <= self.hi)) | self.cont).all(-1)
status[~inside] = 3
root = torch.arange(count, device=a.device)
gaps = self.gaps(torch.cat([a, b]), cap)['gm'][:, self.cert_groups]
ga, gb = gaps[:count], gaps[count:]
queries = torch.full((count,), 2, dtype=torch.long, device=a.device)
bound = (b - a).abs() @ self.cert_lever.T
for depth in range(max_depth + 1):
finite = torch.isfinite(ga).all(-1) & torch.isfinite(gb).all(-1)
collision = (ga <= 0).any(-1) | (gb <= 0).any(-1)
status[root[~finite]] = 2
status[root[collision]] = 1
positive = (ga > eps).all(-1) & (gb > eps).all(-1)
proven = positive & (ga + gb > bound + 2 * eps).all(-1)
pending = (status[root] == 0) & ~proven
if not bool(pending.any()):
break
a, b, ga, gb, root, bound = a[pending], b[pending], ga[pending], gb[pending], root[pending], bound[pending]
if depth == max_depth:
status[root] = 2
break
requested = torch.bincount(root, minlength=count)
status[(status == 0) & (queries + requested > max_queries)] = 2
keep = status[root] == 0
a, b, ga, gb, root, bound = (t[keep] for t in (a, b, ga, gb, root, bound))
if not root.numel():
break
mid = a + 0.5 * (b - a)
gm = self.gaps(mid, cap)['gm'][:, self.cert_groups]
queries += torch.bincount(root, minlength=count)
a, b = torch.cat([a, mid]), torch.cat([mid, b])
ga, gb = torch.cat([ga, gm]), torch.cat([gm, gb])
root = torch.cat([root, root])
bound = torch.cat([bound, bound]) / 2
return {'safe': status == 0, 'collision': status == 1, 'unresolved': status == 2,
'outside_box': status == 3, 'queries': queries}
@torch.no_grad()
def certify_uniform(self, a, b, n=64, eps=1e-4, cap=None):
"""固定层数的均匀细分认证:n 个子段只需一次 gaps 调用(n+1 个点),没有逐层依赖的往返。
判据与 certify_segments 完全相同;界对 Δq 线性,所以子段界 = 整段界 / n。未通过即 unproven
(拒绝),不存在“未知当安全”。cap=None 时取“最小不挡住可通过判定的宽相位”= 最大子段界 + 2eps:
小于它钳制会把本可证明的子段压成不可证(偏保守),大于它只是多算对(偏慢),不改正确性。
"""
if self.dtype != torch.float64 or a.dtype != torch.float64 or b.dtype != torch.float64:
raise ValueError('segment certification requires float64')
if type(n) is not int or n < 1 or eps <= 0 or (cap is not None and cap <= eps):
raise ValueError('invalid subdivision count or tolerance')
if a.shape != b.shape or a.ndim != 2 or a.shape[1] != 6:
raise ValueError('a and b must be [count,6] with identical shape')
count = a.shape[0]
inside = (((a >= self.lo) & (a <= self.hi) & (b >= self.lo) & (b <= self.hi)) | self.cont).all(-1)
bound = (b - a).abs() @ self.cert_lever.T / n # [count,15] 子段界
required = float(bound.max()) + 2 * eps if count else 2 * eps
qc = required if cap is None else cap
alpha = torch.arange(n + 1, dtype=self.dtype, device=a.device) / n
points = (a[:, None] + (b - a)[:, None] * alpha[None, :, None]).reshape(-1, 6)
gm = self.gaps(points, qc)['gm'][:, self.cert_groups].view(count, n + 1, -1)
adjacent = gm[:, :-1] + gm[:, 1:] > bound[:, None, :] + 2 * eps
collision = (gm <= 0).any((1, 2))
safe = inside & (gm > eps).all((1, 2)) & adjacent.all((1, 2)) & ~collision
return {'safe': safe, 'collision': collision, 'unproven': (~safe & ~collision & inside),
'outside_box': ~inside, 'points': n + 1, 'queries': n + 1,
'cap_required_mm': required, 'cap_used_mm': qc}
def min_gap(self, q, cap=40.0): def min_gap(self, q, cap=40.0):
return self.gaps(q, cap)['gm'].min(-1).values return self.gaps(q, cap)['gm'].min(-1).values
+11
View File
@@ -0,0 +1,11 @@
{
"model": {"d": 192, "heads": 8, "ff": 768, "enc": 4, "dec": 4},
"train": {
"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.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
}
}
+11
View File
@@ -0,0 +1,11 @@
{
"model": {"d": 192, "heads": 8, "ff": 768, "enc": 4, "dec": 4},
"train": {
"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.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
}
}
+41
View File
@@ -0,0 +1,41 @@
{
"model": {
"d": 192,
"heads": 8,
"ff": 768,
"enc": 4,
"dec": 4
},
"train": {
"batch": 1024,
"lr": 0.0001,
"warmup": 1000,
"steps": 3000,
"wd": 0.01,
"betas": [
0.9,
0.95
],
"amp": "bf16",
"grad_clip": 1.0,
"w_mf": 1.0,
"w_fk": 0.1,
"w_smooth": 0.01,
"w_value": 0.0,
"w_sub": 0.0,
"p_neq": 0.5,
"p_edge": 0.1,
"p_neq_warm": 0,
"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": 1000,
"eval_tasks": 256,
"log_every": 50,
"patience_evals": 3
}
}
+6 -1
View File
@@ -28,6 +28,10 @@ def main():
ap.add_argument('--parts', type=int, default=8); ap.add_argument('--out', required=True) ap.add_argument('--parts', type=int, default=8); ap.add_argument('--out', required=True)
ap.add_argument('--bs', type=int, default=64) ap.add_argument('--bs', type=int, default=64)
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu') ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu')
ap.add_argument('--fb_gain', type=float, default=0.0, help='部署分布采集:目标反馈增益(与 rollout 一致)')
ap.add_argument('--safety', type=int, default=0, help='部署分布采集:是否开安全层')
ap.add_argument('--replan', default='r3'); ap.add_argument('--commit_n', type=int, default=3)
ap.add_argument('--safety_partial', type=int, default=0)
a = ap.parse_args() a = ap.parse_args()
gap_min = float(os.environ.get('MIN_GAP_MM') or 3) gap_min = float(os.environ.get('MIN_GAP_MM') or 3)
os.makedirs(a.out, exist_ok=True) os.makedirs(a.out, exist_ok=True)
@@ -41,7 +45,8 @@ def main():
for i in range(0, len(tasks), a.bs): for i in range(0, len(tasks), a.bs):
tb = tasks[i:i + a.bs] tb = tasks[i:i + a.bs]
with torch.no_grad(): with torch.no_grad():
_, per = rollout(model, kin, tb, a.device, K=8, safety=False, seed=a.seed * 100003 + i, return_traj=True) _, per = rollout(model, kin, tb, a.device, K=8, safety=bool(a.safety), seed=a.seed * 100003 + i, return_traj=True,
fb_gain=a.fb_gain, replan=a.replan, commit_n=a.commit_n, safety_partial=a.safety_partial)
tr = per['traj'].to(a.device) # [B,T,6] tr = per['traj'].to(a.device) # [B,T,6]
B, Tn, _ = tr.shape B, Tn, _ = tr.shape
_, T, R, _, _ = tasks_to_tensors(tb, a.device) _, T, R, _, _ = tasks_to_tensors(tb, a.device)
+57
View File
@@ -0,0 +1,57 @@
#!/usr/bin/env python
"""反馈蒸馏:用最终部署配置(目标反馈 + 安全层 + 部分前缀 + 每步规划)跑闭环,
收集 (特征, 复合动作 = 模型输出 + 目标反馈) 样本,供 train.py 微调把反馈内化进策略。
PYTHONUTF8=1 python -m ml.dagger.distill_fb --ckpt ml/runs/base_dag2_dag1/best.pt --n 500 \
--fb_gain 1.8 --out ml/data/samples_fbdistill
输出可直接被 ml.data.Samples 读取(collect.X/Y/V/SG/TID.npy;无 meta = act_scale 1.0,与主数据一致)。
动作标签 = 候选动作(含反馈)的归一化 act(/STEP,clamp ±1),与主数据同口径。
"""
import argparse, os, random
import numpy as np
import torch
from ml.common.ckpt import load_policy
from ml.common.features import STEP
from ml.common.kin_torch import Kin
from ml.data import load_tasks
from ml.sim.closed_loop import rollout
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--ckpt', required=True); ap.add_argument('--n', type=int, default=500)
ap.add_argument('--bs', type=int, default=64); ap.add_argument('--fb_gain', type=float, default=1.8)
ap.add_argument('--samples', default='ml/data/samples'); ap.add_argument('--out', required=True)
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu'); ap.add_argument('--seed', type=int, default=1)
a = ap.parse_args()
dev = a.device
model, _ = load_policy(a.ckpt, dev)
kin = Kin(device=dev)
pool = [t for t in load_tasks([a.samples]) if t['split'] == 'train' and t.get('cat') not in ('D',)]
random.Random(a.seed).shuffle(pool); tasks = pool[:a.n]
stp = torch.tensor(STEP) # collect 返回 CPU 张量,标签换算也在 CPU
X, Y, TID = [], [], []
for i in range(0, len(tasks), a.bs):
ch = tasks[i:i + a.bs]
coll = []
with torch.no_grad():
rollout(model, kin, ch, dev, K=8, safety=True, replan='empty', fb_gain=a.fb_gain,
safety_partial=1, commit_n=1, seed=a.seed * 100003 + i, collect=coll)
for f, ac in coll:
X.append(f.numpy()); Y.append((ac / stp).clamp(-1, 1).numpy())
ncol = sum(f.shape[0] for f, _ in coll)
TID.append(np.arange(ncol, dtype=np.int32) + i * 100000)
print(f'[distill] {i + len(ch)}/{len(tasks)} tasks, samples {sum(x.shape[0] for x in X)}', flush=True)
os.makedirs(a.out, exist_ok=True)
X = np.concatenate(X); Y = np.concatenate(Y); TID = np.concatenate(TID)
n = X.shape[0]
np.save(os.path.join(a.out, 'collect.X.npy'), X.astype(np.float32))
np.save(os.path.join(a.out, 'collect.Y.npy'), Y.astype(np.float32))
np.save(os.path.join(a.out, 'collect.V.npy'), np.full(n, 0.5, np.float32))
np.save(os.path.join(a.out, 'collect.SG.npy'), np.zeros((n, 13), np.float32))
np.save(os.path.join(a.out, 'collect.TID.npy'), TID)
print(f'done: {n} samples, X {X.shape}, Y {Y.shape}', flush=True)
if __name__ == '__main__':
main()
+1 -1
View File
@@ -24,7 +24,7 @@ for ((r=1; r<=R; r++)); do
SAMPLES="$SAMPLES $SD" SAMPLES="$SAMPLES $SD"
if [ -f $OUT/done ]; then echo "[dagger] 第 $r 轮已完成,跳过"; CK=$($PY -m ml.common.ckpt pick $OUT); 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 轮起点已采集,跳过" 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 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 --fb_gain ${FB_GAIN:-0} --safety ${DAG_SAFETY:-0} --replan ${DAG_REPLAN:-r3} --commit_n ${DAG_COMMIT_N:-3} --safety_partial ${DAG_PARTIAL:-0}; fi
cat $D/collect.json cat $D/collect.json
pids=() pids=()
for f in $D/tasks_*.jsonl; do for f in $D/tasks_*.jsonl; do
+54
View File
@@ -0,0 +1,54 @@
"""DLS 解析雅可比对拍 + 延迟(python -m ml.eval.check_dls)"""
import time
import torch
from ml.common.kin_torch import Kin
from ml.sim.closed_loop import dls_steps
def main():
dev = 'cuda' if torch.cuda.is_available() else 'cpu'
kin = Kin(device=dev)
g = torch.Generator(device=dev); g.manual_seed(0)
B = 64
lo, hi = kin.lo + 20, kin.hi - 20
q = lo + (hi - lo) * torch.rand(B, 6, device=dev, generator=g)
xf = kin.cum_xf(q)
p = kin.fk(q, xf)
T = p + 6 * torch.randn(B, 3, device=dev, generator=g)
R = torch.zeros(B, 9, device=dev)
a = dls_steps(kin, q, T, R, n=3, analytic=True)
b = dls_steps(kin, q, T, R, n=3, analytic=False)
d = (a - b).abs()
print('pos-only max|Δdq| %.6f° mean %.6f° rel %.4f' % (d.max().item(), d.mean().item(), (d.norm() / b.norm()).item()))
# 带姿态目标:绕随机轴 ±8°
axis = torch.randn(B, 3, device=dev, generator=g); axis = axis / axis.norm(dim=-1, keepdim=True)
ang = (torch.rand(B, 1, device=dev, generator=g) * 16 - 8) * torch.pi / 180
Kx = torch.zeros(B, 3, 3, device=dev)
Kx[:, 0, 1] = -axis[:, 2]; Kx[:, 0, 2] = axis[:, 1]; Kx[:, 1, 0] = axis[:, 2]
Kx[:, 1, 2] = -axis[:, 0]; Kx[:, 2, 0] = -axis[:, 1]; Kx[:, 2, 1] = axis[:, 0]
I = torch.eye(3, device=dev)
Rd = I + torch.sin(ang)[..., None] * Kx + (1 - torch.cos(ang))[..., None] * (Kx @ Kx)
Rt = kin.orient(q, xf) @ Rd
R9 = Rt.reshape(B, 9)
a = dls_steps(kin, q, T, R9, n=3, analytic=True)
b = dls_steps(kin, q, T, R9, n=3, analytic=False)
d = (a - b).abs()
print('pos+rot max|Δdq| %.6f° mean %.6f° rel %.4f' % (d.max().item(), d.mean().item(), (d.norm() / b.norm()).item()))
for n_ in (1, 3):
for Bn in (1, 256):
qq = q[:Bn]; TT = T[:Bn]; RR = R9[:Bn]
for an in (False, True):
for _ in range(3):
dls_steps(kin, qq, TT, RR, n=n_, analytic=an)
torch.cuda.synchronize() if dev == 'cuda' else None
t0 = time.perf_counter()
for _ in range(20):
dls_steps(kin, qq, TT, RR, n=n_, analytic=an)
torch.cuda.synchronize() if dev == 'cuda' else None
print('n=%d B=%3d analytic=%d %.2f ms' % (n_, Bn, an, (time.perf_counter() - t0) / 20 * 1e3))
if __name__ == '__main__':
main()
+266 -2
View File
@@ -7,7 +7,7 @@
口径与 closed_loop.rollout 一致:每步同时检查当前状态 q 与相邻状态中点 mid 的间隙(cap=0.5 mm); 口径与 closed_loop.rollout 一致:每步同时检查当前状态 q 与相邻状态中点 mid 的间隙(cap=0.5 mm);
间隙组对索引 = gA*7+gB(gA<gB,g 为连杆组 0..5 → J1..J6)。 间隙组对索引 = gA*7+gB(gA<gB,g 为连杆组 0..5 → J1..J6)。
""" """
import argparse, json, math, os, sys import argparse, json, math, os, sys, time
from collections import Counter from collections import Counter
import torch import torch
@@ -25,9 +25,253 @@ def pair_names():
return {a * 7 + b: f'{nm(a)}-{nm(b)}' for a in range(7) for b in range(a + 1, 7)} return {a * 7 + b: f'{nm(a)}-{nm(b)}' for a in range(7) for b in range(a + 1, 7)}
@torch.no_grad()
def replay_first_hits(path, out=None):
saved = torch.load(path, map_location='cpu', weights_only=True)
k32, k64 = Kin(), Kin(dtype=torch.float64)
rows, offset = [], 0
for _, per, count in saved['batches']:
for b in (per['col'] > 0).nonzero().flatten().tolist():
it = int(round(float(per['first_hit'][b]) / DT))
prev, q = per['traj'][b, it - 1:it + 1]
mid = prev + 0.5 * (q - prev)
points = torch.stack([per['traj'][b, 0], prev, mid, q])
gm32 = k32.gaps(points, 0.5)['gm']
gm64 = k64.gaps(points.double(), 0.5)['gm']
gap32, gp32 = gm32.min(-1)
gap64, gp64 = gm64.min(-1)
nseg = max(1, math.ceil(float((q - prev).abs().max()) / 0.01))
dense = prev.double() + torch.linspace(0, 1, nseg + 1, dtype=torch.float64)[:, None] * (q.double() - prev.double())
dense_gap = torch.cat([k64.gaps(chunk, 0.5)['gm'].min(-1).values for chunk in dense.split(32)])
boundary = (~k32.cont) & ((q - k32.lo).abs().lt(1e-5) | (q - k32.hi).abs().lt(1e-5))
row = {
'i': offset + b, 'task': saved['tasks'][offset + b],
'first_hit_s': float(per['first_hit'][b]), 'dls_it': int(per['dls_it'][b]),
'point_order': ['q0', 'previous', 'midpoint', 'endpoint'],
'gap32_mm': gap32.tolist(), 'gap64_mm': gap64.tolist(),
'pair32': gp32.tolist(), 'pair64': gp64.tolist(),
'boundary_joints': (boundary.nonzero().flatten() + 1).tolist(),
'previous': prev.tolist(), 'endpoint': q.tolist(),
'dense_nsegments': nseg, 'dense_gap64_min_mm': float(dense_gap.min()),
}
if 'plans' in per:
plans = per['plans']
pi = int(torch.searchsorted(plans['it'], it - 1, right=True)) - 1
step = it - 1 - int(plans['it'][pi])
ncommit = plans['commit'].shape[2]
command = plans['commit'][b, pi, step]
cp, cm = plans['points'][b, pi, step], plans['midpoints'][b, pi, step]
checked = bool(plans['certified'][b, pi, step])
predicted = k32.clamp_box((prev + command)[None])[0]
row['certificate'] = {
'plan_start_it': int(plans['it'][pi]), 'step': step, 'checked': checked,
'endpoint': cp.tolist() if checked else None,
'midpoint': cm.tolist() if checked else None,
'recorded_gap32_mm': plans['gaps'][b, pi, [step, ncommit + step]].tolist() if checked else None,
'replayed_gap64_mm': k64.gaps(torch.stack([cp, cm]).double(), 0.5)['gm'].min(-1).values.tolist() if checked else None,
'command_delta': command.tolist(),
'clamped_reconstruction_max_abs_deg': float((predicted - q).abs().max()),
'certified_vs_executed_max_abs_deg': float((cp - q).abs().max()) if checked else None,
}
rows.append(row)
print('task %d first_hit %.2fs gap32 %s gap64 %s boundary %s' %
(row['i'], row['first_hit_s'], row['gap32_mm'], row['gap64_mm'], row['boundary_joints']), flush=True)
offset += count
result = {
'trace': path, 'n': offset, 'reported_collision_tasks': len(rows),
'replayed_first_hits32': sum(min(r['gap32_mm'][2:]) <= 0 for r in rows),
'replayed_first_hits64': sum(min(r['gap64_mm'][2:]) <= 0 for r in rows),
'scope': 'Replay reported first hits only; same geometry kernel at float32/float64, not a full safety audit.',
'rows': rows,
}
if out:
with open(out, 'w', encoding='utf-8') as f:
json.dump(result, f, indent=2, allow_nan=False)
print('replayed first hits: %d/%d float32, %d/%d float64' %
(result['replayed_first_hits32'], len(rows), result['replayed_first_hits64'], len(rows)), flush=True)
return result
@torch.no_grad()
def replay_dense(path, indices, max_step_deg=0.05, device='cpu', out=None):
saved = torch.load(path, map_location='cpu', weights_only=True)
kin = Kin(device=device, dtype=torch.float64)
if saved.get('kin_fp') != kin.fp:
raise ValueError('trace/kin fingerprint mismatch')
if not indices or min(indices) < 0 or max(indices) >= len(saved['tasks']) or max_step_deg <= 0:
raise ValueError('valid task indices and positive max_step_deg required')
started = time.perf_counter()
rows, offset = [], 0
for _, per, count in saved['batches']:
for index in indices:
if not offset <= index < offset + count:
continue
b = index - offset
nstep = min(per['traj'].shape[1] - 1, math.floor((float(per['limit'][b]) + 1e-6) / DT))
if torch.isfinite(per['t_done'][b]):
nstep = min(nstep, round(float(per['t_done'][b]) / DT))
trajectory = per['traj'][b, :nstep + 1].double()
points, segment_ids, fractions = [trajectory[:1]], [torch.tensor([-1])], [torch.zeros(1)]
for it in range(nstep):
prev, end = trajectory[it:it + 2]
nseg = max(2, 2 * math.ceil(float((end - prev).abs().max()) / (2 * max_step_deg)))
alpha = torch.arange(1, nseg + 1, dtype=torch.float64) / nseg
points.append(prev + alpha[:, None] * (end - prev))
segment_ids.append(torch.full((nseg,), it))
fractions.append(alpha)
points = torch.cat(points)
segments, alpha = torch.cat(segment_ids), torch.cat(fractions)
print('dense task %d steps %d points %d start' % (index, nstep, len(points)), flush=True)
gaps = []
for start in range(0, len(points), 64):
gaps.append(kin.gaps(points[start:start + 64].to(device), 0.5)['gm'].min(-1).values.cpu())
if (start // 64 + 1) % 64 == 0:
print('dense task %d points %d/%d wall %.1fs' %
(index, min(start + 64, len(points)), len(points), time.perf_counter() - started), flush=True)
gaps = torch.cat(gaps)
hit = gaps <= 0
first = int(hit.nonzero()[0]) if hit.any() else None
rows.append({
'i': index, 'task': saved['tasks'][index], 'steps': nstep, 'sampled_points': len(points),
'initial_gap64_mm': float(gaps[0]), 'min_gap64_mm': float(gaps.min()),
'collision_segments': int(segments[hit & (segments >= 0)].unique().numel()),
'first_collision_s': max(0.0, float(segments[first] + alpha[first]) * DT) if first is not None else None,
})
print('dense task %d min_gap %.9f mm collision_segments %d' %
(index, rows[-1]['min_gap64_mm'], rows[-1]['collision_segments']), flush=True)
offset += count
result = {
'trace': str(path), 'tasks_sha256': saved.get('tasks_sha256'), 'kin_fp': kin.fp,
'indices': indices, 'max_step_deg': max_step_deg, 'dtype': 'float64', 'device': device,
'scope': 'Executed trajectory through each task deadline or arrival, including initial state; finite sampling, not continuous certification.',
'collision_tasks': sum(r['min_gap64_mm'] <= 0 for r in rows), 'rows': rows,
'audit_wall_s': time.perf_counter() - started,
}
if out:
with open(out, 'w', encoding='utf-8') as f:
json.dump(result, f, indent=2, allow_nan=False)
return result
@torch.no_grad()
def replay_certificates(path, indices, device='cpu', out=None, repeats=5, extra_segments=()):
saved = torch.load(path, map_location='cpu', weights_only=True)
kin = Kin(device=device, dtype=torch.float64)
if saved.get('kin_fp') != kin.fp:
raise ValueError('trace/kin fingerprint mismatch')
if not indices or min(indices) < 0 or max(indices) >= len(saved['tasks']) or repeats < 1:
raise ValueError('valid task indices and positive repeats required')
rows, offset = [], 0
for _, per, count in saved['batches']:
for index in indices:
if not offset <= index < offset + count:
continue
b = index - offset
nstep = min(per['traj'].shape[1] - 1, math.floor((float(per['limit'][b]) + 1e-6) / DT))
if torch.isfinite(per['t_done'][b]):
nstep = min(nstep, round(float(per['t_done'][b]) / DT))
traj = per['traj'][b, :nstep + 1]
moving = ((traj[1:] - traj[:-1]).abs().max(-1).values > 1e-6).nonzero().flatten().tolist()
if not moving:
continue
plans = per['plans']
nearest, nearest_gap = None, float('inf')
for it in moving:
pi = int(torch.searchsorted(plans['it'], it, right=True)) - 1
step = it - int(plans['it'][pi])
if 0 <= step < plans['commit'].shape[2] and plans['certified'][b, pi, step]:
gap = float(plans['gaps'][b, pi, [step, plans['commit'].shape[2] + step]].min())
if gap < nearest_gap:
nearest, nearest_gap = it, gap
selected = {moving[0], moving[len(moving) // 2], moving[-1]}
if nearest is not None:
selected.add(nearest)
for task_index, it in extra_segments:
if task_index == index:
if it not in moving:
raise ValueError('extra segment must be a moving segment before deadline or arrival')
selected.add(it)
for it in sorted(selected):
rows.append({'i': index, 'start_it': it, 'a': traj[it].tolist(), 'b': traj[it + 1].tolist()})
offset += count
if not rows:
raise ValueError('no moving segments in selected tasks')
a = torch.tensor([r['a'] for r in rows], dtype=torch.float64, device=device)
b = torch.tensor([r['b'] for r in rows], dtype=torch.float64, device=device)
started = time.perf_counter()
print('certificate replay: %d tasks, %d fixed moving segments' % (len(indices), len(rows)), flush=True)
summaries = {}
for budget in (2, 8, 32):
result = kin.certify_segments(a, b, max_queries=budget)
summaries[str(budget)] = {key: int(result[key].sum()) for key in ('safe', 'collision', 'unresolved', 'outside_box')}
summaries[str(budget)]['queries_p50'] = float(result['queries'].double().quantile(0.5))
summaries[str(budget)]['queries_max'] = int(result['queries'].max())
for j, row in enumerate(rows):
row.setdefault('budgets', {})[str(budget)] = {key: value[j].item() for key, value in result.items()}
print('budget %d: %s' % (budget, summaries[str(budget)]), flush=True)
latencies = []
for j, row in enumerate(rows):
aa, bb = a[j:j + 1], b[j:j + 1]
discrete = kin.gaps(torch.cat([aa, aa + 0.5 * (bb - aa), bb]), 0.5)['gm'].min(-1).values
row['previous_midpoint_endpoint_gap_mm'] = discrete.tolist()
nseg = max(2, 2 * math.ceil(float((bb - aa).abs().max()) / 0.02))
alpha = torch.linspace(0, 1, nseg + 1, dtype=torch.float64, device=device)
points = aa + alpha[:, None] * (bb - aa)
dense = torch.cat([kin.gaps(chunk, 0.5)['gm'].min(-1).values for chunk in points.split(64)])
row['dense_points'] = len(points)
row['dense_min_gap_mm'] = float(dense.min())
row['dense_min_fraction'] = float(alpha[dense.argmin()])
for _ in range(3):
kin.certify_segments(aa, bb)
elapsed = []
for _ in range(repeats):
if a.is_cuda:
torch.cuda.synchronize(a.device)
t0 = time.perf_counter()
result = kin.certify_segments(aa, bb)
if a.is_cuda:
torch.cuda.synchronize(a.device)
elapsed.append((time.perf_counter() - t0) * 1000)
row['batch_single_match'] = all(value.item() == row['budgets']['32'][key] for key, value in result.items())
row['latency_ms'] = elapsed
latencies.extend(elapsed)
print('segment %d/%d task %d it %d dense %.6f mm queries %d latency %.2f ms' %
(j + 1, len(rows), row['i'], row['start_it'], row['dense_min_gap_mm'],
row['budgets']['32']['queries'], sum(elapsed) / len(elapsed)), flush=True)
elapsed = torch.tensor(latencies, dtype=torch.float64)
result = {
'trace': str(path), 'tasks_sha256': saved.get('tasks_sha256'), 'kin_fp': kin.fp,
'device': str(device), 'gpu': torch.cuda.get_device_name(a.device) if a.is_cuda else None,
'torch_version': str(torch.__version__), 'cpu_threads': torch.get_num_threads(), 'dtype': 'float64',
'indices': indices, 'extra_segments': list(extra_segments),
'selection': 'First/middle/last moving segment and minimum original certified gap per task; plus explicit extra_segments.',
'cap_mm': 20.0, 'eps_mm': 1e-4, 'max_depth': 12, 'dense_max_step_deg': 0.01,
'timing': {'scope': 'B=1 certificate only, resident inputs, 3 warmups per segment; synchronized wall time, not policy or scheduling latency.',
'repeats_per_segment': repeats, 'calls': len(latencies),
'p50_ms': float(elapsed.quantile(0.5)), 'p99_ms': float(elapsed.quantile(0.99)),
'max_ms': float(elapsed.max()), 'over_20ms': int((elapsed > 20).sum())},
'budgets': summaries,
'dense_collision_segments': sum(r['dense_min_gap_mm'] <= 0 for r in rows),
'accepted_dense_collision_segments': sum(r['dense_min_gap_mm'] <= 0 and r['budgets']['32']['safe'] for r in rows),
'batch_single_match': all(r['batch_single_match'] for r in rows),
'scope': 'Fixed recorded segments, not a new rollout. Dense replay is finite sampling; floating-point certification error is not formally bounded.',
'wall_s': time.perf_counter() - started, 'rows': rows,
}
if out:
with open(out, 'w', encoding='utf-8') as f:
json.dump(result, f, indent=2, allow_nan=False)
return result
def main(): def main():
ap = argparse.ArgumentParser() ap = argparse.ArgumentParser()
ap.add_argument('--ckpt', required=True) ap.add_argument('--ckpt')
ap.add_argument('--trace')
ap.add_argument('--dense_indices', help='逗号分隔的任务下标;回放实际轨迹,不依赖原 col 标记')
ap.add_argument('--cert_indices', help='固定实际段的连续认证、加密对照和单段计时')
ap.add_argument('--cert_segments', default='', help='额外指定任务号:零基段号,逗号分隔')
ap.add_argument('--repeats', type=int, default=5)
ap.add_argument('--max_step_deg', type=float, default=0.05)
ap.add_argument('--samples', default='ml/data/samples') ap.add_argument('--samples', default='ml/data/samples')
ap.add_argument('--split', default='val') ap.add_argument('--split', default='val')
ap.add_argument('--n', type=int, default=512) ap.add_argument('--n', type=int, default=512)
@@ -38,6 +282,26 @@ def main():
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu') ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu')
ap.add_argument('--out', default=None) ap.add_argument('--out', default=None)
a = ap.parse_args() a = ap.parse_args()
if a.dense_indices and a.cert_indices:
ap.error('--dense_indices and --cert_indices are mutually exclusive')
if a.cert_segments and not a.cert_indices:
ap.error('--cert_segments requires --cert_indices')
if a.trace:
if a.cert_indices:
extra = [tuple(map(int, segment.split(':'))) for segment in a.cert_segments.split(',') if segment]
indices = [int(i) for i in a.cert_indices.split(',')]
if any(len(segment) != 2 or segment[0] not in indices for segment in extra):
ap.error('--cert_segments requires task:segment pairs from --cert_indices')
replay_certificates(a.trace, indices, a.device, a.out, a.repeats, extra)
elif a.dense_indices:
replay_dense(a.trace, [int(i) for i in a.dense_indices.split(',')], a.max_step_deg, a.device, a.out)
else:
replay_first_hits(a.trace, a.out)
return
if a.dense_indices or a.cert_indices:
ap.error('--dense_indices and --cert_indices require --trace')
if not a.ckpt:
ap.error('--ckpt or --trace is required')
ck = torch.load(a.ckpt, map_location=a.device) ck = torch.load(a.ckpt, map_location=a.device)
model = build(ck['cfg']).to(a.device) model = build(ck['cfg']).to(a.device)
+178
View File
@@ -0,0 +1,178 @@
"""小规模同步闭环评估;仿真墙钟不等于控制延迟。"""
import argparse, functools, hashlib, json, math, time
from pathlib import Path
import torch
from ml.common.ckpt import load_policy
from ml.common.kin_torch import Kin
from ml.data import load_tasks
from ml.sim.closed_loop import rollout, tasks_to_tensors
import ml.sim.closed_loop as clmod
def run(model, kin, tasks, device, bs=256, **kw):
per = []
for i in range(0, len(tasks), bs):
t0 = time.perf_counter()
print('batch %d-%d/%d start' % (i + 1, min(i + bs, len(tasks)), len(tasks)), flush=True)
def progress(step, total):
print('batch %d step %d/%d wall %.1fs' % (i // bs + 1, step, total, time.perf_counter() - t0), flush=True)
r, p = rollout(model, kin, tasks[i:i + bs], device, progress=progress, **kw)
per.append((r, p, len(tasks[i:i + bs])))
print('batch %d done wall %.1fs' % (i // bs + 1, time.perf_counter() - t0), flush=True)
flat = {k: torch.cat([p[k] for _, p, _ in per]) for k in per[0][1] if k not in ('traj', 'plans')}
_, _, _, ex, tr = tasks_to_tensors(tasks, 'cpu')
ok, col = flat['ok'], flat['col'] > 0
has_ref = torch.isfinite(ex)
okr = ok & has_ref & torch.isfinite(tr)
median = lambda x: x.median().item() if x.numel() else None
out = {
'n': len(tasks), 'n_ref': int(has_ref.sum()),
'success': ok.float().mean().item(),
'collision_free_success': (ok & ~col).float().mean().item(),
'time_ok_1p3': (ok & has_ref & (flat['t_done'] <= 1.3 * ex)).sum().item() / int(has_ref.sum()) if has_ref.any() else None,
'collision_rate': col.float().mean().item(),
'collision_steps_mean': flat['col'].mean().item(),
'travel_ratio_median': median(flat['travel'][okr] / tr[okr].clamp(min=1)),
'time_mean_s': flat['t_done'][ok].mean().item() if ok.any() else None,
'brakes_mean': flat['brakes'].mean().item(),
'start_fail': flat['start_fail'].float().mean().item(),
'goal_ratio_2s': median(flat['goal_ratio_2s']),
'err_fail_med': median(flat['err'][~ok]),
'err_success_med': median(flat['err'][ok]),
'dls_share': flat['dls_it'].ge(0).float().mean().item(),
'time_budget': ('fixed %.3f s' % kw['max_sec']) if kw.get('max_sec') is not None else
(per[0][0]['time_budget'] if len({r['time_budget'] for r, _, _ in per}) == 1 else 'mixed'),
}
if 'speed_ratio' in flat: # 实际执行速度:每题时限内 max|Δq|/STEP(1.0 = VMAX),加速度同口径按每控制步的速度变化
v, acc = flat['speed_ratio'], flat['accel_ratio']
out.update({'speed_ratio_p50': median(v), 'speed_ratio_p95': v.quantile(0.95).item(),
'speed_ratio_max': v.max().item(), 'over_vmax_rate': (v > 1.001).float().mean().item(),
'accel_ratio_p95': acc.quantile(0.95).item(), 'accel_ratio_max': acc.max().item()})
if 'reverse_rate' in flat: # 换向步占比:行程超出主要是同一轴来回抖(轮次 39 分解),所以每个臂都要直接报它
rr = flat['reverse_rate']
out.update({'reverse_p50': median(rr), 'reverse_mean': rr.mean().item(),
'reverse_moving_p50': median(flat['reverse_rate_moving']), # 只在动了的步上算,不被刹停稀释
'moving_share_p50': median(flat['moving_share'])}) # 活动窗内动了的步占比(=1−站住比例)
if 'brake_rate' in flat: # §9.2 要"刹停 <2% 推理周期"。均值会被长尾拖着(实测 p50=0.5% 而 mean=10%),
rr = flat['brake_rate'] # 所以必须分层报:p90 与"卡住题占比"才是能区分杠杆的读数。
out.update({'brake_rate_mean': rr.mean().item(), 'brake_rate_p50': median(rr), 'brake_rate_p90': rr.quantile(0.9).item(),
'stuck_share': (rr > 0.2).float().mean().item(),
'n_plans_mean': flat['n_plans'].mean().item()})
cats = [t.get('cat') for t in tasks] # 分层读数:D 类按定义不可达,混在分母里会让"可达任务到达率"失真
reach = torch.tensor([c != 'D' for c in cats])
if reach.any():
out['success_reachable'] = (ok[reach].float().mean().item())
out['by_cat'] = {c: [int(sum(1 for x in cats if x == c)), int(sum(1 for i, x in enumerate(cats) if x == c and ok[i]))]
for c in sorted({c for c in cats if c})}
if 'backoff' in flat and flat['backoff'].any(): # backoff=缩步顶上的次数;brakes 现在只记连最小档都不安全的
out['backoff_mean'] = flat['backoff'].mean().item() # ⇒ 原来的"全拒"事件数 = 两者之和
out['reject_all_mean'] = (flat['backoff'] + flat['brakes']).mean().item()
if 'tie_opp' in flat and flat['tie_opp'].any(): # tie=1 的自检:钩子可用率/真的改选率,分母与 brake_rate 同为规划次数
out.update({'tie_opp_rate_mean': flat['tie_opp_rate'].mean().item(),
'tie_changed_rate_mean': flat['tie_changed_rate'].mean().item(),
'tie_opp_task_share': (flat['tie_opp'] > 0).float().mean().item()})
return out, per
def json_finite(value):
if isinstance(value, dict): return {k: json_finite(v) for k, v in value.items()}
if isinstance(value, list): return [json_finite(v) for v in value]
if isinstance(value, float) and not math.isfinite(value): return None
return value
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--ckpt', default='ml/runs/base_dag2_dag1/best.pt')
ap.add_argument('--samples', default='ml/data/samples')
ap.add_argument('--tasks', default=None)
ap.add_argument('--split', default='val')
ap.add_argument('--n', type=int, default=256)
ap.add_argument('--K', type=int, default=8)
ap.add_argument('--commit', type=int, default=3)
ap.add_argument('--fb', type=float, default=1.8)
ap.add_argument('--ki', type=float, default=0.0)
ap.add_argument('--fb_scale', type=float, default=0.0)
ap.add_argument('--fb_near', type=float, default=0.2)
ap.add_argument('--fb_fallback', type=float, default=0.0)
ap.add_argument('--kdecay', type=float, default=0.9)
ap.add_argument('--kimax', type=float, default=0.5)
ap.add_argument('--fb_every', type=int, default=1)
ap.add_argument('--safety_try', type=int, default=0)
ap.add_argument('--sel_w', type=float, default=0.1)
ap.add_argument('--dls_safety', type=int, default=0)
ap.add_argument('--fb_clear', type=float, default=0.0)
ap.add_argument('--fb_cmin', type=float, default=0.3)
ap.add_argument('--sub_refresh', type=int, default=0)
ap.add_argument('--fb_block_gain', type=float, default=1.0)
ap.add_argument('--dump', default=None)
ap.add_argument('--out', default=None)
ap.add_argument('--trace', default=None)
ap.add_argument('--select', default='consist')
ap.add_argument('--replan', default='r3')
ap.add_argument('--safety', type=int, default=1, help='1=安全层+部分前缀;0=关')
ap.add_argument('--partial', type=int, default=1)
ap.add_argument('--inc_cap', type=int, default=0, help='1=反馈叠加后再按每轴 VMAX·DT 限幅')
ap.add_argument('--gap_margin', type=float, default=0.0, help='安全层要求的间隙余量 mm(>0 时宽相位 cap 自动抬到 margin+0.5)')
ap.add_argument('--cert_batch', type=int, default=0, help='1=一次 gaps 调用覆盖全部候选(压最坏情况,典型路径略贵)')
ap.add_argument('--steps', type=int, default=1, help='MeanFlow 采样段数;1=线上一口径(历史发布数字全是 1)')
ap.add_argument('--z_scale', type=float, default=1.0, help='候选噪声缩放:>1 让 K 条候选更分散(测"全拒是没有备选"还是"真的没路")')
ap.add_argument('--len_w', type=float, default=0.0, help="ep_len=罚累计归一行程;ep_waste=罚(1−净/总)×当前误差;0 与 endpoint 逐位相同")
ap.add_argument('--tie', type=int, default=0, help='1=等长安全前缀时按沿路最小间隙定夺(需 --cert_batch 1)')
ap.add_argument('--pre_h', type=int, default=0, help="select=pre 的打分步长:0=commit_n(被执行前缀),>0=按绝对步数(#30 曲线)")
ap.add_argument('--pre_near', type=float, default=0.0, help="select=pre 的门控阈值(mm):当前误差≤它时改用整条地平线打分(#31,0=关)")
ap.add_argument('--backoff', type=int, default=0, help='全拒时把首选候选按 1/2、1/4…缩步重试的档数(需 --cert_batch 1)')
ap.add_argument('--max_sec', type=float, default=None)
ap.add_argument('--seed', type=int, default=0)
ap.add_argument('--dls', default='analytic', choices=['analytic', 'fd'])
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu')
a = ap.parse_args()
print('config ' + json.dumps(vars(a), ensure_ascii=False), flush=True)
if a.dls == 'fd':
clmod.dls_steps = functools.partial(clmod.dls_steps, analytic=False)
model, ck = load_policy(a.ckpt, a.device)
kin = Kin(device=a.device)
assert ck.get('fp') in (None, kin.fp)
tasks = ([json.loads(l) for l in open(a.tasks, encoding='utf-8') if l.strip()] if a.tasks
else [t for t in load_tasks([a.samples]) if t['split'] == a.split])
tasks = tasks[:a.n]
if not tasks: ap.error('no tasks selected')
meta = {
'config': vars(a), 'batch_size': 256, 'batch_seed_rule': 'same seed per batch',
'checkpoint_sha256': hashlib.sha256(Path(a.ckpt).read_bytes()).hexdigest(),
'tasks_sha256': hashlib.sha256(json.dumps(tasks, sort_keys=True).encode()).hexdigest(),
'kin_fp': kin.fp, 'act_scale': float(model.act_scale),
}
t0 = time.perf_counter()
r, pers = run(model, kin, tasks, a.device, K=a.K, safety=bool(a.safety), seed=a.seed, max_sec=a.max_sec, steps=a.steps, z_scale=a.z_scale,
safety_partial=(a.commit if (a.safety and a.partial) else 0), commit_n=a.commit,
select=a.select, replan=a.replan, fb_gain=a.fb, fb_scale=a.fb_scale, fb_near=a.fb_near, fb_fallback=a.fb_fallback, fb_ki=a.ki, fb_decay=a.kdecay, fb_imax=a.kimax,
fb_every=a.fb_every, safety_try=a.safety_try, sel_w=a.sel_w, dls_safety=a.dls_safety, fb_clear=a.fb_clear, fb_cmin=a.fb_cmin, sub_refresh=a.sub_refresh, fb_block_gain=a.fb_block_gain,
inc_cap=a.inc_cap, gap_margin=a.gap_margin, cert_batch=a.cert_batch, backoff=a.backoff, len_w=a.len_w, tie=a.tie, pre_h=a.pre_h, pre_near=a.pre_near, return_traj=bool(a.trace))
wall = time.perf_counter() - t0
result = {**meta, 'metrics': r, 'simulation_wall_s': wall}
print(json.dumps(json_finite(result), ensure_ascii=False, allow_nan=False), flush=True)
if a.out:
Path(a.out).write_text(json.dumps(json_finite(result), indent=2, ensure_ascii=False, allow_nan=False) + '\n', encoding='utf-8')
if a.dump:
rows = []
keys = ['done', 'ok', 't_done', 'limit', 'col', 'brakes', 'err', 'first_hit', 'dls_it', 'goal_ratio_2s', 'brake_rate', 'n_plans',
'tie_opp', 'tie_changed', 'tie_opp_rate', 'tie_changed_rate']
flat = {k: torch.cat([p[k] for _, p, _ in pers]).tolist() for k in keys}
_, _, _, ex_t, tr_t = tasks_to_tensors(tasks, 'cpu') # run() 里的同名量是局部变量,这里必须自取
for i, t in enumerate(tasks):
row = {**t, 'i': i, **{k: flat[k][i] for k in keys}}
# 老师用时/行程是题目属性(与臂无关),落盘后任何一臂都能给历史臂补上"1.3×老师"的逐题配对
row['t_exp'] = float(ex_t[i]) if torch.isfinite(ex_t[i]) else None
row['tr_ref'] = float(tr_t[i]) if torch.isfinite(tr_t[i]) else None
rows.append(row)
Path(a.dump).write_text(json.dumps(json_finite(rows), allow_nan=False), encoding='utf-8')
print('dump', a.dump, flush=True)
if a.trace:
torch.save({**meta, 'tasks': tasks, 'batches': pers}, a.trace)
print('trace', a.trace, flush=True)
if __name__ == '__main__':
main()
+35 -6
View File
@@ -26,17 +26,46 @@ def sample_rt(B, device, dtype, p_neq=0.25, mu=-0.4, sigma=1.0, p_edge=0.0):
return r, t return r, t
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): def avg_velocity_target(model, mem, x, e, r, t, target='mf', lam=0.5):
"""平均速度目标的三种写法(目标都 detach;u 带梯度)。target='mf' 与原实现逐位相同。
mf :Eq.4 单段自举 v − (t−r)·du/dt,收敛解 = 平均速度(解析高斯场已验证偏差 <1e−12)
lin :v − (t−r)·[(1−λ)·du(z_t,c,t)/dt + λ·du(z_c,r,c)/dc],系数和=1 ⇒ 收敛解仍是平均速度
sq :同上的 (1−λ)²/λ² 版(K-MF 论文摘要里的写法)⇒ 系数和 0.5,实测只线性收敛(结构性少修一半)
mid :v − (t−r)·du(z_c,r,c)/dc,整条修正移到中点
"""
fn = lambda z_, r_, t_: model.decode(mem, z_, r_, t_)
z = (1 - t)[:, None, None] * x + t[:, None, None] * e
v = e - x
if target == 'mf':
u, dudt = jvp(fn, (z, r, t), (v, torch.zeros_like(r), torch.ones_like(t)))
return u, (v - (t - r)[:, None, None] * dudt).detach(), z
with torch.no_grad():
u = fn(z, r, t) # 这三种写法只要前向拿 u,导数全部进目标(sg)
c = (1 - lam) * t + lam * r
zc = (1 - c)[:, None, None] * x + c[:, None, None] * e
tv = (v, torch.zeros_like(r), torch.ones_like(t))
def jv(zz, rr, tt):
with torch.enable_grad():
return jvp(fn, (zz, rr, tt), tv)[1].detach()
if target == 'mid':
corr = jv(zc, r, c)
else:
d1 = jv(z, c, t)
d2 = jv(zc, r, c)
w = ((1 - lam) ** 2, lam ** 2) if target == 'sq' else ((1 - lam), lam)
corr = w[0] * d1 + w[1] * d2
return u, (v - (t - r)[:, None, None] * corr).detach(), z
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, target='mf', lam=0.5):
mem, x = mem.float(), x.float() mem, x = mem.float(), x.float()
with torch.autocast('cuda', enabled=False): with torch.autocast('cuda', enabled=False):
B = x.shape[0] B = x.shape[0]
r, t = sample_rt(B, x.device, x.dtype, p_neq, p_edge=p_edge) r, t = sample_rt(B, x.device, x.dtype, p_neq, p_edge=p_edge)
e = torch.randn_like(x) e = torch.randn_like(x)
z = (1 - t)[:, None, None] * x + t[:, None, None] * e u, u_tgt, z = avg_velocity_target(model, mem, x, e, r, t, target, lam)
v = e - x
fn = lambda z_, r_, t_: model.decode(mem, z_, r_, t_)
u, dudt = jvp(fn, (z, r, t), (v, torch.zeros_like(r), torch.ones_like(t)))
u_tgt = (v - (t - r)[:, None, None] * dudt).detach()
err = (u - u_tgt).pow(2).mean(dim=(1, 2)) err = (u - u_tgt).pow(2).mean(dim=(1, 2))
w = 1.0 / (err.detach() + ada_c).pow(ada_p) w = 1.0 / (err.detach() + ada_c).pow(ada_p)
loss = (w * err).mean() loss = (w * err).mean()
+3
View File
@@ -144,6 +144,7 @@
.ctlrow { display: flex; gap: 10px; margin-top: 14px; align-items: center; flex-wrap: wrap; } .ctlrow { display: flex; gap: 10px; margin-top: 14px; align-items: center; flex-wrap: wrap; }
.ctlrow .hint { font-size: 12px; color: var(--dim2); } .ctlrow .hint { font-size: 12px; color: var(--dim2); }
.term { background: #070a10; border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; height: 260px; overflow: auto; font: 12px/1.55 var(--mono); color: #c9d4e3; white-space: pre-wrap; word-break: break-all; } .term { background: #070a10; border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; height: 260px; overflow: auto; font: 12px/1.55 var(--mono); color: #c9d4e3; white-space: pre-wrap; word-break: break-all; }
.explore { background: #0b0f16; border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; max-height: 560px; overflow: auto; font: 12px/1.7 var(--mono); color: #c9d4e3; white-space: pre-wrap; }
.term .e { color: var(--bad); } .term .c { color: var(--accent); } .term .g { color: var(--ok); } .term .e { color: var(--bad); } .term .c { color: var(--accent); } .term .g { color: var(--ok); }
.modal { position: fixed; inset: 0; background: #05080ed9; backdrop-filter: blur(7px); display: none; align-items: flex-start; justify-content: center; z-index: 40; padding: 5vh 16px 24px; overflow: auto; } .modal { position: fixed; inset: 0; background: #05080ed9; backdrop-filter: blur(7px); display: none; align-items: flex-start; justify-content: center; z-index: 40; padding: 5vh 16px 24px; overflow: auto; }
.modal.show { display: flex; } .modal.show { display: flex; }
@@ -213,6 +214,7 @@
<div class="card"><h2><span>部署形态评测</span><span class="r">策略 + 安全层</span></h2><div id="bench"></div></div> <div class="card"><h2><span>部署形态评测</span><span class="r">策略 + 安全层</span></h2><div id="bench"></div></div>
<div class="card"><h2><span>验收汇总</span><span class="r">方案 §9.2</span></h2><div id="accept"></div></div> <div class="card"><h2><span>验收汇总</span><span class="r">方案 §9.2</span></h2><div id="accept"></div></div>
</section> </section>
<section class="card"><h2><span>闭环探索日志</span><span class="r">docs/探索日志.md</span></h2><div class="explore" id="explore">加载中…</div></section>
<section class="card"><h2><span>终端输出</span><span class="r" id="termnote">ml/runs/console.log</span></h2><div class="term" id="term"></div></section> <section class="card"><h2><span>终端输出</span><span class="r" id="termnote">ml/runs/console.log</span></h2><div class="term" id="term"></div></section>
<footer id="foot"></footer> <footer id="foot"></footer>
</main> </main>
@@ -834,6 +836,7 @@ $('logy').onclick = () => { logyOn = !logyOn; $('logy').classList.toggle('on', l
for (const id of PREF_IDS) { $(id).onchange = prefSave; $(id).oninput = prefSave; } for (const id of PREF_IDS) { $(id).onchange = prefSave; $(id).oninput = prefSave; }
$('run').onchange = () => { userPicked = true; cur = null; poll(); }; $('run').onchange = () => { userPicked = true; cur = null; poll(); };
$('scenario').onchange = () => { api.scenario($('scenario').value); cur = null; userPicked = false; conOff = 0; $('run').innerHTML = ''; poll(); }; $('scenario').onchange = () => { api.scenario($('scenario').value); cur = null; userPicked = false; conOff = 0; $('run').innerHTML = ''; poll(); };
api('/api/explore').then(d => { const el = $('explore'); el.textContent = (d && d.md) ? d.md : '(demo 模式:无探索日志)'; }).catch(() => { const el = $('explore'); el.textContent = '(无法读取 docs/探索日志.md)'; });
$('auto').onclick = () => { const on = !$('auto').classList.contains('on'); $('auto').classList.toggle('on', on); clearInterval(timer); if (on) timer = setInterval(poll, 1000); }; $('auto').onclick = () => { const on = !$('auto').classList.contains('on'); $('auto').classList.toggle('on', on); clearInterval(timer); if (on) timer = setInterval(poll, 1000); };
timer = setInterval(poll, 1000); poll(); timer = setInterval(poll, 1000); poll();
+5
View File
@@ -608,6 +608,11 @@ class H(BaseHTTPRequestHandler):
if u.path == '/api/status': return self.send(200, json.dumps(status()), 'application/json') if u.path == '/api/status': return self.send(200, json.dumps(status()), 'application/json')
if u.path == '/api/job': return self.send(200, json.dumps(JOB.state()), 'application/json') if u.path == '/api/job': return self.send(200, json.dumps(JOB.state()), 'application/json')
if u.path == '/api/console': return self.send(200, json.dumps(console(int(q.get('offset', ['0'])[0]))), 'application/json') if u.path == '/api/console': return self.send(200, json.dumps(console(int(q.get('offset', ['0'])[0]))), 'application/json')
if u.path == '/api/explore': # 2026-10-20:闭环探索日志(docs/探索日志.md)回写控制台
try:
with open(os.path.join(ROOT, 'docs', '探索日志.md'), encoding='utf-8') as f: md = f.read()
except Exception: md = ''
return self.send(200, json.dumps({'md': md}), 'application/json')
self.send(404, 'not found', 'text/plain') self.send(404, 'not found', 'text/plain')
except Exception as e: except Exception as e:
self.send(500, json.dumps({'error': str(e)}), 'application/json') self.send(500, json.dumps({'error': str(e)}), 'application/json')
+295 -35
View File
@@ -48,23 +48,42 @@ def goal_err(kin, q, T, R):
return e, oe return e, oe
def dls_steps(kin, q, T, R, n=3, scale=0.3, lam=0.5): def execution_points(kin, q, increments):
"""局部 DLS 精修:n 步增量 [B,n,6]""" points, midpoints = [], []
for delta in increments.unbind(1):
nxt = kin.clamp_box(q + delta)
midpoints.append(q + 0.5 * (nxt - q))
points.append(nxt)
q = nxt
return torch.stack(points, 1), torch.stack(midpoints, 1)
def dls_steps(kin, q, T, R, n=3, scale=0.3, lam=0.5, analytic=True):
"""局部 DLS 精修:n 步增量 [B,n,6](analytic:几何雅可比,1 次 FK;否则 7 次批量有限差分)"""
step = torch.tensor(STEP, device=q.device) step = torch.tensor(STEP, device=q.device)
B = q.shape[0]
pose = (R.abs().sum(-1) > 0).float() pose = (R.abs().sum(-1) > 0).float()
Rt = R.view(-1, 3, 3) Rt = R.view(-1, 3, 3)
def err(x): def err(x, Tb, Rtb, poseb, xf=None):
xf = kin.cum_xf(x); p = kin.fk(x, xf); Rq = kin.orient(x, xf) xf = xf if xf is not None else kin.cum_xf(x)
M = Rt @ Rq.transpose(1, 2) p = kin.fk(x, xf); Rq = kin.orient(x, xf)
rv = 0.5 * torch.stack([M[:, 2, 1] - M[:, 1, 2], M[:, 0, 2] - M[:, 2, 0], M[:, 1, 0] - M[:, 0, 1]], -1) * 100 * pose[:, None] M = Rtb @ Rq.transpose(1, 2)
return torch.cat([T - p, rv], -1) rv = 0.5 * torch.stack([M[:, 2, 1] - M[:, 1, 2], M[:, 0, 2] - M[:, 2, 0], M[:, 1, 0] - M[:, 0, 1]], -1) * 100 * poseb[:, None]
return torch.cat([Tb - p, rv], -1)
out = []; x = q.clone() out = []; x = q.clone()
ar = torch.arange(6, device=q.device)
for _ in range(n): for _ in range(n):
e0 = err(x); J = [] xf = kin.cum_xf(x)
for j in range(6): e0 = err(x, T, Rt, pose, xf)
dx = torch.zeros_like(x); dx[:, j] = 1e-3 if analytic:
J.append(-(err(x + dx) - e0) / 1e-3) # 几何角速度 Jw 仅在姿态误差接近零时等于该 skew 残差的负导数。
J = torch.stack(J, -1) # [B,6(err),6(q)] Jv, Jw = kin.jac(x, xf)
J = torch.cat([Jv, 100 * Jw * pose[:, None, None]], 1)
else:
dx = torch.zeros(B, 6, 6, device=q.device); dx[:, ar, ar] = 1e-3
xp = (x[:, None, :] + dx).reshape(B * 6, 6)
ep = err(xp, T.repeat_interleave(6, 0), Rt.repeat_interleave(6, 0), pose.repeat_interleave(6, 0))
J = -((ep - e0.repeat_interleave(6, 0)) / 1e-3).view(B, 6, 6).transpose(1, 2) # [B,6(err),6(q)]
A = J @ J.transpose(1, 2) + lam ** 2 * torch.eye(6, device=q.device) A = J @ J.transpose(1, 2) + lam ** 2 * torch.eye(6, device=q.device)
y = torch.linalg.solve(A, e0.unsqueeze(-1)) y = torch.linalg.solve(A, e0.unsqueeze(-1))
dq = (J.transpose(1, 2) @ y).squeeze(-1) dq = (J.transpose(1, 2) @ y).squeeze(-1)
@@ -141,17 +160,31 @@ class TeacherOracle:
@torch.no_grad() @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, 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'): qp0=None, steps=1, z_scale=1.0, select='consist', oracle=None, replan='r3', sub_rule='cross',
fb_gain=0.0, fb_scale=0.0, fb_near=0.2, fb_fallback=0.0, safety_partial=0, commit_n=3, collect=None,
fb_exec=0.0, exec_safety=0, fb_ki=0.0, fb_decay=0.9, fb_imax=0.5, fb_every=1, safety_try=0, sel_w=0.1, dls_safety=0, fb_clear=0.0, fb_cmin=0.3, sub_refresh=0, fb_block_gain=1.0,
inc_cap=0, gap_margin=0.0, cert_batch=0, backoff=0, len_w=0.0, tie=0, pre_h=0, pre_near=0, progress=None):
"""use_sub=False:不用子目标(sf=0);sub_override=(subs [B,M,6] 绝对关节角, n [B] 个数 或 need [B] bool):冷启动时用给定途经点代替子目标头; """use_sub=False:不用子目标(sf=0);sub_override=(subs [B,M,6] 绝对关节角, n [B] 个数 或 need [B] bool):冷启动时用给定途经点代替子目标头;
qp0 [B,6]:起点的上一帧(默认 = q0,即静止起步)。steps:MeanFlow 采样段数;z_scale:噪声缩放; qp0 [B,6]:起点的上一帧(默认 = q0,即静止起步)。steps:MeanFlow 采样段数;z_scale:噪声缩放;
select:consist(部署口径:冷启动价值前瞻、之后与上一条已提交计划的一致性)/ value(每次都价值前瞻)/ first(不选,取第 0 条)。 select:consist(部署口径:冷启动价值前瞻、之后与上一条已提交计划的一致性)/ value(每次都价值前瞻)/ first(不选,取第 0 条)。
select='pre':把打分地平线换成「这一轮真会执行到的位置」(fut 的第 commit_n 步);'endpoint' 用的是整条地平线末端。
oracle:TeacherOracle,代替 model 出动作(model 可为 None,须配 select='first'、use_sub=False)。 oracle:TeacherOracle,代替 model 出动作(model 可为 None,须配 select='first'、use_sub=False)。
replan:'r3'(部署:队列 ≤ 3 步就规划,稳态 r=3)/ 'empty'(队列空了才规划,每次 r=0,前缀消融用)。 replan:'r3'(部署:队列 ≤ 3 步就规划,稳态 r=3)/ 'empty'(队列空了才规划,每次 r=0,前缀消融用)。
sub_rule:子目标推进规则,见 sub_advance。除默认值外均为诊断用。""" sub_rule:子目标推进规则,见 sub_advance。除默认值外均为诊断用。
inc_cap=1:把「策略动作 + 目标反馈」的合计增量再按每轴 VMAX·DT 限一次幅(默认关;关时反馈是在 ±1 限幅之后叠加的,第30轮实测最大 1.66×VMAX)。
gap_margin>0:安全层要求间隙大于该毫米余量而不是 >0;宽相位 cap 自动抬到 margin+0.5,否则 0.5 的截顶值会让余量门限恒假。
backoff>0:全拒(连第 1 步都不安全)时不再站住,把首选候选按 1/2、1/4…(共 backoff 档)缩步一起送进同一次认证,
取能通过的第 1 档执行;缩步候选不参与"前缀更长者优先"的比较,只在原候选全被拒时顶上。需 cert_batch=1。
tie=1:等长安全前缀之间改用「沿路最小间隙更大」定夺(默认 0=沿用选择器分数顺序)。需 cert_batch=1。
select='ep_len' + len_w>0:在末态误差打分上再减 len_w·Σ|Δ|/STEP(每轴归一的候选累计行程)。§9.2 要行程≤规划器×1.10,
而实测行程比 2.4~2.6 没有任何机制在管;len_w=0 与 select='endpoint' 逐位相同(有回归断言)。
两者默认值下行为与第32轮逐位相同。"""
if (backoff or tie) and not cert_batch: raise ValueError('backoff/tie 目前只实现在 cert_batch=1 口径')
g = torch.Generator(device=device); g.manual_seed(seed) g = torch.Generator(device=device); g.manual_seed(seed)
q0, T, R, ex, tr = tasks_to_tensors(tasks, device) q0, T, R, ex, tr = tasks_to_tensors(tasks, device)
B = q0.shape[0] B = q0.shape[0]
step = torch.tensor(STEP, device=device) step = torch.tensor(STEP, device=device)
gcap = max(0.5, gap_margin + 0.5) # 余量门限必须落在截顶值之内才有意义
act_scale = oracle.act_scale if oracle is not None else float(getattr(model, 'act_scale', 1.0)) act_scale = oracle.act_scale if oracle is not None else float(getattr(model, 'act_scale', 1.0))
astep = step * act_scale # 动作反归一化:每单位 act 对应的度数 astep = step * act_scale # 动作反归一化:每单位 act 对应的度数
has_ref = torch.isfinite(ex) has_ref = torch.isfinite(ex)
@@ -160,12 +193,24 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
q, qp = q0.clone(), (qp0.to(device) if qp0 is not None else q0.clone()) q, qp = q0.clone(), (qp0.to(device) if qp0 is not None else q0.clone())
queue = torch.zeros(B, 0, 6, device=device) queue = torch.zeros(B, 0, 6, device=device)
last = None; last_ok = torch.zeros(B, dtype=torch.bool, device=device) last = None; last_ok = torch.zeros(B, dtype=torch.bool, device=device)
fb_i = torch.zeros(B, 6, device=device) # 积分项:累积持续同向的目标反馈(慢变偏差)
fb_cache = None; pit = 0 # fb_every>1:复用上一次规划的目标反馈(误差方向慢变)
last_brake = 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) 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() 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) 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) col = torch.zeros(B, device=device); travel = torch.zeros(B, device=device); brakes = torch.zeros(B, device=device)
bo = torch.zeros(B, device=device) # 缩步顶上的次数(backoff>0 才会计)
to = torch.zeros(B, device=device) # tie=1 才计:出现「等长安全前缀并列」的规划次数(钩子可用)
tx = torch.zeros(B, device=device) # tie=1 才计:并列里真的由余量改选了那条的次数(钩子有效)
first_hit = torch.full((B,), float('nan'), device=device); dls_it = torch.full((B,), -1, dtype=torch.long, device=device) first_hit = torch.full((B,), float('nan'), device=device); dls_it = torch.full((B,), -1, dtype=torch.long, device=device)
# 2026-10-20(轮次33):速度/加速度按「实际执行位移」算,不看指令——第30轮证明反馈是在限幅之后叠加的
vratio = torch.zeros(B, device=device); aratio = torch.zeros(B, device=device); prev_exec = torch.zeros(B, 6, device=device)
rev = torch.zeros(B, device=device); nact = torch.zeros(B, device=device); prev_sgn = torch.zeros(B, 6, device=device)
nmov = torch.zeros(B, device=device)
nplan = torch.zeros(B, device=device) # 每题规划次数 = 推理周期数(§9.2 的"刹停 <2% 推理周期"要这个分母)
traj = [q.clone()] if return_traj else None traj = [q.clone()] if return_traj else None
plans = {k: [] for k in ('it', 'r', 'qe', 'commit', 'points', 'midpoints', 'gaps', 'certified')} if return_traj else None
n_start = int(round(0.5 / DT)); moved_start = None # R2 起步失败:0.5 s 内关节总行程 < 1° n_start = int(round(0.5 / DT)); moved_start = None # R2 起步失败:0.5 s 内关节总行程 < 1°
k2s = int(round(2.0 / DT)); e2 = None k2s = int(round(2.0 / DT)); e2 = None
e0, _ = goal_err(kin, q0, T, R) e0, _ = goal_err(kin, q0, T, R)
@@ -176,9 +221,14 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
for it in range(nmax): for it in range(nmax):
tnow = it * DT tnow = it * DT
if (queue.shape[1] <= 3) if replan == 'r3' else (queue.shape[1] == 0): if (queue.shape[1] <= 3) if replan == 'r3' else (queue.shape[1] == 0):
nplan += 1.0 # 验收判据要"刹停 / 推理周期"的比值,分母就是这个(批内所有行同步规划)
r = queue.shape[1] r = queue.shape[1]
pre = torch.zeros(B, 3, 6, device=device); pre[:, :r] = queue[:, :r] pre = torch.zeros(B, 3, 6, device=device)
qe = q + queue.sum(1) qe = q
if r:
prefix_points, _ = execution_points(kin, q, queue)
pre[:, :r] = prefix_points - torch.cat([q[:, None], prefix_points[:, :-1]], 1)
qe = prefix_points[:, -1]
e, oe = goal_err(kin, qe, T, R) e, oe = goal_err(kin, qe, T, R)
near = (e < 5) & ((R.abs().sum(-1) == 0) | (oe < 5)) near = (e < 5) & ((R.abs().sum(-1) == 0) | (oe < 5))
subs, nsub, sub_prev, sub_t = sub_advance(kin, subs, nsub, sub_prev, sub_t, qe, tnow, sub_rule) subs, nsub, sub_prev, sub_t = sub_advance(kin, subs, nsub, sub_prev, sub_t, qe, tnow, sub_rule)
@@ -189,7 +239,43 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
else: else:
z = torch.randn(B * K, H, 6, device=device, generator=g) * z_scale z = torch.randn(B * K, H, 6, device=device, generator=g) * z_scale
act, val, sub = model.sample_k(feat, K, z, steps=steps) act, val, sub = model.sample_k(feat, K, z, steps=steps)
if sub_refresh and not cold: # 子目标头作为反应式规划:没有待走途经点时,用当前状态的预测补一个(训练标签在每个状态都有 sub)
need = sub[:, 12] > 0.5
newsubs = q[:, None] + sub[:, :12].float().view(B, 2, 6) * 180
rf = need & (nsub <= 0)
subs = torch.where(rf[:, None, None], newsubs, subs)
nsub = torch.where(rf, torch.full_like(nsub, 2), nsub)
sub_prev = torch.where(rf[:, None], q, sub_prev)
sub_t = torch.where(rf, torch.full_like(sub_t, tnow), sub_t)
inc = act.float().clamp(-1, 1) * astep inc = act.float().clamp(-1, 1) * astep
if fb_gain > 0: # 实验(2026-10-20):目标反馈加在所有候选上(安全层也评估带反馈的候选)
if fb_cache is None or fb_every <= 1 or pit % fb_every == 0:
fb = dls_steps(kin, qe, T, R, n=1); fb_cache = fb
else:
fb = fb_cache
pit += 1
gm_ = None
if fb_clear > 0: # 近障碍衰减:反馈方向可能把候选推进障碍,贴近时让模型自己的绕行占主导
dgc = kin.gaps(qe, fb_clear)['gm'].min(-1).values
gm_ = torch.clamp(dgc / fb_clear, fb_cmin, 1.0)
if fb_ki > 0:
fb_i = fb_decay * fb_i + fb[:, 0] * (~done)[:, None]
lim = step * fb_imax
fb_i = fb_i.clamp(-lim, lim)
inc = inc + fb_gain * fb[:, :, None, :] + fb_ki * fb_i[:, None, None, :]
elif fb_scale > 0: # 距离衰减:远离目标全增益,贴近目标减弱(减少过冲/刹停)
dg, _ = goal_err(kin, qe, T, R)
gdec = fb_gain * torch.clamp(dg / fb_scale, fb_near, 1.0)
if gm_ is not None: gdec = gdec * gm_
inc = inc + gdec[:, None, None, None] * fb[:, :, None, :]
else:
gv = torch.full((B,), fb_gain, device=device, dtype=fb.dtype)
if gm_ is not None: gv = gv * gm_
if fb_block_gain != 1.0: # 上一次被安全层全拒:减弱目标反馈,让模型自己的绕行候选有机会通过认证
gv = torch.where(last_brake, gv * fb_block_gain, gv)
inc = inc + gv[:, None, None, None] * fb[:, :, None, :]
if inc_cap:
inc = torch.maximum(torch.minimum(inc, step), -step) # 反馈之后才限幅:限的是真正要执行的每轴增量
if cold: if cold:
need = sub[:, 12] > 0.5 need = sub[:, 12] > 0.5
subs = q[:, None] + sub[:, :12].float().view(B, 2, 6) * 180 subs = q[:, None] + sub[:, :12].float().view(B, 2, 6) * 180
@@ -206,6 +292,35 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
fut = qe[:, None, None] + torch.cumsum(inc[:, :, r:], 2) # [B,K,H-r,6] fut = qe[:, None, None] + torch.cumsum(inc[:, :, r:], 2) # [B,K,H-r,6]
if select == 'first': if select == 'first':
score = torch.zeros(B, K, device=device); score[:, 0] = 1 score = torch.zeros(B, K, device=device); score[:, 0] = 1
elif select == 'pre': # #29:按「这一轮真会执行到的位置」打分,而不是 16 步开环外推的末端。
# 诊断来自 ep_len/ep_waste 的失败:打分地平线远长于提交步数,被安全层截断的候选那个终点根本到不了。
qa_pre = fut[:, :, min(pre_h if pre_h > 0 else commit_n, fut.shape[2]) - 1].reshape(B * K, 6)
e_pre, _ = goal_err(kin, qa_pre, T.repeat_interleave(K, 0), R.repeat_interleave(K, 0))
score = -e_pre.view(B, K)
if pre_near > 0: # #31:近终段换回整条地平线(终端代价)。轮次 48 的曲线说:时限收益来自短前瞻、
# 精度代价却集中在 h≤4 ⇒ 两半可以分开要;代价是多一次 goal_err(B×K 点),只在门控口径下发生。
qa_full = fut[:, :, -1].reshape(B * K, 6)
e_full, _ = goal_err(kin, qa_full, T.repeat_interleave(K, 0), R.repeat_interleave(K, 0))
score = torch.where((e <= pre_near)[:, None], -e_full.view(B, K), score)
elif select in ('endpoint', 'adapt', 'ep_len', 'ep_waste'):
qa = fut[:, :, -1].reshape(B * K, 6)
e_end, _ = goal_err(kin, qa, T.repeat_interleave(K, 0), R.repeat_interleave(K, 0))
score = -e_end.view(B, K)
if select == 'ep_len' and len_w > 0: # 行程惩罚:每轴按 STEP 归一的累计路程。§9.2 要“行程≤规划器×1.10”,
ln = ((fut[:, :, 1:] - fut[:, :, :-1]).abs() / step).sum(-1).sum(-1) # 而现在 2.4 倍没人管
score = score - len_w * ln
if select == 'ep_waste' and len_w > 0: # 轮次 39 的分解证明行程超出主要是同一轴来回抖(换向步占 23.5%、
dv = fut[:, :, 1:] - fut[:, :, :-1] # 净位移只占总行程 44.5%),绕远只占一小部分 ⇒ 罚"白费的比例":
tot = dv.abs().sum(-2).sum(-1) # 同轴来回会在净位移里相互抵消,所以 waste = 1 − 净/总 ∈ [0,1]。
net = dv.sum(-2).abs().sum(-1) # dv 是 [B,K,H-1,6]:时间在第 -2 轴(写错成 -1 就变成"对轴求和",等于总行程)
frac = (1.0 - net / tot.clamp_min(1e-6)).clamp(0, 1)
score = score - len_w * frac * e.view(B, 1) # 罚度按"当前离目标多远"缩放:近端不会把进度项压死
if select == 'adapt' and last is not None:
n = min(fut.shape[2], last.shape[1] - (commit_n + 1))
w = 0.85 ** torch.arange(n, device=device, dtype=torch.float32)
d2 = (((fut[:, :, :n] - last[:, None, commit_n + 1:commit_n + 1 + n]) / step) ** 2).sum(-1)
sc = torch.where(last_ok[:, None], -(d2 * w).sum(-1), torch.zeros_like(d2[..., 0]))
score = torch.where(last_brake[:, None], sc, score)
elif cold or select == 'value': elif cold or select == 'value':
# 短前瞻:候选末态的价值 # 短前瞻:候选末态的价值
qa = fut[:, :, -1].reshape(B * K, 6); qb = fut[:, :, -2].reshape(B * K, 6) qa = fut[:, :, -1].reshape(B * K, 6); qb = fut[:, :, -2].reshape(B * K, 6)
@@ -216,37 +331,158 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
else: else:
# 2026-10-19 修错位:last[i] = 上一计划从 qe_old 走 i 步后的位置;提交 3 步后 qe_new = last[3], # 2026-10-19 修错位:last[i] = 上一计划从 qe_old 走 i 步后的位置;提交 3 步后 qe_new = last[3],
# 新候选 fut[0] 是 qe_new 再走 1 步 = 对应 last[4]。JS 部署(ik-policy.js)同一处同样修正。 # 新候选 fut[0] 是 qe_new 再走 1 步 = 对应 last[4]。JS 部署(ik-policy.js)同一处同样修正。
n = min(fut.shape[2], last.shape[1] - 4) n = min(fut.shape[2], last.shape[1] - (commit_n + 1))
w = 0.85 ** torch.arange(n, device=device, dtype=torch.float32) w = 0.85 ** torch.arange(n, device=device, dtype=torch.float32)
d2 = (((fut[:, :, :n] - last[:, None, 4:4 + n]) / step) ** 2).sum(-1) d2 = (((fut[:, :, :n] - last[:, None, commit_n + 1:commit_n + 1 + n]) / step) ** 2).sum(-1)
# 2026-10-19(审查 review_closedloop F5):上一次是刹停或 DLS 接管的行没有「已提交计划」, # 2026-10-19(审查 review_closedloop F5):上一次是刹停或 DLS 接管的行没有「已提交计划」,
# 与 JS(lastPlan = null → 一致性项缺席、各候选同分 → 取第 0 条)一致:同分,稳定排序取第 0 条 # 与 JS(lastPlan = null → 一致性项缺席、各候选同分 → 取第 0 条)一致:同分,稳定排序取第 0 条
score = torch.where(last_ok[:, None], -(d2 * w).sum(-1), torch.zeros_like(d2[..., 0])) score = torch.where(last_ok[:, None], -(d2 * w).sum(-1), torch.zeros_like(d2[..., 0]))
if select == 'mix': # 一致性 + 端点进度(w=sel_w/mm)
qa = fut[:, :, -1].reshape(B * K, 6)
e_end, _ = goal_err(kin, qa, T.repeat_interleave(K, 0), R.repeat_interleave(K, 0))
score = score - sel_w * e_end.view(B, K)
order = torch.sort(score, dim=-1, descending=True, stable=True).indices order = torch.sort(score, dim=-1, descending=True, stable=True).indices
pick = order[:, 0] pick = order[:, 0]
commit = inc[ar, pick, r:r + 3] if select == 'average': # 2026-10-20:候选平均(平滑误差)——所有候选置为 K 条动作的均值
inc = inc.mean(1, keepdim=True).expand_as(inc).contiguous()
K_eff = 1
else:
K_eff = K
commit = inc[ar, pick, r:r + commit_n]
if collect is not None: # 反馈蒸馏:收集与部署完全一致的 (特征, 复合动作=模型输出+目标反馈)
collect.append((feat.detach().float().cpu(), inc[ar, pick].detach().float().cpu()))
committed = torch.ones(B, dtype=torch.bool, device=device) committed = torch.ones(B, dtype=torch.bool, device=device)
if safety: braked = torch.zeros(B, dtype=torch.bool, device=device)
if return_traj:
cert_pts = torch.full((B, commit_n, 6), float('nan'), device=device)
cert_mids = cert_pts.clone()
cert_gaps = torch.full((B, 2 * commit_n), float('nan'), device=device)
certified = torch.zeros(B, commit_n, dtype=torch.bool, device=device)
if safety and safety_partial: # 2026-10-20:允许「部分安全前缀」——执行到第一个不安全步为止,而不是全拒刹停
maxlen = torch.zeros(B, dtype=torch.long, device=device)
chosen = torch.zeros(B, commit_n, 6, device=device); chosen_k = pick.clone()
ntry = min(K_eff, safety_try) if safety_try > 0 else K_eff
if cert_batch: # 一次 gaps 覆盖全部候选:典型路径略贵,但把「前面候选被拒→串行调用 K 次」的最坏情况封成 1 次
cks = inc[ar[:, None], order[:, :ntry], r:r + commit_n] # [B,ntry,cn,6]
if backoff: # 缩步档与正常候选并进同一次认证,不额外调用几何
sc = (0.5 ** torch.arange(1, backoff + 1, device=device, dtype=inc.dtype))[None, :, None, None]
cands = torch.cat([cks, inc[ar, order[:, 0], r:r + commit_n][:, None] * sc], 1)
else:
cands = cks
nc = cands.shape[1]
pts, mids = execution_points(kin, qe.repeat_interleave(nc, 0), cands.reshape(B * nc, commit_n, 6))
gaps6 = kin.gaps(torch.cat([pts, mids], 1).reshape(-1, 6), gcap)['gm'].min(-1).values.view(B, nc, 2 * commit_n)
stepok = (gaps6 > gap_margin)[:, :, :commit_n] & (gaps6 > gap_margin)[:, :, commit_n:]
pl_all = torch.cumprod(stepok.long(), -1).sum(-1) # [B,nc] 每条候选的安全前缀长度
plen = pl_all[:, :ntry]
maxlen = plen.max(-1).values
best = plen.argmax(-1) # 与串行同口径:严格更大者胜 ⇒ 首个最大值
if tie: # 等长前缀时不再只看选择器分数:取"沿路最小间隙更大"的那条(零额外几何调用,判据仍是 gap>0)
ci = torch.arange(2 * commit_n, device=device)
keep = (ci < maxlen[:, None]) | ((ci >= commit_n) & (ci < commit_n + maxlen[:, None])) # [B,2cn] 只看会被执行的那些点
clr = gaps6[:, :ntry].where(keep[:, None, :], torch.full((), float('inf'), device=device)).amin(-1)
cand = torch.where(plen == maxlen[:, None], clr, torch.full_like(clr, -float('inf'))).argmax(-1)
ntile = (plen == maxlen[:, None]).sum(-1) # 并列最长的候选条数(勿用 nmax:那是主循环的总步数)
to += (ntile > 1) & (maxlen > 0)
tx += (cand != best)
best = cand
if backoff: # 缩步候选只在全拒时顶上:不参与「前缀更长者优先」的比较,所以正常路径逐位不变
full0 = maxlen == 0
bb = pl_all[:, ntry:].argmax(-1) # 平手取缩得最少的(档 0 = 1/2)
mv = pl_all[ar, ntry + bb]
bo += (full0 & (mv > 0))
best = torch.where(full0, ntry + bb, best)
maxlen = torch.where(full0, mv, maxlen)
chosen_k = torch.where(full0, order[:, 0], order[ar, best.clamp(max=ntry - 1)])
else:
chosen_k = order[ar, best]
chosen = cands[ar, best]
if return_traj:
cert_pts = pts.view(B, nc, commit_n, 6)[ar, best]
cert_mids = mids.view(B, nc, commit_n, 6)[ar, best]
cert_gaps = gaps6[ar, best]
else:
for kk in range(ntry):
ck = inc[ar, order[:, kk], r:r + commit_n]
pts, mids = execution_points(kin, qe, ck)
allq = torch.cat([pts, mids], 1).reshape(-1, 6)
gaps6 = kin.gaps(allq, gcap)['gm'].min(-1).values.view(B, 2 * commit_n)
ok6 = gaps6 > gap_margin
okstep = ok6[:, :commit_n] & ok6[:, commit_n:]
plen = torch.cumprod(okstep.long(), 1).sum(1)
take = plen > maxlen
chosen = torch.where(take[:, None, None], ck, chosen); chosen_k = torch.where(take, order[:, kk], chosen_k)
if return_traj:
cert_pts = torch.where(take[:, None, None], pts, cert_pts)
cert_mids = torch.where(take[:, None, None], mids, cert_mids)
cert_gaps = torch.where(take[:, None], gaps6, cert_gaps)
maxlen = torch.maximum(maxlen, plen)
if B == 1 and int(maxlen[0]) >= commit_n: break # 实时单题:首个全安全候选即停(安全层 16 点→2-4 点)
msk = (torch.arange(commit_n, device=device)[None] < maxlen[:, None])
commit = torch.where(msk[..., None], chosen, torch.zeros_like(chosen))
if return_traj: certified = msk.clone()
brakes += (maxlen == 0).float(); braked = maxlen == 0
pick = chosen_k; committed = maxlen > 0
elif safety:
ok_any = torch.zeros(B, dtype=torch.bool, device=device) ok_any = torch.zeros(B, dtype=torch.bool, device=device)
chosen = torch.zeros(B, 3, 6, device=device); chosen_k = pick.clone() chosen = torch.zeros(B, commit_n, 6, device=device); chosen_k = pick.clone()
for kk in range(K): ntry = min(K_eff, safety_try) if safety_try > 0 else K_eff
ck = inc[ar, order[:, kk], r:r + 3] for kk in range(ntry):
pts = qe[:, None] + torch.cumsum(ck, 1) ck = inc[ar, order[:, kk], r:r + commit_n]
mids = torch.cat([qe[:, None], pts[:, :-1]], 1) + 0.5 * ck pts, mids = execution_points(kin, qe, ck)
allq = torch.cat([pts, mids], 1).reshape(-1, 6) 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) gaps6 = kin.gaps(allq, gcap)['gm'].min(-1).values.view(B, 2 * commit_n)
okk = (gaps6 > gap_margin).all(-1)
take = okk & ~ok_any take = okk & ~ok_any
chosen = torch.where(take[:, None, None], ck, chosen); chosen_k = torch.where(take, order[:, kk], chosen_k); ok_any |= okk chosen = torch.where(take[:, None, None], ck, chosen); chosen_k = torch.where(take, order[:, kk], chosen_k); ok_any |= okk
if return_traj:
cert_pts = torch.where(take[:, None, None], pts, cert_pts)
cert_mids = torch.where(take[:, None, None], mids, cert_mids)
cert_gaps = torch.where(take[:, None], gaps6, cert_gaps)
commit = torch.where(ok_any[:, None, None], chosen, torch.zeros_like(chosen)) commit = torch.where(ok_any[:, None, None], chosen, torch.zeros_like(chosen))
brakes += (~ok_any).float() if return_traj: certified = ok_any[:, None].expand(-1, commit_n).clone()
brakes += (~ok_any).float(); braked = ~ok_any
pick = chosen_k; committed = ok_any pick = chosen_k; committed = ok_any
if safety and fb_gain > 0 and fb_fallback > 0:
fbcom = torch.zeros(B, commit_n, 6, device=device)
fbcom[:, :1] = dls_steps(kin, qe, T, R, n=1) * fb_fallback
pts, mids = execution_points(kin, qe, fbcom)
allq = torch.cat([pts, mids], 1).reshape(-1, 6)
gaps6 = kin.gaps(allq, gcap)['gm'].min(-1).values.view(B, 2 * commit_n)
takef = braked & (gaps6 > gap_margin).all(-1)
commit = torch.where(takef[:, None, None], fbcom, commit)
if return_traj:
cert_pts = torch.where(takef[:, None, None], pts, cert_pts)
cert_mids = torch.where(takef[:, None, None], mids, cert_mids)
cert_gaps = torch.where(takef[:, None], gaps6, cert_gaps)
certified = certified | takef[:, None]
if near.any(): if near.any():
ref = dls_steps(kin, qe, T, R) ref = dls_steps(kin, qe, T, R, n=commit_n)
commit = torch.where(near[:, None, None], ref, commit) take = near
dls_it = torch.where(near & (dls_it < 0), torch.full_like(dls_it, it), dls_it) if dls_safety and safety: # 2026-10-20:近目标 DLS 接管也要过安全层(部署端 _certCommit 本来就会验;不过则退回候选计划)
committed = committed & ~near pts, mids = execution_points(kin, qe, ref)
allq = torch.cat([pts, mids], 1).reshape(-1, 6)
gaps6 = kin.gaps(allq, gcap)['gm'].min(-1).values.view(B, 2 * commit_n)
okd = (gaps6 > gap_margin).all(-1)
take = near & okd
if return_traj:
cert_pts = torch.where(take[:, None, None], pts, cert_pts)
cert_mids = torch.where(take[:, None, None], mids, cert_mids)
cert_gaps = torch.where(take[:, None], gaps6, cert_gaps)
if return_traj:
certified = torch.where(take[:, None], torch.full_like(certified, bool(dls_safety and safety)), certified)
commit = torch.where(take[:, None, None], ref, commit)
dls_it = torch.where(take & (dls_it < 0), torch.full_like(dls_it, it), dls_it)
committed = committed & ~take
# 2026-10-19(F5):last 记真正提交的那条候选(安全层换了候选时是换后的那条);刹停 / DLS 接管的行无效 # 2026-10-19(F5):last 记真正提交的那条候选(安全层换了候选时是换后的那条);刹停 / DLS 接管的行无效
last = torch.cat([qe[:, None], fut[ar, pick]], 1); last_ok = committed if fb_ki > 0: # 刹停/精修接管时清积分(防止原地累积到限幅后突然冲出去)
fb_i = torch.where(committed[:, None], fb_i, torch.zeros_like(fb_i))
last = torch.cat([qe[:, None], fut[ar, pick]], 1); last_ok = committed; last_brake = braked
if return_traj:
plans['it'].append(it + r)
plans['r'].append(r)
for key, value in (('qe', qe), ('commit', commit), ('points', cert_pts), ('midpoints', cert_mids), ('gaps', cert_gaps), ('certified', certified)):
plans[key].append(value)
queue = torch.cat([queue, commit], 1) queue = torch.cat([queue, commit], 1)
cold = False cold = False
d = queue[:, 0]; queue = queue[:, 1:] d = queue[:, 0]; queue = queue[:, 1:]
@@ -264,10 +500,22 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
hit = ((gm[:B] <= 0) | (gm[B:] <= 0)) & ~done & (tn <= limit + 1e-6) hit = ((gm[:B] <= 0) | (gm[B:] <= 0)) & ~done & (tn <= limit + 1e-6)
col += hit.float() col += hit.float()
first_hit = torch.where(hit & torch.isnan(first_hit), torch.full_like(first_hit, tn), first_hit) first_hit = torch.where(hit & torch.isnan(first_hit), torch.full_like(first_hit, tn), first_hit)
act_ = ((~done) & (tn <= limit + 1e-6)).float() # 只计自己时限内的移动(与 col 同口径)
exec_d = (q - qp).abs()
vratio = torch.maximum(vratio, (exec_d / step).max(-1).values * act_) # 实际速度 / VMAX
aratio = torch.maximum(aratio, ((exec_d - prev_exec) / step).max(-1).values * act_) # 每控制步的速度变化 / VMAX
prev_exec = exec_d
sgn = torch.sign(q - qp) # 换向率:轮次 39 的分解证明"行程超出 2.4 倍"里同轴来回占大头
rev += ((sgn != 0) & (prev_sgn != 0) & (sgn == -prev_sgn)).float().sum(-1) * act_
prev_sgn = torch.where(sgn != 0, sgn, prev_sgn) # 零步不重置方向(站住再走同向不算换向)
nact += act_
nmov += act_ * (exec_d.sum(-1) > 1e-6).float() # 只在"动了"的步上算换向:站住会稀释分母(刹停越多的臂会显得越不抖)
e, oe = goal_err(kin, q, T, R) e, oe = goal_err(kin, q, T, R)
if it + 1 == k2s: e2 = e.clone() if it + 1 == k2s: e2 = e.clone()
newly = (~done) & (e < 1) & (oe < 0.5) newly = (~done) & (e < 1) & (oe < 0.5)
t_done = torch.where(newly, torch.full_like(t_done, tn), t_done); done |= newly t_done = torch.where(newly, torch.full_like(t_done, tn), t_done); done |= newly
if progress is not None and (it == 0 or (it + 1) % 50 == 0 or it + 1 == nmax):
progress(it + 1, nmax)
if done.all(): break if done.all(): break
ok = done & (t_done <= limit + 1e-6) ok = done & (t_done <= limit + 1e-6)
if moved_start is None: moved_start = travel.clone() if moved_start is None: moved_start = travel.clone()
@@ -281,15 +529,27 @@ 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(), '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, '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(), 'time_mean_s': t_done[ok].mean().item() if ok.any() else None, 'brakes_mean': brakes.mean().item(),
'backoff_mean': bo.mean().item(),
'start_fail': start_fail.float().mean().item(), 'goal_ratio_2s': ratio2.median().item(), 'start_fail': start_fail.float().mean().item(), 'goal_ratio_2s': ratio2.median().item(),
'speed_ratio_mean': vratio.mean().item(), 'over_vmax_rate': (vratio > 1.001).float().mean().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')} '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 左右比例门禁 # 绕行侧:J1 累计位移的正向/负向极值哪个更大(+1 / −1),供 R7 左右比例门禁
# 首次方向;全程没偏离到 FIRST_DEG 的(基本不绕 J1)退回净方向 # 首次方向;全程没偏离到 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))) 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(), 'ok': ok.cpu(), 't_done': t_done.cpu(), 'limit': limit.cpu(), 'col': col.cpu(), 'travel': travel.cpu(), 'err': e_end.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(), 'side': side.cpu(), 'start_fail': start_fail.cpu(), 'brakes': brakes.cpu(), 'backoff': bo.cpu(), 'first_hit': first_hit.cpu(), 'dls_it': dls_it.cpu(),
'goal_ratio_2s': ratio2.cpu()} 'n_plans': nplan.cpu(), 'brake_rate': (brakes / nplan.clamp_min(1.0)).cpu(),
if return_traj: per['traj'] = torch.stack(traj, 1).cpu() 'tie_opp': to.cpu(), 'tie_changed': tx.cpu(), # tie=1 才有意义:并列次数/改选次数(每题)
'tie_opp_rate': (to / nplan.clamp_min(1.0)).cpu(), # 分母与 brake_rate 同口径 = 规划次数
'tie_changed_rate': (tx / nplan.clamp_min(1.0)).cpu(),
'goal_ratio_2s': ratio2.cpu(), 'speed_ratio': vratio.cpu(), 'accel_ratio': aratio.cpu(),
# 口径与离线分解一致:换向的 (步,轴) 对数 / 活动的 (步,轴) 对数 ∈ [0,1](除以 6 个轴)
'reverse_rate': (rev / (6.0 * nact.clamp_min(1.0))).cpu(),
'reverse_rate_moving': (rev / (6.0 * nmov.clamp_min(1.0))).cpu(),
'moving_share': (nmov / nact.clamp_min(1.0)).cpu()}
if return_traj:
per['traj'] = torch.stack(traj, 1).cpu()
per['plans'] = {k: torch.tensor(v) if k in ('it', 'r') else torch.stack(v, 1).cpu() for k, v in plans.items()}
return res, per return res, per
+4 -2
View File
@@ -73,6 +73,7 @@ def main():
ap.add_argument('--config', default='ml/configs/base.json'); ap.add_argument('--steps', type=int, default=None) 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('--resume', default=None); ap.add_argument('--no-eval', action='store_true')
ap.add_argument('--init', default=None, help='只载入权重(优先 EMA)、优化器与步数从 0 开始(DAgger 微调用)') ap.add_argument('--init', default=None, help='只载入权重(优先 EMA)、优化器与步数从 0 开始(DAgger 微调用)')
ap.add_argument('--freeze-enc', action='store_true', help='冻结编码器(enc + enc_norm),只微调解码器/头')
ap.add_argument('--lr', type=float, default=None); ap.add_argument('--warmup', type=int, default=None) 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('--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) ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu'); ap.add_argument('--seed', type=int, default=0)
@@ -106,7 +107,7 @@ def main():
print(f'train samples {data.n}, val tasks {len(val_tasks)}, act_scale {act_scale}, data_ver {data.data_ver}, device {dev}', flush=True) 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 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) 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']) opt = torch.optim.AdamW([p_ for p_ in model.parameters() if p_.requires_grad], lr=tc['lr'], betas=tuple(tc['betas']), weight_decay=tc['wd'])
step0, best, bad_evals = 0, -1.0, 0 step0, best, bad_evals = 0, -1.0, 0
def check_scale(ck, src): def check_scale(ck, src):
s0 = float(ck.get('act_scale', 1.0)) s0 = float(ck.get('act_scale', 1.0))
@@ -160,7 +161,8 @@ def main():
l_mf, xh = wta_loss(model, mem, Y); mf_raw = l_mf.detach(); xh = xh.float() l_mf, xh = wta_loss(model, mem, Y); mf_raw = l_mf.detach(); xh = xh.float()
else: else:
p_neq = tc['p_neq'] if step >= warm else 0.0 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)) 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),
target=tc.get('mf_target', 'mf'), lam=tc.get('mf_lam', 0.5))
sel = ((aux['r'] == aux['t']) & (aux['t'] <= tc.get('fk_tmax', 0.3))).nonzero(as_tuple=True)[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] tt = aux['t'][sel][:, None, None]
xh = aux['z'][sel] - tt * aux['u'][sel] # 配对去噪估计(fp32) xh = aux['z'][sel] - tt * aux['u'][sel] # 配对去噪估计(fp32)

Some files were not shown because too many files have changed in this diff Show More