"""Does the policy aim from what it sees? A visual-feedback probe, no training. The scripted teacher's clean pick is executed until its pinch point is `--heights` mm above the grasp point, and the state is frozen there. Two observations are made of it: as it is, and with the target piece moved `--shift-mm` sideways (four directions: along and across the jaws' closing axis), with the arm unchanged. For each, the policy's 50-step action chunk is predicted with identical sampling noise, and the pinch point of every predicted action is found by forward kinematics. The chunk's aim is its lowest pinch point (where the predicted descent ends). Follow ratio = the aim's shift along the piece's shift, divided by the piece's shift: 1 = the aim follows the piece fully (the policy aims from the images), 0 = it ignores the change (it replays a path from the joint state). Noise floor: the aim of the same observation under different sampling noise. Run: MUJOCO_GL=egl PHASE2_PROFILE=baseline .venv/bin/python sim/visual_probe.py \ --policy baseline=models/baseline --policy dart300=models/dart300 --out sim/reports/visual_probe """ from __future__ import annotations import argparse import json import sys from pathlib import Path HERE = Path(__file__).resolve().parent sys.path.insert(0, str(HERE)) DIRECTIONS = ("along+", "along-", "across+", "across-") def make_probes(args, cfg): """Frozen teacher states at each height, as observations: unshifted and per shift direction.""" import mujoco import numpy as np from camera_effects import training_look from episode import EpisodeRunner from lerobot_export import Recorder, video_settings from piece_sets import sample_piece_set crf, pix_fmt = video_settings(cfg) runner = EpisodeRunner(cfg, sample_piece_set(np.random.default_rng([args.seed, 10**9]), cfg, "probe"), render=True) m, d, kin, w = runner.m, runner.d, runner.expert.kin, runner.w heights = sorted((float(h) for h in args.heights.split(",")), reverse=True) shift = args.shift_mm / 1000 probes = [] for i in range(args.scenes): ep_seed = int(np.random.default_rng([args.seed, i]).integers(2**62)) task = runner.setup(np.random.default_rng(ep_seed)) pick = runner.expert.plan_pick(d, task.target, np.random.default_rng(ep_seed)) rec = Recorder(cfg, None) rec.begin(runner, task, np.random.default_rng(ep_seed ^ 0x5EED)) axis = np.array([np.cos(pick.yaw), np.sin(pick.yaw), 0.0]) # jaw closing direction across = np.array([-axis[1], axis[0], 0.0]) vecs = {"along+": axis, "along-": -axis, "across+": across, "across-": -across} a = w.qadr[task.target] def observe(): return {"observation.images.overhead": training_look(rec.observe(runner, "overhead"), crf, pix_fmt), "observation.images.wrist": training_look(rec.observe(runner, "wrist"), crf, pix_fmt), "observation.state": runner.to_lerobot(d.qpos[runner.qadr])} k = 0 for q, g in zip(pick.traj.q, pick.traj.g): d.ctrl[:5], d.ctrl[5] = q, g for _ in range(runner.n_sub): mujoco.mj_step(m, d) above = (kin.pose(d.qpos[kin.qadr], pick.offset)[0][2] - pick.grasp_point[2]) * 1000 if above > heights[k]: continue mujoco.mj_forward(m, d) # render every observation from the same, current kinematics base = observe() shifted = {} saved = d.qpos[a:a + 7].copy() for name, v in vecs.items(): d.qpos[a:a + 2] = saved[:2] + v[:2] * shift mujoco.mj_forward(m, d) shifted[name] = observe() d.qpos[a:a + 7] = saved mujoco.mj_forward(m, d) probes.append(dict(scene=i, height=heights[k], actual_mm=round(float(above), 1), piece=w.kind[task.target], move=f"{task.source}-{task.dest.square}", offset=pick.offset, vecs=vecs, base=base, shifted=shifted)) k += 1 if k == len(heights): break runner.close() return probes, cfg["dataset"]["instruction"], m def run_policy(path, probes, instruction, noise_seeds, kin, shift): import numpy as np import torch from lerobot.utils.control_utils import predict_action from eval_policy import load_policy policy, pre, post, device = load_policy(path) def aim(obs, seed, offset): policy.reset() torch.manual_seed(seed) chunk = np.array([predict_action(dict(obs), policy, device, pre, post, use_amp=False, task=instruction, robot_type="so101_follower").squeeze().float().cpu().numpy() for _ in range(50)]) pts = np.array([kin.pose(np.radians(c[:5]), offset)[0] for c in chunk]) return pts[int(np.argmin(pts[:, 2]))] rows = [] for p in probes: ratios, perps, floors = [], [], [] for s in range(noise_seeds): seed = 1000 + s a0 = aim(p["base"], seed, p["offset"]) floors.append(float(np.linalg.norm((aim(p["base"], seed + 500, p["offset"]) - a0)[:2]) * 1000)) for name in DIRECTIONS: v = p["vecs"][name] dv = (aim(p["shifted"][name], seed, p["offset"]) - a0)[:2] ratios.append(float(dv @ v[:2]) / (np.linalg.norm(v[:2]) * shift)) perps.append(float(abs(dv @ np.array([-v[1], v[0]])) * 1000)) rows.append(dict(scene=p["scene"], height=p["height"], piece=p["piece"], move=p["move"], follow=float(np.mean(ratios)), sideways_mm=float(np.mean(perps)), floor_mm=float(np.mean(floors)))) del policy torch.cuda.empty_cache() return rows def main(): import numpy as np from episode import load_config ap = argparse.ArgumentParser(description=__doc__) ap.add_argument("--policy", action="append", required=True, help="NAME=path, repeatable") ap.add_argument("--scenes", type=int, default=20) ap.add_argument("--seed", type=int, default=9_200_003, help="probe scenes; not a test set") ap.add_argument("--heights", default="40,20", help="mm above the grasp point") ap.add_argument("--shift-mm", type=float, default=4.0) ap.add_argument("--noise", type=int, default=3, help="sampling-noise seeds per probe") ap.add_argument("--out", required=True) args = ap.parse_args() out = Path(args.out) out.mkdir(parents=True, exist_ok=True) cfg = load_config() probes, instruction, model = make_probes(args, cfg) from kinematics import Kinematics kin = Kinematics(model) results = {} for spec in args.policy: name, path = spec.split("=", 1) results[name] = run_policy(path, probes, instruction, args.noise, kin, args.shift_mm / 1000) print(name, "done", flush=True) def med(rows, key): return round(float(np.median([r[key] for r in rows])), 2) if rows else None heights = sorted({p["height"] for p in probes}, reverse=True) lines = ["# Visual-feedback probe", "", f"{args.scenes} scenes (seed {args.seed}); the teacher's hand frozen at {', '.join(f'{h:g}' for h in heights)} mm " f"above its grasp point; the target moved {args.shift_mm:g} mm along and across the jaw axis (4 directions) " f"with the arm unchanged; {args.noise} sampling-noise seeds per probe.", "", "Follow ratio: how far the predicted aim (lowest pinch point of the 50-step chunk) moves along the piece's " "shift, per mm of shift. 1 = follows the piece fully, 0 = ignores it. Floor: the aim's change from sampling " "noise alone (mm).", "", "| model | height | follow ratio, median (all) | pawns | knights | sideways drift mm | noise floor mm |", "|---|---|---|---|---|---|---|"] for name, rows in results.items(): for h in heights: r = [x for x in rows if x["height"] == h] lines.append(f"| {name} | {h:g} mm | {med(r, 'follow')} | {med([x for x in r if x['piece'] == 'pawn'], 'follow')} | " f"{med([x for x in r if x['piece'] == 'knight'], 'follow')} | {med(r, 'sideways_mm')} | {med(r, 'floor_mm')} |") text = "\n".join(lines) + "\n" (out / "visual_probe.md").write_text(text) (out / "visual_probe.json").write_text(json.dumps(dict(args=vars(args), results=results, probes=[dict(scene=p["scene"], height=p["height"], actual_mm=p["actual_mm"], piece=p["piece"], move=p["move"]) for p in probes]), indent=1)) print(text) if __name__ == "__main__": main()