This dataset combines sources with different terms (see LICENSE.md). The repository owner approves every request by hand. Use is limited to non-commercial research.

GT Tool-Trace Pilot: reference solutions with exact tool calls and tool-output images

Summary

This repository holds 5,471 records in 5 visual tasks: rotated text reading, mirrored dial reading, mirrored clock reading, grid path planning and object counting.
The task mirror_clock_5k holds 5,000 of the 5,471 records. It was added on 2026-11-01: 5,000 mirrored analog clocks that a new renderer drew for this pilot (see How mirror_clock_5k differs from mirror_reading).
Every record has a question, an answer and a ground-truth (GT) tool-use trace: the tool calls, their arguments and the tool outputs, mostly images.
Every trace is exact: each tool output follows exactly from the input image and the source annotation or generator. No model guessed a trace.
The source labels can still be wrong, so AI agents audited the labels of 2 tasks. An AI agent also read 120 of the generated clocks without the answers (see What is verified).
The traces are reference solutions for training models that reason with tools and images, for example with self-distillation fine-tuning (SDFT).
If the student model can call the same tools, it can reach the teacher's evidence. So the trace teaches tool use, not only the answer.
Every record exists in 4 aligned formats, so different kinds of reference solution can be compared on the same records.
Still open: nothing has been trained on this data, no human checked any label, and vsp_frozenlake fits only if the student calls the tools.
Access is gated: every request is approved by hand, and use is limited to non-commercial research. mirror_reading and lvis_counting are adapted from the preparer's own project data, which is not released yet: do not redistribute them. mirror_clock_5k has the same terms as mirror_reading. Some third-party terms are not fully confirmed (see Licenses and terms).

The diagram shows one real record, rotated_ocr_vietocr_img_001650_00001650, and how the files use it.

trace.jsonl: one GT tool-use trace per record (the source of truth)

  question + input image      "What text is written in this image? ..."  + input_0.png (rotated text line)
        |
        v
  tool call                   Rotate(image="input_0", angle=270)          exact arguments
        |
        v
  tool output                 tool_0.png = the executed rotation          exact image (upright line)
        |
        v
  final thought               reads tool_0.png and ends with the answer   answer "BING AUDIO" only here
        |
        |  code/common.py renders 4 formats (same ids, same order)
        v
  answer_only | text_reasoning | interleaved | interleaved_chat
        |
        v
  SDFT:  teacher = question + one reference format
         student = question only; it can call the same tools (code/tools.py)

What the data is

These terms have one meaning in this card:

A record is one written question with its answer, its input images and its GT tool-use trace.
A row is one item of a source dataset. The builders scan rows and write records.
A label is the answer that the source stores for a row.

Task	Records	The question asks the model to	Tool calls per record	Where the GT comes from
`rotated_ocr`	150	read a line of text that is rotated by 90, 180 or 270 degrees	1 Rotate	the builder's own lossless rotation of an upright text-line image
`mirror_reading`	150	read a clock, gauge or ruler that is shown mirrored	1 Flip	a synthetic generator; the flip reproduces its stored corrected image
`mirror_clock_5k`	5,000	read an analog clock that is shown mirrored, as H:MM with hours 1 to 12	1 Flip	the builder's own clock renderer; the flip of the input equals the drawn upright clock pixel for pixel
`vsp_frozenlake`	100	plan the shortest safe path on a FrozenLake map, a grid with a start, a goal and ice holes	3 Point, 1 AStar, 1 Draw2DPath	the source maps; a breadth-first search (BFS) confirms each path
`lvis_counting`	71	count the objects of one category in a COCO photo	1 Segment	LVIS human polygon annotations

The tools return these outputs:

Tool	Task	Output
Rotate	`rotated_ocr`	the image turned counter-clockwise by 90, 180 or 270 degrees
Flip	`mirror_reading`, `mirror_clock_5k`	the image mirrored left to right or top to bottom
Point	`vsp_frozenlake`	the pixel positions of the elf (the start), the gift (the goal) or the ice holes
AStar	`vsp_frozenlake`	a shortest safe path as move letters (L, R, U, D), from the A* shortest-path algorithm
Draw2DPath	`vsp_frozenlake`	the map with a path drawn on it
Segment	`lvis_counting`	the photo with every instance of one category filled in its own color

