Expanding the Quality-Coverage Frontier with Competitive Flow Matching

arXiv:2611.07055 · cs.CV · Submitted 2026-11-04 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: I'm Tom.

Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.

Tom: We're looking at the paper: "Expanding the Quality-Coverage Frontier with Competitive Flow Matching".

Jane: Here's the gist of the paper. Flow matching generators often face a quality-coverage tradeoff where inference-time techniques raise quality at the cost of coverage.

Tom: Our method expands the quality–coverage frontier toward high-coverage, high-quality generation.

Jane: Core Hypothesis and Mechanism The authors hypothesize that the limitation in flow matching stems from a basic property of the objective, where an intermediate noisy image could correspond to many clean images, yet the model can only predict a single velocity, at best averaging over the multiple possibilities.

Tom: To mitigate this issue, they introduce competition among predictions during training by augmenting the predictor with a randomly drawn low-dimensional conditioning code z.

Title and authors: Tom: So, we're looking at the paper called "Expanding the Quality-Coverage Frontier with Competitive Flow Matching." It sounds like they’re tackling that trade-off where making things look really good often means you miss parts of the data distribution.

Jane: Right, Tom. And what this paper does is try to move that frontier toward generating high quality and also covering more modes of the data at once, which is a big deal for real-world applications.

Lu: Basically, they have this idea that flow matching struggles because when you have a noisy image, there could be many different clean images it could come from, but the model can only pick one velocity to predict, so it’s averaging over all those possibilities instead of exploring them.

Meng: So what’s the core fix? How do they stop that averaging behavior and let the model see multiple modes at once?

Lu: They introduce competition during training by adding a random low-dimensional conditioning code, which they call z, to augment the predictor. For every training example, they sample K values of z to create K candidate velocities that all try to explain the target image.

Tom: So instead of just one prediction loss, they use a winner-take-all objective where only the best-matching candidate gets updated during training. That should force different modes into different predictions instead of them getting averaged together into one compromise.

Jane: That competition is key because it lets the model produce distinct velocity predictions for the same noisy state, which they show in Figure two(c) to visualize those different code-conditioned trajectories <ref:2611.07055#pg1>.

Meng: But what about training? How do you actually implement this winner-take-all loss without making training impossibly slow or unstable?

Lu: During training, they select the candidate velocity with the smallest flow matching regression error among those K candidates and backpropagate only through that winning prediction in this winner-take-all objective.

Tom: That sounds like a clever way to inject mode awareness directly into the learning process, which is what I like because it’s grounded in how we actually train these things.

Jane: And once they have this trained model, they give us two ways to use that auxiliary code during inference: either you sample one code and keep it fixed throughout the whole generation trajectory, or you resample the code independently at every single sampling step.

Lu: For guidance, they suggest combining this with an auxiliary conditioning scale, lambda, which acts like a smooth control knob for steering where you are on that quality-coverage curve.

Meng: So if I want better quality but still need to cover a lot of ground, can I use this lambda thing to fine-tune the trade-off?

Tom: Exactly. They show that combining this auxiliary conditioning scale with inference time guidance strength allows the generation quality to improve substantially while keeping the coverage largely preserved, and sometimes both coverage and sample variation even improve when you use stronger guidance.

Title and authors: Jane: That’s a really important point for us at the start, because it means we can use these techniques to push past those previous operating points where models usually get stuck in a single mode.

Lu: They validate this on ImageNet-two hundred fifty-six using two testbeds, SiT and RAEv2 <ref:2611.07055#pg1>. On the SiT testbed, at sixty-seven percent recall, they reduced the FDr6 from nineteen point two two to just five point nine one.

Tom: That’s a significant drop in that metric when you look at the recall level; it shows a real improvement in how well it captures the data distribution.

Jane: And on RAEv2, at seventy percent recall, they saw the FDr6 go from sixteen point eight three down to three point one eight. That’s showing how this method substantially improves quality while largely keeping the coverage where it is.

Meng: From a deployment standpoint, the cost of adding this extra training step for K candidates sounds like a real consideration, though I'm hearing that the gains are substantial at high coverage regimes.

Lu: The analysis of competition shows that as you increase K, the base model systematically shifts toward higher precision and lower FDr6. Plus, they found that the code signatures get stronger when there is competition over held-out classes, reaching roughly ten times chance at K equals five hundred twelve.

Tom: Ten times chance at five hundred twelve is a huge number; that tells us that more competition really strengthens the learned representations for covering those different data modes.

