Skip to content

DGSeg: Dynamic Gating of Semantic-Spatial Guided Predictions for Reasoning Segmentation

Conference: ECCV2026
Paper: ECCV
Area: Multimodal VLM / Reasoning Segmentation
Keywords: reasoning segmentation, dynamic gating, semantic-spatial guidance, GRPO, promptable segmentation

TL;DR

DGSeg has the MLLM emit two complementary cues — a textual semantic description of what the target is and a bounding-box spatial localization of where it is — routes them through two separate segmentation branches, and uses a lightweight dynamic gating module to estimate pixel-wise fusion weights, reaching 69.6 (val) / 67.3 (test) gIoU on ReasonSeg under the zero-shot setting and surpassing strong baselines such as Seg-Zero, CoPRS and SAM-Veteran.

Background & Motivation

Reasoning segmentation requires a model to answer queries with implicit reference — "find a tool that can tighten screws", "what structure can drain water from a bathroom floor" — by first inferring which object is meant and then producing its pixel-wise mask. MLLMs are already good at the language side of such queries but remain weak at fine-grained localization, so the dominant recipe pairs them up: the MLLM does the thinking, a promptable segmentation model (SAM, SAM2, SAM3) does the drawing, and the interface between the two is an intermediate target cue — a point or a few points, a bounding box, the latent embedding of a <SEG> token, or a localization signal harvested from attention maps.

The problem lives precisely at that interface. Compressing a rich reasoning trace into one sparse cue is inherently lossy: when the target is a dog's nose, the box the MLLM produces often loosely covers the nose while sweeping in the whole dog, and the segmentation model happily treats those irrelevant regions as the target; point prompts may land on the wrong part entirely. Worse, multiple cues are meant to be complementary, yet existing methods — including the default usage of SAM3 — tend to encode semantic and geometric prompts jointly into one unified prompt representation before decoding, so any ambiguous or erroneous prompt contaminates the entire mask: the damage from a bad cue is global rather than local. Having the MLLM iteratively refine its prompts (re-prompting, multi-turn tool invocation) does mitigate this, but both training and inference costs are prohibitive, and the process is still vulnerable to the MLLM's own hallucinations.

The angle this paper takes is: instead of wrestling with noise inside a single shared prompt channel, let complementary cues travel their own paths and then fuse the two predictions by reliability. The MLLM is steered to answer both "what is the target" (semantic identity) and "where is the target" (spatial location), yielding a textual description and a bounding box as two complementary cues; each cue enters its own segmentation branch, and a lightweight dynamic gating module — trained with supervision derived from the relative segmentation quality of the two branches — decides pixel by pixel which branch to trust, suppressing the regions of the unreliable one. Core idea: replace "joint encoding" of complementary cues with "separate prediction + learned fusion", and train the gate against a soft target built from the two branches' own IoUs so that unreliable regions are down-weighted at the pixel level.

Method

Overall Architecture

DGSeg's pipeline reduces to three steps: generate cues, segment separately, fuse with weights. The input is an RGB image \(I\) and a language query \(T\). The MLLM (reasoning model \(F_{\text{reason}}\)) first writes out its reasoning trace in chain-of-thought style, then emits two parseable conclusions: a sentence describing the target's identity, \(c_{\text{sem}}\) (e.g. "the goat with black legs"), and a box-level localization \(c_{\text{spa}}\) (e.g. [152, 399, 501, 640]). SAM3 serves as the segmentation model \(F_{\text{seg}}\) because it accepts both semantic and spatial inputs. Unlike the original SAM3, which jointly encodes multiple prompts into a single unified prompt representation, DGSeg sends \(c_{\text{sem}}\) and \(c_{\text{spa}}\) down two separate branches, producing mask logits \(\ell_{\text{sem}},\ell_{\text{spa}}\) and mask predictions \(m_{\text{sem}},m_{\text{spa}}\) respectively. Finally, the dynamic gating module \(F_{\text{dg}}\) reads the pixel-decoder features of the two branches and predicts, per pixel, how much weight the semantic branch should receive; the two branches' logits are combined with those weights and thresholded into the final mask. The branch predictions are not only fusion inputs — how well each agrees with the ground truth also supplies the supervision that trains the fusion module, which is exactly what the second training stage does.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Image + language query"] --> B["Semantic-spatial cue generation<br/>CoT reasoning → text + bounding box"]
    B --> C["Semantic-spatial dual-branch segmentation<br/>each cue through its own SAM3 branch"]
    C --> D["Dynamic gating fusion<br/>pixel-wise weights over the two logits"]
    D --> E["Final mask"]