The 5 task folders hold 10,942 image files: the input images and the tool-output images. 10,000 of them belong to mirror_clock_5k.
The reasoning text comes from fixed templates filled with verified facts. No language model wrote it.
The vsp_frozenlake Point outputs and Draw2DPath images are copied from the source. The builder checked them against the image pixels.
A tool output reveals the answer when it contains the answer itself. The field reveals_answer marks such steps.

How `mirror_clock_5k` differs from `mirror_reading`

mirror_clock_5k and the clock part of mirror_reading both ask for the time on a mirrored clock. Both use the same Flip tool with the same tools.json. They differ in 4 ways:

	`mirror_reading` (clock part)	`mirror_clock_5k`
Images	50 clocks of one fixed design, from the preparer's generator. Its code is not available.	5,000 clocks from a new renderer, written for this pilot with PIL.
Styles	one design	varied per record: Arabic, Roman or 12/3/6/9-only numerals, 12 fonts, 3 tick styles, line or tapered hands, 14 face colors, an optional seconds hand (750 records) and an optional brand word (1,624 records)
Answer format	H:MM with hours 0 to 11, so 12 o'clock is written as 0	H:MM with hours 1 to 12, so 12 o'clock is written as 12 (415 records)
How the GT is made	the flip reproduces the generator's stored corrected image	the builder chooses the time, draws the upright clock and mirrors it to make the input

Each question states its answer format. Grade each task with its own format.
In mirror_clock_5k, all 720 times from 1:00 to 12:59 occur 6 or 7 times each. The flip axis is horizontal in 2,500 records and vertical in 2,500.
The records are not copies of mirror_reading images.

What the data is for

The main use is SDFT, as described in "Self-Distillation Enables Continual Learning" (arXiv 2601.19897).

In SDFT, one model plays two roles: a teacher and a student.
The teacher sees the question and a reference solution, a worked solution of the question.
The student sees only the question. It learns to match the teacher.
An answer-only reference lets the teacher copy the answer or reason backward from it.
A GT tool-use trace gives the teacher evidence instead: the tool calls and what the tools returned.
If the student can call the same tools, it can reach the same evidence. So the reference teaches tool use, not only the answer.

Three more terms:

OCR (optical character recognition) is reading text from an image.
SFT (supervised fine-tuning) trains a model to reproduce given target outputs. Direct SFT trains on the answers, and tool-use SFT trains on traces with tool calls.
A rollout is an answer that the student generates during training.

Design requirements and why each exists

Requirement	Why it exists	How this data meets it
(a) Exact GT tool calls and tool outputs.	A wrong reference teaches a wrong step.	The builders run the tools themselves, or they copy source outputs and check them against pixels and annotations.
(b) Published evidence that the tool helps on the task.	Without it, the tool step may add nothing.	Each task cites a published result. The strength of the evidence differs per task (see Why each task fits).
(c) The same records in answer-only, text-reasoning and interleaved formats, plus a tool-calling chat format.	The three kinds of reference can then be compared on identical records.	`code/common.py` renders every format from `trace.jsonl`, with the same ids in the same order.
(d) The answer appears only in the last step, and the text never refers to hidden information.	The teacher then reasons forward instead of copying.	The validator rejects an early answer and words such as "ground truth", "hint", "label" and "metadata".
(e) Verified labels with measured error rates.	A label error is a wrong target, so users must know how much label noise can remain.	Partly met. Automatic checks ran on every scanned source row and on every drawn clock. AI agents audited the labels of `rotated_ocr` and `lvis_counting`, and an AI agent read 120 `mirror_clock_5k` clocks blind. `mirror_reading` and `vsp_frozenlake` rest on automatic checks only.

