🤖 machine learning

Velocity Scheduled Flow Matching

This paper introduces Velocity Scheduled Flow Matching (VSFM), a method that relaxes the constant-speed assumption of standard flow matching by allowing variable velocity profiles to reduce sampling costs and improve generation quality (FID) through optimized integration schedules, either by reusing pretrained models at inference or by training from scratch with specific braking profiles.

Original authors: Vitalii Bondar

Published 2026-07-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Vitalii Bondar

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 draw a perfect picture of a cat, but you start with a blurry, static-filled TV screen. In the world of AI image generation, there's a popular method called Flow Matching that acts like a GPS for this transformation. It teaches a neural network to guide the blurry noise step-by-step until it becomes a sharp cat.

For a long time, everyone assumed the GPS should tell the image to move at a constant speed from the blurry start to the sharp finish. It's like driving a car on a straight road where you never hit the gas or the brakes; you just cruise at exactly the same speed the whole time.

But in this paper, Vitalii Bondar asks a simple, playful question: What if we don't have to drive at a constant speed? What if we could speed up when the road is smooth and slow down when the road gets twisty and dangerous?

The Big Idea: Speeding Up and Slowing Down

The author introduces a new method called Velocity Scheduled Flow Matching (VSFM). Instead of forcing the image to move at a steady pace, VSFM lets you choose a "speed profile." You can tell the AI to zoom through the early, messy parts of the journey and then gently brake as it approaches the final, detailed image.

Think of it like a rollercoaster.

The Old Way (Linear): The train moves at a steady, boring speed from the station to the top of the hill and down again.
The New Way (VSFM): The train rockets up the first hill (where the track is simple), then slows down to a crawl right before the sharp, twisting loops at the bottom (where precision matters most).

The "Magic" Trick: No New Training Needed

Here is the coolest part of the discovery. The author found that you don't need to retrain the AI from scratch to use these new speed profiles. If you already have a trained AI that learned to drive at a constant speed, you can simply change the schedule of how you ask it to move.

It's like having a GPS app that already knows the route. You don't need to rebuild the roads or re-teach the app how to drive; you just tell it, "Hey, let's take the fast lane for the first half and slow down for the exit." The paper shows that by simply integrating the AI's instructions on a different, non-uniform time schedule, you can get much better pictures without spending a single extra dollar on computer training time.

The Results: Slowing Down Saves the Day

The author tested this on a dataset of 32x32 pixel images called CIFAR-10. They tried six different "speed profiles" drawn from motion planning (like how robots or animators move things smoothly).

The results were measured using a score called FID (Fréchet Inception Distance), where a lower number means a better, more realistic image.

The "Coasting" Profile: This profile starts fast and gently slows down. When applied to an existing model at inference time (just generating images), it lowered the FID by up to 19.8%. That's a huge jump in quality!
Training from Scratch: When the author trained a new model specifically using this "coasting" speed, it lowered the FID by 17.4% when using only 4 steps (a very fast generation) and by 10.4% at 50 steps.

Why Does This Work? (The "Twisty Road" Analogy)

The paper explains this using the concept of local truncation error. Imagine you are walking along a path, taking big steps.

On a flat, straight path (the early, noisy part of the image), big steps are fine. You won't miss anything.
On a path with sharp, sudden turns (the final part where the image details form), taking big steps makes you stumble and miss the turn.

The "Linear" method (constant speed) forces you to take the same-sized steps everywhere. But the Braking profiles (like "Coasting" or "Uniform Deceleration") tell you to take tiny, careful steps right when the path gets twisty (near the end of the journey).

The paper argues that the "Smooth Landing" profile (which stops very abruptly) actually failed in some cases because it took huge steps at the very beginning, wasting energy, and then tried to cram all the precision into the final few steps. The "Coasting" profile worked best because it found the perfect balance: a gentle start and a smooth, careful finish.

What the Paper Says It's NOT

The author is careful to point out what this method is not.

It is not about changing the math of how the AI learns the image itself (the "coupling" or the "interpolant" stays the same straight line).
It is not about adding more layers to the AI or making the network bigger.
It does not work by magic; it works because of the specific math of how computers calculate steps (the Euler integrator).

How Sure Are We?

The paper is very confident in these numbers because they were measured in real experiments on CIFAR-10.

The 19.8% improvement was observed when applying the method to a public, pre-trained model.
The 17.4% improvement was measured when training a new model from scratch.
The author suggests that this works because of the specific way the computer calculates errors, but they admit that this is a local explanation (looking at one step at a time) and that more work is needed to prove exactly how it behaves globally or on much larger, more complex images (like high-definition photos).

In short, the paper suggests that by simply telling the AI to "slow down as it gets close to the finish line," we can get significantly better images, faster, and without any extra training cost. It's a simple tweak to the schedule that makes the whole journey much smoother.

Technical Summary: Velocity Scheduled Flow Matching (VSFM)

Problem Statement

Flow matching is a continuous-time generative modeling framework where a neural network $v_\theta(x, t)$ is trained to regress the conditional velocity along a linear interpolant between noise $x_0$ and data $x_1$ . Standard flow matching fixes the interpolant to the straight line $x_t = x_0 + t(x_1 - x_0)$ , which implicitly commits the sampler to moving at a constant speed throughout the trajectory.

The sampling cost is determined by the Number of Function Evaluations (NFE) required to integrate the Ordinary Differential Equation (ODE) $dx/dt = v_\theta(x, t)$ . In the low-NFE regime (e.g., 4–50 steps), the trajectory must be traversed efficiently using simple integrators like Euler. The paper posits that the assumption of constant speed is an arbitrary design choice that may not align with the discretization error characteristics of the learned velocity field, particularly near the data manifold where the field varies most rapidly.

