acceptodds
Under review as a conference paper at ICLR 2027

From Position Risks to Block Survival: Faster Generation for Diffusion Language Models

Abstract

Diffusion language models (DLMs) can accelerate generation by predicting multiple tokens in parallel, but there is a mismatch between how these tokens are predicted and how they ultimately contribute to generation. Parallel predictions can hardly condition on the tokens selected earlier within the same block, even though their validity depends on this realized prefix. Under the popular proposal-verification decoding, this mismatch makes errors highly asymmetric: an early rejection prevents all subsequent proposals from contributing decoding progress. We introduce BRISK-DLM, a framework that addresses both mismatches by optimizing proposal learning and selection for verified progress. BRISK-DLM trains on self-generated sequences, using risk–reward weighting to dynamically prioritize positions by their impact on verified progress and decoding cost. During inference, a lightweight prefix-conditioned corrector reranks existing candidates using previously selected tokens and preferences distilled from the model’s own verifier. The corrector reuses the backbone's parallel representations and requires no additional backbone evaluation, while fused execution keeps its overhead small. BRISK-DLM improves end-to-end throughput by up to 37.4% while preserving task quality, establishing a new quality-throughput frontier for DLM generation.

Primary area:
generative models
Keywords:
Diffusion Language Models, Inference Acceleration, Parallel Decoding, Proposal Verification

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_TBR5OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes BRISK-DLM to improve verified parallel generation. The method combines correctness-filtered self-generated training, position weights based on decoding progress and forward-pass cost, and a lightweight prefix-conditioned corrector that reranks existing candidates. Experiments on 8B and 32B I-DLM report geometric-mean throughput gains of 22.7% and 29.8%, respectively, with additional ablations and a transfer study on DFlash.

Critical strengths
  1. Clear motivation and coherent method design. The paper directly targets the early proposal errors that prevent later tokens from contributing decoding progress. Table 3 separates the effects of training data, position weighting, and the corrector, making the main design choices reasonably well supported.

  2. Strong reported efficiency results with practical measurements. The evaluation covers two model scales, three workloads, and six concurrency levels. Throughput includes the corrector overhead, and the implementation study usefully distinguishes improvements in tokens per forward from actual wall-clock gains.

Critical weaknesses
  1. Quality preservation is not uniform. At 32B, MATH-500 decreases from 97.6 to 96.0, MathBench from 95.6 to 92.8, and AIME-2024 from 83.3 to 76.7. Other tasks improve, but the paper does not provide uncertainty estimates. The results support a useful, task-dependent quality-efficiency trade-off rather than uniform quality preservation.

  2. The specific advantage of the cost-aware weighting is not fully isolated. The controlled ablation compares dynamic and uniform weights, while the D-PACE comparison also changes the generation system. Comparisons with a fixed positional schedule or accepted-prefix weighting would make the contribution of the FPT-derived weights clearer.

Questions for authors

N/A

1 comment

Thank you for recognizing our coherent design and practical efficiency gains. We appreciate your suggestions on quality uncertainty and more controlled weighting ablations.

W1. Task quality and evaluation variability.

To quantify evaluation variability, we report the mean and sample standard deviation across three evaluation runs for each model on seven benchmarks:

ModelGSM8K (%)MATH-500 (%)MathBench (%)AIME-2024 (%)AIME-2025 (%)HumanEval (%)MBPP (%)
Qwen3-32B94.40 ± 0.2697.53 ± 0.4694.43 ± 1.0178.90 ± 1.9180.00 ± 3.3094.43 ± 0.3192.77 ± 1.34
I-DLM-32B94.68 ± 0.3297.33 ± 0.3195.20 ± 0.4081.11 ± 1.9278.90 ± 1.9194.30 ± 0.2092.93 ± 1.27
BRISK-DLM-32B95.37 ± 0.2596.53 ± 0.5092.70 ± 0.3678.90 ± 1.9178.90 ± 1.9193.33 ± 1.1594.13 ± 1.21

