README.md

---
license: cc-by-4.0
language:
- en
task_categories:
- video-classification
- time-series-forecasting
tags:
- driving
- safety
- accident-anticipation
- driver-alert
- vlm
- pomdp
size_categories:
- 100K<n<1M
pretty_name: VLAlert-Bench
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train.parquet
  - split: validation
    path: data/val.parquet
  - split: test
    path: data/test.parquet
  - split: extra_val_adasto
    path: data/extra_val_adasto.parquet
  - split: extra_val_accident
    path: data/extra_val_accident.parquet
---

# VLAlert-Bench (v1)

**A unified benchmark for driving-alert decision making.**

VLAlert-Bench integrates six driving-event datasets — Nexar Collision,
DoTA, DAD, DADA-2000, ADAS-TO-Critic, and the Kaggle ACCIDENT @ CVPR
2026 challenge — into a single per-tick prediction task with three
actions: **SILENT (0) / OBSERVE (1) / ALERT (2)**.

At each 1 Hz tick a model observes the last 8 frames of a video and must
output one of three actions. Labels are derived from each source
dataset's event-time annotations using a uniform 2 s ALERT / 4 s
OBSERVE window around the event onset.

> **What's hosted here.** Five 1 Hz tick parquets, per-frame action
> labels, per-video split manifests, the ADAS-TO-Critic mp4 corpus
> (1.6 GB, full source), and a HuggingFace loader. **Nexar / DoTA /
> DAD / DADA-2000 / Kaggle ACCIDENT** videos are not redistributed —
> see "How to load" below for download links.

---

## At a glance

|                       | **Train** | **Val** | **Test** | **Extra: ADAS-TO** | **Extra: ACCIDENT** | **Total** |
| --------------------- | --------: | ------: | -------: | -----------------: | ------------------: | --------: |
| **Videos**            |     6,406 |   1,219 |    2,647 |              1,051 |               2,211 |    13,534 |
| **Ticks (1 Hz)**      |    97,649 |  11,220 |   23,661 |             21,020 |              39,342 |   192,892 |

A *tick* is a 1-second sliding-window record carrying 8 consecutive
frame indices plus the action label at the window's last frame.

### Per-source video counts

| Source             | Train | Val | Test | Extra: ADAS-TO | Extra: ACCIDENT | Native source                                                |
| ------------------ | ----: | --: | ---: | -------------: | --------------: | ------------------------------------------------------------ |
| **Nexar Collision** | 1,500 | 667 |  677 |              — |               — | Kaggle (Nexar Collision Prediction Challenge 2024)           |
| **DoTA**           | 2,949 | 326 | 1,402 |              — |               — | Detection of Traffic Anomaly (Yao et al. 2022)               |
| **DAD**            | 1,157 | 127 |  466 |              — |               — | Dashcam Accident Dataset (Chan et al. 2016)                  |
| **DADA-2000**      |   798 |  99 |  102 |              — |               — | Driver Attention in Accidents (Fang et al. 2022)             |
| **ADAS-TO-Critic** |     — |   — |    — |          1,051 |               — | Critical takeover scenarios (this work; videos co-hosted)    |
| **Kaggle ACCIDENT** |     — |   — |    — |              — |           2,211 | Kaggle ACCIDENT @ CVPR 2026 (Picek et al. 2026)              |

### Per-source tick counts (1 Hz sliding window)

| Source            |   Train |    Val |    Test | Extra: ADAS-TO | Extra: ACCIDENT |
| ----------------- | ------: | -----: | ------: | -------------: | --------------: |
| Nexar Collision   |  56,948 |  6,721 |   6,831 |              — |               — |
| DoTA              |  29,763 |  3,256 |  14,103 |              — |               — |
| DAD               |   4,628 |    508 |   1,864 |              — |               — |
| DADA-2000         |   6,310 |    735 |     863 |              — |               — |
| ADAS-TO-Critic    |       — |      — |       — |         21,020 |               — |
| Kaggle ACCIDENT   |       — |      — |       — |              — |          39,342 |
| **Total**         |  97,649 | 11,220 |  23,661 |         21,020 |          39,342 |

### Action-label distribution (per split)

