| |
| """Dataset coverage plots for RM65 cleaned SFT data. |
| |
| 2) Instruction diversity cosine matrix |
| 3) Per-joint Delta-q histograms (action - state) |
| 4) Per-task action mean/std vs astra_smolvla MEAN_STD |
| 1) Vision feature coverage (PCA 2D of SmolVLM embed_image) |
| |
| Host (2/3/4):: |
| |
| python3 scripts/eval_dataset_coverage_plots.py |
| |
| Vision (GPU, docker):: |
| |
| docker exec rm65_dev2 bash -lc 'cd /home/sdznkj/zkx_ws/sendlerobot && \\ |
| HF_HUB_OFFLINE=1 PYTHONPATH=. python3 scripts/eval_dataset_coverage_plots.py --vision' |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from collections import Counter |
| from pathlib import Path |
|
|
| import numpy as np |
| import pyarrow.parquet as pq |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| CLEAN = ROOT / "datasets/cleaned" |
| OUT = ROOT / "outputs/diag/dataset_plots" |
| CKPT = ROOT / "astra_smolvla" |
| NORM_JSON = ROOT / "outputs/diag/astra_norm_stats.json" |
| EMB_CACHE = OUT / "vision_embeddings.npz" |
|
|
| TASKS = [ |
| ("rm65_stacking_blocks", "堆叠", "observation.images.astra"), |
| ("rm65_cleanup_the_desk", "桌面", "observation.images.astra"), |
| ("rm65_place_to_slot", "插槽", "observation.images.astra"), |
| ("rm65_usb_insert", "USB", "observation.images.mono"), |
| ] |
| JOINTS = ["关节1", "关节2", "关节3", "关节4", "关节5", "关节6", "夹爪"] |
| TASK_COLORS = ["#47A8FF", "#50FFA0", "#FFC850", "#FF648C"] |
| CAM_MARKERS = {"front": "o", "astra": "s", "mono": "^"} |
|
|
| SHORT_INSTR = { |
| "Stack three cylinder blocks. Grasp the left cylinder.": "堆叠·抓左柱", |
| "Stack three cylinder blocks. Place it on the middle cylinder and release.": "堆叠·放到中柱", |
| "Stack three cylinder blocks. Grasp the right cylinder.": "堆叠·抓右柱", |
| "Stack three cylinder blocks. Place it on the stack and release.": "堆叠·放到堆上", |
| "Put three objects from the desk into the box. Grasp the left object.": "桌面·抓左物", |
| "Put three objects from the desk into the box. Place it in the box and release.": "桌面·放进盒", |
| "Put three objects from the desk into the box. Grasp the middle object.": "桌面·抓中物", |
| "Put three objects from the desk into the box. Grasp the right object.": "桌面·抓右物", |
| "Place three objects into matching slots on the silver card. Rotate the gripper and grasp the cylinder.": "插槽·抓圆柱", |
| "Place three objects into matching slots on the silver card. Lift and rotate the cylinder to align with the round slot.": "插槽·对准圆孔", |
| "Place three objects into matching slots on the silver card. Insert into the round slot and release.": "插槽·插入圆孔", |
| "Place three objects into matching slots on the silver card. Rotate the gripper and grasp the T-shaped wooden block.": "插槽·抓T块", |
| "Place three objects into matching slots on the silver card. Lift and rotate the T-shaped wooden block to align with the T-shaped slot.": "插槽·对准T孔", |
| "Place three objects into matching slots on the silver card. Insert into the T-shaped slot and release.": "插槽·插入T孔", |
| "Place three objects into matching slots on the silver card. Rotate the gripper and grasp the blue box.": "插槽·抓蓝盒", |
| "Place three objects into matching slots on the silver card. Lift and rotate the blue box to align with the rectangular slot.": "插槽·对准方孔", |
| "Place three objects into matching slots on the silver card. Insert into the rectangular slot and release.": "插槽·插入方孔", |
| "Insert the blue USB module into the white base. Rotate the gripper and grasp the blue USB module.": "USB·抓住模块", |
| "Insert the blue USB module into the white base. Lift and align the USB with the port.": "USB·对准接口", |
| "Insert the blue USB module into the white base. Insert into the white base and release.": "USB·插入底座", |
| "failed": "USB·failed", |
| } |
|
|
|
|
| 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": 160, |
| } |
| ) |
| return plt |
|
|
|
|
| def _save(fig, plt, name: str) -> Path: |
| OUT.mkdir(parents=True, exist_ok=True) |
| path = OUT / name |
| fig.savefig(path, dpi=160, bbox_inches="tight", pad_inches=0.25) |
| plt.close(fig) |
| print("wrote", path) |
| return path |
|
|
|
|
| def _load_unique_instructions() -> list[tuple[str, str, str]]: |
| """(dataset_cn, short, full_text) unique by full_text, first occurrence.""" |
| seen: set[str] = set() |
| rows = [] |
| for folder, cn, _cam in TASKS: |
| path = CLEAN / folder / "meta/tasks.jsonl" |
| for line in path.read_text(encoding="utf-8").splitlines(): |
| if not line.strip(): |
| continue |
| obj = json.loads(line) |
| full = str(obj["task"]).strip() |
| if full in seen: |
| continue |
| seen.add(full) |
| short = SHORT_INSTR.get(full, full[:18]) |
| rows.append((cn, short, full)) |
| return rows |
|
|
|
|
| def plot_instruction_matrix() -> Path: |
| plt = _setup_cn_mpl() |
| rows = _load_unique_instructions() |
| texts = [r[2] for r in rows] |
| labels = [r[1] for r in rows] |
| n = len(texts) |
|
|
| def ngrams(s: str, k: int = 3) -> list[str]: |
| s = s.lower() |
| if len(s) < k: |
| return [s] |
| return [s[i : i + k] for i in range(len(s) - k + 1)] |
|
|
| docs = [Counter(ngrams(t)) for t in texts] |
| vocab = sorted(set().union(*docs)) |
| idx = {w: i for i, w in enumerate(vocab)} |
| x = np.zeros((n, len(vocab)), np.float64) |
| for i, c in enumerate(docs): |
| for w, cnt in c.items(): |
| x[i, idx[w]] = cnt |
| df = (x > 0).sum(0) |
| idf = np.log((1.0 + n) / (1.0 + df)) + 1.0 |
| x *= idf |
| x /= np.linalg.norm(x, axis=1, keepdims=True) + 1e-9 |
| sim = x @ x.T |
|
|
| fig, ax = plt.subplots(figsize=(11.5, 10.2)) |
| im = ax.imshow(sim, vmin=0.0, vmax=1.0, cmap="magma") |
| ax.set_xticks(range(n)) |
| ax.set_yticks(range(n)) |
| ax.set_xticklabels(labels, rotation=75, ha="right", fontsize=8) |
| ax.set_yticklabels(labels, fontsize=8) |
| fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04, label="字符 3-gram TF-IDF 余弦") |
| ax.set_title("语言指令多样性与语义距离", fontsize=18, fontweight="bold", pad=12) |
| fig.text( |
| 0.01, |
| 0.01, |
| "桌面三个「放进盒子」子任务共用同一句，矩阵里只出现一次。" |
| "USB 的 failed 是废指令。块状高相似来自共用 overall 前缀。", |
| fontsize=10, |
| color="#C8C8C8", |
| ) |
| return _save(fig, plt, "02_instruction_diversity.png") |
|
|
|
|
| def _iter_parquet_action_state(folder: str): |
| data_dir = CLEAN / folder / "data" |
| for path in sorted(data_dir.rglob("*.parquet")): |
| table = pq.read_table(path, columns=["action", "observation.state"]) |
| act = np.asarray(table.column("action").to_pylist(), dtype=np.float32) |
| st = np.asarray(table.column("observation.state").to_pylist(), dtype=np.float32) |
| if act.ndim != 2 or st.ndim != 2: |
| continue |
| d = min(act.shape[1], st.shape[1], 7) |
| yield act[:, :d], st[:, :d] |
|
|
|
|
| def plot_delta_q() -> Path: |
| plt = _setup_cn_mpl() |
| per_task: dict[str, np.ndarray] = {} |
| for folder, cn, _cam in TASKS: |
| chunks = [] |
| for act, st in _iter_parquet_action_state(folder): |
| k = min(6, act.shape[1], st.shape[1]) |
| chunks.append(act[:, :k] - st[:, :k]) |
| dq = np.concatenate(chunks, axis=0) if chunks else np.zeros((0, 6), np.float32) |
| per_task[cn] = dq |
| print(f"delta-q {cn}: n={dq.shape[0]} mean|dq|={np.abs(dq).mean():.4f} std={dq.std(axis=0)}") |
|
|
| fig, axes = plt.subplots(2, 3, figsize=(14.5, 8.6), sharey=False) |
| fig.suptitle("关节 Δq 各维分布（动作绝对角 − 当前编码器）", fontsize=18, fontweight="bold") |
| for j, ax in enumerate(axes.ravel()): |
| astra_cols = np.concatenate( |
| [per_task[t[1]][:, j] for t in TASKS[:3] if per_task[t[1]].size], |
| axis=0, |
| ) |
| p = float(np.percentile(np.abs(astra_cols), 99.7)) if astra_cols.size else 1.0 |
| lo, hi = -max(p, 0.4), max(p, 0.4) |
| bins = np.linspace(lo, hi, 90) |
| for (folder, cn, _c), color in zip(TASKS[:3], TASK_COLORS[:3]): |
| arr = per_task[cn] |
| if arr.size == 0: |
| continue |
| ax.hist( |
| arr[:, j], |
| bins=bins, |
| density=True, |
| histtype="step", |
| linewidth=1.8, |
| color=color, |
| label=cn, |
| ) |
| ax.axvline(0.0, color="#888888", ls=":", lw=0.8) |
| ax.set_xlim(lo, hi) |
| ax.set_title(JOINTS[j], fontsize=13) |
| ax.grid(True, axis="y", alpha=0.25) |
| ax.tick_params(labelsize=9) |
| if j == 0: |
| ax.legend(fontsize=9, loc="upper right") |
| if j >= 3: |
| ax.set_xlabel("度 / 步", fontsize=11) |
| fig.text( |
| 0.01, |
| 0.01, |
| "逐步 Δq = action[:6] − state[:6]。图中只画 Astra 三任务（横轴按它们 99.7 分位）。" |
| f"USB mean|dq|={float(np.abs(per_task['USB']).mean()):.1f}°，不在同一尺度上，未叠进此图" |
| "（cleaned README：USB mono 相对关节滞后约 10 帧）。", |
| fontsize=10, |
| color="#D2C878", |
| ) |
| return _save(fig, plt, "03_delta_q_distribution.png") |
|
|
|
|
| def plot_task_vs_norm() -> Path: |
| plt = _setup_cn_mpl() |
| glob = json.loads(NORM_JSON.read_text()) |
| g_mean = np.asarray(glob["action.mean"], dtype=np.float64) |
| g_std = np.asarray(glob["action.std"], dtype=np.float64) |
|
|
| task_stats = [] |
| for folder, cn, _cam in TASKS: |
| s = json.loads((CLEAN / folder / "meta/stats.json").read_text()) |
| task_stats.append( |
| ( |
| cn, |
| np.asarray(s["action"]["mean"], dtype=np.float64), |
| np.asarray(s["action"]["std"], dtype=np.float64), |
| ) |
| ) |
|
|
| d = 7 |
| x = np.arange(d) |
| width = 0.15 |
| fig, axes = plt.subplots(2, 1, figsize=(14.2, 9.4), gridspec_kw={"height_ratios": [1.35, 1.0], "hspace": 0.32}) |
| ax = axes[0] |
| ax.errorbar( |
| x - 2 * width, |
| g_mean[:d], |
| yerr=g_std[:d], |
| fmt="D", |
| color="#EEEEEE", |
| ecolor="#888888", |
| capsize=3, |
| ms=7, |
| label=f"astra 全局 MEAN_STD n={int(glob['n'])}", |
| zorder=5, |
| ) |
| for i, ((cn, mean, std), color) in enumerate(zip(task_stats, TASK_COLORS)): |
| ax.errorbar( |
| x + (i - 1.0) * width, |
| mean[:d], |
| yerr=std[:d], |
| fmt="o", |
| color=color, |
| ecolor=color, |
| capsize=2, |
| ms=6, |
| label=cn, |
| alpha=0.95, |
| ) |
| ax.set_xticks(x) |
| ax.set_xticklabels(JOINTS[:d], fontsize=12) |
| ax.set_ylabel("绝对角（度） / 夹爪", fontsize=12) |
| ax.set_title("分任务动作目标 vs 旧权重归一化统计", fontsize=18, fontweight="bold") |
| ax.legend(fontsize=10, ncol=3, loc="best") |
| ax.grid(True, axis="y", alpha=0.3) |
|
|
| ax2 = axes[1] |
| for i, ((cn, mean, std), color) in enumerate(zip(task_stats, TASK_COLORS)): |
| z = (mean[:d] - g_mean[:d]) / (g_std[:d] + 1e-8) |
| ax2.bar(x + (i - 1.5) * width, z, width=width, color=color, label=cn) |
| ax2.axhline(0.0, color="#888888", lw=0.8) |
| ax2.axhline(1.0, color="#666666", ls="--", lw=0.7) |
| ax2.axhline(-1.0, color="#666666", ls="--", lw=0.7) |
| ax2.set_xticks(x) |
| ax2.set_xticklabels(JOINTS[:d], fontsize=12) |
| ax2.set_ylabel("相对全局 (μ_task − μ_glob) / σ_glob", fontsize=11) |
| ax2.set_title("各任务均值偏离旧 MEAN_STD 的 z 分数", fontsize=14) |
| ax2.grid(True, axis="y", alpha=0.3) |
| ax2.legend(fontsize=9, ncol=4) |
| fig.text( |
| 0.01, |
| 0.01, |
| "全局统计来自 astra_smolvla preprocessor（stack+desk+slot 共 152305 帧，不含 USB）。" |
| "虚线 ±1σ。旧权重 state 配置是 6 维，safetensors 里仍存了 7 维。", |
| fontsize=10, |
| color="#C8C8C8", |
| ) |
| return _save(fig, plt, "04_task_vs_normalizer.png") |
|
|
|
|
| def pca2(x: np.ndarray) -> tuple[np.ndarray, np.ndarray]: |
| x = x.astype(np.float64) |
| x = x - x.mean(axis=0, keepdims=True) |
| _u, s, vt = np.linalg.svd(x, full_matrices=False) |
| z = x @ vt[:2].T |
| evr = (s[:2] ** 2) / (s ** 2).sum() |
| return z.astype(np.float32), evr |
|
|
|
|
| def _sample_video_frames(mp4: Path, n_frames_hint: int, picks: int = 3) -> list[np.ndarray]: |
| import cv2 |
|
|
| cap = cv2.VideoCapture(str(mp4)) |
| if not cap.isOpened(): |
| return [] |
| n = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0) |
| if n <= 0: |
| n = max(n_frames_hint, picks) |
| idxs = np.linspace(0.08, 0.92, picks) |
| frames = [] |
| for frac in idxs: |
| i = int(frac * max(n - 1, 0)) |
| cap.set(cv2.CAP_PROP_POS_FRAMES, i) |
| ok, bgr = cap.read() |
| if ok and bgr is not None: |
| frames.append(bgr) |
| cap.release() |
| return frames |
|
|
|
|
| def extract_vision_embeddings(n_ep: int = 12, frames_per_ep: int = 3) -> Path: |
| sys.path.insert(0, str(ROOT)) |
| sys.path.insert(0, str(ROOT / "scripts")) |
| import torch |
|
|
| from lerobot.common.policies.smolvla.modeling_smolvla import SmolVLAPolicy, resize_with_pad |
| from lerobot.configs.policies import PreTrainedConfig |
| from smolvla_diag_visualize import force_offline, load_stats, sanitize_ckpt_config |
|
|
| 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 |
|
|
| vecs, task_ids, cam_ids, ep_ids = [], [], [], [] |
| cam_name = [] |
| with torch.no_grad(): |
| for ti, (folder, cn, cam2_key) in enumerate(TASKS): |
| info = json.loads((CLEAN / folder / "meta/info.json").read_text()) |
| n_total = int(info["total_episodes"]) |
| eps = np.linspace(0, n_total - 1, num=min(n_ep, n_total), dtype=int) |
| cams = [("front", "observation.images.front"), ("cam2", cam2_key)] |
| for ep in eps: |
| for cam_tag, vkey in cams: |
| mp4 = ( |
| CLEAN |
| / folder |
| / "videos" |
| / "chunk-000" |
| / vkey |
| / f"episode_{int(ep):06d}.mp4" |
| ) |
| if not mp4.is_file(): |
| print("missing", mp4) |
| continue |
| bgrs = _sample_video_frames(mp4, 400, picks=frames_per_ep) |
| for bgr in bgrs: |
| rgb = bgr[:, :, ::-1].copy() |
| t = torch.from_numpy(rgb).permute(2, 0, 1).float().div_(255.0).unsqueeze(0).to(device) |
| t = resize_with_pad(t, 512, 512, pad_value=0) |
| t = t * 2.0 - 1.0 |
| tok = policy.model.vlm_with_expert.embed_image(t) |
| vec = tok.float().mean(dim=1).squeeze(0).cpu().numpy() |
| vecs.append(vec.astype(np.float32)) |
| task_ids.append(ti) |
| cam_ids.append(0 if cam_tag == "front" else 1) |
| cam_name.append("front" if cam_tag == "front" else ("mono" if "mono" in vkey else "astra")) |
| ep_ids.append(int(ep)) |
| print(f"vision {cn}: accumulated {len(vecs)} embeddings", flush=True) |
| if device.type == "cuda": |
| torch.cuda.empty_cache() |
|
|
| OUT.mkdir(parents=True, exist_ok=True) |
| np.savez_compressed( |
| EMB_CACHE, |
| feat=np.stack(vecs, axis=0), |
| task=np.asarray(task_ids, np.int32), |
| cam=np.asarray(cam_ids, np.int32), |
| cam_name=np.asarray(cam_name), |
| ep=np.asarray(ep_ids, np.int32), |
| ) |
| print("wrote", EMB_CACHE, "n=", len(vecs), "dim=", vecs[0].shape) |
| return EMB_CACHE |
|
|
|
|
| def plot_vision_pca() -> Path: |
| plt = _setup_cn_mpl() |
| zfile = np.load(EMB_CACHE, allow_pickle=True) |
| feat = zfile["feat"] |
| task = zfile["task"] |
| cam_name = [str(x) for x in zfile["cam_name"]] |
| xy, evr = pca2(feat) |
|
|
| fig, ax = plt.subplots(figsize=(11.8, 8.6)) |
| for ti, (_f, cn, _c) in enumerate(TASKS): |
| for cam, marker in (("front", "o"), ("astra", "s"), ("mono", "^")): |
| m = (task == ti) & np.array([c == cam for c in cam_name]) |
| if not np.any(m): |
| continue |
| ax.scatter( |
| xy[m, 0], |
| xy[m, 1], |
| s=28, |
| c=TASK_COLORS[ti], |
| marker=marker, |
| alpha=0.82, |
| edgecolors="none", |
| label=f"{cn} · {cam}", |
| ) |
| ax.set_title("视觉特征覆盖（SmolVLM embed_image → PCA）", fontsize=18, fontweight="bold") |
| ax.set_xlabel(f"PC1 解释方差 {evr[0]*100:.1f}%", fontsize=12) |
| ax.set_ylabel(f"PC2 解释方差 {evr[1]*100:.1f}%", fontsize=12) |
| ax.legend(fontsize=9, ncol=2, loc="best") |
| ax.grid(True, alpha=0.25) |
| fig.text( |
| 0.01, |
| 0.01, |
| "每任务约 12 条 episode × 3 帧 × 两路相机。圆=front，方=astra，三角=USB mono。" |
| "本机无 sklearn，用 PCA 代替 t-SNE；分离仍能看覆盖与相机域。", |
| fontsize=10, |
| color="#C8C8C8", |
| ) |
| return _save(fig, plt, "01_vision_coverage_pca.png") |
|
|
|
|
| def write_index(paths: list[Path]) -> Path: |
| items = "".join(f"<li><a href='{p.name}'>{p.name}</a></li>" for p in paths) |
| idx = OUT / "index.html" |
| idx.write_text( |
| "<html><body style='background:#111;color:#eee;font-family:sans-serif'>" |
| "<h3>数据集覆盖图</h3><ul>" |
| + items |
| + "</ul></body></html>\n", |
| encoding="utf-8", |
| ) |
| return idx |
|
|
|
|
| def parse_args(): |
| p = argparse.ArgumentParser() |
| p.add_argument("--vision", action="store_true", help="extract SmolVLM embeddings (GPU)") |
| p.add_argument("--skip-stats", action="store_true") |
| return p.parse_args() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| OUT.mkdir(parents=True, exist_ok=True) |
| paths: list[Path] = [] |
| if not args.skip_stats: |
| paths.append(plot_instruction_matrix()) |
| paths.append(plot_delta_q()) |
| paths.append(plot_task_vs_norm()) |
| if args.vision or EMB_CACHE.is_file(): |
| if args.vision or not EMB_CACHE.is_file(): |
| extract_vision_embeddings() |
| paths.append(plot_vision_pca()) |
| elif not args.skip_stats: |
| print("skip vision (pass --vision inside docker)") |
| |
| vis = OUT / "01_vision_coverage_pca.png" |
| if vis.is_file() and vis not in paths: |
| paths.insert(0, vis) |
| idx = write_index(paths) |
| print("index", idx) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
