yrlyrl/spatial-mmcot-ipt_pt

Spatial MMCoT v1 · ipt_pt

Path tracing in ProcTHOR houses (IPT PT-ipt). The input is a top-down map with the route (points 1 and 2, midpoint M1) drawn on it, plus the forward views from points 1 and 2. The target is the view from waypoint M1. The question asks which of four objects you can see on your left or right at M1. The upstream think text is one of 16 fixed phrases (8 for the left side, 8 for the right) such as 'Looking right from midpoint M1:', so the reasoning is taken from the text chain-of-thought donor named below, joined row by row (its questions match the upstream ones exactly, row for row). The donor never saw the generated view: its plan reasons from the top-down map and usually settles the answer before the view appears. The donor was also prompted with more than the question: with the answer, and with a travel-direction field that no released question contains, and many plans cite them (see Known issues). Treat these plans as rationales written for a known answer. Refused by the conversion's checks: 14 rows whose read-back names another option letter or object than the label (S0.readback_names_other_letter, S0.readback_names_other_option); 131 rows whose text is not in the Latin script (S0.non_latin_script); 1,662 rows whose plan the donor reuses verbatim for a question with a different answer (S0.donor_plan_reused). meta.scene_id is the MD5 of the map's upstream bytes; the split key (below) is a cluster of near-identical maps, which meta does not store.

Supervision kind (supervision_kind in meta): visual_aux on every row: the reasoning text is a text-only chain of thought, written by a model that saw the input image(s) but never the target image, so the answer can usually be derived from the text before the image. Use these rows as image supervision, not as interleaved reasoning whose answer depends on the generated image, and not as evidence that generating the image helps.

Upstream: images, questions and answers from linjieli222/spatial-imaginative-token-pt-ipt; every thought (plan and read-back) from the text chain-of-thought release linjieli222/spatial-imaginative-token-pt-textcot. Licence: apache-2.0 (declared by both repositories). The images are renders of ProcTHOR houses made with AI2-THOR, both released by the Allen Institute for AI under Apache-2.0.

Known issues

