Asymmetric Flow Models

arXiv:2605.12964 · cs.CV · Submitted 2026-05-13 · 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: "Asymmetric Flow Models".

Jane: Here's the gist of the paper. Flow-based generation in high-dimensional pixel spaces is difficult because velocity prediction requires modeling high-dimensional noise, even when data has strong low-rank structure This paper presents Asymmetric Flow Modeling (AsymFlow), a rankasymmetric velocity parameterization that restricts noise prediction to a low-rank subspace while keeping data prediction full-dimensional On ImageNet 256×256, AsymFlow achieves a leading 1.57 FID, outperforming prior DiT/JiT-like pixel diffusion models by a large margin AsymFlow also provides the first-ever route for finetuning pretrained latent flow models into pixel-space models: aligning the low-rank pixel subspace to the latent space gives a seamless initialization that preserves the latent model’s high-level semantics and structure Pruning redundant reasoning tokens The core innovation of AsymFlow is its rankasymmetric velocity parameterization, which treats the data component as full-dimensional while restricting the noise component to a low-rank subspace This asymmetric prediction allows for an analytical recovery of the full-dimensional velocity without altering the network architecture or training/sampling procedures The paper introduces a parameterization family where varying the rank r yields endpoints corresponding to full x0-prediction and full u-prediction This decomposition reveals that AsymFlow behaves like u-prediction in the low-rank subspace and like x0-prediction in the orthogonal complement How the training signal is built The standard velocity target is defined as u = ϵ − x0, where ϵ ∼ N (0, I) AsymFlow changes this to uA:= P ϵ − x0, where P is the orthogonal projector onto the low-rank subspace The full-rank velocity is then recovered analytically using the formula u = P uA + (I − P)xt + uA σt The training objective remains the standard flow matching loss LFM = Et,x0,ϵ h∥u − uˆ∥ 2 i Where the gains come from The gains in performance stem from several key aspects of AsymFlow: 1.

Tom: The asymmetric parameterization reduces the burden of representing high-dimensional noise in internal states without changing the network architecture 2.

Jane: The latent-to-pixel initialization is achieved through a principled latent-to-pixel lift using Procrustes alignment, which enables a seamless initialization that preserves the latent model’s high-level semantics and structure 3.

Tom: Variance reduction is implemented by injecting a term −λ(x L0 − E

x L0xt: ) into the flow matching loss, which reduces sampling variance when∥x0 − x L0∥ is small 4.

Title and authors: Tom: So we're looking at a paper called Asymmetric Flow Models. The title itself hints at what they did. It's about changing how we predict the velocity in flow-based generation, which is usually done in pixel spaces where things get really high-dimensional.

Jane: It sounds technical, but basically they are tackling the problem that makes making high-resolution images or videos difficult with these methods. The core idea is to restrict the noise prediction part of that process to a smaller subspace while keeping the main data prediction part full-dimensional.

Lu: They're using this rankasymmetric velocity parameterization, which is a way of writing down the velocity target that splits it into two parts, one low-rank and one full. This allows them to analytically recover the whole thing without changing the actual network architecture or how they train or sample.

Meng: That sounds promising for deployment because if you don't need to change your whole model setup just to make generation work better, that's a big win for production pipelines.

Lalam: I see what it means in plain terms: they take the complex task of predicting velocity and break it down into two manageable pieces based on the structure of the data itself.

The paper's summary: Tom: Okay, so what’s actually happening in this paper? They are addressing a major hurdle in flow-based generation where modeling high-dimensional noise is just too much for a standard network.

Jane: Exactly, the summary says that velocity prediction needs to model this high-dimensional noise even when the data has some low-rank structure, and AsymFlow restricts that noise prediction to this low-rank subspace.

Lu: They introduce a parameterization family where you can vary a rank 'r', and endpoints correspond to predicting either the full data, xzero or just the velocity u. This decomposition shows they can treat the task differently in those two subspaces.

Meng: So they are essentially creating a way for the network to focus its limited capacity on what matters most—the structured part of the noise—instead of wasting it trying to model every single noisy pixel dimension.

Lalam: I think it means that instead of trying to learn one giant function for everything, you teach the model two specialized functions, one for the structured noise and one for the rest.

The paper's improvements: Tom: The results they’re showing are pretty strong. They achieved a leading one point five seven FID score on ImageNet two hundred fifty-six by using this AsymFlow parameterization, which they claim is better than prior DiT or JiT-like models by a lot <ref:2605.12964#pg1,a leading 1.57 FID>.

Jane: That performance jump, getting that leading score of one point five seven FID, is significant because it’s outperforming existing pixel diffusion models significantly <ref:2605.12964#pg1>. It suggests the method actually helps with generation quality in a way that matters for photorealism.

