README: correct prompt template for cache key + unpack script

README.md

@@ -16,85 +16,115 @@ size_categories:
 Precomputed [UMT5-XXL](https://huggingface.co/google/umt5-xxl) text embeddings for the
 **1,039,891 unique task prompts** of the RoboTwin 2.0 3D dataset
 ([`flex-pi/robotwin_3d`](https://huggingface.co/datasets/flex-pi/robotwin_3d)), as consumed by
-Wan2.2-TI2V-5B / FastWAM.
+Wan2.2-TI2V-5B / FastWAM. Precomputing these costs substantial GPU time; this cache skips it.
 
-Precomputing these takes substantial GPU time; this cache lets you skip it.
+## ⚠️ The cache key is the *templated* prompt, not the raw task string
+
+Task strings from `meta/tasks.jsonl` are wrapped in a fixed template before encoding. Hashing the
+raw task string will **not** find anything.
+
+```python
+DEFAULT_PROMPT = "A video recorded from a robot's point of view executing the following instruction: {task}"
+key = hashlib.sha256(DEFAULT_PROMPT.format(task=task).encode("utf-8")).hexdigest()
+```
+
+Worked example:
+
+| | |
+|---|---|
+| task | `Lift the medium-sized green bottle ensuring it remains upright.` |
+| prompt | `A video recorded from a robot's point of view executing the following instruction: Lift the medium-sized green bottle ensuring it remains upright.` |
+| key | `83eacc02ca58bc93ecd638b3d2318494f442778e62a71a13d7987dfdb649fe18` |
 
 ## Contents
 
 | Path | Description |
 |---|---|
-| `shards/shard_NNNNN.safetensors` | 520 shards, 2,000 prompts each (last one 1,891), ~2.10 GB per shard |
-| `manifest.txt` | The 1,039,891 prompt hashes, **sorted**, one per line — line `i` is row `i % 2000` of shard `i // 2000` |
+| `shards/shard_NNNNN.safetensors` | 520 shards × 2,000 prompts (last one 1,891), ~2.10 GB each |
+| `manifest.txt` | All 1,039,891 keys, **sorted**, one per line — line `i` is row `i % 2000` of shard `i // 2000` |
 
-Each shard holds two tensors, row-aligned:
+Each shard holds two row-aligned tensors, plus `__metadata__["keys"]` (JSON list of that shard's
+keys in row order):
 
 | Tensor | Shape | Dtype |
 |---|---|---|
 | `contexts` | `[N, 128, 4096]` | `bfloat16` |
 | `masks` | `[N, 128]` | `bool` |
 
-The shard's `__metadata__["keys"]` is a JSON list of that shard's N hashes, in row order.
+`masks` marks valid tokens (mean 40.9 of 128). Values past the mask are **not** zero — they are raw
+T5 outputs. FastWAM zeroes them on load (`context[~mask] = 0`); do the same if your model does not
+apply the mask.
 
-The key for a prompt is `sha256(prompt.encode("utf-8")).hexdigest()`. Prompts themselves live in
-`meta/tasks.jsonl` of the main dataset.
+## Converting back to the per-file `.pt` layout
 
-`masks` marks the valid tokens (mean 40.9 of 128). Values beyond the mask are **not** zero — they are
-the raw T5 outputs. Zero them yourself if your model does not apply the mask.
-
-## Usage
-
-Random access without downloading everything — resolve one prompt to its shard, fetch only that shard:
+FastWAM reads a flat directory of `{key}.t5_len128.wan22ti2v5b.pt` files, each a `{"context", "mask"}`
+dict — **not** shards. This script reconstructs exactly that layout:
 
 ```python
-import bisect, hashlib, json
+# unpack_to_pt.py -- rebuild the flat .pt cache from the sharded release.
+#   python unpack_to_pt.py /path/to/text_embeds_cache/robotwin2.0_3d
+import json, os, sys
+from concurrent.futures import ThreadPoolExecutor
+
+import torch
 from huggingface_hub import hf_hub_download
 from safetensors import safe_open
 
-REPO = "flex-pi/robotwin_3d_text_embeds_cache"
-SHARD = 2000
+REPO, NSHARD = "flex-pi/robotwin_3d_text_embeds_cache", 520
+out, tmp = sys.argv[1], "/tmp/tec_shards"
+os.makedirs(out, exist_ok=True)
 
-manifest = hf_hub_download(REPO, "manifest.txt", repo_type="dataset")
-keys = open(manifest).read().split()          # sorted
-
-def get(prompt):
-    h = hashlib.sha256(prompt.encode("utf-8")).hexdigest()
-    i = bisect.bisect_left(keys, h)
-    if i == len(keys) or keys[i] != h:
-        raise KeyError(prompt)
-    path = hf_hub_download(REPO, f"shards/shard_{i // SHARD:05d}.safetensors", repo_type="dataset")
-    with safe_open(path, framework="pt") as f:
-        row = i % SHARD
-        return f.get_slice("contexts")[row], f.get_slice("masks")[row]
-
-context, mask = get("Lift the medium-sized green bottle ensuring it remains upright.")
-print(context.shape, context.dtype, int(mask.sum()))   # (128, 4096) torch.bfloat16 49
+def do(i):
+    # local_dir= gives a real file we can delete; the default cache would only
+    # yield a symlink, so removing it frees nothing.
+    p = hf_hub_download(REPO, f"shards/shard_{i:05d}.safetensors",
+                        repo_type="dataset", local_dir=tmp)
+    with safe_open(p, framework="pt") as f:
+        ks = json.loads(f.metadata()["keys"])
+        C, M = f.get_slice("contexts"), f.get_slice("masks")
+        for r, k in enumerate(ks):
+            dst = os.path.join(out, f"{k}.t5_len128.wan22ti2v5b.pt")
+            if not os.path.exists(dst):
+                torch.save({"context": C[r], "mask": M[r]}, dst)
+    os.remove(p)          # drop the 2 GB shard once expanded
+    print(f"shard {i:05d} -> {len(ks)} files", flush=True)
+
+with ThreadPoolExecutor(4) as ex:
+    list(ex.map(do, range(NSHARD)))
 ```
 
-`safe_open` + `get_slice` reads only the requested row, so this does not load the whole 2 GB shard
-into memory.
+Expands to ~1 TB across 1,039,891 files. Point `text_embedding_cache_dir` at `out` afterwards.
+
+To pull only part of it, pass a subset of shard indices — each shard is self-describing.
 
-### Rebuilding the original per-prompt `.pt` layout
+## Random access without unpacking
 
-Some code expects `{cache_dir}/{sha256}.t5_len128.wan22ti2v5b.pt` holding `{"context", "mask"}`:
+Resolve one prompt to its shard and read only that row; `get_slice` avoids loading the 2 GB shard:
 
 ```python
-import json, os, torch
+import bisect, hashlib, json
+from huggingface_hub import hf_hub_download
 from safetensors import safe_open
 
-def unpack(shard_path, out_dir):
-    os.makedirs(out_dir, exist_ok=True)
-    with safe_open(shard_path, framework="pt") as f:
-        ks = json.loads(f.metadata()["keys"])
-        C, M = f.get_slice("contexts"), f.get_slice("masks")
-        for r, k in enumerate(ks):
-            torch.save({"context": C[r], "mask": M[r]},
-                       os.path.join(out_dir, f"{k}.t5_len128.wan22ti2v5b.pt"))
-```
+REPO, SHARD = "flex-pi/robotwin_3d_text_embeds_cache", 2000
+TPL = "A video recorded from a robot's point of view executing the following instruction: {task}"
+keys = open(hf_hub_download(REPO, "manifest.txt", repo_type="dataset")).read().split()
 
-Note this expands to ~1 TB across 1,039,891 files.
+def get(task):
+    h = hashlib.sha256(TPL.format(task=task).encode("utf-8")).hexdigest()
+    i = bisect.bisect_left(keys, h)
+    if i == len(keys) or keys[i] != h:
+        raise KeyError(task)
+    p = hf_hub_download(REPO, f"shards/shard_{i // SHARD:05d}.safetensors", repo_type="dataset")
+    with safe_open(p, framework="pt") as f:
+        r = i % SHARD
+        return f.get_slice("contexts")[r], f.get_slice("masks")[r]
+
+ctx, mask = get("Lift the medium-sized green bottle ensuring it remains upright.")
+print(ctx.shape, ctx.dtype, int(mask.sum()))   # torch.Size([128, 4096]) torch.bfloat16 49
+```
 
 ## Provenance
 
-Repacked byte-exactly from the original per-prompt `.pt` cache — tensors are bit-identical, verified
-by round-trip comparison against the source files. Encoder: UMT5-XXL, context length 128.
+Repacked byte-exactly from the original per-prompt `.pt` cache; tensors are bit-identical, verified
+by round-trip comparison against the source files. Encoder UMT5-XXL, context length 128, bfloat16.