Dino Forcing Flow Models: Do not denoise what you can predict

arXiv:2610.11751 · cs.CV · Submitted 2026-10-08 · Read on arXiv

Listen

Transcript

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

Tom: I'm Tom, and with me are Jane, Lu, senior AI researcher at Tsinghua, Meng, lead engineer at a mysterious AI startup and Lalam, the in-house Large Language Model.

Jane: Today's paper: "Dino Forcing Flow Models".

Tom: The gist The proposed DINO Forcing (DF) method simplifies flow matching by predicting pretrained representations directly and using that prediction as self-conditioning,

Jane: First, who's behind it and why it matters.

Title and authors: Tom: So, we're looking at the paper "Dino Forcing Flow Models: Do not denoise what you can predict." Essentially, they are tackling the problem that when you use pretrained representations like DINO in flow matching, you often end up with two separate denoising processes which adds complexity and slow down training.

Jane: Right. They point out that co-denoising the images and the DINO embeddings introduces these paradoxes into the training process, specifically requiring a second denoising trajectory and those careful schedules that you have to design manually, according to page two of this paper #pg2 <ref:2610.11751#pg2>.

Lu: They propose a simpler alternative called DINO Forcing, where instead of denosing the representation alongside the image, you just predict that pretrained representation directly and then use that prediction to condition the model during generation, which is a schedule-free self-conditioning mechanism <ref:2610.11751#pg3>

Meng: So what's the main practical takeaway here is that this approach leads to substantially faster convergence for both latent and pixel space flow matching frameworks, which is something they show on page two of this paper #pg2 <ref:2610.11751#pg2>.

Tom: That speedup is significant when you look at the numbers they report on page two of this paper #pg2 <ref:2610.11751#pg2>. They show results on SiT-XL/two with eight hundred training epochs, and DINO Forcing reaches an FID of two point four seven in only one hundred epochs for latent space <ref:2610.11751#pg2>

Jane: That is a big difference when you compare it to prior methods that might need hundreds of epochs just to get decent results on their own, so the convergence speedup is really something to consider here <ref:2610.11751#pg2>

Lu: They also show improvement in pixel space by more than twenty percent over comparable prior methods, reaching an FID of five point five three at two hundred epochs for the L model <ref:2610.11751#pg2>

Meng: It really shows the benefit across both latent and pixel spaces, which is something they emphasize on page one of this paper #pg1 <ref:2610.11751#pg3>

Tom: The principle they’re pushing here is straightforward: do not denoise what you can predict, meaning the pretrained representation isn't an independent thing that needs its own trajectory; it's a property of the image that the model can infer as it emerges <ref:2610.11751#pg3>

Jane: It’s about inferring that property as the image is evolving, which seems like a much more natural way for a generative model to learn things than forcing it through a rigid schedule <ref:2610.11751#pg3>

Lu: They also show capabilities for inference and inversion with this method. At inference time, they replicate training by rolling out that representation prediction across the denoising steps, providing a continuously updated guide <ref:2610.11751#pg3>

Meng: And they even suggest that the predicted DINOv2 from the representation-conditioning branch can act as a standalone condition to test its utility, or even reconstruct an image given features and a null class <ref:2610.11751#pg3>

Tom: So to wrap up on "Dino Forcing Flow Models: Do not denoise what you can predict," the main point is that predicting the representation directly and using it as self-conditioning removes that second ODE and those representation-specific schedules entirely <ref:2610.11751#pg1>

Jane: This results in substantially faster convergence and better generation quality measured by FID score, with results showing improvements over prior methods in both latent and pixel spaces <ref:2610.11751#pg3>

Lu: It really supports the idea that we can simplify the pipeline by letting the evolving sample guide itself through predictions instead of forcing it into a rigid schedule <ref:2610.11751#pg3>

Meng: For practical engineering, cutting out those extra trajectories means less bookkeeping and fewer dependencies to manage when you're trying to build something scalable <ref:2610.11751#pg3>