Key Designs

1. Semantic-spatial dual-perspective cue generation: making the MLLM state both what and where

No single cue type suffices: a <SEG> embedding carries semantics but localizes imprecisely, while boxes and points are spatially explicit yet semantically poor and prone to being oversized. Marr's classical framing of visual understanding as knowing what is where suggests that a complete object representation needs both semantic identity and spatial localization. DGSeg therefore instructs the MLLM, chain-of-thought style, to first produce a reasoning trace \(c_{\text{CoT}}\) and then two conclusions: a semantic cue \(c_{\text{sem}}\) and a spatial cue \(c_{\text{spa}}\). The semantic cue is a free-form textual description rather than a category label, and this is deliberate: category labels are costly to annotate and are not necessarily aligned with the prompt space the segmentation model actually operates in, whereas a descriptive sentence (e.g. "the part of the dog that allows it to have a keen sense of smell") lands much more directly in SAM3's text-prompt space. The spatial cue supplies coarse localization that narrows the search region around the target. The complementarity runs both ways — the semantic cue can correct the extra regions a loose box sweeps in, and the spatial cue can recover what a vague description fails to localize. The reliability of these cues is enforced by the Stage-1 RL fine-tuning (reward design in Loss & Training).

2. Semantic-spatial dual-branch segmentation: confining a bad prompt's damage to its own branch

Original SAM3 encodes multiple prompts into one unified prompt representation, so an unreliable prompt from any source affects the whole prediction. DGSeg instead routes \(c_{\text{sem}}\) and \(c_{\text{spa}}\) through two separate prompt paths, obtaining two independent sets of pixel-decoder features and two sets of mask logits. On the surface this is merely "splitting things up", but it preserves the correspondence between prompt quality and prediction quality: the semantic branch's prediction can only be corrupted by an error in the semantic prompt, and the spatial branch's only by an error in the spatial prompt. Those two error types are qualitatively different — a vague description versus a box that is too large or on the wrong part — which is exactly what makes it possible to judge, at the pixel level, which branch to believe locally. The ablation supports this reading: a joint-encoding baseline without fusion reaches only 60.8 gIoU, which is below the spatial-branch-only variant at 63.4, showing that noise in the semantic cue really does contaminate the whole mask when the prompts share one encoding; splitting them and fusing recovers 66.0.

3. Dynamic gating fusion: learning the fusion weights from branch features under relative-quality supervision

Each branch is right in some regions and wrong in others, and naive averaging drags the good branch down with the bad one (average fusion scores only 63.8 gIoU). The real difficulty is: on what basis should the fusion module know whom to trust? DGSeg's answer is to let the gate read it out of pixel-level features. \(F_{\text{dg}}\) takes the concatenation \([f_{\text{sem}},f_{\text{spa}}]\) of the two branches' pixel-decoder features — these come from SAM3's pixel decoder and encode the joint representation of image and cues while preserving segmentation patterns such as boundary structures and high-response regions — and pushes them through a light two-convolution network followed by a sigmoid, yielding a pixel-wise weight map \(W\in[0,1]^{1\times h\times w}\). After resizing \(W\) to the logits' spatial resolution, fusion is written as

\[\ell=W^{\uparrow}\odot\ell_{\text{sem}}+(1-W^{\uparrow})\odot\ell_{\text{spa}},\qquad m=\mathbb{I}[\ell>0]\]

