Self-Consistent Flow: Unifying Velocity and Endpoint Prediction for Rectified Flow Models

Abstract: In rectified-flow-based generative models, the neural network can be trained to predict two different targets, such as the instantaneous velocity or the data endpoint, to perform denoising. Although prior work shows that these parameterizations lead to different empirical behaviors, the mechanisms underlying their respective advantages remain to be underexplored, and how to combine them effectively is still unclear. In this work, we analyze how learning errors from different parameterizations affect the generation performance. We show that predicting the data endpoint has a clear training signal that stabilizes training, whereas predicting the velocity maintains stable sampling dynamics near the data manifold. Motivated by these insights, we propose Self-Consistent Flow (SC-Flow), a new method that unifies the benefits of both parameterizations. By employing a lightweight consistency loss, SC-Flow jointly trains a single network to predict both the local velocity and the data endpoint, and the consistency between the two predictions improves the model's performance. The method requires no major architectural changes and adds minimal computational overhead. Extensive experiments on image generation tasks demonstrate that SC-Flow substantially stabilizes optimization and improves the straightness of generation paths, leading to significant gains in generation quality over standard rectified-flow baselines.

• The paper introduces Self-Consistent Flow, a shared-network method that combines velocity prediction, endpoint prediction, and an algebraic consistency loss to stabilize training and sampling.
• Theoretical analysis shows endpoint prediction has lower-variance, manifold-aligned targets for training, while direct velocity prediction avoids endpoint-error amplification near the data manifold during sampling.
• SC-Flow improves ImageNet FID to 1.86 from 2.06 for a longer-trained SiT baseline, reaches comparable quality in roughly 3.5× fewer iterations, and achieves CIFAR-10 FID gains of 22.8%.

Rectified flow models learn a neural ODE that transports a Gaussian prior to the data distribution, and the underlying network can be parameterized to predict either the instantaneous velocity ($v$-prediction) or the clean data endpoint ($x$-prediction). Although these targets are equivalent in the optimal case, they exhibit markedly different empirical behaviors, and prior comparisons have largely rested on small-scale evidence. This paper, by Han, Hu, and Liu of Tufts University (2607.12171), provides a theoretical account of this discrepancy in terms of learning errors and introduces Self-Consistent Flow (SC-Flow), a dual-target training scheme that couples the two predictions through an algebraic consistency loss.

Theoretical analysis of learning errors

The paper's central analytical contribution is a decomposition of the error behavior of the two parameterizations under linear interpolation paths $x_t = (1-t)x_0 + t x_1$ with independent coupling. Two complementary results motivate the method.

Variance and intrinsic dimensionality. Conditioning on $(x_t, t)$, the endpoint target satisfies $$\mathrm{Var}[x_1 \mid x_t, t] = (1-t)^2\,\mathrm{Var}[u \mid x_t, t]$$, so the endpoint target has strictly lower variance than the velocity target. The authors further formalize the manifold argument of Li and He, which had previously been supported only by toy examples. Assuming data lie in an $l$-dimensional linear subspace ($l < d$) spanned by a column-orthonormal $Q$, they prove that the optimal ambient velocity target contains an orthogonal noise-cancellation term,

$$\mathbf{v}^*_h(x_t) = Q\,\mathbf{v}^*_l(Q^\top x_t) - \frac{1}{1-t}(I - QQ^\top)x_t,$$

whereas the optimal endpoint target factors cleanly as $\mathbf{m}^*_h(x_t) = Q\,\mathbf{m}^*_l(z_t)$. The endpoint predictor therefore operates entirely within the low-dimensional intrinsic space, while the velocity predictor must additionally fit a high-variance component in the orthogonal complement. This makes X-Flow the easier regression problem and explains why velocity-only training can fail to converge in pixel-space settings.

