whab13/prismvla-procthor-engine

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)

# 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:

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},
}