acceptodds
Withdrawn from ICLR 2027

Beyond Blind Generation Scaling: Verification-Guided Inference for Diffusion Language Models

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Test-time scaling typically improves language-model performance by spending additional inference compute on generation, implicitly assuming that more generation compute directly yields more reliable outputs. We show that this view is incomplete for diffusion language models. By decomposing model outcomes according to their observability, we identify a compute-dependent loud-to-silent-to-correct transition in the output distribution: as denoising compute increases, loud failures decline before semantic errors disappear, creating an intermediate regime in which surface-valid but incorrect outputs become dominant among the remaining failures before correctness eventually catches up. This reveals that surface validity can improve before semantic correctness. Motivated by this failure transition, we introduce *verification-guided inference*, a new test-time inference paradigm that moves beyond blind generation scaling by separating candidate generation from output assurance. The model first generates with a moderate budget, filters directly observable validity failures with a lightweight deterministic check, and applies an independent verifier to the remaining candidates; only rejected candidates receive higher-budget regeneration. Across code generation and mathematical reasoning, the transition persists across diffusion model families and evaluation controls. On security-sensitive programming tasks, silent failures can additionally include functionally valid yet vulnerable programs. Independent verification detects 72–83% of silent failures with a single pass costing only 2.3% of the token-forward compute of 256-step generation. Under full coverage, verification-guided inference improves correctness from 41.1% to 48.0%, reduces silent failures from 45.8% to 34.0%, and lowers average generation-equivalent compute from 256 to 243.

Primary area:
generative models
Keywords:
Diffusion language models, test-time scaling, verification-guided inference, silent failures, inference-time compute, code generation, semantic verification

Reviews

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

The paper observed that as the number of denoising steps increases, the output distribution transitions from mostly invalid to mostly valid but incorrect, and then may transition to mostly correct. Based on this observation, the paper proposes verification-guided inference, which combines a deterministic checker and an independent verifier to filter outputs with smaller budgets and regenerate only those that failed the checks with larger budgets. On HumanEval and MBPP, the method improves accuracy from 41.1% to 48.0% with less generation compute.

Critical strengths
  1. The paper provides good motivation and observations that surface validity can improve before semantic correctness. Although this may not be surprising, it is valuable to see this discussed in DLMs as the denoising budget increases.

  2. The paper proposes a simple, intuitive yet effective method to adaptively decide whether to invoke a fixed high budget.

Critical weaknesses
  1. I think the paper could benefit from some discussion of other related work on adaptive DLM inference (e.g., Prophet [1] and PG-DLM(adapt) [2]), as these methods also adaptively decide inference computation based on reward or confidence signals derived from the current or completed generation. More importantly, I would love to see some matched comparisons on the same evaluation subset, decoding configuration, output length, and total compute, etc.

  2. As the authors acknowledge, the failure regime varies across model-task pairs, and the latency benefit depends on how often verification permits early termination. Therefore, the observed performance gain may be highly dependent on the current selected model/task pair.

[1] Li, Pengxiang, et al. "Diffusion language model knows the answer before it decodes." The Fourteenth International Conference on Learning Representations. 2026.

[2] Dang, Meihua, et al. "Inference-Time Scaling of Diffusion Language Models via Trajectory Refinement." arXiv preprint arXiv:2507.08390 (2025).

Questions for authors
  1. Table 4 already shows that Self-Verification is much weaker at error identification. How would the end-to-end results change with smaller or weaker verifier models? Does the reported gain come from a general allocation strategy, or more from having a stronger model as the verifier?

  2. Would the method be applicable to tasks where there is no capable independent verifier?

  3. What is the value of using DLM when direct generation with Qwen2.5-7B-Instruct will have higher single-sample correctness 69.1% compared with the reported 48.0%? Some discussion of the end-to-end latency, throughput, compute, and memory differences would be helpful to justify the accuracy gap.

Reviewer_zgyXOpenReview ↗
Rating
2
Confidence
1
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates how the composition of errors in diffusion language models changes with increasing test-time denoising computation. The authors distinguish between loud failures, which violate directly observable validity requirements, and silent failures, which satisfy basic validity checks but remain semantically incorrect. They report that increasing denoising steps initially reduces loud failures more rapidly than semantic errors, leading to a growing proportion of silent failures among incorrect outputs.

Motivated by this observation, the authors propose verification-guided inference, a two-stage procedure that combines deterministic validity checking with an independent language-model verifier. Candidates accepted by both stages are returned immediately, while rejected candidates undergo fresh generation with a larger denoising budget.