A tool output may still reveal the answer. Then the step says so (reveals_answer), and the text may state the answer only after that step.
The measured error rates describe the audited candidates, not the written records (see What is verified).

Relation to two papers

TIR-Bench ("TIR-Bench: A Comprehensive Benchmark for Agentic Thinking-with-Images Reasoning", arXiv 2511.01833) is evidence, not data.

TIR-Bench is a test benchmark of 1,215 examples in 13 tasks. It is not a training set, so this pilot uses its results only.
Its Table 2 gives accuracy in % and shows which tool types help. On Rotated OCR, o3 scores 8.3 without tools and 53.3 with a code tool.
On the same task, GPT-4.1 scores 11.7, and the PyVision agent built on GPT-4.1 scores 63.3.
Its Section 4.5 pilot fine-tunes Qwen-2.5-VL-7B on rotated OCR. Tool-use SFT beats direct SFT, and it improves from 1k to 15k training samples.

VPD ("Visual Program Distillation: Distilling Tools and Programmatic Reasoning into Vision-Language Models", arXiv 2312.03052) is the recipe that this data extends.

In VPD, programs call vision tools. VPD turns the steps of programs with a correct answer into a text chain of thought, and it distills a model on them.
On TallyQA counting, PaLI-X-VPD scores 76.6 on complex questions, against 75.4 for the PaLI-X-Instruct baseline.
On simple TallyQA questions, the scores are 86.2 against 85.5.
This data differs in two ways. It keeps the tool-output images in the trace. And every step is exact by construction, not only filtered by a correct answer.

Why each task fits

Task	Tool	Evidence that the tool helps	How the GT is made exact	Caveat
`rotated_ocr`	Rotate	Direct. TIR-Bench Rotated OCR (o3 8.3 → 53.3; GPT-4.1 11.7 → PyVision 63.3) and its Section 4.5 SFT pilot. That pilot trains on `ducto489/ocr_datasets`, the source of this task. TIR-Bench's own 60 test images come from OCRBench, a different source.	The builder rotates the upright image losslessly. The tool output equals the upright source image pixel for pixel in 150 of 150 records.	Qwen2.5-VL-7B already scores 48.3 on TIR-Bench Rotated OCR without tools. So an open model may gain less from the tool than o3 and GPT-4.1 do.
`mirror_reading`	Flip	Analogue only, because a flip is not a rotation. TIR-Bench rotation tasks show tool gains: Rotated OCR (above) and Rotation Game (o3 33.3 → 77.3). TIR-Bench Instrument Reading, on dials that are not mirrored, shows mixed gains: o3 17.5 → 21.3, o4-mini 18.8 → 13.8.	The flip reproduces the stored corrected image on 1,433 of 1,433 scanned rows, with a maximum RGB difference of 0. A 180-degree rotation reproduces it on 0 of 1,433 rows, so a rotation cannot replace the flip.	No published result tests a flip tool on mirrored dials.
`mirror_clock_5k`	Flip	Analogue only, the same evidence as `mirror_reading`.	The builder draws the upright clock for a chosen time and mirrors it to make the input. The flip of the input equals the upright clock pixel for pixel in 5,000 of 5,000 records. A 180-degree rotation reproduces it on 0 of the 5,035 drawn clocks.	No published result tests a flip tool on mirrored clocks. All clocks come from one renderer, with flat colors and no photos.
`vsp_frozenlake`	Point, AStar, Draw2DPath	Direct but nuanced: the same task, with a mixed result. Tool-use SFT does not beat direct SFT on the navigation sub-task that this data covers (see the notes below).	BFS confirms that every answer is a shortest safe path (250 of 250 path-planning rows).	The AStar text and the Draw2DPath image reveal the answer in 100 of 100 records. So the task fits only if the student calls the tools.
`lvis_counting`	Segment	Indirect. Perception Tokens (Aurora), arXiv 2412.03548: intermediate box tokens improve counting by +10.8% on BLINK, +11.3% on CVBench and +8.3% on SEED-Bench. VPD on TallyQA (above). Neither tests a segmentation tool.	The overlay comes from LVIS human polygons. The labels were noisy, so the builder kept only the 71 rows that two further AI auditors confirmed.	The overlay gives each object its own color, so it partially reveals the count.

