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

```text
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](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](LICENSE_NOTES.md).

If you use EventActivityNet v1.0, cite this dataset and the original ActivityNet / ActivityNet Captions sources. See [CITATION.cff](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:

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

```bash
sha256sum -c metadata/shard_checksums.sha256
```

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