acceptodds
Under review as a conference paper at ICLR 2027

Where and When: Structure-Grounded Credit Assignment for Cross-Modal Reinforcement Learning

Abstract

Reinforcement learning for visual code generation is cross-modal: the reward comes from rendered pixels, but the actions are code tokens. Most existing methods assign the same advantage to every token in a response and the same credit to every edit in an episode. Finer-grained token-level methods ignore which screen region a token affects. Yet each rendered node, such as a DOM element, links a screen region to a code span. We propose Structure-Grounded Credit Assignment (SGCA), which uses these nodes to locate where in a response and when in an episode the reward is earned. Spatial credit reweights the advantage of each node's tokens according to that node's rendering error: below-average responses are penalized most where they differ from the target, and above-average ones are reinforced most where they match it. Temporal credit scores each edit by its subsequent return minus a learned baseline for edits to that node. On Design2Code, the spatial credit outperforms all baselines, improving CLIP score by 1.53 points, and its gain grows fivefold from the simplest to the most complex pages. In multi-turn repair, the gains from the two credits stack: together they improve CLIP score by 1.37 points and reduce LPIPS by 18% on web pages, and raise the official ChartMimic score, a metric not used in any reward, by 4.3 points. All twelve pre-specified comparisons remain significant after Holm correction.

Primary area:
reinforcement learning
Keywords:
credit assignment, reinforcement learning, visual code generation, multi-turn code repair, GRPO

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_KXB5OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper addresses credit assignment in RL for visual code generation, where rewards come from rendered pixels but actions are code tokens. It proposes Structure-Grounded Credit Assignment (SGCA), which uses the correspondence between rendered nodes (DOM elements or Matplotlib artists) and their source spans to assign finer-grained credit. Spatial credit rescales the GRPO advantage across tokens according to each block’s rendering error, oriented by the advantage sign and preserving the mean advantage, without learned models or extra rollouts. Temporal credit, for multi-turn repair, scores each edit by its return-to-go minus a learned node-conditioned value, which can also be used to choose the next component to edit.

Critical strengths
  1. The paper observes that each rendered visual part (e.g., a DOM element) maps to the code span that produced it. It uses this correspondence to weight tokens by the rendering error of their region, instead of broadcasting one advantage per response. This grounding of credit in visual-part–code correspondence is new, cheap (no learned model or extra rollouts), and generalizes from web pages to charts.
Critical weaknesses
  1. Lack of clarity of region-to-code mapping. The mapping relies on heuristics: source blocks are paired with DOM nodes in document order, and the discrepancy is measured inside the generated node’s box, which assumes positional alignment with the target. Displaced elements, missing elements, and CSS in <style> blocks can all misattribute credit. The only quantitative localization test uses single-fault injection on 100 pages, achieving 67% top-1 accuracy, which does not establish robustness under multiple compounding errors. The paper does not report how often the gate fires, how often pairing fails, or what fraction of tokens fall outside all blocks. This matters because the block-shuffled control shows that misplaced weights actively hurt structure (−3.7 HTML score).

  2. The generality claim is not supported beyond static rendering. Pages are rendered with scripts disabled, and both the reward and all evaluation metrics lack interactive evaluations. Functional behavior, such as whether a button works when clicked, is therefore neither rewarded nor measured, and the paper includes no dynamic or interaction-based evaluation. Yet the conclusion presents SGCA as a general recipe for learning from visual feedback (line 485). In interactive settings, the relevant code (event handlers, scripts) usually lies outside the element's source span, and errors only appear in specific UI states, so the node-to-code correspondence becomes many-to-many and state-dependent.

Questions for authors
  1. Could the authors explain the region-to-code mapping in more detail and report how reliable it is in practice? For example, how often does source-to-DOM pairing fail, when the browser repairs malformed HTML, and how is credit assigned when an element is displaced or missing from the generated page?

  2. How would the SGCA method handle interactive elements such as buttons? For these, the relevant code (event handlers, scripts) usually lies outside the element’s source span, and errors only appear after an interaction. Interactive elements are very important for webpages, but it seems the authors only use static screenshots to evaluate and disabled scripts when rendering. Evaluation benchmarks are also limited to static webpage evaluation. Could you provide results on WebGen-Bench as you mentioned in line 91?

  3. Have the authors tried SGCA with a newer or different parameter scale base model (e.g., the Qwen3-VL series or Qwen2.5-VL-3B)?

