| |
| """Unified offline open-loop eval for RM65 SmolVLA task checkpoints. |
| |
| Covers stack / usb / cleanup / place. Writes per-task trajectory plots, |
| metrics.json, MAE bar chart, and a cross-task dashboard. |
| |
| docker exec rm65_dev2 bash -lc 'cd /home/sdznkj/zkx_ws/sendlerobot && \\ |
| HF_HUB_OFFLINE=1 PYTHONPATH=. python3 scripts/eval_task_ckpts_offline.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] |
| LOCAL_VLM = ROOT / "base_models/SmolVLM2-500M-Video-Instruct" |
| OUT_ROOT = ROOT / "outputs/diag/task_offline" |
| JOINT_NAMES = ["j1", "j2", "j3", "j4", "j5", "j6", "gripper"] |
| HEX = ["#50B4FF", "#50FFA0", "#FFC850", "#FF648C", "#B48CFF", "#78DCDC", "#F0F0F0"] |
|
|
| TASKS = { |
| "stack": { |
| "ckpt": ROOT / "smolvla_rm65_stack_30ep_s1000", |
| "dataset": ROOT / "datasets/cleaned/rm65_stacking_blocks", |
| "cam2_key": "observation.images.astra", |
| "title": "叠块 stack 30ep/s1000", |
| "legacy_out": ROOT / "outputs/diag/stack_30ep_offline", |
| }, |
| "usb": { |
| "ckpt": ROOT / "smolvla_rm65_usb_100ep_s40000", |
| "dataset": ROOT / "datasets/cleaned/rm65_usb_insert", |
| "cam2_key": "observation.images.mono", |
| "title": "USB 插入 usb 100ep/s40000", |
| "legacy_out": None, |
| }, |
| "cleanup": { |
| "ckpt": ROOT / "smolvla_rm65_cleanup_47ep_s40000", |
| "dataset": ROOT / "datasets/cleaned/rm65_cleanup_the_desk", |
| "cam2_key": "observation.images.astra", |
| "title": "桌面清理 cleanup 47ep/s40000", |
| "legacy_out": None, |
| }, |
| "place": { |
| "ckpt": ROOT / "smolvla_rm65_place_47ep_s40000", |
| "dataset": ROOT / "datasets/cleaned/rm65_place_to_slot", |
| "cam2_key": "observation.images.astra", |
| "title": "槽位放置 place 47ep/s40000", |
| "legacy_out": None, |
| }, |
| } |
|
|
|
|
| def _setup_cn_mpl(): |
| import matplotlib |
|
|
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| from matplotlib import font_manager |
|
|
| |
| cjk_candidates = [ |
| Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"), |
| Path("/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc"), |
| ] |
| for cjk in cjk_candidates: |
| if not cjk.is_file(): |
| continue |
| try: |
| font_manager.fontManager.addfont(str(cjk)) |
| except Exception: |
| pass |
| |
| for idx in (3, 0, 1, 2, 4): |
| try: |
| prop = font_manager.FontProperties(fname=str(cjk), index=idx) |
| name = prop.get_name() |
| if name: |
| plt.rcParams["font.sans-serif"] = [name, "Noto Sans CJK SC", "DejaVu Sans"] |
| break |
| except Exception: |
| continue |
| break |
| plt.rcParams["font.family"] = "sans-serif" |
| 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", |
| "legend.facecolor": "#1C1C1C", |
| "legend.edgecolor": "#444444", |
| "grid.color": "#2A2A2A", |
| "savefig.facecolor": "#111111", |
| } |
| ) |
| return plt |
|
|
|
|
| def sanitize_config(ckpt: Path) -> None: |
| sys.path.insert(0, str(ROOT)) |
| import dataclasses |
|
|
| from lerobot.common.policies.smolvla.configuration_smolvla import SmolVLAConfig |
| from lerobot.configs.policies import PreTrainedConfig |
|
|
| allowed = {f.name for f in dataclasses.fields(SmolVLAConfig)} |
| allowed |= {f.name for f in dataclasses.fields(PreTrainedConfig)} |
| allowed.add("type") |
| cfg_path = ckpt / "config.json" |
| cfg = json.loads(cfg_path.read_text()) |
| dropped = sorted(k for k in cfg if k not in allowed) |
| for k in dropped: |
| cfg.pop(k, None) |
| if LOCAL_VLM.is_dir(): |
| cfg["vlm_model_name"] = str(LOCAL_VLM) |
| cfg_path.write_text(json.dumps(cfg, indent=4) + "\n") |
| if dropped: |
| print("dropped config keys:", dropped) |
|
|
|
|
| def load_episode(ds: Path, ep: int) -> dict: |
| import pandas as pd |
|
|
| info = json.loads((ds / "meta/info.json").read_text()) |
| tasks = {} |
| for line in (ds / "meta/tasks.jsonl").read_text().splitlines(): |
| if line.strip(): |
| row = json.loads(line) |
| tasks[int(row["task_index"])] = row["task"] |
| chunk = ep // int(info.get("chunks_size", 1000)) |
| pq = ds / info["data_path"].format(episode_chunk=chunk, episode_index=ep) |
| df = pd.read_parquet(pq) |
| state = np.stack(df["observation.state"].to_numpy()).astype(np.float32) |
| action = np.stack(df["action"].to_numpy()).astype(np.float32) |
| task_index = df["task_index"].to_numpy().astype(np.int64) |
| return { |
| "state": state, |
| "action": action, |
| "task_index": task_index, |
| "tasks": tasks, |
| "info": info, |
| "n": len(df), |
| "chunk": chunk, |
| } |
|
|
|
|
| def read_video_frames(path: Path, indices: list[int]) -> dict[int, np.ndarray]: |
| import av |
|
|
| want = set(int(i) for i in indices) |
| out: dict[int, np.ndarray] = {} |
| container = av.open(str(path)) |
| for i, frame in enumerate(container.decode(video=0)): |
| if i in want: |
| out[i] = frame.to_ndarray(format="rgb24") |
| if len(out) == len(want): |
| break |
| container.close() |
| missing = want - set(out) |
| if missing: |
| raise FileNotFoundError(f"{path} missing frames {sorted(missing)[:8]}") |
| return out |
|
|
|
|
| def rgb_tensor(img: np.ndarray, torch): |
| t = torch.from_numpy(img).permute(2, 0, 1).float() / 255.0 |
| return t.unsqueeze(0) |
|
|
|
|
| def infer_episode(policy, ds: Path, cam2_key: str, ep: int, device) -> dict: |
| import torch |
|
|
| data = load_episode(ds, ep) |
| info = data["info"] |
| n = data["n"] |
| chunk_id = data["chunk"] |
| step = int(policy.config.n_action_steps) |
| starts = list(range(0, n, step)) |
| relative = bool(getattr(policy.config, "use_relative_actions", False)) |
| front = read_video_frames( |
| ds |
| / info["video_path"].format( |
| episode_chunk=chunk_id, episode_index=ep, video_key="observation.images.front" |
| ), |
| starts, |
| ) |
| cam2 = read_video_frames( |
| ds |
| / info["video_path"].format(episode_chunk=chunk_id, episode_index=ep, video_key=cam2_key), |
| starts, |
| ) |
| policy.reset() |
| pred_abs = np.full((n, 7), np.nan, dtype=np.float32) |
| with torch.no_grad(): |
| for fi, t0 in enumerate(starts): |
| state_np = data["state"][t0, :7].copy() |
| task = data["tasks"][int(data["task_index"][t0])] |
| batch = { |
| "task": task, |
| "observation.state": torch.from_numpy(state_np).unsqueeze(0).to(device), |
| "observation.images.camera1": rgb_tensor(front[t0], torch).to(device), |
| "observation.images.camera2": rgb_tensor(cam2[t0], torch).to(device), |
| } |
| pred = policy.predict_action_chunk(batch)[0].detach().float().cpu().numpy() |
| take = pred[: min(step, n - t0)].copy() |
| |
| |
| if not relative: |
| take[:, :6] = state_np[:6] + take[:, :6] |
| pred_abs[t0 : t0 + take.shape[0]] = take |
| if fi % 5 == 0 or fi + 1 == len(starts): |
| print( |
| f" ep{ep:03d} {fi + 1}/{len(starts)} f={t0} " |
| f"|dq|={np.abs(take[:, :6] - state_np[:6]).mean():.3f} " |
| f"grip={take[0, 6]:.0f}", |
| flush=True, |
| ) |
| del batch |
| if device.type == "cuda" and fi % 8 == 0: |
| torch.cuda.empty_cache() |
| data["pred"] = pred_abs |
| data["episode"] = ep |
| data["relative"] = relative |
| return data |
|
|
|
|
| def episode_metrics(data: dict) -> dict: |
| st = data["state"][:, :7] |
| ac = data["action"][:, :7] |
| pr = data["pred"] |
| valid = np.isfinite(pr[:, 0]) |
| joint_mae = float(np.abs(pr[valid, :6] - ac[valid, :6]).mean()) |
| joint_mae_vs_enc = float(np.abs(pr[valid, :6] - st[valid, :6]).mean()) |
| per_joint = { |
| JOINT_NAMES[j]: float(np.abs(pr[valid, j] - ac[valid, j]).mean()) for j in range(6) |
| } |
| grip_acc = float(np.mean(np.abs(pr[valid, 6] - ac[valid, 6]) < 0.5)) |
| return { |
| "episode": int(data["episode"]), |
| "frames": int(data["n"]), |
| "valid_frames": int(valid.sum()), |
| "joint_mae_vs_demo_deg": joint_mae, |
| "joint_mae_vs_encoder_deg": joint_mae_vs_enc, |
| "per_joint_mae_vs_demo": per_joint, |
| "gripper_agree": grip_acc, |
| "use_relative_actions": bool(data.get("relative", False)), |
| } |
|
|
|
|
| def plot_episode(data: dict, out: Path, title: str) -> Path: |
| plt = _setup_cn_mpl() |
| st = data["state"][:, :7] |
| ac = data["action"][:, :7] |
| pr = data["pred"] |
| n = data["n"] |
| ep = data["episode"] |
| x = np.arange(n) |
| fig, axes = plt.subplots(7, 1, figsize=(16.5, 12.4), sharex=True, gridspec_kw={"hspace": 0.08}) |
| fig.subplots_adjust(top=0.88, bottom=0.07, left=0.08, right=0.98) |
| fig.suptitle(f"{title} open-loop ep{ep:03d}", fontsize=17, fontweight="bold", y=0.995) |
| mode = "relative→abs (policy)" if data.get("relative") else "Δq + q_now (eval)" |
| fig.text( |
| 0.01, |
| 0.965, |
| f"solid=encoder dashed=demo action orange=open-loop VLA ({mode})\n" |
| "infer every n_action_steps frames, execute first n_action_steps of each chunk", |
| fontsize=11, |
| color="#C8C8C8", |
| va="top", |
| ) |
| legend_done = False |
| for j, ax in enumerate(axes): |
| c = HEX[j] |
| (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.0, color=c, zorder=3) |
| (vla,) = ax.plot(x, pr[:, j], color="#FF9F1C", lw=1.8, zorder=4) |
| 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) |
| if not legend_done: |
| ax.legend([s_line, h_line, vla], ["encoder", "demo", "open-loop VLA"], loc="upper right", fontsize=10) |
| legend_done = True |
| axes[-1].set_xlabel("frame (20 Hz)", fontsize=12) |
| axes[-1].set_xlim(0, n - 1) |
| m = episode_metrics(data) |
| fig.text( |
| 0.01, |
| 0.008, |
| f"joint |pred-demo| mean {m['joint_mae_vs_demo_deg']:.2f} deg " |
| f"gripper agree {m['gripper_agree']:.0%} frames {n}", |
| fontsize=10.5, |
| color="#D2C878", |
| ) |
| out.mkdir(parents=True, exist_ok=True) |
| path = out / f"ep{ep:03d}_trajectory.png" |
| fig.savefig(path, dpi=130, bbox_inches="tight", pad_inches=0.22) |
| plt.close(fig) |
| print("wrote", path) |
| return path |
|
|
|
|
| def plot_task_mae_bars(metrics: list[dict], out: Path, title: str) -> Path: |
| plt = _setup_cn_mpl() |
| eps = [f"ep{m['episode']:03d}" for m in metrics] |
| maes = [m["joint_mae_vs_demo_deg"] for m in metrics] |
| grips = [m["gripper_agree"] * 100 for m in metrics] |
| fig, axes = plt.subplots(1, 2, figsize=(11.5, 4.2)) |
| fig.suptitle(f"{title} — offline metrics", fontsize=14, fontweight="bold") |
| axes[0].bar(eps, maes, color="#50B4FF") |
| axes[0].set_ylabel("joint MAE vs demo (°)") |
| axes[0].grid(True, axis="y", alpha=0.3) |
| axes[1].bar(eps, grips, color="#50FFA0") |
| axes[1].set_ylabel("gripper agree (%)") |
| axes[1].set_ylim(0, 105) |
| axes[1].grid(True, axis="y", alpha=0.3) |
| path = out / "metrics_bars.png" |
| fig.savefig(path, dpi=140, bbox_inches="tight", pad_inches=0.2) |
| plt.close(fig) |
| print("wrote", path) |
| return path |
|
|
|
|
| def plot_cross_task_summary(all_metrics: dict[str, list[dict]], out: Path) -> Path: |
| plt = _setup_cn_mpl() |
| names = list(all_metrics.keys()) |
| means = [float(np.mean([m["joint_mae_vs_demo_deg"] for m in all_metrics[k]])) for k in names] |
| grips = [float(np.mean([m["gripper_agree"] for m in all_metrics[k]])) * 100 for k in names] |
| fig, axes = plt.subplots(1, 2, figsize=(12.5, 4.4)) |
| fig.suptitle("RM65 SmolVLA — 四任务离线开环汇总", fontsize=15, fontweight="bold") |
| axes[0].bar(names, means, color=["#50B4FF", "#FFC850", "#B48CFF", "#FF648C"][: len(names)]) |
| axes[0].set_ylabel("mean joint MAE vs demo (°)") |
| axes[0].grid(True, axis="y", alpha=0.3) |
| axes[1].bar(names, grips, color=["#50FFA0", "#78DCDC", "#50B4FF", "#FFC850"][: len(names)]) |
| axes[1].set_ylabel("mean gripper agree (%)") |
| axes[1].set_ylim(0, 105) |
| axes[1].grid(True, axis="y", alpha=0.3) |
| path = out / "cross_task_mae.png" |
| fig.savefig(path, dpi=150, bbox_inches="tight", pad_inches=0.22) |
| plt.close(fig) |
| print("wrote", path) |
| return path |
|
|
|
|
| def write_task_index(out: Path, title: str, paths: list[Path], metrics: list[dict]) -> None: |
| items = "".join(f"<li><a href='{p.name}'>{p.name}</a></li>" for p in paths) |
| rows = "".join( |
| "<tr>" |
| f"<td>ep{m['episode']:03d}</td>" |
| f"<td>{m['frames']}</td>" |
| f"<td>{m['joint_mae_vs_demo_deg']:.3f}</td>" |
| f"<td>{m['gripper_agree']:.0%}</td>" |
| "</tr>" |
| for m in metrics |
| ) |
| (out / "index.html").write_text( |
| "<html><body style='background:#111;color:#eee;font-family:sans-serif;padding:16px'>" |
| f"<h3>{title}</h3>" |
| "<table border='1' cellpadding='6' style='border-collapse:collapse;margin:12px 0'>" |
| "<tr><th>ep</th><th>frames</th><th>joint MAE°</th><th>grip agree</th></tr>" |
| + rows |
| + "</table><ul>" |
| + items |
| + "</ul></body></html>\n", |
| encoding="utf-8", |
| ) |
|
|
|
|
| def write_dashboard(all_metrics: dict[str, list[dict]], coverage: dict) -> Path: |
| out = OUT_ROOT |
| out.mkdir(parents=True, exist_ok=True) |
| plot_cross_task_summary(all_metrics, out) |
|
|
| rows = [] |
| for name, mets in all_metrics.items(): |
| mean_mae = float(np.mean([m["joint_mae_vs_demo_deg"] for m in mets])) |
| mean_grip = float(np.mean([m["gripper_agree"] for m in mets])) |
| cov = coverage.get(name, {}) |
| rows.append( |
| "<tr>" |
| f"<td><b>{name}</b></td>" |
| f"<td>{cov.get('ckpt','')}</td>" |
| f"<td>{'✓' if cov.get('traj') else '✗'}</td>" |
| f"<td>{'✓' if cov.get('attn') else '✗'}</td>" |
| f"<td>{'✓' if cov.get('metrics') else '✗'}</td>" |
| f"<td>{mean_mae:.2f}</td>" |
| f"<td>{mean_grip:.0%}</td>" |
| f"<td><a href='{name}/index.html'>{name}/</a></td>" |
| "</tr>" |
| ) |
|
|
| summary = { |
| "tasks": { |
| k: { |
| "episodes": mets, |
| "mean_joint_mae_vs_demo_deg": float(np.mean([m["joint_mae_vs_demo_deg"] for m in mets])), |
| "mean_gripper_agree": float(np.mean([m["gripper_agree"] for m in mets])), |
| } |
| for k, mets in all_metrics.items() |
| }, |
| "coverage": coverage, |
| } |
| (out / "summary.json").write_text(json.dumps(summary, indent=2, ensure_ascii=False) + "\n") |
|
|
| html = out / "index.html" |
| html.write_text( |
| "<html><head><meta charset='utf-8'><title>RM65 SmolVLA task offline eval</title></head>" |
| "<body style='background:#111;color:#eee;font-family:sans-serif;padding:20px;max-width:1100px'>" |
| "<h2>RM65 SmolVLA 四任务离线开环评测汇总</h2>" |
| "<p>open-loop：按 n_action_steps 切 chunk，与 cleaned demo 关节/夹爪对比。" |
| "注意力图见 <code>outputs/diag/smolvla_attn_*</code>。</p>" |
| "<p><img src='cross_task_mae.png' style='max-width:100%;border:1px solid #333'/></p>" |
| "<table border='1' cellpadding='8' style='border-collapse:collapse;width:100%'>" |
| "<tr><th>任务</th><th>ckpt</th><th>轨迹图</th><th>注意力</th><th>指标</th>" |
| "<th>mean MAE°</th><th>grip</th><th>目录</th></tr>" |
| + "".join(rows) |
| + "</table>" |
| "<h3>覆盖说明</h3>" |
| "<ul>" |
| "<li>stack：既有 stack_30ep_offline + attn_stack30_f074/f216</li>" |
| "<li>usb / cleanup / place：本脚本新绘轨迹 + metrics；注意力由 smolvla_diag_visualize 补</li>" |
| "</ul>" |
| "</body></html>\n", |
| encoding="utf-8", |
| ) |
| print("dashboard", html) |
| return html |
|
|
|
|
| def parse_args(): |
| p = argparse.ArgumentParser() |
| p.add_argument("--tasks", type=str, default="usb,cleanup,place,stack") |
| p.add_argument("--episodes", type=str, default="0,1,2") |
| p.add_argument("--device", type=str, default="cuda") |
| p.add_argument("--skip-existing", action="store_true") |
| return p.parse_args() |
|
|
|
|
| def main() -> None: |
| import os |
|
|
| os.environ["HF_HUB_OFFLINE"] = "1" |
| os.environ["TRANSFORMERS_OFFLINE"] = "1" |
| os.environ["HF_DATASETS_OFFLINE"] = "1" |
| sys.path.insert(0, str(ROOT)) |
| import torch |
|
|
| from lerobot.common.policies.smolvla.modeling_smolvla import SmolVLAPolicy |
| from lerobot.configs.policies import PreTrainedConfig |
| from smolvla_diag_visualize import load_stats |
|
|
| args = parse_args() |
| task_names = [t.strip() for t in args.tasks.split(",") if t.strip()] |
| episodes = [int(x) for x in args.episodes.split(",") if x.strip()] |
| device = torch.device(args.device if torch.cuda.is_available() or args.device == "cpu" else "cpu") |
| if args.device == "cuda" and not torch.cuda.is_available(): |
| device = torch.device("cpu") |
| print("WARN: cuda unavailable, using cpu") |
|
|
| all_metrics: dict[str, list[dict]] = {} |
| coverage: dict[str, dict] = {} |
|
|
| for name in task_names: |
| if name not in TASKS: |
| raise SystemExit(f"unknown task {name}; choose from {list(TASKS)}") |
| meta = TASKS[name] |
| ckpt: Path = meta["ckpt"] |
| ds: Path = meta["dataset"] |
| out = OUT_ROOT / name |
| out.mkdir(parents=True, exist_ok=True) |
| print(f"\n==== {name} ckpt={ckpt.name} ds={ds.name} ====", flush=True) |
|
|
| |
| legacy = meta.get("legacy_out") |
| if ( |
| args.skip_existing |
| and legacy |
| and all((legacy / f"ep{ep:03d}_trajectory.png").is_file() for ep in episodes) |
| and (out / "metrics.json").is_file() |
| ): |
| mets = json.loads((out / "metrics.json").read_text()) |
| all_metrics[name] = mets |
| coverage[name] = { |
| "ckpt": ckpt.name, |
| "traj": True, |
| "attn": any( |
| (ROOT / "outputs/diag" / d).is_dir() |
| for d in ["smolvla_attn_stack30_f074", "smolvla_attn_stack30_f216"] |
| ), |
| "metrics": True, |
| } |
| print("skip existing", name) |
| continue |
|
|
| if not ckpt.is_dir() or not (ckpt / "model.safetensors").is_file(): |
| raise FileNotFoundError(f"missing ckpt {ckpt}") |
| if not ds.is_dir(): |
| raise FileNotFoundError(f"missing dataset {ds}") |
|
|
| sanitize_config(ckpt) |
| config = PreTrainedConfig.from_pretrained(str(ckpt)) |
| stats = load_stats(ckpt, config) |
| policy = SmolVLAPolicy.from_pretrained(str(ckpt), config=config, dataset_stats=stats) |
| policy.to(device) |
| policy.eval() |
| print( |
| f"device={device} chunk={policy.config.chunk_size} " |
| f"n_action_steps={policy.config.n_action_steps} " |
| f"relative={getattr(policy.config, 'use_relative_actions', False)}", |
| flush=True, |
| ) |
|
|
| paths: list[Path] = [] |
| mets: list[dict] = [] |
| for ep in episodes: |
| traj_path = out / f"ep{ep:03d}_trajectory.png" |
| npy_path = out / f"ep{ep:03d}_pred.npy" |
| if args.skip_existing and traj_path.is_file() and npy_path.is_file(): |
| print(f"skip existing ep{ep:03d}") |
| |
| data = load_episode(ds, ep) |
| data["pred"] = np.load(npy_path) |
| data["episode"] = ep |
| data["relative"] = bool(getattr(policy.config, "use_relative_actions", False)) |
| m = episode_metrics(data) |
| mets.append(m) |
| paths.append(traj_path) |
| continue |
| data = infer_episode(policy, ds, meta["cam2_key"], ep, device) |
| np.save(npy_path, data["pred"]) |
| paths.append(plot_episode(data, out, meta["title"])) |
| m = episode_metrics(data) |
| mets.append(m) |
| print( |
| f" metrics ep{ep:03d}: MAE={m['joint_mae_vs_demo_deg']:.2f}° " |
| f"grip={m['gripper_agree']:.0%}", |
| flush=True, |
| ) |
| del data |
| if device.type == "cuda": |
| torch.cuda.empty_cache() |
|
|
| paths.append(plot_task_mae_bars(mets, out, meta["title"])) |
| (out / "metrics.json").write_text(json.dumps(mets, indent=2) + "\n") |
| write_task_index(out, meta["title"], paths, mets) |
| |
| if legacy and legacy.is_dir(): |
| (out / "NOTE_legacy.txt").write_text( |
| f"Earlier plots also at {legacy}\n", encoding="utf-8" |
| ) |
|
|
| all_metrics[name] = mets |
| attn_ok = False |
| if name == "stack": |
| attn_ok = (ROOT / "outputs/diag/smolvla_attn_stack30_f074").is_dir() |
| else: |
| attn_ok = (ROOT / f"outputs/diag/smolvla_attn_{name}_f074").is_dir() |
| coverage[name] = { |
| "ckpt": ckpt.name, |
| "traj": True, |
| "attn": attn_ok, |
| "metrics": True, |
| } |
|
|
| del policy |
| if device.type == "cuda": |
| torch.cuda.empty_cache() |
|
|
| write_dashboard(all_metrics, coverage) |
| print("DONE") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
