PaperlayerView exact revision on arXiv

Source-linked AI summary

Trace: A Taxonomy-Guided Environment for Multidomain Visual Reasoning

Md Tanvirul Alam

arXiv:2607.19790v1cs.CV

TL;DR

Vision-language RLVR lacks broad, exactly verifiable, reproducible training data. Trace provides a taxonomy-guided procedural environment, and training on 64,000 instances improves macro-average performance across 24 external benchmarks by 3.51 points for Qwen2.5-VL-3B and 4.06 points for Qwen2.5-VL-7B.

  • Problem

    Vision-language RLVR lacks training data that jointly provide broad visual variation, exact answer verification, and reproducibility.

  • Method

    Trace factorizes visual reasoning tasks into scene grammars, executable task programs, and reward contracts within a deterministic generator–renderer–verifier environment.

  • Results

    3.51 and 4.06 percentage points: RLVR on 64,000 Trace instances improved the 24-benchmark macro-average for Qwen2.5-VL-3B and Qwen2.5-VL-7B, respectively.

  • Takeaways & Limitations

    Broad procedural training provides evidence of transferable visual reasoning beyond Trace’s generated task distributions.

  • Takeaways & Limitations

    The external benchmark suite cannot establish transfer to every natural-image distribution, and some benchmarks use model-based graders.

Abstract

from arXiv · show

Reinforcement learning with verifiable rewards (RLVR) has substantially improved language-model reasoning, yet its extension to vision-language models remains constrained by the lack of training data that are simultaneously broad, exactly verifiable, and reproducible. We introduce Trace, a taxonomy-guided environment for multidomain visual reasoning. Trace factorizes task construction into a scene grammar and an executable task program, separating visual realization from answer computation. A shared semantic state determines the rendered image, prompt, typed answer, verifier state, and replayable instance trace. The resulting environment comprises 1,000 tasks over 277 scene grammars and 11 visual domains, with controlled semantic and visual variation. RLVR on 64,000 Trace instances improves the macro-average across 24 external benchmarks by 3.51 percentage points for Qwen2.5-VL-3B and 4.06 points for Qwen2.5-VL-7B, providing evidence that broad procedural training can transfer beyond the generated task distributions. Project page: https://maveryn.github.io/trace/.

1 Introduction

TRACE is a taxonomy-guided environment for multidomain visual reasoning that separates visual construction from executable reasoning and exact verification. It provides broad, procedurally generated supervision and improves Qwen2.5-VL performance on external visual-reasoning benchmarks.

  • Environment design: TRACE separates scene grammars, executable task programs, and reward contracts to decouple visual construction from reasoning computation and exact answer verification.Bounded query variation changes meaningful task arguments without creating separate tasks.
  • Coverage: The environment contains 1,000 tasks over 277 scene grammars spanning 11 visual domains.The domains include charts, games, geometry, graphs, icons, illustrations, pages, physics, puzzles, symbolic notation, and three-dimensional scenes.
  • Instance generation: Each instance derives its image, prompt, typed answer, verifier state, and replayable trace from a shared semantic state.This supports exact supervision and controlled variation in semantic content and visual realization.
  • RLVR evaluation: 64,000 TRACE instances improved the benchmark macro-average by 3.51 percentage points for Qwen2.5-VL-3B and 4.06 points for Qwen2.5-VL-7B across 24 external benchmarks.The study tests transfer beyond held-out instances from the same environment and reports evidence of transfer beyond the generated task distributions.

2 Related Work