where \(\odot\) is element-wise multiplication and \(\mathbb{I}[\cdot]\) is the indicator function (⚠️ the exact thresholding convention follows the original paper; this equation is OCR-damaged in the cached text). The crucial point is that the weights are per pixel rather than a single scalar for the whole image: within one target, the region around the box may belong to the semantic branch while the body of the target belongs to the spatial branch, and a scalar cannot switch locally like that — the ablation's "learned scalar" variant scores only 64.0 gIoU, 2.0 below the pixel-wise gate. The gate can learn this because the segmentation loss alone gives only ambiguous supervision over which branch should get how much weight; Stage 2 therefore constructs an auxiliary soft target \(W^{*}\) from the two branches' own IoUs and pushes the gate directly toward the branch closer to the ground truth (details in Loss & Training). Post-hoc analysis confirms the behaviour: the IoU difference between the semantic and spatial branches, \(s_{\text{sem}}-s_{\text{spa}}\), correlates strongly with the average fusion weight on the semantic branch (\(r=0.637\)); at the pixel level, when the semantic branch's logit is clearly higher the predicted weight also leans semantic (Fig. 3b). The gate thus learns more than "which branch is globally better" — it reads the joint image-and-cue features to make local decisions and perform local denoising. The paper also notes that stronger fusion modules such as MoE slot into the same pipeline and reach comparable performance (65.6), so the framework stays open about the fuser.

A Worked Example

Take the bottom example of Fig. 4 — the query "A truck on the bed of another truck", where the target is the truck being carried. The MLLM's <answer> yields a semantic cue (a description of the carried truck) and a box that roughly covers it. The semantic branch segments according to the description and follows the target's shape more faithfully; the spatial branch segments according to the box and tends to swallow the larger truck carrying it as well. Evaluating the two branches' features over foreground pixels, the gate visibly shifts weight toward the semantic branch in the region where the larger truck was wrongly segmented, and the final mask keeps only the carried vehicle. Neither branch is discarded along the way — the wrong part is simply suppressed through pixel-wise weighting.

Loss & Training

Training has two stages, deliberately decoupling cue generation from fusion learning so that the two optimizations do not interfere.

Stage 1: GRPO fine-tuning of the MLLM (LoRA), with the segmentation model frozen. The goal is for the MLLM to emit cues that are both structured and genuinely referential, so the reward has three terms. A format reward requires the reasoning process inside <think></think> and the final conclusion inside <answer></answer>, scoring 1 if the format is respected and 0 otherwise, so that cues can be parsed reliably. A spatial reward is simply the IoU between the predicted box \(c_{\text{spa}}\) and the ground-truth box \(b^{*}\). A semantic reward deliberately avoids category labels: the semantic cue is pushed through the semantic branch to obtain \(m_{\text{sem}}\), and its IoU with the ground-truth mask \(m^{*}\) becomes the reward. The rationale is that category labels are expensive to annotate and need not align with the segmentation model's working prompt space; using the segmentation model's mask preference as feedback effectively teaches the MLLM to speak a language the downstream model understands. The ablation confirms the choice — replacing the semantic reward with a label reward drops gIoU from 66.0 to 64.7, and removing it entirely drops to 62.1.

Stage 2: freezing the MLLM and the segmentation backbone, training only the dynamic gating module (3 epochs, batch size 1, learning rate \(1\times10^{-4}\), weight decay \(1\times10^{-4}\)). The overall objective is

\[\mathcal{L}=\mathcal{L}_{\text{seg}}+\lambda_{\text{w}}\,\mathcal{L}_{\text{w}}+\lambda_{\text{ent}}\,\mathcal{L}_{\text{ent}}\]

where \(\mathcal{L}_{\text{seg}}\) is the segmentation loss on the final fused mask; \(\mathcal{L}_{\text{w}}\) is a binary cross-entropy between the predicted weights and a soft target built by normalizing the two branches' IoUs \(s_{\text{sem}}=\text{IoU}(m_{\text{sem}},m^{*})\) and \(s_{\text{spa}}=\text{IoU}(m_{\text{spa}},m^{*})\) at temperature \(\tau\):

\[W^{*}=\frac{\exp(s_{\text{sem}}/\tau)}{\exp(s_{\text{sem}}/\tau)+\exp(s_{\text{spa}}/\tau)}\]

\(\mathcal{L}_{\text{ent}}\) is an entropy penalty on \(W^{\uparrow}\) that stops the gate from degenerating into an averaged 0.5 everywhere, while \(\lambda_{\text{w}}\) is annealed over iterations so that early training gets strong guidance without converging onto the soft target itself. Training additionally reweights pixels, assigning higher weight where the two branches disagree, since those are precisely the pixels where fusion matters. Remaining hyper-parameters and further configurations live in the supplementary material.

Key Experimental Results