Lalam: From a cultural perspective, this suggests that models can become more intuitive learners when they don't have to be explicitly told every small detail about the representation during the entire generation process <ref:2610.11751#pg3>

Jane: And they showed that this works even when you don't have a ton of extra supervision for the alignment part, which is pretty neat since those auxiliary representations are usually tricky to get right <ref:2610.11751#pg3>

Lu: They also showed inference and inversion capabilities with this method. At inference time, they replicate training by rolling out that representation prediction across the denoising steps <ref:2610.11751#pg3>

Tom: So it’s not just about making things faster; it’s about making them fundamentally more robust because of how they learn to predict things on the fly <ref:2610.11751#pg3>

Jane: They give us a much clearer path forward for making flow matching models both efficient and high quality without needing those heavy, second-pass denoising steps <ref:2610.11751#pg3>

Lu: So we're looking at how much simpler we can make the training loop by leaning into what the model can already predict about itself in "Dino Forcing Flow Models: Do not denoise what you can predict" <ref:2610.11751#pg3>

Tom: Definitely. Next up, let’s see how other teams are tackling those multimodal large language models as image classifiers.

The paper's summary: Tom: So we’ve seen how DINO Forcing Flow Models tackle that tricky co-denoising problem by just predicting the representation they need and using that as their own guide during generation. Jane Right, and what this really means is they’re cutting out a whole second denoising process and those extra schedules you have to design yourself.

Lu: They’re saying the pretrained representation isn't some separate thing that needs its own trajectory; it’s just a property of the image that the model can learn as it builds. Meng So, instead of forcing the model through two different denoising paths, they let it use what it already knows about itself to guide itself along a single path.

Tom: That’s the core idea, right? It’s about not denosing something when you can predict what you need to denoise it with. Jane And they show that this works even without needing extra supervision for the alignment part, which is pretty neat since those auxiliary representations are usually tricky to get right.

Lu: They also showed that at inference time, you just keep rolling out those predictions step by step, so you always have a continuously updated guide guiding the process. Meng And they even suggest that the predicted DINOv2 from the representation part can be used on its own to test how useful it is, or even reconstruct an image if you give it some features and a null class.

Tom: It’s not just about making things faster; it’s about making the whole thing more robust because of how they learn to predict these representations on the fly during generation. Jane They give us a much clearer path forward for building flow matching models that are both efficient and high quality without needing those heavy, second-pass denoising steps.

Lu: So we're looking at how much simpler we can make the training loop by leaning into what the model can already predict about itself in DINO Forcing Flow Models: Do not denoise what you can predict.

The paper's improvements: Tom: So we’re looking at how DINO Forcing Flow Models suggest that auxiliary representations don't always need to be generated alongside the main image, but can just be inferred as the image emerges during generation. Jane That means the model doesn't have to worry about generating a whole new set of features separately if it can just predict what it needs right then and there.

Lu: They showed that this conditioning mechanism works well even without needing external supervision for the alignment part, which is really cool because those auxiliary representations are usually tough to get right. Meng That’s a practical win for training because it cuts down on the overhead of adding more complex loss terms and schedules you have to tune.

Tom: And they emphasize that you can get those benefits just from the content of the pretrained representation itself, not necessarily by generating a whole new one. Jane It’s about inferring it as it emerges, which seems like a much more natural way for a generative model to learn things.

Lu: Plus, they’ve shown inference and inversion capabilities too. At inference time, you just keep rolling out those prediction steps across the denoising process so you always have that updated guide. Meng And they even suggest using the predicted DINOv2 from that conditioning branch as a standalone condition to test its utility or even reconstruct an image given some features and a null class.

Tom: So it’s not just about making things faster; it’s about making the whole system more robust because of how they learn to predict these representations on the fly. Jane They give us a much clearer path forward for building flow matching models that are both efficient and high quality without needing those heavy, second-pass denoising steps.

Conclusion: Tom: So we just finished our deep dive into "Dino Forcing Flow Models: Do not denoise what you can predict." Basically, they figured out how to stop wasting time on denoising representations when the model can just use its own predictions as guidance during generation. Jane Right. They’re cutting out that second ODE and those separate schedules entirely, which should make training much smoother for flow matching models across both latent and pixel spaces.