Lu: One key improvement they highlight is the latent-to-pixel initialization route. They provide the first way to take a pretrained latent flow model and finetune it into a pixel-space model by aligning that low-rank pixel subspace with the original latent space.

Meng: That alignment is crucial because it means you don't have to start training from scratch when you want to adapt an existing, large latent model. It gives you a seamless starting point that keeps all the high-level structure of the model intact while adapting it for pixel generation.

Lalam: And they also added a variance reduction term into the flow matching loss, which helps reduce sampling variance when the actual data xzero is close to what the model predicts, which is a practical thing for making things more stable during generation.

Conclusion: Tom: So, to wrap up on Asymmetric Flow Models: they introduced this rankasymmetric velocity parameterization that lets them handle high-dimensional pixel spaces without changing the network architecture. The main takeaway is the leading one point five seven FID on ImageNet two hundred fifty-six and the new way to finetune latent models into pixel generators <ref:2605.12964#pg1>.

Jane: It opens up a new path for taking those powerful latent flow models that people have already trained and adapting them for direct pixel generation with improved visual fidelity, which is a big step forward.

Lu: From my side, the analytical recovery of the full-dimensional velocity without altering the network structure is a solid mathematical move that shows this isn't just a heuristic trick but has some underlying theoretical foundation.

Meng: For deployment, I see it as making large latent models more accessible for pixel tasks because you can initialize them intelligently instead of having to build a new pixel model from scratch.

Lalam: I’m pretty sure Asymmetric Flow Models is setting a new standard for how we approach high-dimensional generation problems by smartly splitting the prediction task into structured and unstructured components.

Hansheng Chen, Jan Ackermann, Minseo Kim, Gordon Wetzstein, Leonidas Guibas

Stanford University

cs.CV

Submitted: 2026-05-13

Updated: 2026-10-29

Comments: NeurIPS 2026. Code: https://github.com/Lakonik/LakonLab Webpage: https://hanshengchen.com/asymflow

Code: https://github.com/black-forest-labs/flux

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 98/100

The gist: Flow-based generation in high-dimensional pixel spaces is difficult because velocity prediction requires modeling high-dimensional noise…

Key concepts

Rank-asymmetric velocity parameterization
This core innovation treats the data component as full-dimensional while constraining the noise prediction to a low-rank subspace. This asymmetric approach allows for an analytical recovery of the complete velocity without changing the network structure, effectively managing high-dimensional noise efficiently.
Latent-to-pixel initialization
AsymFlow uses a principled latent lift via Procrustes alignment to initialize pixel models from pretrained latent flow models. This aligns the low-rank pixel subspace with the latent space, ensuring that the model starts with high-level semantics and structure preserved.
Variance reduction term
A specific term, -λ(x_L0 − E[x_L0|xt]), is added to the flow matching loss. This term reduces sampling variance when the difference between the true data and the model's prediction is small, improving stability during generation.
Perceptual correction
In low-noise regimes, AsymFlow fades the variance-reduction term and introduces an LPIPS perceptual loss between predicted and true images. This helps correct visual artifacts in subtle details, enhancing the photorealism of the generated output.

Terminology

Summary

Flow-based generation in high-dimensional pixel spaces is difficult because velocity prediction requires modeling high-dimensional noise, even when data has strong low-rank structure This paper presents Asymmetric Flow Modeling (AsymFlow), a rankasymmetric velocity parameterization that restricts noise prediction to a low-rank subspace while keeping data prediction full-dimensional On ImageNet 256×256, AsymFlow achieves a leading 1. p. 057 FID, outperforming prior DiT/JiT-like pixel diffusion models by a large margin AsymFlow also provides the first-ever route for finetuning pretrained latent flow models into pixel-space models: aligning the low-rank pixel subspace to the latent space gives a seamless initialization that preserves the latent model’s high-level semantics and structure

Pruning redundant reasoning tokens

The core innovation of AsymFlow is its rankasymmetric velocity parameterization, which treats the data component as full-dimensional while restricting the noise component to a low-rank subspace This asymmetric prediction allows for an analytical recovery of the full-dimensional velocity without altering the network architecture or training/sampling procedures The paper introduces a parameterization family where varying the rank r yields endpoints corresponding to full x0-prediction and full u-prediction This decomposition reveals that AsymFlow behaves like u-prediction in the low-rank subspace and like x0-prediction in the orthogonal complement

How the training signal is built

The standard velocity target is defined as u = ϵ − x0, where ϵ ∼ N (0, I) AsymFlow changes this to uA:= P ϵ − x0, where P is the orthogonal projector onto the low-rank subspace The full-rank velocity is then recovered analytically using the formula u = P uA + (I − P)xt + uA σt The training objective remains the standard flow matching loss LFM = Et,x0,ϵ h∥u − uˆ∥ 2 i

Where the gains come from