Setup: Qwen2.5-VL (3B and 7B) as the reasoning model and SAM3 as the segmentation backbone; Stage 1 uses GRPO with LoRA at a per-GPU batch size of 8 with 8 samples per instance; Stage 2 trains for 3 epochs. Both stages are trained only on 9,000 instances sampled from RefCOCOg, so evaluation on ReasonSeg is zero-shot. Metrics are gIoU and cIoU: cIoU is the ratio of summed intersection to summed union over all images and is therefore biased toward large images, whereas gIoU averages per-image IoU; the paper takes gIoU as the primary metric on ReasonSeg.

Main Results

ReasonSeg, zero-shot (%):

Method MLLM Val gIoU Val cIoU Test gIoU Test cIoU
Seg-Zero Qwen2.5-VL-3B 62.6 58.5 56.1 48.6
PIXELTHINK Qwen2.5-VL-3B 62.3 58.5 58.8 52.1
CoPRS Qwen2.5-VL-3B 61.3 60.6 57.8 52.7
DGSeg Qwen2.5-VL-3B 66.0 58.3 60.0 50.3
Seg-Zero Qwen2.5-VL-7B 62.6 62.0 57.5 52.0
PIXELTHINK Qwen2.5-VL-7B 63.8 62.7 60.2 55.8
CoPRS Qwen2.5-VL-7B 65.2 64.5 59.8 55.1
SAM-Veteran Qwen2.5-VL-7B 68.2 67.3 62.6 56.1
SAM3 Agent Qwen2.5-VL-7B 65.4 50.5 62.6 56.2
DGSeg Qwen2.5-VL-7B 69.6 65.5 67.3 63.6

Referring segmentation (cIoU, %):

Method MLLM RefCOCO testA RefCOCO+ testA RefCOCOg test Avg.
Seg-Zero Qwen2.5-VL-3B 79.3 73.7 71.5 74.8
PIXELTHINK Qwen2.5-VL-3B 78.7 72.9 72.2 74.6
DGSeg Qwen2.5-VL-3B 78.9 74.5 72.3 75.2
Seg-Zero Qwen2.5-VL-7B 80.3 76.2 72.6 76.4
RISE Qwen2.5-VL-7B 79.7 77.7 73.4 76.9
SAM-Veteran Qwen2.5-VL-7B 80.8 76.6 73.4 76.9
DGSeg Qwen2.5-VL-7B 80.3 76.4 73.9 76.9

The difference between the reasoning and referring settings is worth stating explicitly: RefCOCO-style referring expressions are explicit ("the man in the black trousers on the left") and only require localization, whereas ReasonSeg queries are implicit ("what structure can drain water from a bathroom floor") and require inferring the target's identity before localizing it, so the two benchmarks probe different capabilities. On referring benchmarks DGSeg is tied for best rather than clearly ahead (7B average 76.9, level with RISE and SAM-Veteran), and the gains concentrate on the reasoning benchmark — consistent with the claim that semantic-spatial complementarity matters most for implicit references that demand reasoning. Note also that training data differ across methods: some baselines (e.g. LENS) are fine-tuned on the ReasonSeg training split while DGSeg is zero-shot, so absolute numbers are not directly comparable across methods (⚠️ setting differences follow the original paper).

Ablation Study

Fusion strategy and dual-branch design (ReasonSeg, Qwen2.5-VL-3B, gIoU %):

Config Val Test Note
Oracle fusion (\(W^{*}\) as upper bound) 67.9 62.8 reference ceiling, still short of perfect
Baseline (no fusion, joint prompt encoding) 60.8 55.7 semantic and spatial cues encoded jointly
Average fusion (non-learnable) 63.8 58.2 equal weights, good branch dragged down
Confidence-based weighting (non-learnable) 64.1 57.2 weights from confidence
Learned scalar 64.0 57.8 one weight for the whole image
MoE fusion 65.6 60.6 a stronger learnable fuser
Dynamic gating (ours) 66.0 60.0 pixel-wise weights
Semantic-only branch 55.3 52.8 text cue only
Spatial-only branch 63.4 54.9 box cue only

Reward design ablation (Qwen2.5-VL-3B, gIoU %):

Config Val Test Note
w/o Stage 1 (no RL fine-tuning) 36.0 33.7 cues fully unreliable, performance collapses
w/o format reward 64.6 59.6 unstable cue parsing
w/o semantic reward 62.1 58.5 largest single-term drop
w/o spatial reward 64.1 59.4 degraded coarse localization
Semantic reward replaced by label reward 64.7 59.1 misaligned with the segmentation model's prompt space
Full reward (ours) 66.0 60.0

