Flow Matching: Directly Learning the Velocity Field That Continuously Transports Noise to Data

The goal of a generative model is to sample from a known simple distribution and obtain samples that follow the target data distribution. View this as a "transport": at time t=0, every particle is independently drawn from Gaussian noise; at time t=1, these particles should land exactly on the data distribution. As long as we can describe, for each particle at any time and any position, the direction and speed at which it should move, we can continuously transport the entire blob of noise into the data distribution.

This "direction and speed it should move" is represented by a time-varying velocity field v_t(x), where x is the particle's current position and t is time. Once the velocity field is given, the particle's trajectory is determined by the ordinary differential equation dx/dt = v_t(x): the derivative of position with respect to time equals the velocity of that position at the current time. An initial position x_0 is sampled from the noise distribution; integrating from t=0 to t=1 yields x_1, which is the generated sample. Thus the generation problem is transformed into two subproblems: first construct a suitable velocity field, and then integrate along this velocity field.

The key to directly using a velocity field in place of "step-by-step noise prediction" is that velocity is an instantaneous change in continuous time. At each step, the particle's displacement direction is uniquely determined by the velocity at the current time, so the entire trajectory can be derived from the initial point in one go, without separately deciding at each discrete time step how much noise to add or remove. The learning target changes from "the noise increment at each step" to "the movement velocity at every moment"; both describe the same evolution process, but the velocity field formulation is more direct in continuous time.

The real difficulty is that we cannot directly obtain the desired marginal velocity field. By marginal velocity we mean, after considering all possible pairings, the velocity that a particle at time t and position x should "on average" have. It requires knowing the true correspondence between noise points and data points, and such correspondence does not exist in unsupervised generation. The Flow Matching solution is to construct a set of easily sampled conditional paths: first artificially specify how noise points and data points are paired and how the path goes from one end to the other; at every point on each conditional path we can compute a clear target velocity, and then we use regression to learn the conditional expectation of these conditional velocities. The learned function is an approximation of the marginal velocity field, and it is ultimately used to drive the transport from noise to data.

The simplest and most commonly used conditional path is a straight line connecting a noise point and a data point. Given a noise endpoint x₀ and a data endpoint x₁, the particle's position at time t is defined as x_t = (1−t)·x₀ + t·x₁. At t=0, x_t equals x₀; at t=1, x_t equals x₁, and each intermediate point is linearly interpolated between these two endpoints in proportion, so the entire trajectory is a straight line segment.

Walk through a concrete numerical example. Let the noise point be x₀ = [−1, 2] and the data point be x₁ = [3, 0], and take t = 0.25. The position at this time is (1−0.25)·[−1,2] + 0.25·[3,0], that is 0.75·[−1,2] + 0.25·[3,0]. First dimension: 0.75×(−1) + 0.25×3 = −0.75 + 0.75 = 0; second dimension: 0.75×2 + 0.25×0 = 1.5 + 0 = 1.5, so x_0.25 = [0, 1.5]. This point lies on the line segment from [−1,2] to [3,0], at one quarter of the way along the full trajectory.

The conditional velocity is the derivative of this linear path with respect to time. Differentiating x_t = (1−t)·x₀ + t·x₁ with respect to t gives u_t = x₁ − x₀, which is a constant vector that does not vary over time. Plugging in the numbers, u = [3,0] − [−1,2] = [4, −2]. The meaning of this velocity is that the particle moves at every moment in the direction toward the data endpoint at a constant rate; the first dimension increases by 4 units per second and the second dimension decreases by 2 units per second, so from t=0 to t=1 it exactly covers the entire distance from x₀ to x₁.

Thus, training data pairs become very easy to construct: randomly sample a noise point x₀, randomly sample a data point x₁, and randomly sample a time t, first compute the position x_t using the interpolation formula, then compute the conditional velocity u = x₁ − x₀, so what the network sees is the input (t, x_t) and the target it needs to regress is u. Because each such pairing gives an explicit answer that requires no optimization, the labels of training samples are obtained "free", which is exactly why Flow Matching is more convenient than directly learning the marginal velocity field.

