Datasets:

nvidia
/

cascade

	---
	pretty_name: "CASCADE: Causal Spatio-Temporal Analysis of Driving Environments"
	license: other
	license_name: nvidia-autonomous-vehicle-dataset-license
	license_link: https://huggingface.co/datasets/nvidia/cascade/blob/main/LICENSE.pdf
	language:
	- en
	task_categories:
	- other
	tags:
	- autonomous-driving
	- autonomous-vehicles
	- self-driving
	- driving-scenes
	- scene-understanding
	- spatio-temporal
	- causal-reasoning
	- video-understanding
	- annotations
	- nvidia
	- physical-ai
	size_categories:
	- 1K<n<10K
	configs:
	- config_name: default
	data_files:
	- split: train
	path:
	- data/batch_00001/*.json
	extra_gated_heading: "Access to CASCADE is gated"
	extra_gated_description: \|
	CASCADE is released under the NVIDIA Autonomous Vehicle Dataset License Agreement — a
	custom, non-commercial research license. Access is reviewed and approved on a
	per-user basis by NVIDIA. Please provide the information below and agree to
	the license terms; you will be notified once your request has been reviewed.
	extra_gated_button_content: "Request access"
	extra_gated_fields:
	Full name: text
	Affiliation: text
	Country: country
	Job title:
	type: select
	options:
	- Student
	- Researcher (academia)
	- Researcher (industry)
	- Engineer
	- Other
	Intended research use (1–2 sentences): text
	I will use CASCADE for non-commercial research only and will not redistribute it: checkbox
	I have read and agree to the NVIDIA Autonomous Vehicle Dataset License Agreement: checkbox
	---

	# CASCADE: Causal Spatio-Temporal Analysis of Driving Environments

	<!--
	Once the teaser figure is ready, drop it into assets/ and uncomment:
	![CASCADE teaser](assets/teaser.png)
	-->

	The CASCADE dataset adds causally-linked, temporally-ordered annotations to
	2,000+ 20-second driving clips drawn from the
	[NVIDIA Physical AI Dataset for AV](https://huggingface.co/datasets/nvidia/PhysicalAI-Autonomous-Vehicles).
	Each clip is annotated as a temporally ordered structure of environments,
	agents, traffic control, and actions — explicitly linked by causal and
	co-reference relations — so that complex driving scenarios can be queried
	as structured graphs rather than recovered from raw pixels. This dataset is
	for research and development only.

	* Data Collection Method
	* Human
	* Built upon the existing [NVIDIA Physical AI Dataset for AV](https://huggingface.co/datasets/nvidia/PhysicalAI-Autonomous-Vehicles)
	* Labeling Method
	* Human

	Designed to be used in combination with the
	[NVIDIA Physical AI Dataset for AV](https://huggingface.co/datasets/nvidia/PhysicalAI-Autonomous-Vehicles)
	clips it references. Annotation schema version `2.0.0`.

	## Applications

	CASCADE supports research workflows focused on causal and spatio-temporal
	driving scenarios:

	- Causal scenario mining — query for interactions in which one entity's
	action causes another's response, at scale and with structured predicates.
	- Spatio-temporal scene understanding — train and evaluate models that
	reason jointly about position, motion, and intent of multiple agents over
	20-second windows.
	- Behavior prediction with causal grounding — fine-tune trajectory and
	intent-prediction models against examples explicitly labeled with what
	each actor was reacting to.
	- Vision-Language-Action (VLA) reasoning evaluation — structured
	complement to the Chain-of-Causation labels released alongside the parent
	Physical AI dataset.
	- AV Causal Scenario Retrieval (Coming soon) — evaluate video retrieval
	systems that, given a natural-language causal driving scenario, must
	retrieve all matching Physical AI videos using the CASCADE annotations as
	ground truth.
	- Causal Q&A (Coming soon) — evaluate multiple-choice causal reasoning over
	driving clips, including risk-entity localization, causal identification,
	multihop causality, counterfactuals, compliance, and spatial-causal reasoning.

	## Dataset

	### Dataset Description

	A dataset of 2,000+ labeled driving scenes, 20 seconds long,
	built upon the NVIDIA Physical AI Dataset for AV. CASCADE is designed to
	capture complex interactions involving the ego vehicle, the environment,
	other agents, and traffic elements, with a strong focus on **spatial,
	temporal, and causal relationships**. The dataset is distributed as a
	collection of JSON files, intended to be used in combination with the
	Physical AI Dataset for AV, and ships with a companion devkit to simplify
	its use.

	### Dataset Characterization

	Clips are selected from the ~300,000 clips in the Physical AI dataset.
	2,000+ clips are manually curated as eventful, non-nominal seed
	examples (ego interacts with another agent, or performs a maneuver in an
	interesting environment such as a construction zone or severe weather). A
	classifier trained on these seeds then selects approximately 30,000
	non-nominal candidate clips from the full corpus, of which the released
	CASCADE set of 2,000+ clips is annotated.

	Each selected clip is annotated end-to-end by one annotator and then
	reviewed by an independent reviewer. If the review is positive the
	annotation is accepted; otherwise it is returned with comments for rework
	and re-reviewed before entering the dataset. Each annotated clip also records
	why it is non-nominal via a clip-level `eventful_reason` field
	(`ego_adapts`, `special_environment`, `agent_adapts`, or `other`).

	### Dataset Quantification

	\| Metric \| Value \|
	\|-------------------------------------\|-----------\|
	\| Total clips (annotated) \| 2,066 \|
	\| Annotation files released (`data/`) \| 2,066 \|
	\| Clip duration \| 20 s \|
	\| Total annotated hours \| ~11.5 h \|
	\| Released data size \| ~11 MB \|

	## Annotation Data Structure

	Annotations are structured text (`.json`), schema version `2.0.0`.<sup>†</sup>
	Each `annotation-<hash>.json` records a single 20-second clip with
	causally-linked, temporally-grounded annotations across four categories:

	- Environments and conditions — road type (intersection, roundabout,
	tunnel, …), lane layout, crosswalks, weather, lighting, and special
	conditions such as construction zones.
	- Ego vehicle — actions performed by the recording vehicle and its
	containment within environments over time.
	- Agents — every relevant non-ego road user (vehicles, pedestrians,
	cyclists, officers, …) with type, quantity, timestamped actions, position
	and direction relative to ego, containment, and bounding-box tracks.
	- Static & regulatory objects — traffic lights with timestamped
	color/modulation state, plus signs, cones, barriers, and debris with
	type, visibility window, and containment.

	> Optional layers. Environments, conditions, and containment are
	> optional and are annotated only where relevant to the ego or
	> ego-influencing agents — they are not guaranteed to be dense or present on
	> every clip. Coverage depends on the annotation scope: ego-centric batches
	> concentrate on ego and agent behavior and may carry few or no environments
	> and little or no containment (the ego in particular may have none). Treat
	> the environment and containment layers as optional and do not assume
	> per-clip spatial grounding.

	These entities are connected by four families of inter-entity link that
	turn co-occurring events into structured interactions, summarised below.

	<sup>†</sup> To be used in combination with the existing video clips
	(`.mp4`) from the
	[NVIDIA Physical AI Dataset for AV](https://huggingface.co/datasets/nvidia/PhysicalAI-Autonomous-Vehicles).
	CASCADE does not redistribute video; each record's `video.clip_id`
	references the underlying Physical AI clip.

	### Inter-entity links

	\| Family \| Carrier \| Meaning \|
	\|-------------------------------\|----------------------------------\|------------------------------------------------------------------------------------------------------------------\|
	\| `because_of` \| `AgentAction` / `EgoAction` \| Causal. This action was performed in response to the listed entities — e.g., ego decelerated because of a yellow signal state. \|
	\| `action_target` \| `AgentAction` / `EgoAction` \| The entities this action is directed at — e.g., the agent being yielded to or overtaken. \|
	\| `containment` \| `Agent` / `EgoVehicle` \| The environment regions an entity is inside of over a window (e.g., a particular lane of a crossroad). \|
	\| `influence` (`influenced_by`) \| `Agent` / `EgoVehicle` \| Other entities that modulate this entity's behavior over a window, without being its direct cause. \|

	`because_of` (action-rooted cause) and `influenced_by` (its subject-state
	complement — an entity whose state was modulated by another over a window)
	are the principal mechanisms by which the annotation captures
	interactions as distinct from independent co-occurrences, and both are
	surfaced as first-class operators in the devkit's query DSL (see
	[Developer Tooling](#developer-tooling)).

	### Where to read more

	- Conceptual format — entities, type groups, spatial context, traffic
	control, the action vocabulary and orthogonal flags, ego-relative pose,
	temporal grounding, and a fully worked example walking through one clip:
	see [`docs/annotation-format.md`](docs/annotation-format.md).
	- Field-level reference — every Pydantic model with field names, types,
	enums, and ontology-prefixed vocabularies: see
	[`docs/schema.md`](docs/schema.md). The canonical machine-readable source
	of truth is the Pydantic model in the devkit
	(`src/cascade_av/spec/schema.py`).
	- Retrieval task format — natural-language scenario queries, expected
	matching clips, split files, and batch JSON structure: see
	[`docs/retrieval-task.md`](docs/retrieval-task.md).
	- Causal Q&A task format — multiple-choice causal reasoning questions,
	answer formats, query types, and grounding evidence: see
	[`docs/causal-qa-task.md`](docs/causal-qa-task.md).

	### File Structure

	```
	cascade/
	├── data/
	│ ├── batch_00001/
	│ │ ├── <clip_uuid>__<annotation_hash>.json
	│ │ └── …
	│ └── batch_NNNNN/
	│ └── …
	├── tasks/
	│ ├── causal_qa/
	│ │ ├── causal_qa_split.yaml # Causal Q&A split manifest
	│ │ ├── batch_00001/
	│ │ │ └── causal_qa.json
	│ │ └── batch_NNNNN/
	│ │ └── …
	│ └── retrieval/
	│ ├── retrieval_split.yaml # Retrieval query split manifest
	│ ├── batch_00001/
	│ │ ├── train_queries.json
	│ │ └── val_queries.json
	│ └── batch_NNNNN/
	│ └── …
	├── docs/
	│ ├── annotation-format.md # Conceptual format reference
	│ ├── causal-qa-task.md # Causal Q&A task format
	│ ├── retrieval-task.md # AV Causal Scenario Retrieval task format
	│ └── schema.md # Field-level Pydantic / JSON reference
	├── assets/ # Figures, illustrations
	└── README.md
	```

	### AV Causal Scenario Retrieval (Coming soon)

	CASCADE will include an AV Causal Scenario Retrieval task. It will provide
	natural-language queries describing causal driving scenarios, and systems will
	be expected to retrieve all videos from the referenced Physical AI Dataset
	that match each query. Ground-truth matches will be listed by Physical AI
	`clip_id` and by the CASCADE annotation JSON file supporting the match.

	The task will be released with train and validation splits. Split
	assignments will be recorded as named, versioned splits in
	[`tasks/retrieval/retrieval_split.yaml`](tasks/retrieval/retrieval_split.yaml)
	for the retrieval task — each split will have a name (e.g. `v0.1`), an
	introduction date, and `train` / `val` lists of retrieval batch JSON files.
	Those batch files will contain retrieval items with a natural-language `query`
	and a `matches` list. Each match will record the Physical AI Dataset `clip_id`
	and the CASCADE `annotation_file` satisfying the query. New task splits will be
	appended over time; existing ones will never be modified, so published results
	remain reproducible.

	### Causal Q&A (Coming soon)

	CASCADE will also include a Causal Q&A task. It will provide multiple-choice
	questions derived from CASCADE's dense annotation graphs. Each item will
	include a `query_type`, a natural-language question, lettered answer options,
	the correct option letters, the Physical AI `clip_id`, the supporting CASCADE
	`annotation_file`, and a `cascade_grounding` block identifying the annotation
	fields and IDs used to derive the answer.

	Causal Q&A splits will be recorded in
	[`tasks/causal_qa/causal_qa_split.yaml`](tasks/causal_qa/causal_qa_split.yaml).
	The planned task schema covers risk-entity localization, causal
	identification, multihop causality, counterfactual yes/no questions,
	compliance yes/no questions, and spatial-causal questions.

	## Intended Usage

	This dataset may be used for autonomous-vehicle-related research use
	cases only, for non-commercial purposes, and subject to the license
	terms below.

	## Developer Tooling

	The CASCADE Python developer kit, `cascade_av`, lives at
	<https://github.com/nv-tlabs/cascade-devkit> (Apache-2.0). It parses
	each annotation JSON into a typed Pydantic tree, exposes a small **query
	DSL** with causal and temporal operators, and ships with Jupyter
	visualization, a local annotation tool, and on-demand fetching of the
	underlying Physical AI sensor data.

	On a fresh Ubuntu / Debian host, one line clones the repo, installs system
	prerequisites (apt + Node LTS + uv), runs `make install`, and smoke-tests
	the Python side:

	```bash
	curl -LsSf https://raw.githubusercontent.com/nv-tlabs/cascade-devkit/main/scripts/install.sh \| bash
	```

	The script is idempotent — re-running is safe. If you already have
	Python ≥ 3.11, `uv`, Node ≥ 18, and `ffmpeg` on PATH, `make install`
	inside a clone is the lighter alternative. The full install matrix
	(devcontainer, pip-from-git for read/query-only workflows) is in the
	[devkit README](https://github.com/nv-tlabs/cascade-devkit#install).

	### Quickstart

	```python
	from cascade_av.dataset import CascadeDataset

	ds = CascadeDataset("/path/to/json_annotations")

	# Causal query — ego decelerates BECAUSE OF a pedestrian.
	matches = ds.find("ego.action = decel because_of agent.type = ped")

	# Influence query — ego's state was influenced by a red light.
	at_red = ds.find("ego influenced_by light.color = red")

	# Fetch the canonical camera for the first match and visualize it in Jupyter.
	m = matches.matches[0]
	ds.download_clips([m.clip_id])
	ds.get_sequence(m.clip_id).visualize(match=m, pad=1.0)
	```

	The query DSL composes causal, temporal, and spatial predicates
	(`because_of`, `influenced_by`, `then(N)`, `while`, `within …:`, `and / or / not`, …).
	See the devkit's documentation for:

	- [Full DSL grammar](https://github.com/nv-tlabs/cascade-devkit/blob/main/docs/user/query_language.md)
	- [Visualization API + timeline filters](https://github.com/nv-tlabs/cascade-devkit/blob/main/docs/user/visualization.md)
	- [Sensor-data fetching from the Physical AI AV dataset](https://github.com/nv-tlabs/cascade-devkit#working-with-the-sensor-data)
	- [Local annotator tool — editing the JSON bundles in-browser](https://github.com/nv-tlabs/cascade-devkit/blob/main/docs/user/annotator.md)

	For non-Python pipelines, the raw JSONs can be pulled with
	`huggingface_hub.snapshot_download(...)` or auto-detected by the HF
	[`datasets`](https://huggingface.co/docs/datasets) library via the
	`configs` declaration in this card's YAML front-matter.

	## Version History

	\| Version \| Notes \|
	\|---------\|---------------------------------------------------------------------------------------------------------------------------\|
	\| 0.1 \| Initial release. 2,000+ annotated 20-second clips. Annotation schema version `2.0.0`. \|

	Previous versions, when present, will be tagged and remain accessible through
	the Hugging Face repo history.

	## License/Terms of Use

	This dataset is made available under a custom **NVIDIA Autonomous Vehicle
	Dataset License Agreement** — a non-commercial research license. Access is gated;
	users must agree to the terms before being granted access, and NVIDIA reviews
	and approves access on a per-user basis.

	Key terms:

	- Non-commercial research use only.
	- No redistribution.
	- All rights remain with NVIDIA and its licensors.

	The full text of the license is included in this repository as
	[`LICENSE.pdf`](LICENSE.pdf).

	## Dataset Owner(s)

	NVIDIA Corporation.

	## Ethical Considerations

	NVIDIA believes Trustworthy AI is a shared responsibility, and we have
	established policies and practices to enable development for a wide array of
	AI applications. When downloaded or used in accordance with our terms of
	service, developers should work with their internal developer teams to ensure
	that this dataset meets the requirements of the relevant industry and use
	case and addresses unforeseen product misuse.

	Please report quality, risk, security vulnerabilities, or NVIDIA AI concerns
	[here](https://www.nvidia.com/en-us/support/submit-security-vulnerability/).

	## Citation

	If you use CASCADE in your research, please cite:

	```bibtex
	@misc{cascade2026,
	title = {{CASCADE}: Causal Spatio-Temporal Analysis of Driving Environments},
	author = {NVIDIA Corporation},
	year = {2026},
	howpublished = {\url{https://huggingface.co/datasets/nvidia/cascade}}
	}
	```