Computational overhead (single H100):

Method Peak Memory (GB) ↓ FLOPs (GFLOPs) ↓ FPS ↑
Baseline (no fusion) 11.75 7375.7 0.280
DGSeg 12.24 (+4.2%) 7395.1 (+0.3%) 0.275 (-2.0%)

Key Findings

  • Cue quality is the bottleneck. Removing Stage 1 entirely collapses gIoU from 66.0 to 36.0 with the downstream segmentation architecture untouched, showing that the pipeline's ceiling is set by the cues the MLLM produces; the fusion module can only correct locally on top of that.
  • How the semantic reward is defined matters more than whether a semantic cue exists. Among the three reward terms, dropping the semantic reward hurts most (66.0 → 62.1), and replacing it with a category-label reward also drops to 64.7. The point is not merely to make the MLLM say something, but to align its output with the prompt space the segmentation model actually responds to — mask preference is a better feedback signal than human-defined labels.
  • Joint encoding really is contaminated by noise. The no-fusion joint-encoding baseline (60.8) scores below the spatial-branch-only variant (63.4), which is the most direct evidence for the paper's motivation; splitting and fusing reaches 66.0, higher than either single branch.
  • Finer fusion helps, but the ceiling remains. Learnable fusion generally beats non-learnable fusion, and the pixel-wise gate (66.0) beats the image-level scalar (64.0); the Oracle upper bound of 67.9 shows the gate cannot recover when both branches are wrong — it only helps in the "one branch right, one branch wrong" case.
  • The overhead is negligible. The dual-branch design plus gating costs only 0.3% more FLOPs and 4.2% more peak memory, with a 2.0% FPS drop — far cheaper engineering than the iterative prompt-refinement route.
  • A caveat on metrics. On ReasonSeg the 3B model's cIoU (58.3) is actually below Seg-Zero (58.5) and CoPRS (60.6); the paper explains that cIoU is dominated by large images and therefore takes gIoU as the primary metric. No single column should be read in isolation.

Highlights & Insights

  • Prompt quality is treated as a first-class citizen, but the fix targets how prompts are consumed rather than the prompts themselves. Unlike multi-turn re-prompting or prompt-denoising routes, DGSeg accepts that cues will carry noise and lets the downstream model absorb it through "separate consumption + learned fusion". This perspective transfers directly to any pipeline where an LLM emits structured prompts for a specialized downstream model (detection, tracking, retrieval).
  • Using the downstream model's mask preference as the RL reward instead of category labels. This is the paper's "aha" moment: aligning the reasoning model to the segmentation model's prompt space beats aligning it to human-defined semantic labels (64.7 → 66.0, and the semantic term accounts for a 3.9 drop when removed). The essence is to reward "whether the downstream model understands you", a cheap cross-module alignment signal that needs no extra annotation.
  • The soft fusion target supervises the gate without extra labels. Normalizing the two branches' IoUs at temperature \(\tau\) into \(W^{*}\) turns "which branch is closer to ground truth" into a per-pixel regression target; an entropy penalty prevents collapse into average fusion, and annealing avoids converging onto the soft target itself. This combination — auxiliary target + entropy regularization + annealing — is a reusable recipe for training gating or routing modules.
  • The engineering value of two-stage decoupling. Freeze the segmentation model and train the MLLM first, then freeze the MLLM and train a tiny module. This prevents two learnable components from interfering and makes Stage 2 extremely cheap (3 epochs, two convolution layers). The division of labour — heavy module aligned via RL, light module trained with supervision — is worth reusing.

