1 Introduction↩︎

Recent large vision-language models (LVLMs) have shown impressive capabilities in jointly understanding visual and textual inputs [1]–[4]. Inspired by Chain-of-Thought (CoT) reasoning in language models [5], many LVLMs generate intermediate natural-language rationales before producing the final answer. However, discrete tokenized textual rationales are a lossy medium for representing continuous visual evidence, and they often provide only an implicit connection to the visual tokens that support each reasoning step [6], [7]. Recent latent reasoning approaches address this limitation by moving the reasoning process from natural language into continuous latent space. While representing rationales as latent embeddings is promising, existing methods primarily focus on latent attention optimization [8]–[10], reconstructing visual information [7], [11], [12], optimizing latent reasoning trajectories [6], [13], [14], or interleaved vision-language reasoning [15]–[17]. As a result, they often leave latent reasoning weakly connected to the compositional and relational structure of visual evidence. However, visual reasoning should not be defined only by where computation takes place, but also by the visual evidence around which it is organized. Images are composed of entities, attributes, and relations, and many visual questions require binding these elements into a question-relevant scene structure. Existing latent reasoning methods move reasoning into continuous hidden states, but provide limited control over whether the resulting latent rationales are grounded in this structured visual evidence.

To address this gap, we propose ReGuLaR: Relation-Grounded Latent Reasoning for Large Vision-Language Models. Instead of exposing scene graphs as prompts or requiring graph generation at inference time, ReGuLaR uses object relation-level supervision to shape question-conditioned latent states, inducing an internal graph-like reasoning process before answer generation. Representing graph-like visual evidences in the sequential model embeddings is challenging. As illustrated in 1, ReGuLaR focus on a question-relevant subject-relation-object relation triplet at each latent reasoning step, gradually forming a scene graph that captures the visual evidence needed to answer the question. Although appealing, encoding such an information-dense triplet into a single latent embedding remains challenging. To this end, we introduce a relation-grounding transformer (ReGFormer), which extracts subject and object visual features and grounds latent embeddings to the corresponding relations. To support the training of ReGuLaR, we construct a high-quality image-text dataset, RGrounding-351K, with annotations of object relations and bounding boxes for the corresponding objects. Extensive experiments on diverse benchmarks show that ReGuLaR consistently outperform general purpose LVLMs, text-based CoT reasoning models and existing latent reasoning approaches, confirming ReGuLaR achieves the state-of-the-art performance.

Our contributions are summarized as follows:

• We propose ReGuLaR, a relation-grounded latent reasoning framework that makes LVLMs reason over question-relevant objects and relations in continuous latent space before generating answers.

• We introduce ReGFormer, a training-time module that grounds latent reasoning states through role-aware subject/object attention and relation-level supervision, while preserving the standard inference interface without external scene graphs or object annotations.

• We construct RGrounding-351K, a relation-grounded vision-language dataset of approximately 351K examples, integrating question-answer pairs, scene graphs, and object bounding boxes to support fine-grained latent relation grounding.

• We demonstrate the effectiveness of ReGuLaR on diverse visual reasoning benchmarks, where it outperforms strong general-purpose, RL-based, and latent reasoning baselines; ablations and visualizations further validate the importance and interpretability of relation-grounded latent supervision.

2 Related Work↩︎

2.1 Structured Visual Evidence for Vision-Language Reasoning↩︎

Large Vision-language models (LVLMs) have evolved from task-specific architectures for applications like image captioning [18], [19] and visual question answering [20], [21] to large-scale pretrained models that align visual and textual representations [22]–[24]. With visual instruction tuning, recent LVLMs further connect strong vision encoders with large language models, showing strong capabilities in joint reasoning over visual and textual inputs [1]–[3], [25]–[27].

Despite these advances, current LVLMs still struggle with fine-grained reasoning that requires faithful grounding of objects, attributes, spatial relations, and inter-object dependencies [28], [29]. Prior work introduces visual structures, such as localized object regions’ bounding boxes and scene graphs, to provide more structured visual evidence [30]–[33]. However, it remains underexplored how to make answer generation follow a human-like process of first reasoning over question-relevant visual structures and then producing the answer. To this end, ReGuLaR uses relation-level grounding to train a question-conditioned latent bottleneck, encouraging the model to organize relevant objects and relations into an implicit graph-like reasoning process before generating the answer.

