| # `Bmingg/gebd-data` — training data for EfficientGEBD on EgoDex / EgoVerse |
|
|
| Private Hugging Face **dataset** repository holding everything a rented GPU needs |
| to train and evaluate the boundary-detection models in |
| `github.com/Bmingg/gebd-training` (private): pre-extracted frames, ground-truth |
| pickles, the pretrained backbone, and the team's timestamp scorer. Results go |
| to the sibling repo `Bmingg/gebd-results`; code goes through GitHub. |
|
|
| Everything here is a `.tar.zst` archive (tar stream compressed with zstd). The |
| lab server keeps the originals under `/mnt/SSD4/`; these are copies, packed by |
| `vast/pack.sh`, uploaded by `vast/upload.sh`, and unpacked on an instance by |
| `vast/bootstrap.sh`. `MANIFEST.txt` lists the SHA-256 of every archive at the |
| time of the last pack. |
|
|
| ## Access |
|
|
| Private. You need a Hugging Face token from Bmingg with **read** access to this |
| repo (write is only needed to upload). Never store it in the shared account's |
| login; pass it per command: |
|
|
| ```bash |
| pip install "huggingface_hub[cli]" |
| HF_TOKEN=hf_... hf download Bmingg/gebd-data egodex_stage2_gt.tar.zst --repo-type dataset --local-dir /tmp/dl |
| zstd -dc /tmp/dl/egodex_stage2_gt.tar.zst | tar -C /data/egodex_stage2_gebd -xf - |
| ``` |
|
|
| Each archive unpacks into the directory named in the table, under the parent |
| given in the last column. On a Vast instance `vast/bootstrap.sh` does all of |
| this for the datasets named in its `DATASETS` variable. |
|
|
| ## What is in the repo |
|
|
| | archive | size | unpacks to | contents | |
| |---|---|---|---| |
| | `egodex_stage2_frames.tar.zst` | 8.7 GB | `frames_t100/{train,val}/<episode>/frame1..100.jpg` | **EgoDex stage2, fixed-100 protocol.** Every video resampled to exactly 100 frames, 224×224 JPEG. 19,126 train + 251 val episodes — but see the next row | |
| | `egodex_stage2_frames_missing.tar.zst` | 3.4 GB | same tree | Patch. The main archive was packed before `tar -h` and stored 5,156 episode directories as dangling symlinks (4,905 train, all 251 val). This archive holds those episodes as real directories. Unpack the main archive, delete its symlinks, then unpack this one — `bootstrap.sh` does exactly that | |
| | `egodex_stage2_gt.tar.zst` | 0.6 MB | `gebd_pkls/k400_mr345_{train,val}_min_change_duration0.3.pkl` | Ground truth for the fixed-100 protocol (schema below), `num_frames = 100` | |
| | `egodex_stage2_frames10.tar.zst` | 12.2 GB | `frames10/{train,val}/<episode>/frame1..N.jpg` | **EgoDex stage2 at a fixed 10 fps** — the same 19,126 + 251 videos decoded at exactly 10 frames per second, N = round(10 × duration), frame i at (i−1)/10 s. Used by the sliced protocols (`INPUT.SLICING = pad | overlap`), which cut these into 100-frame records at load time. No symlinks | |
| | `egodex_stage2_gt_fps10.tar.zst` | 0.6 MB | `gebd_pkls_fps10/…` | Ground truth for the 10 fps frames: `num_frames = N`, `fps = 10`, plus `slot_seconds = 0.1` | |
| | `egodex_stage2_proxies.tar.zst` | 5.8 GB | `{train,val}/<task>/<episode>.mp4` | The 854×480, 30 fps h264 proxies of the stage2 videos only (19,377 of the 69,590 in the full proxy set). Source for `extract_qwen_features.py --source video --video-root <dir>`, i.e. feeding Qwen at native resolution; not needed by any CNN run | |
| | `egoverse_gt.tar.zst` | 0.7 MB | `gebd_pkls_t100/…` | EgoVerse ground truth, fixed-100 protocol (frames for it are **not** uploaded — 22 GB, opt-in via `vast/upload.sh egoverse`) | |
| | `egoverse_sliced_gt.tar.zst` | 1.3 MB | `gebd_pkls_sliced10s/…` | EgoVerse ground truth for the earlier 10-second-clip experiment, one record per clip named `<video>__cNN`. Its 159 GB of frames were never uploaded | |
| | `csn_pretrained.tar.zst` | 155 MB | `CSN-pretrained/` | ir-CSN-152 backbone weights pretrained on IG-65M (mmaction2 checkpoint + config). Required for every CSN run; ResNet50 runs use torchvision's ImageNet weights instead | |
| | `stage0.tar.zst` | 20 KB | `stage0/{eval,egodex,postprocess}.py` | The team's timestamp metric from the `VR-finetune-VLM` repo, stdlib only. Optional: without it `decode_both.py` reports the F1 columns and prints `n/a` for timestamp | |
|
|
| Parent directories on an instance: everything EgoDex under |
| `/data/egodex_stage2_gebd/`, EgoVerse under `/data/egoverse_gebd/`, the |
| backbone and `stage0` under the repo root / `/data`. On the lab server the |
| originals live under `/mnt/SSD4/` with the same names. |
|
|
| ## The data itself |
|
|
| **EgoDex stage2** is the QA'ed EgoDex subset used for every current experiment: |
| 19,126 training episodes with the natural task distribution and the cleaned |
| 251-episode validation split (13 broken `build_unstack_lego` episodes removed, |
| 27 AV1-only episodes transcoded). Boundaries come from the stage2 narration |
| captions. Train videos average 9.0 s, val 14.4 s, about 0.5 boundaries per |
| second in both. Episode directories are named `<task>__episode_<id>`. |
|
|
| **Two protocols share the same videos and the same boundaries**, and differ only |
| in how frames are sampled: |
|
|
| - *fixed-100* (`frames_t100`, `gebd_pkls`): 100 frames per video whatever its |
| length, so a slot is 0.09 s on a typical train video and 0.15 s on val; |
| - *fixed 10 fps* (`frames10`, `gebd_pkls_fps10`): one frame every 0.1 s, so a |
| slot means the same thing everywhere; the loader slices into 100-frame records. |
|
|
| The ground-truth pickles are Python dicts keyed by episode name, in the |
| Kinetics-GEBD `k400_mr345` layout the EfficientGEBD code expects: |
|
|
| ```python |
| { |
| 'add_remove_lid__episode_000349': { |
| 'num_frames': 100, # slots in the record (100, or N at 10 fps) |
| 'fps': 11.42, # (num_frames-1)/duration, or 10.0 at 10 fps |
| 'video_duration': 8.667, # seconds |
| 'path_video': '/mnt/SSD4/dataset/video_proxies/egodex/train/add_remove_lid/episode_000349.mp4', |
| 'path_frame': 'add_remove_lid__episode_000349', # directory name under frames_*/<split>/ |
| 'f1_consis': [1.0], 'f1_consis_avg': 1.0, # single annotator; placeholders |
| 'substages_myframeidx': [[12.0, 27.0, 39.0, ...]], # boundaries as 1-based slot indices |
| 'substages_timestamps': [[1.0, 2.3, 3.3, ...]], # the same boundaries in seconds |
| 'slot_seconds': 0.1, # 10 fps pickles only |
| }, ... |
| } |
| ``` |
|
|
| `path_video` points at the lab server and is informational only. The frame |
| directory is `path_frame`; frames are `frame1.jpg … frameN.jpg`, 1-based. |
|
|
| ## Provenance |
|
|
| | archive | built by | |
| |---|---| |
| | fixed-100 frames + gt | `prepare_egodex_stage2.py` (frames reuse the older `egodex_gebd` extraction where identical) | |
| | 10 fps frames + gt | `prepare_egodex_stage2_sliced.py` | |
| | stage2 proxies | `vast/pack.sh egodex_proxies` (file list from the stage2 pkls' `path_video`) | |
| | EgoVerse gt | `prepare_egoverse_gebd.py`, `prepare_egoverse_sliced.py` (on the server, `/mnt/SSD4/egoverse_gebd`) | |
| | CSN weights | mmaction2 model zoo, `ircsn_ig65m-pretrained-r152-bnfrozen_8xb12-32x2x1-58e_kinetics400-rgb` | |
| | stage0 | copied from `VR-finetune-VLM/stage0` | |
|
|
| All scripts are in `gebd-training`. Re-packing after a data change is |
| `./vast/pack.sh <target>` then `./vast/upload.sh <target>`; both are idempotent. |
|
|
| ## Sizes to plan for |
|
|
| A fixed-100 instance needs the 8.7 + 3.4 GB archives plus their unpacked 13 GB; |
| a sliced instance the 12.2 GB archive plus 16 GB unpacked. Peak disk during |
| bootstrap is roughly image + archive + unpacked set; 64 GB is enough for either |
| protocol, 80 GB for both on one instance. |
|
|
