Squash history (QC grids added; final preview state)

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,42 @@
+Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC-BY-NC-ND-4.0)
+
+Copyright (c) 2026 neil
+
+This dataset is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives
+4.0 International License. To view a copy of this license, visit
+
+    https://creativecommons.org/licenses/by-nc-nd/4.0/
+
+or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
+
+You are free to:
+  - Share — copy and redistribute the material in any medium or format
+
+Under the following terms:
+  - Attribution — You must give appropriate credit, provide a link to the
+    license, and indicate if changes were made. You may do so in any reasonable
+    manner, but not in any way that suggests the licensor endorses you or your use.
+  - NonCommercial — You may not use the material for commercial purposes.
+  - NoDerivatives — If you remix, transform, or build upon the material, you may
+    not distribute the modified material.
+  - No additional restrictions — You may not apply legal terms or technological
+    measures that legally restrict others from doing anything the license permits.
+
+------------------------------------------------------------------------------
+SOURCE-MATERIAL NOTICE
+------------------------------------------------------------------------------
+This dataset is derived from videos published on https://www.ted.com which are
+themselves licensed under CC-BY-NC-ND 4.0 by TED Conferences, LLC. The tracking
+parameters, JPG frames, and alpha mattes in this dataset are derivative works of
+those videos. This dataset matches the upstream license (CC-BY-NC-ND 4.0) and
+inherits the same restrictions on the source material:
+
+  - You may NOT use this dataset for commercial purposes.
+  - You MUST credit "TED" as the source of the original video content in any
+    publication, demo, or derivative work.
+  - You SHOULD link back to the original TED talk page for any individual
+    speaker whose data you use in a publication, demo, or derivative work.
+  - You may NOT redistribute modified or derivative versions of this dataset.
+
+This notice does not constitute legal advice. If your intended use is unclear,
+consult a lawyer or contact TED directly.

README.md