2.2 Latent Space Reasoning↩︎

Chain-of-thought (CoT) improves reasoning by externalizing intermediate steps in natural language [5], but discrete textual tokens can be verbose and lossy, especially for visual reasoning, where dense perceptual details are difficult to encode in words. Latent space reasoning addresses this limitation by allocating computation to hidden states rather than fully decoded rationales: prior work encodes complex intermediate information in the latent space of LLMs [34]–[36], and more recent studies extend latent reasoning to multimodal models through latent attention optimization [8]–[10], reconstructing visual information [7], [11], [12], optimizing latent reasoning trajectories [6], [13], [14], or interleaved vision-language reasoning [15]–[17]. These methods show that reasoning can be more efficient and perceptually informative when performed in continuous space, but they do not explicitly ground the latent reasoning process in fine-grained object attributes and inter-object relations. In contrast, ReGuLaR grounds latent reasoning with question-relevant object relations, encouraging the model to capture essential object attributes and relational dependencies during the reasoning process.

3 Method↩︎

3.1 Overview↩︎

As illustrated in Figure 2, ReGuLaR follows a human-like reasoning paradigm: it first performs latent reasoning and then generates the answer. Given an image-question pair, the model first enters the latent reasoning phase, where each reasoning step produces a latent state intended to encode one question-relevant object relation in the form of subject-relation-object. To guide these latent states toward such fine-grained visual information, we introduce a training-time relation-grounding transformer (ReGFormer), detailed in Section 3.2. At inference time, ReGuLaR performs latent reasoning and answer generation without invoking ReGFormer. We describe the training data and optimization objective in Sections 3.3 and 3.4, respectively.

3.2 Relation Grounding with ReGFormer↩︎

Although scene graphs provide detailed and fine-grained visual information about an image, incorporating such graph-structured information into a sequential Chain-of-Thought is challenging. A straightforward approach is to verbalize the scene graph as natural language and include it in the reasoning trace. However, due to the discrete and sequential nature of text, this strategy can be token-expensive and lossy. Moreover, textual CoT is typically decoupled from the visual tokens that support each reasoning step, providing only an implicit connection between the rationale and the underlying visual evidence. While moving reasoning into continuous latent space is appealing, encoding complex graph-like visual information in latent states remains non-trivial.

To this end, we introduce ReGFormer, a training-time module that grounds latent reasoning states in fine-grained object relations and aligns them with the visual tokens that support each reasoning step. As illustrated in Figure 3, ReGFormer takes as input the latent reasoning state and the visual token embeddings from the backbone LVLM. For the \(t\)-th latent reasoning step, let \(\mathbf{z}_t \in \mathbb{R}^{d}\) denote the hidden state of the current latent reasoning token, and let \(\{\mathbf{v}_1,\dots,\mathbf{v}_n\}\) denote the \(n\) visual token embeddings. We first project them into the relation-grounding space: \[\mathbf{r}_t = \mathbf{z}_t \mathbf{W}_z, \qquad \mathbf{x}_i = \mathbf{v}_i \mathbf{W}_v\] where \(\mathbf{r}_t,\mathbf{x}_i \in \mathbb{R}^{d_r}\). The projected reasoning state then attends to all projected visual tokens through a cross-attention layer, producing a visually grounded reasoning state \(\mathbf{u}_t\): \[\mathbf{u}_t = \mathrm{CrossAttn}(\mathbf{r}_t, \mathbf{X})\] Here, \(\mathbf{X} = [\mathbf{x}_1;\dots;\mathbf{x}_n] \in \mathbb{R}^{n \times d_r}\).