Linear paths also have a consequence that must be faced squarely: paths generated by different endpoint pairs may intersect at the same location. The same (t, x_t) may be crossed by multiple different (x₀, x₁) paths at the same time, and the conditional velocity directions given by those paths are not the same. At this point the network cannot satisfy all targets simultaneously; when minimizing squared error, its optimal output is the weighted average of all conditional velocities passing through that point, that is, the conditional expectation. This averaging behavior is exactly the source of the marginal velocity field to be discussed later.

During training, the network is not required to remember any specific sample pairs; instead, it minimizes a squared-error objective: for randomly sampled (t, x_t) and the corresponding conditional velocity u_t, make the network output v_θ(t, x_t) as close as possible to u_t. Written in expectation form, this is E‖v_θ(t, x_t) − u_t(x_t | x₁ or endpoint)‖², where u_t is the conditional velocity under the given endpoint condition. This loss measures the deviation between the velocity predicted by the network and "the velocity that the point should have on this particular path".

The mathematical nature of the squared loss determines that its optimal solution is not to memorize a particular path, but to take the conditional expectation. For any fixed (t, x_t), minimizing the squared distance to multiple possible target values, the optimal single predicted value is the weighted average of those target values, with weights determined by the probability that each path passes through that point. Therefore, after the network converges, its output is E[u_t | t, x_t], that is, the velocity obtained by averaging all conditional velocities that can pass through here, conditioned on the known time and position. This conditional expectation is exactly equal to the velocity field that makes the marginal probability path satisfy the continuity equation; under the corresponding conditions, the two coincide. In other words, while fitting a large number of conditional velocities, the network implicitly learns the marginal velocity field required to transport the overall distribution.

This training approach has an immediate benefit: it does not require simulating the entire trajectory along the ODE. Each training step only needs to independently sample a time t, sample endpoints, and compute the path point x_t and the conditional velocity u_t to obtain a training sample; the samples do not depend on one another. Because there is no step-by-step solving of the ordinary differential equation and no error propagation over time, this kind of training is called simulation-free. In contrast, the sampling stage must still start from the initial noise and integrate along the learned velocity field to t=1; this step cannot be omitted, and the error introduced by integration discretization will be analyzed in the next section. Training is cheap while sampling requires integration, which is the sharpest dividing line in the computational cost of flow matching.

Using two-dimensional bimodal data to tie together the previous mechanisms, one can intuitively see how the velocity field makes a blob of Gaussian noise "fork" into two clusters. Let the target data consist of two clusters separated from each other, such as a left cluster and a right cluster. The initial distribution is taken as standard Gaussian N(0, I), i.e., particles start from a symmetric blob of noise near the origin; endpoints are randomly drawn from either the left cluster or the right cluster.

Training samples are constructed as follows: first sample a noise point x₀ from N(0, I), then randomly sample one data point x₁ from the two clusters, then randomly sample a time t, and use a straight-line path (or a probability path with noise) to compute the position x_t at that time and the corresponding target velocity. The network learns on such samples: in the early stage, when particles are still concentrated near the origin and the distinction between the two clusters is not yet clear, the velocity field needs to coarsely split them into left and right directions; closer to t=1, the velocity increasingly converges to the internal structure of each cluster, finely assigning particles to the specific shape of a cluster. Thus the learned velocity field appears across the whole space as: near the center it provides a macroscopic left-or-right split, and near each cluster it provides microscopic refinement that converges into the cluster.

At generation time, take a new batch of initial points x₀ and integrate along the learned velocity field from t=0 to t=1. The integrator can use a simple Euler method or a higher-order ODE solver; the choice determines the accuracy for the same number of sampling steps. Plotting each trajectory lets one check whether the field behaves well: whether trajectories show unnecessary crossings, severe curvature, or crowd together in sparse regions. These phenomena respectively point to problems with the conditional path design or velocity field estimation.