Jane: And they found that using a fixed code sampling policy actually yields a stronger high-coverage frontier compared to resampled-code sampling, which is interesting because it suggests consistency in the code helps maintain broader coverage.

Lu: The paper concludes that this auxiliary conditioning scale lambda gives smooth control over the quality-coverage trade-off, and competition changes how the generator responds to guidance by improving quality while largely preserving coverage at high-coverage operating points.

Tom: So we’re looking at a method called Competitive Flow Matching that uses a winner-take-all objective during training, adds an auxiliary code for competition, and lets you use an inference knob lambda to balance quality and coverage.

Jane: It seems like they’ve found a way to expand that quality-coverage frontier toward high coverage, high quality generation where previous methods couldn't get.

Lu: The main thing is that the competition allows different modes to shape different predictions instead of just being averaged into one compromise, which is a fundamental shift in how the model learns to represent the data distribution.

Meng: It’s cool that they are using these competitive signals from training to achieve this effect on inference time too, because I hate when we have to tweak things constantly during deployment.

Tom: Yeah, and it seems like this method gives us a way to get better results without completely sacrificing the coverage we need for robust generation.

Jane: So while there’s an extra training cost that grows with K, the paper suggests that understanding these auxiliary conditions and using them in more adaptive ways could lead to even further expansion of that quality-coverage frontier in the future.

The paper's summary: Tom: So, we're looking at how this Competitive Flow Matching paper tries to fix that quality versus coverage trade-off they see in these models right now.

Jane: It sounds like they’re trying to push those models toward generating high quality while still being able to cover a lot more of the data possibilities at once.

Tom: Exactly. The core idea is that flow matching generators usually only pick one velocity, which means when you have a noisy image, it's averaging many different clean images together instead of exploring them individually.

Jane: So they introduce competition during training by adding this random low-dimensional code, which they call z. They sample K different versions of this code to create K competing velocities that all try to explain the target image.

Tom: And instead of just picking one prediction, they use a winner take all objective, meaning only the best-matching candidate gets updated during training. That forces different modes into distinct predictions instead of them getting averaged together into one compromise.

Jane: That competition is what lets the model produce multiple velocity predictions for the same noisy state, which they show in their figures to visualize those different code-conditioned trajectories. It’s a fundamental shift in how the model learns to represent the data distribution.

Tom: And once they have this trained model, they give us two ways to use that auxiliary code during inference: you can keep one fixed throughout the whole generation trajectory, or you can resample it independently at every single sampling step.

Jane: They also introduce this auxiliary conditioning scale, lambda. Think of it as a smooth inference-time knob for controlling where you are on that quality versus coverage curve. You can use it by itself or combine it with existing guidance methods to trade precision for recall directly.

Tom: And they show that combining this winner take all model with inference time guidance allows the generation quality to improve substantially while keeping the coverage largely preserved, and sometimes both things actually improve when you use stronger guidance.

Jane: This is important because it means we can push past those previous operating points where models usually get stuck in just one mode. The validation on ImageNet-two hundred fifty-six showed a real reduction in that quality metric at high recall levels, like moving from nineteen point two two down to five point nine one when they hit sixty-seven percent recall.

Tom: They also found that increasing K, the number of competing codes, systematically shifts the base model toward higher precision and lower error metrics. Plus, they found that using a fixed code sampling policy actually yields a stronger high-coverage frontier compared to resampled code sampling.

Jane: So basically, this paper shows how competition during training can fundamentally change how a generative model responds to guidance at inference time, improving quality while largely preserving coverage at those high-coverage operating points. But they also admit the cost is an additional training cost that grows with K.

Tom: That extra training cost is something we need to watch closely when we think about deploying these things on real traffic, but the results on how they manage that trade-off are what really grab my attention right now.

The paper's improvements: Tom: So, we’re talking about what they suggest we do next to use this competitive training approach effectively and where its limitations are.

Jane: They're suggesting that because this competition is so powerful, we can use it to explore different modes in ways that are totally new for generative models.

Tom: Yeah, the idea is that understanding these auxiliary conditions—the things they add like z—and using them in more adaptive ways could expand that quality-coverage frontier even further.

Jane: That means we could start thinking about how to use those learned structures to guide generation in more nuanced ways, maybe tailoring the competition based on what we’re trying to generate.

Tom: I mean, since they found that using a fixed code sampling policy is empirically better for high coverage, it suggests that consistency in the code helps maintain broader coverage during inference. That's a practical thing for deployment.