Inference instability near the data manifold. The advantage of X-Flow reverses as $x$0. Because the derived velocity is $x$1, any endpoint learning error $x$2 is amplified to $x$3. The paper's claim is explicit and asymmetric: endpoint prediction stabilizes training, while velocity prediction stabilizes sampling near the data manifold. A 2D toy experiment in the appendix illustrates both failure modes vividly: as ambient dimension grows to $x$4, independent V-Flow collapses entirely due to target variance, while independent X-Flow preserves global structure but loses the intrinsic variance of the data because the $x$5 singularity forces trajectories onto the conditional mean. This trade-off, rather than a blanket preference for one parameterization, is the paper's core thesis.

The SC-Flow method

SC-Flow trains a single network $x$6 with a binary mode flag $x$7 that selects the output: $x$8 (velocity, $x$9) or $x_t = (1-t)x_0 + t x_1$0 (endpoint, $x_t = (1-t)x_0 + t x_1$1). The conditioning embeddings are summed, $x_t = (1-t)x_0 + t x_1$2, so the only architectural addition over a standard rectified-flow backbone is a two-entry mode embedding. The training objective combines three terms:

$x_t = (1-t)x_0 + t x_1$3

where $x_t = (1-t)x_0 + t x_1$4 is the standard flow-matching loss, $x_t = (1-t)x_0 + t x_1$5 is the endpoint regression loss (notably dropping the $x_t = (1-t)x_0 + t x_1$6 weighting that would make it exactly equivalent to $x_t = (1-t)x_0 + t x_1$7; the authors report this change has negligible effect), and the consistency term

$x_t = (1-t)x_0 + t x_1$8

enforces the exact analytical relationship between the two predictions. This distinguishes SC-Flow from the dual-output diffusion models of Benny and Wolf, which use uncoupled losses and separate output heads; here the constraint binds the two parameterizations into a single coherent vector field, and a single shared head performs both tasks.

At sampling time, either branch can drive the ODE. The default strategy switches from the endpoint-derived velocity to the direct velocity at a threshold $x_t = (1-t)x_0 + t x_1$9. An ablation over $(x_t, t)$0 shows FID is minimized in $(x_t, t)$1 (FID 1.86) and degrades toward both extremes, consistent with the theoretical analysis: large $(x_t, t)$2 exposes the solver to the asymptotic error amplification of X-Flow, while small $(x_t, t)$3 forfeits the low-variance early-stage supervision.

Empirical results

The evaluation covers CIFAR-10 (U-Net backbone) and class-conditional ImageNet $(x_t, t)$4 (DiT-L/4 and DiT-XL/2 in latent space, frozen SD-VAE, CFG, Dopri5 with 250 steps). The headline numbers are strong.

Model	Training steps	FID	sFID	IS	Precision
SiT-L	400K	11.53	12.06	110.75	0.65
SC-Flow-L-Mix	400K	9.85	10.02	145.61	0.68
SiT-XL	800K	6.22	6.65	157.46	0.73
SC-Flow-XL-Mix	800K	4.19	4.65	185.01	0.79
SiT-XL	7M	2.06	4.60	258.09	0.81
SC-Flow-XL-Mix	4M	1.86	4.21	285.93	0.85

On CIFAR-10, SC-Flow-Mix achieves FID 2.41 versus 3.12 for the rectified-flow baseline, a 22.8% relative improvement. On ImageNet, the relative gains are 14.6% (L/4) and 32.6% (XL/2) at matched training budgets. Two claims deserve emphasis. First, SC-Flow at 4M steps (FID 1.86) surpasses SiT-XL trained for 7M steps (FID 2.06), and the convergence curves indicate SC-Flow reaches SiT's final quality in roughly 3.5× fewer iterations. Second, the gains come at negligible cost: training time per epoch rises only marginally (e.g., 0.81 vs. 0.78 seconds for XL), and sampling cost is unchanged since only the active branch is evaluated per ODE step. The method also transfers across architectures, working with convolutional U-Nets as well as Transformers. Additionally, the straighter trajectories translate into faster sampling: SC-Flow-XL reaches FID 1.95 with 128 steps, beating SiT-XL's 256-step result (FID 2.06).

Ablations: what actually drives the gains