Lu: It really supports the idea that we can simplify the pipeline by letting the evolving sample guide itself through predictions instead of forcing it into a rigid schedule. Meng For engineering purposes, cutting out those extra trajectories means less bookkeeping and fewer dependencies to manage when you try to build something scalable.

Tom: That’s what it is. It’s about the model being smarter by watching what it’s already creating, rather than relying on external guidance for every single step in the process. Jane And they showed that this works even when you don't have a ton of extra supervision for the alignment part, which is pretty neat since those auxiliary representations are usually tricky to get right.

Lu: They also showed inference and inversion capabilities. At inference time, you just replicate training by rolling out that representation prediction across the denoising steps. Meng And they even suggest using the predicted DINOv2 from that representation-conditioning branch as a standalone condition to test its utility or even reconstruct an image given some features and a null class.

Jane: They give us a much clearer path forward for making flow matching models both efficient and high quality without needing those heavy, second-pass denoising steps. Tom So we're looking at how much simpler we can make the training loop by leaning into what the model can already predict about itself in DINO Forcing Flow Models: Do not denoise what you can predict.

Lu: Definitely. Next up, let’s see how other teams are tackling those multimodal large language models as image classifiers.

Arijit Ghosh, Lucas Degeorge, Paul Couairon, Alexei A. Efros, Vicky Kalogeiton, David Picard

ENPC (Ecole Polytechnique) · IP Paris (Institut Pasteur) · UC Berkeley

cs.CV

Submitted: 2026-10-08

Updated: 2026-10-08

Code: https://github.com/arijit-hub/dino_forcing

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

Importance score: 92/100

The gist: The gist The proposed DINO Forcing (DF) method simplifies flow matching by predicting pretrained representations directly and using that prediction as self-conditioning, which substantially improves

Key concepts

Co-denoising: A prior method where the model simultaneously denoises the image and a pretrained representation. This requires managing two separate denoising paths and often involves complex schedules for both, which slows down training.
DINO Forcing (DF): The proposed simpler alternative. Instead of co-denoising, DF predicts the necessary pretrained representation directly in one pass and uses that prediction as a guide or condition for the main flow matching model during generation. It removes the need for a second ODE.
Representation Alignment Loss: A loss function used to train the model to ensure its predicted representation aligns with features from an external pretrained feature space, like DINO's output. This guides the flow matching process toward meaningful, learned visual features.
Do not denoise what you can predict: The core principle derived from the results. It suggests that auxiliary representations should not always be generated through a separate denoising trajectory; instead, if a representation can be inferred or predicted from the evolving sample, using that prediction as conditioning is sufficient for high-quality generation.

Terminology

Alignment — 20× in this paper · explained in 1 episode
Latent Space — 15× in this paper · explained in 7 episodes
Transformer — 13× in this paper · explained in 2 episodes
Flow Matching — 11× in this paper · explained in 8 episodes
Diffusion Model — 8× in this paper · explained in 8 episodes
Ablation — 7× in this paper · explained in 1 episode
Diffusion Models — 6× in this paper · explained in 6 episodes
Dino Forcing — 6× in this paper
Adam — 5× in this paper · explained in 2 episodes
Generative AI — 4× in this paper · explained in 2 episodes
Generative Model — 4× in this paper · explained in 2 episodes
Generative Models — 4× in this paper · explained in 2 episodes
Core — 2× in this paper · explained in 2 episodes
Cosine Similarity — 2× in this paper · explained in 3 episodes
Flow Matching Model — 2× in this paper · explained in 2 episodes
Grounding — 2× in this paper · explained in 3 episodes
Inception Score — 2× in this paper
Alignment Methods — 1× in this paper · explained in 1 episode
Benchmark — 1× in this paper · explained in 2 episodes
Embeddings — 1× in this paper · explained in 2 episodes
Entanglement — 1× in this paper · explained in 3 episodes
Failure Modes — 1× in this paper · explained in 3 episodes
Fidelity — 1× in this paper · explained in 2 episodes
Generative Modeling — 1× in this paper · explained in 3 episodes
Latent Diffusion Model — 1× in this paper · explained in 2 episodes
Latent Diffusion Models — 1× in this paper · explained in 2 episodes
Nash Equilibrium — 1× in this paper · explained in 2 episodes
Transformer Architecture — 1× in this paper · explained in 2 episodes

