acceptodds
Under review as a conference paper at ICLR 2027

Variable-Length Non-Autoregressive Speech-to-Speech Translation, With and Without a Pretrained Diffusion Language Model

Abstract

Non-autoregressive generative approaches, such as masked diffusion language models and flow matching, have gained considerable traction in recent years: masked diffusion for text generation and code infilling, and flow matching for image generation and text-to-speech synthesis. Yet they remain rarely explored for speech-to-speech translation. A central obstacle is output length. Source and target utterances differ in length, and the relationship varies across language pairs, whereas in their standard form these models fill a canvas of output positions whose size must be fixed before decoding begins. In this work, we present several techniques for handling variable-length output in non-autoregressive speech-to-speech translation, adapting methods originally developed for other domains, such as code infilling and molecule generation. We study two settings: a large pretrained masked diffusion language model, LLaDA, together with variable-length extensions of it, and a much smaller model based on Branching Flows that does not rely on a large language model. All systems are trained and evaluated on the CVSS-C French–English benchmark. The Branching Flows model reaches 24.19 ASR-BLEU, slightly above the discrete diffusion-based model Dub-S2ST (23.35).

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Speech-to-speech translation, Non-autoregressive generation, Variable-length generation, Masked diffusion language models, Flow matching, Branching Flows, LLaDA

Reviews

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

This paper addresses output-length determination in non-autoregressive speech-to-speech translation. The authors argue that masked diffusion and discrete flow models fill a canvas whose size must be fixed before decoding, whereas translation length varies across utterances, and that existing NAR S2ST systems therefore rely on an external length predictor, parallel decoding of candidate lengths, or the source length. Rather than proposing a new method, the paper adapts existing variable-length generation techniques to S2ST within the UnitY two-pass layout, varying only the text decoder while sharing the speech encoder, text-to-unit model and vocoder. Two settings are studied: LLaDA-8B-Base attached to the speech encoder through a projector and LoRA, decoded on a fixed EOS-padded canvas or extended with FlexMDM and DreamOn; and a small DiT decoder trained from scratch with Branching Flows, which starts from a single masked element and reaches its length through splits and deletions. On CVSS-C French–English, the LLaDA-based systems reach 28.10, 29.15 and 29.86 ASR-BLEU. Branching Flows reaches 24.19 with a dev-tuned split multiplier, slightly above Dub-S2ST 23.35 and S2UT 23.54 but below the autoregressive UnitY 25.39.

Critical strengths

Output length is a known difficulty for canvas-based NAR decoders, and the paper compares several recent variable-length mechanisms on S2ST within a shared pipeline: the same speech encoder initialisation, text-to-unit model, vocoder and ASR scorer, with a continued-training control for the extra epoch given to the extensions. Deviations from the original recipes and the decoding behaviour of each system are documented in detail, and applying Branching Flows to translation is new.

Critical weaknesses
  1. In Table 1, the LLaDA row is decoded without an EOS rule and returns 1,060 empty texts, a failure mode for which the LLaDA authors give a remedy. With a similar rule in Table 4 Appendix D, the same model before the extra epoch reaches 34.38 text BLEU, above FlexMDM 32.51 and DreamOn 33.49 after the extra epoch. The extensions, meanwhile, use their own decode-time choices; DreamOn, for instance, exhausts its 64-expansion cap on 53% of test utterances in Appendix B.3, so it is unclear how much of its length decision comes from the expansion mechanism rather than the separately trained count head.

  2. Branching Flows is compared with Dub-S2ST, but the two differ in more than how length is decided. Branching Flows writes intermediate text and uses a text-supervised UnitY encoder, UnitY piece embeddings and an auxiliary AR loss, whereas Dub-S2ST is textless with its length tied to the source. Its margin over Dub-S2ST (24.19 vs. 23.35) also depends on the dev-tuned multiplier (22.94 at m = 1.0). The result therefore says little about the length mechanism itself.

