Flow matching: velocity scaling cuts FID from 28.0 to 12.2 on ImageNet-256

Scaling the learned velocity field in flow matching recently showed a strong gain in generation quality. A new arXiv paper (cs.CV) does not dispute the effect itself, but it changes the explanation and proposes a way to choose the coefficient by measurement rather than blindly. The result: FID on ImageNet-256 at 25 function evaluations (NFE 25) and without guidance drops from 28.0 to 12.2. The authors estimate this value by linear interpolation between FID measurements at neighboring gain values.

What was mistaken for the cause

In flow matching, the model v_θ learns to predict the velocity at which a point moves from noise to data. The sampler integrates this field over time. The technique in question multiplies the predicted velocity by a coefficient γ(t). Earlier work explained the improvement this way: training with mean squared error (MSE) systematically underestimates the velocity magnitude, and scaling restores it to the correct value.

The authors of the new paper disagree. They argue that MSE training does not create a deficit in velocity magnitude. Scaling still works, so a different mechanism must be responsible.

Population time lag

The proposed explanation is called population time lag. The states the sampler receives at model time t resemble training states from an earlier time. The sample, in effect, lags behind what the model learned at that t. The velocity field is therefore applied to points that are "younger" than the model expects.

This suggests two ways to correct it, which the paper treats as equivalent:

• multiply the velocity by a gain γ(t) so the trajectory catches up to the right stage faster;
• shift the model time backward, so the network is given the time that matches the point's actual state.

Both techniques compensate for the same lag. That is why scaling worked, even though the explanation for it was different.

Measurement instead of tuning

The main practical takeaway: the lag can be measured. The authors measure it and use it to choose the gain. According to their data, this works across different architectures and model sizes.

Key figures from the abstract:

• dataset and resolution: ImageNet-256;
• sampling budget: NFE 25;
• guidance: not used;
• FID before: 28.0;
• FID after: 12.2 (estimated by linear interpolation between neighboring gain values);
• coverage: different architectures and model sizes.

Note separately that 12.2 was not obtained by a direct measurement at a single point. It is an interpolation between two measured gain values. That is enough to understand the scale of the effect, but exact reproducibility should be checked on your own checkpoints. The abstract does not say how the result compares with guidance, larger NFE budgets or other datasets.

What to do in practice

For a team that trains or fine-tunes flow-matching models for images, this suggests several steps. First, check whether your sampler already includes a velocity multiplier or a time-schedule shift. These techniques may solve the same problem and duplicate each other.

Next, measure the lag on your own checkpoint and match the gain value to it, rather than searching over the coefficient on an FID grid. A grid is expensive, because each point requires a full sample generation. Measuring the lag could potentially shorten this search.

Finally, at low NFE, where sampler errors are most noticeable, compare two variants: scaling and a model-time shift. According to the paper they are equivalent in meaning, but on a specific architecture and step schedule they may differ in stability. For researchers, the work also raises a broader question: which other sampler "defects" turn out, in practice, to be a time mismatch between training and inference. For details and for verification of the conclusions on other datasets, consult the full text of the paper.