| |
| """Extract ACT encoder features with each frame's position inside its episode. |
| |
| Enables splitting an episode into phases. The interesting contrast for this task: |
| during REACHING the gripper has not touched anything, so any cable discrimination |
| must come from vision; during SORTING the cable is in hand, so tactile is |
| available too. If cable identity is decodable during reaching just as well as |
| during sorting, touch is not what carries it. |
| |
| Frames are sampled uniformly across each episode (not randomly) so every phase is |
| covered evenly. |
| """ |
| import argparse |
| import numpy as np |
| import torch |
| import torch.nn.functional as F |
| from lerobot.datasets.lerobot_dataset import LeRobotDataset |
| from lerobot.policies.act.modeling_act import ACTPolicy |
|
|
|
|
| def episode_task(ds, ep): |
| t = ds.meta.episodes["tasks"][ep] |
| return t[0] if isinstance(t, (list, np.ndarray)) else str(t) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--repo-id", default="Kaz55/dg5f_ur5e_bluev2_cable170_330_270ep") |
| ap.add_argument("--policy-path", required=True) |
| ap.add_argument("--eps-per-task", type=int, default=30) |
| ap.add_argument("--frames-per-ep", type=int, default=40) |
| ap.add_argument("--device", default="cuda") |
| ap.add_argument("--out", default="outputs/pca/cache_cable_phase.npz") |
| args = ap.parse_args() |
|
|
| ds = LeRobotDataset(args.repo_id) |
| policy = ACTPolicy.from_pretrained(args.policy_path).to(args.device).eval() |
| cap = {} |
| policy.model.encoder.register_forward_hook( |
| lambda m, i, o: cap.__setitem__("e", o.detach().mean(0).squeeze(0).float().cpu().numpy())) |
|
|
| by = {} |
| for ep in range(ds.meta.total_episodes): |
| by.setdefault(episode_task(ds, ep), []).append(ep) |
|
|
| rng = np.random.default_rng(0) |
| feats, y, eps, tpos, tsec = [], [], [], [], [] |
| fps = ds.meta.fps |
| for task, e in sorted(by.items()): |
| chosen = rng.choice(e, size=min(args.eps_per_task, len(e)), replace=False) |
| print(f" {task}: {len(chosen)} episodes", flush=True) |
| for ep in chosen: |
| lo = int(ds.meta.episodes["dataset_from_index"][ep]) |
| hi = int(ds.meta.episodes["dataset_to_index"][ep]) |
| n = hi - lo |
| |
| idxs = np.linspace(0, n - 1, min(args.frames_per_ep, n)).astype(int) |
| for k in idxs: |
| item = ds[int(lo + k)] |
| b = {kk: v.unsqueeze(0).to(args.device) for kk, v in item.items() |
| if isinstance(v, torch.Tensor)} |
| b["task"] = [task] |
| with torch.no_grad(): |
| policy.select_action(b) |
| policy.reset() |
| feats.append(cap["e"]); y.append(task); eps.append(ep) |
| tpos.append(k / max(n - 1, 1)) |
| tsec.append(k / fps) |
| np.savez_compressed(args.out, feats=np.array(feats), y=np.array(y), |
| eps=np.array(eps), tpos=np.array(tpos), tsec=np.array(tsec)) |
| print(f"\nwrote {args.out}: {len(y)} frames, fps={fps}", flush=True) |
| print(f" episode length: {np.mean([int(ds.meta.episodes['dataset_to_index'][e]) - int(ds.meta.episodes['dataset_from_index'][e]) for e in range(ds.meta.total_episodes)]) / fps:.1f} s average", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