During evaluation, two kinds of comparison can be made. First, increase the number of sampling steps and observe whether the distribution metric converges as the number of steps increases; if the result clearly breaks down with few steps, it indicates that the path or velocity field has high curvature and requires more steps or a more accurate solver. Second, compare random pairing with optimal-transport-style pairing: the former connects noise points and data points arbitrarily, while the latter tries to make paired paths shorter and with fewer crossings. Observing trajectory lengths and sampling errors under the two pairings can reveal the effect of path choice on final quality. Always keep in mind that the quality of endpoint samples is jointly determined by two sources: the estimation error of the velocity field itself and the numerical integration error introduced during sampling. The combination of the two determines how far generated samples deviate from the true data distribution.

The cost structures of the training and inference stages are completely different, and this difference is exactly what makes Flow Matching easy to misjudge. During training, we do not simulate any complete trajectory. Each training sample is drawn independently: draw one endpoint x₀ from the noise distribution, draw one endpoint x₁ from the data distribution, randomly draw an intermediate time t, use an interpolation formula to directly compute the path point x_t at that time and the target conditional velocity, and then use a network to regress the target conditional velocity. What other times look like along the entire path does not need to be known during training, nor do we need to solve differential equations step by step. This is the source of "training is fast": samples are mutually independent, labels can be computed in closed form, and there is no error accumulation along the time direction.

At inference, however, the trajectory must actually be traversed. Given a newly sampled noise point x₀, the network gives the current velocity at each moment, and we need to integrate step by step from t=0 to t=1 to obtain the final sample x₁. This step cannot be completed with a single forward pass, because it is essentially solving an initial value problem for an ordinary differential equation: the velocity changes with the position at each step, and the position in turn determines the velocity for the next step. Therefore, sampling requires multi-step ODE integration; the more steps and the more accurate the solver, the closer the result is to the true trajectory.

The contrast between the two processes can be summarized in one figure: in the training stage, the target velocity is regressed only at randomly sampled path points, with arrows pointing from the endpoints and intermediate points to the network; in the inference stage, starting from new noise, multi-step integration is performed along the velocity field given by the network, with arrows strung together along the time direction into a complete trajectory. The key point of the figure is a contrast—Flow Matching eliminates trajectory simulation during training, not ODE integration during inference. Training can be completed cheaply by processing one independent sample per step, but sampling must incur a computational cost related to integration accuracy; the two are not symmetric.

What all probability paths have in common is that the t=0 end lies at the noise distribution and the t=1 end lies at the data distribution, so no matter which path is chosen, the endpoint distribution is the same; however, different paths can differ greatly in training difficulty and sampling efficiency, and this difference comes from the geometric and statistical properties of the path itself.

Diffusion-type paths are a process of "gradually adding noise and then gradually removing it." Their theory is the most mature and has direct connections with stochastic processes and stochastic differential equations, so there are many ready-made tools available for analysis. Their cost is that the paths tend to be quite tortuous, particles are spread quite diffusely by noise in the early stage, and accurate reconstruction during sampling requires more ODE steps.

Optimal transport-style displacement interpolation, by contrast, tends toward straighter, shorter paths. It moves noise points to data points as "directly" as possible, so paths bend less and therefore may be integrated using fewer ODE steps. Intuitively, the straighter the path, the less likely low-order integrators such as Euler are to deviate from the true trajectory, and the better the quality of few-step sampling.