Jane: And when you look at the guidance part—that scale lambda—it gives us smooth control over the quality versus coverage trade-off, which is a huge improvement over just having one fixed setting. It lets us fine-tune that balance on the fly during inference.

Tom: The main thing is that this competition changes how the generator responds to guidance, improving quality while largely preserving coverage at those high-coverage operating points. That's what we need for robust generation systems.

Jane: So, they’re not just giving us a trick for training; they’re suggesting a new way to think about how we condition and steer these models when it comes to real-world applications. It moves beyond just getting the best static image.

Tom: It really does. And this opens up some interesting paths for future work, like seeing if we can learn even more complex structures from those auxiliary conditions themselves rather than just using them as a fixed input code z.

Jane: Exactly, and that’s where the real curiosity lies—understanding what these auxiliary conditions are actually learning so we can use them in ways that are more adaptive and less manual.

Conclusion: Tom: So we’re wrapping up on "Expanding the Quality-Coverage Frontier with Competitive Flow Matching." Basically, this paper shows that competition during training lets models produce different velocity predictions for the same noisy state instead of just averaging them out.

Jane: It really does move the goal toward generating high quality while keeping coverage broad at those high operating points, especially when you use that inference-time guidance scale lambda.

Tom: I think we're seeing a model that's much more robust to the trade-off, which is what we need for production systems. The numbers on ImageNet-two hundred fifty-six showed a solid drop in the quality metric at sixty-seven percent recall.

Jane: That’s a significant improvement because it means we can trust these models to capture more of the true data distribution without sacrificing visual fidelity. It's not just about making things look better; it's about making them look right across different scenarios.

Tom: And from an engineering standpoint, knowing that a fixed code sampling policy actually helps maintain that high-coverage frontier is useful information for deploying these things to production environments.

Jane: Right, and the paper flags the training cost as something we have to manage because increasing K adds a bit of overhead to the training process.

Lu: I agree, but what’s really interesting is that this competition structure itself might be a new way to learn representations that aren't just optimizing for one single best guess during training. It suggests the model learns about multiple possibilities simultaneously.

Meng: From my side, I worry about the cost of training with K candidates; if we have to run this for very large K values, the time it takes to get a baseline might become too high for what we can actually deploy on our infrastructure.

Lalam: I’m confident in what they found; the result is that competition fundamentally changes how the AI responds to guidance, improving quality while largely preserving coverage at those high-coverage operating points. It's a solid mechanism for pushing past previous limits.

Tom: So, "Expanding the Quality-Coverage Frontier with Competitive Flow Matching" gives us a better tool to handle that tension between making things look perfect and covering all the data there is.

Jane: It does, and it sets up some interesting future work around using those learned auxiliary conditions in more adaptive ways, which could be key for next-generation generative models.

Cornell University · Adobe Research

cs.CV

Submitted: 2026-11-04

Updated: 2026-11-04

Comments: 40 pages, 24 figures. Project page: https://lilydaytoy.github.io/CFM/

Project page: https://lilydaytoy.github.io/CFM

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 86/100

The gist: Flow matching generators often face a quality-coverage tradeoff where inference-time techniques raise quality at the cost of coverage.

Key concepts

Winner-Take-All (WTA) Objective
During training, instead of averaging predictions from multiple candidates, the model only optimizes against the single best prediction among K competing velocity models. This forces different generative modes to specialize and shape distinct outputs for the same noisy input, preventing them from being averaged into a compromise.
Auxiliary Conditioning Code (z)
A randomly drawn low-dimensional code 'z' is injected into the predictor during training. This code conditions the velocity model, allowing it to learn how different latent codes influence the generation process. This auxiliary signal helps capture diverse modes that would otherwise be averaged out.
Quality-Coverage Tradeoff Frontier
This refers to the boundary in generative models where improving output quality (Precision) often comes at the expense of covering a wide range of possible outputs (Recall). The method aims to push this frontier outward, enabling high-quality generation across a wider variety of generated samples.

Terminology

Summary

Flow matching generators often face a quality-coverage tradeoff where inference-time techniques raise quality at the cost of coverage. p. 0

Where the paper says it

ABSTRACT Flow matching (FM) generators often face a quality-coverage tradeoff. Inferencetime techniques such as classifier-free guidance raise quality, but at the cost of coverage.

Our method expands the quality–coverage frontier toward high-coverage, high-quality generation. p. 0
Where the paper says it