Next, ReGFormer applies role-aware pooling to extract subject- and object-specific visual evidence for the current relation. We compute subject and object queries from \(\mathbf{u}_t\) and visual keys from the projected visual tokens: \[\mathbf{q}_t^s = \mathbf{u}_t \mathbf{W}_q^s, \quad \mathbf{q}_t^o = \mathbf{u}_t \mathbf{W}_q^o, \quad \mathbf{k}_i^v = \mathbf{x}_i \mathbf{W}_K\] where \(\mathbf{q}_t^s,\mathbf{q}_t^o,\mathbf{k}_i^v \in \mathbb{R}^{d_r}\). We denote all visual keys as \(\mathbf{K}^v = [\mathbf{k}_1^v;\dots;\mathbf{k}_n^v] \in \mathbb{R}^{n \times d_r}\). The subject and object attention distributions are then computed as: \[\begin{align} \boldsymbol{\alpha}_t^{s} &= \mathrm{softmax} \left( \frac{\mathbf{q}_t^{s}(\mathbf{K}^v)^\top}{\sqrt{d_r}} \right) \\ \boldsymbol{\alpha}_t^{o} &= \mathrm{softmax} \left( \frac{\mathbf{q}_t^{o}(\mathbf{K}^v)^\top}{\sqrt{d_r}} \right) \end{align}\]

Using these role-specific attention distributions, we obtain subject and object visual features by weighted pooling over the projected visual tokens: \[\mathbf{c}_t^{s} = \sum_{i=1}^{n} \alpha_{t,i}^{s} \mathbf{x}_i, \qquad \mathbf{c}_t^{o} = \sum_{i=1}^{n} \alpha_{t,i}^{o} \mathbf{x}_i.\] Finally, we concatenate the subject feature, object feature, and relation-aware latent state: \[\mathbf{m}_t = [\mathbf{c}_t^{s}; \mathbf{c}_t^{o}; \mathbf{u}_t]\] and feed \(\mathbf{m}_t\) into a relation prediction head to produce a distribution over the relation vocabulary. The resulting relation prediction and role-specific attention maps are used to supervise the latent reasoning state during training, while ReGFormer is removed during inference.

3.3 Training Data↩︎

As described in Section 3.2, training ReGuLaR with ReGFormer requires supervision for both object-level grounding and relation-level prediction. To this end, we construct RGrounding-351K, a high-quality image-text dataset with approximately 351K examples. Each example contains an image, a question-answer pair, a scene graph, and bounding boxes for the objects in the scene graph. For each image-question pair, we further derive a set of question-relevant relation targets from the image-level scene graph. Specifically, we identify objects mentioned in the question or answer as anchors using the available question/answer annotations, and select relations whose subject or object is connected to these anchors. Table 1 summarizes the data sources of RGrounding-351K, with additional construction details provided in the Appendix.

3.5pt

3.4 Training Objective↩︎

To train the model to follow the thinking-then-answering format, we apply supervised fine-tuning (SFT) with our proposed relation-grounding objectives. For each training example, we use the selected question-relevant relation targets described above rather than the full scene graph. For each latent reasoning step \(t\), we sample one subject-relation-object triplet from these targets, together with the bounding boxes of its subject and object. We convert the bounding boxes into target attention distributions over visual tokens. Specifically, \(\boldsymbol{\beta}_t^{s}, \boldsymbol{\beta}_t^{o}\in\mathbb{R}^{n}\) are defined as uniform distributions over the visual tokens whose image patches overlap with the subject and object bounding boxes, respectively, with zero probability assigned to all other tokens. Let \(\boldsymbol{\alpha}_t^{s}\) and \(\boldsymbol{\alpha}_t^{o}\) denote the subject and object attention distributions predicted by ReGFormer. We supervise role-aware grounding with: \[\mathcal{L}_{\mathrm{attn}} = \frac{1}{T} \sum_{t=1}^{T} \left[ D_{\mathrm{KL}}\!\left(\boldsymbol{\beta}_t^{s} \,\|\, \boldsymbol{\alpha}_t^{s}\right) + D_{\mathrm{KL}}\!\left(\boldsymbol{\beta}_t^{o} \,\|\, \boldsymbol{\alpha}_t^{o}\right) \right]\] where \(D_{\mathrm{KL}}(\cdot\|\cdot)\) denotes the Kullback–Leibler (KL) divergence. Intuitively, this loss provides a grounding signal for the role-aware pooling layer in ReGFormer, encouraging its subject and object queries to attend to the corresponding visual evidence.