Summary

The gist The proposed DINO Forcing (DF) method simplifies flow matching by predicting pretrained representations directly and using that prediction as self-conditioning, which substantially improves convergence speed and generation quality in both latent and pixel spaces.

Prior Work Limitations

Recent flow matching methods that leverage pretrained representations typically diffuse and denoise the representation alongside the image, which introduces a second denoising trajectory and requires carefully designed schedules. This co-denoising approach often involves fitting a model to pairs of independent noise samples to a coupled pair that does not require extra noise since the link between the image and its representation is deterministic. Co-denoising methods come with notable performance gains but require an additional ODE trajectory for the pretrained representations (and thereby handcrafted schedules). Specifically, with independent noises ϵI, ϵD and two time variables, the co-denoising model fits vθ xtI, ϕ(x)tD, tI, tD (tI, tD) ∈ [0, 1]2.

The DINO Forcing Mechanism

The core idea of DF is to predict the pretrained representation it needs (i.e. DINO) and condition itself on that prediction throughout generation. This involves a two-pass training procedure:

Pass 1: Representation look-ahead prediction, where a forward pass produces a preliminary representation prediction zˆ (Φ), which serves as a look-ahead estimate of the content in the current denoising trajectory. This pass runs without gradients and provides the conditioning for Pass 2.
Pass 2: Conditioned prediction and alignment, where the look-ahead prediction zˆ (Φ) is used as the conditioning input in a second forward pass to produce both the flow matching velocity prediction vθ(xtzˆ (Φ), t) for image generation and a refined representation prediction zˆ that is supervised against an external pretrained feature space ϕ(x).

Loss Formulation and Fusion

The final training objective is formulated as Ltotal = LFM + λ · LAlign, where LFM =∥vθ − (x − ϵ)∥2 is the standard flow matching velocity loss. The representation alignment loss is defined as cosine similarity between zˆ and target representations ϕ(x), given by LAlign = −zˆ∥zˆ∥,ϕ(x)∥ϕ(x)∥. To fuse image and frozen representations, DF takes merged image and pretrained representation tokens by concatenating them along the channel dimension.

Performance Results

DF achieves strong performance in substantially fewer training epochs for both latent and pixel space flow matching frameworks. In latent space, DF reaches an FID of 2.47 after only 100 epochs, surpassing prior methods trained for substantially longer (Fig. 2, right). At the same training budget, our B model outperforms XL baseline models. In pixel space, DF improves over Latent Forcing (Baade et al., 2026) from 7.20 to 5.53 FID at comparable model size and training budget.

Key Insights and Ablations

The paper suggests that the pretrained representation is not an independent quantity that needs its own generative trajectory; it is a property of the image that the model can progressively infer as the image emerges. The results support the principle: do not denoise what you can predict. Ablation studies show that The conditioning mechanism helps on its own: without any supervision, FID drops from 18.80 to 12.96. Furthermore, the improvement from DF could come from the conditioning mechanism, or from the pretrained representation content of the target. The authors conclude that auxiliary representations need not always be generated alongside the primary modality: when they can be inferred from the evolving sample, prediction may be enough.

Inference and Inversion Capabilities

At inference time, DF replicates training by rolling out the representation prediction across denoising steps, providing a continuously updated guide. Furthermore, the predicted DINOv2 from the representation-conditioning branch can be seen as a standalone condition to test its utility. The method is also capable of acting as a DINOv2 inverter: given the features of an image and a null class, it reconstructs the image itself.

Implementation Details

