---
license: apache-2.0
tags:
  - vla
  - procthor
  - synthetic-data
  - vision-language-action
  - quadruped
  - robotics
language:
  - en
size_categories:
  - 100K<n<1M
---

# PrismVLA ProcTHOR data engine

Generates **R2R-superset** parquet rows from procedurally-generated AI2-THOR houses:
text instruction + per-step actions + frame folds + waypointing + object pointing + QA.
Designed for training the PrismVLA stack (PRISM SSM vision + 24L Mamba LM + delta-cross
fusion + PointHead + ActionHead) but the schema is byte-compatible with R2R-style
`AlignedRouteTapes` loaders, so any next-token-prediction VLA can train on it.

## Why this dataset matters

Real-world VLN data (R2R / RxR / EnvDrop / ScaleVLN) is forward-biased: ~64% of step
actions are "move forward" because turns are short. Pure step-action supervision
collapses small VLAs to a "move forward" prior. ProcTHOR rollouts can be re-sampled
freely — bias toward turn-heavy episodes, balance the action distribution at
generation time, and you cure the collapse without architectural changes.

This engine also exposes **omniscient ground truth** the real corpora don't:
per-step waypoint pixel projection, goal pixel, every visible object's UV +
3D + depth, and per-step QA pairs. All of it streams through a single
**R2R-byte-compatible** parquet so existing trainers read it unchanged.

## Output schema (per row = per episode)

R2R-compatible columns (an `AlignedRouteTapes` loader reads these unchanged):

| column | type | source |
|---|---|---|
| `id` | string | episode id |
| `video` | string | frames-dir relpath |
| `instruction` | string | natural English, stitched from subcommands |
| `n_phases` | int32 | |
| `subcommands` | json[str] | templated per phase, optionally Qwen-rewritten |
| `phase_spans` | json[[int,int]] | from `segment_actions()` |
| `phase_kinds` | json[str] | forward / left / right / stop |
| `actions` | json[int] | per-timestep discrete action |

Extra GT columns enabled by simulator omniscience:

| column | shape | head it feeds |
|---|---|---|
| `agent_pose` | `T x 6` | optional aux |
| `camera_intrinsics` | dict | needed by every projection |
| `action_chunks` | `T x K x 3` | ActionHead (body-frame [vx, vy, ωz]) |
| `waypoint_uv` | `T x 2` (NaN-able) | Waypointing PointHead |
| `goal_uv` | `T x 2` (NaN-able) | Goal-pointing PointHead |
| `visible_objects` | per-step list of dicts | Object-pointing PointHead + QA |
| `qa_pairs` | per-step list of dicts | LM grounding loss |
| `meta` | dict | episode metadata |

Frames live at `<out_dir>/frames/<episode_id>/rgb/00000.jpg`, etc — 512x512 JPG, fov 90°,
camera intrinsics in the parquet.

## Quick start (one rented box, multi-GPU)

```bash
# 1) Setup once
git clone https://huggingface.co/datasets/whab13/prismvla-procthor-engine
cd prismvla-procthor-engine
bash setup_env.sh

# 2) Edit generate_parallel.sh to set N_EPISODES_PER_SHARD + N_SHARDS,
#    then launch
bash generate_parallel.sh        # one shard per GPU, parallel

# 3) When done, push to a HF dataset repo
HF_TOKEN=hf_xxx OUT_DIR=./procthor_data REPO=whab13/prismvla-procthor-data \
  bash upload_to_hf.sh
```

## Throughput

Reference numbers on a single Ada-arch GPU (RTX 4090 / L40):
- ~12–15 seconds per episode (avg ~60 steps each)
- ~240 episodes/hour/GPU
- 4 GPUs in parallel ≈ ~1000 episodes/hour

So **2000 episodes ≈ 2 hours on a 4-GPU box**. Disk: ~2.5 MB/episode → 2000 eps ≈ 5 GB.

## Recommended rented-box specs

| spec | min | recommended |
|---|---|---|
| GPU | 1x 16 GB | 4-8x 24 GB (4090 / L40 / A6000) |
| RAM | 16 GB | 64 GB |
| disk | 20 GB | 100 GB SSD |
| OS | Ubuntu 22.04 | Ubuntu 22.04 + NVIDIA driver 535+ |

Don't need a fast network — uploads are deferred.

## Customizing the generator

All knobs are in `procthor_engine/sim.py::ProcTHOREngine.__init__` and
`generate.py` argparse. The defaults are tuned for diverse-room navigation
data:

- `width=512 height=512 fov=90` — match PrismVLA's 512x512 trunk
- `lookahead=5` — waypoint = path position 5 steps ahead
- `max_steps_per_ep=80` — cap episode length
- `min_dist_m=2.5` — reject too-short routes
- `n_rescue=12` — retry on stuck starts

The 4 action types (`forward`, `left`, `right`, `stop`) and their angular increments
(±15°) are hard-coded for compatibility with the AI2-THOR `MoveAhead` /
`RotateLeft` / `RotateRight` / `Stop` primitives. Change them in `sim.py` if you
need a different action set, but expect to retrain phase-segmentation thresholds
in `phase_segment.py`.

## Captioner (optional)

If you want more-natural English subcommands than the template strings,
run the Qwen captioning passes AFTER generation:

```bash
pip install -r requirements-captioner.txt
python -m procthor_engine.vlm_rewrite --in-parquet path/to/raw.parquet \
  --out-parquet path/to/rewritten.parquet
```

This loads Qwen3-VL-4B-Instruct and rewrites each subcommand. ~10 min/100 episodes
on a 24 GB GPU. The non-captioned templated data trains fine; this is purely a
language-diversity boost.

## License + citation

Apache 2.0. AI2-THOR / ProcTHOR are themselves AI2-licensed (free for research).

If you use this for research:
```
@misc{prismvla-procthor-engine,
  title  = {PrismVLA ProcTHOR data engine — R2R-superset synthetic VLN data},
  author = {Habacivch, Will},
  year   = {2026},
  url    = {https://huggingface.co/datasets/whab13/prismvla-procthor-engine},
}
```