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.

CASCADE: Causal Spatio-Temporal Analysis of Driving Environments

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. 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
Labeling Method
- Human

Designed to be used in combination with the NVIDIA Physical AI Dataset for AV 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.^† 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.

^† To be used in combination with the existing video clips (.mp4) from the NVIDIA Physical AI Dataset for AV. 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).

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.
Field-level reference — every Pydantic model with field names, types, enums, and ontology-prefixed vocabularies: see 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.
Causal Q&A task format — multiple-choice causal reasoning questions, answer formats, query types, and grounding evidence: see 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 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. 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:

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.

Quickstart

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:

For non-Python pipelines, the raw JSONs can be pulled with huggingface_hub.snapshot_download(...) or auto-detected by the HF 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.

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.

Citation

If you use CASCADE in your research, please cite:

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

Downloads last month: 6

Total file size:

7.54 MB