@@ -0,0 +1,172 @@
+---
+license: cc-by-nc-nd-4.0
+language:
+- en
+pretty_name: TEDWB1k-preview
+size_categories:
+- 1K<n<10K
+task_categories:
+- other
+tags:
+- 3d-human
+- smpl-x
+- flame
+- avatar
+- gaussian-splatting
+- video
+- motion-capture
+- ted
+- preview
+configs:
+- config_name: subjects
+  data_files:
+  - split: train
+    path: metadata/subjects_train.parquet
+  - split: train_subset_x1
+    path: metadata/subjects_train_subset_x1.parquet
+  - split: train_subset_x12
+    path: metadata/subjects_train_subset_x12.parquet
+  - split: train_val
+    path: metadata/subjects_train_val.parquet
+  - split: test
+    path: metadata/subjects_test.parquet
+---
+
+# TEDWB1k-preview
+
+> ⚠️ **This is the public preview of [`initialneil/TEDWB1k`](https://huggingface.co/datasets/initialneil/TEDWB1k).**
+> The full dataset (1,431 TED-talk speakers, ~120 GB) is hosted at the gated repo above.
+> This preview repo exists so the HuggingFace **Dataset Viewer** can render the
+> per-subject thumbnails and tracking grids without going through the gated EULA flow.
+>
+> If you want the **full training data** (frames + mattes + per-frame SMPL-X / FLAME
+> tracking for all 1,431 subjects), go to the gated main repo, accept the agreement,
+> and use [`load_tedwb1k.py`](https://huggingface.co/datasets/initialneil/TEDWB1k/blob/main/load_tedwb1k.py).
+
+## What's in this preview
+
+This repo is **schema-identical** to the gated main repo, but the heavy
+per-subject data (`frames.tar`, `mattes.tar`, tracking pickles) is included
+**only for the 12 subjects in `train_subset_x12`** as a working sample. For
+the other 1,419 subjects, only the metadata and QC visualizations are
+present (so the viewer table still lists all 1,431 entries).
+
+| What | Subjects | Size |
+|---|---:|---:|
+| Per-split parquets with embedded source-frame thumbnails | 1,431 | ~210 MB |
+| `metadata/previews/<id>.jpg` (1024×1024 source frames) | 1,431 | ~210 MB |
+| `metadata/ehm/<id>.jpg` (full-res SMPL-X overlay grids) | 1,431 | ~17.6 GB |
+| `metadata/flame/<id>.jpg` (full-res FLAME overlay grids) | 1,431 | ~8.0 GB |
+| `metadata/base/<id>.jpg` (full-res PIXIE+Sapiens grids) | 1,431 | ~5.2 GB |
+| **Per-subject heavy data** (frames.tar + mattes.tar + tracking) | **12** | ~540 MB |
+| **Total preview** | | **~32 GB** |
+
+The HF Dataset Viewer above renders 5 tabs (`train`, `train_subset_x1`,
+`train_subset_x12`, `train_val`, `test`) with one row per subject, the
+per-subject frame and shot counts, and a thumbnail of the first source
+frame. Each thumbnail is the actual `shots_images/<id>/<first_shot>/000000.jpg`
+that the tracker consumed.
+
+## Quick start
+
+If you only want to play with one of the 12 sample subjects (no agreement
+required):
+
+```bash
+pip install huggingface_hub
+
+python -c "
+from huggingface_hub import snapshot_download
+snapshot_download(
+    'initialneil/TEDWB1k-preview',
+    repo_type='dataset',
+    allow_patterns='subjects/-2Dj9M71JAc/*',
+    local_dir='./tedwb1k_x1',
+)
+"
+```
+
+That gives you tracking pickles + `frames.tar` + `mattes.tar` for one
+sample subject in a few seconds. To turn it into the 5-file bundle that
+[HolisticAvatar](https://github.com/initialneil/HolisticAvatar)'s
+`TrackedData` expects, use the same `load_tedwb1k.py` from the main repo:
+
+```bash
+wget https://huggingface.co/datasets/initialneil/TEDWB1k/raw/main/load_tedwb1k.py
+python load_tedwb1k.py --split train_subset_x1 --out ./tedwb1k_x1 \
+    --repo_id initialneil/TEDWB1k-preview
+```
+
+For the **full 1,361-subject training set**, request access at the
+[gated main repo](https://huggingface.co/datasets/initialneil/TEDWB1k).
+
+## Per-subject visualizations
+
+Each of the 1,431 subjects has 4 standalone visualization files under
+`metadata/`:
+
+- `metadata/previews/<id>.jpg` — clean 1024×1024 source frame (the first
+  frame of the first shot). Embedded in the parquet preview column too.
+- `metadata/ehm/<id>.jpg` — full-resolution SMPL-X overlay grid from the
+  final tracking stage (large vertical contact sheet, ~13 MB).
+- `metadata/flame/<id>.jpg` — FLAME overlay grid from the intermediate
+  face-fitting stage (~6 MB).
+- `metadata/base/<id>.jpg` — stage-1 PIXIE+Sapiens overlay grid (~4 MB).
+
+You can fetch any single subject's visualization with one
+`hf_hub_download` call:
+
+```python
+from huggingface_hub import hf_hub_download
+path = hf_hub_download(
+    'initialneil/TEDWB1k-preview',
+    'metadata/ehm/05jJodDVJRQ.jpg',
+    repo_type='dataset',
+)
+```
+
+## Splits
+
+Same as the main repo:
+
+| Split | Subjects | Notes |
+|---|---:|---|
+| `train_subset_x1` | 1 | tiny single-subject overfit (⊂ `train`) |
+| `train_subset_x12` | 12 | small overfit (⊂ `train`) — **the only subjects with downloadable heavy data in this preview** |
+| `train_val` | 20 | training monitor (⊂ `train`) |
+| `test` | 70 | identity-disjoint evaluation |
+| `train` | 1,361 | full training pool |
+| **total** | **1,431** | |
+
+`train` (1,361) and `test` (70) are identity-disjoint and together cover
+all 1,431 subjects. `train_subset_x1`, `train_subset_x12`, and `train_val`
+are subsets of `train`.
+
+## Why two repos?
+
+HuggingFace's Dataset Viewer cannot render tabs/thumbnails for **gated**
+datasets — the worker that computes split names runs without a user
+identity and can't satisfy the gating EULA. The full TEDWB1k is gated for
+TED-content compliance, so to keep the viewer working we mirror the
+metadata + a 12-subject sample to this public preview repo.
+
+For full discussion see this thread:
+<https://discuss.huggingface.co/t/after-gated-user-access-was-enabled-the-huggingface-not-showing-dataset-viewer/157333>
+
+## License
+
+[**CC-BY-NC-ND 4.0**](https://creativecommons.org/licenses/by-nc-nd/4.0/) —
+same as the main repo. Non-commercial research use only. Attribution
+required. **No derivatives** — you may not distribute modified or remixed
+versions of this dataset.
+
+The tracking parameters, JPG frames, and mattes are all derived works of
+TED talk videos that are themselves CC-BY-NC-ND on ted.com. This dataset
+matches the upstream license to remain compatible with TED's source
+restrictions.
+
+## Links
+
+- **Full gated dataset**: <https://huggingface.co/datasets/initialneil/TEDWB1k>
+- Tracking pipeline: <https://github.com/initialneil/HolisticTracker>
+- HolisticAvatar (downstream model): <https://github.com/initialneil/HolisticAvatar>

README_preview.md

@@ -0,0 +1,174 @@
+---
+license: cc-by-nc-nd-4.0
+language:
+- en
+pretty_name: TEDWB1k-preview
+size_categories:
+- 1K<n<10K
+task_categories:
+- other
+tags:
+- 3d-human
+- smpl-x
+- flame
+- avatar
+- gaussian-splatting
+- video
+- motion-capture
+- ted
+- preview
+configs:
+- config_name: subjects
+  data_files:
+  - split: train
+    path: metadata/subjects_train.parquet
+  - split: train_subset_x1
+    path: metadata/subjects_train_subset_x1.parquet
+  - split: train_subset_x12
+    path: metadata/subjects_train_subset_x12.parquet
+  - split: train_val
+    path: metadata/subjects_train_val.parquet
+  - split: test
+    path: metadata/subjects_test.parquet
+---
+
+# TEDWB1k-preview
+
+> ⚠️ **This is the public preview of [`initialneil/TEDWB1k`](https://huggingface.co/datasets/initialneil/TEDWB1k).**
+> The full dataset (1,431 TED-talk speakers, ~120 GB) is hosted at the gated repo above.
+> This preview repo exists so the HuggingFace **Dataset Viewer** can render the
+> per-subject thumbnails and tracking grids without going through the gated EULA flow.
+>
+> If you want the **full training data** (frames + mattes + per-frame SMPL-X / FLAME
+> tracking for all 1,431 subjects), go to the gated main repo, accept the agreement,
+> and use [`load_tedwb1k.py`](https://huggingface.co/datasets/initialneil/TEDWB1k/blob/main/load_tedwb1k.py).
+
+## What's in this preview
+
+This repo is **schema-identical** to the gated main repo, but it's a lightweight
+**catalog + sample** rather than a full mirror:
+
+| What | Subjects | Size |
+|---|---:|---:|
+| Per-split parquets with embedded source-frame thumbnails | 1,431 | ~210 MB |
+| `metadata/previews/<id>.jpg` (1024×1024 source frames) | 1,431 | ~210 MB |
+| **Per-subject heavy data** (frames.tar + mattes.tar + tracking) | **12** | ~540 MB |
+| **Total preview** | | **~1 GB** |
+
+The HF Dataset Viewer above renders 5 tabs (`train`, `train_subset_x1`,
+`train_subset_x12`, `train_val`, `test`) with one row per subject, the
+per-subject frame and shot counts, and a thumbnail of the first source
+frame (the actual `shots_images/<id>/<first_shot>/000000.jpg` that the
+tracker consumed).
+
+For full-resolution per-subject tracking visualizations
+(`metadata/ehm/<id>.jpg`, `metadata/flame/<id>.jpg`, `metadata/base/<id>.jpg`),
+go to the gated main repo — they're fetchable per-subject without downloading
+the heavy `frames.tar`/`mattes.tar`.
+
+## Quick start
+
+If you only want to play with one of the 12 sample subjects (no agreement
+required):
+
+```bash
+pip install huggingface_hub
+
+python -c "
+from huggingface_hub import snapshot_download
+snapshot_download(
+    'initialneil/TEDWB1k-preview',
+    repo_type='dataset',
+    allow_patterns='subjects/-2Dj9M71JAc/*',
+    local_dir='./tedwb1k_x1',
+)
+"
+```
+
+That gives you tracking pickles + `frames.tar` + `mattes.tar` for one
+sample subject in a few seconds. To turn it into the 5-file bundle that
+[HolisticAvatar](https://github.com/initialneil/HolisticAvatar)'s
+`TrackedData` expects, use the same `load_tedwb1k.py` from the main repo:
+
+```bash
+wget https://huggingface.co/datasets/initialneil/TEDWB1k/raw/main/load_tedwb1k.py
+python load_tedwb1k.py --split train_subset_x1 --out ./tedwb1k_x1 \
+    --repo_id initialneil/TEDWB1k-preview
+```
+
+For the **full 1,361-subject training set**, request access at the
+[gated main repo](https://huggingface.co/datasets/initialneil/TEDWB1k).
+
+## Per-subject visualizations
+
+In this preview, each of the 1,431 subjects has **one** standalone
+visualization file:
+
+- `metadata/previews/<id>.jpg` — clean 1024×1024 source frame (the first
+  frame of the first shot). Also embedded in the parquet `preview` column
+  so the HF Dataset Viewer renders it inline.
+
+For full-resolution **SMPL-X / FLAME / PIXIE+Sapiens overlay grids**, head
+to the gated main repo where each subject also has:
+
+- `metadata/ehm/<id>.jpg` — final SMPL-X overlay grid (~13 MB)
+- `metadata/flame/<id>.jpg` — intermediate FLAME overlay grid (~6 MB)
+- `metadata/base/<id>.jpg` — stage-1 PIXIE+Sapiens overlay grid (~4 MB)
+
+You can fetch any single subject's full-res visualization from the main
+repo (after accepting the gating EULA) with one `hf_hub_download` call:
+
+```python
+from huggingface_hub import hf_hub_download
+path = hf_hub_download(
+    'initialneil/TEDWB1k',
+    'metadata/ehm/05jJodDVJRQ.jpg',
+    repo_type='dataset',
+)
+```
+
+## Splits
+
+Same as the main repo:
+
+| Split | Subjects | Notes |
+|---|---:|---|
+| `train_subset_x1` | 1 | tiny single-subject overfit (⊂ `train`) |
+| `train_subset_x12` | 12 | small overfit (⊂ `train`) — **the only subjects with downloadable heavy data in this preview** |
+| `train_val` | 20 | training monitor (⊂ `train`) |
+| `test` | 70 | identity-disjoint evaluation |
+| `train` | 1,361 | full training pool |
+| **total** | **1,431** | |
+
+`train` (1,361) and `test` (70) are identity-disjoint and together cover
+all 1,431 subjects. `train_subset_x1`, `train_subset_x12`, and `train_val`
+are subsets of `train`.
+
+## Why two repos?
+
+HuggingFace's Dataset Viewer cannot render tabs/thumbnails for **gated**
+datasets — the worker that computes split names runs without a user
+identity and can't satisfy the gating EULA. The full TEDWB1k is gated for
+TED-content compliance, so to keep the viewer working we mirror the
+metadata + a 12-subject sample to this public preview repo.
+
+For full discussion see this thread:
+<https://discuss.huggingface.co/t/after-gated-user-access-was-enabled-the-huggingface-not-showing-dataset-viewer/157333>
+
+## License
+
+[**CC-BY-NC-ND 4.0**](https://creativecommons.org/licenses/by-nc-nd/4.0/) —
+same as the main repo. Non-commercial research use only. Attribution
+required. **No derivatives** — you may not distribute modified or remixed
+versions of this dataset.
+
+The tracking parameters, JPG frames, and mattes are all derived works of
+TED talk videos that are themselves CC-BY-NC-ND on ted.com. This dataset
+matches the upstream license to remain compatible with TED's source
+restrictions.
+
+## Links
+
+- **Full gated dataset**: <https://huggingface.co/datasets/initialneil/TEDWB1k>
+- Tracking pipeline: <https://github.com/initialneil/HolisticTracker>
+- HolisticAvatar (downstream model): <https://github.com/initialneil/HolisticAvatar>

load_tedwb1k.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python
+"""Download and assemble a TEDWB1k split for HolisticAvatar.
+
+Usage examples
+--------------
+# Smallest possible test (1 subject, ~80 MB):
+python load_tedwb1k.py --split train_subset_x1 --out ~/data/tedwb1k_x1
+
+# 12-subject overfit set (~1 GB):
+python load_tedwb1k.py --split train_subset_x12 --out ~/data/tedwb1k_x12
+
+# 20-subject training-monitor set (~2 GB, subset of train):
+python load_tedwb1k.py --split train_val --out ~/data/tedwb1k_train_val
+
+# 70-subject test set (~10 GB):
+python load_tedwb1k.py --split test --out ~/data/tedwb1k_test
+
+# Full training pool (1361 subjects, ~190 GB):
+python load_tedwb1k.py --split train --out ~/data/tedwb1k_train
+
+# Use already-downloaded HF cache, skip re-download:
+python load_tedwb1k.py --split test --out ~/data/tedwb1k_test --hf_cache ~/.cache/huggingface
+
+After it finishes, point your training config at --out:
+    DATASET.data_path: <out>
+
+The directory `<out>` will contain the same five files HolisticAvatar's
+`TrackedData.__init__` expects:
+    optim_tracking_ehm.pkl   # merged from per-subject pkls
+    id_share_params.pkl      # merged from per-subject pkls
+    videos_info.json         # merged from per-subject jsons
+    dataset_frames.json      # copied from the release root
+    extra_info.json          # generated locally with absolute frames_root/matte_root
+
+…plus `frames_root/<vid>/...` and `matte_root/<vid>/...` containing the per-shot
+JPGs that the dataloader reads at training time.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pickle
+import sys
+import time
+from pathlib import Path
+
+REPO_ID = "initialneil/TEDWB1k"
+REPO_TYPE = "dataset"
+
+SPLIT_FILES = {
+    "train":             "train.txt",
+    "train_subset_x1":   "train_subset_x1.txt",
+    "train_subset_x12":  "train_subset_x12.txt",
+    "train_val":         "train_val.txt",
+    "test":              "test.txt",
+}
+
+# Per-subject files we always need to feed TrackedData:
+PER_SUBJECT_TRACKING = [
+    "tracking/optim_tracking_ehm.pkl",
+    "tracking/id_share_params.pkl",
+    "tracking/videos_info.json",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--split", required=True, choices=list(SPLIT_FILES.keys()),
+                    help="Which subject set to download.")
+    ap.add_argument("--out", required=True, type=Path,
+                    help="Local directory to assemble the dataset into.")
+    ap.add_argument("--repo_id", default=REPO_ID,
+                    help=f"HuggingFace dataset repo id (default: {REPO_ID}).")
+    ap.add_argument("--hf_cache", type=Path, default=None,
+                    help="Override HuggingFace cache dir (default: ~/.cache/huggingface).")
+    ap.add_argument("--keep_tars", action="store_true",
+                    help="Keep frames.tar / mattes.tar after extraction (default: delete to save space).")
+    ap.add_argument("--skip_download", action="store_true",
+                    help="Skip download step (assume HF cache is already populated).")
+    ap.add_argument("--skip_extract", action="store_true",
+                    help="Skip frames/mattes extraction (just merge tracking pkls).")
+    ap.add_argument("--local_snapshot", type=Path, default=None,
+                    help="Skip HF download entirely; treat this local dir as the snapshot. "
+                         "Useful for testing build_release.py output before upload, or if "
+                         "the user already has a clone of the repo.")
+    return ap.parse_args()
+
+
+def read_subject_ids(
+    split_name: str,
+    repo_id: str,
+    hf_cache: Path | None,
+    local_snapshot: Path | None,
+) -> list[str]:
+    """Fetch and parse the split txt for the chosen split."""
+    txt_name = SPLIT_FILES[split_name]
+    if local_snapshot is not None:
+        local_txt = local_snapshot / txt_name
+        if not local_txt.exists():
+            raise FileNotFoundError(f"{local_txt} not found in local snapshot")
+        print(f"[1/5] Reading split file {txt_name} from local snapshot ...")
+    else:
+        from huggingface_hub import hf_hub_download
+        print(f"[1/5] Fetching split file {txt_name} from {repo_id} ...")
+        local_txt = Path(hf_hub_download(
+            repo_id=repo_id,
+            filename=txt_name,
+            repo_type=REPO_TYPE,
+            cache_dir=str(hf_cache) if hf_cache else None,
+        ))
+    ids = [ln.strip() for ln in Path(local_txt).read_text().splitlines() if ln.strip()]
+    print(f"   {len(ids)} subject ids in '{split_name}'")
+    return ids
+
+
+def download_subject_files(
+    repo_id: str,
+    hf_cache: Path | None,
+    subject_ids: list[str],
+) -> Path:
+    """Snapshot only the subject files we need. Returns the snapshot root."""
+    from huggingface_hub import snapshot_download
+
+    patterns: list[str] = []
+    for vid in subject_ids:
+        for f in PER_SUBJECT_TRACKING:
+            patterns.append(f"subjects/{vid}/{f}")
+        patterns.append(f"subjects/{vid}/frames.tar")
+        patterns.append(f"subjects/{vid}/mattes.tar")
+    # Always grab dataset_frames.json (used for train/valid frame split inside TrackedData)
+    patterns.append("dataset_frames.json")
+
+    print(f"[2/5] snapshot_download from {repo_id} ({len(patterns)} patterns) ...")
+    snap = snapshot_download(
+        repo_id=repo_id,
+        repo_type=REPO_TYPE,
+        allow_patterns=patterns,
+        cache_dir=str(hf_cache) if hf_cache else None,
+    )
+    print(f"   snapshot at: {snap}")
+    return Path(snap)
+
+
+def merge_tracking(
+    snapshot: Path,
+    subject_ids: list[str],
+    out: Path,
+) -> None:
+    """Merge per-subject tracking files into the 5-file TrackedData bundle.
+
+    Per-subject `optim_tracking_ehm.pkl` and `id_share_params.pkl` are FLAT
+    (no top-level video_id key) — the merger wraps them under each video_id
+    so the result matches the format produced by `merge_ehmx_dataset.py`.
+    """
+    print(f"[3/5] Merging tracking files for {len(subject_ids)} subjects ...")
+    merged_optim: dict = {}
+    merged_id_share: dict = {}
+    merged_videos_info: dict = {}
+    n_frames_total = 0
+    missing: list[str] = []
+
+    t0 = time.time()
+    for i, vid in enumerate(subject_ids, 1):
+        sub = snapshot / "subjects" / vid / "tracking"
+        opt_p = sub / "optim_tracking_ehm.pkl"
+        id_p  = sub / "id_share_params.pkl"
+        vi_p  = sub / "videos_info.json"
+        if not (opt_p.exists() and id_p.exists() and vi_p.exists()):
+            missing.append(vid)
+            continue
+        with open(opt_p, "rb") as f:
+            merged_optim[vid] = pickle.load(f)
+        with open(id_p, "rb") as f:
+            merged_id_share[vid] = pickle.load(f)
+        with open(vi_p, "r") as f:
+            vi = json.load(f)
+        merged_videos_info.update(vi)
+        n_frames_total += len(merged_optim[vid])
+        if i % 50 == 0 or i == len(subject_ids):
+            elapsed = time.time() - t0
+            print(f"   merged {i}/{len(subject_ids)} subjects "
+                  f"({n_frames_total} frames so far, {elapsed:.1f}s)")
+
+    if missing:
+        print(f"   WARNING: {len(missing)} subjects had missing tracking files: {missing[:5]}...", file=sys.stderr)
+
+    out.mkdir(parents=True, exist_ok=True)
+    with open(out / "optim_tracking_ehm.pkl", "wb") as f:
+        pickle.dump(merged_optim, f, protocol=pickle.HIGHEST_PROTOCOL)
+    with open(out / "id_share_params.pkl", "wb") as f:
+        pickle.dump(merged_id_share, f, protocol=pickle.HIGHEST_PROTOCOL)
+    with open(out / "videos_info.json", "w") as f:
+        json.dump(merged_videos_info, f)
+    print(f"   wrote optim_tracking_ehm.pkl ({n_frames_total} frames)")
+    print(f"   wrote id_share_params.pkl ({len(merged_id_share)} subjects)")
+    print(f"   wrote videos_info.json ({len(merged_videos_info)} subjects)")
+
+    # Copy dataset_frames.json from snapshot (used by train/valid splits inside TrackedData)
+    src_frames = snapshot / "dataset_frames.json"
+    if src_frames.exists():
+        out_frames = out / "dataset_frames.json"
+        out_frames.write_text(src_frames.read_text())
+        print(f"   copied dataset_frames.json")
+    else:
+        print("   WARNING: dataset_frames.json missing in snapshot — train/valid splits won't work")
+
+
+def setup_frame_dirs(
+    snapshot: Path,
+    subject_ids: list[str],
+    out: Path,
+    keep_tars: bool,
+) -> tuple[Path, Path]:
+    """Materialize per-subject frames + mattes under out/frames_root, out/matte_root.
+
+    Handles both layouts:
+    - Snapshot has `subjects/<vid>/frames.tar` (HF upload case): extract into
+      out/frames_root/<vid>/ and (optionally) delete the tar to save disk.
+    - Snapshot has `subjects/<vid>/frames/` as a real dir or symlink (local
+      build_release.py output, or pre-extracted clone): symlink it from
+      out/frames_root/<vid> -> resolved frames dir.
+    """
+    import tarfile
+
+    frames_root = out / "frames_root"
+    matte_root  = out / "matte_root"
+    frames_root.mkdir(parents=True, exist_ok=True)
+    matte_root.mkdir(parents=True, exist_ok=True)
+
+    print(f"[4/5] Setting up frames + mattes for {len(subject_ids)} subjects ...")
+    n_extracted = n_linked = n_missing = 0
+    for vid in subject_ids:
+        sub = snapshot / "subjects" / vid
+        for kind, dest_root in [("frames", frames_root), ("mattes", matte_root)]:
+            tar_path = sub / f"{kind}.tar"
+            dir_path = sub / kind
+            target   = dest_root / vid
+            if target.exists() or target.is_symlink():
+                continue  # idempotent
+            if tar_path.exists():
+                target.mkdir(parents=True, exist_ok=True)
+                with tarfile.open(tar_path, "r") as tar:
+                    tar.extractall(path=target)
+                if not keep_tars:
+                    tar_path.unlink()
+                n_extracted += 1
+            elif dir_path.exists():
+                # Resolve through any symlinks so the link in out/ is stable.
+                target.symlink_to(dir_path.resolve())
+                n_linked += 1
+            else:
+                print(f"   WARNING: {vid}/{kind} not in snapshot (no .tar, no dir)", file=sys.stderr)
+                n_missing += 1
+    print(f"   extracted={n_extracted // 2}  linked={n_linked // 2}  missing={n_missing}")
+    return frames_root, matte_root
+
+
+def write_extra_info(out: Path, frames_root: Path, matte_root: Path) -> None:
+    """Write extra_info.json with absolute paths to the local extracted dirs."""
+    print("[5/5] Writing extra_info.json ...")
+    extra = {
+        "frames_root": str(frames_root.resolve()),
+        "matte_root":  str(matte_root.resolve()),
+        "pshuman_root": None,
+    }
+    with open(out / "extra_info.json", "w") as f:
+        json.dump(extra, f, indent=2)
+    print(f"   frames_root = {extra['frames_root']}")
+    print(f"   matte_root  = {extra['matte_root']}")
+
+
+def main() -> int:
+    args = parse_args()
+    out = args.out.expanduser().resolve()
+    local_snapshot = args.local_snapshot.expanduser().resolve() if args.local_snapshot else None
+
+    if local_snapshot is None:
+        try:
+            import huggingface_hub  # noqa: F401
+        except ImportError:
+            print("ERROR: huggingface_hub is required. Install with:", file=sys.stderr)
+            print("  pip install huggingface_hub", file=sys.stderr)
+            return 2
+
+    subject_ids = read_subject_ids(args.split, args.repo_id, args.hf_cache, local_snapshot)
+
+    if local_snapshot is not None:
+        print(f"[2/5] Using local snapshot at {local_snapshot} (no download)")
+        snapshot = local_snapshot
+    elif args.skip_download:
+        print("[2/5] --skip_download: assuming local snapshot is already populated")
+        from huggingface_hub import snapshot_download
+        snapshot = Path(snapshot_download(
+            repo_id=args.repo_id,
+            repo_type=REPO_TYPE,
+            allow_patterns=["dataset_frames.json"],
+            cache_dir=str(args.hf_cache) if args.hf_cache else None,
+        ))
+    else:
+        snapshot = download_subject_files(
+            repo_id=args.repo_id,
+            hf_cache=args.hf_cache,
+            subject_ids=subject_ids,
+        )
+
+    merge_tracking(snapshot, subject_ids, out)
+
+    if args.skip_extract:
+        print("[4/5] --skip_extract: skipping frames/mattes setup")
+        frames_root = out / "frames_root"
+        matte_root  = out / "matte_root"
+    else:
+        frames_root, matte_root = setup_frame_dirs(snapshot, subject_ids, out, args.keep_tars)
+
+    write_extra_info(out, frames_root, matte_root)
+
+    print()
+    print("=" * 60)
+    print(f"DONE. Local dataset assembled at: {out}")
+    print(f"  Point training config at:  DATASET.data_path: {out}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())