Datasets:
license: cc-by-4.0
pretty_name: Spatial MMCoT v1 - vdrop
language:
- en
task_categories:
- visual-question-answering
- image-to-image
tags:
- spatial-reasoning
size_categories:
- 1K<n<10K
configs:
- config_name: preview
default: true
data_files:
- split: train
path: preview/train/*.parquet
- split: validation
path: preview/validation/*.parquet
- config_name: train
data_files:
- split: train
path: train/*.parquet
- split: validation
path: validation/*.parquet
- config_name: meta
data_files:
- split: train
path: meta/train/*.parquet
- split: validation
path: meta/validation/*.parquet
Spatial MMCoT v1 · vdrop
VDrop cross-view (QianYangMILA/vdrop-crossview-8k, arXiv:2605.27310), Infinigen Indoors rooms. Two egocentric views of one room with partly overlapping fields of view are the input (input_image_0 = cam0, input_image_1 = cam1); the target is upstream's ground-truth panorama render, a wide panorama of the room that spans both views. The questions are multiple choice and the trained answer is the option letter. The upstream release ships no reasoning text at all, so every thought here is EMPTY: output_text_list is exactly <think></think><image_start> and <image_end><think></think><answer>X</answer>. The panorama belongs to the scene, not the question: every question about a scene shares that scene's two input views and its one panorama, so the 6,807 rows use 1,152 distinct panoramas. Report validation scores with confidence intervals clustered by scene (for example a bootstrap over meta.scene_id), not as independent rows. The scenes were generated with Infinigen Indoors (github.com/princeton-vl/infinigen, whose code is BSD-3-Clause); the renders are distributed by the VDrop authors under CC-BY-4.0. Changes from upstream: the PNG images are re-encoded as JPEG and downscaled (the two input views from 1280x720 to 512x288, the panorama to 1,024 px wide); of the upstream thinking images only the panorama is kept; perspective-taking questions phrased relative to 'your partner' are dropped (as the upstream authors' build_interleaved_from_visual_only.py does by default); rows are removed by answer-prior balancing and split into train/validation by scene (both below); the ThinkMorph system prompt is prepended to the unchanged question.
Reasoning text in this release (r4)
The paragraph above describes the upstream data, and where it describes the reasoning text it describes the text of the previous release (r3). In this release every thought was rewritten: Qwen3.8-27B in thinking mode (temperature 1.0, top-p 0.95, top-k 20; prompt v4.1, scripts/annotate/rationale.py in our conversion code (the code repository is not public yet)) was shown the row's input images, its target images in order, the question, the options and the answer, and wrote the thought before each target image (what is still unknown, and what the picture should show to settle it) and the read-back after the last one. The images, the question, the options, the answer and the number of steps are r3's, checked row by row (image bytes, instruction, K and the <answer> value).
This is the training subset: 208 rows of r4 are not in it, listed with their reason in reports/subset_dropped.jsonl: 208 the rewrite model judged the stored answer doubtful (its note is in the list) (label_doubt).
Self-check of the rewritten text (measured 2026-10-02 on 22 rows sampled from this source before the removals above, each judged against its full-resolution pictures): 0.86 faithfulness errors per row (a claim the pictures contradict), 55% of rows with none; the plan names the real obstacle on 96%, the read-back reads the picture it follows on 82%, and the answer follows from the text on 82%.
The measured caveats on the r3 card were counted on r3's rows and text and are not repeated here; the per-row known-issue lists below were measured again on these rows and this text.
Supervision kind (supervision_kind in meta): visual_only on every row: the thoughts are empty: the rows supervise the image and the answer only.
Upstream: QianYangMILA/vdrop-crossview-8k. Licence: cc-by-4.0.
Known issues
No row of this source is listed in reports/known_issues/ (its summary.json is empty).
Size
| split | rows | target image slots | distinct target images |
|---|---|---|---|
| train | 6,543 | 6,543 | 1,109 |
| validation | 264 | 264 | 43 |
A slot is one target position in one row; rows can share a target image (same scene or same intermediate state), and a row can repeat one of its own targets, so there are fewer distinct images (by content hash) than slots.
| task | train | validation |
|---|---|---|
| anchor | 657 | 20 |
| counting | 570 | 37 |
| perspective_taking | 1,218 | 48 |
| relative_direction | 1,330 | 50 |
| relative_distance | 2,768 | 109 |
Input images per row: 2. Target images per row (the images the model is trained to generate): 1.
Image corpus (source_scene_corpus): infinigen 6,807.
Row format
One row is: input image(s) and a question, then K rounds of thought → target image (the target is the source's own ground-truth image, which the model is trained to generate), then a final thought (normally a read-back of the last target; where a source's final thought is something else, or often leaves out the answer, the source note or Known issues says so) and the answer; here K is 1. In the train config:
image_list list<binary> inputs first, then the K target images in order
num_input_images int64 how many of image_list are inputs
instruction_list list<string> one element: system prompt + question + options
output_text_list list<string> K+1 elements:
[0] <think>plan 1</think><image_start>
[j] <image_end><think>plan j+1</think><image_start>
[K] <image_end><think>read-back</think><answer>answer</answer>
row_uid string join key to `meta` and `preview`
On every row <answer> holds the option key (answer type mcq_letter 6,807) that the model is trained to emit (a letter for mcq_letter), while meta.answer_value (the answer column of preview) holds that option's text. Map the key through the options listed in the question before comparing the two, and score model output against <answer>.
The system prompt is ThinkMorph's VLM_THINK_SYSTEM_PROMPT from its inferencer.py, verbatim (GEN_THINK_SYSTEM_PROMPT there has the same text), including its leading and trailing newline. The markers are plain strings, not tokenizer special tokens; the prompt writes </image_end> and the data writes <image_end>, exactly as the ThinkMorph-7B checkpoint was trained.
preview shows the same rows with one column per slot: input_image_i for the inputs; for each of the K = num_steps rounds, the plan thought_j and its target target_image_j; and the read-back in thought_1 on every row.
meta holds the per-row sidecar: task, scene_id and geometry_uid (the scene and geometry keys; the split key is named in the split paragraph below), trajectory_id (a camera-path or sample label, empty where the source has none), num_steps, num_input_images, answer_type, answer_value, majority_class_rate, target_image_kind, target_px, est_tokens, licence, split (train / validation, the Hub split names), supervision_kind (full_interleaved / visual_aux / visual_only) and filter_flags. majority_class_rate is the share of the task's most frequent answer_value among its training rows: it measures answer skew and is not a guessing baseline (where a task mixes question types or each row has its own options it can be far below chance); compare scores with the text-only baselines below.
Per-row license in meta: cc-by-4.0 6,807.
Flags on released rows (filter_flags in meta and preview, comma-separated):
| flag | rows | meaning |
|---|---|---|
S5.replay_unsupported |
6,807 | no solver re-derives this task's answer from the trace, so S5 did not replay it |
S14.sampled_qa |
196 | chosen for the S14 human spot-check (reports/s14_sample.tsv) |
Training with a BAGEL-family loader
Rows here have 2 input images: the first num_input_images entries of image_list are inputs and the rest are targets, so the loader must read num_input_images. The UnifiedEditIterableDataset of the IPT release (https://github.com/weikaih04/Imaginative-Perception-Token, data/interleave_datasets/edit_dataset.py) does: its parse_row conditions on image_list[:num_input_images] and trains the remaining images as targets, one after each output_text_list element but the last. The stock ThinkMorph loader (the same class in https://github.com/ThinkMorph/ThinkMorph) does not: it conditions on image_list[0] only and trains image_list[j+1] after output_text_list[j], the answer element included, so every input after the first is trained as a generated image and every target moves one slot later per extra input. Every row here has one target, so on a row with exactly two inputs it trains image_list[1] (the second input view) after the plan and image_list[2] (the real target) after the answer. It raises no error. To use it, make two changes in its parse_row:
k = int(row.get("num_input_images", 1) or 1)
for im in images[:k]: # replaces the single _add_image(images[0], ...)
data = self._add_image(data, pil_img2rgb(Image.open(io.BytesIO(im))),
need_loss=False, need_vae=True, need_vit=True)
...
img_idx = idx + k # replaces img_idx = idx + 1
The stock BAGEL edit loader (ByteDance-Seed/Bagel) cannot train these rows: it never reads output_text_list and expects each instruction_list element to be a list of paraphrases.
parquet_info.json keys each training chunk as <source>/<split>/<file>, here vdrop/train/chunk_00000.parquet, with row-group counts read from the parquet footers. The loader matches a chunk only when its key equals the path it builds, os.path.join(data_dir, file), and skips a chunk with no key without a warning: a source that is alone in its group then fails with IndexError: list index out of range, and in a mixed group it adds no rows. Download into a directory named after the source, not after the repository:
from huggingface_hub import snapshot_download
snapshot_download("yrlyrl/spatial-mmcot-vdrop", repo_type="dataset", local_dir="<root>/vdrop",
allow_patterns=["train/*", "validation/*", "parquet_info.json", "reports/known_issues/*"])
Then either run from <root> with data_dir: vdrop/train and parquet_info_path: vdrop/parquet_info.json, or rebuild the index with absolute keys and use an absolute data_dir:
import json, os
root = "/abs/path/to/root" # the directory that holds vdrop/
info = json.load(open(os.path.join(root, "vdrop", "parquet_info.json")))
info = {os.path.join(root, k): v for k, v in info.items()}
json.dump(info, open(os.path.join(root, "vdrop", "parquet_info_abs.json"), "w"))
# data_dir = os.path.join(root, "vdrop", "train") (spelled exactly so, no trailing slash)
# parquet_info_path = os.path.join(root, "vdrop", "parquet_info_abs.json")
The Hugging Face cache (.../snapshots/<hash>/train/) or a folder named spatial-mmcot-vdrop matches no key.
num_used_data counts chunk files, not rows: the loader repeats this source's file list up to that number, lists every (file, row group) pair, and deals whole row groups out, floor(R / world_size) to each rank and floor(that / num_workers) to each DataLoader worker. The remainder is never read. This source has 1 training chunk file holding 52 row groups of up to 128 rows, so keep num_used_data large, e.g. the 128 of ThinkMorph's interleaved_reasoning.yaml (upstream's example.yaml asks for more than GPUs x workers); every row group is then read. Set to 1 and alone in its group on 8 GPUs with 4 workers, it reads only 32 of the 52 row groups. In a run that mixes sources, give each source the same multiple of its own training chunk-file count, e.g. 128 per file (128 here): the file list is repeated up to num_used_data entries, so a flat 128 for every source would read a two-file source's rows half as often as a one-file source's.
How the rows were chosen
| stage | rows |
|---|---|
| upstream rows read | 7,728 |
refused before conversion (S0raw; each reason is in the table below) |
158 |
| after conversion and per-row filters | 7,570 |
| removed by S10 (none) | 0 |
| removed by answer-prior balancing (S13) | 555 |
removed for training after the r4 rewrite (subset_dropped.jsonl) |
208 |
| released | 6,807 |
The rows refused before conversion are perspective-taking questions asked relative to "your partner's perspective": most name no image, so the partner's viewpoint cannot be recovered from the two input views, and the rest are dropped too, as the upstream authors' own build script does.
Every removed row has one line, with its reason, in reports/:
| file | step | reason (the line's flag, or the field shown) |
rows |
|---|---|---|---|
build/dropped.jsonl |
S0raw | S3.partner_phrasing |
158 |
s13_dropped.jsonl |
S13 | step: rank |
514 |
s13_dropped.jsonl |
S13 | step: letter |
41 |
subset_dropped.jsonl |
r4 | reason: label_doubt |
208 |
Every line of s13_dropped.jsonl has reason: prior_downsample; step names the balancing pass that removed it, and split is written train or val (the Hub's validation).
S0raw lines in build/dropped.jsonl were refused before a release row existed, so their row_uid field holds the converter's key for the upstream record (the upstream qa config's id, e.g. perspective_taking_000002), not a 16-hex row_uid; lines from later steps carry the row_uid the row had. No removed row appears in meta or preview.
Per-step counters of the conversion
7,728 upstream rows were read; S0raw refused 158 before a row existed and passed 7,570 to the first step. S0 runs once more, last, on the final bytes. The reason for every refused, dropped or quarantined row is in the files above.
| step | in | out | dropped | quarantined | rejected | repaired |
|---|---|---|---|---|---|---|
| S0raw (refused before conversion) | 7,728 | 7,570 | 0 | 0 | 158 | 0 |
| S4 | 7,570 | 7,570 | 0 | 0 | 0 | 0 |
| S4c | 7,570 | 7,570 | 0 | 0 | 0 | 0 |
| S5 | 7,570 | 7,570 | 0 | 0 | 0 | 0 |
| S8 | 7,570 | 7,570 | 0 | 0 | 0 | 0 |
| S9 | 7,570 | 7,570 | 0 | 0 | 0 | 0 |
| S0 (final structural check, after S9) | 7,570 | 7,570 | 0 | 0 | 0 | 0 |
The train/validation split keeps rows sharing a scene_id in meta on one side, and the assignment is frozen (splits/ in the summary repository). S12 saw 7,570 rows under 1,251 keys. No validation input image has the content of a training input image. The S12 run did not record whether its pixel-level near-copy test ran for this source, so near-copies are not ruled out.
Answer-prior balancing (S13)
Each (task, split) group is checked separately. An answer is the answer value compared as lower-cased text without a trailing full stop, with 'farther' read as 'further' and 'nearer' as 'closer' (for multiple choice, the option text, not the letter; where the candidates are drawn in the image, as in zebra_jigsaw and zebra_tetris, the answer is the letter itself). An answer is real when it holds at least 5 rows and 2% of the group; k is the number of real answers. Answer step: the target is max(30%, 1/k) when k >= 2, and max(30%, 1/d) over the d distinct answers when k = 1; a validation group uses the larger of its own target and its task's train target. A group is cut only when k >= 1 and its most common answer holds more than the target plus 5 percentage points; every answer is then capped at one common count, chosen so that none exceeds the target, and smaller answers keep all their rows. At the answer step, a group at or below that trigger, or with no real answer (k = 0), is left as it is, so its most common answer can hold up to the target plus 5 percentage points. A task whose train group has exactly two real answers is instead cut, in every split, so that its two largest answers have equal counts, with no trigger. Rank and label steps: then, in a group where every option value of every row is a number, the rank of the correct option among the sorted values, and after it, in a group where every trained answer is an option label, the label, are each capped by the same cut-and-trigger rule on their own counts (own target, validation included): capped, never evened out, so two labels are cut only when one exceeds 55%, and then only down to 50%. These steps can also cut groups the answer step left whole, including k = 0 groups, and can raise an answer's final share above its target; the run fails if a real answer ends above the target plus 5 percentage points. A train group of at least 20 rows in which one answer holds 90% or more fails the run. PET (exact_cells_pet) instead cuts each (question type x turn direction) cell to equal counts of its two answers; a PET cell that shows only one answer is removed.
| task | split | pass | rule | rows in → out | real answers k | target | largest share, before → after | cut |
|---|---|---|---|---|---|---|---|---|
| anchor | train | answer | cap30[canon] |
690 → 690 | 0 | 30.0% | 1.4% → 1.4% | no |
| anchor | train | letter | cap30[letter] |
690 → 690 | 4 | 30.0% | 33.3% → 33.3% | no |
| anchor | validation | answer | cap30[canon] |
26 → 26 | 0 | 30.0% | 7.7% → 7.7% | no |
| anchor | validation | letter | cap30[letter] |
26 → 21 | 3 | 33.3% | 46.2% → 33.3% | yes |
| counting | train | answer | cap30[canon] |
1,098 → 1,098 | 6 | 30.0% | 30.3% → 30.3% | no |
| counting | train | rank | cap30[rank] |
1,098 → 590 | 4 | 30.0% | 39.0% → 30.0% | yes |
| counting | train | letter | cap30[letter] |
590 → 590 | 4 | 30.0% | 31.0% → 31.0% | no |
| counting | validation | answer | cap30[canon] |
43 → 43 | 3 | 33.3% | 30.2% → 30.2% | no |
| counting | validation | rank | cap30[rank] |
43 → 37 | 3 | 33.3% | 41.9% → 32.4% | yes |
| counting | validation | letter | cap30[letter] |
37 → 37 | 3 | 33.3% | 32.4% → 32.4% | no |
| perspective_taking | train | answer | cap30[canon] |
1,245 → 1,245 | 7 | 30.0% | 26.5% → 26.5% | no |
| perspective_taking | train | letter | cap30[letter] |
1,245 → 1,245 | 4 | 30.0% | 27.6% → 27.6% | no |
| perspective_taking | validation | answer | cap30[canon] |
49 → 49 | 5 | 30.0% | 26.5% → 26.5% | no |
| perspective_taking | validation | letter | cap30[letter] |
49 → 49 | 4 | 30.0% | 32.7% → 32.7% | no |
| relative_direction | train | answer | cap30[canon] |
1,399 → 1,399 | 7 | 30.0% | 27.2% → 27.2% | no |
| relative_direction | train | letter | cap30[letter] |
1,399 → 1,399 | 4 | 30.0% | 26.0% → 26.0% | no |
| relative_direction | validation | answer | cap30[canon] |
59 → 59 | 5 | 30.0% | 25.4% → 25.4% | no |
| relative_direction | validation | letter | cap30[letter] |
59 → 50 | 4 | 30.0% | 37.3% → 30.0% | yes |
| relative_distance | train | answer | cap30[canon] |
2,824 → 2,824 | 4 | 30.0% | 3.0% → 3.0% | no |
| relative_distance | train | letter | cap30[letter] |
2,824 → 2,824 | 4 | 30.0% | 34.5% → 34.5% | no |
| relative_distance | validation | answer | cap30[canon] |
137 → 137 | 11 | 30.0% | 9.5% → 9.5% | no |
| relative_distance | validation | letter | cap30[letter] |
137 → 110 | 4 | 30.0% | 37.2% → 30.0% | yes |
S13 removed 555 rows from this source.
Text-only baselines
Accuracy of guessers that never see an image. For each task the released training rows are split into two fixed halves by a hash of row_uid; each guesser is fitted on one half and scored once on the other (one held-out half, not cross-validation; eval rows below). The reference is chance (the mean of 1 / number of options) where every row is multiple choice, and otherwise the eval-half accuracy of always giving the answer most common in the fit half (when a task's top answers are nearly tied, this need not be the task's most common answer; the line after the table gives that answer's validation score). Accuracies are recounted from the stored rates and eval rows, so they are exact. A task is flagged when a text-only guesser beats its reference by more than 0.15 (for a free-form task, a guesser other than the most common answer). A flagged task can be partly answered from the text alone; an unflagged task passed only these probes, which do not prove the text carries no answer. Report scores on every task next to this baseline.
Guessers: keywords: the most common answer per set of spatial words in the question; last_mentioned: the option named last in the question body; letter_prior: the most common answer letter; majority: the answer most common in the fit half; numeric_offset: where every option is a number, the smallest or largest option plus or minus the offset the correct one sat at most often (last_mentioned on the other rows); option_prior: the option text that won most often when shown; option_rank: where every option is a number, the option at the rank among the sorted values that the correct one held most often (last_mentioned on the other rows); template: the most common answer per question wording (numbers masked, object names kept).
| task | best text-only guesser | accuracy | reference | margin | eval rows | flagged |
|---|---|---|---|---|---|---|
| anchor | option_prior |
0.438 | 0.250 (chance) | +0.188 | 363 | yes |
| counting | template |
0.410 | 0.250 (chance) | +0.160 | 315 | yes |
| perspective_taking | option_prior |
0.451 | 0.250 (chance) | +0.201 | 625 | yes |
| relative_direction | option_prior |
0.399 | 0.250 (chance) | +0.149 | 712 | no |
| relative_distance | option_prior |
0.379 | 0.346 (chance) | +0.033 | 1,432 | no |
Spot-check (S14)
Pending. The S14 rows are chosen and flagged S14.sampled_qa in meta and preview; the human pass over them has not been signed off yet.
Citation
Please cite the upstream paper and Infinigen (https://github.com/princeton-vl/infinigen), as the VDrop card asks:
@article{yang2026and,
title={How and What to Imagine? Visual Thinking in Unified Multimodal Models for Cross-View Spatial Reasoning},
author={Yang, Qian and Sikarwar, Ankur and Le, Huy and Zhang, Le and Shi, Zhuan and Taslakian, Perouz and Agrawal, Aishwarya},
journal={arXiv preprint arXiv:2605.27310},
year={2026}
}
@inproceedings{infinigen2024indoors,
author={Raistrick, Alexander and Mei, Lingjie and Kayan, Karhan and Yan, David and Zuo, Yiming and Han, Beining and Wen, Hongyu and Parakh, Meenal and Alexandropoulos, Stamatis and Lipson, Lahav and Ma, Zeyu and Deng, Jia},
title={Infinigen Indoors: Photorealistic Indoor Scenes using Procedural Generation},
booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
month={June},
year={2024},
pages={21783-21794}
}
@inproceedings{infinigen2023infinite,
title={Infinite Photorealistic Worlds Using Procedural Generation},
author={Raistrick, Alexander and Lipson, Lahav and Ma, Zeyu and Mei, Lingjie and Wang, Mingzhe and Zuo, Yiming and Kayan, Karhan and Wen, Hongyu and Han, Beining and Wang, Yihan and Newell, Alejandro and Law, Hei and Goyal, Ankit and Yang, Kaiyu and Deng, Jia},
booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
pages={12630--12641},
year={2023}
}
Provenance
The release files were written by our conversion code (the code repository is not public yet), scripts/convert/export.py at commit b3fa1b993ca9, from build vdrop_r3. The build was made by scripts/convert/run_source.py from the same repository at commit 76c78bd817c2. S10, S12 and S13 ran before the export; reports/export_manifest.json pins every input the export read by SHA-1 (build_manifest_sha1, s10_keep_sha1, s12_assignments_sha1, s13_balanced_keep_sha1).
Every row removed between upstream and this release has one line, with its reason, in reports/: build/dropped.jsonl (rows refused before conversion or dropped by a conversion step); build/quarantine.jsonl (rows set aside by S4c because an automatic check could not match the read-back's conclusion to the label); s10_dropped.jsonl (duplicates removed by S10); s10_label_conflicts.jsonl (rows S10 withheld because another row asks the identical question, options in the same order, of the same images with a different answer); s13_dropped.jsonl (rows removed by answer-prior balancing). known_issues/ lists rows with a measured problem (see Known issues); reports/ also holds the build manifest (absolute paths cut to basenames) and counters, the S14 sample list (s14_sample.tsv: row_uid, task, split) and export_manifest.json. Part of yrlyrl/spatial-mmcot.