Preprint EXPANDING THE QUALITY–COVERAGE FRONTIER WITH COMPETITIVE FLOW MATCHING Wenxuan Peng1,2 Richard Zhang2 Haitian Zheng2 Jaskirat Singh2 Tsai-Shien Chen2 Eli Shechtman2 Bharath Hariharan1 Hadar Averbuch-Elor1 Zongze Wu2 1Cornell University 2Adobe Research Project page: https://lilydaytoy. io/CFM/ 68 70 72 74 76 78 6 8 10 12 14 16 18 20 22 REPA (CFG) CAFM (CFG) Self-Flow (CFG) MixFlow (CFG) iREPA (CFG) DeepFlow (CFG) SiT (CFG) SiT (AG) Ours Recall (%) FDr6 (10K) robin golden retriever balloon Figure 1: Our method expands the quality–coverage frontier toward high-coverage, high-quality generation.

p. 0
Where the paper says it

Preprint EXPANDING THE QUALITY–COVERAGE FRONTIER WITH COMPETITIVE FLOW MATCHING Wenxuan Peng1,2 Richard Zhang2 Haitian Zheng2 Jaskirat Singh2 Tsai-Shien Chen2 Eli Shechtman2 Bharath Hariharan1 Hadar Averbuch-Elor1 Zongze Wu2 1Cornell University 2Adobe Research Project page: https://lilydaytoy. io/CFM/ 68 70 72 74 76 78 6 8 10 12 14 16 18 20 22 REPA (CFG) CAFM (CFG) Self-Flow (CFG) MixFlow (CFG) iREPA (CFG) DeepFlow (CFG) SiT (CFG) SiT (AG) Ours Recall (%) FDr6 (10K) robin golden retriever balloon Figure 1: Our method expands the quality–coverage frontier toward high-coverage, high-quality generation.

Core Hypothesis and Mechanism

The authors hypothesize that the limitation in flow matching stems from a basic property of the objective, where an intermediate noisy image could correspond to many clean images, yet the model can only predict a single velocity, at best averaging over the multiple possibilities. To mitigate this issue, they introduce competition among predictions during training by augmenting the predictor with a randomly drawn low-dimensional conditioning code z. p. 0

Where the paper says it

To mitigate this, we introduce competition among predictions during training. We achieve this by augmenting the predictor with a randomly drawn low-dimensional conditioning code z.

p. 0
Where the paper says it

To mitigate this, we introduce competition among predictions during training. We achieve this by augmenting the predictor with a randomly drawn low-dimensional conditioning code z.

For each training example, they sample K values of z to produce K candidate velocities that compete to explain the target, and apply the loss only to the best-matching candidate in a winner-take-all objective. p. 0
Where the paper says it

For each training example, we sample K values of z to produce K candidate velocities that compete to explain the target, and apply the loss only to the best-matching candidate. This winner-take-all objective allows different modes to shape different predictions, rather than being averaged into a single compromise.

p. 0
Where the paper says it

For each training example, we sample K values of z to produce K candidate velocities that compete to explain the target, and apply the loss only to the best-matching candidate. This winner-take-all objective allows different modes to shape different predictions, rather than being averaged into a single compromise.

This winner-take-all objective allows different modes to shape different predictions rather than being averaged into a single compromise. p. 0
Where the paper says it

For each training example, we sample K values of z to produce K candidate velocities that compete to explain the target, and apply the loss only to the best-matching candidate. This winner-take-all objective allows different modes to shape different predictions, rather than being averaged into a single compromise.

Training and Guidance Strategies

The training involves injecting the low-dimensional Gaussian code z, which is mapped through a function cϕ to condition the predictor vθ. During training, they select the prediction with the smallest FM regression error among K candidates and backpropagate only through that winning prediction in the LWTA objective. p. 3

Where the paper says it