3 comments
AuthorsOpenReview ↗

Response to Reviewer KXB5

Thank you for your careful review and constructive comments.

Changes are marked in blue; section, table, and figure numbers refer to the revised manuscript.

W1 + Q1: Mapping and reliability.

Single-turn attribution proceeds as follows:

  1. Parse source character offsets and obtain rendered DOM nodes and boxes.
  2. Descend from body through at most three single-child wrappers; visible children become blocks.
  3. Pair source and rendered children in document order, stop at the first tag mismatch, and drop zero-area nodes.
  4. A token inherits its first character's block weight. Outside-block tokens, including <head>/<style> and unpaired blocks, receive the mean block weight. Eq. 2 applies sign orientation and normalization.
  5. Set spatial scales to one if fewer than two blocks pair, maximum discrepancy is below 0.02, or discrepancy spread is below a quarter of the maximum. This recovers single-turn GRPO.

In repair, blocks are visible children of the replaced component; spatial weights apply to the edit payload, and the gate retains SGCA-ST's temporal advantage.

Reliability. Pairing is truncated on 4.6% of training responses and fails outright on 2.7%; outright failures trigger the gate. Browser repairs occur on 6.8% of responses, declining from 12.1% to 3.4%. Of these repairs, 31% change block structure; the gate catches 93% of those, leaving 0.15% of responses with uncaught browser-repair misalignment. Overall gate rate is 11.4%. Outside-block tokens account for 23.5% of tokens, 81% of them in <head>/<style>.

Harder faults. Displacement can produce error within the generated element's own box. On 500 pages, explicit displacement reaches 63% Top-1 versus 4% chance. A missing element has no source span, so no token is blamed directly; its error falls in the parent's or a neighbour's box, and one of them ranks first on 54% of pages. With two/three simultaneous faults, Recall@k (k = fault count) is 56.5%/51.0% versus 8%/12% chance. Shared-CSS attribution identifies affected blocks with 31% Top-1 and 57% Top-3. The rule's tokens receive the default weight; linking rules to matched nodes would extend credit to the rule itself.

Misplaced weights. The original −3.7 HTML result uses full permutation. Permuting each response's weights with probability 0.25 retains 75% of the CLIP gain and yields 33.21 HTML versus GRPO's 31.91.

Revision: Sections 4.1–4.2 and Appendix C.1 clarify mapping and fallback; Appendix F.3 (Table A13) reports reliability statistics, harder faults, and the partial-permutation runs.

W2 + Q2: Interactive behaviour and generality.

We evaluate the existing single-turn checkpoints on WebGen-Bench with its official functionality and appearance pipeline. Each instruction is given as text-only input without an agent framework, and the model generates a single HTML file in one pass (three seeds).

CheckpointFunctional accuracy (%) ↑Appearance (1–5) ↑
Base model27.32.71
GRPO28.12.79
SGCA-S28.62.94

SGCA-S improves appearance by 0.15 over GRPO. Functional accuracy is on par (28.6 versus 28.1); we do not claim the 0.5-point difference as a gain. Training uses static renders with scripts disabled and no interaction reward, so spatial credit targets appearance.

We agree that the original conclusion overreached, and we have removed the statement that structure-grounded credit is "a general recipe for learning from visual feedback". The claim is now that the same credit rules are reused through task-specific structural mappings, shown for static HTML and Matplotlib renders. For buttons, credit must connect UI state, event handler, and visual outcome; rendering after interaction events and linking handlers to target elements through selectors would extend the interface to state-conditioned records. We leave this to future work.

Revision: Section 5.1 introduces this evaluation; Appendix F.5 (Table A15) reports results. Section 6 removes the general-recipe claim and states the static-render scope.

Q3: Newer and smaller models.

We add Qwen2.5-VL-3B and Qwen3-VL-8B using Table A2's single-turn settings (Design2Code evaluation, three seeds). The 7B row is from the original paper.

BaseGRPO CLIPSGCA-S CLIPΔ [95% CI]ΔLPIPS
Qwen2.5-VL-3B67.8469.711.87 [1.05, 2.68]−5.26
Qwen2.5-VL-7B71.1772.701.53 [0.82, 2.25]−4.44
Qwen3-VL-8B74.0275.201.18 [0.57, 1.80]−3.25

