acceptodds
Under review as a conference paper at ICLR 2027

Error-Aware Flexible-Length Diffusion Language Model

Abstract

Diffusion language models are trained to generate text by iteratively refining corrupted sequences in a non-autoregressive way. This makes them particularly attractive for error correction tasks. However, standard diffusion language models are usually trained on synthetically corrupted sequences and are limited to a fixed output length, which significantly constrains their performance. We propose a novel Flexible-Length Diffusion Language Model, which addresses the problem of fixed output length by allowing the model not only to substitute tokens during the reverse process but also to insert and delete them. Our model achieves a 21.25% relative improvement over the best USDM configuration on HumanEval single-line code infilling, while maintaining comparable text generation performance. Moreover, we question whether random errors introduced by the standard forward process during training are sufficient for error correction. In particular, we study diffusion models as error correctors in automatic speech recognition (ASR) settings and introduce a framework for using TTS and CTC as a forward process to generate realistic ASR errors and train diffusion models with this task-specific corruption. Additionally, we extend existing methods for using diffusion models for ASR by proposing new decoding methods that not only significantly reduce the gap to autoregressive language models but also achieve a better WER-RTF trade-off. Our Flex ASR-DiffLM model achieves a WER of 3.41% on LibriSpeech dev-other, surpassing the autoregressive language model on several evaluation sets while performing recognition 1.5-2x faster. We publish all training and evaluation recipes.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
discrete diffusion models, diffusion language models, error correction models, flexible-length generation, speech recognition, decoding methods

Reviews

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

The paper extends text diffusion with token insertion and deletion, so output length can change during generation. It also trains ASR correction models on errors produced by a TTS-to-CTC pipeline and introduces faster decoding and rescoring methods. Experiments show better code infilling than the tested diffusion baselines and a useful ASR accuracy-speed trade-off on LibriSpeech. General text generation is comparable only with additional length initialization.

Critical strengths

Insertion, deletion, and substitution address a real limitation of fixed-length diffusion, with clear gains on the reported code-infilling tasks.

Critical weaknesses
  1. Appendix B.1 uses weighted cross-entropy without noise-level conditioning, and evaluates neither iterative denoising nor the count head. In this setup, the model acts as a parallel edit predictor. A matched non-diffusion editor is not compared, so faster decoding than an autoregressive corrector does not isolate what the diffusion formulation adds. This weakens the connection between the paper’s two main contributions.

  2. In Table 6, outputs average only 6.0 tokens without forced insertions; two initial updates raise this to 14.7, and three to 29.0. MAUVE rises from 0.46 to 0.84 after two updates. Appendix A.3 also reports count underestimation. This leaves the model’s ability to learn the output-length distribution unconvincing, which matters because flexible length is the central contribution.

Questions for authors

In the reported ASR system, which training or inference operation distinguishes Flex ASR-DiffLM from a non-diffusion parallel edit model trained on the same TTS-CTC pairs?

How were the two forced initialization updates selected, and what existing evidence shows that this choice transfers across target-length ranges without retuning?

20 comments

Thank you very much for the review and for the two very important questions. Below, we will provide additional experiments and we believe that the new results should address the concerns you raised.

In the reported ASR system, which training or inference operation distinguishes Flex ASR-DiffLM from a non-diffusion parallel edit model trained on the same TTS-CTC pairs?

Yes, we agree. In our ASR-specific DiffLM, there is no substantial difference that distinguishes Flex ASR-DiffLM from a non-diffusion parallel edit model trained on the same TTS-CTC pairs with our augmented canvas. It was intended as a first step to introduce real ASR errors into the forward process. Our framing in the submission was not clear enough here and we have revised Section 1, Section 4, Section 5 and Appendix C to make it clearer.

Our motivation was a controlled comparison. All four models use the same architecture and the same decoding methods and they differ only in the sequence length and in the corruption:

Table A (Table 7). Relation between our DiffLM formulations for speech recognition.

Corruption / Sequence lengthFixedVariable
SyntheticUSDMFlex-DiffLM
ASR errorsASR-DiffLMFlex ASR-DiffLM

Our solution to the fixed-length problem is the augmented canvas, while training on real ASR errors is our solution to synthetic corruption. Combining the augmented canvas with real ASR errors shows the largest improvement over standard USDM (4.22 to 3.88 with the best decoding method of each model, CTC trained without TTS data, Table 5).

