code: trajectory logging, te_weights grid, chunk profile

code/scripts/chunk_eval.py

@@ -52,10 +52,13 @@ class Condition:
     k: int | None = None  # actions executed per prediction in "replan" mode
     delay: int = 0  # observation latency in control steps
     displacement_cm: float = 0.0
+    te_coeff: float = 0.01  # temporal-ensembling weight exp(-c * i), i = 0 for the oldest prediction (ACT's default)
 
     @property
     def name(self) -> str:
         mode = f"replan{self.k}" if self.mode == "replan" else self.mode
+        if self.mode == "te" and self.te_coeff != 0.01:
+            mode = f"te{self.te_coeff:g}"  # e.g. te0, te-0.05; the default keeps the plain "te" name
         return f"{mode}_d{self.delay:02d}_m{self.displacement_cm:g}"
 
 
@@ -82,6 +85,11 @@ def build_grid(name: str, modes: list[tuple[str, int | None]] | None = None) ->
         delay_sweep = [Condition(mode, k, delay=d) for mode, k in modes for d in DELAYS]
         displacement_sweep = [Condition(mode, k, displacement_cm=m) for mode, k in modes for m in DISPLACEMENTS_CM]
         return delay_sweep + displacement_sweep
+    if name == "te_weights":
+        # Does favoring recent predictions let temporal ensembling react to a moved cube, and at
+        # what latency cost? The default (0.01) runs are in the core grid.
+        return [Condition("te", delay=d, displacement_cm=m, te_coeff=c)
+                for c in (0.0, -0.05) for d, m in ((0, 0), (0, 6), (20, 0))]
     raise ValueError(f"unknown grid {name!r}")
 
 