Prior work establishes structured visual-task generation, executable generator–verifier environments, multimodal RL mixtures, and synthetic verifiable visual data as foundations for controllable reasoning research. Trace extends these directions by separating scene rendering from task computation across 11 visual domains.

  • Controlled visual task generation: Structured visual-task generators use explicit scenes, functional programs, taxonomies, or curated concepts to control visual-reasoning evaluation.CLEVR, GQA, PuzzleVQA, Task Me Anything, and WorldBench exemplify these approaches.
  • Executable generator–verifier environments: Generator–verifier environments replace fixed datasets with programs that generate instances and evaluate solutions across diverse reasoning domains.Reasoning Gym provides more than one hundred environments, while Enigmata applies the model to 36 puzzle tasks in seven categories.
  • Multimodal RL data and mixture design: Multimodal RL research builds broad mixtures from existing datasets, assigns format-based rewards, and studies example selection or source proportions.These efforts span classification, visual mathematics, counting, structural perception, spatial reasoning, and referring expressions.
  • Synthetic and verifiable visual RL data: Synthetic visual RL systems create controlled puzzle experiences, expand rules into executable image-generation pipelines, or modify existing data while preserving verifiability.Examples include Jigsaw-R1, VisualSphinx, SynthRL, ViCrit, Sphinx, and TRON.
  • Trace: Trace factorizes visual realization and task computation across 11 visual domains, using 277 scene grammars and 1,000 stable task programs.This separation lets multiple reasoning objectives share a scene grammar while applying task-specific computations and reward contracts.

3 A Program-Centered Task Taxonomy

TRACE defines task identity by pairing a reusable scene grammar with an executable task program, answer schema, and reward contract, separating visual structure from answer computation. This boundary keeps operand queries and generation variation within a task while distinguishing changes to visual or computational structure, and supports cross-grammar analysis without collapsing scene-specific tasks.

  • Task factorization: A task couples a scene grammar to an executable task program, answer schema, and reward contract, separating visual structure from answer computation.A scene grammar specifies object vocabulary, relations, layout family, and question-facing scaffold.
  • Task factorization: TRACE represents each task as T = (S, P, Y, C), with the program specifying candidate construction, operand roles, intermediate computations, final operator, and output binding.Broad descriptions such as count objects or select an extremum are not precise enough for sampling or analysis.
  • Task boundaries: Operand choices remain bounded queries, whereas changes to candidate predicates, computation, or scene grammar define new tasks.This prevents operand-specific variants from overcounting one computation while preserving meaningful reasoning differences.
  • Task boundaries: Generation parameters vary instances of a fixed task: semantic parameters can change answers, while render-only parameters preserve answer-relevant relations and reward.Render-only variation changes visual realization without changing the fixed semantic state and query.
  • Canonicalization and extension: Canonicalized operators expose recurring computational structures across grammars, but tasks remain distinct when their scene grammars, metrics, or output bindings differ.TRACE samples tasks uniformly by default, so preserving scene-specific task identity also prevents heterogeneous computations from being hidden behind one sampling unit.
  • Canonicalization and extension: New scene grammars add families of semantic states and visual realizations, while new tasks add executable programs and reward contracts to existing grammars.Additional reasoning objectives can reuse an existing scene grammar without duplicating its visual construction.

4 The TRACE Environment

TRACE is a deterministic generator–renderer–verifier environment that derives visual instances, typed answers, scorers, and replayable traces from shared semantic state. It spans 1,000 tasks, 277 scene grammars, and 11 visual domains while supporting controlled answer-preserving variation and validation.

  • Environment pipeline: TRACE constructs each instance through a deterministic generator–renderer–verifier pipeline grounded in one shared semantic state.The pipeline separates semantic generation, task execution, rendering, prompt construction, scorer binding, and trace recording while keeping them state-consistent.
  • Instance representation: Each instance records its semantic state, query, execution, rendering decisions, verifier state, typed answer, and bound scorer, enabling replay and failure analysis.Independent seeded streams vary semantic, prompt, and rendering choices without coupling superficial variation to task computation.
  • Task composition: 1,000 tasks span 277 scene grammars and 11 visual domains, with scene grammars reused across multiple reasoning objectives.The 277 grammars support a median of three tasks each, with mean 3.61 and range 1–26.
  • Controlled variation: Semantic controls vary task-relevant state, while scene-compatible realization controls vary presentation only when queried relations and the typed answer remain unchanged.Controls include dimensions, values, thresholds, placement, layout, camera, palette, typography, materials, context, and bounded raster effects.
  • Validation: Instances are retained only when execution yields a unique typed answer, state-consistent prompt and image, deterministic replay, and successful scene-specific rendering checks.Automatic checks test visibility, contrast, fit, and collisions; direct review additionally assesses semantic clarity, prompt–image consistency, and visual legibility.