Notes on the vsp_frozenlake evidence, from AdaReasoner (arXiv 2601.18631, Qwen2.5-VL 7B):

Its VSP task (visual spatial planning on FrozenLake maps) has two sub-tasks. Navigation plans a path, and verification judges whether a given path is safe. This data covers navigation only.
Table 2 gives the overall VSP score: tool-use SFT 64.91 against direct SFT 46.64. This gain comes from verification.
Table 11 gives navigation alone: tool-use SFT 41.00 against direct SFT 42.67. So on navigation, tool-use SFT does not help.
Table 3 is for the model trained with tool-use SFT and then tool RL (reinforcement learning with tool calls), without reflection data.
In that model, A* offered only at inference raises navigation (44.83 → 62.33) but lowers verification (94.20 → 80.00).
AdaReasoner's tool-use SFT data, the source of this task, contains no A* call. The AStar step is this builder's addition.
No cited result trains on traces that contain A* calls.

Notes on the other evidence:

The Aurora gains are the abstract's figures. The abstract does not name their baseline or say whether they are percentage points.
In the table, each arrow goes from the score without tools to the score with tools.

Fit for two training set-ups

Two set-ups decide which tasks fit:

Student-calls-tools mode: the student makes tool calls in its rollouts and gets real tool outputs from code/tools.py.
Teacher-only-hint mode: only the teacher sees the tool outputs, as part of its reference solution.

The reference rate is how often the teacher copies from the reference instead of reasoning. A high reference rate means that the teacher teaches copying.

Task	Tool output reveals the answer	Student-calls-tools mode	Teacher-only-hint mode
`rotated_ocr`	0 of 150, but the restored line is plain upright text	fits	fits, because the teacher still has to read the text; but the upright line is easy to read, so measure the reference rate
`mirror_reading`	0 of 150	fits	fits, because the flipped dial still has to be read
`mirror_clock_5k`	0 of 5,000	fits	fits, because the flipped clock still has to be read; but the restored clock is clean and easy to read, so measure the reference rate
`vsp_frozenlake`	100 of 100	fits	does not fit, because the AStar text and the Draw2DPath image contain the answer path
`lvis_counting`	0 of 71, but the overlay is a partial reveal	fits	fits with a caveat: a teacher can count the overlay colors instead of the objects

In student-calls-tools mode, a revealing tool output is fine, because the student gets the same output for the same call.
Draw2DPath is the exception: by default it returns an approximate drawing of the same path (see Open points).
Segment and Point return an output only for the recorded arguments, for example the category as named in the question. Other arguments get an error.
So in student-calls-tools mode, measure how often the student's calls miss.
In teacher-only-hint mode, a revealing tool output lets the teacher copy the answer. Measure the reference rate in this mode.

What is verified, and how

AI agents did all label audits. No human checked any record.

1. Gates over every scanned source row. A gate is an automatic check that a source row must pass before it can be sampled. Each builder runs its scan gates on every scanned row.

Task	Source rows scanned	Rows that pass all gates	Records written
`rotated_ocr`	3,000	776	150
`mirror_reading`	1,433	1,006	150
`mirror_clock_5k`	5,035 drawn clocks	5,000	5,000
`vsp_frozenlake`	750	244	100
`lvis_counting`	5,172	4,837	71

rotated_ocr scanned the first 3,000 rows of its train split (about 11M rows). So its gate rates describe that window only.
mirror_clock_5k has no source rows. Its builder runs the gates on every drawn clock. It drew 5,035 clocks for 5,000 records: each of the 35 clocks that failed a gate was drawn again in a new style, with the same time and axis.
The 35 failures were 22 clocks with a numeral more than half covered by a hand, 12 with the seconds hand too close to another hand, and 1 that the pixel reader did not read within tolerance.
In vsp_frozenlake, 10 of the 11 gates need a path-planning row, so they run on the 250 path-planning rows only.
Further sampling rules and audits reduce the rows that pass the gates to the written records. build_report.json in each task folder lists every gate with its pass count.