All results are mean ± sample standard deviation over three evaluation runs.

The repeated evaluations indicate stable performance across runs, with task-dependent changes rather than a uniform degradation across benchmarks. Fine-tuning updates the model parameters and can affect tasks differently; similar differences are also observed between Qwen3-32B and I-DLM-32B.

Across the seven benchmarks, the macro-average scores are 90.35% for Qwen3-32B, 90.64% for I-DLM-32B, and 89.98% for BRISK-DLM-32B. BRISK therefore maintains broadly comparable aggregate quality, with a 0.66 percentage-point decrease relative to I-DLM, while improving throughput by 29.8%.

W2. What does modeling forward-pass cost add to adaptive weighting?

Table 3 compares BRISK with standard uniform weighting. Following your suggestion, we also evaluated a fixed linear schedule that assigns the highest weight to the first proposal and decreases the weight linearly toward the last. Linear weighting performs comparably to BRISK early in training, when both emphasize the first few positions. As those positions become more reliable, BRISK shifts emphasis toward later tokens that can extend the accepted prefix, whereas the linear schedule continues to favor the same early positions.

On MATH-500 at stride N=8, with the same correctness-filtered training data and the corrector disabled, uniform weighting yields 15.55% rejection and 3.13 TPF, fixed linear weighting yields 15.20% rejection and 3.20 TPF, and BRISK achieves 14.03% rejection and 3.35 TPF. The lower test TPF of the linear schedule supports adapting positional priorities over training.

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

The paper proposes BRISK-DLM, a method for speeding up diffusion language models that use proposal–verification decoding, such as I-DLM. BRISK-DLM first finetunes the model on its own correct generations, with weights derived such that training focuses on the positions that most limit accepted progress. Second, BRISK-DLM introduces a lightweight head that reranks the top-K parallel candidates at inference and is trained to match the model's own verifier.

The authors evaluate BRISK-DLM on 8B and 32B I-DLM models across math and code benchmarks. It improves throughput over I-DLM by 22.7% at 8B and 29.8% at 32B, with comparable task quality on most benchmarks. The training recipe also transfers to the DFlash drafter, and the paper includes ablations and a detailed analysis of the corrector.

Critical strengths
  1. The motivation is sound. In a proposal-verification setting, it makes intuitive sense that positions should be weighted by their effect on accepted progress, since an early rejection discards all subsequent proposals. The paper motivates this cleanly and proposes a reasonable algorithm to address it. The figures are particularly helpful, especially Figures 1 and 4.

  2. The experiments are thorough. The paper reports results on multiple model scales, concurrency levels, and GPU configurations, against multiple baselines. The ablation section is also extensive: each algorithmic component is ablated individually, and sweeps over hyperparameters such as the candidate size K and the stride N are provided.

Critical weaknesses
  1. The risk–reward weighting in Section 3.2 closely follows D-PACE, whose overlap is only discussed in the appendix. Both are motivated by an acceptance-based efficiency objective and derive largely the same per-position loss weights. When each verification step costs a single forward pass, the BRISK weight matches the D-PACE weight up to a factor of (1 − a_i).

  2. The prefix-conditioned corrector adds considerable complexity for a modest gain. It improves throughput by only 5.5% in Table 3, and its reference implementation actually reduces throughput, so the gain depends on fused kernels. The main novelty, supervising on reached states through the first rejection, yields only small improvements over teacher-forced supervision in Table 5 (2-7% TPS).

  3. Unlike most speculative decoding methods, BRISK does not preserve the output distribution of the original model, since it fine-tunes the backbone that also serves as the verifier. Performance decreases on several benchmarks in Table 1 (e.g., MathBench and AIME-24 at 32B, HumanEval and MBPP at 8B). Moreover, the throughput gains diminish as concurrency increases. For instance, Qwen3-32B nearly matches BRISK-32B at C = 32.