Both new models improve, with confidence intervals that exclude zero. The absolute CLIP gain shrinks as the base model improves, while the relative LPIPS reduction stays between 13% and 16%. All three policies are Qwen-VL models; we have not tested another family.

Revision: Sections 5.1–5.2 and Appendix F.2 (Table A12) report model settings, results, and the model-family scope.

We thank the reviewer again for the thoughtful comments.

Thank you for the detailed response and additional experiments. The new results address most of my concerns. I would suggest explicitly discussing the limitations of SGCA in handling dynamic and interactive webpages in the Limitations section, particularly the challenges of state-dependent credit assignment.

Overall, the rebuttal is appreciated and I will maintain weak acceptance for this paper.

Thank you for your constructive feedback and continued support. We will explicitly discuss SGCA’s limitations in handling dynamic and interactive webpages in the Limitations section, with particular attention to the challenges of state-dependent credit assignment.

Reviewer_KUGxOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes Structure-Grounded Credit Assignment (SGCA) for reinforcement learning in visual code generation. It uses DOM nodes or Matplotlib artists to connect rendered regions with source-code spans. The spatial component redistributes token advantages according to regional discrepancies and the sign of the response advantage, while preserving the mean advantage. The temporal component assigns credit to edits using subsequent returns minus a node-conditioned value estimate, which can also guide component selection. Experiments cover single-turn webpage generation, multi-turn webpage repair, and chart repair. The paper reports improvements from both components and further gains from their combination. Ablations examine weight placement, sign awareness, return-to-go, critic inputs, and edit ordering.

Critical strengths
  1. The paper addresses the mismatch between pixel-space rewards and code-token actions by using DOM nodes and Matplotlib artists to connect rendered regions with source spans. This design is well motivated and specific to visual code generation. Spatial credit assignment requires neither additional rollouts nor a learned attribution model.
  2. Experiments cover webpage generation, webpage repair, and chart repair, including CLIP, LPIPS, and the official ChartMimic low-level score. The ablations support the importance of structural correspondence and component-conditioned baselines. The independent gains from SGCA-S and SGCA-T, together with further improvements from SGCA-ST, also support their complementary roles.
Critical weaknesses
  1. Regional visual discrepancies do not necessarily identify the responsible code: parent layouts and shared CSS can affect multiple components, while missing components may lack corresponding nodes. The 67% Top-1 accuracy in the single-block fault-injection experiment supports the heuristic, but its reliability under shared-style errors, missing components, and simultaneous faults remains unclear. Fallback frequency and the training impact of misattribution are also unreported.
  2. Table 3 supports the node critic's effectiveness but does not establish whether it models long-term dependencies or primarily predicts near-term gains from local features. Experiments involve at most three editing rounds, without direct measurements of critic prediction error or component-ranking quality. Despite 20% random exploration under value ordering, estimates for infrequently visited components remain unvalidated.
  3. Cross-domain applicability depends on task-specific parsing, region localization, and editing interfaces. The results support HTML and Matplotlib settings with traceable structure and localized edits, but applicability to dynamic webpages, substantial cross-component dependencies, or tasks without explicit rendered nodes remains unverified.
Questions for authors
  1. Could the authors provide targeted localization results or failure analyses for parent-layout errors, shared CSS, missing components, or simultaneous faults? What fraction of training responses trigger attribution fallback, and what are the main causes?
  2. Can shallow block partitioning and mean regional discrepancy dilute small errors within large containers? Is there diagnostic evidence showing how block granularity or discrepancy aggregation affects localization and training performance?
  3. Could the authors report critic prediction error or component-ranking quality on held-out trajectories, particularly for infrequently visited components? With identical node features, how do predictions of immediate gains compare with predictions of subsequent returns? Existing results with longer editing sequences would also help establish the scope of the findings.
  4. Section 4.1 defines wj,i=ukw_{j,i}=u_k, but Figure 4 assigns the header of page 4518 a regional weight of 0.51 and a corresponding token weight of 0.70. What do these quantities represent? Is there an undocumented transformation, and is it used consistently in the main experiments and ablations?
4 comments
AuthorsOpenReview ↗

Response to Reviewer KUGx

Thank you for your careful review and constructive comments.

Changes are marked in blue; section, table, and figure numbers refer to the revised manuscript.

W1 + Q1: Attribution and fallback.