The ablation studies isolate the contribution of the consistency loss, and the findings are notable because they partially contradict prior parameterization comparisons. Training an X-Flow-only model ($(x_t, t)$5 alone) yields performance nearly identical to the velocity baseline (11.48 vs. 11.53 FID for L/4), despite the endpoint target being a clean image and the velocity target a corrupted difference. The authors conclude that the choice of target alone does not explain the performance gap — a direct challenge to the position that X-Flow is intrinsically superior. Instead:

• The consistency loss is essential. With $(x_t, t)$6, SC-Flow improves only slightly over the baseline (11.14 vs. 11.53 FID); with $(x_t, t)$7, the full gain appears (9.85). Qualitatively, without the constraint the V- and X-branches produce visibly divergent samples, whereas with it the two flows generate nearly identical images with fewer artifacts.
• Weight sharing matters. Training two independent networks with the same three-term objective (the "-2net" variant) still beats the baseline but falls short of shared-backbone SC-Flow (10.92/10.57 vs. 9.85 FID), indicating that joint learning of the related targets within one backbone contributes beyond the consistency constraint alone.
• The mechanism is variance reduction under finite data. When training noise is reduced by sampling four noise draws per data sample on CIFAR-10, both methods improve, but SC-Flow's margin shrinks (2.57→2.28 vs. 3.12→2.41). Since the two targets are equivalent given infinite data, this supports the hypothesis that the consistency loss primarily compensates for stochasticity in the finite-sample training signal.
• Path straightness and error dynamics. SC-Flow yields modestly straighter trajectories (Max-dev 0.248–0.250 vs. 0.256; Mean-cos 0.833 vs. 0.828). Empirical velocity MSE on validation data confirms the theory: X-Flow and V-Flow errors are indistinguishable for $(x_t, t)$8, after which the X-Flow error spikes sharply due to the $(x_t, t)$9 amplification, while SC-Flow maintains the lowest error across the full time range.

Limitations and open questions

The paper is explicit about the boundaries of its results. The consistency constraint is derived specifically for linear rectified paths and ODE sampling; extension to nonlinear schedules (e.g., variance-preserving paths) requires a different formulation of the constraint. All experiments are in latent image spaces at $$\mathrm{Var}[x_1 \mid x_t, t] = (1-t)^2\,\mathrm{Var}[u \mid x_t, t]$$0, and the authors note that at much higher ambient dimensionality the high-variance velocity target may dominate the shared network without adaptive loss balancing — whether the method holds for text-to-image or video generation is untested. The consistency term also requires a second forward pass during training, a modest but nonzero overhead. Finally, the analysis assumes lossless linear encoding of data onto a low-dimensional subspace and an independent coupling, both idealizations; the authors themselves acknowledge that lossless linear encoding is rarely achievable in practice, and the extension to nonlinear noise scheduling is asserted rather than worked out.

Conclusion

This paper reframes the velocity-versus-endpoint parameterization debate as a trade-off in learning-error behavior: endpoint prediction offers lower-variance targets confined to the data manifold and stabilizes optimization, while velocity prediction avoids the $$\mathrm{Var}[x_1 \mid x_t, t] = (1-t)^2\,\mathrm{Var}[u \mid x_t, t]$$1 error amplification that destabilizes sampling near $$\mathrm{Var}[x_1 \mid x_t, t] = (1-t)^2\,\mathrm{Var}[u \mid x_t, t]$$2. SC-Flow exploits both sides of this trade-off through a single shared network with a binary mode switch and an algebraic consistency loss, achieving FID improvements of up to 32.6% over matched rectified-flow baselines on ImageNet $$\mathrm{Var}[x_1 \mid x_t, t] = (1-t)^2\,\mathrm{Var}[u \mid x_t, t]$$3, a 3.5× reduction in training iterations to reach baseline quality, and faster sampling via straighter trajectories — all at essentially unchanged computational cost. The most consequential empirical finding is that neither parameterization alone accounts for the performance gap between methods; the coupling between them, enforced through consistency, is what delivers the gains.