Given the role-aware representation \(\mathbf{m}_t\) from ReGFormer, the relation prediction head produces logits over the relation vocabulary: \[\boldsymbol{\ell}_t^{\mathrm{rel}} = f_{\mathrm{rel}}(\mathbf{m}_t), \quad \mathbf{p}_t^{\mathrm{rel}} = \mathrm{softmax}(\boldsymbol{\ell}_t^{\mathrm{rel}})\] We supervise relation prediction with the cross-entropy loss, encouraging each latent reasoning state to encode the relation between the currently grounded subject-object pair: \[\mathcal{L}_{\mathrm{rel}} = -\frac{1}{T} \sum_{t=1}^{T} \log \mathbf{p}_{t,y_t}^{\mathrm{rel}}\] where \(y_t\) is the ground-truth relation label for the \(t\)-th subject-object pair, and \(\mathbf{p}_{t,y_t}^{\mathrm{rel}}\) denotes the probability assigned to the correct relation.

After the latent reasoning stage, the model generates the final answer autoregressively. We optimize the answer tokens with the standard next-token prediction loss: \[\mathcal{L}_{\mathrm{ans}} = -\frac{1}{N} \sum_{j=1}^{N} \log p_\theta \left( a_j \mid I, q, \mathbf{z}_{1:T}, a_{<j} \right)\] where \(I\) is the input image, \(q\) is the question, \(\mathbf{z}_{1:T}\) are the latent reasoning states, and \(a_{1:N}\) are the answer tokens.

The overall training objective is: \[\mathcal{L} = \lambda_{\mathrm{ans}}\mathcal{L}_{\mathrm{ans}} + \lambda_{\mathrm{rel}}\mathcal{L}_{\mathrm{rel}} + \lambda_{\mathrm{attn}}\mathcal{L}_{\mathrm{attn}}\]

Through these supervision signals, ReGFormer guides the backbone LVLM to organize each latent reasoning step around a question-relevant subject-relation-object triplet before generating the answer. Because the relation prediction and attention grounding losses are computed from the latent states and back-propagated into the backbone LVLM, the model is encouraged to encode question-relevant subjects, objects, and relations in its own latent reasoning trajectory. Once this behavior is learned, ReGFormer is removed. At inference time, ReGuLaR first performs a fixed number of latent reasoning steps and then switches to autoregressive answer generation, requiring only the image and question without external scene graphs, object annotations, or additional grounding modules.

1.3mm

4 Experiment↩︎

4.0.0.1 Experiment setup.

We use Qwen2.5-VL-7B [2] as the backbone and initialize ReGuLaR from the corresponding pretrained checkpoints. During training, we freeze the vision encoder and the modality-alignment projector. We set the loss weights \(\lambda_{ans}=1.0\), \(\lambda_{rel}=1.0\), and \(\lambda_{attn}=0.1\) for all experiments. All experiments are conducted on \(4\times\) NVIDIA A100 GPUs with 80GB memory. Additional implementation details are provided in the Appendix.

4.0.0.2 Evaluation benchmarks.

We evaluate the reasoning ability of ReGuLaR on a diverse set of vision-language benchmarks with English questions and answers. \(V^*\) Bench [44] evaluates a model’s ability to recognize fine-grained visual details and relative spatial relations. MMVP [45] evaluates fine-grained visual perception by testing whether LVLMs can distinguish visually similar images and answer questions about details that are often overlooked. HRBench [46] assesses model performance on reasoning over ultra-high-resolution images. BLINK [29] is a comprehensive benchmark covering 14 visual perception tasks. SEED-Bench-2-Plus [47] evaluates text-rich visual comprehension across diverse real-world scenarios such as charts, maps, and web pages. HallusionBench [48] tests whether LVLMs can avoid hallucinations and visual illusions under subtle visual changes.

4.0.0.3 Baselines.

We compare ReGuLaR with models from three categories. (1) General-purpose LVLMs, including LLaVA-OneVision [49], GPT-4o [4], and Qwen2.5-VL-7B [2]. (2) RL-based reasoning LVLMs, including DeepEyes [50], PAPO [51], and Vision-R1 [52]. (3) Latent-reasoning LVLMs, including LVR [7], MONET [15], and LASER [6].