But one-step correction is not specific to Flex ASR-DiffLM. A DiffLM includes iterative denoising, a noise schedule during training, noise conditioning and the clean-token predictor pθ,sp_{\theta,s}. For speech recognition, we use all our diffusion LMs (USDM, Flex-DiffLM, ASR-DiffLM and Flex ASR-DiffLM) as single-step correctors, which only need pθ,sp_{\theta,s}. We do not use the count head for any of them.

For iterative denoising, our results show that it does not give an improvement on LibriSpeech.

Table B. USDM (25 epochs) iterative joint decoding on LibriSpeech dev-other. WER [%] for different numbers of denoising iterations and initial noise levels.

Iterations LLτstart=0.1\tau_{\mathrm{start}}=0.1τstart=0.2\tau_{\mathrm{start}}=0.2τstart=0.3\tau_{\mathrm{start}}=0.3τstart=0.4\tau_{\mathrm{start}}=0.4
14.604.634.634.65
24.594.604.624.62
34.594.604.604.62
44.584.594.604.60
54.594.604.604.60

This means that for ASR, we are only interested in the difference in how pθ,sp_{\theta,s} is trained.

From the training perspective, standard discrete DiffLMs are also close to parallel denoising models. MDLM training is masked language modeling like BERT with a sampled masking rate and USDM predicts the clean tokens from a sequence with uniformly replaced tokens in the same way. Our ASR-specific DiffLMs keep this setup and only replace the synthetic corruption with TTS-CTC errors.

Reviewer_dzaCOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

The paper has two contributions that are only loosely connected. Flex-DiffLM (Sec. 3), and Error-aware training for ASR error correction (Secs. 4–5). They propose a uniform-state (USDM-style) discrete diffusion LM that can also change sequence length. The paper also proposes a single-pass "pseudo-log-likelihood" (PLL) score for diffusion-LM rescoring and three decoding schemes: DiffLM-Sum, Denoising+Rescoring and Soft-Input decoding.

Critical strengths
  • Clear and practical motivation. Combining USDM-style "re-evaluate every token" substitution with insertions and deletions suits error correction, where the positions and types of errors (sub/ins/del) are unknown.
  • Useful practical findings for ASR + diffusion LMs.
  • Transparancy on algorithms, definitions, are good.
Critical weaknesses

I hope the authors can address this question: it appears that length is not actually learned. Variable-length behaviour depends on a separately trained count head plus heuristics, and the main claims hide this.

  • The reverse step needs |D_g|. This comes from a post-hoc count head trained on a frozen backbone with MSE regression on targets clipped at 15. The paper itself states the count head "often underestimates the number of missing tokens, leading to short sequences" in text generation.
  • Without the two forced "insert into every gap" updates, unconditional samples average 6.0 tokens with MAUVE 0.46 (Table 6). With three forced updates the mean length is 29.0. The output-length distribution is therefore set by an inference hyperparameter, not learned. This undercuts the claim that the model works "without specifying the target length in advance"
Questions for authors

see above

11 comments

Thank you very much for the review! Below, we answer the points you raised, and we will be happy to discuss them further.

it appears that length is not actually learned. [...] Without the two forced "insert into every gap" updates, unconditional samples average 6.0 tokens with MAUVE 0.46 [...] The output-length distribution is therefore set by an inference hyperparameter, not learned.

We also noticed this issue and have been working on improving it since the submission.

Note: we did not change the forward process, the model or the diffusion training objective of Section 3, and we use the same Flex-DiffLM checkpoint as in the submission. Our work was only focused on improving the sampling procedure and the count head. Everything else stayed the same.

In the submission, we used the simplified reverse process of Section 3.1. Without forced updates, it generates 6.0 tokens on average with MAUVE 0.46, and with two forced updates 14.7 tokens with MAUVE 0.84 (Table 9, Table 6 in the submission).

Below, we remove each simplification one by one (always with no forced initialization steps, since there is no such hyperparameter anymore). All transition probabilities below follow from our forward process.

