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

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

Darkness threshold:

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

```text
Small subset Medium subset Large
```

Target durations:

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

Scale construction uses seed `2025` and stratifies by:

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

```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`.

## 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.