| |
| """Does the ACT encoder representation actually carry cable identity? |
| |
| 2-D PCA is unsupervised: if cable type is not among the top variance directions |
| it stays invisible even when the information is present. So measure it directly |
| with a linear probe, then visualise with LDA (a supervised projection). |
| |
| Critical: the split is by EPISODE, not by frame. Frames inside one episode are |
| near-duplicates, so a frame-level split leaks the answer and any probe scores |
| ~100% regardless of what the model learned. Held-out episodes are the only |
| honest test. LDA is likewise fit on train episodes and plotted on test episodes, |
| otherwise a supervised projection manufactures clusters that do not generalise. |
| """ |
| import argparse |
| import numpy as np |
| import torch |
| import torch.nn.functional as F |
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| from sklearn.decomposition import PCA |
| from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA |
| from sklearn.linear_model import LogisticRegression |
| from sklearn.preprocessing import StandardScaler |
| from sklearn.pipeline import make_pipeline |
|
|
| from lerobot.datasets.lerobot_dataset import LeRobotDataset |
| from lerobot.policies.act.modeling_act import ACTPolicy |
|
|
| COLORS = {"blue cable": "#2B6CB0", "cable 1.70 sq": "#C05621", "cable 3.30 sq": "#2F855A"} |
|
|
|
|
| def episode_task(ds, ep): |
| t = ds.meta.episodes["tasks"][ep] |
| return t[0] if isinstance(t, (list, np.ndarray)) else str(t) |
|
|
|
|
| def collect(ds, policy, device, eps_per_task, frames_per_ep, seed=0): |
| captured = {} |
| policy.model.encoder.register_forward_hook( |
| lambda m, i, o: captured.__setitem__("enc", o.detach().mean(0).squeeze(0).float().cpu().numpy())) |
| by_task = {} |
| for ep in range(ds.meta.total_episodes): |
| by_task.setdefault(episode_task(ds, ep), []).append(ep) |
| rng = np.random.default_rng(seed) |
| feats, pix, labels, epids = [], [], [], [] |
| for task, eps in sorted(by_task.items()): |
| chosen = rng.choice(eps, size=min(eps_per_task, len(eps)), 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]) |
| for i in rng.choice(np.arange(lo, hi), size=min(frames_per_ep, hi - lo), replace=False): |
| item = ds[int(i)] |
| batch = {k: v.unsqueeze(0).to(device) for k, v in item.items() |
| if isinstance(v, torch.Tensor)} |
| batch["task"] = [task] |
| with torch.no_grad(): |
| policy.select_action(batch) |
| policy.reset() |
| feats.append(captured["enc"]) |
| gs = item["observation.images.gelsight1"].unsqueeze(0).float() |
| pix.append(F.adaptive_avg_pool2d(gs, 16).flatten().numpy()) |
| labels.append(task); epids.append(ep) |
| return np.array(feats), np.array(pix), np.array(labels), np.array(epids) |
|
|
|
|
| def probe(X, y, ep, seed=0): |
| """Logistic-regression accuracy on held-out EPISODES.""" |
| rng = np.random.default_rng(seed) |
| tr = np.zeros(len(y), bool) |
| for task in np.unique(y): |
| eps = np.unique(ep[y == task]) |
| keep = rng.choice(eps, size=int(len(eps) * 0.7), replace=False) |
| tr |= np.isin(ep, keep) |
| clf = make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000, C=1.0)) |
| clf.fit(X[tr], y[tr]) |
| return clf.score(X[~tr], y[~tr]), tr |
|
|
|
|
| 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=25) |
| ap.add_argument("--device", default="cuda") |
| ap.add_argument("--out", default="outputs/pca/cable_repr_analysis.png") |
| args = ap.parse_args() |
|
|
| ds = LeRobotDataset(args.repo_id) |
| policy = ACTPolicy.from_pretrained(args.policy_path).to(args.device).eval() |
| feats, pix, y, ep = collect(ds, policy, args.device, args.eps_per_task, args.frames_per_ep) |
| print(f"collected {len(y)} frames; encoder dim {feats.shape[1]}\n", flush=True) |
|
|
| chance = 1.0 / len(np.unique(y)) |
| results = {} |
| for name, X in (("ACT encoder", feats), ("GelSight pixels", pix)): |
| acc, tr = probe(X, y, ep) |
| results[name] = (X, acc, tr) |
| print(f" {name:16s} held-out episode accuracy: {acc:.1%} (chance {chance:.1%})", flush=True) |
|
|
| fig, axes = plt.subplots(1, 3, figsize=(16.5, 5.2)) |
| |
| for ax, name in zip(axes[:2], ("ACT encoder", "GelSight pixels")): |
| X, acc, tr = results[name] |
| lda = LDA(n_components=2).fit(X[tr], y[tr]) |
| xy = lda.transform(X[~tr]) |
| yt = y[~tr] |
| for task in sorted(set(y)): |
| m = yt == task |
| ax.scatter(xy[m, 0], xy[m, 1], s=9, alpha=0.55, edgecolors="none", |
| c=COLORS.get(task, "#666"), label=task) |
| ax.set_title(f"{name} — LDA (held-out episodes)\nprobe accuracy {acc:.1%} vs chance {chance:.1%}", |
| fontsize=10.5) |
| ax.set_xlabel("LD1"); ax.set_ylabel("LD2") |
| ax.spines[["top", "right"]].set_visible(False) |
| axes[0].legend(frameon=False, fontsize=9) |
|
|
| |
| X = results["ACT encoder"][0] |
| Xc = X - X.mean(0) |
| p = PCA(n_components=30).fit(Xc) |
| Z = p.transform(Xc) |
| sep = [] |
| for k in range(30): |
| groups = [Z[y == t, k] for t in sorted(set(y))] |
| between = np.var([g.mean() for g in groups]) |
| within = np.mean([g.var() for g in groups]) |
| sep.append(between / (within + 1e-12)) |
| axes[2].bar(range(1, 31), sep, color="#2B6CB0") |
| axes[2].set_title("ACT encoder — cable separability per PC\n(between-class / within-class variance)", |
| fontsize=10.5) |
| axes[2].set_xlabel("principal component"); axes[2].set_ylabel("separability ratio") |
| axes[2].spines[["top", "right"]].set_visible(False) |
|
|
| fig.suptitle("Does the ACT internal representation encode cable identity?", fontsize=13) |
| fig.tight_layout() |
| fig.savefig(args.out, dpi=150) |
| print(f"\nwrote {args.out}", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