Questions for authors

Please address the concern raised under Critical Weaknesses.

2 comments

We thank the reviewer for the review. The goal of this paper is to study how variable-length methods built for other domains, such as code infilling and molecule generation, can be adapted to speech translation, where the length of the translation must be decided from the speech, and how well they perform, rather than to propose a new architecture.

W1)

  • EOS rule: We agree. With the EOS rule of the LLaDA authors, the continued LLaDA model, trained for the same extra epoch as FlexMDM and DreamOn, reaches 33.83 text BLEU and 30.09 ASR-BLEU, above FlexMDM (32.51 / 29.15) and DreamOn (33.49 / 29.86); in ASR-BLEU the difference is significant against FlexMDM (p = 0.001) but not against DreamOn (p = 0.065), and in UTMOS and COMET it is below both. We added it as the last row of Table 1 and to the conclusion. With the two EOS rules of the submitted Appendix D, the same model reaches 34.84 and 30.89 (Appendix C, Table 3).
  • DreamOn's 64 expansions: In 7,785 of the 7,815 utterances that use all 64 expansions, a canvas recurs: expansions alternate with deletions that give back the same canvas. With a loop stop that blocks expansion once a canvas repeats, the output text changes in only 71 utterances, decoder calls fall from 79.14 to 16.01 per utterance, and ASR-BLEU moves from 29.86 to 29.85 (p = 0.117) (Appendix C). The cap is thus reached by a loop that leaves the output unchanged, not by a search over lengths.
  • Count head vs. expansions: On 500 random development utterances, starting DreamOn 2 tokens shorter or longer than the reference, the final length is on average 0.31 tokens short or 0.58 long, so expansions and deletions correct most of the start error, but text BLEU still falls from 35.28 (reference start) to 33.49 and 32.01: the start length from the count head matters as well as the mechanism.

W2)

  • Baselines: We agree: Branching Flows uses text and the UnitY encoder, so UnitY and DASpeech are the like-for-like baselines. The released DASpeech, decoded with our ASR pipeline, reaches 24.97, 0.78 above Branching Flows (p = 0.001) and 0.42 below UnitY (p = 0.008) (Table 2).
  • Length mechanism: To isolate it, Table 2 now has Stage 1 of Branching Flows, the checkpoint the second stage starts from, with the same encoder, text targets, piece embeddings and auxiliary loss, decoded on a fixed canvas with a length predicted from the speech. It reaches 23.10, 1.09 below Branching Flows with m = 1.2 (p = 0.001) and not significantly different from Dub-S2ST (p = 0.06).
  • Multiplier m: m = 1.2 is chosen among 1.0 to 1.3 on the first 500 development utterances only; with m = 1.0, which keeps the authors' expected split count, canvases are too short (BP 0.913). A second training seed with the same m = 1.2 reaches 23.93, also above Dub-S2ST (p = 0.001) and S2UT (p = 0.011) (Table 2).

Thank you for the candid and thorough response. I really appreciate the additional controls, and the revised tables and conclusion make the comparisons much fairer and the paper clearly stronger. With these corrections, though, the advantage of the variable-length mechanisms over the fixed canvas with an EOS rule and the like-for-like baselines seems less clear to me than in the submission. On balance I'm keeping my rating at 2 for now.

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

This paper investigates variable-length non-autoregressive speech-to-speech translation under two settings: with and without a pretrained diffusion language model (DLM). In the pretrained DLM setting, the authors evaluate LLaDA and two extensions, FlexMDM and DreamOn. LLaDA uses a fixed canvas during decoding, whereas FlexMDM starts with an empty canvas and grows it incrementally, and DreamOn supports both canvas expansion and contraction. In the setting without a pretrained DLM, the authors use Branching Flows with a much smaller decoder.

This paper trains and evaluates the systems on CVSS-C French-English dataset.

Critical strengths