∼ N (0, Id), k ∈ {1, . , K} (4) As shown in Figure 3(b), among the K candidates, we select the one with the smallest FM regression error and backpropagate only through the winning prediction, which minimizes LWTA(θ, ϕ) = Ex0,y,ϵ,t,z1:K min k∈{1,.

Once trained, there are two ways to use the auxiliary code during inference: sampling one code and keeping it fixed throughout the generation trajectory, or independently resampling the code at each sampling step. p. 4
Where the paper says it

2 INFERENCE AND GUIDANCE Once trained, there are multiple possibilities for how the auxiliary code should be used along a sampling trajectory during inference. We can either sample one code and keep it fixed throughout the generation trajectory, or independently resample the code at each sampling step.

Guidance can be applied by adjusting the auxiliary-conditioning scale λ and combining it with inference-time guidance strength γ, where vλγ = vλ + γ (vλ − vG). p. 4
Where the paper says it

Adjusting how strongly this conditioning influences the shared predictor provides an additional inference-time control that complements conventional guidance. We realize this adjustment by multiplying cϕ(z) by a scale λ: vλ = vθ(xt, t, y, λcϕ(z)).

Experimental Validation and Results

The method is validated on ImageNet-256 using two testbeds, SiT and RAEv2. On the SiT testbed, at the 67% Recall point, their method reduces FDr,6 from 19. p. 0

Where the paper says it

We validate on ImageNet-256, using two different testbeds, SiT and RAEv2. Given less than 3% of the original SiT pretraining compute for post-training, at the 67% Recall point, our method reduces FDr,6 from 19.

22 to 5.91. On RAEv2, at the 70% Recall point, it reduces FDr,6 from 16. p. 0
Where the paper says it

We validate on ImageNet-256, using two different testbeds, SiT and RAEv2. Given less than 3% of the original SiT pretraining compute for post-training, at the 67% Recall point, our method reduces FDr,6 from 19.

83 to 3.18. The results show that the method substantially improves quality while largely preserving coverage, extending the quality–coverage frontier toward broad coverage. p. 7
Where the paper says it

91 with the highest Precision and Inception Score among the compared methods. With our method, stronger guidance improves quality while largely preserving coverage, extending the quality–coverage frontier toward broad coverage.

Impact of Competition and Scaling

Analysis of competition shows that as K increases, the base model shifts systematically toward higher Precision and lower FDr,6. Furthermore, the code signatures strengthen with competition over held-out classes, reaching roughly ten times chance at K = 512 (Figure 19). The fixed-code sampling policy is empirically found to yield a stronger high-coverage frontier compared to resampled-code sampling. p. 4

Where the paper says it

We can either sample one code and keep it fixed throughout the generation trajectory, or independently resample the code at each sampling step. We empirically find that the former works better overall, particularly in the broad-coverage regime.

Conclusion and Future Directions

The paper concludes that the auxiliary conditioning scale λ provides smooth control over the quality–coverage trade-off, and competition changes how the generator responds to guidance, improving quality while largely preserving coverage at high-coverage operating points. A practical limitation is the additional training cost which grows with K. p. 9

Where the paper says it

For pretrained models, stronger guidance improves quality at the cost of coverage; for WTA-post-trained models, it improves quality while largely preserving coverage, and at high-coverage operating points it can even increase Recall and within-class diversity. A practical limitation of our method is its additional training cost: while it does not require training models from scratch, selecting the winner involves evaluating K candidate predictions for each training state, and this cost grows with K.

Future work suggests that understanding the structure learned by auxiliary conditions and using them in more adaptive ways could further expand the quality-coverage frontier. p. 9
Where the paper says it

The auxiliary-conditioned predictions thus appear to learn more structure than the objective explicitly asks for. Understanding this structure better, and learning or using auxiliary conditions in more adaptive ways, could further expand the quality–coverage frontier.

Pruning redundant reasoning tokens

Flow matching generators often face a quality-coverage tradeoff where inference-time techniques raise quality at the cost of coverage. Our method expands the quality–coverage frontier toward high-coverage, high-quality generation.

How the training signal is built

The velocity model vθ is trained by squared regression, and may incorporate any extra conditioning signal y. To introduce competition, they sample K candidate velocities that compete to explain the target, and apply the loss only to the best-matching candidate. p. 0

Where the paper says it

We achieve this by augmenting the predictor with a randomly drawn low-dimensional conditioning code z. For each training example, we sample K values of z to produce K candidate velocities that compete to explain the target, and apply the loss only to the best-matching candidate.

The training objective is LWTA(θ, ϕ) = Ex0,y,ϵ,t,z1:K min k∈[1,…,K] ubk − ut squared. p. 3
Where the paper says it

, K} (4) As shown in Figure 3(b), among the K candidates, we select the one with the smallest FM regression error and backpropagate only through the winning prediction, which minimizes LWTA(θ, ϕ) = Ex0,y,ϵ,t,z1:K min k∈{1,. ,K} ∥ubk − ut∥ 2 2 .

