Velocity Scaling in Flow Matching: The Real Reason It Works

Population time lag — not velocity underestimation — is the true reason velocity scaling works in Flow Matching.
Velocity scaling in Flow Matching has long been explained as compensation for MSE training underestimating velocity magnitudes. A new study (arXiv:2610.10823) overturns this, showing MSE training produces no velocity magnitude gap. The real cause is "population time lag" — cumulative discretization errors in ODE solvers cause sampled states to match earlier training-distribution timesteps, creating temporal misalignment. Velocity scaling and rewinding model time are two equivalent fixes for the same issue. Selecting gain coefficients based on direct measurement of time lag drops FID from 28.0 to 12.2 on ImageNet-256 (NFE=25, no guidance), consistently across architectures and model scales.
Velocity Scaling: A Misunderstood Trick
In the Flow Matching framework for generative models, researchers previously discovered a practically valuable trick: multiplying the learned velocity field $v_\theta$ by a time-varying gain $\gamma(t)$ can significantly improve generation quality. This seemingly simple operation delivers immediate results in practice, yet the underlying mechanism has long been a subject of debate.
A newly published arXiv paper (arXiv:2610.10823v1) offers an explanation that sharply contradicts the prevailing interpretation. Prior work argued that velocity fields trained with mean squared error (MSE) loss systematically underestimate the magnitude of velocities, and that velocity scaling corrects for this error. In other words, the popular view treated velocity scaling as compensation for a training deficiency.

Flow Matching is one of the important paradigms in modern generative modeling. Its core idea is to learn a continuous-time velocity field $v_\theta(x, t)$ that progressively "flows" a noise distribution ($t=0$) along trajectories toward a data distribution ($t=1$). During training, the model is tasked with predicting at each timestep the velocity vector that pushes the current state toward the target, using MSE as the loss function. During inference, starting from noise, a numerical ODE solver (e.g., Euler's method) integrates along the velocity field to generate samples. Compared to diffusion models, Flow Matching has a more direct training objective and "straighter" trajectories, theoretically enabling high-quality results with fewer sampling steps (NFE, Number of Function Evaluations). It is precisely in the pursuit of high-quality few-step sampling that inference-time adjustments like velocity scaling become especially important.
The Real Problem Is Not Underestimated Velocity
The core contribution of this research is to overturn the hypothesis that "MSE training leads to insufficient velocity magnitude." Through analysis, the authors demonstrate that MSE training does not produce any velocity magnitude gap. In other words, the magnitudes of the learned velocities are not systematically too small — the prevailing explanation had identified the wrong root cause.
So why does velocity scaling still work? The study offers a more fundamental explanation: population time lag. Specifically, the state sampled at model time $t$ actually more closely resembles the state distribution from an earlier time point in the training data. The sampling trajectory lags behind on the time axis. This lag is the true cause of degraded generation quality.
Two Equivalent Corrections
Once the problem is attributed to time lag, the solution becomes clear. The study points out that velocity scaling and rewinding the model time are fundamentally two approaches to solving the same problem. The former amplifies velocity to push the sampled state forward more quickly; the latter directly applies a correction in the time dimension. Both paths lead to the same destination — compensating for the bias introduced by population time lag.
This shift in perspective is significant: it reframes what was treated as an "error correction" heuristic into a principled treatment of the temporal alignment problem in sampling dynamics, providing a more reliable theoretical foundation for future method design.
Population time lag can be understood intuitively as follows: during training, a Flow Matching model sees large numbers of $(x_t, v_t)$ paired samples at each timestep $t$ and learns to predict the conditional expected velocity $\mathbb{E}[v | x_t, t]$. However, during inference, the ODE solver (especially Euler's method with large step sizes) introduces discretization errors that cause the actual integration trajectory to deviate from the ideal flow lines. This deviation is cumulative: small errors at each step cause the state $x_t$ to drift into regions that, in the training distribution, only appear at earlier times. In other words, the input the model receives at time $t$ more closely resembles the typical state at time $t - \Delta$ in the training set, where $\Delta$ is the so-called time lag. This phenomenon is not a failure of the model's learning capacity, but a structural misalignment between discrete solving and continuous training — one that becomes especially pronounced when the number of steps (NFE) is small.
Using Time Lag to Guide Gain Selection
Beyond the theoretical explanation, this work also provides an actionable methodology. Since population time lag is the key variable, directly measuring it and using it to select the gain $\gamma(t)$ can systematically improve generation quality — without relying on trial and error.
The experimental results are quite compelling. On ImageNet-256 with NFE=25 and no guidance, this time-lag-informed gain selection approach reduced FID from 28.0 to 12.2 (estimated via linear interpolation between FID measurements at adjacent gain values). Cutting FID by more than half represents a substantial improvement in both the quality and diversity of generated samples.
More importantly, this improvement is consistent across different architectures and model scales. The method's generality indicates that population time lag is indeed a universal phenomenon throughout the Flow Matching sampling process, not an artifact of any particular model.
FID (Fréchet Inception Distance) is the standard metric for evaluating the quality and diversity of generated images. It works by extracting features from both real and generated images at an intermediate layer of a pretrained Inception network, fitting each set of features to a multivariate Gaussian distribution, and then computing the Fréchet distance between the two Gaussians. Lower FID indicates that the generated distribution is closer to the real distribution — i.e., better quality and diversity. A drop from 28.0 to 12.2 represents a significant improvement in both visual fidelity and distributional coverage, especially notable given that no additional training is required — only inference strategy adjustments. It is worth noting that the value in the paper is estimated via linear interpolation between adjacent gain FID measurements, so actual results may vary slightly, but the order-of-magnitude improvement is highly meaningful.
Implications for Generative Model Practice
The value of this research extends beyond improving a specific benchmark number. It reminds practitioners that a technique that works in practice may not be well-understood by its popular explanation. Velocity scaling was once attributed to "correcting insufficient velocity magnitude," when the real cause turned out to be distributional misalignment along the time dimension.
From an engineering standpoint, this means that when tuning Flow Matching models, rather than blindly adjusting gain values, it is more productive to first measure the population time lag during sampling and use it to guide gain selection. This approach — grounded in measurable quantities — is more efficient than empirical grid search and more readily transferable to new models and datasets.
For the research community, this work also demonstrates the importance of revisiting the mechanisms behind established empirical methods. Diagnosing the correct root cause leads to better solutions.
Related articles

DeepCell: One-Click AI Generation of Documents, Spreadsheets, and Slides
DeepCell tops Product Hunt with one-click generation of documents, spreadsheets, and slides, using the .deepcell format for linked updates, designed for System 2 tasks like modeling and sales reviews.

Doneas: 15-Minute Daily Accountability Calls That Keep Indie Developers From Procrastinating
Doneas is a daily accountability tool for indie developers: plan tasks on Monday, join a 15-minute call with five builders each day, and log deliveries on a public progress page. This article analyzes its core mechanics, effectiveness, and potential issues around retention and matching.

Fastlane 2.0: Fully Automated AI Ad Campaigns, From Creative to Optimization
Fastlane 2.0 is an AI ad automation tool: enter your website and it learns your brand, generates video and image ads, and runs and optimizes them on Meta, TikTok, Instagram, and YouTube.