# EventActivityNet Dataset Format

## Overview

EventActivityNet v1.0 stores one HDF5 file per video. Scale membership and train/validation splits are defined by manifests, so files do not need to be physically moved to use a particular split or scale.

File size varies substantially with video duration and spatial resolution.

Every production HDF5 file has exactly these root datasets:

```text
events
voxel_event_start
voxel_event_count
```

Every production HDF5 file has these required root attributes:

```text
fps
height
width
num_bins
interpolate_bins
```

## HDF5 Schema

### `events`

| Property | Value |
|---|---|
| Shape | `(T, 5, H, W)` |
| Dtype | `int16` |
| Compression | gzip |
| Shuffle | enabled |
| Chunking | `(1, 5, min(H, 256), min(W, 256))` |

`T`, `H`, and `W` vary by video. Spatial resolution is preserved from the source video.

### `voxel_event_start`

| Property | Value |
|---|---|
| Shape | `(T,)` |
| Dtype | `int64` |
| Compression | LZF |
| Shuffle | enabled |
| Chunking | `(1024,)` |

### `voxel_event_count`

| Property | Value |
|---|---|
| Shape | `(T,)` |
| Dtype | `int32` |
| Compression | LZF |
| Shuffle | enabled |
| Chunking | `(1024,)` |

## Root Attributes

| Attribute | Meaning |
|---|---|
| `fps` | Source video FPS metadata |
| `height` | Source video height |
| `width` | Source video width |
| `num_bins` | Number of voxel bins; always `5` in v1.0 |
| `interpolate_bins` | Whether temporal bin interpolation was used |

## Semantics

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

- `events[t]` is the 5-bin voxel tensor for timestep `t`.
- `voxel_event_start[t]` is the zero-based generated-slice start index for voxel sample `t`.
- `voxel_event_count[t]` is the number of generated slices accumulated into voxel sample `t`.

For normal full samples with `frames_per_bin=1`, `voxel_event_count[t]` is typically `5`. Final partial samples may be smaller.

## Manifest Fields

Release scale manifests include one record per video. Typical fields:

| Field | Meaning |
|---|---|
| `video_id` | Canonical ActivityNet video ID, including `v_` prefix |
| `split` | `train` or `validation` |
| `class_label` | ActivityNet action class label |
| `duration_seconds` | Verified duration used for scale construction |
| `duration_source` | Duration field source, `src_fmt_dur` |
| `duration_bucket` | `short`, `medium`, or `long` |
| `event_friendly` | Boolean event-friendly flag |
| `event_keyword_hits` | Matched event-friendly caption keywords |
| `first_frame_mean` | Normalized first-frame brightness used for the darkness rule |
| `dark_first_frame` | Whether first-frame mean is below `0.4` |

## Memory-Safe Loading Example

```python
import h5py

path = "path/to/video.h5"

with h5py.File(path, "r") as f:
    events = f["events"]
    starts = f["voxel_event_start"]
    counts = f["voxel_event_count"]

    print(events.shape)        # (T, 5, H, W)
    print(events.dtype)        # int16
    print(starts.shape)        # (T,)
    print(counts.shape)        # (T,)
    print(f.attrs["num_bins"]) # 5

    first_voxel = events[0]    # loads one timestep, not the whole file
```

Avoid loading entire HDF5 arrays into memory unless your system has sufficient RAM.

## Payload Shards

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.

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