2. Exact-output checks.

rotated_ocr: rotating the saved input back gives the upright image pixel for pixel on all 2,961 decodable rows, for each of the 3 angles.
mirror_reading: an automatic pixel reading of the flipped image agrees with the answer on 1,433 of 1,433 rows.
mirror_clock_5k: the flip of each input equals the drawn upright clock pixel for pixel in 5,000 of 5,000 records.
mirror_clock_5k: an automatic pixel reader finds the hand angles in the restored clock. It knows the clock center and the record's style (hand colors and lengths), but not the time. It reads the minute hand within 3 degrees and the hour hand within 7.5 degrees of the answer in 5,000 of 5,000 records. The largest errors are 0.5 degrees (minute hand) and 1.3 degrees (hour hand).
mirror_clock_5k: three more pixel gates check that each clock stays readable. A hand covers at most half of any numeral. The seconds hand stays away from the outer half of the other hands. At least 40% of the hour hand stays visible next to the minute hand.
mirror_clock_5k: after the build, the builder read the 10,000 written image files again. The flip check, the pixel reader and the image sha256 values pass on 5,000 of 5,000 records.
vsp_frozenlake: a color test of the holes agrees with the Point outputs on 10,000 of 10,000 grid squares.
lvis_counting: the number of LVIS instances equals the answer on 5,170 of 5,172 rows.

3. Shared validator. code/common.py validate checks the formats, the image files, the answer position and the banned words. It reports 0 errors on each of the 5 task folders of this repository.

4. Tool executor self-test. code/test_tools.py runs every recorded call through code/tools.py. It passes 222,721 of 222,721 checks over the 5,471 records of this repository. 190,000 of these checks are on mirror_clock_5k.

Flip, Rotate and AStar run live. Segment, Point and Draw2DPath replay the recorded output, with Draw2DPath in replay mode.
The test reproduces every recorded tool response byte for byte and every recorded output image.
The test also checks error cases, other arguments and equivalent spellings of the same call.

5. Label audits by AI agents.

rotated_ocr: a blind AI reader transcribed the 180 candidates without seeing the answer. Ignoring case and white space, 177 of 180 readings match the label.
Two further AI checks judged the other 3 rows. A checker agent judged 1 row, and the coordinating agent judged the 2 rows that differ only in a dash.
Their result: 2 labels are wrong, and 1 cannot be decided. The builder dropped all 3 rows.
The label error rate among the 180 candidates is 1.11% (95% Wilson interval 0.31% to 3.96%).
lvis_counting: after a first AI audit, two further AI auditors checked the 100 sampled rows. Auditor A counted blind.
Auditor B saw the answer and the overlay, so the two checks are not fully independent. They gave the same count on 76 of the 96 rows where both gave one.
Keep means that B confirmed the answer and A's blind count equals it. Wrong means that B rejected the answer and A's count differs. Every other row is doubtful.
The result is 71 keep, 1 wrong and 28 doubtful. So the error rate of the 100 sampled rows is between 1% (wrong only) and 29% (wrong or doubtful).
The builder wrote only the 71 kept rows as records.
mirror_clock_5k: the builder chose every time, so a label can only be wrong if the drawing does not show it. A blind read tests this: an AI agent read restored clocks without the answers.
The sample has 120 records: 5 from each of 24 style groups (numeral system, flip axis, hand shape, seconds hand or not).
All 120 readings equal the answers, with 0 disagreements. 118 of the 120 images read are still in the written data, and 118 of 118 agree (95% Wilson interval 96.8% to 100%).
Later, a fix drew 2 of the read clocks again with clearer hands, and 2 other records joined the sample. The builder read these 4 images, so they have no blind read.
mirror_reading and vsp_frozenlake have no label audit. Their labels rest on the automatic checks above.
The written records of rotated_ocr and lvis_counting have no measured error rate of their own.