The gate fires on 11.4% of training responses. Its triggers are a maximum discrepancy below 0.02 (63% of gate events), fewer than two paired blocks (24%), and low discrepancy spread (13%). It sets spatial scales to one, recovering single-turn GRPO while retaining temporal credit in SGCA-ST. Outside-block tokens receive the mean block weight.

We expand fault injection to 500 held-out pages. Scores and chance levels are percentages; the last row reports Recall@k, with k the number of faults.

FaultTop-1 / Recall@kTop-3Chance
Original five types66.284.64
Parent layout58.079.08
Shared CSS31.057.010
Missing component54.076.08
2 / 3 simultaneous faults56.5 / 51.0–8 / 12

For parent-layout faults, a hit identifies the container or its most affected child; for missing components, the parent or neighbour. These and shared-CSS tests measure affected-region localization, whereas the original faults identify the modified block. Shared-rule tokens receive the default weight; linking CSS rules to matched nodes would extend credit to the rule itself.

To measure the training impact of misattribution, we permute each response's block weights with probability 0.25 or 0.5 (three seeds). This retains 75% or 44% of the CLIP gain over GRPO; full permutation removes it (Table 3).

Revision: Sections 4.1–4.2 and Appendix C.1 clarify mapping and fallback; Section 5.4 and Appendix F.3 (Table A13) report gate causes, fault localization, and the partial-permutation runs.

W2 + Q3: What the critic learns.

With identical node features, predicting subsequent return improves component selection: 52% versus 41% for immediate gain.

MeasureNode returnNode immediate gainPage-only†Largest error
Spearman with G_t0.580.370.26–
Best-component selection (%)52413429
Rarely visited components (%)46383130

† Page-only correlation pools pages and rounds. Its scores tie within a state, so its accuracy is the chance level under uniform tie-breaking.

We generate fresh trajectories on 100 training pages, execute every candidate at s_0 and s_1, and continue greedily to measure return. We use training pages because "rarely visited" is defined by training edit counts (bottom third, tracked per component on its source page), which exist only there; this diagnostic therefore does not cover held-out pages. When the node predictors disagree, the return predictor earns more in 64% of cases, mainly through layout edits enabling later text fixes. For longer sequences, evaluating the T = 3 checkpoints for five rounds increases SGCA-ST's CLIP lead over multi-turn GRPO from 1.37 to 1.62.

Revision: Section 5.4 and Appendix F.4 (Table A14) report critic diagnostics and the five-round evaluation.

W3: Cross-domain applicability.

We agree and have removed the conclusion's claim that structure-grounded credit is a general recipe. The same credit rules run on HTML and Matplotlib through different parsers and renderers; the evidence is limited to static renders with traceable structure. Dynamic pages require UI-state tracking; shared dependencies require linking a span to multiple affected regions; tasks without rendered nodes require another region-to-code mapping.

Revision: Section 1 clarifies the reusable interface; Section 6 states the static-render scope.

Q2: Granularity and aggregation.

Mean aggregation can dilute small faults: Top-1 is 49% in the largest third of blocks versus 74% in the smallest. Max and top-10% aggregation raise the large-block score to 61% and 60%. Descending one level deeper raises the gate rate by 6.3 percentage points. Training with max gives 72.84 CLIP versus 72.70 with mean (three seeds); the difference's CI includes zero, and both improve on GRPO.

Revision: Appendix F.3 reports these diagnostics and the mean-versus-max training comparison.

Q4: Figure 4 values.

Thank you for catching this; it was our plotting error, and we apologize.

The plotting script retained an old transform, 0.4 + 0.6·u_k, explaining the header's 0.51 → 0.70 (values rounded for display). We corrected panel (e) and the captions of Figures 4 and A1 to show raw w = u_k, before orientation and normalization.

The transform exists only in the plotting script. The main experiments follow Section 4.1 and Eq. 2, and the ablations follow Appendix C.1; see online_rule_attr.py, adv_estimator.py, and free_block_env.py in the anonymous repository. The experimental results are unaffected.

We thank the reviewer again for the thoughtful comments and we hope our response fully resolves your concern.

Dear Reviewer KUGx,

Thank you again for your thoughtful review. As the discussion period is closing soon, we would like to kindly check whether our responses have addressed your questions. Please let us know if anything remains unclear, and we will be glad to clarify.

Best regards,

The Authors