Rows with a measured per-row problem are listed in reports/known_issues/, one TSV per issue (a # <description> line, then row_uid<TAB>split<TAB>detail lines), so they can be filtered out. They are still in this release: no row was removed for these issues.

issue	rows	train	validation	what	how it was found	file
plan_cites_hidden_travel_direction	3,707	3,589	118	The plan quotes a 'travel direction' field (reverse/forward) that the donor model was prompted with but no released question contains; a model trained on it learns to cite an instruction it never receives.	thought_0 matches 'travel direction is|:|= reverse|forward', a quoted “travel direction”, or '<prompt|question|query> ... says|states|... travel direction' (the review's strict pattern); measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 55cac424/6014a164	reports/known_issues/plan_cites_hidden_travel_direction.tsv
plan_faces_wrong_way	2,237	2,171	66	The question's route runs from 2 to 1, but the plan reads the hidden 'reverse' field as a second reversal and reasons facing from 1 toward 2 (against the question and the target view), then still reaches the labelled answer.	the question's route is 2->1 and a clause of thought_0 (sentences split at ';', ':', '—', 'so', 'meaning', 'i.e.'; the clause has no 2->1 phrase, no negation and no path/line subject just before the match) says it moves/faces from 1 to 2, faces 'back toward (way)point 2' or 'opposite the 2→1', or that its forward/facing direction points toward (way)point 2; measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 55cac424/6014a164	reports/known_issues/plan_faces_wrong_way.tsv
plan_shared_with_other_row	817	795	22	The donor reused this plan word for word for another question about the same map (same answer); when the other question lists different distractors, the plan argues over objects that are not this row's options.	sha1 of thought_0 occurs on more than one shipped row; detail names the other rows and whether their option sets differ; measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 55cac424/6014a164	reports/known_issues/plan_shared_with_other_row.tsv
plan_says_answer_was_given	4	3	1	The plan says the correct answer was given to it ('since the question’s correct answer indicates the pillow, we reconcile ...'); the donor was prompted with the answer, which no released question contains.	thought_0 or the read-back matches '<prompt|question|query>'s correct answer', '<given|provided|stated|expected|intended> correct answer', 'correct answer is given/provided/stated' or 'answer indicates'; measured 2026-09-25; known_issues.py sha1 655e5307; export 4aaee1f rows 55cac424/6014a164	reports/known_issues/plan_says_answer_was_given.tsv

To leave the listed rows out (the snippet in the loader section downloads reports/known_issues/ with the data):

import glob, os
root = "<root>/ipt_pt"
drop = {line.split("\t")[0] for f in glob.glob(os.path.join(root, "reports/known_issues/*.tsv"))
        for line in open(f) if line.strip() and not line.startswith(("#", "row_uid\t"))}
# keep a row when its row_uid (a column of train/, meta/ and preview/) is not in drop

Measured caveats

Measured on this release by the pre-publication review (2026-09-25): problems that cannot be listed row by row (a shortcut in the options, a label convention, an upstream labelling scheme) and what the review found around the lists above. Where a caveat counts listed rows ("listed as ..."), the count is the table's, read from reports/known_issues/summary.json. Its other numbers are the review's own measurements, which no file carries: they hold for exactly these rows and are not re-measured automatically. Items marked Training-signal defect are problems in what the rows teach, not only in how they are described; no row was removed for them.

• Training-signal defect. The donor was not given only the question. Its answer equals the upstream label on all 11,204 upstream rows, and some plans say so (listed as plan_says_answer_was_given: 4 rows, 3 train and 1 validation; e.g. 'since the question's correct answer indicates the pillow, we reconcile ...', 123e79feaa159b69). Its prompt also carried a travel-direction field that no released question contains: 'reverse' on exactly the routes from 2 to 1. 3,707 rows (3,589 train, 118 validation; listed as plan_cites_hidden_travel_direction) quote it ('The prompt says travel direction is reverse', '"Travel direction: reverse"'), and 4,513 plans mention 'reverse' although no question does. On 2,237 rows (2,171 train, 66 validation; listed as plan_faces_wrong_way) the plan reads the field as a second reversal, reasons facing from 1 toward 2 against the question and the target view, and still reaches the labelled answer. So 39.4% of the 9,397 rows train the model to cite an instruction it never receives, and 23.8% train reasoning with the wrong facing that ends on the right answer. Treat these plans as rationales for a known answer, not as reasoning that can be reproduced from the inputs.
• The donor also reuses plans verbatim for questions about the same map that have the same answer, and those rows are kept: 817 rows (795 train, 22 validation; listed as plan_shared_with_other_row) share their plan word for word with another row (404 groups, none spanning the two splits). In 803 of them the other question lists different distractors, so the plan may discuss objects that are not among this row's options and skip some that are (434 plans name an object that is an option only in the sibling row). Every such plan still reaches this row's own answer and letter.

Size

split	rows	target image slots	distinct target images
train	9,110	9,110	5,742
validation	287	287	182

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
path_tracing	9,110	287

Input images per row: 3. Target images per row (the images the model is trained to generate): 1. Image corpus (source_scene_corpus): procthor 9,397.

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
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`

Every image is a JPEG, and no input image is larger than 512 px on its long edge (measured on this release, 2026-09-25); the size each target was stored at is target_px in meta.

On every row <answer> holds the option key (answer type mcq_letter 9,397) 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: apache-2.0 9,397.

Flags on released rows (filter_flags in meta and preview, comma-separated):

flag	rows	meaning
S5.replay_unsupported	9,397	no solver re-derives this task's answer from the trace, so S5 did not replay it
S14.sampled_qa	200	chosen for the S14 human spot-check (reports/s14_sample.tsv)

The question of 9,397 rows still shows where an image placeholder was removed from it: a word followed directly by punctuation, as in 'as shown in , you' or 'your forward view at point 1: .' (e.g. d347698d6c9fb118, 9a3dcfb968966c55, 1ea007e4536188c1).

Training with a BAGEL-family loader

Rows here have 3 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 3 inputs it trains image_list[1] after the plan and image_list[2] after the answer, both of them input views, and the real target is never trained. 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 ipt_pt/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-ipt_pt", repo_type="dataset", local_dir="<root>/ipt_pt",
                  allow_patterns=["train/*", "validation/*", "parquet_info.json", "reports/known_issues/*"])

Then either run from <root> with data_dir: ipt_pt/train and parquet_info_path: ipt_pt/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 ipt_pt/
info = json.load(open(os.path.join(root, "ipt_pt", "parquet_info.json")))
info = {os.path.join(root, k): v for k, v in info.items()}
json.dump(info, open(os.path.join(root, "ipt_pt", "parquet_info_abs.json"), "w"))
# data_dir = os.path.join(root, "ipt_pt", "train")   (spelled exactly so, no trailing slash)
# parquet_info_path = os.path.join(root, "ipt_pt", "parquet_info_abs.json")

The Hugging Face cache (.../snapshots/<hash>/train/) or a folder named spatial-mmcot-ipt_pt 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 2 training chunk files holding 72 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 2 and alone in its group on 8 GPUs with 4 workers, it reads only 64 of the 72 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 (256 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	11,204
refused before conversion (S0raw; each reason is in the table below)	1,807
after conversion and per-row filters	9,397
removed by S10 (none)	0
removed by answer-prior balancing (S13)	0
released	9,397

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	S0.donor_plan_reused	1,662
build/dropped.jsonl	S0raw	S0.non_latin_script	131
build/dropped.jsonl	S0raw	S0.readback_names_other_letter	13
build/dropped.jsonl	S0raw	S0.readback_names_other_option	1

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

11,204 upstream rows were read; S0raw refused 1,807 before a row existed and passed 9,397 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)	11,204	9,397	0	0	1,807	0
S4	9,397	9,397	0	0	0	0
S4c	9,397	9,397	0	0	0	0
S5	9,397	9,397	0	0	0	0
S8	9,397	9,397	0	0	0	0
S9	9,397	9,397	0	0	0	0
S0 (final structural check, after S9)	9,397	9,397	0	0	0	0

The train/validation split keeps clusters of rows whose first input images are near-identical (perceptual-hash radius 8) on one side, and the assignment is frozen (splits/ in the summary repository). The rows carry no house id, so near-identical top-down maps are clustered instead. S12 saw 9,397 rows under 1,571 keys. No validation input image has the content of a training input image, and none is a pixel-level near-copy of one. S12 does not record per source whether that test ran, but it skips it only for a source whose spec sets split_leak_pixels: false, and no spec does; over all sources it compared 21,661 candidate pairs (perceptual hash within 6 bits) pixel by pixel and found no near-copy (checked 2026-09-25).

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
path_tracing	train	answer	cap30[canon]	9,110 → 9,110	16	30.0%	4.9% → 4.9%	no
path_tracing	train	letter	cap30[letter]	9,110 → 9,110	4	30.0%	25.8% → 25.8%	no
path_tracing	validation	answer	cap30[canon]	287 → 287	20	30.0%	4.9% → 4.9%	no
path_tracing	validation	letter	cap30[letter]	287 → 287	4	30.0%	28.2% → 28.2%	no

S13 removed no row 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; option_prior: the option text that won most often when shown; template: the most common answer per question wording (numbers masked, object names kept).

task	best text-only guesser	accuracy	reference	margin	eval rows	flagged
path_tracing	option_prior	0.467	0.250 (chance)	+0.217	4,556	yes

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

Both upstream repositories are part of the Imaginative Perception Token data collection, released with Bigverdi et al., Imaginative Perception Tokens Enhance Spatial Reasoning in Multimodal Language Models (arXiv:2606.03988); please cite it:

@misc{bigverdi2026imaginativeperceptiontokensenhance,
  title={Imaginative Perception Tokens Enhance Spatial Reasoning in Multimodal Language Models},
  author={Mahtab Bigverdi and Linjie Li and Weikai Huang and Yiming Liu and Jaemin Cho and Jieyu Zhang and Tuhin Kundu and Chris Dangjoo Kim and Zelun Luo and Linda Shapiro and Ranjay Krishna},
  year={2026},
  eprint={2606.03988},
  archivePrefix={arXiv},
  primaryClass={cs.AI},
  url={https://arxiv.org/abs/2606.03988}
}

Provenance

The release files were written by our conversion code (the code repository is not public yet), scripts/convert/export.py at commit 4aaee1f4e946, from build ipt_pt_r2. The build was made by scripts/convert/run_source.py from the same repository at commit 949af62f8ab7. 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.