1. Inserting noise tokens. Our forward process inserts a noise token into each gap with probability τlen(1−τlen)\tau^{\mathrm{len}}(1-\tau^{\mathrm{len}}). During the reverse process, this probability increases as τlen\tau^{\mathrm{len}} moves from 1 to 0.5 and decreases from 0.5 to 0. In the submission, we handled only the decreasing part, by deleting inserted tokens with the factor

rdel=max⁡(0  1−τ′len(1−τ′len)τlen(1−τlen)),r_{\mathrm{del}}=\max\left(0\;1-\frac{\tau'^{\mathrm{len}}(1-\tau'^{\mathrm{len}})}{\tau^{\mathrm{len}}(1-\tau^{\mathrm{len}})}\right),

and clipped the increasing part to zero. In the true reverse process, noise tokens are also inserted. A gap without a noise token receives one with probability

rins=max⁡(0  τ′len(1−τ′len)−τlen(1−τlen)1−τlen(1−τlen)).r_{\mathrm{ins}}=\max\left(0\;\frac{\tau'^{\mathrm{len}}(1-\tau'^{\mathrm{len}})-\tau^{\mathrm{len}}(1-\tau^{\mathrm{len}})}{1-\tau^{\mathrm{len}}(1-\tau^{\mathrm{len}})}\right).

Without noise tokens, every visible token during sampling was a real token. So the count head saw inputs unlike its training data and reported too few missing tokens, by a factor of about 1/(1+τlen)1/(1+\tau^{\mathrm{len}}). A simulation of this sampler with an ideal count predictor ends at 7.7 tokens on average, where the training text has 21.6.

This also explains why the submission needed two forced insertion updates: they compensated for the missing noise-token insertions at the start of sampling.