Thank you for your response, it has addressed most of my questions. I will maintain my score.

Thank you very much for your response and continued support of our work.

Reviewer_Fp8xOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Structure-Grounded Credit Assignment (SGCA), a reinforcement learning framework for visual code generation. SGCA improves reward attribution at both token and edit levels by leveraging the correspondence between rendered screen regions and code spans. Experiments on Design2Code and multi-turn repair tasks demonstrate consistent improvements from the proposed SGCA.

Critical strengths
  1. The paper is well organized, with a clear, logical structure.
  2. The proposed SGCA is reasonable and practical, which is expected to leverage the correspondence between rendered screen regions and code spans for visual code generation.
Critical weaknesses
  1. It would be better to include more recent and competitive baselines for visual code generation and reinforcement learning. In particular, the use of Qwen2.5-VL may not adequately reflect the capabilities of the latest available models.
  2. The paper would benefit from experiments involving LLMs of different parameter scales and model architectures.
Questions for authors

Please refer to Critical Weaknesses.

4 comments
AuthorsOpenReview ↗

Response to Reviewer Fp8x

Thank you for your careful review and constructive comments.

Changes are marked in blue; section, table, and figure numbers refer to the revised manuscript.

W1-a: Recent and competitive baselines.

We add EGCA [1] and GRPO versus SGCA-S under ReLook's critic reward, evaluated on Design2Code with three seeds.

MethodCLIP ↑LPIPS ↓GPU time (× GRPO)
GRPO71.1728.221.00
EGCA [1]71.6227.411.54
SGCA-S72.7023.781.22
ReLook critic reward + GRPO71.9526.882.05
ReLook critic reward + SGCA-S73.3122.972.27

New baseline. EGCA (Execution-Grounded Credit Assignment) [1] uses execution differences against a reference program and an LLM localizer to concentrate GRPO credit on the implicated code span. Our adaptation uses each page's reference HTML as the reference program and Qwen2.5-VL-7B-Instruct, the policy's base model, as the localizer (Appendix F.1). SGCA-S derives token weights from rendered regions and source spans, without reference code or an LLM localizer. It exceeds EGCA by 1.08 CLIP (95% CI [0.38, 1.79]) at lower training cost.

Reward control. With ReLook's critic reward fixed, SGCA-S adds 1.36 CLIP, which isolates credit assignment. The full ReLook adaptation in Table 1 differs from this control: it spends half of its generation budget on critic-guided revisions and adds a feedback loss (Table A3).

Existing baselines. The paper includes AT-RL (2026), ReLook (ACL 2026), WebGen-Agent (ICLR 2026), and MURPHY (2025), with budget-matched adaptations in Appendix C.4. SGCA-S exceeds AT-RL and ReLook by 1.22 and 0.91 CLIP at lower cost (Tables A5–A6).

Revision: Sections 5.1–5.2 and Appendix F.1 (Table A11) report these comparisons and distinguish the reward control from full ReLook.

W1-b + W2: Model scales, generations, and architectures.

We add Qwen2.5-VL-3B-Instruct and Qwen3-VL-8B-Instruct using Table A2's single-turn settings and three seeds. The 7B rows are from the original paper.

Base modelMethodCLIP ↑SSIM ↑MSE ↓LPIPS ↓HTML ↑
Qwen2.5-VL-3B (new)GRPO67.8465.2113.4633.1527.62
SGCA-S69.7167.0811.7227.8929.95
Qwen2.5-VL-7B (original)GRPO71.1769.9910.1228.2231.91
SGCA-S72.7071.548.9123.7833.68
Qwen3-VL-8B (new)GRPO74.0272.638.7424.9135.47
SGCA-S75.2073.887.8321.6636.92

SGCA-S improves every metric on both new models. CLIP gains are 1.87 (95% CI [1.05, 2.68]) at 3B and 1.18 ([0.57, 1.80]) at 8B. The absolute CLIP gain shrinks as the base model improves (1.87, 1.53, and 1.18 from 3B to 8B), while the relative LPIPS reduction stays between 13% and 16%. Gains increase with page complexity on both new models, matching the 7B trend (Table A7). In a preliminary one-seed Qwen3-VL-8B repair run, SGCA-ST gains 1.21 CLIP over multi-turn GRPO.