The paper investigates variable-length non-autoregressive speech-to-speech translation under two settings, with and without a pretrained DLM, and compares four systems to examine the applicability of different NAR decoding strategies to this task.

Critical weaknesses
  1. The novelty of this work appears incremental, as it primarily adapts four existing systems to non-autoregressive S2ST rather than introducing a substantially new method.

  2. The experiments are conducted on a single dataset, CVSS-C French-English, which raises the generalizability issue of the systems.

  3. Although Tables 1 and 2 present the main experimental results, the paper would benefit from additional analyses to facilitate a more comprehensive comparison of the systems. For example, how does canvas size affect translation quality? How do the systems compare in terms of decoding speed and computational efficiency?

Questions for authors

Please see the weaknesses.

2 comments

We thank the reviewer for the review. The goal of this paper is to study how variable-length methods built for other domains, such as code infilling and molecule generation, can be adapted to speech translation, where the length of the translation must be decided from the speech, and how well they perform, rather than to propose a new architecture.

W1) This is an adaptation study by design. None of the four original methods takes speech as input: we feed the French speech to LLaDA (on which we also build FlexMDM and DreamOn) through a speech encoder and a projector, and the Branching Flows decoder is trained from scratch and cross-attends to a speech encoder. There is also no source text to count, so each decoder has to decide the length of the English translation from the speech alone.

W2) We follow Dub-S2ST, our main textless baseline, which is "trained and evaluated with French-English (fr-en) subset, due to the abundance of samples compared to other language pairs". Due to limited time and H200 availability, we are now working on CVSS-C Spanish-English; since Dub-S2ST is trained only on French-English, a fair comparison also needs S2UT (in the Dub-S2ST setup), Dub-S2ST and Branching Flows trained on Spanish, which we will add once ready.

W3)

  • Canvas size: In Table 2, quality follows how close the canvas length is to that of the translation. With Branching Flows, m = 1.0 grows canvases that are too short (BP 0.913, 22.94 ASR-BLEU), m = 1.2 longer ones (BP 0.951, 24.19), and target-length rescaling, which steers each canvas toward a length taken from the reference, reaches BP 0.977 and 24.92 (diagnostic). On a fixed canvas, Stage 1 of Branching Flows reaches 23.10 with a length predicted from the speech and 24.62 with the reference length (diagnostic): the same decoder loses 1.52 from the canvas size alone, although its total output length is right (BP 0.998). The systems built on LLaDA use a canvas of 64 slots (at most 64 for FlexMDM and DreamOn), because the longest English target sentence in the training set has 57 LLaDA tokens (99% have at most 22), so no target is cut.
  • DreamOn: We tried a few fixed start lengths, and starting from the length predicted by the count head worked better.
  • Speed and computation: Following UnitY, we time every system from speech to waveform on 500 random development utterances at batch size 1 on one A100, and count FLOPs with PyTorch (Appendix E, Table 5). Branching Flows is the slowest, 1.50 s per utterance (589.3 GFLOPs), against 0.13 s for DASpeech (178.7), 0.44 s for UnitY (73.4), 0.59 s for Dub-S2ST (644.0) and 0.70 s for S2UT (86.4), because its two decoders each run 64 steps. The three systems built on LLaDA take 3.46 to 4.29 s per utterance with an 8B model, so we report them separately (Appendix E).

Thanks the authors for the clarification. The response addressed some of my concerns. However, as there is no option available for 2.5, I maintain my rating of 2.

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

The paper studies how non-autoregressive speech-to-speech translation can decide its output length during decoding. French speech is translated into English text by a non-autoregressive decoder, and a separately trained text-to-unit DiT then renders the text into speech. Two decoder families are compared. The first is LLaDA-8B on a fixed EOS-padded canvas, together with ports of FlexMDM and DreamOn that let the canvas grow or shrink during decoding. The second is a small decoder trained with Branching Flows, which grows the output from a single element through splits and deletions. On CVSS-C Fr→En, the three LLaDA-based systems reach 28.10–29.86 ASR-BLEU. Branching Flows reaches 24.19, which is above Dub-S2ST (23.35) but below the autoregressive UnitY (25.39).