DETAILS.md gives every gate, audit rule and number, with the reasons behind the decisions.

Files and formats

Each task folder has the same files:

File	Content
`trace.jsonl`	the source of truth: question, images, answer, the steps of the trace, final thought, verified facts and gate results
`answer_only.jsonl`	`id`, `task`, `question`, `images`, `answer`
`text_reasoning.jsonl`	the same fields plus `reasoning`: the text-only version of every step; it never mentions a tool
`interleaved.jsonl`	the same fields plus, for each step `i`, `reasoning_thought_i`, `tool_call_i`, `tool_response_i` and `reasoning_image_i`. A last `reasoning_thought_<n>` holds the final thought (n is the number of steps).
`interleaved_chat.jsonl`	a tool-calling chat: system, user, one assistant and tool turn per step, and a final assistant turn
`tools.json`	the function schemas of the task's tools
`build_report.json`	gates, exclusions, sampling rule, evidence, limitations, license notes and rebuild commands
`validation.json`	the result of `code/common.py validate`
`images/<id>/`	`input_<k>` files (question images) and `tool_<i>` files (tool outputs)

The top level has these files:

DETAILS.md: the technical details.
LICENSE.md: a pointer to the terms below.
MANIFEST.md: the size and sha256 of every file.
preview.html: 4 example records for each of the first 4 tasks. mirror_clock_5k is not in the preview yet, and the preview's totals count only the first 4 tasks (471 records).
template_stats.json: the template-diversity numbers of the first 4 tasks.

The folder code/ holds the builders, the renderer and validator, the tool executor and its test, the three audit files and SPEC.md. The repository holds about 332 MB of files, and mirror_clock_5k takes 244 MB of it.

How to load

Every task and format has its own config, named <task>-<format>. For example, rotated_ocr-interleaved reads rotated_ocr/interleaved.jsonl, and rotated_ocr-trace reads rotated_ocr/trace.jsonl. Each config has one split, train.

The image paths in images, output_image and reasoning_image_<i> are strings relative to the task folder.
Paths under facts record the source files for provenance. They do not resolve in this repository.

Download the whole repository to read the images:

import json, os
from huggingface_hub import snapshot_download

root = snapshot_download(repo_id="kuvvi/gt-tool-trace-pilot", repo_type="dataset")  # gated: request access on the dataset page first, then log in with a read token
task_dir = os.path.join(root, "rotated_ocr")
with open(os.path.join(task_dir, "interleaved.jsonl")) as fh:
    records = [json.loads(line) for line in fh]
first_input = os.path.join(task_dir, records[0]["images"][0])            # images/<id>/input_0.png
first_tool_output = os.path.join(task_dir, records[0]["reasoning_image_0"])  # images/<id>/tool_0.png

The datasets library reads the same configs. Image fields stay path strings:

from datasets import load_dataset

ds = load_dataset("kuvvi/gt-tool-trace-pilot", "rotated_ocr-interleaved", split="train")

A local test with datasets 4.8.5 loaded all 25 configs from this folder. The Hub dataset viewer was not tested.

To run the tools in student rollouts, load code/tools.py by path:

import importlib.util

spec = importlib.util.spec_from_file_location("gt_tools", os.path.join(root, "code", "tools.py"))
tools = importlib.util.module_from_spec(spec)
spec.loader.exec_module(tools)
out = tools.execute(task_dir, records[0]["id"], "Rotate", {"image": "input_0", "angle": 270})
# out == {"tool_response": {...}, "image": PIL.Image or None}
# bad arguments: out["tool_response"]["status"] == "error" and out["image"] is None