On architectures: all three policies belong to the Qwen-VL family, and we have not tested another family. SGCA computes credit from rendered structure and token offsets, not from policy attention or hidden states, and its temporal head uses separate frozen visual features, so nothing in it depends on the policy architecture. The evidence covers 3B to 8B and two model generations.

Revision: Sections 5.1–5.2 and Appendix F.2 (Table A12) report the model comparison and state its model-family scope; Appendix E distinguishes supplementary analyses from the twelve pre-specified tests.

References

[1] Abhijit Kumar, Natalya Kumar, and Shikhar Gupta. 2026. Execution-Grounded Credit Assignment for GRPO in Code Generation. arXiv:2603.16158.

We thank the reviewer again for the thoughtful comments and we hope our response fully resolves your concern.

Dear Reviewer Fp8x,

We sincerely appreciate your valuable comments. As the discussion period is closing soon, we would like to check whether our responses have adequately addressed your concerns. We would be glad to provide any further clarification if needed. If you find our responses satisfactory, we would greatly appreciate it if you could consider revising your score.

Best regards, The Authors

Dear Reviewer Fp8x,

We apologize for following up again. As the discussion period closes in a few hours, we would like to briefly summarize how our rebuttal addresses your two concerns:

  • Recent baselines: we added EGCA (2026), a recent credit-assignment method for GRPO; SGCA-S outperforms it by 1.08 CLIP at lower training cost. Under ReLook's critic reward, SGCA-S also adds 1.36 CLIP over GRPO (Table A11).
  • Model scales and generations: in addition to the original 7B results, SGCA-S improves all metrics on Qwen2.5-VL-3B (+1.87 CLIP) and the newer Qwen3-VL-8B (+1.18 CLIP) (Table A12).

If these address your concerns, we would be grateful if you could consider updating your evaluation. If any concern remains, please let us know and we will respond before the deadline.

Best regards,

The Authors

Dear Reviewer Fp8x,

We are very sorry to bother you once more. With about two and a half hours left in the discussion period, we would be sincerely grateful if you could take a brief look at our additional baselines (Table A11) and model-scale results (Table A12). If you feel these have addressed your concerns, we would deeply appreciate it if you would kindly consider updating your score. Thank you very much for your time and understanding.

Best regards,

The Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

Author Summary of the Review Process

Dear Reviewers, Area Chair, Senior Area Chairs, and Program Chairs,

We thank Reviewers Fp8x, KUGx, and KXB5 for their valuable feedback. We are encouraged that the reviewers find the core idea of grounding credit in the correspondence between rendered nodes and code spans to be new and cheap (KXB5), well motivated (KUGx), and reasonable and practical (Fp8x). Below is a summary of our responses.

  • Reviewer KXB5 (Rating 3) asked about the reliability of the region-to-code mapping, interactive webpages, and newer base models. We reported mapping and fallback statistics, extended fault injection to harder cases, added a WebGen-Bench evaluation, added results on Qwen2.5-VL-3B and Qwen3-VL-8B, and narrowed the generality claim. The reviewer indicated that the new results address most of their concerns and maintained weak acceptance. As suggested, we added a Limitations section on dynamic and interactive webpages.

  • Reviewer KUGx (Rating 3) asked about attribution under harder fault types, the critic's long-term modeling, and a plotting inconsistency in Figure 4. We added fault-injection and fallback analyses, critic diagnostics, and a five-round evaluation, and corrected the plotting error, which does not affect any results. The reviewer indicated that our response addresses most of their questions and maintained weak acceptance.

  • Reviewer Fp8x (Rating 2) raised two requests concerning experimental scope rather than the method itself: (1) more recent baselines, and (2) different model scales and newer base models. For (1), we added EGCA (2026), which SGCA-S outperforms by 1.08 CLIP at lower training cost, together with a reward-controlled comparison under ReLook's critic reward (Table A11). For (2), SGCA-S improves all metrics on Qwen2.5-VL-3B and Qwen3-VL-8B (Table A12); Reviewer KXB5 raised the same question and indicated that the new results address their concerns. Reviewer Fp8x has not responded to our rebuttal throughout the discussion period.

In summary, we have responded to every concern with new experiments or clarifications, and both reviewers who engaged in the discussion maintained their support for acceptance. All revisions are marked in blue in the updated manuscript. Amid the rapid pace of today's AI research, we are sincerely grateful to all reviewers and chairs for their patience and dedication throughout the review process.

Best regards,

The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.