---
pretty_name: WOD-E2E Fast-dDrive SASD (TPU-ready)
license: other
license_name: waymo-open-dataset-license
license_link: https://waymo.com/open/terms/
tags:
- autonomous-driving
- waymo-open-dataset
- vision-language-action
- diffusion-language-model
- tpu
size_categories:
- n<1K
configs:
- config_name: default
  data_files:
  - split: train
    path: train-*.parquet
---

# WOD-E2E Fast-dDrive SASD — TPU-ready training shards

Pre-tokenized **Section-Aware Structured Diffusion (SASD)** training samples for the
Fast-dDrive Qwen2.5-VL-3B block-diffusion driving model, packaged as sharded Apache
Parquet for **multi-host TPU training** (grain / `datasets` / MaxText `hf` data path).

Each row is one Waymo Open Dataset End-to-End (WOD-E2E) front-camera frame, already run
through the Fast-dDrive prep (chat template + Qwen2.5-VL processor + deep-JSON scaffold +
3D M-RoPE positions + per-section block indices), so the TPU side needs **no tokenizer,
no processor, no torch** — it just loads arrays and trains.

> ⚠️ **PRIVATE / license-restricted.** This data is derived from the Waymo Open Dataset and
> is shared **privately** under the [WOD License](https://waymo.com/open/terms/), which
> prohibits redistribution. Do not make this dataset public or share it outside your
> licensed use.

## Honest limitations (read before using)
- **Pseudo text labels.** WOD-E2E ships **no native text targets**. `trajectory` and
  `future_meta_behavior` derive from real GT / ego-intent; `critical_objects` and
  `explanation` are **heuristic pseudo-labels**. Train/eval accordingly.
- **Subset.** This is a ~400-frame representative subset. The full 263-shard WOD-E2E train
  split runs through the identical 3-stage pipeline (see "Provenance").
- **Not TPU-verified by the author.** The packaging + decode is bit-exact verified on CPU/GPU;
  end-to-end TPU training is the intended downstream use, validated on emulation + a single GPU.

## Schema (per row)
Scalars: `sample_id (str)`, `L (int32)`, `n_blocks (int32)`.
Arrays — each a little-endian binary blob + a `<name>_shape` int list:

| column | dtype | shape | meaning |
|---|---|---|---|
| `input_ids` | int64 | [L] | token ids (mask-padded to multiple of bd_size=32) |
| `labels` | int64 | [L] | -100 except assistant-response tokens |
| `rbi` | int32 | [L] | response-block index per token (-1 = none) |
| `turn` | int32 | [L] | turn index for the hybrid block-causal mask |
| `scaffold` | bool | [L] | fixed JSON-scaffold positions (never noised) |
| `weight_vec` | float32 | [L] | per-token section-importance weight |
| `block_alpha` / `block_beta` | float32 | [n_blocks] | per-block Beta noise schedule |
| `position_ids` | int32 | [3, L] | 3D M-RoPE positions |
| `vision_mask` | bool | [L] | image/vision-start token positions |
| `pixel_values` | float16 | [N, 1176] | Qwen2.5-VL patch features (3 front cams) |
| `image_grid_thw` | int64 | [n_img, 3] | per-image temporal/height/width grid |

## Reconstruct (numpy, framework-free)
```python
import numpy as np, pyarrow.parquet as pq
ARRAY_DTYPES = {  # see dataset_info_train.json
  "input_ids":"int64","labels":"int64","rbi":"int32","turn":"int32","scaffold":"bool",
  "weight_vec":"float32","block_alpha":"float32","block_beta":"float32",
  "position_ids":"int32","vision_mask":"bool","pixel_values":"float16","image_grid_thw":"int64"}
row = pq.read_table("train-00000-of-00007.parquet").to_pylist()[0]
def dec(name): return np.frombuffer(row[name], np.dtype(ARRAY_DTYPES[name])).reshape(row[name+"_shape"])
input_ids = dec("input_ids"); pixel_values = dec("pixel_values")
```
See `load_example.py` for a runnable version.

## Provenance (3-stage pipeline, reproducible at full scale)
1. `fast_ddrive/data/convert_wod_e2e.py` (autovla env): tfrecord → train JSON + JPEGs (`--with_target`).
2. `jax_ddrive/eval/prep_train_jax.py` (ddrive env): JSON+JPEGs → per-sample SASD npz.
3. `jax_ddrive/ddrive_jax/convert/prep_to_parquet.py` → these Parquet shards.

Model: `Efficient-Large-Model/Fast-dDrive` (Qwen2.5-VL-3B block-diffusion VLA).