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:

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

{
  '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.