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.

Downloads last month: 25

Total file size:

1.87 GB

You need to agree to share your contact information to access this dataset

VLAlert-Bench (v1)