The method is evaluated on code generation, mathematical reasoning, and security-sensitive programming tasks using LLaDA, Dream, and Dream-Coder. Additional experiments examine decoding settings, stronger correctness tests, self-verification, and verification overhead. On HumanEval and MBPP, the proposed method reportedly improves correctness from 41.1% to 48.0%, reduces silent failures from 45.8% to 34.0%, and reduces average generation-equivalent compute from 256 to 243. The authors also report improvements in accuracy and computational efficiency on GSM8K.

Critical strengths

One strength of the paper is that it looks beyond overall accuracy and examines how additional inference computation affects different types of errors. The distinction between obvious failures and outputs that look valid but are actually incorrect is particularly useful. The results show that making outputs more valid doesn't necessarily make them more correct. This is an important finding for understanding the limitations of test-time scaling in diffusion language models.

Another strength is that the proposed method is simple and practical. It combines validity checking, independent verification, and selective regeneration. The authors evaluate it on both coding and mathematical reasoning tasks, with additional experiments across different models and decoding settings. They also consider stronger correctness checks, security-related tasks, and computational overhead. These evaluations make the findings more convincing and practically relevant.

Critical weaknesses

My main concern is that the reported efficiency gains are difficult to reconcile with the earlier results. Based on the failure rates in Table 1 and the verifier rejection rates in Table 4, I would expect more regeneration and therefore higher computational costs than those reported in Table 5. The authors explain that these results come from separate experimental runs, so this is not necessarily a contradiction. However, without the actual acceptance rates, escalation frequencies, and computational costs at each stage, it's difficult to understand where the efficiency gains come from. This makes the paper's main quantitative claim less convincing.

My second concern is that the proposed method seems quite similar to existing verification-guided inference approaches. Using a verifier to select candidates and deciding when to spend more computation are already well-established ideas. The paper applies them to diffusion language models, but it's not entirely clear what the new methodological contribution is. I would also like to see stronger comparisons under the same compute budget, including directly using the verifier model for generation, generating multiple candidates and selecting the best verified one, and existing adaptive diffusion methods. Without these baselines, it's hard to tell whether the improvements come from the proposed method itself or from a fairly standard verification-and-regeneration strategy.

Questions for authors

What are the actual acceptance and escalation rates for the two verification-guided settings in Table 5, and how much computation does each stage require?

Tables 1 and 4 seem to suggest more regeneration than the average compute reported in Table 5. Could you explain this difference and clarify which experimental settings changed?

Why does verification-guided inference increase loud failures from 13.1% to 18.0% while reducing silent failures? Could you also show the final outcomes for accepted and regenerated candidates?

How does your method compare with direct Qwen2.5-7B-Instruct generation, generating multiple diffusion candidates and selecting the verified ones, or adaptive diffusion methods, under the same compute budget?

Are the improvements in correctness, silent failures, and computation statistically significant? Could you provide paired confidence intervals and check whether the gains still hold under EvalPlus?

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

This paper categorizes intermediate outputs from DLMs into three types: loud errors, silent errors, and correct outputs. Using this categorization, the authors show that increasing denoising compute initially reduces loud errors while increasing silent errors. Eventually, at higher denoising budgets, silent errors decrease as correctness improves. Based on this observation, the authors propose an efficient inference method that uses a higher denoising budget only when the correctness of the initial output cannot be verified. To verify correctness, they use deterministic validation and an LLM judge. They use three different DLMs and five datasets: HumanEval, MBPP, GSM8K, EvalPlus, and CWEval. Their method improves correctness while reducing average compute.

Critical strengths
  • Extensive experimental setup: 3 DLMs, 5 datasets spanning math and code, and an analysis of the LLM judge's verification capabilities.
  • They find that errors transition from loud failures to silent failures to correct outputs. This finding provides insights beyond final task accuracy.
Critical weaknesses
  • The novelty of the method is very incremental given prior work. Works with very high overlap in motivation and approach have not been adequately discussed: [1] PRISM: https://openreview.net/forum?id=QrC8OgQyOI; [2] FrugalGPT: https://openreview.net/forum?id=cSimKw5p6R.
  • The dependence on the LLM judge has not been experimentally studied. How robust are the method's gains to the capability of the LLM judge? Do the compute savings disappear if the LLM judge is more computationally expensive?
Questions for authors
  • How does this work fundamentally differ from prior related works?
  • How sensitive are the method's benefits (accuracy as well as compute savings) to the use of a weaker or stronger LLM judge?
  • The reported compute costs seem difficult to reconcile with the error distributions. Can you provide detailed numbers connecting the error distributions to the compute savings?

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

Related papers

Discussion (0)

Sign in to comment.