Add pooled features and targets (pooled/)

pooled/README.md

@@ -0,0 +1,45 @@
+# Pooled features and targets
+
+Two files derived from the `rollout.npz` files and the labels of this dataset, for training probes on the policy's token embeddings
+without loading the 114 MB rollouts. Both are keyed by the `dir` column of `manifest.csv` (for example `basket/ep000`), and step `t` of an
+episode's targets lines up with row `t` of its features and with policy step `t` of `rollout.npz`.
+
+## features.npz
+
+One float32 array of shape (policy steps, 6144) per episode: 399 arrays, one row per policy step (`n_policy` in `manifest.csv`).
+
+| columns | content |
+|---|---|
+| 0-2047 | mean over the 88 base-image tokens (`base_image` in `rollout.npz`) |
+| 2048-4095 | mean over the 88 wrist-image tokens (`wrist_image`) |
+| 4096-6143 | mean over the non-padded language tokens (`language`, the tokens where `language_mask` is true; 4 of 200 per step here) |
+
+The tokens are stored as float16 in `rollout.npz` and averaged in float32. `pool_features.py` is the code that produced the file; run on
+`basket/ep000` it reproduces the stored array exactly.
+
+## targets.npz
+
+Targets for the auxiliary heads of failure probes, built from the labels of this dataset (`labels.json`).
+
+| key | shape, type | content |
+|---|---|---|
+| `phrases` | (896,) str | sorted unique phrases of the semantic timelines (`semantic_timeline` in `labels.json`) of all 399 episodes |
+| `phrase_embeddings` | (896, 512) float32 | L2-normalised CLIP ViT-B/32 (`openai/clip-vit-base-patch32`) text features of the phrases |
+| `mode_names` | (10,) str | the failure-mode classes: `wrong_object`, `stuck_or_no_progress`, `wrong_target`, `object_displacement`, `placement_or_insertion_failure`, `grasp_failure`, `open_close_failure`, `press_failure`, `other`, `timeout_or_insufficient_progress` |
+| `phrase_ids/<dir>` | (policy steps,) int32 | for each policy step, the index into `phrases` of the timeline segment that covers it; -1 where there is none |
+| `mode/<dir>` | scalar int8 | index into `mode_names` (`fail_mode` of `labels.npz`); present for the 254 failed episodes only |
+
+How the phrase of a step is chosen: it is the phrase of the timeline segment whose policy-step range covers the step (a later segment overwrites a
+step shared with the previous one); steps after a segment that no segment covers repeat the previous step's phrase; steps before the first segment
+are -1. The failure modes are the labeller's output (see `LABELS.md`: Gemini, not individually verified), and only seven of the ten classes occur.
+
+```python
+import numpy as np
+f, z = np.load("features.npz"), np.load("targets.npz")
+x = f[dir]                                  # (steps, 6144), dir such as "basket/ep000"
+ids = z["phrase_ids/" + dir]                # (steps,)
+clip_target = z["phrase_embeddings"][ids]   # (steps, 512); rows where ids < 0 have no target
+mode = z["mode_names"][z["mode/" + dir]] if "mode/" + dir in z.files else None   # failed episodes only
+```
+
+License: the same as the rest of this dataset.

pooled/features.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:401a47d01ca4833253857083b44266c470287f1ad4beb04e4b1060f08e083519
+size 896097570

pooled/pool_features.py

@@ -0,0 +1,39 @@
+"""How pooled/features.npz was made: one (policy steps, 6144) float32 array per episode, pooled from its rollout.npz.
+
+    python pool_features.py <dataset folder with manifest.csv and <dir>/rollout.npz> features.npz
+
+Columns: [0:2048] mean over the base-image tokens, [2048:4096] mean over the wrist-image tokens,
+[4096:6144] mean over the non-padded language tokens (language_mask), all averaged in float32.
+"""
+
+import csv
+import sys
+from pathlib import Path
+
+import numpy as np
+
+
+def pool_rollout(path: Path) -> np.ndarray:
+    """(n_policy, 6144) float32 from one rollout.npz."""
+    with np.load(path) as z:
+        base = z["base_image"].astype(np.float32).mean(axis=1)  # (steps, 88, 2048) -> (steps, 2048)
+        wrist = z["wrist_image"].astype(np.float32).mean(axis=1)
+        mask = z["language_mask"].astype(np.float32)  # (steps, 200), True for real tokens
+        language = (z["language"].astype(np.float32) * mask[..., None]).sum(axis=1) / np.maximum(mask.sum(axis=1, keepdims=True), 1.0)
+    return np.concatenate([base, wrist, language], axis=1).astype(np.float32)
+
+
+def main(root: str, out: str) -> None:
+    with open(Path(root) / "manifest.csv", newline="") as f:
+        rows = list(csv.DictReader(f))
+    arrays = {}
+    for r in rows:
+        x = pool_rollout(Path(root) / r["dir"] / "rollout.npz")
+        assert x.shape == (int(r["n_policy"]), 6144), (r["dir"], x.shape)  # one row per policy step
+        arrays[r["dir"]] = x
+    np.savez(out, **arrays)  # keys are the `dir` column of manifest.csv
+    print(f"wrote {len(arrays)} episodes to {out}")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1], sys.argv[2])

pooled/targets.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f48398f44df421ccddd288e2742112340b8ac7bb4532cb7117b5cf5deae81896
+size 2332318