Critical strengths
  1. The reporting is careful and transparent. All deviations from the original FlexMDM, DreamOn and Branching Flows recipes are documented, step-by-step decoding traces are provided, failure modes are disclosed openly, and training budgets within Table 1 are controlled. The results are therefore credible and useful for reproduction.

  2. To my knowledge, this is the first application of Branching Flows to conditional language generation. The length-bucket analysis identifies a concrete limitation: the outputs become increasingly too short as the references grow longer.

Critical weaknesses
  1. The central question is not answered against the obvious alternative: the same decoder on a fixed canvas whose size comes from a predicted length. Moreover, Appendix D shows that the fixed-canvas LLaDA model with a simple EOS rule reaches 34.38 text BLEU with less training, which exceeds both FlexMDM (32.51) and DreamOn (33.49). Table 1 therefore does not support the claim that variable-length canvases help.

  2. The headline gain over Dub-S2ST is confounded by text supervision and an encoder pretrained on CVSS-C Fr→En. The like-for-like autoregressive UnitY is 1.2 ASR-BLEU better. DASpeech, which the paper cites but does not compare against, reports 24.71–25.03 on the same test set with a single decoding pass, while Branching Flows needs 128 sequential calls and its latency is not reported.

  3. The claimed "two-pass layout of UnitY" is in fact a cascade: the text-to-unit stage is trained separately on output text, and the speech length comes from a linear regression. The contribution thus concerns only speech-to-text translation, yet Table 2 reports no text BLEU. The choices of LLaDA and the DiT are not motivated, and Appendix C shows that an off-the-shelf TTS model is 1.07 ASR-BLEU better than the text-to-unit stage used throughout.

  4. Novelty is limited to transferring existing methods, and the authors' decoding modifications are not ablated. Closely related work (Whisper-LLaDA, DIFFA, dLLM-ASR, Edit Flows, dLLM-Var) is not discussed. The empirical evidence also rests on a single seed and a single language pair without significance tests, and the DreamOn port is degenerate on 53% of test utterances.

Questions for authors
  1. How does the stage-1 fixed-canvas decoder perform with a predicted length, and with the oracle length? A predicted-length result close to 24.19 would weaken the case for Branching Flows.
  2. How does the continued LLaDA model in Table 1 perform with the EOS rule of Appendix D?
  3. Can you report text BLEU for all rows of Table 2, results for DASpeech decoded with your ASR pipeline, and wall-clock latency?
2 comments

We thank the reviewer for the careful review. The goal of this paper is to study how variable-length methods built for other domains, such as code infilling and molecule generation, can be adapted to speech translation, where the length of the translation must be decided from the speech, and how well they perform, rather than to propose a new architecture.

W1)

  • Predicted length: Added to Table 2. Stage 1 of Branching Flows on a fixed canvas with a length predicted from the speech reaches 23.10 ASR-BLEU, 1.09 below Branching Flows with m = 1.2 (24.19, p = 0.001) and not significantly different from Dub-S2ST (p = 0.06).
  • LLaDA with an EOS rule: We agree. With the EOS rule of its authors, LLaDA reaches 30.09, above FlexMDM (29.15, p = 0.001) and not significantly different from DreamOn (29.86, p = 0.065); we added it to Table 1 and the conclusion.

W2)

  • Baselines: We agree: Branching Flows uses text and the UnitY encoder, so UnitY and DASpeech are the like-for-like baselines. The released DASpeech, decoded with our ASR pipeline, reaches 24.97 (25.03 in their paper), 0.78 above Branching Flows (p = 0.001) and 0.42 below UnitY (p = 0.008) (Table 2).
  • Latency: Following UnitY, we time each system from speech to waveform on 500 random development utterances at batch size 1 on one A100 (Appendix E). Branching Flows is the slowest, 1.50 s per utterance against 0.13 to 0.70 s for the baselines, as its two decoders each run 64 steps.

