🤖 machine learning

MeanFlowNFT: Bringing Forward-Process RL to Average-Velocity Generators

The paper introduces MeanFlowNFT, a novel framework that adapts the forward-process Reinforcement Learning method DiffusionNFT to MeanFlow generators by constructing an induced instantaneous-velocity predictor, thereby enabling efficient reward optimization that preserves fast few-step sampling while significantly outperforming existing few-step and even multi-step RL-tuned models in image and video generation.

Original authors: Yushi Huang, Xiangxin Zhou, Jun Zhang, Liefeng Bo, Tianyu Pang

Published 2026-07-17

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yushi Huang, Xiangxin Zhou, Jun Zhang, Liefeng Bo, Tianyu Pang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot artist how to paint a picture of a "sleek car driving down a neon-lit cyberpunk street." In the world of artificial intelligence, the current top artists use a technique called diffusion or flow. Think of this like a sculptor chipping away at a block of marble. They start with a rough, noisy lump of stone (random static) and make tiny, careful adjustments step-by-step to reveal the final statue. The problem is, this process is slow. To get a really good picture, the robot might need to take 50 or even 100 tiny steps, checking its work after every single chip. It's like walking across a room by taking one-inch steps; you'll get there, but it takes forever.

To make this faster, scientists recently invented a new trick called MeanFlow. Instead of taking tiny steps, the robot learns to predict the "average speed" it needs to travel over a whole stretch of time. It's like the robot learning to take giant, confident leaps across the room instead of shuffling. This allows it to create high-quality images in just a few steps. However, there's a catch: these fast robots are hard to teach what humans actually like. Usually, to teach an AI to be more creative or follow rules better, we use a method called Reinforcement Learning (RL). But the best RL methods we have right now were designed for the slow, step-by-step robots, not the fast, leaping ones. Trying to teach the fast robot with the old slow-robot lessons is like trying to teach a cheetah to run by giving it instructions meant for a turtle; the math just doesn't line up.

This is where the new paper, MeanFlowNFT, comes in. The researchers asked a simple but tricky question: Can we teach our fast, leaping robot to be even better using the same efficient RL methods we use for the slow ones, without slowing it down?

The answer is a resounding yes, and here is how they did it. The team realized that even though the robot is trained to predict "average speed" (to take those big leaps), there is a hidden mathematical link between that average speed and the "instantaneous speed" (the speed at any single tiny moment) that the old RL methods need. They built a clever bridge called an induced instantaneous-velocity predictor. Think of it like this: The robot's brain is trained to plan a long road trip (the average speed). The researchers created a special "translator" that looks at that long trip plan and instantly figures out what the car's speedometer would read at any specific second (the instantaneous speed).

They then used this translator to teach the robot using the old, efficient RL method. The robot learns from the feedback (rewards) based on the translator's speedometer readings, but once the lesson is over, the robot goes back to using its original "average speed" brain to generate images. This means the robot gets smarter and more aligned with human preferences without losing its super-speed.

The results are impressive. When they tested this on image generators (like Stable Diffusion 3.5-Medium) and video generators (like Wan2.1), the new MeanFlowNFT model consistently beat the previous best fast models. In fact, on image generation, it outperformed other top-tier models on 6 out of 8 different quality metrics. Even more surprisingly, on video generation, a 4-step MeanFlowNFT model scored 84.33 on a quality test called VBench. This is better than a much slower, 50-step model (LongCat-Video RL) which only scored 82.57.

The paper proves that this method doesn't just work in theory; it works in practice. By using this "translator" trick, they managed to keep the training process fast and efficient (no need to calculate complex probabilities) while still getting the benefits of advanced reinforcement learning. The robot learns to take better leaps, creating more beautiful and accurate images and videos in a fraction of the time it used to take. It's a bit like teaching a cheetah to run faster not by making it walk, but by giving it a better map of the terrain so it knows exactly where to place its giant paws.

Technical Summary: MeanFlowNFT

1. Problem Statement

Diffusion and Flow Matching models have established themselves as the dominant paradigms for high-quality image and video generation. However, their reliance on integrating instantaneous velocities over many sequential steps results in slow inference times. MeanFlow addresses this bottleneck by predicting the average velocity over a time interval, enabling high-quality generation in just a few steps.

Simultaneously, Reinforcement Learning (RL) has become a standard method for aligning generative models with human preferences. While DiffusionNFT introduced an efficient, forward-process RL framework that avoids reverse-process trajectories and likelihood estimation, it optimizes instantaneous velocities. A critical gap exists: applying forward-process RL to MeanFlow is non-trivial because MeanFlow samples using average velocities, creating a mismatch between the optimization target (instantaneous) and the sampling mechanism (average). The central question is whether a pretrained MeanFlow model can be finetuned with efficient forward-process RL to enable superior few-step generation.

2. Methodology: MeanFlowNFT

The paper proposes MeanFlowNFT, the first forward-process RL framework specifically designed for MeanFlow generators. The core innovation lies in bridging the gap between average and instantaneous velocities using the MeanFlow identity.

2.1 Theoretical Foundation

