docs/DATASET_GENERATION.md

EventActivityNet v1.0 Dataset Generation

Source Video Lineage

EventActivityNet v1.0 was generated from the non-interpolated/original-rate ActivityNet video lineage. It was not generated from the recovered 240fps interpolated video directory.

Source FPS varies by video. The generator records FPS metadata per HDF5 file and preserves source spatial resolution.

Large Subset Curation

The Large release exactly matches the recovered original Large subset manifest. It contains 3,263 unique video IDs.

The recovered subset curation implementation:

• merges ActivityNet Captions train and validation metadata before sampling;
• uses seed 2025;
• performs initial class-balanced sampling with max(5, int(class_ratio * class_count));
• uses default class_ratio=0.2;
• length-balances using 33% and 66% duration quantiles;
• enriches with event-friendly examples from caption keywords or first-frame darkness.

Event-friendly keywords:

run, fast, sprint, night, dark, slow-motion

Darkness threshold:

normalized first-frame mean brightness < 0.4

The minimum-per-class rule is an initial sampling-stage rule. Later global length balancing can reduce final per-class counts below that initial quota.

HDF5 Generation Pipeline

The confirmed generation call chain is:

• activitynet.sh
• activitynet.py
• mp4_to_h5.mp4_to_h5_stream()
• data/v2v_core_esim_gpu.EventEmulatorGPU.video_to_voxel()
• HDF5 writer

Confirmed generation parameters:

Parameter	Value
Source video lineage	non-interpolated/original-rate ActivityNet videos
Number of bins	5
frames_per_bin	1
Spatial resizing	none; source resolution preserved
Output event dtype	int16
voxel_event_start dtype	int64
voxel_event_count dtype	int32
events compression	gzip+shuffle
Auxiliary compression	LZF+shuffle
Learned checkpoint required	no

The recovered implementation shows that no learned HyperE2VID/V2V checkpoint is used for HDF5 generation. Checkpoints found in the recovered project belong to downstream reconstruction/evaluation code, not to the generation of the HDF5 voxel files.

Voxel Metadata Semantics

The generator emits event slices from adjacent grayscale video frames and accumulates them into output voxel samples.

• voxel_event_start[t] is the generated-slice start index for voxel sample t.
• voxel_event_count[t] is the number of generated slices accumulated into voxel sample t.

Release Scale Construction

Large is the recovered historical subset.

Medium and Small are newly generated deterministic nested v1.0 release scales:

Small subset Medium subset Large

Target durations:

• Medium: approximately 50 hours.
• Small: approximately 20 hours.

Scale construction uses seed 2025 and stratifies by:

(split, class_label, duration_bucket, event_friendly)

Within each stratum, records are ranked deterministically by a stable hash of seed and video ID.

Verified Output

Final validation confirmed:

• 3,263 valid HDF5 files;
• all files open successfully;
• zero truncated or unreadable files;
• zero remaining structural warnings;
• Large train/validation split: 2,316 / 947.

Original-Rate Timing Mapping

EventActivityNet v1.0 uses original-rate, variable-FPS ActivityNet videos. The released HDF5 files were not generated from anet_240fps_v2 or anet_240fps_old.

Implementation-derived timing:

• one event slice is generated for each adjacent decoded source-frame transition (e, e + 1);
• one full events[t] tensor groups five adjacent-frame transitions and has shape (5, H, W);
• for source frame count N, events_T = ceil((N - 1) / 5);
• voxel t covers event-slice range [5*t, 5*t + 5), clipped to available transitions [0, N - 1);
• the corresponding source-frame interval is [5*t, min(5*t + 5, N - 1)];
• with rational FPS fps_num / fps_den, the approximate seconds interval is [5*t * fps_den / fps_num, min(5*t + 5, N - 1) * fps_den / fps_num];
• the final voxel may be partial, with voxel_event_count[t] smaller than 5;
• HDF5 root fps is the original source-frame FPS captured by OpenCV, not a 240 fps derivative;
• voxel_event_start[t] is the generated event-slice start index for voxel t;
• voxel_event_count[t] is the number of generated adjacent-frame slices in voxel t;
• voxel_event_start and voxel_event_count are not timestamps and not pixel-event counts.

For caption/action interval [start_seconds, end_seconds], use original FPS to compute:

start_frame = floor(start_seconds * fps_num / fps_den)
end_frame = ceil(end_seconds * fps_num / fps_den)
t_start = max(0, floor(start_frame / 5))
t_end_exclusive = min(events_T, ceil(end_frame / 5))

Use [t_start, t_end_exclusive) for Python slicing, or [t_start, t_end_exclusive - 1] as an inclusive range when non-empty. Do not use time_seconds = t / fps for voxel starts; voxel start time is approximately 5 * t / fps.

Annotation Alignment

Additional public annotation files are provided under annotations/ and metadata/:

• annotations/activitynet_captions.json: ActivityNet Captions timestamped natural-language descriptions for release videos. Validation references preserve val_1 and val_2 separately.
• annotations/activitynet_actions.json: ActivityNet v1.3 temporal action segments and labels.
• annotations/eventactivitynet_alignment.json: EventActivityNet project-derived caption/action alignment generated using temporal IoU with midpoint-distance fallback.
• annotations/annotation_issues.jsonl: known upstream annotation quirks recorded without changing canonical values.
• metadata/video_metadata.jsonl: original-rate timing metadata, including exact rational FPS where available.

Captions are timestamped descriptions from ActivityNet Captions. They are not instruction-tuning examples.