But "straighter" does not automatically mean "easier to learn." How the endpoints are paired changes how much the conditional paths cross, and also changes the variance of the target conditional velocity: when the pairing is disordered, velocity targets with opposite directions appear near the same spatial location, forcing the network to learn a blurred average velocity; when the pairing is regular, the targets are more consistent and the regression is easier. It can be seen that path choice simultaneously affects two things—the clarity of the target velocity during training, and the curvature of the trajectory during sampling. In addition, the complex structure of real high-dimensional data distributions, the intervention of conditional guidance, and the geometry of latent space all feed back into the actual effect of the path, so the intuition that "the straightest path is optimal" does not always hold. Therefore, when evaluating a path, one cannot look only at trajectory length but must jointly judge trajectory length, curvature, velocity regression error, and few-step sampling quality.

Sampling accuracy is directly determined by the integration step size, and using an exactly solvable example shows most clearly how errors accumulate. Consider the velocity field v(x) = −x, initial position x₀ = 1, integrating from t=0 to t=1. The solution to this ODE is x(t) = e^(−t), so the true value at t=1 is e^(−1) ≈ 0.368.

Use the Euler method with step size h = 0.5 to take two steps. The Euler update formula is x_{k+1} = x_k + h·v(x_k), where v(x_k) = −x_k, so x_{k+1} = x_k − h·x_k. First step: x₁ = 1 − 0.5×1 = 0.5. Second step: x₂ = 0.5 − 0.5×0.5 = 0.25. The final result is 0.25, while the true value is about 0.368, so the relative error is quite noticeable.

The root cause of the error is that each Euler step assumes that the velocity remains constant during that step, but in reality the velocity changes continuously with x; the farther from the starting point, the less valid this assumption becomes, and the deviation accumulates step by step. Reducing the step size can reduce the error in each step, or using a higher-order solver (such as Runge–Kutta-type methods) can achieve higher accuracy with the same number of steps, but both incur more computation: halving the step size means the number of function evaluations doubles, and higher-order solvers also need to call the network multiple times per step.

In actual flow matching, the velocity field varies in complex ways with time and position and is much harder to integrate than this one-dimensional example, so sampling quality cannot be described only by "sampling steps". For the same number of steps, different solvers have different numbers of function evaluations (NFE, number of function evaluations), and it is NFE that really determines the trade-off between computational cost and accuracy. The correct approach is to plot an NFE—quality curve: the horizontal axis is the number of function evaluations, the vertical axis is generation quality, and compare where different solvers and step-count choices lie on the curve, rather than reporting the number of steps in isolation. This curve makes the relationship between integration error and computational cost explicit and is the standard way to evaluate sampling efficiency.

Conditional generation enables Flow Matching not only to transport distributions, but also to transport them in a targeted way according to specified conditions. The conditional flow v(x, t, c) learns how particles should be transported from noise to data regions that match the condition c (for example, a text description or class label). During training, the condition embedding is used as one of the network inputs, and the conditional velocity field learns "where to go under the given condition".

Classifier-free guidance is a technique that enhances conditional alignment. It simultaneously trains a conditional model and an unconditional model; at sampling time the two are linearly combined so that the predicted velocity shifts toward the conditional direction, thereby amplifying the influence of the condition on generation. From the perspective of the velocity field, this is equivalent to artificially changing the original velocity direction: the average velocity of the unconditional part is "pulled" by the conditional part toward regions that better match the prompt.

This change comes at a cost. When the guidance strength is too large, particles are persistently pushed toward narrow regions with the highest conditional probability; although the generated content matches the prompt better, diversity decreases because sampling only covers one peak of the conditional distribution and ignores the rest. At the same time, overly strong guidance makes the velocity field sharp in high-condition regions, trajectories stiffer, velocity norms larger, numerical integration more difficult, and artifacts likely to appear. Therefore prompt matching cannot be treated as the only evaluation objective. Condition adherence, coverage of the generated distribution, the magnitude of the velocity field norm, and stability under different numbers of sampling steps should be measured separately in order to comprehensively judge whether the guidance strength is appropriate. An appropriate strength balances alignment, diversity, and integrability rather than increasing without limit.