Limitations & Future Work

  • No recourse when both branches are wrong. The gate can only assess which branch is relatively better and has no third source of evidence; the Oracle ceiling (67.9) shows that even a perfect gate is limited by the two branches' quality. Adding a third cue type (attention maps, depth or surface-normal priors) or triggering a fallback when both branches agree but are both wrong are plausible directions.
  • Strong coupling to the segmentation backbone. The semantic cue travels as a text prompt, so a text-prompt-capable model such as SAM3 is required; with SAM/SAM2, which accept only geometric prompts, the pipeline cannot be assembled as is. Swapping the semantic branch for another semantic injection route (e.g. CLIP-feature modulation) would sacrifice the premise that the two branches are symmetric, and needs weighing.
  • Training settings differ across compared methods. The paper stresses the zero-shot setting on ReasonSeg, yet some baselines in the table (LENS, for instance) were fine-tuned on the ReasonSeg training split; all models are trained on only 9,000 RefCOCOg instances, a relatively small budget, and the gains on referring benchmarks are clearly weaker than on the reasoning benchmark.
  • Key hyper-parameters live in the supplementary material. The annealing schedule for \(\lambda_{\text{w}}\), the value of \(\lambda_{\text{ent}}\), the temperature \(\tau\), the reweighting factor for disagreeing pixels and the gate's channel configuration are all absent from the main text, so reproduction requires the appendix.
  • Extendable directions: jointly train the gate and cue generation instead of freezing in two stages, so that Stage 1's reward also perceives gating behaviour; push the relative-quality supervision upstream and use the gate's output to guide the MLLM's cue refinement; and scale the two branches to multiple branches and multiple prompts (the paper itself notes the fuser can be replaced by stronger designs).
  • vs LISA: LISA conditions SAM on the contextual embedding of a <SEG> special token — effectively a single semantic latent channel with no explicit reasoning output and no way to judge whether that prompt is any good. DGSeg emits an explicit textual description and a bounding box as two cues, processes them separately and fuses them, adding the missing step of assessing and suppressing unreliable prompts.
  • vs Seg-Zero / Seg-R1: these take the purely spatial route (box plus points) and use RL to improve box quality; once the box is oversized, irrelevant objects enter the mask (the first row of Fig. 5 is exactly this failure). DGSeg keeps the spatial cue but adds a semantic one, and uses the gate to suppress the spatial branch's over-coverage at the pixel level.
  • vs SAM-Veteran / RSAgent / SegAgent: these follow "MLLM iteratively refines prompts", which reduces noise but is expensive to train and run and can still be misled by hallucinations. DGSeg buys similar robustness with a single forward pass plus a two-convolution fusion module (only +0.3% FLOPs).
  • vs LENS: LENS likewise combines semantic and spatial information and attaches a lightweight segmentation head to a frozen MLLM's attention maps, but it lacks any mechanism to assess target-cue reliability and is highly sensitive to erroneous cues (the original shows a failure case); the original also states that LENS was fine-tuned on the ReasonSeg training split, a different setting from DGSeg's zero-shot protocol (⚠️ the original cites LENS inconsistently, as [32] in Sec. 2.1 and as [58] in Fig. 5 and Sec. 4.4; follow the original).
  • vs SAM3 / SAM3 Agent: the original encodes multiple prompt types jointly into one representation, whereas DGSeg splits them into two branches and adds gated fusion on the same backbone. In Table 1, SAM3 Agent (7B) reaches 65.4 Val gIoU against DGSeg's 69.6, so the gap comes from how prompts are handled rather than from the skeleton's capacity.
  • Connection to Stable-SAM and SAMRefiner: those two show that the mask decoder produces biased activations under low-quality prompts and that more accurate prompts can be mined from coarse masks. DGSeg addresses the same concern about prompt quality, but denoises the fusion instead of the prompts, making the two lines complementary.

Rating

  • Novelty: ⭐⭐⭐⭐ The "separate prediction + learned fusion" combination is not entirely new, but constructing the soft gate target from relative branch quality and defining the RL semantic reward via segmentation-model mask preference are genuine contributions
  • Experimental Thoroughness: ⭐⭐⭐⭐ Two tasks, two model scales, four ablation groups (fusion strategy / reward / dual-branch / overhead) plus correlation analysis and visualizations; weaker on scale diversity beyond 3B and 7B, and the supplementary hyper-parameters never reach the main text
  • Writing Quality: ⭐⭐⭐ Motivation and framework are clearly narrated, but many formulas and figures in the text are OCR-damaged, the LENS citation number is inconsistent, and all key hyper-parameters are deferred to the supplement
  • Value: ⭐⭐⭐⭐ Leading zero-shot results on ReasonSeg (69.6/67.3 gIoU at 7B) at near-negligible cost, with two easily transferable techniques: downstream-model preference as reward, and soft-target supervision for gating