The fusion strategy involves concatenating patch tokens along the channel dimension to yield a fused representation of shape (B,T,D+D’), which is then projected to the transformer’s hidden dimension via a lightweight linear layer. The implementation details specify that for latent space training on SiT-L/2, the representation branch is attached at the deepest block in all main experiments. The sampling uses a simple Euler ODE solver in 50 steps. The sampling framework involves the model outputting an ODE step and a prediction zˆ used as the self-condition at the next step.

Conclusion

DINO Forcing is a simple alternative to co-denoising pretrained representations in flow-matching models by predicting the representation it needs and immediately reusing it as conditioning. This removes the second ODE and representation-specific denoising schedule, while preserving the benefits of representation guidance. Despite its simplicity, this change substantially improves both convergence and generation quality, surpassing methods trained for substantially longer both in latent and pixel space. The results suggest that auxiliary representations need not always be generated alongside the primary modality: when they can be inferred from the evolving sample, prediction may be enough. The authors thank Nicolas Dufour for all the productive discussions and arguments in the lab, in David’s office, in pubs, and in Slack! The work was supported by a Hi!Paris grant, two Hi!Paris chairs for A.A.Efros and V.Kalogeiton, ANR/France 2030 program (ANR-23-IACL-0005) and ANR project sharp ANR-23-PEIA-0008 in the context of the PEPR IA. The authors used generative AI tools to create or modify scientific figures or images, creation of artifacts, draft parts of a research paper, brainstorming, sourcing/searching for information, edit a research paper to improve readability, identify relevant literature, and format references. The work is available openly in https://github.com/arijit-hub/dino forcing. The paper is available on arXiv as 2610.11751v1 [cs.CV] 8 Oct 2026. The authors are Arijit Ghosh ∗, Lucas Degeorge ∗, Paul Couairon 2 Alexei A. Efros 3, Vicky Kalogeiton †, David Picard †∗ Equal Contribution, † Equal Supervision 1 ENPC, IP Paris. The work is supported by a Hi!Paris grant, two Hi!Paris chairs for A.A.Efros and V.

Improvements for AI systems

Bold header: Improved Training Efficiency for Flow Matching Models

This improvement allows flow matching models to converge substantially faster by adopting a simple principle: do not denoise what you can predict, leading to convergence in 2× fewer epochs on ImageNet compared to prior methods, and achieving better generation quality measured by FID score.

Bold header: Schedule-Free Self-Conditioning Mechanism

The DINO Forcing (DF) method removes the need for a second ODE and any representation-specific denoising schedules by predicting the target representation directly, as stated in the abstract: predict the pretrained representation directly, then condition the model on its own prediction.

Bold header: Enhanced Generation Quality via Self-Conditioning

The system can achieve superior generation quality in pixel space by utilizing self-conditioning, as shown by results where DF improves FID over comparable prior methods by more than 20% and reaches an FID of 5.53 at 200 epochs for the L model.

Bold header: Deterministic Representation Guidance During Sampling

At inference time, the model can leverage the predicted representation throughout generation because the pretrained representation is produced by the generator itself and evolves together with the image, as demonstrated by rolling out predictions across denoising steps to provide a continuously updated, model-generated guide.

Bold header: DINO Inversion Capability

The system can be repurposed as a DINOv2 inverter: given the features of an image and a null class, it reconstructs the image itself, enabling high-fidelity reconstruction by using the predicted features to guide reconstruction processes.

Abstract

Co-denoising pretrained representations such as DINO can substantially improve the training speed and quality of flow matching models, but it introduces a second denoising trajectory and requires carefully designed schedules. We propose a simpler alternative: predict the pretrained representation directly, then condition the model on its own prediction. This removes the need for a second ODE and any representation-specific denoising schedules, while retaining the benefits of representation guidance. Our approach converges substantially faster and achieves better generation quality as measured by FID score. On ImageNet, it outperforms the state of the art in latent space at 2x fewer epochs than prior methods; in pixel space, it improves FID over comparable prior methods by more than 20%. These results support a simple principle: do not denoise what you can predict. Our code is openly available at https://github.com/arijit-hub/dino forcing.