Flow Matching for Generative Modeling

A Continuous Normalizing Flow learns a velocity field that pushes a simple distribution (like a Gaussian) into a complex data distribution by solving an ordinary differential equation. Think of it as a river current: every point in space has an arrow telling it where to flow, and following those arrows from $t{=}0$ to $t{=}1$ transforms noise into data.

The problem with training CNFs before this paper had two faces. First, maximum likelihood training required simulating the entire ODE at each training step to compute the change in log-density — this involves the Jacobian trace of the velocity field, which is computationally brutal for high-dimensional data. Second, while diffusion models found simulation-free shortcuts via score matching, those shortcuts locked the probability path into specific curved trajectories (VP, VE schedules) that needed hundreds of ODE steps to sample accurately.

The field needed a training method that was both simulation-free (like score matching) and path-flexible (unlike score matching). Flow Matching is that method.

The central idea of Flow Matching is disarmingly simple. Instead of training a CNF by simulating it (which is expensive), or by matching scores (which constrains the path), we directly regress the velocity field. We define a target probability path $p_t$ from noise ($t{=}0$) to data ($t{=}1$) and a target vector field $u_t$ that generates this path. Then we train a neural network $v_\theta$ to predict $u_t$ everywhere.

The ideal training loss is the Flow Matching objective — a simple mean squared error between the predicted and target velocity fields:

There is one catch: the marginal velocity field $u_t(x)$ is intractable. Computing it requires integrating over the entire data distribution, which is the very thing we are trying to learn. This is where the paper's theoretical breakthrough comes in.

The insight that makes everything work: instead of regressing the intractable marginal vector field $u_t(x)$, regress the conditional vector field $u_t(x | x_1)$ — the velocity that transports noise to a single data point $x_1$. The Conditional Flow Matching (CFM) loss is:

Why does this work? The paper proves (Theorem 2) that the FM loss and the CFM loss have identical gradients with respect to the network parameters $\theta$. This is the same type of insight behind denoising score matching: individual conditional targets may point in different directions (each one pulls toward a single data point), but their average over all data points equals the true marginal direction.

Think of it like surveying a crowd: asking every person "which way is the exit?" gives noisy individual answers, but averaging all fingers yields the correct direction. Each conditional velocity field is one finger; the marginal field is the average.

Flow Matching works with any probability path, but the paper focuses on Gaussian conditional paths — because they yield closed-form velocity targets that make training trivial. A Gaussian conditional path takes the form:

$p_t(x | x_1) = \mathcal{N}(x \mid \mu_t(x_1),\, \sigma_t(x_1)^2 I)$

where $\mu_t$ and $\sigma_t$ are time-dependent schedules controlling the mean and standard deviation. At $t{=}0$, the path should be pure noise ($\mu_0 = 0$, $\sigma_0 = 1$). At $t{=}1$, it should concentrate on the data point ($\mu_1 = x_1$, $\sigma_1 \approx 0$). Everything in between is a smooth interpolation.

The paper proves (Theorem 3) that for any such Gaussian path, the conditional velocity field has a simple closed form:

With the general framework in place, the authors propose a specific path choice that is dramatically better than diffusion paths: Optimal Transport (OT) displacement interpolation. The OT path uses the simplest possible schedules:

$\mu_t(x_1) = t \cdot x_1, \qquad \sigma_t = 1 - (1 - \sigma_{\min})t$

This means each sample follows a straight line from its noise origin to its data destination. No curves, no spirals, no detours. Plugging these schedules into the Gaussian velocity formula gives the OT conditional velocity:

Why are straight paths better? Three reasons:

Faster sampling. A straight trajectory is easier for numerical ODE solvers to follow — even a basic Euler integrator can produce high-quality samples in $\sim$100 function evaluations, compared to $\sim$250+ for diffusion paths.

Easier learning. When the velocity field is smooth and nearly constant along each trajectory, the neural network has an easier regression target. Diffusion paths create rapidly varying velocity fields near $t{=}0$ and $t{=}1$ that are harder to fit.

Better generalization. Empirically, OT paths consistently produce lower FID scores and better log-likelihoods than diffusion paths under the same training budget.

One of the most striking features of Flow Matching is how simple the training loop becomes. The entire algorithm reduces to:

1. Sample a data point $x_1 \sim q(x_1)$ and noise $x_0 \sim \mathcal{N}(0, I)$

2. Sample a random time $t \sim \mathcal{U}[0, 1]$

3. Interpolate: $x_t = (1 - (1 - \sigma_{\min})t)\, x_0 + t\, x_1$

4. Compute the target velocity: $u_t = x_1 - (1 - \sigma_{\min})\, x_0$

5. Minimize $\| v_\theta(t, x_t) - u_t \|^2$

That is the entire training loop. No score functions, no noise schedule lookups, no ODE simulation. Just sample, interpolate, regress.

Once the velocity field $v_\theta$ is trained, generating samples is pure ODE integration. Start from random noise $x_0 \sim \mathcal{N}(0, I)$ and solve:

$\frac{d}{dt} \phi_t(x) = v_\theta(t, \phi_t(x)), \quad \phi_0(x) = x_0$

Any standard ODE solver works — dopri5 (adaptive Runge-Kutta) for maximum quality, or a simple Euler method for fast generation with fewer steps. Because OT paths produce nearly straight trajectories, even crude solvers give good results.

For computing exact likelihoods, the model augments the ODE with the instantaneous change of variables formula, tracking the log-determinant of the Jacobian as the flow progresses:

The authors trained Flow Matching on CIFAR-10 and ImageNet ($32{\times}32$, $64{\times}64$, $128{\times}128$) using the same U-Net architecture as prior diffusion models. The results are consistent across every setting:

FM with OT paths beats diffusion baselines on both FID and likelihood. On CIFAR-10, FM-OT achieves FID 6.35 vs DDPM's 7.48, and NLL 2.99 vs 3.12 bits per dimension. On ImageNet $64{\times}64$, FM-OT reaches FID 14.45 vs ScoreFlow's 24.95.

FM with diffusion paths is already more stable than standard diffusion training. Even without switching to OT, the FM training objective provides smoother loss curves and faster convergence than DDPM or score matching on the same diffusion paths.

OT paths require far fewer sampling steps. FM-OT achieves comparable quality with 142 NFE (number of function evaluations) on CIFAR-10, versus 274 for DDPM. On ImageNet $64{\times}64$, the gap widens to 138 vs 601.

Flow Matching did not just offer a better training method — it changed how the field thinks about generative modeling. By proving that diffusion is one instance of a broader family of probability paths, it freed researchers to explore new geometries, new interpolation strategies, and new domains far beyond images.

The impact has been sweeping and rapid. Sora (OpenAI, 2024) uses flow matching for video generation. Stable Diffusion 3 (Stability AI, 2024) replaced its diffusion backbone with flow matching. Meta's Voicebox and AudioBox generate speech and sound effects via flow matching. In robotics, π₀ (Physical Intelligence, 2024) uses flow matching to generate continuous robotic actions.

Concurrent work at ICLR 2023 — Rectified Flow (Liu et al.) and Stochastic Interpolants (Albergo & Vanden-Eijnden) — independently arrived at structurally similar frameworks, confirming that this was an idea whose time had come. Together, these papers marked the transition from "diffusion models" to "flow-based generative models" as the dominant paradigm.