W3)

  • Cascade: We agree and revised the introduction: each system is a cascade whose text-to-unit decoder reads only the text, not the states of the first decoder as in UnitY.
  • Text BLEU: Table 2 now reports it: 26.81 for Branching Flows (m = 1.2), 26.60 for the second seed, 28.66 for UnitY.
  • LLaDA: LLaDA pads shorter targets with EOS tokens that are masked and predicted like any other token, as in our fixed-canvas unit pilot, and its authors report a related problem of generations that end too early (Section 1).
  • DiT: We follow Dub-S2ST, which reports that replacing its DiT with a standard Transformer decoder degrades translation quality at every NFE (their Table 6).
  • TTS: Yes, Matcha-TTS reading the text is 1.07 higher (29.17 vs 28.10, Appendix F); we use the same text-to-unit route for every system that writes text.

W4)

  • Novelty: As stated above, this is an adaptation study by design; none of the original methods takes speech as input.
  • Decoding modifications: On the first 500 development utterances, our FlexMDM decoding reaches 28.48 text BLEU, ranking masks by top probability as in the paper 29.19, and the paper's Poisson insertions 26.74; for Branching Flows, replacing the authors' random draws with credits and a confidence update each raised BLEU (Appendix B).
  • Related work: Added to Section 2: Whisper-LLaDA and dLLM-ASR (speech recognition), DIFFA (spoken language understanding), dLLM-Var and Edit Flows (variable-length text generation); none addresses speech translation. Edit Flows would be an interesting candidate, but we did not include it as no official code is available.
  • Seeds and significance: With paired bootstrap tests (Section 4) and a second training seed (Table 2), Branching Flows (m = 1.2) is significantly above Dub-S2ST and S2UT with both seeds (p <= 0.011).
  • Language pair: Due to limited time and H200 availability, we are now working on CVSS-C Spanish-English; since Dub-S2ST is trained only on French-English, a fair comparison also needs S2UT (in the Dub-S2ST setup), Dub-S2ST and Branching Flows trained on Spanish, which we will add once ready.
  • DreamOn: The expansions alternate with deletions that give back the same canvas. A loop stop that blocks expansion once a canvas repeats cuts decoder calls from 79.14 to 16.01 per utterance, while ASR-BLEU moves from 29.86 to 29.85 (p = 0.117) (Appendix C).

Q1) See W1 for the predicted length. With the reference length, as a diagnostic, Stage 1 reaches 24.62, 0.30 below Branching Flows with target-length rescaling (24.92, p = 0.019), which also takes its length from the reference (Table 2).

Q2) With the two EOS rules of the submitted Appendix D (now in Appendix C: no EOS at the first slot, and confidence -inf for a slot whose most probable token is EOS), the continued LLaDA reaches 34.84 text BLEU and 30.89 ASR-BLEU with no empty output, above FlexMDM, DreamOn and the authors' rule (p = 0.001 each) (Appendix C, Table 3).

Q3) All three are now in the paper: text BLEU (see W3), DASpeech and latency (see W2).

Thank you for the thorough rebuttal. The predicted-length control, the significance tests, the second seed and the DreamOn fix address my soundness concerns, and I have raised my Soundness score.

However, the new results also narrow the contribution. For LLaDA, the fixed canvas with a simple EOS rule outperforms both variable-length extensions. Branching Flows remains below DASpeech and UnitY, and it is the slowest system evaluated, slower even than the autoregressive baselines. The abstract should state this rather than headline the comparison with Dub-S2ST. In addition, FlexMDM should be reported with the better-performing top-probability ranking, and the Branching Flows decoding ablation should include numbers.

As the limited significance of the contribution remains my main concern, I keep my overall rating.

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

