README.md

---
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:
  - 10K<n<100K
configs:
  - config_name: default
    data_files:
      - split: train
        path:
          - data/batch_00001/004834ee-*.json
          - data/batch_00001/00d75a72-*.json
          - data/batch_00001/0142974a-*.json
          - data/batch_00001/02a3b715-*.json
          - data/batch_00001/03692422-*.json
          - data/batch_00001/044b58f9-*.json
          - data/batch_00001/05299522-*.json
          - data/batch_00001/06871d14-*.json
      - split: validation
        path:
          - data/batch_00001/077410f3-*.json
          - data/batch_00001/07c5490b-*.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
approximately **1,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.

## Dataset

### Dataset Description

A dataset of approximately **1,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.
**1,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 **1,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

**1,000** densely annotated 20-second driving clips.

## 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`).

### File Structure

```
cascade/
├── data/
│   ├── dataset_split.yaml     # Batch → split manifest (train / validation)
│   ├── batch_00001/
│   │   ├── <clip_uuid>__<annotation_hash>.json
│   │   └── …
│   └── batch_NNNNN/
│       └── …
├── docs/
│   ├── annotation-format.md   # Conceptual format reference
│   └── schema.md              # Field-level Pydantic / JSON reference
├── assets/                    # Figures, illustrations
└── README.md
```

CASCADE is released with **train** and **validation** splits. Split
assignments are recorded as **named, versioned splits** in
[`data/dataset_split.yaml`](data/dataset_split.yaml) — each split has a
name (e.g. `v0.1`), an introduction date, and per-file train / validation
lists. New splits are appended over time; existing ones are never modified,
so published results remain reproducible. The front-matter
`configs.data_files` always reflects the latest split.

## 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. Approximately **1,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}},
  note         = {[TBD: replace with full author list and venue once available]}
}
```