Methodology

1. Generalized Training Target

The authors introduce Velocity Scheduled Flow Matching (VSFM), which generalizes the conditional target from a constant displacement to a time-varying form:
$u_t(x | x_0, x_1) = v(t) \cdot (x_1 - x_0)$
where $v: [0, 1] \to \mathbb{R}_{\ge 0}$ is a non-negative velocity profile satisfying $\int_0^1 v(t) dt = 1$ . This constraint ensures the total displacement remains $x_1 - x_0$ , while $v(t)$ controls the rate of traversal.

The training objective regresses the network on the constant-magnitude displacement $(x_1 - x_0)$ at positions $x_t$ determined by the movement profile $\alpha(t) = \int_0^t v(s) ds$ :
$L_{VSFM}(\theta) = \mathbb{E}_{t, x_0, x_1} \left[ \| v_\theta(x_t, t) - (x_1 - x_0) \|^2 \right]$
Crucially, the velocity profile $v(t)$ influences training only through the distribution of positions $x_t$ , not by weighting the loss magnitude. This avoids numerical instability associated with $v(t)^2$ weighting near $t=1$ .

2. Polynomial Velocity Profiles

The study instantiates VSFM with six polynomial profiles derived from motion planning boundary-value problems:

Baseline: Linear ( $v(t)=1$ ).
Braking Sub-family: Monotonically decreasing velocity (Uniform deceleration, Coasting, Smooth landing). These move fast near $t=0$ and decelerate to rest at $t=1$ .
Symmetric Sub-family: Zero velocity at both endpoints (Ease-in-out, Minimum-jerk).

3. Inference-Time Rescheduling (Training-Free)

A key contribution is the ability to apply any admissible profile to a pretrained linear flow-matching model without retraining.

Mechanism: The pretrained model $v_\theta$ is trained on the linear trajectory where $x_\tau = x_0 + \tau(x_1 - x_0)$ . To sample under a new profile $v(t)$ , the authors define an adapted field $\tilde{v}(x, t) = v(t) v_\theta(x, \alpha(t))$ .
Implementation: By changing variables to $\tau = \alpha(t)$ , the ODE becomes $dx/d\tau = v_\theta(x, \tau)$ . The sampler integrates this ODE on a non-uniform grid $\tau_i = \alpha(i/N)$ .
Algorithm: The update step is $x_{i+1} = x_i + v_\theta(x_i, \tau_i) \cdot \Delta \tau_i$ , where $\Delta \tau_i = \alpha((i+1)/N) - \alpha(i/N)$ . This effectively runs the standard Euler sampler on a non-uniform time grid induced by the profile.

4. Discretization Error Analysis

The paper attributes performance gains to the local truncation error of the Euler integrator. The error at step $i$ scales with $(\Delta \tau_i)^2 \cdot \frac{d^2x}{d\tau^2}$ .

The term $\frac{d^2x}{d\tau^2}$ (field variation) is largest near $\tau=1$ (the data manifold) where the velocity field is highly nonlinear.
Braking profiles assign small $\Delta \tau_i$ (small steps) near $t=1$ , thereby suppressing the dominant error source.
Symmetric profiles concentrate large steps at the midpoint, which is less effective for noise-to-data generation where the critical nonlinearity is at the endpoint.

Key Results

Experiments were conducted on CIFAR-10 (32x32) using a class-conditional UNet and a fixed-step Euler integrator.

1. Training from Scratch

Training under the Coasting profile yielded the best results:

4 NFE: FID reduced by 17.4% (35.39 vs. 42.86 baseline).
50 NFE: FID reduced by 10.4% (8.29 vs. 9.25 baseline).
Uniform deceleration also improved over the baseline, while Smooth landing underperformed at low NFE due to excessively large initial steps.
Symmetric profiles showed marginal gains at high NFE but trailed the baseline at low NFE.

2. Inference-Time Adaptation (Training-Free)

Applying the Coasting profile to the publicly available TorchCFM checkpoint (trained linearly) without retraining:

50 NFE: FID reduced by 19.8% (4.38 vs. 5.47 baseline).
32 NFE: FID reduced by 18.6% (5.23 vs. 6.43 baseline).
100 NFE: Uniform deceleration achieved the best FID (3.89, -16.0%).
Smooth landing initially performed worse at 32 NFE (7.43 vs. 6.43) due to large initial steps introducing truncation error, but improved at higher NFE budgets.

Significance and Claims

The paper claims that the velocity profile is a simple, low-cost lever for improving few-step sampling in flow matching. The primary significance lies in two areas:

Training-Free Adaptation: It demonstrates that a pretrained linear flow-matching model can be optimized for specific NFE budgets simply by changing the integration schedule (the velocity profile), requiring no additional training or architectural changes.
Theoretical Insight: It identifies that the constant-speed assumption in standard flow matching is suboptimal for Euler integration. By aligning the step size with the local truncation error (taking smaller steps where the field varies most), significant quality gains are achieved, particularly in the low-NFE regime.

The authors note that these findings are specific to the Euler integrator and the noise-to-data generation task. They suggest that the benefits might differ for image-to-image tasks (where the source is structured) or when using higher-order solvers that cancel leading truncation errors. The study is limited to CIFAR-10 and polynomial profiles, leaving replication on higher-resolution datasets and the exploration of learned or non-polynomial profiles as future work.