The paper studies how non-autoregressive speech-to-speech translation can decide its own output length. All systems follow a UnitY-style two-pass layout: a text decoder writes the translation, and a shared text-to-unit stage converts it into speech. The paper compares three text decoders built on LLaDA-8B: fixed-canvas EOS padding, FlexMDM, and DreamOn. It also trains a smaller Branching Flows decoder without a pretrained language model. On CVSS-C French–English, FlexMDM and DreamOn improve over fixed-canvas LLaDA (29.15 and 29.86 vs. 28.10 ASR-BLEU). Branching Flows reaches 24.19, slightly above Dub-S2ST (23.35).

Critical strengths

S1: Output length is a real obstacle for canvas-based non-autoregressive decoders in S2ST. The paper compares several recent variable-length methods on the same task under a shared back end and evaluation protocol, and keeps the number of updates matched across the LLaDA-based variants.

S2: The paper is transparent. The appendices trace decoding step by step and report failure modes, such as LLaDA's 1,060 empty outputs and DreamOn's expand–delete loop. They also include diagnostics like target-length rescaling, which show that length control remains the main limitation of Branching Flows.

Critical weaknesses

W1: The methodological contribution and the scope of the length claim are limited. The three variable-length methods are ported from code infilling and molecule generation, mostly with changes to decoding heuristics, so the paper reads as an adaptation study rather than a new method. The variable-length decision is also made only for the text. The speech length comes from a rounded linear regression on text counts, which then fixes a unit canvas (Section 3.1; Appendix C). The question "whether the decoder can decide the length itself" is therefore answered for text, which makes the system closer to a cascaded S2TT + TTS pipeline than direct S2ST. The paper should state this scope clearly and explain what is specific to speech translation beyond porting the methods.

W2: The comparisons do not establish how large or how reliable the improvements are. (i) The fixed-canvas LLaDA baseline is decoded without the EOS-confidence fix that the LLaDA authors recommend, and it produces 1,060 empty outputs (Table 1; Appendix A). Appendix D shows that a simple EOS rule is available. Without this fix, part of the FlexMDM/DreamOn gain may come from avoiding empty outputs rather than from variable-length modeling. (ii) DreamOn uses all 64 expansions in 53% of test utterances, and these account for 92.2% of its decoder calls (Appendix B.3). This indicates a degenerate expand–delete loop, not working length control. (iii) Table 1 has no reference point outside LLaDA, such as an autoregressive LLM decoder or a cascade with the same back end. (iv) Branching Flows beats Dub-S2ST only after tuning the split multiplier m on the development set. With m = 1.0 it falls below Dub-S2ST, and no significance test against the baselines is reported. (v) Each row is a single training run decoded once, on a single language pair, French–English, whose length ratio is relatively stable. (vi) The paper also substitutes its own decoding rules for several of the original samplers: deterministic credits, margin ranking, custom schedules, and a custom confidence update. This makes it hard to tell whether the results reflect the methods themselves or the extra tuning.

W3: Non-autoregressive decoding is usually motivated by efficiency, but no wall-clock latency or throughput is reported. The paper only gives NFE counts: an 8B model makes 64 to 79+ calls for text, plus another 64 for units, compared with autoregressive UnitY at 25.39 ASR-BLEU. Evaluation also relies only on ASR-BLEU, with no speech quality or naturalness measure and no semantic metric.

Questions for authors

Q1: Beyond adapting DreamOn, FlexMDM, and Branching Flows to S2TT, what is specific to speech translation? Since speech length comes from a fixed linear predictor, can the approach be extended so the unit decoder also decides its own length?

Q2: Do the FlexMDM/DreamOn gains over LLaDA remain when LLaDA uses the EOS-confidence fix recommended by its authors? How does DreamOn behave once the expand–delete loop is fixed? Can you report variation across training seeds, significance tests against Dub-S2ST and S2UT, and results on at least one more language pair with a different length ratio?