@@ -175,10 +183,11 @@ class CubeDisplacement(gym.Wrapper):
     """
 
     def __init__(self, env: gym.Env, displacement_m: float, window: tuple[int, int] = DISPLACEMENT_WINDOW,
-                 seed_offset: int = 10_000):
+                 seed_offset: int = 10_000, log_steps: int = 0):
         super().__init__(env)
         self.displacement_m = displacement_m
         self.window = window
+        self.log_steps = log_steps  # log right-arm joints and gripper-cube distance for the first N steps
         self.seed_offset = seed_offset
         self.records: list[dict] = []
         self._episode: dict | None = None
@@ -187,6 +196,13 @@ class CubeDisplacement(gym.Wrapper):
     def _physics(self):
         return self.env.unwrapped._env.physics
 
+    def _log_row(self) -> list[float]:
+        physics = self._physics()
+        grip = physics.named.data.xpos["vx300s_right/gripper_link"]
+        box = physics.named.data.xpos["box"]
+        right_arm = physics.data.qpos[8:14]  # vx300s_right waist ... wrist_rotate
+        return [self._t, *np.round(right_arm, 5).tolist(), round(float(np.linalg.norm(grip - box)), 5)]
+
     def _cube_xy(self) -> np.ndarray:
         return self._physics().data.qpos[-7:-5].copy()  # the cube's free joint is the last 7 qpos
 
@@ -230,6 +246,8 @@ class CubeDisplacement(gym.Wrapper):
             "reward_before_move": None,
             "first_step_at_reward": {},
         }
+        if self.log_steps:
+            self._episode["trajectory"] = [self._log_row()]  # rows: step, 6 right-arm joints, gripper-cube distance
         self.records.append(self._episode)
         return obs, info
 
@@ -247,6 +265,8 @@ class CubeDisplacement(gym.Wrapper):
         if ep is not None:
             for level in range(1, int(reward) + 1):
                 ep["first_step_at_reward"].setdefault(str(level), self._t)
+            if self.log_steps and self._t <= self.log_steps and not (terminated or truncated):
+                ep["trajectory"].append(self._log_row())
         return obs, reward, terminated, truncated, info
 
 
@@ -302,8 +322,9 @@ def run_task(task: dict) -> dict:
     cond = Condition(**task["condition"])
     env_cfg, policy, preprocessor, postprocessor, env_pre, env_post = _load(task["checkpoint"], task["device"])
     vec = make_env(env_cfg, n_envs=task["n_envs"], use_async_envs=False)[env_cfg.type][0]
-    vec.envs = [CubeDisplacement(e, cond.displacement_cm / 100.0, window=tuple(task['window'])) for e in vec.envs]
-    executor = ChunkExecutor(policy, cond.mode, delay=cond.delay, k=cond.k)
+    vec.envs = [CubeDisplacement(e, cond.displacement_cm / 100.0, window=tuple(task['window']),
+                                 log_steps=task.get('log_steps', 0)) for e in vec.envs]
+    executor = ChunkExecutor(policy, cond.mode, delay=cond.delay, k=cond.k, te_coeff=cond.te_coeff)
     videos_dir = Path(task["out_path"]).with_suffix("") if task["n_videos"] else None
 
     start = time.time()
@@ -375,7 +396,7 @@ def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("--checkpoint", required=True, help="local pretrained_model directory")
     parser.add_argument("--checkpoint-label", default=None, help="name recorded in the results")
-    parser.add_argument("--grid", choices=("validation", "core"), required=True)
+    parser.add_argument("--grid", choices=("validation", "core", "te_weights"), required=True)
     parser.add_argument("--only", nargs="*", default=None, help="run only these condition names from the grid")
     parser.add_argument("--modes", nargs="*", default=None, help="execution modes, e.g. full replan50 replan25 replan10 te")
     parser.add_argument("--window", default=f"{DISPLACEMENT_WINDOW[0]}:{DISPLACEMENT_WINDOW[1]}",
@@ -386,6 +407,8 @@ def main() -> None:
     parser.add_argument("--workers", type=int, default=min(8, os.cpu_count() or 1))
     parser.add_argument("--device", default="cuda")
     parser.add_argument("--videos-per-condition", type=int, default=0)
+    parser.add_argument("--log-trajectory", type=int, default=0, metavar="N",
+                        help="log right-arm joints and gripper-cube distance for the first N steps of each episode")
     parser.add_argument("--deterministic", action=argparse.BooleanOptionalAction, default=True,
                         help="deterministic GPU kernels so reruns are identical (default on; --no-deterministic matches lerobot-eval)")
     parser.add_argument("--out", required=True, type=Path)
@@ -437,6 +460,7 @@ def main() -> None:
                     "n_videos": args.videos_per_condition if i == 0 else 0,
                     "deterministic": args.deterministic,
                     "window": list(window),
+                    "log_steps": args.log_trajectory,
                     "out_path": str(out_path),
                 }
             )

code/scripts/chunk_profile.py

@@ -0,0 +1,92 @@
+"""How fast does an ACT chunk move, as a function of the index inside the chunk?
+
+The policy predicts a chunk for demonstration frames of the approach phase. For every chunk
+index i we measure the right-arm step size ||a[i+1] - a[i]|| (joint targets, radians per control
+step) and average it over frames. For comparison we also measure the demonstrator's own step size
+at the same frames.
+
+This tests the replan-10 hypothesis: if the first actions of each chunk are slow, a policy that
+only ever executes indices 0-9 moves slowly. Under latency d the executed slice starts at index d,
+which would explain why latency helps replan 10.
+
+Usage (small; no simulator):
+    python scripts/chunk_profile.py --checkpoint PATH --label NAME --out results/analysis/profile_NAME.json
+"""
+
+import argparse
+import glob
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+
+RIGHT_ARM = slice(7, 13)  # ALOHA action/state layout: left arm 0-5, left gripper 6, right arm 7-12, right gripper 13
+DATASET = "lerobot/aloha_sim_transfer_cube_human"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--checkpoint", required=True)
+    parser.add_argument("--label", required=True)
+    parser.add_argument("--device", default="mps" if torch.backends.mps.is_available() else "cuda")
+    parser.add_argument("--frames-per-episode", type=int, default=6, help="frames sampled from steps 0-150 of each episode")
+    parser.add_argument("--out", type=Path, required=True)
+    args = parser.parse_args()
+
+    from lerobot.configs.policies import PreTrainedConfig
+    from lerobot.datasets.lerobot_dataset import LeRobotDataset
+    from lerobot.envs.configs import AlohaEnv
+    from lerobot.policies import make_policy, make_pre_post_processors
+
+    policy_cfg = PreTrainedConfig.from_pretrained(args.checkpoint)
+    policy_cfg.pretrained_path = Path(args.checkpoint)
+    policy_cfg.device = args.device
+    policy = make_policy(cfg=policy_cfg, env_cfg=AlohaEnv(task="AlohaTransferCube-v0"), rename_map={})
+    policy.eval()
+    pre, post = make_pre_post_processors(policy_cfg=policy_cfg, pretrained_path=args.checkpoint,
+                                         preprocessor_overrides={"device_processor": {"device": args.device},
+                                                                 "rename_observations_processor": {"rename_map": {}}})
+
+    ds = LeRobotDataset(DATASET, video_backend="pyav")
+    # Demonstration actions per episode, straight from the parquet files.
+    root = Path(ds.root)
+    actions = pd.concat(pd.read_parquet(f) for f in sorted(glob.glob(str(root / "data" / "**" / "*.parquet"), recursive=True)))
+    demo = {ep: np.stack(g.sort_values("frame_index")["action"].to_numpy()) for ep, g in actions.groupby("episode_index")}
+    starts = {ep: int(g["index"].min()) for ep, g in actions.groupby("episode_index")}
+
+    rng = np.random.default_rng(0)
+    chunk_steps, demo_steps, first_offsets = [], [], []
+    for ep in sorted(demo):
+        for t in sorted(rng.choice(np.arange(0, 150), size=args.frames_per_episode, replace=False)):
+            item = ds[starts[ep] + int(t)]
+            batch = {"observation.images.top": item["observation.images.top"].unsqueeze(0),
+                     "observation.state": item["observation.state"].unsqueeze(0), "task": [""]}
+            with torch.no_grad():
+                chunk = policy.predict_action_chunk(pre(batch))  # (1, H, 14), normalized
+                chunk = post(chunk).cpu().numpy()[0]  # joint targets
+            arm = chunk[:, RIGHT_ARM]
+            chunk_steps.append(np.linalg.norm(np.diff(arm, axis=0), axis=1))  # (H-1,)
+            first_offsets.append(float(np.linalg.norm(arm[0] - item["observation.state"].numpy()[RIGHT_ARM])))
+            demo_arm = demo[ep][int(t):int(t) + 12, RIGHT_ARM]
+            demo_steps.append(float(np.linalg.norm(np.diff(demo_arm, axis=0), axis=1).mean()))
+
+    profile = np.mean(chunk_steps, axis=0)
+    result = {
+        "label": args.label,
+        "n_frames": len(chunk_steps),
+        "step_size_by_index": profile.round(6).tolist(),
+        "mean_step_first_10": float(profile[:10].mean()),
+        "mean_step_10_to_40": float(profile[10:40].mean()),
+        "demo_mean_step_next_10": float(np.mean(demo_steps)),
+        "mean_offset_first_action_to_state": float(np.mean(first_offsets)),
+    }
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(json.dumps(result, indent=1))
+    print({k: v for k, v in result.items() if k != "step_size_by_index"})
+    print("step size at indices 0, 2, 5, 10, 20, 40, 80:", [round(float(profile[i]), 4) for i in (0, 2, 5, 10, 20, 40, 80)])
+
+
+if __name__ == "__main__":
+    main()

code/scripts/jobs/run_grid.sh

@@ -6,7 +6,7 @@
 #            "hub:<repo>@<revision>:<subfolder>" (e.g. hub:FTG64/act_aloha_transfer_cube@025000:checkpoints/025000/pretrained_model)
 #   LABEL    short name recorded in the results and used for the output folder (results/<RUN>)
 #   RUN      output folder name inside results/ of the dataset repo
-#   GRID     validation | core            ONLY   optional space-separated condition names
+#   GRID     validation | core | te_weights   ONLY   optional space-separated condition names
 #   SEEDS    start:stop                   WORKERS / NENVS / BLOCK   parallelism settings
 #   VIDEOS   videos per condition (default 0)
 #   MODES    optional space-separated modes (default: chunk_eval.py's MODES), e.g. "full replan50 replan25 replan10 te"
@@ -23,7 +23,7 @@ REPO=FTG64/act-chunking-study
 STUDY=/tmp/study
 : "${CKPT:?}" "${LABEL:?}" "${RUN:?}" "${GRID:?}" "${SEEDS:?}"
 WORKERS=${WORKERS:-7}; NENVS=${NENVS:-5}; BLOCK=${BLOCK:-25}; VIDEOS=${VIDEOS:-0}; ONLY=${ONLY:-}
-MODES=${MODES:-}; WINDOW=${WINDOW:-}; DETERMINISTIC=${DETERMINISTIC:-0}
+MODES=${MODES:-}; WINDOW=${WINDOW:-}; DETERMINISTIC=${DETERMINISTIC:-0}; LOGTRAJ=${LOGTRAJ:-0}
 
 (while true; do echo "[mem $(date +%H:%M:%S)] $(free -m | awk '/Mem:/ {print $3 " MB used of " $2 " MB"}')"; sleep 60; done) &
 MEM_PID=$!
@@ -46,6 +46,7 @@ if [ -n "$ONLY" ]; then extra+=(--only $ONLY); fi
 if [ -n "$MODES" ]; then extra+=(--modes $MODES); fi
 if [ -n "$WINDOW" ]; then extra+=(--window "$WINDOW"); fi
 if [ "$DETERMINISTIC" = "1" ]; then extra+=(--deterministic); fi
+if [ "$LOGTRAJ" != "0" ]; then extra+=(--log-trajectory "$LOGTRAJ"); fi
 python "$STUDY/code/scripts/chunk_eval.py" --checkpoint "$POLICY" --checkpoint-label "$LABEL" --grid "$GRID" \
   "${extra[@]}" --seeds "$SEEDS" --block "$BLOCK" --n-envs "$NENVS" --workers "$WORKERS" \
   --videos-per-condition "$VIDEOS" --out "/tmp/$RUN" --hub-repo "$REPO"

code/scripts/summarize.py

@@ -222,13 +222,23 @@ def sweep_figure(by_ckpt: dict[str, list[dict]], kind: str, path: Path) -> None:
 
 
 def checkpoint_figure(ckpt_runs: list[Path], training_log: Path | None, path: Path) -> dict:
-    points = []
+    import re
+
+    runs = {}
     for run in ckpt_runs:
         eps = [e for e in load_run(run) if e["mode_name"] == "full" and e["delay"] == 0 and e["displacement_cm"] == 0]
         if eps:
-            points.append((eps[0]["checkpoint"], cell(eps)))
-    ours = sorted((int(name.rsplit("_", 1)[-1]), c) for name, c in points if name.startswith("ours"))
-    reference = [(name, c) for name, c in points if not name.startswith("ours")]
+            runs[eps[0]["checkpoint"]] = eps
+    ours_runs = {int(m.group(1)): eps for name, eps in runs.items() if (m := re.search(r"ours_(\d+)", name))}
+    ours = sorted((step, cell(eps)) for step, eps in ours_runs.items())
+    ours_seeds = {e["seed"] for eps in ours_runs.values() for e in eps}
+    # Reference checkpoints are scored on the same seeds as our checkpoints so the comparison is paired.
+    reference = []
+    for name, eps in runs.items():
+        if re.search(r"ours_\d+", name):
+            continue
+        shared = [e for e in eps if e["seed"] in ours_seeds] or eps
+        reference.append((name.replace("ckpt_", ""), cell(shared)))
     n_panels = 1 + (training_log is not None)
     fig, axes = plt.subplots(1, n_panels, figsize=(5.2 * n_panels, 3.6), squeeze=False)
     fig.patch.set_facecolor(SURFACE)
@@ -253,13 +263,14 @@ def checkpoint_figure(ckpt_runs: list[Path], training_log: Path | None, path: Pa
         err = np.array([[100 * (c["rate"] - c["lo"]) for _, c in ours], [100 * (c["hi"] - c["rate"]) for _, c in ours]])
         ax.errorbar(x, y, yerr=err, color="#2a78d6", linewidth=2, elinewidth=1, capsize=0, marker="o", markersize=7,
                     markeredgecolor=SURFACE, markeredgewidth=1.5, zorder=3)
-        for (s, c), xi, yi in zip(ours, x, y):
-            ax.annotate(f"{100 * c['rate']:.0f}%", (xi, yi), textcoords="offset points", xytext=(0, 9),
-                        ha="center", fontsize=9, color=TEXT_2)
+        for i, ((s, c), xi, yi) in enumerate(zip(ours, x, y)):  # beside the point, clear of the CI bar
+            last = i == len(ours) - 1
+            ax.annotate(f"{100 * c['rate']:.1f}%", (xi, yi), textcoords="offset points", xytext=(-8 if last else 8, -2),
+                        ha="right" if last else "left", va="top", fontsize=9, color=TEXT_2)
     for name, c in reference:
         ax.axhline(100 * c["rate"], color=MUTED, linewidth=1)
-        ax.text(ax.get_xlim()[0] if not ours else x.min(), 100 * c["rate"] + 1.5,
-                f"{name}: {100 * c['rate']:.1f}% (n={c['n']})", fontsize=9, color=TEXT_2)
+        ax.text(x.min() if ours else 0, 100 * c["rate"] - 2, f"{name} checkpoint, same seeds: {100 * c['rate']:.1f}%",
+                fontsize=9, color=TEXT_2, va="top")
     ax.set_ylim(0, 100)
     ax.set_xlabel("training step (thousands)")
     ax.set_ylabel("success rate (%)")