Using ODE sampling does not mean it is Flow Matching; several related methods share the framework of "continuous transport" but differ in concept, core mechanism, and training objective. To distinguish them, look at three dimensions: how the path is defined, what the training objective is, and how the sampler is chosen, rather than judging solely by the name "flow".

The core of continuous normalizing flow is the invertible ODE transformation and the density change it induces. It directly concerns how the distribution density evolves over time, with the rate of density change given by the divergence of the velocity field. Training usually requires computing the divergence or explicitly maximizing likelihood, so it is closely tied to likelihood estimation and density evaluation. It emphasizes the precise invertible transformation of probability density.

The core of Flow Matching is regressing the velocity on a pre-specified probability path. It first constructs an easy-to-sample conditional path (e.g., a straight-line path), computes the target velocity at path points using a closed-form formula, and then has the network regress those target velocities, forming a simulation-free training objective. It does not explicitly compute divergence or likelihood; instead, it directly fits the velocity field, and finally uses that velocity field to drive ODE sampling.

Diffusion models and score models are rooted in stochastic noise-adding processes and the score field. They first define forward stochastic noise addition, then learn the score function needed for backward denoising. Sampling can proceed either through a stochastic differential equation (SDE) path or through the equivalent probability flow ODE, so "using ODE sampling" is likewise common in diffusion models, but this does not turn them into Flow Matching.

Rectified Flow is a more specific design within the Flow Matching family. It deliberately favors straight-line paths and repeatedly straightens paths through "reflow" to reduce sampling curvature and the number of steps required; it is a concrete implementation under the Flow Matching framework.

These methods overlap with one another: the probability flow ODE of diffusion models can correspond to a certain kind of Flow Matching, and continuous normalizing flows can also be formally connected to Flow Matching under specific objectives. But they emphasize different aspects of the problem—some focus on density and likelihood, some on score and denoising, and some on velocity and path. When comparing, one should specify the concrete settings of the path, objective, and sampler in order to judge which class a method actually belongs to, rather than being misled by the name.

When two conditional paths with opposite directions pass through the same position, the network faces a fundamental contradiction: the same (t, x) point simultaneously belongs to two paths, and the target velocities given by these two paths point in opposite directions. The optimal solution under squared loss is to average all conditional velocities passing through that point. If the two velocities are equal in magnitude and opposite in direction, the average is zero; if they point to different data modes, the average direction falls between the two modes, pointing to an intermediate region with no actual data. The network cannot simultaneously satisfy both targets at this point and can only give a compromise.

This averaging behavior creates field curvature and decision ambiguity where multiple paths intersect. The velocity direction changes sharply near the intersection, forming high-curvature regions; particle trajectories consequently become bent and may even stall where the average velocity is close to zero. Higher curvature makes integration more difficult, requiring smaller step sizes or more accurate solvers to get it right, and sampling quality degrades accordingly.

Reducing crossings can be approached from several directions. Optimal transport pairing makes endpoint correspondences more regular, with paths parallel rather than crossing, thereby reducing conflicts at intersections. Introducing conditional information separates paths of different modes along the conditional dimension, allowing particles of different modes at the same position to receive different velocities. Reflow directly straightens paths on top of the learned field, further eliminating curvature.

What needs to be guarded against is that in high-dimensional spaces, looking only at animations of a few trajectories can easily be misleading. The fact that individual trajectories look straight does not mean the entire distribution is correctly covered. One should systematically check mode coverage (whether all data modes are generated), local velocity variance (whether velocity directions are chaotic at intersections), and endpoint distribution error; only these metrics can reflect the true impact of averaging effects in high-dimensional space.

Low training loss but poor generated samples indicate that the problem lies somewhere between "fitting the velocity" and "actual sampling". To isolate and locate the sources of error, three things need to be measured separately: field error, integration error, and endpoint distribution error.

