| |
| """Extract ACT encoder features for four cable sizes drawn from two datasets. |
| |
| The 3.00 sq cable lives in a different dataset (cable3sizes_180ep) from the other |
| three (bluev2_cable170_330_270ep). Both were recorded with the same rig and the |
| same camera layout, and features come from one single policy, so they land in a |
| common space -- but the cross-dataset boundary is a real confound worth stating: |
| any session-level difference (lighting, gel state, day) rides along with the |
| 3.00 sq label. The ordering test is what guards against reading too much into it: |
| a session artefact has no reason to place 3.00 sq *between* two other sizes. |
| |
| Equal episode counts per size keep the t-SNE from being dominated by one class. |
| """ |
| import argparse |
| import numpy as np |
| import torch |
| from lerobot.datasets.lerobot_dataset import LeRobotDataset |
| from lerobot.policies.act.modeling_act import ACTPolicy |
|
|
| SOURCES = [ |
| ("Kaz55/dg5f_ur5e_bluev2_cable170_330_270ep", |
| {"cable 1.70 sq": "1.70 sq", "blue cable": "blue (2.6 mm)", "cable 3.30 sq": "3.30 sq"}), |
| ("Kaz55/dg5f_ur5e_cable3sizes_180ep", |
| {"cable 3.00 sq": "3.00 sq"}), |
| ] |
|
|
|
|
| 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("--policy-path", required=True) |
| ap.add_argument("--eps-per-size", type=int, default=60) |
| ap.add_argument("--frames-per-ep", type=int, default=15) |
| ap.add_argument("--device", default="cuda") |
| ap.add_argument("--out", default="outputs/pca/cache/cache_4sizes.npz") |
| args = ap.parse_args() |
|
|
| 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())) |
|
|
| rng = np.random.default_rng(0) |
| feats, label, eps, src = [], [], [], [] |
| for repo, wanted in SOURCES: |
| ds = LeRobotDataset(repo) |
| by = {} |
| for ep in range(ds.meta.total_episodes): |
| t = episode_task(ds, ep) |
| if t in wanted: |
| by.setdefault(t, []).append(ep) |
| for task, e in sorted(by.items()): |
| chosen = rng.choice(e, size=min(args.eps_per_size, len(e)), replace=False) |
| print(f" {repo.split('/')[-1]:34s} {wanted[task]:14s} {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 |
| for k in np.linspace(0, n - 1, min(args.frames_per_ep, n)).astype(int): |
| 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"]); label.append(wanted[task]) |
| eps.append(f"{repo}#{ep}"); src.append(repo.split("/")[-1]) |
| np.savez_compressed(args.out, feats=np.array(feats), label=np.array(label), |
| eps=np.array(eps), src=np.array(src)) |
| lab = np.array(label) |
| print(f"\nwrote {args.out}: {len(label)} frames") |
| for u in sorted(set(label)): |
| print(f" {u:14s} {int((lab == u).sum())}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