4.1 Main Results↩︎

Table [tab:main95results] reports the main results across six benchmarks. On visual perception and fine-grained reasoning tasks, ReGuLaR shows clear advantages over prior latent reasoning methods. It achieves the best results on \(V^*\) Bench, MMVP, and BLINK, improving over the strongest latent reasoning baseline by \(3.15\) points on \(V^*\) overall, \(3.48\) points on attribute recognition, \(2.63\) points on spatial reasoning, and \(3.26\) points on BLINK. These gains suggest that grounding latent states in question-relevant objects and relations helps the model better preserve and organize fine-grained visual evidence before answer generation.

ReGuLaR also performs strongly on high-resolution benchmarks. It achieves the best overall score on HRBench and the best results on its 4K subset, while remaining highly competitive on the 8K subset, showing that relation-grounded latent reasoning remains effective for high-resolution visual inputs. Beyond perception-centric benchmarks, ReGuLaR obtains the best performance on SEED-Bench-2-Plus, which includes text-rich and diverse visual understanding tasks such as charts, maps, and web pages, and remains strong on HallusionBench. These results indicate that our method improves fine-grained visual reasoning without sacrificing generality across broader multimodal understanding and hallucination-sensitive settings.

BLINK comprises 14 diverse single-image and multi-image visual reasoning tasks. As shown in Figure 4, ReGuLaR outperforms both the base Qwen2.5-VL-7B and the state-of-the-art latent reasoning method Laser in overall performance, achieving the best results on 10 of the 14 tasks. The gains are especially notable on tasks that require precise grounding of object attributes, spatial relations, and cross-image correspondence. This suggests that relation-grounded latent reasoning provides a stronger inductive bias for visual reasoning: by structuring latent computation around question-relevant entities and their relations, ReGuLaR makes more effective use of fine-grained visual evidence across diverse reasoning settings.

4.2 Visualization of Relation-Grounded Latent Rationales↩︎

Although ReGFormer is not required at inference time, the trained ReGFormer can still be attached to the latent reasoning states as a diagnostic probe to visualize their semantics. Figure 5 shows representative examples, each including the input question, the answer of ReGuLaR, and two latent reasoning steps. For each step, we visualize the subject attention map in red, the object attention map in blue, and the relation predicted by ReGFormer from the corresponding latent state. These examples show that different latent states can focus on question-relevant entities and recover meaningful relations, suggesting that ReGuLaR performs visually grounded relation reasoning before final answer generation.

4.3 Ablation Study↩︎

4.3.0.1 Loss weights.

The training objective of ReGuLaR consists of the answer generation loss and two auxiliary relation-grounding losses: the relation prediction loss weighted by \(\lambda_{\mathrm{rel}}\) and the attention grounding loss weighted by \(\lambda_{\mathrm{attn}}\). We study the sensitivity of ReGuLaR to these two weights while keeping the answer loss weight fixed. When varying \(\lambda_{\mathrm{rel}}\), we fix \(\lambda_{\mathrm{attn}}=0.1\); when varying \(\lambda_{\mathrm{attn}}\), we fix \(\lambda_{\mathrm{rel}}=1.0\). Table 2 reports the average performance over \(V^*\) Bench, MMVP, and BLINK. The model performs best with \(\lambda_{\mathrm{rel}}=1.0\) and \(\lambda_{\mathrm{attn}}=0.1\), which we use for all main experiments. The results also show that excessively weak or strong auxiliary supervision can hurt performance, suggesting that relation grounding is most effective when it guides latent states without overwhelming answer-generation learning.

2.5mm

4.3.0.2 Effect of Relation-Grounded Latent Supervision.

