README.md

metadata

pretty_name: EventActivityNet
tags:
  - event-based-vision
  - video-understanding
  - activitynet
  - hdf5
size_categories:
  - 1K<n<10K

Dataset Card for EventActivityNet v1.0

Dataset Summary

EventActivityNet v1.0 is a generated event voxel tensor dataset derived from ActivityNet videos and ActivityNet Captions annotations. It contains per-video HDF5 files with 5-bin event voxel tensors, release metadata, and three nested release scales: Large, Medium, and Small.

The dataset is designed for research on event-based video understanding, event voxel tensor representation learning, and caption-aligned activity modeling.

Dataset Details

Field	Value
Dataset name	EventActivityNet
Version	v1.0
Repository	https://huggingface.co/datasets/IIS-CVL/EventActivityNet
Data type	HDF5 event voxel tensors plus release manifests
Source lineage	ActivityNet / ActivityNet Captions
Source video lineage	non-interpolated/original-rate ActivityNet videos
HDF5 files	3,263
Total size	approximately 4.36 TB
Action classes	200
Event bins	5
Large train / validation	2,316 / 947

Scale Statistics

Scale	Videos	Hours	Train	Validation	Classes	Event-friendly
Large	3,263	106.94	2,316	947	200	65.31%
Medium	1,537	50.00	1,074	463	200	64.80%
Small	667	20.00	473	194	200	64.62%

Small is a strict subset of Medium, and Medium is a strict subset of Large.

Dataset Structure

Each ActivityNet video in the release corresponds to exactly one HDF5 file. Scale membership and train/validation assignment are manifest-based, so users can select Large, Medium, Small, train, or validation subsets without physically moving HDF5 files.

Source and Provenance

The Large release exactly matches the recovered original Large subset manifest. The subset was curated from ActivityNet Captions train and validation metadata after merging those splits before sampling.

Verified curation principles:

• seed 2025;
• initial class-balanced sampling with max(5, int(class_ratio * class_count));
• duration stratification using 33% and 66% quantile buckets;
• event-friendly enrichment using caption keywords or first-frame darkness.

The source video lineage is the non-interpolated/original-rate ActivityNet video lineage. Source FPS varies by video.

Generation Pipeline

The recovered generation implementation follows this call chain:

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

Confirmed generation properties:

• 5 event bins;
• source spatial resolution preserved;
• no learned V2V checkpoint required for HDF5 generation;
• events stored as int16;
• auxiliary index/count arrays stored as int64 and int32.

Medium and Small are newly generated deterministic nested v1.0 release scales derived from Large.

Event-Friendly Definition

A video is event-friendly if either condition holds:

• a caption contains at least one keyword: run, fast, sprint, night, dark, slow-motion;
• the first frame has normalized mean brightness below 0.4.

Scale	Event-friendly videos	Caption-keyword matches	Dark-first-frame matches	Both keyword and dark	Neither trigger
Large	2,131	630	1,954	453	1,132
Medium	996	297	914	215	541
Small	431	118	396	83	236

Data Format

Each video is stored as one HDF5 file with:

• events: (T, 5, H, W), int16;
• voxel_event_start: (T,), int64;
• voxel_event_count: (T,), int32.

T, H, W, and file size vary by video. See DATASET_FORMAT.md for details.

Intended Uses

EventActivityNet is intended for:

• event-based video representation learning;
• activity recognition using generated event voxel tensors;
• event/video-language modeling with captions;
• benchmarking methods across nested dataset scales;
• research on event-friendly subsets of activity videos.

Out-of-Scope Uses

This dataset should not be used for:

• identifying people;
• biometric recognition;
• surveillance deployment;
• making consequential decisions about individuals;
• redistributing or using source-derived data in ways that violate ActivityNet or ActivityNet Captions terms.

Limitations

• The release contains generated event voxel tensors, not native sensor event streams.
• Source FPS varies by video.
• Medium and Small are deterministic nested v1.0 scales, not historical original subsets.
• The verified local class count is 200. Some ActivityNet references mention 203 classes, but the recovered release metadata and manifests for EventActivityNet v1.0 verify 200 action classes.
• The verified Large duration is 106.94 hours using the release duration field. Historical references to 107.3 hours should be treated as approximate for this recovered release.

Licensing and Citation

EventActivityNet is derived from ActivityNet / ActivityNet Captions. Source dataset terms, licenses, and citation obligations still apply. See LICENSE_NOTES.md.

If you use EventActivityNet v1.0, cite this dataset and the original ActivityNet / ActivityNet Captions sources. See CITATION.cff.

Integrity Verification

Final technical validation confirmed:

• 3,263 valid HDF5 files;
• all files open successfully;
• zero truncated or unreadable files;
• zero remaining structural warnings;
• required datasets and dtypes are present in every file;
• Large split counts are 2,316 train and 947 validation;
• total release size is approximately 4.36 TB.

Payload Files

The HDF5 payload is distributed as deterministic uncompressed tar shards:

• 157 train tar shards under data/train/;
• 62 validation tar shards under data/validation/;
• 219 tar shards total;
• 3,263 HDF5 members total;
• one HDF5 member per released ActivityNet video.

Large, Medium, and Small share the same physical HDF5 payload. Medium and Small are selected using scales/medium_ids.txt and scales/small_ids.txt; they do not duplicate payload files.

Annotation Files

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.

Timing Metadata

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.

Checksums

Tar shard checksums are published in metadata/shard_checksums.sha256. To verify downloaded shards from the repository root:

sha256sum -c metadata/shard_checksums.sha256

The checksum file contains one repository-relative entry for each of the 219 tar shards.