Field error measures whether the velocity field learned by the network is faithful. The approach is to compute the mean squared error (MSE) of the velocity at held-out path points, i.e., the deviation between the network output and the true target velocity. To isolate field error, use a high-precision solver during sampling: if the solver is sufficiently accurate, the remaining endpoint error mainly comes from the velocity field itself being learned inaccurately. This separates "the field was learned wrong" from "the integration was not computed accurately".

Integration error measures the bias introduced by discretization. Fix the same velocity field, and compare the differences in endpoint quality under different NFEs (number of function evaluations) and different solvers. If quality clearly improves as NFE increases and solver order increases, this indicates that the previous error was mainly caused by numerical integration; if quality barely changes with NFE, this indicates that the bottleneck is not in the integration but in the field itself.

Endpoint distribution error measures the overall gap between the final sample distribution and the true data distribution. Available metrics include: if the density can be computed, directly compute likelihood; for image-like tasks, distribution distances such as FID are commonly used; precision and recall should also be examined, reflecting respectively whether the samples are realistic and whether the distribution is sufficiently covered; in addition, task-specific metrics should be incorporated. Also check whether trajectories explode (abnormal velocity norm causes position divergence), go out of bounds, or exhibit conditional drift (generated results deviate from the given condition).

When comparing across methods, also control for variables in the representation layer and data processing. Fix the latent-space codec and data processing pipeline, and compare with the diffusion baseline under the same computational budget, so that performance differences can be attributed to the flow matching objective itself, rather than to different latent-space representations or data preprocessing. Otherwise conclusions will be contaminated by representation differences.

Connecting the components of Flow Matching in causal order reveals how an idea travels from problem formulation all the way to verifiable practice.

Start by choosing the distributions at the two ends: at t=0 take a simple noise distribution (such as Gaussian noise), and at t=1 take the target data distribution. With the two ends in place, the second step is to define a conditional probability path connecting them, most commonly the linear interpolation x_t = (1−t)·x₀ + t·x₁. The third step is to randomly sample a time t and a path point x_t during training; this step does not require simulating the entire trajectory. The fourth step is to regress the known conditional velocity u = x₁ − x₀ at these path points, with the network output v_θ(t, x_t) approximating it. Fifth, because the optimal solution of the squared loss is the conditional expectation, the network implicitly learns the marginal velocity field—that is, the average over all possible conditional velocities conditioned on time and position. Sixth, at sampling time start from a new noise point, solve the ODE dx/dt = v_θ(t, x), and integrate the particle to t=1 to obtain a data sample. Seventh, control integration error through the number of sampling steps and solver order. Eighth, evaluate separately at three levels—velocity field, trajectory, and endpoint distribution—distinguishing field error, integration error, and distribution error.

This chain begins with the concept of "learning the velocity field," passes through conditional paths, regression targets, and the implicit formation of the marginal velocity field, and finally arrives at ODE sampling and layered evaluation; each step takes the previous step's output as its input, forming a complete causal chain.

Turning this causal chain into verifiable practice requires fixing variables, observing evidence, and preserving falsification. The object of verification is the claim "Flow Matching: directly learning the velocity field that continuously transports noise into data." At the input layer, fix the same batch of samples, the same preprocessing, and the permission boundary; record input hashes, slice labels, and rejection reasons to ensure that the same data is being compared. At the mechanism layer, change only one core variable (for example, path choice or pairing method), lock all other configurations, and then observe key intermediate states—where the velocity field deviates and in which link of the chain the first deviation from expectation appears—so as to locate the problem. At the output layer, use the same acceptance rules and the same resource budget, and compare differences in quality, cost, latency, and failure rate across levels. At the falsification layer, keep a control group that does not enable the target mechanism (for example, not using a Flow Matching objective, or using a simpler pairing), and check whether the benefit replicates stably across different samples and random seeds. Only after passing these four layers of verification can one say "Flow Matching brings the claimed improvement," rather than mistaking representational differences, random fluctuations, or other confounding factors for the method's own contribution.