Questions for authors
  1. Can the authors compare BRISK weighting against D-PACE weighting within the same pipeline?

  2. Can the authors report throughput at higher concurrency levels (e.g., C = 64-256), which are common in production serving?

6 comments

Thank you for recognizing our sound motivation and thorough experiments. We appreciate your suggestions on controlled comparisons with D-PACE and evaluation at higher concurrency.

W1. How does BRISK’s scope differ from D-PACE’s?

D-PACE and BRISK pursue a similar goal: translating parallel proposals into higher generation throughput. BRISK targets a broader class of proposal–verification systems, extending beyond the separate diffusion-drafter–autoregressive-target setting studied by D-PACE. In particular, our framework supports I-DLM-style self-verification, where a single backbone generates new proposals while verifying previous ones within the same forward pass. Rejection in this setting affects both accepted-prefix length and the number of forward passes required for decoding. BRISK therefore accounts for decoder-specific progress and execution costs through an objective based on forwards per committed token, making its formulation applicable to both self-verifying DLMs and separate drafter–target systems.

Within this broader scope, BRISK addresses two complementary subproblems, each with new contributions. First, how can proposal learning reflect the states and failure costs encountered during generation? We combine correctness-filtered self-generated trajectories with cost-aware position weighting, aligning the training contexts and supervision with realized decoding behavior. Second, how can independently predicted candidates form a coherent proposal block? We introduce a prefix-conditioned corrector that selects candidates according to the preceding selections, with supervision from states actually reached during verification. These contributions connect proposal learning with block construction rather than modifying position weights alone. With the trained backbone fixed, the corrector provides a further 5.5% net throughput improvement on MATH-500 without an additional backbone forward pass (Table 3).

We also directly compare BRISK and D-PACE weighting within the same DFlash pipeline, keeping all other settings fixed. On GSM8K across concurrency levels C ∈ {1, 2, 4, 8}, BRISK improves geometric-mean throughput by 23.9% over the original DFlash and 8.1% over D-PACE under matched experimental settings. This controlled comparison establishes the effectiveness of BRISK weighting in their shared setting, while our I-DLM experiments demonstrate the complete framework in a self-verifying architecture.

W2. Does the corrector’s gain justify its complexity?

We appreciate your close look at the corrector’s cost and benefit. In this serving stack, fused execution is the standard way a component is integrated rather than a requirement specific to the corrector: I-DLM’s own system optimizations, including CUDA Graph capture, stationary-batch scheduling, and a fused verification kernel, give 2.1–2.5× over its unoptimized implementation (Yu et al., 2026, their §3.3 and §4.3). Our corrector is integrated the same way; it adds no backbone evaluation and does not modify the trained backbone, the verification rule, or the stopping rule. The unfused reference row in Table 15 is a diagnostic in the same spirit.

Our corrector provides a consistent net gain. With the backbone fixed, it removes over one fifth of the remaining rejections (14.03% → 11.10%) and raises TPF by 8.4% and TPS by 5.5% (Table 3). On A100, it improves TPS over head-off decoding by 7.2–13.6% (Table 5) and by 8.2–9.5% with lower p95 latency (Table 15). On supervision, the 2–7% TPS range you note is accurate. It comes from changing only the training targets, with the same head and inference path: over the stronger teacher-forced control at each load, BRISK supervision adds 2.2%, 3.5%, and 4.0% TPS, roughly one third of the corrector’s total gain.

W3. Output distribution and task quality.

BRISK fine-tunes the backbone that also serves as the verifier. Our quality claim concerns empirical task performance rather than exact distributional equivalence. To assess evaluation variability, we conducted three evaluation runs for each 32B model on seven benchmarks:

ModelGSM8K (%)MATH-500 (%)MathBench (%)AIME-2024 (%)AIME-2025 (%)HumanEval (%)MBPP (%)
Qwen3-32B94.40 ± 0.2697.53 ± 0.4694.43 ± 1.0178.90 ± 1.9180.00 ± 3.3094.43 ± 0.3192.77 ± 1.34
I-DLM-32B94.68 ± 0.3297.33 ± 0.3195.20 ± 0.4081.11 ± 1.9278.90 ± 1.9194.30 ± 0.2092.93 ± 1.27
BRISK-DLM-32B95.37 ± 0.2596.53 ± 0.5092.70 ± 0.3678.90 ± 1.9178.90 ± 1.9193.33 ± 1.1594.13 ± 1.21

All results are mean ± sample standard deviation across three evaluation runs.

The repeated evaluations indicate stable performance across runs, with task-dependent changes rather than uniform degradation across benchmarks. Fine-tuning updates model parameters and can affect tasks differently; similar mixed changes are also observed between Qwen3-32B and I-DLM-32B.

Across these seven benchmarks, the macro-average scores are 90.35% for Qwen3-32B, 90.64% for I-DLM-32B, and 89.98% for BRISK-DLM-32B. BRISK therefore maintains broadly comparable aggregate quality, with a 0.66 percentage-point decrease relative to I-DLM. At 8B, the original seven-benchmark average increases from 84.4% to 84.9%, despite the individual declines on HumanEval and MBPP. We acknowledge these task-level regressions; comparable aggregate quality does not imply preservation on every benchmark.

We address the concurrency-dependent throughput gains separately below.

Q1. How do the two weighting rules compare under matched conditions?

We compare BRISK and D-PACE weighting within the same DFlash pipeline, keeping the settings identical and changing only the weighting rule. On GSM8K across concurrency levels C ∈ {1, 2, 4, 8}, BRISK improves geometric-mean throughput by 23.9% over the original DFlash and 8.1% over D-PACE under matched experimental settings.

Importantly, BRISK’s contribution extends beyond position weighting. It combines correctness-filtered self-generated training data, acceptance-aware proposal learning, and prefix-conditioned candidate selection to improve end-to-end generation efficiency. Its applicability spans both self-verifying DLMs and separate drafter–target systems: we evaluate the full framework on I-DLM and demonstrate transfer of the training recipe to DFlash with a fixed autoregressive target. The controlled weighting comparison therefore evaluates one component of a broader framework, rather than the entirety of our contribution.

Q2. How does throughput scale at concurrency 64–256?

We ran the 32B models at C=64, 128, and 256 on 2×H200 (TP2) with the same fixed 2,048-token protocol. Under heavy load a smaller stride is preferable (Table 13), so we report N=4 (aggregate TPS):

TaskCI-DLMBRISKGainQwen3-32B
GSM8K642,890.93,616.21.25×3,800.8
GSM8K1283,417.64,358.11.28×6,001.2
GSM8K2563,560.64,650.81.31×7,559.4
MATH-500642,776.83,654.91.32×3,881.6
MATH-5001283,361.14,351.61.29×4,783.3
MATH-5002563,594.84,637.61.29×7,419.1

The gain over I-DLM does not diminish. Across C=64–256, BRISK is 25–32% faster than I-DLM. In this regime the GPU is saturated, so throughput follows compute per committed token, which BRISK lowers by raising TPF.

Against the AR model, we agree with your observation. Each ISD forward processes 2N-1 positions per request, so strided decoding spends more compute per committed token than AR decoding (Yu et al., 2026, their Appendix B) and saturates the GPU earlier. BRISK is within 6% of Qwen3-32B at C=64 and reaches about 62% of it at C=256. This is a property of the decoding paradigm, which BRISK inherits. What BRISK changes is where the crossover occurs: at C=64, I-DLM is at 72–76% of the AR throughput and BRISK at 94–95%.

Thank you for the detailed response. I believe the new results, especially the high-concurrency table, are useful additions to the paper. However, my main concerns still remain. First, the novelty is limited, since the paper closely follows the motivation of D-PACE. Second, at high concurrency, BRISK still lags behind Qwen3-32B, which limits its practical applicability. Moreover, since the method does not preserve the original output distribution, it loses accuracy on several benchmarks. Therefore, I will maintain my original score.

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