Where the gains come from

The gains stem from the winner-take-all assignment which allows different modes to shape different predictions rather than being averaged into a single compromise. This enables the model to produce different velocity predictions for the same noisy state, as shown in Figure 2(c), natively accounting for both modes. p. 1

Where the paper says it

This enables the model to produce different velocity predictions for the same noisy state, as shown in Fig. 2(c), natively accounting for both modes.

The combination of auxiliary conditioning and guidance shows that quality improves substantially while coverage is largely preserved, and in some cases both improve with stronger guidance. p. 2
Where the paper says it

Preprint scale, exposes a smooth quality–coverage curve rather than a single operating point. More importantly, when combined with inference-time guidance, the technique changes how the generator responds to guidance: generation quality improves substantially while coverage is largely preserved, and in some cases coverage and sample variation even both improve with stronger guidance.

The authors hypothesize that the limitation in flow matching stems from a basic property of the objective, where an intermediate noisy image could correspond to many clean images, yet the model can only predict a single velocity, at best averaging over the multiple possibilities. To mitigate this issue, they introduce competition among predictions during training by augmenting the predictor with a randomly drawn low-dimensional conditioning code z. For each training example, they sample K values of z to produce K candidate velocities that compete to explain the target, and apply the loss only to the best-matching candidate in a winner-take-all objective.

The velocity predictor uses three fully connected hidden layers of width 128, each followed by SiLU, and a linear scalar output layer. An auxiliary code z ∼ N (0, I8) passes through a separate 8→128→128 MLP with SiLU after both linear layers. p. 4

Where the paper says it

Its original conditioning inputs, time t and class label y, are mapped to AdaLN modulation parameters that control the scale, shift, and gating of each transformer block. To implement cϕ, we map the Gaussian code z through a small MLP into the same conditioning space and use a parallel AdaLN pathway to produce an auxiliary modulation of the same form.

The training involves minimizing the batch average of mink∈[1,…,K](vθ(xt, t; cϕ(zk))−u) squared. p. 3
Where the paper says it

Given a data sample x0 ∼ pdata, Gaussian noise ϵ ∼ N (0, I), and time t, the training procedure constructs intermediate states xt by interpolating between data and noise points using interpolation schedule αt, σt, creating sample-wise velocity targets ut: xt = αtx0 + σtϵ, ut = ˙αtx0 + ˙σtϵ. (1) The velocity model vθ is trained by squared regression, and may incorporate any extra conditioning signal y, LFM(θ) = Ex0,ϵ,t ∥vθ(xt, t, y) − ut∥ 2 2 .

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Competitive Flow Matching training introduces a winner-take-all objective that allows different modes to shape different predictions rather than being averaged into a single compromise, enabling different targets can thus shape different predictions. This allows the model to produce multiple velocity predictions for the same noisy state, natively accounting for both modes.

  2. The auxiliary conditioning scale lambda provides a smooth inference-time knob for controlling the generator’s operating point, allowing users to trade Precision for Recall by varying lambda in a way that can be used on its own or combined with existing guidance methods.

  3. Combining the WTA post-trained model with inference-time guidance allows it to improve quality while largely preserving coverage, and at high-coverage operating points, it can even increase Recall and within-class diversity.

Abstract

Flow matching (FM) generators often face a quality-coverage tradeoff. Inference-time techniques such as classifier-free guidance raise quality, but at the cost of coverage. We hypothesize this limitation stems from a basic property of the objective: an intermediate noisy image could correspond to many clean images, yet the model can only predict a single velocity, at best averaging over the multiple possibilities. To mitigate this, we introduce competition among predictions during training. We achieve this by augmenting the predictor with a randomly drawn low-dimensional conditioning code z. For each training example, we sample K values of z to produce K candidate velocities that compete to explain the target, and apply the loss only to the best-matching candidate. This winner-take-all objective allows different modes to shape different predictions, rather than being averaged into a single compromise. Furthermore, this term naturally enables a new form of guidance, auxiliary conditioning scaling, which complements traditional guidance methods. Together, these two guidance mechanisms show that our method substantially improves the quality-coverage frontier. We validate on ImageNet-256, using two different testbeds, SiT and RAEv2. Given less than 3% of the original SiT pretraining compute for post-training, at the 67% Recall point, our method reduces FD r,6 from 19.22 to 5.91. On RAEv2, at the 70% Recall point, it reduces FD r,6 from 16.83 to 3.18.

Sources

Related papers