tools.py needs only the standard library, PIL and numpy. It reads only the task folder that you pass to it.
Flip, Rotate and AStar run live on any valid arguments.
Segment and Point replay the recorded output when the arguments match a recorded call. Other arguments get a neutral error message.
Draw2DPath draws the path with an approximate renderer by default (see Open points).
To convert the data to another schema, start from trace.jsonl. DETAILS.md has the field mapping and a short converter.
The builders in code/ do not run in this repository: they stop before they delete or download anything, because the source files are not included.

Licenses and terms

The repository license is other, because the parts have different terms. Access is gated, and the repository owner approves every request by hand. Each user agrees to use the data for non-commercial research only and to follow the terms of every source below. Some terms are not confirmed yet (see Status), so access to the affected tasks can change.

Task	Source	Terms recorded at build time	Status
`rotated_ocr`	Hugging Face `ducto489/ocr_datasets` (rows from its vietocr part)	The card YAML and the Hub tag say apache-2.0. The card body says that the set combines several sources and that users must check their licenses.	The vietocr terms are not confirmed.
`mirror_reading`	adapted from the preparer's unreleased project data (a synthetic dial generator)	Shared for non-commercial research through gated access only.	Do not redistribute it. Ask the preparer before you use it in a publication.
`mirror_clock_5k`	generated in this work by `code/build_mirror_clock_5k.py`, modeled on the preparer's unreleased `mirror_reading` data	The same terms as `mirror_reading`: shared for non-commercial research through gated access only.	Do not redistribute it. Ask the preparer before you use it in a publication. The numerals and brand words use DejaVu, Cantarell, Source Code Pro, Inconsolata and Ubuntu fonts. Their licenses allow text rendered with them in images.
`vsp_frozenlake`	Hugging Face `AdaReasoner/AdaReasoner-TC-VSP`	The card body says "License: Apache 2.0". The card YAML has no license field. The card asks users to cite arXiv 2601.18631.	Apache 2.0 by the card body only.
`lvis_counting`	adapted from the preparer's unreleased project data (questions and answers), with COCO val2017 images and LVIS v1 val annotations	The images are Flickr photos with per-image Creative Commons 2.0 licenses (`facts.image_license`), and the COCO terms of use apply. LVIS is distributed under CC BY 4.0.	48 of the 71 images (68%) have a NonCommercial clause. 27 (38%) have a NoDerivs clause, and 22 (31%) have a ShareAlike clause. Do not redistribute the questions and answers.

Tool outputs rendered from source images keep the terms of those images.
The Segment overlays are adaptations of the lvis_counting photos. A NoDerivs clause may forbid sharing them, so confirm this for the 27 NoDerivs images, or remove their overlays.
The reasoning templates and the code were made for this pilot. No license is stated for them yet.

Sources and credits

Prepared by Jiawei Gu (University of Washington).

Data sources:

"Combined OCR Dataset", ducto489/ocr_datasets on Hugging Face (rotated_ocr). The rows come from its vietocr part, which the card links as https://github.com/pbcquoc/vietocr. The card asks users to cite the original sources.
AdaReasoner/AdaReasoner-TC-VSP on Hugging Face (vsp_frozenlake), Apache 2.0 by its card body (https://www.apache.org/licenses/LICENSE-2.0).
COCO val2017 images (lvis_counting): "Microsoft COCO: Common Objects in Context", arXiv 1405.0312. Terms of use: https://cocodataset.org/#termsofuse.
LVIS v1 val annotations (lvis_counting): "LVIS: A Dataset for Large Vocabulary Instance Segmentation", arXiv 1908.03195, under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/).
Changes to LVIS: the builder rendered the polygons as colored overlays and checked each answer against the instance count.
mirror_reading: adapted from the preparer's unreleased project data.
mirror_clock_5k: generated in this work, modeled on the preparer's unreleased mirror_reading data. Fonts: DejaVu (Bitstream Vera license), Cantarell, Source Code Pro and Inconsolata (SIL Open Font License 1.1), and Ubuntu (Ubuntu Font Licence 1.0).
The questions and answers of lvis_counting: adapted from the preparer's unreleased project data.

Papers:

"Self-Distillation Enables Continual Learning", arXiv 2601.19897.
"TIR-Bench: A Comprehensive Benchmark for Agentic Thinking-with-Images Reasoning", arXiv 2511.01833.
"Visual Program Distillation: Distilling Tools and Programmatic Reasoning into Vision-Language Models" (VPD), arXiv 2312.03052.
"Perception Tokens Enhance Visual Reasoning in Multimodal Language Models" (Aurora), arXiv 2412.03548.
"AdaReasoner: Dynamic Tool Orchestration for Iterative Visual Reasoning", arXiv 2601.18631.

Open points

Does the student call the tools? The answer decides which tasks fit (see the fit table). vsp_frozenlake fits only if the student calls the tools.
Draw2DPath mode in rollouts. code/tools.py has 3 modes. Confirm the mode before training.
- approx (the default) draws every path with an approximate renderer. So it tells the student nothing about the recorded answer.
- replay returns the recorded image for the recorded path and an error for any other path.
- replay_or_approx returns the recorded image for the recorded path and an approximate drawing for any other path.
- Both replay modes tell the student whether its path equals the recorded answer: through the error, or through the style difference.
- In approx mode, a mean of 98.1% (minimum 97.0%) of the source's red path pixels lie within 2 px of the drawing. The drawn pixels lie within 2 px of the source path (precision 1.000, minimum 1.000).
- So the teacher's reference image and the student's tool output differ slightly in style.
Human spot-check. No human checked any label. A human check of about 20 lvis_counting records is the recommended next step.
Benchmark overlap. Check it before you evaluate a model trained on this data.
- lvis_counting: 6 of the 71 images are CV-Bench 2D Count test images, and 7 more are CV-Bench 2D Relation images. TallyQA overlap was not checked.
- vsp_frozenlake: the maps are AdaReasoner training data, so models trained on AdaReasoner data may have seen them.
- rotated_ocr: 0 of the 180 candidate answers equal an OCRBench answer. The rows are public OCR training data.
- mirror_reading: the builder excluded rows whose image equals an image of the source eval split. Values can still repeat there.
- mirror_clock_5k: every image was drawn for this pilot, so no benchmark image is in it. Its times can repeat in any clock benchmark as values.
Conversion to other schemas. trace.jsonl is the source of truth, and code/common.py renders the formats from it. Convert from trace.jsonl, and keep the same ids in the same order.
Templated text style. A student can learn the template style along with the reasoning.
- rotated_ocr has only 43 sentence patterns, and the 10 most common cover 49.2% of its sentences.
- mirror_reading has 189 patterns, and the 10 most common cover 20.4%. Check student outputs for copied phrasing.
- mirror_clock_5k was not measured with code/template_stats.py. Its builder has 3 to 6 phrasings for each sentence, and its questions have 80 different forms.
Licenses and access. Some third-party terms of rotated_ocr and lvis_counting are not fully confirmed. Until they are, approve access requests by hand and only for non-commercial research. mirror_reading and the lvis_counting questions and answers stay unreleased project data, and mirror_clock_5k has the same terms as mirror_reading: no redistribution.
- For lvis_counting, confirm that the overlays of the 27 NoDerivs images may be shared, or remove them.
- 48 of the 71 lvis_counting images do not allow commercial use.
mirror_clock_5k in a training mix. It holds 91% of the records (5,000 of 5,471). Weight or sample the tasks so that clock reading does not dominate the mix.
- Its answers use hours 1 to 12, and mirror_reading uses hours 0 to 11.
- 105 records have the hour hand within 4 degrees of the minute hand, as on real clocks. There the hour hand can show only as a strip along the minute hand.
- 1,227 records have hour ticks only, so the minute must be estimated from the hand angle.
- 4 records of its 120-record audit sample have no blind read (see What is verified).
Not measured yet. Nothing has been trained on this data. It is not known whether SDFT benefits from these traces.

Downloads last month: 197

Total file size:

332 MB

You need to agree to share your Hugging Face information to access this dataset