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)

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

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

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:

python tools/build_unified_benchmark.py --step all

---

Citations

Primary

@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)

@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

@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

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.