The method relies on the MeanFlow identity, which relates the instantaneous velocity $v(x_t, t)$ to the average velocity $u(x_t, s, t)$ over an interval $[s, t]$ :
$v(x_t, t) = u(x_t, s, t) + (t - s) \frac{d}{dt}u(x_t, s, t)$
where $\frac{d}{dt}u = \partial_t u + (\partial_x u) v$ .

2.2 Induced Instantaneous-Velocity Predictor

Instead of modifying the MeanFlow network to predict instantaneous velocities directly, the authors construct an induced instantaneous-velocity predictor, denoted as $V_\theta$ :
$V_\theta(x_t, s, t) \triangleq u_\theta(x_t, s, t) + (t - s) [\partial_t u_\theta + (\partial_x u_\theta) \hat{v}_\theta]$
Here, $u_\theta$ is the trainable average-velocity network. The term $\hat{v}_\theta$ serves as the direction for the spatial derivative and is approximated by the network's instantaneous velocity at $s=t$ .

2.3 Optimization Objective

The framework applies the DiffusionNFT-style objective to this induced predictor $V_\theta$ . The training process involves:

Implicit Parameterization: Constructing "positive" ( $V^+_\theta$ ) and "negative" ( $V^-_\theta$ ) predictors based on a frozen reference model ( $V^{old}$ ) and the trainable model ( $V_\theta$ ), weighted by a reward $r$ and guidance strength $\beta$ .
Forward-Process Loss: Minimizing a reward-weighted squared error between these induced predictors and the conditional velocity $v_t$ :
$\mathcal{L}_{MFNFT} = \mathbb{E} [ r \|V^+_\theta - v_t\|^2 + (1-r) \|V^-_\theta - v_t\|^2 ]$
Decoupled Sampling: Crucially, while optimization occurs in the instantaneous-velocity space ( $V_\theta$ ), inference remains based on the average velocity $u_\theta$ . This preserves MeanFlow's native few-step sampling efficiency.

2.4 Practical Implementation Details

To ensure training stability and computational efficiency, the authors introduce three key design choices:

Finite-Difference Derivatives: The total derivative term $\frac{d}{dt}u$ is approximated using central finite differences in time $t$ , avoiding expensive Jacobian-vector products (JVPs).
Shared Derivative Term: To prevent training collapse, the trainable and reference predictors share the same estimated derivative term ( $\frac{d}{dt}u^{old}$ ). This eliminates the derivative-difference term that would otherwise destabilize the optimization.
Conditional Velocity Direction: The direction for finite differences uses the forward-process conditional velocity $v_t$ (available at no extra cost) rather than the trainable instantaneous velocity $\hat{v}_\theta$ , which improves stability.

3. Key Contributions

First Forward-Process RL for MeanFlow: MeanFlowNFT is the first framework to apply forward-process RL to MeanFlow generators. It successfully optimizes the underlying average velocity by applying DiffusionNFT-style objectives to an induced instantaneous-velocity predictor.
Theoretical Guarantees: The authors prove that in an idealized setting, the optimal induced predictor recovers the improved policy target of DiffusionNFT. Furthermore, they demonstrate that this policy improvement provably transfers to the average-velocity network, ensuring the MeanFlow policy improves strictly.
Efficiency and Performance: The method maintains the likelihood-free, solver-agnostic nature of DiffusionNFT while preserving the few-step sampling efficiency of MeanFlow.

4. Experimental Results

Experiments were conducted on image generation (Stable Diffusion 3.5-Medium) and video generation (Wan2.1 1.3B).

Image Generation (SD3.5-M): MeanFlowNFT (4 steps) consistently outperforms few-step baselines (DMD, CDM, AnyFlow) and recent few-step RL methods (Rdm, RTDMD). Notably, it achieves superior or comparable results to the 40-step DiffusionNFT baseline on 6 out of 8 metrics (e.g., ImageReward, CLIPScore, OCR) while using 10 $\times$ fewer function evaluations.
Video Generation (Wan2.1): With only 4 sampling steps, MeanFlowNFT achieves the best results among few-step models on 5 of 7 metrics. It surpasses the 50-step LongCat-Video RL baseline on all reported metrics (e.g., VBench score of 84.33 vs. 82.57).
Test-Time Scaling: The model exhibits consistent performance improvements as the number of sampling steps increases (from 2 to 32), maintaining high consistency in layout and content across different step counts, outperforming the AnyFlow baseline in step-consistency.

5. Significance and Claims

The paper claims that MeanFlowNFT successfully bridges the gap between the efficiency of average-velocity generators and the alignment capabilities of forward-process RL. By decoupling optimization (instantaneous space) from sampling (average space), the method enables superior few-step generation without sacrificing the speed benefits of MeanFlow.

The authors emphasize that MeanFlowNFT not only improves upon existing few-step generators but also challenges the notion that multi-step RL-tuned models are necessary for high performance. The results suggest that with the correct theoretical bridging (the MeanFlow identity), few-step models can surpass multi-step RL-tuned diffusion models in both quality and efficiency. The work is presented as a foundational step, with the authors noting that their induced-predictor construction could potentially extend to other flow-map models (e.g., consistency trajectory models) and other forward-process RL objectives, though these remain future work.