Asymmetric Flow Models

TL;DR

AsymFlow reparameterizes the flow-matching velocity target for pixel-space diffusion: instead of predicting the full-dimensional velocity $u = \epsilon - x_0$ , the network predicts the asymmetric velocity $u_A = P\epsilon - x_0$ , where $P$ is a patch-wise low-rank projector that restricts the noise term to a low-rank subspace while keeping data prediction full-dimensional. The full velocity is recovered analytically, so neither the architecture nor the training/sampling code changes. On ImageNet 256×256 the same JiT-H/16 backbone goes from FID 1.86 (x₀-pred) to 1.57 (rank-8 AsymFlow + REPA); the same parameterization enables the first latent→pixel finetuning recipe, turning FLUX.2 klein 9B into AsymFLUX.2 klein, which beats its latent base on HPSv3 (10.66 vs 9.50), DPG-Bench (86.8 vs 85.2), and GenEval (0.82 vs 0.80). The framing places the win on the parameterization rather than on a new loss, encoder, or architecture.

Key claims

Pure $x_0$ -prediction (JiT) and pure $u = \epsilon - x_0$ prediction are the rank-0 and full-rank special cases of a single family; a small but non-zero noise-prediction rank is optimal — it keeps the numerical stability of velocity prediction in a meaningful subspace while reducing the network’s burden of representing high-dimensional noise. [§ Method, project page]
On ImageNet 256×256 with the JiT-H/16 network (953M, 363 GFLOPs), rank-8 AsymFlow reaches FID 1.76; adding a REPA loss takes it to 1.57, outperforming all listed pixel-diffusion baselines including PixelDiT-XL/16 (1.61), JiT-G/16 (1.82 at 2B params), PixelREPA-H/16 (1.81), PixelGen-XL/16 (1.83), and PixelFlow-XL/4 (1.98). [Table on project page]
AsymFlow provides the first latent→pixel finetuning recipe: aligning the patch-wise low-rank pixel subspace with a pretrained latent space lets a pixel model be initialized directly from a latent flow model, so the initialized denoising trajectory already preserves high-level semantics and finetuning mainly corrects low-level detail. [§ Method, project page]
AsymFLUX.2 klein (finetuned from FLUX.2 klein 9B with a variance-reduced flow-matching objective + perceptual correction) beats its latent base on HPSv3 10.66 vs 9.50, DPG-Bench 86.8 vs 85.2, and GenEval 0.82 vs 0.80, taking the #1 HPSv3 score among the listed comparisons (including Qwen-Image 9.52 and FLUX.1 dev 10.43). [Results table, project page]

Method

Standard velocity-prediction flow matching forces the network to output a full-dimensional target $u = \epsilon - x_0$ , in which the noise term $\epsilon$ is full-dimensional Gaussian. In pixel space this wastes transformer capacity on representing high-dimensional noise that has no low-rank structure to exploit. AsymFlow replaces the prediction target with $u_A = P\epsilon - x_0$ , where $P$ is a fixed patch-wise low-rank projector (rank 8 of the 768-dim patch space for 16×16 patches). The asymmetric velocity decomposes into the low-rank subspace $\text{Im}(P)$ (where the model effectively predicts $u$ ) and its orthogonal complement $\text{Im}(I - P)$ (where it effectively predicts $x_0$ ). At training/sampling time the full-dimensional velocity is reconstructed analytically from the asymmetric prediction, so the architecture, optimizer, and sampler are unchanged.

For latent→pixel finetuning, $P$ is chosen so its low-rank image is the linear lift of the source latent’s per-patch space into pixel space. This means a pretrained latent flow model’s denoising trajectory is, at initialization, a valid asymmetric-velocity prediction in pixel space — high-level structure is inherited and only low-level texture needs finetuning. AsymFLUX.2 klein adds a variance-reduced FM objective plus a perceptual correction term during the latent→pixel finetune.

Results

ImageNet 256×256 (class-conditional, JiT-H/16, 953M / 363 GFLOPs): AsymFlow-H/16 reaches FID 1.57 (with REPA) and 1.76 (without), versus the same-backbone JiT-H/16 at 1.86 and JiT-G/16 at 1.82 with 2B params and 766 GFLOPs. [Table on project page]
Text-to-image (1024×1024): AsymFLUX.2 klein, finetuned from FLUX.2 klein Base 9B, scores HPSv3 10.66 / DPG 86.8 / GenEval 0.82 — #1 on HPSv3 among the listed pixel and latent models (FLUX.1 dev 10.43, Qwen-Image 9.52, FLUX.2 klein Base 9.50). [Table on project page]
Limitation called out by authors: latent-to-pixel finetuning assumes a good patch-level linear lift; it may not work well when the pretrained latent space does not preserve pixel structure. [§ Limitations]
Independent third-party report: roughly 40% faster inference at sharper textures than the latent base, per the project’s quote in coverage; not stated in the abstract.

Why it’s interesting

This is the third distinct lever a Luma-relevant 2026 pixel-diffusion paper has pulled on the same JiT-H/16 backbone. PixelGen: Improving Pixel Diffusion with Perceptual Supervision swapped MSE for perceptual losses and got FID 5.11 in 80 epochs from scratch; Continuous Adversarial Flow Models kept MSE but added a learned discriminator at post-training for FID 3.57 → 1.80 guided; Representation Fréchet Loss for Visual Generation added a closed-form Fréchet-distance criterion at post-training for FID 0.75 at 1-NFE. AsymFlow changes none of those — same network, same loss, same sampler — and instead changes the parameterization of what the network is asked to predict. That places the contribution upstream of the loss-design fork (Pixel-space diffusion §Key claims) and makes it a candidate composition partner with all three. The latent→pixel finetuning recipe also makes it the most direct successor to L2P: Unlocking Latent Potential for Pixel Generation (L2P), which transferred a latent model into pixel space by retraining shallow layers on synthetic outputs; AsymFlow’s analytical low-rank alignment is a different and more principled route to the same goal. The headline FID 1.57 is also the strongest evidence so far that pixel-space diffusion has fully closed the FID gap with class-conditional latent diffusion on ImageNet at parity backbone scale, sharpening the Diffusion training efficiency question of whether parameterization or latent design (cf. Unified Latents (UL): How to train your latents) is the right primary lever.