| Split                | SILENT | OBSERVE | ALERT |
| -------------------- | -----: | ------: | ----: |
| train                |  83.3% |    7.2% |  9.5% |
| val                  |  86.5% |    5.6% |  8.0% |
| test                 |  77.8% |    9.1% | 13.1% |
| extra_val_adasto     |  80.0% |   10.0% | 10.0% |
| extra_val_accident   |  77.9% |   10.8% | 11.2% |

### Category distribution (public-facing schema)

We expose **three** clip-level categories: `positive` (an event
occurs), `negative` (no event), `mixed` (continuous human-takeover
clips with both alert and silent segments). Per-frame action labels
remain the primary supervision target.

| Split                | positive | negative |  mixed |
| -------------------- | -------: | -------: | -----: |
| train                |   66,686 |   30,963 |      — |
| val                  |    7,571 |    3,649 |      — |
| test                 |   19,066 |    4,595 |      — |
| extra_val_adasto     |        — |        — | 21,020 |
| extra_val_accident   |   39,342 |        — |      — |

---

## Splits

| Split                | Purpose                                                                              |
| -------------------- | ------------------------------------------------------------------------------------ |
| `train`              | In-domain training (Nexar + DoTA + DAD + DADA-2000). Stratified, leakage-free.       |
| `val`                | In-domain validation for model selection.                                            |
| `test`               | In-domain held-out test (each source's *native* test split, untouched).              |
| `extra_val_adasto`   | **Held-out OOD** — full ADAS-TO-Critic corpus. Never used for training or selection. |
| `extra_val_accident` | **Held-out OOD** — Kaggle ACCIDENT @ CVPR 2026 challenge clips.                      |

All five splits are video-disjoint
(`stats/leakage_report.json` — max overlap = 0).

---

## Source datasets, licenses, and how to obtain the videos

| Source            | Videos hosted here?    | Where to obtain                                                | License                                          |
| ----------------- | ---------------------- | -------------------------------------------------------------- | ------------------------------------------------ |
| Nexar Collision   | ✗ annotations only     | https://www.kaggle.com/competitions/nexar-collision-prediction | Kaggle competition terms (non-commercial use)    |
| DoTA              | ✗ annotations only     | https://github.com/MoonBlvd/Detection-of-Traffic-Anomaly       | Research-only                                    |
| DAD               | ✗ annotations only     | http://aliensunmin.github.io/project/dashcam/                  | Research-only                                    |
| DADA-2000         | ✗ annotations only     | https://github.com/JWFangit/LOTVS-DADA                         | Research-only                                    |
| **ADAS-TO-Critic** | **✓ full mp4s** (1.6 GB) | This repository, `adasto_critic_videos/`                       | CC-BY-NC-4.0 (this work)                         |
| Kaggle ACCIDENT   | ✗ annotations only     | https://www.kaggle.com/competitions/accident                   | Kaggle competition terms                         |

> ADAS-TO-Critic videos are mirrored in this repository under
> `adasto_critic_videos/` so the OOD evaluation can be reproduced
> end-to-end without further downloads.

---

## How to load

### Read the parquet directly (no install of `datasets` needed)

```python
import pandas as pd
val = pd.read_parquet("hf://datasets/HenryYHW/VLAlert/data/val.parquet")
print(val.head())
print(val.tick_label.value_counts())   # 0=SILENT 1=OBSERVE 2=ALERT
```

### Use the HuggingFace `datasets` loader

```python
from datasets import load_dataset

ds = load_dataset("HenryYHW/VLAlert", split="validation")
print(ds[0])
# {'video_id': 'nexar_00002',
#  'source': 0,                  # ClassLabel: nexar
#  'category': 0,                # ClassLabel: positive
#  'frame_indices': [...8 ints], # window of consecutive frame indices
#  'tta_raw': 5.13,              # seconds-to-event at last frame
#  'tick_label': 1,              # ClassLabel: OBSERVE
#  'video_path': 'NEXAR_COLLISION/test-public/positive/00002.mp4',
#  ...}

ds_adasto = load_dataset("HenryYHW/VLAlert", split="extra_val_adasto")
ds_kaggle = load_dataset("HenryYHW/VLAlert", split="extra_val_accident")
```

### Materialize frames from a local copy of the source videos

```python
import cv2
def load_window(record, root="/path/to/your/source-dataset-root"):
    cap = cv2.VideoCapture(f"{root}/{record['video_path']}")
    frames = []
    for fi in record["frame_indices"]:
        cap.set(cv2.CAP_PROP_POS_FRAMES, fi)
        ok, frame = cap.read()
        if ok:
            frames.append(frame)
    cap.release()
    return frames
```

For ADAS-TO-Critic, the corresponding mp4s live in the repo at
`adasto_critic_videos/<video_id>.mp4` — pull them with the HF Hub or
`git lfs`.

---

## Label generation rules

For each clip with an event time `t_event` (seconds since clip start),
per-frame labels are assigned as:

| Window relative to t_event           | Label   |
| ------------------------------------ | ------- |
| `t < t_event − 4`                    | SILENT  |
| `t_event − 4 ≤ t < t_event − 2`      | OBSERVE |
| `t_event − 2 ≤ t < t_event`          | ALERT   |
| `t ≥ t_event` (post-event)           | SILENT  |
| (any frame of a `negative` clip)     | SILENT  |

Source-specific event time:

| Source            | `t_event` (seconds)                                                          |
| ----------------- | ---------------------------------------------------------------------------- |
| Nexar             | `time_of_event` from per-folder `metadata.csv`                               |
| DoTA              | `anomaly_start` (frames) ÷ 10 fps                                            |
| DAD               | fixed `t_event = 4.0` (videos are 4 s leading directly into the accident)    |
| DADA-2000         | `accident_time` (frames) ÷ 30 fps from per-clip `annotation.json`            |
| ADAS-TO-Critic    | fixed `t_event = 10.0` (uniform 20 s clips centred on the takeover request)  |
| Kaggle ACCIDENT   | `t_takeover` from `takeover_manifest_b50.csv`                                |

Each tick is a 1 Hz slide of an 8-frame window. The tick label is the
per-frame label at the **last** frame of the window.

---

## File layout

```
HenryYHW/VLAlert/
├── README.md                              ← this file
├── vlalert_bench.py                       ← HF GeneratorBasedBuilder loader
├── dataset_infos.json                     ← lightweight metadata
├── manifest/
│   ├── video_split.json                   ← all 13,534 videos, full schema
│   ├── nexar_split.json
│   ├── dota_split.json
│   ├── dad_split.json
│   ├── dada_split.json
│   ├── adasto_critic_split.json
│   └── accident_split.json
├── labels/
│   ├── train_perframe.json                ← per-video per-frame labels
│   ├── val_perframe.json
│   ├── test_perframe.json
│   ├── extra_val_adasto_perframe.json
│   └── extra_val_accident_perframe.json
├── data/
│   ├── train.parquet                      ← per-tick records (primary training input)
│   ├── val.parquet
│   ├── test.parquet
│   ├── extra_val_adasto.parquet
│   └── extra_val_accident.parquet
├── adasto_critic_videos/                  ← 1,051 mp4 clips (ADAS-TO-Critic full source)
└── stats/
    ├── per_source_video_count.csv
    └── leakage_report.json
```

---

## Reproducibility

All split assignments are deterministic given the source datasets
(`seed = 42`; 10 % of each native training set carved into `val`).
To regenerate from scratch:

```bash
python tools/build_unified_benchmark.py --step all
```

---

## Citations

### Primary

```bibtex
@misc{wang2026vlalertbench,
  author = {Wang, Yuhang and Zhou, Hao},
  title  = {VLAlert-Bench: A Unified Benchmark for Driving-Alert Decisions},
  year   = {2026},
  url    = {https://huggingface.co/datasets/HenryYHW/VLAlert}
}
```

### Source-dataset attribution (please cite the ones you use)

```bibtex
@misc{nexar2024collision,
  author       = {{Nexar}},
  title        = {Nexar Collision Prediction Challenge},
  year         = {2024},
  howpublished = {\url{https://www.kaggle.com/competitions/nexar-collision-prediction}},
  note         = {Kaggle competition}
}

@inproceedings{yao2022dota,
  title     = {{DoTA}: Unsupervised Detection of Traffic Anomaly in Driving Videos},
  author    = {Yao, Yu and Wang, Xizi and Xu, Mingze and Pu, Zelin and Wang, Yuchen and Atkins, Ella and Crandall, David J.},
  booktitle = {IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI)},
  year      = {2022}
}

@inproceedings{chan2016dad,
  title     = {Anticipating Accidents in Dashcam Videos},
  author    = {Chan, Fu-Hsiang and Chen, Yu-Ting and Xiang, Yu and Sun, Min},
  booktitle = {Asian Conference on Computer Vision (ACCV)},
  year      = {2016}
}

@article{fang2022dada,
  title   = {{DADA}-2000: Can Driving Accident be Predicted by Driver Attention? Analyzed by a Benchmark},
  author  = {Fang, Jianwu and Yan, Dingxin and Qiao, Jiahuan and Xue, Jianru and Yu, Hongkai},
  journal = {IEEE Transactions on Intelligent Transportation Systems},
  year    = {2022}
}

@misc{accident2026cvpr,
  author       = {Picek, Lukas and {\v{C}}erm{\'a}k, Vojt{\v{e}}ch and Hanzl, Marek and {\v{C}}erm{\'a}k, Michal},
  title        = {{ACCIDENT} @ {CVPR}},
  year         = {2026},
  howpublished = {\url{https://kaggle.com/competitions/accident}},
  note         = {Kaggle}
}

@misc{adastocritic2026,
  author = {Wang, Yuhang and Zhou, Hao},
  title  = {{ADAS-TO-Critic}: Critical Takeover Scenarios for Driver-Alert Evaluation},
  year   = {2026},
  note   = {Released as part of VLAlert-Bench, this repository},
  url    = {https://huggingface.co/datasets/HenryYHW/VLAlert}
}
```

### Related methodology

```bibtex
@article{kaelbling1998planning,
  title   = {Planning and Acting in Partially Observable Stochastic Domains},
  author  = {Kaelbling, Leslie Pack and Littman, Michael L. and Cassandra, Anthony R.},
  journal = {Artificial Intelligence},
  volume  = {101}, number = {1-2}, year = {1998}
}

@inproceedings{lee2019set,
  title     = {Set Transformer: A Framework for Attention-based Permutation-Invariant Neural Networks},
  author    = {Lee, Juho and Lee, Yoonho and Kim, Jungtaek and Kosiorek, Adam R. and Choi, Seungjin and Teh, Yee Whye},
  booktitle = {International Conference on Machine Learning (ICML)},
  year      = {2019}
}

@inproceedings{cho2014gru,
  title     = {Learning Phrase Representations using {RNN} Encoder--Decoder for Statistical Machine Translation},
  author    = {Cho, Kyunghyun and van Merri{\"e}nboer, Bart and Gulcehre, Caglar and Bahdanau, Dzmitry and Bougares, Fethi and Schwenk, Holger and Bengio, Yoshua},
  booktitle = {EMNLP},
  year      = {2014}
}

@inproceedings{hu2022lora,
  title     = {{LoRA}: Low-Rank Adaptation of Large Language Models},
  author    = {Hu, Edward J. and Shen, Yelong and Wallis, Phillip and Allen-Zhu, Zeyuan and Li, Yuanzhi and Wang, Shean and Wang, Lu and Chen, Weizhu},
  booktitle = {ICLR},
  year      = {2022}
}
```

---

## Acknowledgments

We thank the maintainers of Nexar, DoTA, DAD, DADA-2000, and the
organizers of the Kaggle ACCIDENT @ CVPR 2026 challenge for releasing
their data. This work was supported in part by the University of
South Florida.

---

## v6 — Per-Tick Refresh (2026-05-29)

`annotations/v6/` hosts the **current** per-tick benchmark used by all
paper numbers (replaces the v4_sft and v5 jsonl, which remain for
backwards-compat reproducibility).

### Labelling rule

For each tick whose anchor (last) frame falls at $t_f$, given an event
onset $t^{\star}$ extracted from the source's native annotation:

* `t_f < t*`                                  →  **SILENT**
* `t* ≤ t_f ≤ t* + 5s`                        →  **ALERT**       (DADA, Nexar)
* `t_f > t* + 5s`                             →  **DISCARD**     (post-window, not informative)

**Corpus-specific exceptions** that preserve source semantics:

* **DoTA** replaces the fixed 5s window with the native
  `[anomaly_start, anomaly_end)` span; post-anomaly ticks are
  **SILENT** ("incident resolved") rather than discarded.
* **DAD** retains clip-level labels (no per-frame event timestamps
  available).
* **ADAS-TO-Critic** (test-only OOD): all clips share an expert-reviewed
  takeover at `t* = 10s`; the analysis window is `[1, 12]s`, and
  `t_f > 12s` is discarded.
* **ACCIDENT (CARLA)** (test-only OOD): all clips are positive;
  evaluation uses only pre-accident ticks (`t_f ≤ t*`).

Event-time sources:
`annotation.json[accident_time]` for DADA;
`metadata.csv[time_of_event] × 20` for Nexar (20 fps annotation);
`anomaly_start/end` for DoTA;
`labels.csv[accident_time]` for CARLA-ACCIDENT.

### Files

| File                                                             |   Size | Ticks  |
| ---------------------------------------------------------------- | -----: | -----: |
| `annotations/v6/v5_sft/v5_sft_train_v6.jsonl`                    | 97 MB  | 80,221 |
| `annotations/v6/v5_sft/v5_sft_val_v6.jsonl`                      | 13 MB  | 11,149 |
| `annotations/v6/extra_val_adasto/v5_sft_extra_val_adasto_v6.jsonl`| 14 MB | 12,612 |
| `annotations/v6/v6_changelog.json`                               |   1 KB |      — |
| `annotations/v6/extra_val_adasto/v6_changelog_adasto.json`       |   1 KB |      — |
| `annotations/v6/build_v6_dataset.py`                             |   5 KB |      — |

### Per-source class distribution (v6)

**Train (80,221 ticks, 80% / 5.2% / 21.4% S/O/A overall)**

| Source     | Clips |  Ticks | SILENT | OBSERVE | ALERT |
| ---------- | ----: | -----: | -----: | ------: | ----: |
| Nexar      | 1,500 | 40,190 | 36,900 |      98 | 3,192 |
| DoTA       | 2,949 | 29,763 | 15,906 |   3,948 | 9,909 |
| DAD        | 1,157 |  4,628 |  2,988 |       0 | 1,640 |
| DADA-2000  |   800 |  5,640 |  3,090 |     106 | 2,444 |

**Val (11,149 ticks, 77.6% / 4.6% / 17.8% S/O/A overall)**

| Source     | Clips |  Ticks | SILENT | OBSERVE | ALERT |
| ---------- | ----: | -----: | -----: | ------: | ----: |
| Nexar      |   667 |  6,721 |  6,232 |      72 |   417 |
| DoTA       |   326 |  3,256 |  1,735 |     428 | 1,093 |
| DAD        |   127 |    508 |    328 |       0 |   180 |
| DADA-2000  |    99 |    664 |    356 |       9 |   299 |

**Test-only OOD splits**

| Split | Clips | Ticks | Notes |
| --- | ---: | ---: | --- |
| ADAS-TO-Critic (v6, `[0,12]s` window) | 1,051 | 12,612 | 1,051 SILENT (pre-1s) + 11,561 ALERT |
| ACCIDENT — CARLA labelled set | 2,211 | 17,224 | pre-accident ticks only; all clips positive |

### Diff vs v5_sft_*.jsonl

|              | v5 ticks |  v6 kept | Δ discarded | Label flips |
| ------------ | -------: | -------: | ----------: | ----------: |
| Train        |   97,649 |   80,221 |      17,428 |       4,768 |
| Val          |   11,220 |   11,149 |          71 |         319 |
| ADAS-TO val  |   21,020 |   12,612 |       8,408 |       9,459 |

### Reproducing

```bash
python annotations/v6/build_v6_dataset.py            # rebuilds train+val v6
```

Both scripts emit per-source diffs into the changelog JSONs.

The original `annotations/v4_sft/` and v5 splits remain unchanged so
downstream code can pin either version.