2. Several tokens per gap. In the submission, a gap with ∣D∣|\mathcal D| deleted tokens restored at most one token per step, with probability 1−(τ′len/τlen)∣D∣1-(\tau'^{\mathrm{len}}/\tau^{\mathrm{len}})^{|\mathcal D|}. In the true reverse process, each deleted token is restored independently with probability 1−τ′len/τlen1-\tau'^{\mathrm{len}}/\tau^{\mathrm{len}}.

3. Count head with cross-entropy. In the submission, the count head was trained with MSE on counts clipped at 15 and its output was rounded. We now train it with cross-entropy on the exact count, so it predicts a distribution over the number of deleted tokens.

Here, we show results that support our intuition in the comment above.

Table A. Effect of each change (1,500 samples, 96 steps).

ModelForced updatesGen PPL ↓\downarrowMean lengthEntropy ↑\uparrowMAUVE ↑\uparrow
Real text--31.223.42.780.90
AR LM, variable length--36.215.32.400.86
MDLM, 16 tokens--42.316.02.670.90
USDM, 16 tokens--39.816.02.650.88
Flex-DiffLM, submission240.814.72.490.84
Flex-DiffLM, submission0195.46.01.650.46
+ 1. noise tokens are inserted053.914.02.330.81
+ 2. several tokens per gap050.616.02.430.84
+ 3. count head with cross-entropy040.521.92.740.87

Table B. Length distribution of the generated sequences and of the training text.

Forced updatesMeanStd10%25%Median75%90%
Training text--21.614.8610182943
Flex-DiffLM, submission06.03.0345710
Flex-DiffLM, submission214.76.0810141923
Flex-DiffLM, reimplemented reverse process021.513.5811182940

One of the most important things: with the reimplemented reverse process, the generated lengths follow the training text: the mean, the median and the 75% quantile are the same, and the spread is close (13.5 against 14.8).

Also, with this count head, the mean length does not depend on the number of sampling steps. With 384 and 1,152 steps it stays at 21.2 and 21.3 tokens, while Gen PPL improves to 36.8 and 33.7 and MAUVE to 0.87 and 0.89. So the number of sampling steps changes the quality of the samples, not their length.

This undercuts the claim that the model works "without specifying the target length in advance"

With our reimplemented reverse process, this claim actually holds without any forced updates. Unconditional generation starts from the empty sequence and gives 21.5 tokens on average, where the training text has 21.6. In the previous comment, we also compared the learned length distribution with the reference distribution.

Reviewer_athHOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies diffusion language models with length-editing capabilities and their application to ASR error correction. General Flex-DiffLM uses an interleaved blank canvas, separate content and length noise variables, and corresponding training and sampling procedures to insert, delete, and substitute tokens during denoising. The authors further use TTS→CTC to generate task-specific errors for fixed- and variable-length ASR models, combining one-step parallel correction with hypothesis aggregation, soft inputs, and efficient sequence scoring. Experiments cover code infilling, text generation, and LibriSpeech ASR, showing benefits for unknown-length infilling and a promising recognition accuracy–speed trade-off.

Critical strengths
  1. The variable-length design addresses the practical difficulty of unknown infilling lengths and yields clear gains. The interleaved blank canvas allows token insertion and deletion alongside content correction. In Table 1, variable-length Flex-DiffLM reaches 46.95% HumanEval single-line Pass@1, exceeding the best USDM configuration at 38.72% and the best DreamOn configuration at 41.14%. It also obtains the strongest non-oracle results among the evaluated diffusion models on multi-line infilling and SantaCoder-FIM. These comparisons directly support the value of reducing reliance on a prespecified infilling length.
  2. Task-specific training and parallel correction demonstrate useful ASR system gains. Table 4 compares corruption sources, length-editing capabilities, and decoding methods, providing partial evidence about their respective roles. In the single-greedy-hypothesis correction setting of Table 5, Flex ASR-DiffLM achieves 4.38% WER and an RTF of 0.0013, compared with 4.69% and 0.0054 for the denoising LM. Together with the operating-point comparison in Figure 2, these results indicate potential for competitive recognition quality at lower processing cost.
Critical weaknesses
  1. The narrative is fragmented, and the central contribution and its connection to the experiments are insufficiently clear. The paper introduces variable-length diffusion modeling, ASR-aware corruption, and several decoding and scoring methods, but does not sufficiently organize their relative importance and dependencies. It is difficult to identify whether the primary advance is a general multistep generation framework or a one-step parallel editing system for ASR, and to attribute the gains across tasks to specific design choices. For example, general Flex-DiffLM uses two noise conditions, multistep sampling, and a count head, whereas the ASR-specific models use weighted cross-entropy without time conditioning and perform one-step correction without the count head. These differences are disclosed in the main text and Appendix B.1, and Table 4 provides partial comparisons, but the overall presentation still lacks a clear connection from the central problem to the method and its validation. The paper should clarify how the two approaches relate, delineate their respective contributions, and explain which results support the general diffusion mechanism versus task-specific training and editing-based decoding. This affects both readability and the assessment of the contributions' significance and the scope of the experimental conclusions.
  2. The robustness of correction and length control needs more targeted analysis. Overall WER demonstrates a net benefit, and some methods retain the original hypotheses during rescoring, but the paper does not separate repaired errors from newly introduced ones. In particular, the rate at which initially correct CTC transcripts become incorrect after final selection is not reported. This limits understanding of how correction gains and overcorrection are distributed across examples. For variable-length text generation, Appendix G.1 already demonstrates the influence of initialization on length and quality: zero, two, and three forced insertion updates yield mean lengths of 6.0, 14.7, and 29.0, respectively. Appendix A.3 also acknowledges underestimation by the count head in text generation. For code infilling, each gap permits at most one insertion per reverse step, making the relationship between missing-span length and sampling budget particularly relevant. Aggregate results and oracle comparisons in Table 1 support average gains, but do not show how count errors and infilling success vary with missing-span length, leaving effectiveness on longer missing spans in need of further diagnosis.
Questions for authors
  1. Could the contributions and their validation be organized more clearly around the central problem? Please explain the relationship and respective contributions of general variable-length generation and one-step ASR editing. A single comparison table listing each model's training objective, shared and omitted components, inference procedure, and corresponding experiments would help. Building on Table 4, please clarify which gains support the general diffusion framework and which primarily arise from task-specific corruption, parallel editing, and decoding design.
  2. How many new errors are introduced while correcting existing ones? Please report the proportion of initially correct CTC transcripts that become incorrect under the final system, and analyze initially correct and incorrect examples separately. Further separating improvements and newly introduced substitution, insertion, and deletion errors would help explain how the aggregate WER gains are distributed.
  3. How do longer missing spans affect count prediction and infilling performance? Please stratify code-infilling examples by reference missing-span length and report count-head error, output-length deviation, and completion accuracy under a fixed sampling budget. This would clarify the effects of count prediction and a finite sampling budget on longer spans, beyond repeating the existing initialization-sensitivity analysis for text generation.
15 comments

We thank the reviewer very much for the constructive review and the clearly formulated strengths, weaknesses and questions.

Please explain the relationship and respective contributions of general variable-length generation and one-step ASR editing. A single comparison table listing each model's training objective, shared and omitted components, inference procedure, and corresponding experiments would help.

We have added additional clarification in Section 1 (Introduction) and Section 5 (Using Diffusion Language Models for ASR) to better explain how our variable-length diffusion framework relates to one-step ASR editing (see red changes). We also added Appendix C (Model Comparison), where we compare the four models and explain how they are connected. We hope these additions make the relationship between the models clearer.

Below, we will post several comments that address your points more specifically.

For example, general Flex-DiffLM uses two noise conditions, multistep sampling, and a count head, whereas the ASR-specific models use weighted cross-entropy without time conditioning and perform one-step correction without the count head.

For speech recognition, we use all diffusion LMs as single-step correctors. According to our additional results (and also in line with related works), iterative denoising does not provide an improvement on LibriSpeech.

Table A. USDM (25 epochs) iterative joint decoding on LibriSpeech dev-other. WER [%] for different numbers of denoising iterations and initial noise levels.

Iterations LLτstart=0.1\tau_{\mathrm{start}}=0.1τstart=0.2\tau_{\mathrm{start}}=0.2τstart=0.3\tau_{\mathrm{start}}=0.3τstart=0.4\tau_{\mathrm{start}}=0.4
14.604.634.634.65
24.594.604.624.62
34.594.604.604.62
44.584.594.604.60
54.594.604.604.60

Then, only how the clean-token predictor pθ,sp_{\theta,s} is trained in each diffusion LM is relevant (see definitions in Section 5), because we only use it in our decoding methods:

Table B (Table 6). Training of the clean-sequence predictor pθp_\theta across DiffLM formulations.

ModelCorruptionLength editsInputLossNoise conditioning
USDMSyntheticNoToken sequenceUSDM ELBOτ\tau
Flex-DiffLMSyntheticYesAugmented canvasUSDM ELBO + CEτsub,τlen\tau^{\mathrm{sub}}, \tau^{\mathrm{len}}
ASR-DiffLMASR errorsNoToken sequenceCopy-weighted CENone
Flex ASR-DiffLMASR errorsYesAugmented canvasCopy-weighted CENone

For the one-step correction used in all our ASR experiments, these are the only relevant differences.

During inference for speech recognition, Flex-DiffLM and Flex ASR-DiffLM, as well as USDM and ASR-DiffLM, work almost the same, except that Flex-DiffLM and USDM are conditioned on the noise level.

Then, the relation between our 4 models can be illustrated for ASR as follows:

Table C (Table 7). Relation between our DiffLM formulations for speech recognition.

Corruption / Sequence lengthFixedVariable
SyntheticUSDMFlex-DiffLM
ASR errorsASR-DiffLMFlex ASR-DiffLM

Table D. Inference procedure and experiments per model.

ModelGeneration tasksSpeech recognitionCount headExperiments
USDMIterative sampling, fixed lengthOne-step correctionNoTables 1 and 2, Table E
Flex-DiffLMIterative reverse process, variable lengthOne-step correctionGeneration onlyTables 1 and 2, Table E
ASR-DiffLM--One-step correctionNoTable E
Flex ASR-DiffLM--One-step correctionNoTable E

Note: multistep sampling and the count head are used only where a sequence is generated (code infilling in Table 1 and text generation in Table 2). For ASR, no model uses them.

Table E lets us see how each of our proposed solutions affects the results.

Table E (Table 5, Table 4 in the submission). WER for different decoding methods with fixed- and flexible-length diffusion models, trained with synthetic corruption or ASR-induced errors. CTC without TTS data.

Decoding methodUSDMASR-DiffLMFlex-DiffLM$^*$Flex ASR-DiffLM
Joint decoding (baseline)4.654.564.684.38
Soft-input greedy4.634.504.644.35
DiffLM-Sum4.434.274.323.88
Denoising + rescoring4.224.074.373.96

ASR-specific corruption improves both the fixed-length and the flexible-length model with every decoding method. Combining it with the augmented canvas shows the largest improvement over standard USDM.

Comments on the paper

1 comment

Dear Area Chair and Reviewers,

We wanted to thank you for your work and detailed reviews. We appreciate your comments on the strengths of our work: the importance of variable-length generation with diffusion LMs (athH, dzaC and M5AW), the clear motivation of our approaches (dzaC), the effectiveness of integrating real errors into the forward process for ASR (athH, dzaC) and the clear description of our algorithms and definitions (dzaC).

We ran additional experiments to address the raised concerns and believe that your feedback and these experiments have significantly improved our paper. All changes are marked in red in the revised paper. Below, we summarize the main concerns and how we addressed them:

  • Unclear connection between contributions (athH, dzaC, M5AW).

    • For further clarification, we added Appendix C (Model Comparison), thanks to reviewer athH’s suggestion. There, we compare all our models and explain how they are trained, how they are used for ASR, and what they have in common. We also clarify the connection between our contributions (variable-length modeling and ASR errors) in Sections 1 and 5.

    • But most importantly, we trained Flex ASR-DiffLM with synthetic corruption on top of real ASR errors (results in Table 4, more details on training in Section 4 and Appendix J.10). This means that Flex ASR-DiffLM has the same training and inference properties as standard DiffLMs, but performs better on ASR and just as well on text generation (Table 40 for ASR and Table 38 for text generation, both in Appendix J.10). We believe these experiments address this question, particularly reviewer M5AW’s concern that Flex ASR-DiffLM is only a one-step parallel editor.

  • Length modeling depends on forced insertions (dzaC, M5AW, athH). We reimplemented our reverse process and removed the simplifications from it (more details in Section 3.1 and Appendix I.1). Now, our models not only generate much better text without forced insertions but also match the length distribution of real text more closely than the autoregressive LM does (Figure 6 and Table 11).

  • Long-gap analysis (athH, M5AW).

    • Code infilling. We grouped HumanEval Multi-Line results by gap length (Table V for M5AW and Table O for athH with reference-derived counts). Flex-DiffLM had the best overall score (Table 1) and matched the reference length more closely than DreamOn in every group above 8 tokens.

    • Text generation. We used reviewer M5AW’s suggestion to check how the generated length depends on the prompt (Table 11). We clearly see that Flex-DiffLM follows the same trend as the training data. For 22 of the 25 prompts, Flex-DiffLM matched the training length distribution better than the AR LM.

  • Error Analysis (athH). Appendix J.8 reports the errors each model corrects or introduces. We group results by initially correct and incorrect CTC transcripts (Table 29) and by edit operation (Table 30).

  • Different training budgets and decoding settings (M5AW). We varied the decoding settings for each model and compared WER at similar recognition times (Figure 2). We also compared the effects of longer training on each model and how performance scales with model size (Figure 4).

  • ELBO and cross-entropy training (M5AW, athH). We added a useful discussion of prior work in Section 4 and Appendix J.10 regarding how to convert the predictions of a USDM trained with cross-entropy into the form used by a USDM trained with the ELBO. We tested this transformation and obtained the same speech recognition result (Table 39). Text generation results were also similar (Appendix J.10).

We also wanted to point out additional strengths of our work that could go unnoticed:

  • Consistent comparisons. We ran all experiments in our own setup to keep comparisons consistent within each table. We thank reviewer dzaC for highlighting this.

  • New results

    • We added a lot of new results, analyses and discussion (scaling laws, beam size analysis, etc.) to the revised paper. We hope these encourage the reviewers to raise their scores.

    • We also evaluated Flex-DiffLM on maze panning, which is used in various related works. It is a good task for variable-length generation because the path length is unknown. Flex-DiffLM performed better than USDM and MDLM across all three difficulty settings (Appendix K.1).

  • Flexible-length framework. We find that our forward process with substitutions, insertions, and deletions is a more natural way to train a variable-length diffusion model. Our model also supports different sampling regimes: we can update only the length, apply only substitutions or alternate between the two (Figure 7).

We thank the reviewers again for their valuable feedback. We believe our work is substantially better now, and we hope the reviewers will consider the new experiments and revisions when deciding whether to raise their scores.

Note: For new sections, we marked only the section titles in red.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.