To further demonstrate the effectiveness of our proposed relation-grounded latent reasoning, we introduce two additional models fine-tuned from Qwen2.5-VL-7B on RGrounding-351K. Vanilla SFT is trained only with the next-token prediction loss to directly generate the answer without latent reasoning. Text rationale converts the question-relevant scene graph into textual subject-relation-object triplets and uses them as intermediate rationales before answer generation. As shown in Table 3, ReGuLaR substantially outperforms vanilla SFT, indicating that the improvement does not simply come from fine-tuning on RGrounding-351K. Instead, explicitly modeling a thinking-then-answering process helps the model organize the visual evidence needed for reasoning. Moreover, ReGuLaR also outperforms the text-rationale variant, showing that verbalizing visual relations as discrete text is less effective than grounding continuous latent states with visual-token evidence. This suggests that ReGuLaR benefits from both the compactness of continuous latent reasoning and the fine-grained evidence support provided by ReGFormer over visual tokens.

2.2mm

4.3.0.3 Number of reasoning steps.

At inference time, ReGuLaR uses a fixed budget of latent reasoning steps before generating the final answer. We study the effect of this budget by evaluating ReGuLaR with 1, 4, 8, and 16 latent reasoning steps. As shown in Table 4, using only one step leads to relatively lower performance, suggesting that a single latent state is insufficient to capture the multiple objects, attributes, and relations needed for visual reasoning. Increasing the budget to 4 steps substantially improves the average score, while further increasing it to 8 or 16 steps yields only marginal changes. Therefore, we use 4 latent reasoning steps in our main experiments as an efficient and effective inference setting.

3mm

5 Discussion↩︎

In this work, we present ReGuLaR, a relation-grounded latent reasoning framework for vision-language reasoning. Instead of verbalizing intermediate reasoning steps as natural-language CoT or leaving latent thoughts weakly grounded, ReGuLaR uses question-relevant scene graphs to supervise latent reasoning states during training. With the training-time ReGFormer, each latent state is encouraged to encode the subject, object, and relation information needed for faithful visual reasoning, while inference remains simple and requires no external scene graphs, object annotations, or additional grounding modules. Extensive experiments show that ReGuLaR consistently improves over strong existing approaches across diverse benchmarks. Ablation studies further demonstrate that these gains do not simply come from fine-tuning on RGrounding-351K or verbalizing scene-graph triplets as text; instead, directly grounding continuous latent states with visual-token evidence is crucial. Looking forward, relation-grounded latent reasoning may be further extended from static visual inputs, including both single-image and multi-image settings, to dynamic temporal scenarios. In such settings, temporal relations, object interactions, and state changes can provide richer structure for latent reasoning.

6 Limitations↩︎

One limitation of ReGuLaR is its reliance on relation-level grounding supervision during training, including object bounding boxes and inter-object relation annotations. Although these annotations are not needed at inference time, collecting high-quality relation supervision may become expensive when scaling to broader domains. Future work may reduce this requirement through weak supervision, automatic scene-graph construction, or self-training pipelines that produce relation signals at scale.

7 Implementation Details↩︎

7.1 Training setup↩︎

We initialize ReGuLaR from the pretrained Qwen2.5-VL-7B checkpoint. The vision encoder and the modality-alignment projector are frozen during training, while the language model and the relation-grounded latent reasoning components are updated. The model is trained on RGrounding-351K with supervised fine-tuning and the proposed relation-grounding objectives.

We train ReGuLaR for 3000 optimization steps on \(4\times\) NVIDIA A100 GPUs with 80GB memory. We use a per-device batch size of 1 and gradient accumulation of 16, resulting in a global batch size of 64. The base learning rate is \(1\times10^{-5}\) with a cosine learning-rate schedule and a warmup ratio of 0.03. We use AdamW with \(\epsilon=10^{-8}\) and weight decay of 0.1. Training is performed in bfloat16 with gradient checkpointing and DeepSpeed ZeRO-3. For the training objective, we set \(\lambda_{\mathrm{ans}}=1.0\), \(\lambda_{\mathrm{rel}}=1.0\), and \(\lambda_{\mathrm{attn}}=0.1\). The training process takes approximately 70 hours to complete. During inference, ReGFormer is removed, and the model performs a fixed number of latent reasoning steps before generating the final answer.

Unless otherwise specified, all results are obtained from a single training run and evaluated with deterministic decoding, following the practice of recent latent reasoning work [6], [7], [15]. The Avg. column reports the arithmetic mean of benchmark-level overall accuracies.