Diffusion language models (DLMs) generate multiple tokens in parallel, but early token rejection invalidates an entire proposal‑block and limits real throughput. BRISK‑DLM optimizes for verified progress per forward pass. It uses risk‑reward weighted training on correctness‑filtered self‑generated trajectories to prioritize critical positions. At inference, a lightweight prefix‑conditioned corrector reranks existing candidates without extra backbone forward passes. Fused GPU execution keeps overhead low. Evaluations on math reasoning and code generation show meaningful throughput gains while maintaining output quality, and the approach transfers to other DLM drafting systems.

Critical strengths
  1. Practical insight on DLM bottleneck: Identifies that per‑position rejection compounding (early rejection kills whole block progress), rather than raw block size, governs real parallel efficiency; frames optimization around verified progress per forward pass.

  2. Two‑pronged solution covering training + inference: Combines adaptive risk‑reward loss weighting for training and a lightweight reranking corrector for inference; does not modify the underlying DLM backbone architecture.

  3. Corrector design is compute‑friendly: No additional backbone forward evaluation, re‑uses existing candidate pool; heavy overhead is eliminated via fused GPU execution.

Critical weaknesses
  1. Depends on high‑quality self‑generated trajectories: Training requires correctness‑filtered model‑produced samples. If base DLM generates many wrong reasoning traces, training data quality degrades and hurts final performance.

  2. Still residual overhead from corrector: Though optimized, the lightweight corrector introduces non‑zero runtime cost; naive un‑fused implementation reduces end‑to‑end throughput, requiring careful system‑level engineering.

  3. Corrector only reranks existing Top‑K candidates: Cannot generate new tokens outside the precomputed candidate set; performance is bounded by the quality of the base proposal distribution.

Questions for authors
  1. Can risk‑reward positional weighting be adapted for non‑diffusion speculative‑decoding systems (e.g. standard autoregressive draft‑verify)?

  2. How does BRISK‑DLM behave for extremely long sequences, where block‑level rejection patterns may shift drastically?

  3. Can we remove the requirement for expensive self‑generated trajectory collection, and derive risk‑reward weights purely from offline static datasets?

  4. How does this method perform on open‑domain conversational or creative writing tasks, where correctness filtering for trajectories is hard to define?

2 comments

Thank you for recognizing our focus on verified progress and our efficient design. We appreciate your suggestions on training data requirements and broader applicability.

W1. Filtering may leave too few correct trajectories.

In our experiments, correctness filtering leaves sufficient data for effective adaptation. For the 8B model, a collection from the initial checkpoint retains about 86% of generated responses, yielding 40 million tokens of correctness-filtered training data. The complete adaptation pipeline requires 150 GPU-hours on H20, including data collection and training. With this budget, BRISK improves geometric-mean end-to-end throughput by 22.7% over I-DLM across the evaluated workloads and concurrency levels. When a base model solves few hard prompts, fewer trajectories pass the filter for a fixed generation budget. One way to keep filtering efficient is to mix datasets of different difficulty: start with easier prompts that the model can solve reliably, train on their accepted responses, and introduce harder prompts as the model improves. The quantity to track is the number of retained responses per generation budget at each difficulty. Moreover, our controlled ablation shows that filtering improves MATH-500 accuracy from 91.4% to 96.2% at only a 2.5% throughput cost. These results demonstrate that retaining reliable supervision is effective without requiring a large unfiltered corpus or repeated data regeneration.

W2. The unfused corrector can reduce throughput.

We want to kindly note that the corrector adds no backbone evaluation, but an unoptimized implementation can reduce throughput. With the same backbone and corrector checkpoint on A100 at C=1, the reference implementation lowers throughput from 90.0 to 60.4 tok/s, whereas optimized execution reaches 97.4 tok/s (Table 15). Across C=1, 8, and 32, the optimized corrector is 8.2%, 9.5%, and 9.1% faster than head-off decoding, with lower request p95 latency.