5 Experimental Setup

The experiments train Qwen2.5-VL models with GRPO on fixed procedurally generated TRACE data, then assess transfer using held-out TRACE instances and 24 external benchmarks under standardized evaluation protocols.

  • Training Data: 64,000 training instances comprise 64 independently generated examples from each of 1,000 TRACE tasks, with 2,000 additional held-out validation examples.Both model scales use the same data, and final checkpoints are reported after 500 updates.
  • Optimization: 500 GRPO updates sample 128 prompts and eight responses per prompt, yielding 512,000 sampled responses during one shuffled pass over training prompts.Rewards are normalized within each eight-response group and optimized with a clipped token-level policy objective.
  • Optimization: 10−6 learning rate, BF16 parameters, full-parameter training, and one policy epoch per update are used on eight H100 80GB GPUs.Training takes 12.2 hours for the 3B model and 13.9 hours for the 7B model; both scales share all training settings.
  • External Evaluation: 24 external benchmarks span six groups, and each model is evaluated on 32,805 examples per decoding seed using native benchmark metrics.The groups cover charts and tables, visual mathematics, science and general reasoning, spatial reasoning, perception and counting, and puzzles and logic.
  • External Evaluation: Overall and category scores are unweighted means across benchmarks, preventing larger evaluation sets from dominating aggregate results.Category scores average four benchmarks, while the overall score averages all 24 benchmarks.
  • External Evaluation: At 7B, additional comparisons include Game-RL, Sphinx, and PC-GRPO synthetic-data checkpoints, while Vero is reported separately as a real-image reference.These comparisons use the same external protocol but have unmatched training data, optimization, and compute.

6 Results

TRACE RLVR improves both in-distribution visual reasoning and transfer to external benchmarks at 3B and 7B scales. Gains span domains, task structures, answer interfaces, benchmark categories, and optimization trajectories rather than concentrating in one family.

  • In-distribution generalization: Accuracy increases from 24.45 to 41.05 at 3B and from 34.25 to 51.55 at 7B on unseen TRACE instances.These gains measure generalization to new semantic and visual realizations within the TRACE task distributions.
  • In-distribution generalization: Improvements span operation families, visual domains, answer interfaces, and both single-query and multi-query tasks, with formula evaluation, aggregation, and numeric answers showing the largest gains.The 3D domain, transformation, and matching exhibit stronger scale-dependent behavior.
  • External transfer: 3.51 points raise the 3B benchmark-macro average from 39.34 ± 0.63 to 42.85 ± 0.39, while 4.06 points raise the 7B average from 47.93 ± 0.30 to 51.99 ± 0.17.All six category averages increase at both scales.
  • External transfer: Mean performance improves on 21 of 24 benchmarks at 3B and all 24 benchmarks at 7B, with paired item-bootstrap intervals excluding zero on 18 and 21 benchmarks.The reported counts correspond to 3B and 7B, respectively.
  • External transfer: Visual mathematics gains 7.44 points at 3B and 5.65 points at 7B, while WeMath gains 10.95 points at 3B and 10.96 points at 7B.Transfer extends across external benchmarks with different visual formats, task structures, and evaluation metrics.
  • External transfer: The TRACE-trained 7B checkpoint exceeds Game-RL-7B by 3.94 points, Sphinx-7B by 2.64 points, and PC-GRPO-7B by 3.18 points in macro-average.It also has the highest reported mean on 21 of 24 benchmarks and the highest category average in all six groups among these synthetic-data RLVR checkpoints.
  • External transfer: Scale changes benchmark-level transfer: ChartQAPro, TreeBench, and EvoChart shift from −0.14, −0.66, and −1.68 at 3B to 2.24, 2.22, and 7.84 points at 7B.EvoChart is the largest departure from the equal-gain diagonal, showing dependence on model capacity and training mixture.
  • Optimization dynamics: Mean reward rises from 0.240 to 0.432 at 3B and from 0.353 to 0.542 at 7B, while completion length increases and sampled-token entropy decreases at both scales.Completion length changes from 198 to 308 tokens at 3B and 211 to 237 tokens at 7B; entropy changes from 0.829 to 0.137 and 0.361 to 0.088, respectively.