We use dynamic image resolution. Each image is constrained to 128 to 8,192 visual tokens, corresponding to an image-size budget from \(128 \times 28 \times 28\) to \(8192 \times 28 \times 28\) pixels.

7.2 ReGFormer Architecture↩︎

ReGFormer is a lightweight training-time module built on top of Qwen2.5-VL-7B. The backbone hidden size is \(d=3584\), and both latent reasoning states and visual token states are projected into a relation-grounding space of dimension \(d_r=1024\). We use two linear projections for this mapping, one for latent reasoning states and one for visual token states.

The projected states are passed through a 2-layer cross-attention transformer with 8 attention heads. In each layer, latent reasoning states serve as queries, while visual token states serve as keys and values. Each layer contains LayerNorm, multi-head cross-attention, a residual connection, and a feed-forward network with hidden dimension \(4d_r=4096\) and GELU activation. The dropout rate is set to 0.0. The transformed reasoning state is combined with the original projected reasoning state through a learnable residual gate initialized to \(10^{-3}\).

For role-aware pooling, ReGFormer uses separate \(1024\times1024\) linear projections to generate subject queries, object queries, and visual keys. The subject and object queries attend to all visual tokens separately, producing role-specific attention maps and visual features. The subject feature, object feature, and relation-aware latent state are concatenated into a 3072-dimensional vector, normalized with LayerNorm, and passed to a two-layer relation head. The relation head maps 3072 dimensions to 1024 with GELU activation, and then outputs logits over the final relation vocabulary of 2,111 labels. ReGFormer is used only during training and removed during inference.

7.3 Ablation Baseline Training Details↩︎

In the ablation study, we compare ReGuLaR with two baselines: Vanilla SFT and Text Rationales. Both baselines are initialized from the same Qwen2.5-VL-7B checkpoint and trained on RGrounding-351K. To ensure a fair comparison, we keep the main training setup consistent with ReGuLaR, including the frozen vision encoder and modality-alignment projector, optimizer, learning-rate schedule, batch size, number of training steps, and image resolution budget.

7.3.0.1 Vanilla SFT.

The vanilla SFT baseline is trained to directly generate the final answer without latent reasoning. It uses the same image-question-answer examples from RGrounding-351K, but removes the latent reasoning tokens, scene-graph triplet supervision, and ReGFormer objectives. The model is optimized only with the standard next-token prediction loss over the answer tokens.

7.3.0.2 Text Rationales.

The text-rationale baseline keeps the thinking-then-answering format but represents intermediate reasoning as natural language. Specifically, we convert the question-relevant scene-graph annotations into textual subject-relation-object triplets and insert them before the final answer as explicit rationales. For example, the textual rationale is formatted as a sequence of triplets such as refrigerator-in_front_of-dining table; person-wearing-shirt, followed by the final answer. The model is trained with next-token prediction over both the textual triplet rationales and the final answer. This baseline uses the same data and training recipe as ReGuLaR, but replaces relation-grounded latent supervision with explicit text-based rationale supervision.

8 Dataset Construction↩︎

RGrounding-351K contains 351,139 samples in total. Table 1 summarizes its data sources.

As described in Section 3.3, each sample contains an image, a question-answer pair, a scene graph, and bounding boxes for the objects involved in the scene graph or object relations. Most source datasets provide images, scene graphs, and object bounding boxes directly. VSR [43] does not include bounding boxes, but it is built on COCO [53], which provides object bounding box annotations for the corresponding images.

Many source datasets, however, do not contain question-answer pairs targeting the annotated relations. To construct such supervision, we use GPT-5.4 to generate relation-focused question-answer pairs from the scene graph annotations. We use the system prompt provided in Figure 6. The authors manually inspect 2,000 random samples from all data with AI-generated question-answer pair to verify that the generated questions are unambiguous and that the answers are faithful to the underlying scene graphs and visual evidence. We ensure a strict separation between training and evaluation data: none of the official evaluation examples are used for training.

9 Baseline Details↩︎

9.0.0.1 LLaVA-OneVision [49].

We include LLaVA-OneVision as a broadly trained open LVLM baseline. Unlike methods designed specifically for reasoning, LLaVA-OneVision is optimized for general visual instruction following across images, multi-image inputs, and videos. Its performance therefore reflects the capability of a strong general-purpose multimodal model.