Q3: What are the wall-clock latency and throughput of each system compared with autoregressive UnitY and S2UT? Can you report a speech quality metric (e.g., MOS or UTMOS) and a semantic metric (e.g., COMET or BLEURT) alongside ASR-BLEU?

2 comments

We thank the reviewer for the careful review and the detailed questions. The goal of this paper is to study how variable-length methods built for other domains, such as code infilling and molecule generation, can be adapted to speech translation, where the length of the translation must be decided from the speech, and how well they perform, rather than to propose a new architecture. We answer each question below.

Q1) None of the original methods take speech as input. DreamOn was built for code infilling, and Branching Flows for molecules, antibodies, and proteins. Two things are specific to speech translation:

  • Speech input. LLaDA reads only text, so we feed it the French speech through a speech encoder and a projector that stacks every four encoder states into one vector. The Branching Flows decoder is trained from scratch and cross-attends to the speech encoder.
  • Length from speech. There is no source text to count, so each decoder has to decide the length of the English translation from the speech alone.

A unit decoder that decides its own length. This was our first attempt. We trained Branching Flows directly from speech to units. One DiT decoder, with a split head and a deletion head, grew the unit sequence from a single element and chose the number of units itself. Its best decode reached 20.47 ASR-BLEU, below Dub-S2ST at 23.35. The same method on text reaches 24.19.

Why we think text works better. In the Branching Flows paper, the sequences grown from a single element are short:

  • QM9 molecules start from one element and have fewer than 30 atoms (App. F, pp. 28, 31).
  • The generated antibody CDR3 segments have 7 to 40 residues (p. 11).
  • Their long antibody sequences, 110 to 140 residues, do not grow from one element. They start from 110 to 140 elements (p. 34).

Our English text averages 11.7 pieces, within that short range. Units average 101, 8.6 times more, and must still grow from one element because the length is not known. For the same method, that is a much harder task.

Q2)

  • EOS fix: No. With the EOS rule of its authors, LLaDA reaches 30.09 ASR-BLEU, above FlexMDM (29.15) and not significantly different from DreamOn (29.86, p = 0.065), though it stays below both in UTMOS and COMET (Table 1, last row; Appendix C).
  • DreamOn loop: We added a loop stop that blocks expansion once a canvas repeats. Decoder calls fall from 79.14 to 16.01 per utterance, while ASR-BLEU barely moves, from 29.86 to 29.85 (p = 0.117) (Appendix C, Table 3).
  • Seeds, significance, language pair: We report paired bootstrap tests against Dub-S2ST and S2UT (Section 4) and a second training seed for Branching Flows (Table 2); with both seeds, Branching Flows (m = 1.2) is significantly above both baselines (p <= 0.011). Due to limited time, we are now working on CVSS-C Spanish-English; since Dub-S2ST is trained only on French-English, a fair comparison also needs S2UT (in the Dub-S2ST setup), Dub-S2ST and Branching Flows trained on Spanish, which will take time given the current H200 queue, but we will add them once ready.

Q3)

  • Latency: Following UnitY, we time every system from speech to waveform (vocoder included) on 500 random development utterances, at batch size 1 on one A100 (Appendix E, Table 5). Branching Flows is the slowest, at 1.50 s per utterance against 0.13 s for DASpeech, 0.44 s for UnitY, 0.59 s for Dub-S2ST and 0.70 s for S2UT, because its two decoders each run 64 steps.
  • UTMOS / COMET: In COMET, Branching Flows (m = 1.2) scores 0.685, above Dub-S2ST, S2UT and DASpeech and 0.001 below UnitY. In UTMOS, every system is between 4.07 and 4.17, except DASpeech at 3.97 (Appendix D, Table 4).

Thank you for the response and the additional experiments, which address part of my concerns. However, my main concerns remain: with the EOS fix, the gain over fixed-canvas LLaDA no longer holds, the length decision covers only text, and the latency results do not support the efficiency motivation. I will maintain my current score.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.