7 Limitations and Future Work

TRACE remains limited by human-designed task coverage and the lack of difficulty calibration or component-level attribution. Evaluation is also constrained by single-run variability, unmatched checkpoint comparisons, incomplete natural-image coverage, and some model-based grading.

  • Taxonomy and coverage: The human-designed taxonomy and 1,000 authored tasks do not exhaust visual reasoning, while operation families lack a shared cross-domain difficulty notion.Future complexity modeling could use program structure, semantic-state size, visual density, and empirical solve rates.
  • Attribution and training strategy: The complete TRACE mixture shows transfer, but the study does not isolate the effects of domains, operation families, sampling, or rendering controls.Mixture ablations could provide attribution; explicit task identities and generation parameters also enable difficulty-aware curricula, adaptive sampling, and competence-based mixture optimization.
  • Evaluation constraints: Evaluation uses one training run per model scale, descriptive comparisons with unmatched released RLVR checkpoints, and an external suite that cannot cover every natural-image distribution.Some benchmarks also use model-based graders, and procedural consistency does not guarantee equal perceptual difficulty.

8 Conclusion

TRACE presents procedural visual data as an executable, modular environment with exact verification and deterministic replay, and RLVR on 64,000 instances improves the macro-average across 24 external benchmarks by 3.51 points.

  • Conclusion: TRACE separates scene grammars, task programs, bounded queries, and reward contracts into explicit, executable components.These components provide stable units for generation, sampling, verification, and analysis.
  • Conclusion: Every instance is exactly verifiable and deterministically replayable across semantic and visual variation.The environment maintains this reproducibility while supporting controlled variation.
  • Conclusion: 64,000 TRACE instances improve the macro-average across 24 external benchmarks by 3.51 points.The result comes from reinforcement learning with verifiable rewards on TRACE instances.

Broader Impact … A.3 Invariant enforcement

Trace combines inspectable, reproducible procedural multimodal reasoning with invariant-preserving visual realization across diverse domains and operation families. Its design also acknowledges potential misuse and computational costs of stronger visual-reasoning systems and large-scale RLVR training.

  • Broader Impact: Trace may improve reproducibility by making task definitions, supervision, and reward computation inspectable while reducing reliance on sensitive or copyrighted imagery where procedural data suffice.The paper also notes risks from surveillance, automated assessment, consequential decision pipelines, and substantial computational requirements.
  • A.1 Domain construction profiles: Prompts, labels, values, and answers are derived from shared semantic state and recorded task execution, while domain profiles specify state representations, rendering conventions, and visible vocabularies.The common generation and reward pipeline is described separately in Section 4.
  • A.1 Domain construction profiles: Across charts, games, geometry, graphs, icons, illustrations, pages, physics, puzzles, symbolic scenes, and three-dimensional scenes, renderers vary appearance while preserving domain-specific semantic structure.The profiles use procedural layouts, assets, notation, and labels whose visible elements remain linked to the underlying scene or document state.
  • A.1 Domain construction profiles: Pages, physics, puzzles, symbolic scenes, and three-dimensional scenes similarly vary presentation while keeping fields, quantities, rules, tokens, spatial relations, and labels bound to their underlying states.Three-dimensional labels are checked against final projected geometry for visibility and separation.
  • A.2 Operation-family definitions: Task programs are classified by composable operation families, including retrieval, filtering, counting, comparison, ranking, aggregation, logic, spatial relations, topology, and matching.Assignments are multi-label when several operations contribute materially to a task output.
  • A.2 Operation-family definitions: Transformation, state update, and formula evaluation extend the operation taxonomy to geometric or symbolic changes, actions or transitions, and arithmetic, algebraic, or domain-specific computations.Formula evaluation can include derived metrics and numeric differences, ratios, or rates.
  • A.3 Invariant enforcement: Semantic generation enforces task constraints and answer uniqueness before structural realization, geometry-dependent verifier projection, and post-render effects that preserve the final canvas coordinate system.Render-only controls cannot modify task-program operands, answer values, or the reward contract.
  • A.3 Invariant enforcement: Independent seeded streams and recorded instance traces replay semantic state, prompts, rendering choices, and verifier state together while preserving queried semantic relations and typed answers.Answer-bearing geometry is projected before validation; optional finishing layers remain renderer-specific and are recorded in the trace.