9.0.0.2 Qwen2.5-VL-7B [2].

Qwen2.5-VL-7B serves two roles in our experiments: it is both a strong open-source LVLM baseline and the initialization of ReGuLaR. The model uses dynamic-resolution visual processing and has strong performance in visual tasks. Comparing with Qwen2.5-VL-7B directly measures the effect of adding our relation-grounded latent reasoning training.

9.0.0.3 DeepEyes [50].

DeepEyes represents a line of work that improves reasoning by changing how the model interacts with visual evidence. Instead of relying only on the original visual input, it trains the model with reinforcement learning to perform image-in-the-loop reasoning, such as inspecting useful regions more carefully. This makes it a relevant comparison for methods that strengthen visual reasoning through additional perceptual actions.

9.0.0.4 PAPO [51].

PAPO addresses the observation that multimodal RL can improve language-side reasoning while still leaving visual perception errors unresolved. It introduces perception-aware optimization so that policy learning is guided not only by answer correctness but also by whether the model preserves useful visual information. We compare with PAPO to evaluate against methods that explicitly target perception during reasoning.

9.0.0.5 Vision-R1 [52].

Vision-R1 brings R1-style post-training into multimodal reasoning. It first uses multimodal reasoning data for cold-start training and then applies reinforcement learning to elicit more deliberate reasoning behavior. It is included as a strong RL-enhanced LVLM baseline, complementary to our approach which improves reasoning through latent relation grounding rather than reward-based post-training.

9.0.0.6 LVR [7].

LVR is one of the closest baselines to our work because it also moves part of the reasoning process out of natural language. It trains autoregressive latent states to recover question-relevant visual tokens, allowing the model to reason in visual embedding space before generating the final answer. The key distinction is that LVR grounds latent states through visual reconstruction, while ReGuLaR grounds them through question-relevant object relations.

9.0.0.7 MONET [15].

MONET treats intermediate reasoning as continuous visual thoughts rather than decoded textual rationales. It uses staged training and latent-space policy optimization to make these continuous states useful for multimodal reasoning. We include MONET to compare with another recent framework that optimizes latent visual reasoning.

9.0.0.8 Laser [6].

Laser improves latent visual reasoning through latent superposition, where a latent state is encouraged to carry information about a broader future reasoning window rather than a single immediate step. This design improves efficiency and preserves richer visual semantics during latent reasoning.

10 Use of AI Assistants↩︎

We used AI assistants to support writing, coding, and data annotation. For writing, AI assistants were used to improve grammar and clarity, while all final text was reviewed by the authors. For coding, AI assistants helped with debugging and inspecting implementation details, with all code changes manually verified before use. AI assistants were also used in the data annotation pipeline; details of the annotation process and quality control are provided in Appendix 8.

11 Potential Risks↩︎

ReGuLaR is designed for research on vision-language reasoning and should not be used as a standalone system for high-stakes decision making. Like other LVLMs, it may produce incorrect or overconfident answers. RGrounding-351K is derived from existing public vision-language datasets and model-assisted annotation. It may therefore inherit biases, noise, or potentially sensitive visual content from the original data sources. We follow the licenses and terms of use of the source datasets, do not add personal metadata or identity labels, and manually inspect sampled generated annotations to reduce ambiguous or inappropriate question-answer pairs.

12 Artifact Licenses↩︎

RGrounding-351K is constructed from existing public vision-language datasets. We use these source datasets only for research purposes and follow their original licenses and terms of use. The derived dataset will be released subject to the licenses and redistribution constraints of the original data sources. The backbone and baseline models are used under their respective model licenses or terms of use. Our code will be released upon acceptance with a license specified in the release repository.

13 Personally Identifying Information and Offensive Content.↩︎

Our training data is derived from existing public vision-language datasets and does not introduce new personally identifying information beyond the source datasets. Since some source images may contain people, faces, scene text, or other potentially identifying visual content, we follow the access and redistribution terms of the original datasets. We do not collect additional personal information. We also manually inspect generated annotations to reduce ambiguous, offensive, or inappropriate question-answer pairs.

References↩︎