exp: 轮次29——全拒后减半反馈到达55.1%，补齐无碰撞指标与首撞回放
512题无碰撞到达54.7%、碰撞1.8%；9次首撞均在J5限位且双精度复现。保留小样本消融，撤回未经实际调度验证的50Hz达标结论，附六项回归测试及完整配置结果。
This commit is contained in:
@@ -25,9 +25,58 @@ def pair_names():
|
||||
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()),
|
||||
}
|
||||
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
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument('--ckpt', required=True)
|
||||
ap.add_argument('--ckpt')
|
||||
ap.add_argument('--trace')
|
||||
ap.add_argument('--samples', default='ml/data/samples')
|
||||
ap.add_argument('--split', default='val')
|
||||
ap.add_argument('--n', type=int, default=512)
|
||||
@@ -38,6 +87,11 @@ def main():
|
||||
ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu')
|
||||
ap.add_argument('--out', default=None)
|
||||
a = ap.parse_args()
|
||||
if a.trace:
|
||||
replay_first_hits(a.trace, a.out)
|
||||
return
|
||||
if not a.ckpt:
|
||||
ap.error('--ckpt or --trace is required')
|
||||
|
||||
ck = torch.load(a.ckpt, map_location=a.device)
|
||||
model = build(ck['cfg']).to(a.device)
|
||||
|
||||
+77
-25
@@ -1,32 +1,57 @@
|
||||
"""小规模闭环评估（部署口径）：
|
||||
python -m ml.eval.eval_cl --n 256 --commit 3 --fb 1.8 --partial [--ki 0.1 --select consist]
|
||||
输出：到达 / 碰撞 / ratio2s / 刹停 / 精修接管 / 墙钟。直接调 rollout，参数与部署一致。"""
|
||||
import argparse, functools, json, time
|
||||
"""小规模同步闭环评估；仿真墙钟不等于控制延迟。"""
|
||||
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
|
||||
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):
|
||||
agg, per = {}, []
|
||||
per = []
|
||||
for i in range(0, len(tasks), bs):
|
||||
r, p = rollout(model, kin, tasks[i:i + bs], device, **kw)
|
||||
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])))
|
||||
n = sum(w for _, _, w in per)
|
||||
for r, _, w in per:
|
||||
for k, v in r.items():
|
||||
if k in ('n', 'time_budget') or v is None: continue
|
||||
agg[k] = agg.get(k, 0.0) + v * w
|
||||
out = {k: v / n for k, v in agg.items()}; out['n'] = n
|
||||
out['goal_ratio_2s'] = torch.cat([p['goal_ratio_2s'] for _, p, _ in per]).median().item()
|
||||
out['err_fail_med'] = torch.cat([p['err'] for _, p, _ in per])[~torch.cat([p['ok'] for _, p, _ in per])].median().item()
|
||||
out['dls_share'] = torch.cat([p['dls_it'] for _, p, _ in per]).ge(0).float().mean().item()
|
||||
out['time_budget'] = per[0][0]['time_budget']
|
||||
return out
|
||||
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 != 'traj'}
|
||||
_, _, _, 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'),
|
||||
}
|
||||
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():
|
||||
@@ -48,6 +73,14 @@ def main():
|
||||
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=关')
|
||||
@@ -57,6 +90,7 @@ def main():
|
||||
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)
|
||||
@@ -65,17 +99,35 @@ def main():
|
||||
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 = run(model, kin, tasks, a.device, K=a.K, safety=bool(a.safety), seed=a.seed, max_sec=a.max_sec,
|
||||
r, pers = run(model, kin, tasks, a.device, K=a.K, safety=bool(a.safety), seed=a.seed, max_sec=a.max_sec,
|
||||
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)
|
||||
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,
|
||||
return_traj=bool(a.trace))
|
||||
wall = time.perf_counter() - t0
|
||||
print('ckpt=%s n=%d K=%d commit=%d fb=%.2f ki=%.2f select=%s replan=%s safety=%d' %
|
||||
(a.ckpt, r['n'], a.K, a.commit, a.fb, a.ki, a.select, a.replan, a.safety))
|
||||
print('success %.3f time_ok_1p3 %.3f coll %.3f ratio2s %.3f brakes %.1f dls_share %.3f err_fail %.2f wall %.1fs (%.0f ms/题)'
|
||||
% (r['success'], r['time_ok_1p3'] or 0, r['collision_rate'], r['goal_ratio_2s'], r['brakes_mean'],
|
||||
r['dls_share'], r['err_fail_med'], wall, wall / max(1, len(tasks)) * 1000))
|
||||
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']
|
||||
flat = {k: torch.cat([p[k] for _, p, _ in pers]).tolist() for k in keys}
|
||||
for i, t in enumerate(tasks):
|
||||
rows.append({**t, 'i': i, **{k: flat[k][i] for k in keys}})
|
||||
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__':
|
||||
|
||||
Reference in New Issue
Block a user