This level of system integration is already standard for the baseline: I-DLM’s serving stack relies on CUDA Graph capture, stationary-batch scheduling, and a fused verification kernel (Yu et al., 2026, their §3.3 and §4.3). Our corrector follows the same execution model, using fused execution and CUDA Graph replay, so it runs inside the existing serving path rather than requiring separate infrastructure.

W3. Reranking is limited to the top-K candidates.

We chose K=16 empirically, as the point where candidate coverage has largely saturated and measured throughput is highest. On MATH-500 head-off first rejections, Top-16 already contains the verifier’s top-ranked token in 96.56% of states; doubling to K=32 adds only 2.15 points (Table 6), and ranks 17–32 are selected in 0.07% of cases. With the corrector fixed, K=32 improves neither decoding progress (natural-EOS TPF of 4.07 vs. 4.36 at K=16; Table 6) nor serving speed, where K=16 is 1.9–8.6% faster at all three evaluated concurrency levels (Table 14).

The restriction applies to proposals, not to the decoder’s output: under Section 3.3 of our paper, a rejected position is resampled over the full vocabulary, so tokens outside Top-K remain reachable. The candidates themselves come from the proposal distribution, which risk–reward training improves (Section 3.2).

Q1. Do the weights transfer to autoregressive drafters?

Yes, provided the verifier commits a prefix and the cost model accounts for both drafting and verification. The weights depend on how improving acceptance at one position changes expected cost per committed token. For an autoregressive drafter, sequential draft steps have a cost that should be included rather than reusing the I-DLM cost formula. Table 4 provides a related transfer result: applying our training recipe to DFlash with a fixed Qwen3-8B autoregressive target improves geometric-mean throughput by 18.3% on GSM8K. DFlash uses a parallel drafter, so this experiment does not establish the gain for a conventional autoregressive drafter.

Q2. Do speedups persist on very long sequences?

BRISK’s components operate at the block level: position weights depend only on the position within a proposal block, and the corrector state is re-initialized at every block, so neither assumes a sequence length. Empirically, we ran 64 MATH-500 problems with natural stopping, so that all measured tokens are task output, under an 8,192-token cap (8B, 1×H200, C=1, N=8).

SystemTPSCompletion time, median / p90 (s)Mean output tokensCorrect
I-DLM-8B462.46.59 / 17.653,82057/64
BRISK, corrector off559.46.07 / 15.873,85160/64
BRISK600.85.78 / 14.103,87460/64

BRISK is 29.9% faster than I-DLM, with similar output lengths and no loss in accuracy. The longest requests benefit at least as much: p90 completion time, which reflects outputs near the cap, falls by 20%.

Q3. Can offline data replace self-generated trajectories?

Yes. Given offline prefixes, the model can propose continuations and the verifier can score them; the resulting conditional acceptance estimates determine the weights. No reference answer is needed for this calculation, although the text alone does not supply the verifier statistics. Table 3 already tests offline data with dynamic weighting: the open-source-data row reaches 83.4% accuracy and 1,436.2 tok/s on MATH-500, compared with 96.2% and 1,847.2 tok/s using filtered self-generated data under the same weighting rule. These results distinguish feasibility from performance: self-generation is optional for computing the weights, but the choice of training prefixes mattered in this experiment.

Q4. How does BRISK perform on open-ended generation?

Only the data-selection step in BRISK-DLM uses answer-level correctness. For math problems, we filter out responses with incorrect final answers to avoid reinforcing those errors during training. For open-ended dialogue or creative writing, many different responses can be valid, so we can skip this filter: matching a single reference answer would discard potentially useful variation in content and style. The rest of BRISK-DLM relies on token-level signals: position weighting uses the verifier’s acceptance rate at each proposal position, and the corrector learns which candidates the verifier prefers given the prefix. Neither requires a correctness label for the response as a whole.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.