B Experimental Details · B.1 TRACE validation slices · B.2 External evaluation suite

The experimental setup specifies shared training-run configuration, controlled external decoding, TRACE validation slices, and standardized scoring across the external benchmark suite. Validation uses overlapping views of the same inventory, while external evaluation preserves benchmark-specific scoring procedures across checkpoints.

  • B Experimental Details: Table 5 reports the configuration shared by the 3B and 7B training runs.The configuration is shared across both model scales.
  • B Experimental Details: External inference uses temperature 0.6, top-p 1.0, a 4,096-token response limit, and decoding seeds 42, 43, and 44.The seeds affect response generation only.
  • B Experimental Details: Model weights remain fixed across decoding runs despite using seeds 42, 43, and 44.Only response generation varies with the decoding seeds.
  • B.1 TRACE validation slices: Each TRACE validation task contributes two previously unseen instances, and all slice scores use one decoding seed.Table 6 reports held-out TRACE accuracy by answer interface and query structure.
  • B.1 TRACE validation slices: TRACE slice rows are overlapping analytical views of the same task inventory rather than separate evaluation sets.The slices organize held-out accuracy by answer interface and query structure.
  • B.2 External evaluation suite: Each external benchmark uses its standard scorer when available, while some open-answer benchmarks retain fixed model-based grading procedures.The same grader, prompt, and parser are used for every checkpoint on those open-answer benchmarks.
  • B.2 External evaluation suite: Table 7 lists the complete external benchmark suite, references, and evaluated sample counts.The suite combines benchmark-specific scoring with documented evaluation metadata.

B.3 External benchmark uncertainty

External benchmark improvements are quantified with paired confidence intervals from joint bootstrap resampling. The procedure resamples evaluation items alongside all three decoding seeds and respects each benchmark’s official scoring unit.

  • Uncertainty estimation: Paired confidence intervals quantify improvement from each base checkpoint to its TRACE-trained counterpart.Table 8 reports these intervals for external benchmarks.
  • Uncertainty estimation: Each bootstrap replicate jointly resamples evaluation items with predictions from all three decoding seeds.This preserves pairing between resampled items and seed-specific predictions.
  • Benchmark-specific resampling: Grouped metrics are resampled at official scoring units: problem families for WeMath and items within official splits for TableVQABench.The resampling unit therefore follows each benchmark’s scoring protocol.

C Representative Task Atlas

The representative task atlas presents seeded visual-reasoning examples pairing rendered instances with questions and typed answers across chart, game, geometry, and graph tasks. Its examples span visual measurement, spatial reasoning, transformations, and discrete structure problems.

  • Atlas presentation: Each page presents twelve seeded examples from one visual domain, pairing each rendered instance with its question and typed answer.Rule-heavy questions are condensed only when required for legibility.
  • Representative chart tasks: Chart tasks require interpreting intervals, scatter clusters, size encodings, thresholds, extrema, annotations, and confusion-matrix counts.Examples include counting intervals containing 54 and selecting the closest centroid option for cluster “Milow.”
  • Representative game tasks: Game tasks cover Sokoban, dartboard scoring, maze routes, chess attacks, Reversi flips, Snakes and Ladders distance, racing order, and dots-and-boxes ownership.These tasks ask for state-based counts, scores, route encounters, legal-move effects, distances, and relative positions.
  • Representative geometry tasks: Geometry tasks include tangent-circle distances, protractor readings, sector angles, folded-segment lengths, inscribed angles, circle overlaps, coordinate reflections, and bearing routes.The examples combine diagram measurements with geometric computation and transformed-point or endpoint matching.
  • Representative graph tasks: Graph and structure tasks span binary trees, bridges, phylogenies, automata, directed reachability, max flow, pipe connectivity, and metro shortest paths.Questions target local node relations, clade membership, state transitions, edge-edit reachability, network flow, connected regions, and path length.
Loading 2607.19790v1…