| |
| """Judge plots 1 (trajectory+chunk) and 4 (latency waterfall). |
| |
| Plot 1 needs offline SmolVLA chunks. Run once with --infer inside docker:: |
| |
| docker exec rm65_dev2 bash -lc 'cd /home/sdznkj/zkx_ws/sendlerobot && \\ |
| HF_HUB_OFFLINE=1 PYTHONPATH=. python3 scripts/eval_judge_plots.py --infer' |
| |
| After that, host python can redraw:: |
| |
| python3 scripts/eval_judge_plots.py |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| OUT = ROOT / "outputs/diag/judge_plots" |
| EP = ROOT / "datasets/dagger_rm65_20260923_175937/episode_000000" |
| CHUNK_CACHE = OUT / "offline_chunks.npz" |
| SUMMARY = ROOT / "logs/astra_stack_20260923_142308_opengrip/summary.json" |
| CKPT = ROOT / "astra_smolvla" |
| |
| INFER_FRAMES = [0, 50, 74, 125, 175, 225, 275, 325, 375, 425] |
| MAX_STEP_DEG = 0.4 |
| JOINT_NAMES = ["关节1", "关节2", "关节3", "关节4", "关节5", "关节6", "夹爪"] |
|
|
|
|
| def _setup_cn_mpl(): |
| import matplotlib |
|
|
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| from matplotlib import font_manager |
|
|
| cjk = Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc") |
| if cjk.is_file(): |
| font_manager.fontManager.addfont(str(cjk)) |
| cjk_name = font_manager.FontProperties(fname=str(cjk)).get_name() |
| else: |
| cjk_name = "Noto Sans CJK JP" |
| plt.rcParams["font.family"] = "sans-serif" |
| plt.rcParams["font.sans-serif"] = [cjk_name, "Noto Sans CJK JP", "DejaVu Sans"] |
| plt.rcParams["axes.unicode_minus"] = False |
| plt.rcParams.update( |
| { |
| "figure.facecolor": "#111111", |
| "axes.facecolor": "#161616", |
| "axes.edgecolor": "#555555", |
| "text.color": "#EEEEEE", |
| "xtick.color": "#BBBBBB", |
| "ytick.color": "#BBBBBB", |
| "axes.labelcolor": "#DDDDDD", |
| "axes.titlecolor": "#F0F0F0", |
| "legend.facecolor": "#1C1C1C", |
| "legend.edgecolor": "#444444", |
| "grid.color": "#2A2A2A", |
| "savefig.facecolor": "#111111", |
| "savefig.dpi": 180, |
| } |
| ) |
| return plt |
|
|
|
|
| def infer_chunks(frames: list[int]) -> Path: |
| sys.path.insert(0, str(ROOT)) |
| sys.path.insert(0, str(ROOT / "scripts")) |
| import torch |
|
|
| from smolvla_diag_visualize import ( |
| force_offline, |
| load_episode_frame, |
| load_rgb_tensor, |
| load_stats, |
| sanitize_ckpt_config, |
| ) |
| from lerobot.common.policies.smolvla.modeling_smolvla import SmolVLAPolicy |
| from lerobot.configs.policies import PreTrainedConfig |
|
|
| force_offline() |
| sanitize_ckpt_config(CKPT) |
| config = PreTrainedConfig.from_pretrained(str(CKPT)) |
| stats = load_stats(CKPT, config) |
| policy = SmolVLAPolicy.from_pretrained(str(CKPT), config=config, dataset_stats=stats) |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| policy.to(device) |
| policy.eval() |
| if hasattr(policy.model, "vlm_with_expert"): |
| policy.model.vlm_with_expert._attn_capture = None |
|
|
| img_keys = [k for k in policy.config.image_features if "empty" not in k] |
| state_dim = int(policy.config.robot_state_feature.shape[0]) |
| meta = json.loads((EP / "meta.json").read_text()) |
| task = meta.get("task") or "Stack three cylinder blocks. Grasp the left cylinder." |
|
|
| starts = [] |
| chunks = [] |
| with torch.no_grad(): |
| for fi, frame in enumerate(frames): |
| info = load_episode_frame(EP, frame) |
| state_np = np.asarray(info["state"], dtype=np.float32) |
| if state_np.shape[0] < state_dim: |
| state_np = np.pad(state_np, (0, state_dim - state_np.shape[0])) |
| state_np = state_np[:state_dim] |
| batch = { |
| "task": task, |
| "observation.state": torch.from_numpy(state_np).unsqueeze(0).to(device), |
| } |
| for key, path in zip(img_keys[:2], [info["cam1"], info["cam2"]], strict=False): |
| batch[key] = load_rgb_tensor(path).to(device) |
| act = policy.predict_action_chunk(batch)[0].detach().float().cpu().numpy() |
| starts.append(int(frame)) |
| chunks.append(act.astype(np.float32)) |
| print(f"infer {fi + 1}/{len(frames)} frame={frame} chunk={act.shape}", flush=True) |
| del batch, act |
| if device.type == "cuda": |
| torch.cuda.empty_cache() |
|
|
| OUT.mkdir(parents=True, exist_ok=True) |
| np.savez_compressed( |
| CHUNK_CACHE, |
| starts=np.asarray(starts, dtype=np.int32), |
| chunks=np.stack(chunks, axis=0), |
| frames=np.asarray(frames, dtype=np.int32), |
| ) |
| print("wrote", CHUNK_CACHE) |
| return CHUNK_CACHE |
|
|
|
|
| def plot_trajectory_chunk() -> Path: |
| plt = _setup_cn_mpl() |
| z = np.load(EP / "trajectory.npz") |
| st = z["states"].astype(np.float32) |
| ac = z["actions"].astype(np.float32) |
| t, d = st.shape |
| d = min(d, 7) |
| x = np.arange(t) |
|
|
| cache = np.load(CHUNK_CACHE) |
| starts = cache["starts"].astype(int) |
| chunks = cache["chunks"].astype(np.float32) |
| highlight = 74 |
| hex_colors = ["#50B4FF", "#50FFA0", "#FFC850", "#FF648C", "#B48CFF", "#78DCDC", "#F0F0F0"] |
|
|
| human_dq = float(np.abs(np.diff(ac[:, :6], axis=0)).mean()) if t > 1 else 0.0 |
| chunk_dq, over = [], [] |
| for ch in chunks: |
| dq = np.abs(np.diff(ch[:, :6], axis=0)) |
| chunk_dq.append(float(dq.mean())) |
| over.append(float((dq > MAX_STEP_DEG).mean())) |
|
|
| fig, axes = plt.subplots(d, 1, figsize=(16.5, 12.2), sharex=True, gridspec_kw={"hspace": 0.08}) |
| fig.subplots_adjust(top=0.88, bottom=0.07, left=0.08, right=0.98) |
| fig.suptitle("离线开环：动作轨迹跟踪与 Chunk 叠加", fontsize=18, fontweight="bold", y=0.995) |
| fig.text( |
| 0.01, |
| 0.965, |
| "连续实线 = 编码器实际关节角（整段都发生过） 虚线 = 人手示教动作（本段 100% 人工，几乎贴着实线）\n" |
| "橙色短峰线 = 模型在该时刻开环预测的未来 50 步，不是真机走过的路；亮橙 = 第 74 帧那一截", |
| fontsize=11, |
| color="#C8C8C8", |
| va="top", |
| ) |
|
|
| legend_done = False |
| for j, ax in enumerate(axes): |
| c = hex_colors[j] |
| for start, ch in zip(starts, chunks): |
| x0, x1 = int(start), int(start) + ch.shape[0] |
| ax.axvspan(x0, x1, color="#2A3348" if int(start) == highlight else "#1E1E22", alpha=0.85, lw=0) |
| (h_line,) = ax.plot(x, ac[:, j], ls="--", lw=1.2, color=c, alpha=0.55, zorder=2) |
| (s_line,) = ax.plot(x, st[:, j], ls="-", lw=2.2, color=c, zorder=3) |
| vla_lines = [] |
| for start, ch in zip(starts, chunks): |
| if j >= ch.shape[1]: |
| continue |
| xs = np.arange(int(start), int(start) + ch.shape[0]) |
| is_hl = int(start) == highlight |
| (ln,) = ax.plot( |
| xs, |
| ch[:, j], |
| color="#FF9F1C" if is_hl else "#E0A14A", |
| lw=2.6 if is_hl else 1.7, |
| alpha=0.95 if is_hl else 0.78, |
| zorder=4, |
| solid_capstyle="round", |
| ) |
| ax.plot(xs[0], ch[0, j], "o", color="#FF9F1C", ms=4.5 if is_hl else 3.2, zorder=5) |
| vla_lines.append(ln) |
| ax.set_ylabel(JOINT_NAMES[j], fontsize=12, color=c, rotation=0, ha="right", va="center", labelpad=14) |
| ax.grid(True, axis="x", alpha=0.25) |
| ax.tick_params(labelsize=10) |
| if not legend_done: |
| ax.legend( |
| [s_line, h_line, vla_lines[0]], |
| ["编码器实际关节（连续实线）", "人手示教（虚线）", "VLA 预测 chunk（橙色峰线）"], |
| loc="upper right", |
| fontsize=10, |
| framealpha=0.92, |
| ) |
| legend_done = True |
|
|
| axes[-1].set_xlabel("帧（约 20 Hz 采样）", fontsize=12) |
| axes[-1].set_xlim(0, t - 1) |
| fig.text( |
| 0.01, |
| 0.008, |
| f"人手平均每步 {human_dq:.3f} 度 VLA chunk 平均每步 {float(np.mean(chunk_dq)):.3f} 度 " |
| f"超过 {MAX_STEP_DEG:g} 度限幅的步占比 {float(np.mean(over)):.0%} " |
| f"离线推理帧 {list(map(int, starts))}", |
| fontsize=10.5, |
| color="#D2C878", |
| ) |
| path = OUT / "01_offline_trajectory_chunk.png" |
| OUT.mkdir(parents=True, exist_ok=True) |
| fig.savefig(path, dpi=180, bbox_inches="tight", pad_inches=0.22) |
| plt.close(fig) |
| return path |
|
|
|
|
| def plot_latency_waterfall() -> Path: |
| plt = _setup_cn_mpl() |
| from matplotlib.patches import Patch |
|
|
| summary = json.loads(SUMMARY.read_text()) |
| lat = summary["latency_ms"] |
| infer = lat["inference"] |
| chunk = lat["chunk_total"] |
| post = max(0.0, float(chunk["mean"]) - float(infer["mean"])) |
| rows = [ |
| ("1 相机缓存 / USB缓冲", 80.0, False), |
| ("2 gRPC观测单向传输", float(lat["one_way"]["mean"]), True), |
| ("3 VLA推理（一个chunk）", float(infer["mean"]), True), |
| ("4 chunk前后处理", post, True), |
| ("5 首个控制周期", 50.0, False), |
| ("6 指令后伺服跟踪", 20.0, False), |
| ] |
| total = sum(r[1] for r in rows) |
| p50, p95, mx = float(infer["p50"]), float(infer["p95"]), float(infer["max"]) |
|
|
| fig = plt.figure(figsize=(15.2, 9.2)) |
| gs = fig.add_gridspec(2, 1, height_ratios=[3.4, 1.0], hspace=0.28) |
| ax = fig.add_subplot(gs[0]) |
| ax2 = fig.add_subplot(gs[1]) |
| fig.suptitle("端到端延迟瀑布图", fontsize=20, fontweight="bold", y=0.98) |
| fig.text( |
| 0.5, |
| 0.935, |
| "从快门到第一次运动 | astra_stack_20260923_142308_opengrip | 实心=本轮实测，斜纹=经验估计（未打时间戳）", |
| ha="center", |
| fontsize=12, |
| color="#C0C0C0", |
| ) |
|
|
| t0 = 0.0 |
| y_pos = list(range(len(rows) - 1, -1, -1)) |
| for i, ((name, ms, measured), y) in enumerate(zip(rows, y_pos)): |
| color = "#47A8FF" if measured else "#7A7A7A" |
| bar = ax.barh( |
| y, |
| ms, |
| left=t0, |
| height=0.62, |
| color=color, |
| edgecolor="#111111", |
| linewidth=0.4, |
| hatch="///" if not measured else None, |
| zorder=3, |
| ) |
| ax.text( |
| total * 1.01, |
| y, |
| f"{ms:.1f} ms {'实测' if measured else '估计'}", |
| va="center", |
| ha="left", |
| fontsize=12, |
| color="#F0E080" if measured else "#B0B0B0", |
| ) |
| t0 += ms |
|
|
| ax.set_yticks(y_pos) |
| ax.set_yticklabels([r[0] for r in rows], fontsize=12) |
| ax.set_xlim(0, total * 1.28) |
| ax.set_xlabel("累计时间（毫秒）", fontsize=13) |
| ax.tick_params(labelsize=11) |
| ax.axvline(total, color="#666666", ls=":", lw=1) |
| ax.text(total, len(rows) - 0.15, f"合计约 {total:.0f} ms", color="#AAAAAA", fontsize=11, ha="right") |
| ax.legend( |
| handles=[ |
| Patch(facecolor="#47A8FF", label="本轮实测"), |
| Patch(facecolor="#7A7A7A", hatch="///", label="经验估计"), |
| ], |
| loc="lower right", |
| fontsize=11, |
| ) |
| ax.grid(True, axis="x", alpha=0.3) |
|
|
| |
| ax2.barh(0, mx, height=0.45, color="#2A3C50", label="最大") |
| ax2.barh(0, p95, height=0.45, color="#3C78B4", label="P95") |
| ax2.barh(0, p50, height=0.45, color="#47A8FF", label="P50") |
| ax2.set_yticks([0]) |
| ax2.set_yticklabels(["VLA 推理分布"]) |
| ax2.set_xlabel("毫秒", fontsize=13) |
| ax2.set_xlim(0, mx * 1.12) |
| ax2.tick_params(labelsize=11) |
| ax2.legend(loc="upper right", ncol=3, fontsize=11) |
| ax2.text( |
| p50, |
| -0.42, |
| f"P50 = {p50:.0f} ms P95 = {p95:.0f} ms 最大 = {mx:.0f} ms", |
| ha="left", |
| fontsize=12, |
| color="#D0D8E8", |
| ) |
| ax2.set_ylim(-0.85, 0.7) |
| ax2.grid(True, axis="x", alpha=0.3) |
|
|
| fig.text( |
| 0.01, |
| 0.015, |
| f"合计约 {total:.0f} ms chunk 数 {infer['n']} 观测约 {summary['obs']['fps_mean']} FPS（目标 20） " |
| f"真机执行每步平均 {summary['arm']['step']['mean']} 度", |
| fontsize=11.5, |
| color="#D0D0D0", |
| ) |
| path = OUT / "04_latency_waterfall.png" |
| fig.savefig(path, dpi=200, bbox_inches="tight", pad_inches=0.25) |
| plt.close(fig) |
| return path |
|
|
|
|
| def write_index(p1: Path, p4: Path) -> Path: |
| idx = OUT / "index.html" |
| idx.write_text( |
| "<html><body style='background:#111;color:#eee;font-family:sans-serif'>" |
| "<h3>Judge plots v1 (1 and 4)</h3><ul>" |
| f"<li><a href='{p1.name}'>01 trajectory & chunk</a></li>" |
| f"<li><a href='{p4.name}'>04 latency waterfall</a></li>" |
| "</ul></body></html>\n", |
| encoding="utf-8", |
| ) |
| return idx |
|
|
|
|
| def parse_args(): |
| p = argparse.ArgumentParser() |
| p.add_argument("--infer", action="store_true", help="re-run offline VLA chunks (needs GPU/torch)") |
| return p.parse_args() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| OUT.mkdir(parents=True, exist_ok=True) |
| if args.infer or not CHUNK_CACHE.is_file(): |
| if not args.infer: |
| raise SystemExit( |
| f"missing {CHUNK_CACHE}; run with --infer inside docker rm65_dev2" |
| ) |
| infer_chunks(INFER_FRAMES) |
| p1 = plot_trajectory_chunk() |
| p4 = plot_latency_waterfall() |
| idx = write_index(p1, p4) |
| print("wrote", p1) |
| print("wrote", p4) |
| print("index", idx) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