The gains in performance stem from several key aspects of AsymFlow:

  1. The asymmetric parameterization reduces the burden of representing high-dimensional noise in internal states without changing the network architecture

  2. The latent-to-pixel initialization is achieved through a principled latent-to-pixel lift using Procrustes alignment, which enables a seamless initialization that preserves the latent model’s high-level semantics and structure

  3. Variance reduction is implemented by injecting a term −λ(x L0 − E[x L0xt]) into the flow matching loss, which reduces sampling variance when∥x0 − x L0∥ is small

  4. Perceptual correction is introduced in the low-noise regime by fading the variance-reduction term and introducing an LPIPS perceptual loss between xˆ0 and x0

Finishing the process

The paper demonstrates that finetuning a pretrained latent flow model into a pixel-space AsymFlow model establishes a new state of the art for pixel-space text-to-image generation The resulting AsymFLUX.2 klein model, when finetuned from FLUX. p. 02 klein 9B, beats its latent base on HPSv3, DPG-Bench, and GenEval while qualitatively showing substantially improved visual realism This work opens promising directions for high-fidelity image and video generation with finer low-level control The method enhances the photorealism of diffusion models, which significantly benefits creative industries by enabling high-fidelity prototyping and asset creation

Conclusion

We introduced AsymFlow, a rankasymmetric flow velocity parameterization that enables highdimensional pixel-space generation with plain diffusion transformers When trained from scratch, this single parameterization yields a leading 1.57 FID among ImageNet pixel diffusion models It also provides the first path for finetuning pretrained large latent flow models into pixel generators with improved visual fidelity, demonstrating AsymFlow’s scalability and practical impact This opens promising directions for high-fidelity image and video generation with finer low-level control, as well as other high-dimensional data modalities previously out of reach for flow-based modeling

References

[1] Michael Samuel Albergo and Eric Vanden-Eijnden. Building normalizing flows with stochastic interpolants. p. 9 In ICLR, 2023

[3] Shuai Bai, Keqin Chen, Xuejing Liu, Jialin Wang, Wenbin Ge, Sibo Song, Kai Dang, Peng Wang, Shijie Wang, Jun Tang, Humen Zhong, Yuanzhi Zhu, Mingkun Yang, Zhaohai Li, Jianqiang Wan, Pengfei Wang, Wei Ding, Zheren Fu, Yiheng Xu, Jiabo Ye, Xi Zhang, Tianbao Xie, Zesen Cheng, Hang Zhang, Zhibo Yang, Haiyang Xu, and Junyang Lin. Qwen2.5-vl technical report

[4] Fan Bao, Shen Nie, Kaiwen Xue, Yue Cao, Chongxuan Li, Hang Su, and Jun Zhu. All are worth words: A ViT backbone for diffusion models

[5] Black Forest Labs. Flux

[7] Tim Brooks, Bill Peebles, Connor Holmes, Will DePue, Yufei Guo, Li Jing, David Schnurr, Joe Taylor, Troy Luhman, Eric Luhman, Clarence Ng, Ricky Wang, and Aditya Ramesh. Video generation models as world simulators

[12] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A largescale hierarchical image database

[35] Tianhong Li and Kaiming He. Back to basics: Let denoising generative models denoise

[38] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C. Lawrence Zitnick. Microsoft coco: Common objects in context

[51] Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Bjorn Ommer. High-resolution image synthesis with latent diffusion models

[73] Richard Zhang, Phillip Isola, Alexei Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric

[74] Wenliang Zhao, Lujia Bai, Yongming Rao, Jie Zhou, and Jiwen Lu. Unipc: A unified predictorcorrector framework for fast sampling of diffusion models

[75] Boyang Zheng, Nanye Ma, Shengbang Tong, and Saining Xie.

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. Better high-dimensional generation fidelity: AsymFlow achieves a leading 1.57 FID on ImageNet 256x256, outperforming prior DiT/JiT-like models by a large margin, resulting in substantially improved visual realism.

  2. Enhanced finetuning of latent models: The method provides the first-ever route for finetuning pretrained latent flow models into pixel-space models, allowing users to align the low-rank pixel subspace to the latent space for seamless initialization.

  3. Improved text-to-image generation quality: The resulting AsymFLUX.2 klein model sets a new state of the art in pixelspace generation, beating its latent base on HPSv3, DPG-Bench, and GenEval while qualitatively exhibiting substantially improved visual realism.

  4. Faster optimization convergence: The rank-asymmetric target improves optimization efficiency, with AsymFlow (r=8) reaching comparable FID roughly 40% faster than the JiT baseline.

  5. Robustness to auxiliary losses: The AsymFlow parameterization is strongly compatible with REPA, improving FID from 1.76 to 1.57 when combined with variance reduction and perceptual correction losses, suggesting it is much more robust to auxiliary losses.

Sources

Related papers