README.md

metadata

license: apache-2.0
task_categories:
  - robotics
tags:
  - robotics
  - text-embeddings
  - t5
  - wan2.2
size_categories:
  - 1M<n<10M

RoboTwin 2.0 3D — T5 Text Embedding Cache

Precomputed UMT5-XXL text embeddings for the 1,039,891 unique task prompts of the RoboTwin 2.0 3D dataset (flex-pi/robotwin_3d), as consumed by Wan2.2-TI2V-5B. Precomputing these costs substantial GPU time; this cache skips it.

Cache key

Task strings from meta/tasks.jsonl are wrapped in a fixed template before encoding, and the cache key is the sha256 of that templated prompt:

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()

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 (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 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

masks marks valid tokens (mean 40.9 of 128). Values past the mask are raw T5 outputs rather than zeros. Zero them on load (context[~mask] = 0) if your model does not apply the mask.

Converting back to the per-file .pt layout

The training pipeline reads a flat directory of {key}.t5_len128.wan22ti2v5b.pt files, each a {"context", "mask"} dict, rather than shards. This script reconstructs that layout:

# 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, NSHARD = "flex-pi/robotwin_3d_text_embeds_cache", 520
out, tmp = sys.argv[1], "/tmp/tec_shards"
os.makedirs(out, exist_ok=True)

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)))

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.

Random access without unpacking

Resolve one prompt to its shard and read only that row; get_slice avoids loading the 2 GB shard:

import bisect, hashlib, json
from huggingface_hub import hf_hub_download
from safetensors import safe_open

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()

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, bfloat16.