Paper deep dive
Self-Consistent Flow: Unifying Velocity and Endpoint Prediction for Rectified Flow Models
Xu Han, Jiajing Hu, Li-Ping Liu
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 95%
Last extracted: 7/15/2026, 4:43:59 AM
Summary
This paper introduces Self-Consistent Flow (SC-Flow), a novel training framework for rectified-flow-based generative models. SC-Flow unifies velocity and endpoint prediction by jointly training a single network with a lightweight consistency loss. This approach stabilizes optimization, improves generation path straightness, and significantly enhances image generation quality on ImageNet with minimal computational overhead.
Entities (8)
Relation Signals (9)
Xu Han → affiliatedwith → Tufts University
confidence 98% · Xu Han xu.han@tufts.edu Department of Computer Science Tufts University
Li-Ping Liu → affiliatedwith → Tufts University
confidence 98% · Li-Ping Liu liping.liu@tufts.edu Department of Computer Science Tufts University
Jiajing Hu → affiliatedwith → Tufts University
confidence 98% · Jiajing Hu jiajing.hu@tufts.edu Department of Computer Science Tufts University
Self-Consistent Flow → evaluatedon → ImageNet
confidence 96% · Experiments on ImageNet show that SC-Flow substantially outperforms baseline methods
Self-Consistent Flow → unifies → Velocity Prediction
confidence 95% · SC-Flow is a novel framework that trains a single model to simultaneously predict two complementary targets: the instantaneous velocity and the likely endpoint.
Self-Consistent Flow → employs → Consistency Loss
confidence 94% · By employing a lightweight consistency loss, SC-Flow jointly trains a single network to predict both the local velocity and the data endpoint
Self-Consistent Flow → improves → Training Stability
confidence 93% · SC-Flow substantially stabilizes optimization and improves the straightness of generation paths
Self-Consistent Flow → outperforms → Rectified Flow
confidence 92% · SC-Flow substantially outperforms baseline methods, demonstrating the advantage of combining flow targets in a unified model.
Self-Consistent Flow → measuredby → FID
confidence 90% · achieving significant FID improvements with the same sampling cost
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
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.
Tags
Links
- Source: https://arxiv.org/abs/2607.12171v1
- Canonical: https://arxiv.org/abs/2607.12171v1
PDF not stored locally. Use the link above to view on the source site.
Full Text
80,332 characters extracted from source content.
Expand or collapse full text
Self-Consistent Flow: Unifying Velocity and Endpoint Prediction for Rectified Flow Models Xu Han xu.han@tufts.edu Department of Computer Science Tufts University Jiajing Hu jiajing.hu@tufts.edu Department of Computer Science Tufts University Li-Ping Liu liping.liu@tufts.edu Department of Computer Science Tufts University 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. 1 Introduction Generative models based on ordinary differential equations (ODEs) (Lipman et al., 2022; Liu et al., 2022), have emerged as a powerful alternative to traditional diffusion models, enabling high-quality synthesis with significantly fewer sampling steps. The neural network learns the vector field of an ODE that transforms a simple prior distribution into the data distribution. In a flow matching model (Lipman et al., 2022; Liu et al., 2022), the generative model needs to predict the vector field to learn the ODE that defines the model distribution. Besides predicting the velocity field at a given noisy sample, the underlying neural network can also be parameterized to predict the clean sample or the noise (Li and He, 2025). Different parameterizations also appear in different diffusion-based generation (Song et al., 2020b), where the neural network can learn the score function in the reverse SDE (Song and Ermon, 2019), predict the noise (Ho et al., 2020; Rombach et al., 2022), or predict the clean sample (Song et al., 2020a). While these different predicting targets are mathematically equivalent, they do yield distinct empirical performances. Previous studies that develop specific methods often consider that one parameterization is superior over another one depending on the empirical performance. Recent research (Li and He, 2025) compares different flow parameterization in a systematic study and favors X-Flow based on an argument of data manifold. Given that different parameterizations are equivalent in the optimal case, we believe that the learning error is the root reason for their performance difference. However, there still lacks a systematic analysis of learning errors in these different parameterizations. In this work, we relate prediction targets to learning errors and develop a dual-target predictive model to reduce the error. We introduce Self-Consistent Flow (SC-Flow) to combine the strengths of the two learning targets. SC-Flow is a novel framework that trains a single model to simultaneously predict two complementary targets: the instantaneous velocity (v) and the likely destination of the ODE path (x). Our key insight is that by receiving training signals in both forms, the neural network gains extra power in learning the vector field, bridging the optimization benefits of data prediction with the inference stability of velocity prediction. SC-Flow uses a single network backbone to compute the two fitting targets, with a binary mode flag to indicate the type of the target. The design adds negligible overhead to a baseline rectified flow model and incurs the same level of inference costs in the generation procedure. Experiments on ImageNet show that SC-Flow substantially outperforms baseline methods, demonstrating the advantage of combining flow targets in a unified model. We also conduct an extensive empirical study to verify our theoretical analysis and demonstrate that the performance gain is due to our new design. Our contributions can be summarized as follows: • Dual-Target Framework: We propose SC-Flow, a novel training framework for rectified flows that supervises a single model on two complementary targets: the instantaneous velocity and the likely endpoint. The consistency loss enforces the analytical relationship between the two predictions. This improves optimization and ensures the learned vector fields are coherent. • Analysis of learning errors: We rigorously analyze the variance and error dynamics of flow estimators. We show that direct endpoint prediction is less affected by sampling variance, whereas the velocity target is more stable near the data manifold. • Empirical verification: SC-Flow substantially outperforms the standard rectified flow baseline on ImageNet 256×256256× 256, achieving significant FID improvements with the same sampling cost and negligible additional training overhead. 2 Related Works Modern denoising-based generative models are formulated through three closely related perspectives: score-based modeling (Song and Ermon, 2019), reverse diffusion processes (Song et al., 2020b; Ho et al., 2020), and flow matching (Liu et al., 2022; Lipman et al., 2022). Across these formulations, the neural networks are often parameterized differently to perform the denoising step. In score-based methods (Song and Ermon, 2019), the neural network is trained to learn the score function at different noise levels. The learning target is also equivalent to learning the score function in the reverse SDE (Song et al., 2020b). In DDPM (Ho et al., 2020), the network is trained to predict the noise (ϵε-prediction). In DDIM (Song et al., 2020a), the network directly predicts the clean sample conditioned on the noisy sample. In the framework of Flow Matching (Lipman et al., 2022) and Rectified Flows (Liu et al., 2022), the network learns a continuous-time ODE vector field to map a simple prior to the data distribution. With a noisy sample as the input, the output of the network should predict velocity (v-prediction) of the vector field. Compared against the diffusion-based formulation, the velocity is essentially the sum of the score function and the drift in the reverse SDE. With the assumption of rectified flow, the network can also predict the real data sample (X-Flow) or the noise (ϵε-Flow), and then derive the velocity prediction. Therefore, X-Flow and ϵε-Flow share a similar spirit respectively as DDPM and DDIM. The different parameterizations are systematically investigated by Ma et al. (2024); Li and He (2025), which compared noise, score, and velocity predictions within the stochastic interpolant framework, demonstrating that generative performance heavily depends on the chosen target. In particular, Ma et al. (2024) observes a significant performance increase with weighted score and velocity (they are equivalent) in the latent diffusion model; while the study by Li and He (2025) favors x-flow on the original pixel space with an argument that the data is on a manifold and easy to predict. However, the argument is only supported by a small example. In this work, we deepen the understanding from a theoretical perspective and investigate how learning error affects the generation quality. In diffusion-based generative models, Benny and Wolf (2022) have explored multiple parameterizations and dual outputs and let the neural network to both noise and the clean sample using a naive shared structure and a learned mixing strategy. However, this approach only relies on a shared network trunk and encourages the network to learn information from both targets. In our work, we develop a new algorithm from rectified flow, which is very different from diffusion-based models. Furthermore, we restrict the model to be consistent with the two flows. 3 Background Rectified Flow (RF) learns a neural ODE to transform an initial noise distribution p0p_0 into the target data distribution p1p_1, with a time-dependent vector field vt(t):ℝd→ℝdv_t(x_t):R^d ^d that guides the evolution of state tx_t: dt=vt(t)dt,0∼p0,t∈[0,1].dx_t=v_t(x_t)dt, x_0 p_0, t∈[0,1]. (1) Starting from 0∼p0x_0 p_0 (typically a standard Gaussian distribution), RF integrates the ODE from t=0t=0 to t=1t=1, yielding a sample 1∼p1x_1 p_1. The vector field vt(t)v_t(x_t) is learned by a neural network θ(t,t)v_θ(x_t,t), where θ represents the trainable parameters. In an RF model, the vector field is given by a conditional flow. RF starts with a coupling distribution p(0,1)p(x_0,x_1) such that the marginal p(0)p(x_0) and p(1)p(x_1) are respectively the noise distribution and the data distribution. Then the conditional flow is defined by the straight path between (0,1)∼p(0,1)(x_0,x_1) p(x_0,x_1). Let t=t1+(1−t)0x_t=tx_1+(1-t)x_0, the conditional velocity at xtx_t is u(t|0,1)=1−0=1−t1−t. u(x_t|x_0,x_1)=x_1-x_0= x_1-x_t1-t. (2) The model θ(t,t)v_θ(x_t,t) is then trained with conditional flow loss by: ℒ(ϕ)=t∼[0,1],0,1[‖(1−0)−θ(t,t)‖22].L(φ)=E_t [0,1],x_0,x_1 [\|(x_1-x_0)-v_θ(x_t,t)\|_2^2 ]. (3) Latent space diffusion/flow models achieve both high generation quality and efficiency compared to the pixel space models. In the latent space model, the RGB image is encoded to a latent space sample x using an encoder E. The reconstructed image is decoded from the latent x by the decoder D. In this work, we focus on learning the data distribution p(1)p(x_1) and assume the encoder-decoder is fixed. 4 SC-Flow Model Figure 1: SC-Flow overview: (A) Training. Linear rectified path xt=(1−t)x0+tx1x_t=(1-t)x_0+tx_1 with instantaneous velocity u=x1−x0u=x_1-x_0; Training minimizes LFM=‖θ−u‖2L_FM=\|v_θ-u\|^2, Lx=‖~θ−x1‖2L_x=\| m_θ-x_1\|^2, and the consistency term Lc=‖~θ−(xt+(1−t)θ)‖2L_c=\| m_θ-(x_t+(1-t)v_θ)\|^2. (B) Model. Single network nθ(xt,t,y,b)n_θ(x_t,t,y,b) with summed embeddings Et(t)+Ey(y)+Eb(b)E_t(t)+E_y(y)+E_b(b); mode b=0b=0 outputs θv_θ (velocity) and b=1b=1 outputs ~θ m_θ (endpoint). (C) Sampling. Sampling integrates the probability-flow ODE with a per-step drift chosen from θv_θ and (~θ−xt)/(1−t)( m_θ-x_t)/(1-t) (Equation˜10); any selection/blending policy may be used without retraining. Motivation. SC-Flow is motivated by re-examining the flow-matching objective. Let p(0,1)=p0(0)p1(1)p(x_0,x_1)=p_0(x_0)p_1(x_1) denote the independent coupling between the prior and the target data distribution. Here, 1∼p1x_1 p_1 is a clean sample drawn from the empirical data distribution, and 0∼p0=(,)x_0 p_0=N(0,I) is a random noise sample drawn from a standard Gaussian prior. By the definition of the straight path t=(1−t)0+t1x_t=(1-t)x_0+tx_1, we can algebraically rewrite the instantaneous velocity as 1−0=1−t1−tx_1-x_0= x_1-x_t1-t. Substituting this directly into the flow-matching objective, for t∈(0,1)t∈(0,1), the training loss becomes p[‖θ(t,t)−(1−0)‖22] _p [\|v_θ(x_t,t)-(x_1-x_0)\|_2^2 ] =p[‖θ(t,t)−1−t1−t‖22] =E_p [ \|v_θ(x_t,t)- x_1-x_t1-t \|_2^2 ] =1(1−t)2p[‖((1−t)θ(t,t)+t)−1‖22]. = 1(1-t)^2E_p [ \|((1-t)v_θ(x_t,t)+x_t)-x_1 \|_2^2 ]. (4) Because the network θ(t,t)v_θ(x_t,t) makes its predictions conditioned only on the intermediate state tx_t and time t, the pointwise optimal predictor that minimizes this squared error is given by the conditional expectation. Therefore, the optimal value for θv_θ satisfies ((1−t)θ(t,t)+t)=p[1|t].((1-t)v_θ(x_t,t)+x_t)=E_p[x_1|x_t]. Noting that the left-hand side only involves (t,t)(x_t,t), we can define a new function θ(t,t)m_θ(x_t,t) to replace the left-hand side. We then train by directly regressing θ(t,t)m_θ(x_t,t) toward the data endpoint 1x_1. The relationship between θm_θ and θv_θ is θ=(1−t)θ(t,t)+t,θ=θ(t,t)−t1−t. m_θ=(1-t)v_θ(x_t,t)+x_t, v_θ= m_θ(x_t,t)-x_t1-t. (5) The SC-Flow method. We introduce another neural function ~θ m_θ to directly learn 1x_1. The learning objective for ~θ m_θ is Lx(θ)=‖~θ(t,t)−1‖22. L_x(θ)=\| m_θ(x_t,t)-x_1\|_2^2. (6) Here we use the same θ to denote the network parameters, since later both θv_θ and ~θ m_θ are parameterized by the same network. Compared with Equation˜4, this objective removes the leading factor 1/t21/t^2 to improve training stability; empirically, we find that this change has a negligible impact on performance. Since θv_θ and ~θ m_θ are computed from different neural functions, we need to make them consistent with each other. We include another consistency term in the training objective Lc=‖~θ(t,t)−θ(t,t)‖22=‖~θ(t,t)−((1−t)θ(t,t)+t)‖22. L_c= \| m_θ(x_t,t)-m_θ(x_t,t) \|_2^2= \| m_θ(x_t,t)-((1-t)v_θ(x_t,t)+x_t) \|_2^2. (7) The entire training objective is ℒ(θ)=wvLFM(θ)+wxLx(θ)+wcLc(θ). (θ)=w_vL_FM(θ)+w_xL_x(θ)+w_cL_c(θ). (8) This joint training objective is illustrated in Figure˜1. Parameterization. While θv_θ and ~θ m_θ play different roles, their required information is similar. In this work, we train a single network nθn_θ to compute both functions as illustrated in Figure˜1. In particular, we use a binary flag b∈0,1b∈\0,1\ to indicate which function it computes θ(t,t):=nθ(t,t,b=0),~θ(t,t):=nθ(t,t,b=1). v_θ(x_t,t):=n_θ(x_t,t,b=0), m_θ(x_t,t):=n_θ(x_t,t,b=1). (9) From ~θ m_θ, we derive the velocity: ~θ=~θ(t,t)−t1−t v_θ= m_θ(x_t,t)-x_t1-t (10) We refer to the original flow θv_θ as V-Flow and to our new flow ~θ v_θ as X-Flow. We also consider conditional generation. Let y denote a conditioning variable (e.g., a class label). We augment the inputs with y, so the network becomes nθ(t,t,b,y)n_θ(x_t,t,b,y). In the implementation, we embed the time t, the indicator b, and the condition y with vectors and send their sum into the neural network, e(t,y,b)=et(t)+ey(y)+eb(b)e(t,y,b)=e_t(t)+e_y(y)+e_b(b). Here, we assume y is a global, discrete conditioning variable (such as a class label) that can be mapped to a single embedding vector and added directly to the network’s intermediate states. As discussed in Section 2, diffusion-based and flow-based generative models share a few common design choices of network parameterizations. In this sense, our approach is related in spirit to the dual-output diffusion model of Benny and Wolf (2022). However, beyond the broader distinction between diffusion and flow frameworks, our method differs in two key aspects. First, SC-Flow introduces an explicit consistency objective that enforces agreement between the predicted velocity and data endpoint, whereas dual-output diffusion (Benny and Wolf, 2022) does not impose such a constraint between outputs. Second, our approach employs a single shared network with a lightweight toggle mechanism to produce both predictions, enabling tighter coupling between the two parameterizations with minimal additional complexity. As shown in our experiments, these design choices play an important role in improving both optimization stability and generation performance. Sampling. In the generative procedure, we have two vector fields θ(t,t)v_θ(x_t,t) and ~θ(t,t) v_θ(x_t,t) for sampling. We can use either of them for sampling with path integration. We can also blend them in the sampling procedure. ˙t=~θ(t,t),t≤τ,θ(t,t),t>τ. x_t\;=\; cases v_θ(x_t,t),&t≤τ,\\[2.0pt] v_θ(x_t,t),&t>τ. cases (11) In our experiment, we use τ=0.5τ=0.5. Abalation study can be found in Appendix A.3 Ablation on the Blending Threshold τ 4. The blending strategy slightly improves generation performance in the experiment, though θv_θ and ~θ v_θ do not have significant differences because of the consistent term. The strategy is justified by the stability during inference. Detailed analysis can be found in analysis section. Computation. Compared with a baseline that predicts θv_θ with a single network, our model introduces only a minimal number of additional parameters –the embedding of the binary switch b. Training time increases only slightly because the computations for θv_θ and θm_θ are largely shared. At sampling time, the runtime is nearly identical to that of the baseline flow-matching model: the compute budget is essentially unchanged, and we simply toggle b to select θv_θ or ~θ v_θ. Algorithm 1: SC-Flow training (single head) 1:Input: (wv,wx,wc)(w_v,w_x,w_c), clamp ε , optimizer 2:for minibatches (x0,x1,y)(x_0,x_1,y) in dataset do 3: Draw t∼([ε, 1−ε])t ([ ,\,1- ]) 4: xt←(1−t)x0+tx1x_t←(1-t)x_0+tx_1, u←x1−x0u← x_1-x_0 5: θ←nθ(xt,t,y,b=0)v_θ _θ(x_t,t,y,b=0) 6: ~θ←nθ(xt,t,y,b=1) m_θ _θ(x_t,t,y,b=1) 7: Compute LFM,Lx,LcL_FM,L_x,L_c 8: ℒ(θ)←wvLFM(θ)+wxLx(θ)+wcLc(θ)L(θ)← w_vL_FM(θ)+w_xL_x(θ)+w_cL_c(θ) 9: Update θ with ∇θL _θL 10:end for Algorithm 2: SC-Flow sampling (ODE) 1:Input: prior x0∼p0x_0 p_0, condition y, clamp ε 2:Choose per-step drift rule using equation 11 3:for t from 0 to 11 with an ODE solver do 4: θ←nθ(xt,t,y,b=0)v_θ _θ(x_t,t,y,b=0) 5: ~θ←nθ(xt,t,y,b=1) m_θ _θ(x_t,t,y,b=1) 6: ~θ←(x^1−xt)/max(1−t,ε) v_θ←( x_1-x_t)/ (1-t, ) 7: x˙t←mix(θ,~θ,t) x_t (v_θ, v_θ,t) as described in Equation˜11 8: Advance xtx_t one ODE step using x˙t x_t 9:end for 10:return xt=1x_t=1 5 Analysis of SC-Flow In this section, we analyze the learning errors associated with fitting the velocity versus the data endpoint. By examining the target variance, the dimensionality of the optimal vector fields, and the asymptotic error during sampling, we reveal a fundamental trade-off that motivates our dual-target SC-Flow architecture. We first demonstrate why endpoint prediction (X-Flow) provides superior training stability, and subsequently show why velocity prediction (V-Flow) is necessary to prevent inference instability near the data manifold. We base our analysis on the following model assumption. We assume the independent coupling of noise and the data distribution, p(0,1)=p(0)p(1)p(x_0,x_1)=p(x_0)p(x_1). The conditional path is a linear interpolation xt=(1−t)x0+tx1x_t=(1-t)x_0+tx_1 for t∈(0,1)t∈(0,1). The analysis can be extended to the case of non-linear noise scheduling (Tsimpos et al., 2025), but we focus on the linear case for notational simplicity. The setting here represents practices in real applications (Liu et al., 2022; Esser et al., 2024). Variance and the intrinsic dimension of learning targets. We first consider the learning targets of the neural network in the V-Flow and X. Given (t,t)(x_t,t), let p(0,1|t,t)p(x_0,x_1|x_t,t) be the conditional distribution of paths passing through tx_t. The conditional velocity is =1−t1−t=1−0u= x_1-x_t1-t=x_1-x_0. Then: Var[1|t,t]=(1−t)2Var[|t,t]. [x_1|x_t,t]=(1-t)^2Var[u|x_t,t]. (12) We can see that 1x_1 has a lower variance than u. The finite-sample estimation of the true target [1|t,t]E[x_1|x_t,t] has lower variance than the velocity target [|t,t]E[u|x_t,t]. For image data, noise in u degrades or even destroys the smoothness property of images, making patterns difficult to learn. Li and He (2025) advocates for X-Flow by suggesting that data resides on a low-dimensional manifold and is thus inherently easier to fit, but their justification relies primarily on small-scale toy problems. We extend this intuition by providing a formal analysis. Consistent with our previous notation, we consider data x in a d-dimensional space. Following Zhang et al. (2025), we assume the data can be embedded into a lower-dimensional latent space ℝlR^l (where l<dl<d). Specifically, we assume x can be perfectly reconstructed from its latent representation ∈ℝlz ^l: =Q,=Qz=Qx,x=Qz, with Q∈ℝd×lQ ^d× l being a column-orthonormal matrix (Q⊤Q=IlQ Q=I_l). Therefore, the latent space ℝlR^l contains the latent data manifold. Although lossless linear encoding is rarely achievable in complex real-world applications, it remains a robust analytical tool, as the primary variance of high-dimensional data is often concentrated within a few principal components. The vector field on x entails a vector field on z. Given the conditional flow t=t1+(1−t)0x_t=tx_1+(1-t)x_0, the projected conditional flow is t=t1+(1−t)0z_t=tz_1+(1-t)z_0, where 0=Q⊤0z_0=Q x_0. If the optimal velocity estimator in the data and latent spaces are respectively h∗(t)=[1−0|t]v^*_h(x_t)=E[x_1-x_0|x_t] and l∗(t)=[1−0|t]v^*_l(z_t)=E[z_1-z_0|z_t]. Because of the noise term 0x_0 in the high-dimensional space, the optimal velocity h∗v^*_h is still in the high-dimensional space. In particular, the two vector fields have the following relationship (Zhang et al., 2025). We put the proof in Appendix Appendix A.1 Proof. h∗(t)=Ql∗(Q⊤t)−11−t(I−QQ⊤)t. ^*_h(x_t)=Qv^*_l(Q x_t)- 11-t(I-Q )x_t. (13) In contrast, with the assumption of linear construction, the predicting target of X-Flow stays in an l-dimensional subspace. Let h∗(t)=[1|t]m^*_h(x_t)=E[x_1|x_t] and l∗(t)=[1|t]m^*_l(x_t)=E[z_1|z_t] be the optimal predicting targets of X-Flow, respectively, in the data and latent spaces. We can separate the linear components of tx_t by t=(1−t)0+tQ1=(1−t)(I−QQ⊤)0+Qtx_t=(1-t)x_0+tQz_1=(1-t)(I-Q )x_0+Qz_t. Let t=(1−t)(I−QQ⊤)0s_t=(1-t)(I-Q )x_0. With the setup of the learning problem: 1) the isotropic Gaussian distribution of 0x_0 and 2) the independent coupling, ts_t is independent of 0=Q⊤0z_0=Q x_0 and 1=Q⊤1z_1=Q x_1. Then we have the relationship between the two optimal predicting targets: h∗(t)=[Q1|t]=[Q1|t,t]=Q[1|t]=Ql∗(t).m^*_h(x_t)=E[Qz_1|x_t]=E[Qz_1|z_t,s_t]=QE[z_1|z_t]=Qm^*_l(z_t). (14) This result indicates that the network in the X-Flow setup can predict targets in a low-dimensional latent space; therefore, it is more likely to reduce the learning error than the network that directly predicts velocity values. For these two reasons, we argue that it is easier to train the neural network in the X-Flow setting. Inference stability near the data manifold. Despite its training stability, deriving the velocity from an endpoint predictor introduces severe inference instability as the trajectory approaches the data manifold. Specifically, the learning error of ~θ m_θ will be scaled up by 11−t 11-t. With the conditional distribution p(1,0|t,t)p(x_1,x_0|x_t,t), let δ=‖θ(t,t)−[]‖22δ=\|v_θ(x_t,t)-E[u]\|_2^2 be the learning error of the V-Flow model. Let ϵ=‖~θ(t,t)−[1]‖22ε=\| m_θ(x_t,t)-E[x_1]\|_2^2 be the learning error of the X-Flow model, then the error of the velocity ~θ v_θ computed from ~θ m_θ is δ~=ϵ(1−t)2 δ= ε(1-t)^2, which is scaled up because of the factor 11−t 11-t. At the early stage of the path, when (1−t)(1-t) is significantly greater than 0, it is hard to argue whether θv_θ or ~θ v_θ has smaller error for reasons from both sides. However, the analysis does indicate that X-Flow has an advantage when the data dimension is much higher the compact latent dimension. The previous work by Li and He (2025) studies parameterization methods in the pixel space and shows that some V-Flow networks θv_θ cannot even converge while the X-Flow model ~θ m_θ can. The finding is consistent with our theoretical analysis above. However, at the late stage when 1−t1-t is small, and the error ϵε of the X-Flow model is significantly amplified by the factor 11−t 11-t, then X-Flow is a worse choice than V-Flow. We can compare the learning errors on a validation set by checking their learning objectives. The two errors δ and δ~ δ can be compared by: δ δ =t[∥(θ−[|t])∥22]=[∥θ−∥22]−t[tr(Var())], =E_x_t[\|(v_θ-E[u|x_t])\|_2^2]=E[\|v_θ-u\|_2^2]-E_x_t[tr(Var(u))], (15) δ~ δ =t[∥(~θ−[|t])∥22]=[∥~θ−∥22]−t[tr(Var())]. =E_x_t[\|( v_θ-E[u|x_t])\|_2^2]=E[\| v_θ-u\|_2^2]-E_x_t[tr(Var(u))]. (16) The second term is a constant and does not affect the comparison. Our experiment later shows that δ~ δ is significantly larger than δ when t approaches 1. 6 Experiments We empirically evaluate SC-Flow on image generation tasks. We first check the performance of SC-Flow and then examine the effect of the proposed training method with a series of ablation studies. Datasets and evaluation metrics. The experiment is conducted on the two well-known datasets, CIFAR-10 (Krizhevsky, 2009) and ImageNet 256×256256× 256 (Deng et al., 2009). The evaluation metrics are Fréchet Inception Distance (FID) (Heusel et al., 2017), sFID (Siarohin et al., 2019), Inception Score (IS) (Salimans et al., 2016), and Precision (Kynkänniemi et al., 2019). Lower FID/sFID and higher IS and Precision correspond to better performance. Our primary baseline for performance comparison is Rectified Flow. All methods share the same neural backbone architecture, with the only difference being the additional switch b introduced in SC-Flow. SC-Flow supports three sampling strategies: V-Flow, X-Flow, and a mixed approach defined in Equation˜11. We denote the three strategies with suffixes -V, -X, and -Mix, respectively. 6.1 Evaluation with CIFAR-10 For our CIFAR-10 experiments, we use a U-Net backbone with an architecture similar to the one used in DDPM++ (Nichol and Dhariwal, 2021), which is a standard for this dataset. Both the baseline and SC-Flow models are trained for 250K iterations. For evaluation, we generate samples using Heun’s method with 250 steps to ensure stable ODE integrations. Table 1: Main results on CIFAR-10 (250K iterations, 250 sampling steps). SC-Flow consistently outperforms the Rectified Flow baseline. Model FID ↓ sFID ↓ IS ↑ Precision ↑ RectifiedFlow 3.12 3.34 9.47 0.72 SC-Flow-V 2.49 2.93 9.61 0.73 SC-Flow-X 2.41 2.88 9.64 0.73 SC-Flow-Mix (τ=0.5τ=0.5) 2.41 2.83 10.65 0.73 As shown in Table˜1, SC-Flow demonstrates a significant performance improvement over the standard rectified flow baseline on CIFAR-10. The SC-Flow-Mix and SC-Flow-X variants achieve the best FID score of 2.41, a substantial 22.8% relative improvement over the baseline’s 3.12. All SC-Flow sampling modes achieve better performance than the baseline method, indicating that the new training scheme also improves the V-flow θv_θ. This strong performance with a convolutional U-Net architecture (Ronneberger et al., 2015) (as opposed to a Transformer (Vaswani et al., 2017)) highlights the general applicability and benefit of our proposed method. 6.2 Evaluation with ImageNet 256x256 Our experiments on ImageNet use the DiT-L/4 and DiT-XL/2 (Peebles and Xie, 2023) backbones as the foundation for our models. Here L and XL are mode sizes defined in the original paper. The number are patch sizes used by the generative model. We use “-L” and “-XL” to indciate these two settings. Our standard Rectified Flow baselines are trained following the SiT (Ma et al., 2024). The SC-Flow model employs the same backbone architecture, except for the input of the binary switch b. The L/4 models are trained for 400K iterations and the XL/2 models for 800K iterations, both with a constant learning rate of 1×10−41× 10^-4. For evaluation, all models are sampled using the Dopri5 ODE solver (Dormand and Prince, 1980) with 250 steps. In this experiment, we include DiT as a baseline. DiT uses the same network backbone but is a diffusion-based generative method. We also train a flow matching model with only X-flow: we train ~θ m_θ with the objective LxL_x and generate images with the derived X-flow ~θ v_θ. We denote this method as RectifiedFlow-L-X or RectifiedFlow-XL-X. All experiments are conducted with classifier free guidance (cfg) (Ho and Salimans, 2022) during sampling. Table 2: Performances on ImageNet 256×256256× 256. SC-Flow with all three sampling methods has significant improvements over the baseline model. (a) L/4 (cfg=4.0, 400K training steps, 250 sampling steps) Model Training Steps FID ↓ sFID ↓ IS ↑ Precision ↑ DiT-L 400K 11.84 12.22 116.50 0.63 SiT-L 400K 11.53 12.06 110.75 0.65 SiT-L-X 400K 11.48 12.02 112.63 0.65 SC-Flow-L-V 400K 9.92 10.04 143.09 0.68 SC-Flow-L-X 400K 10.63 11.90 137.86 0.67 SC-Flow-L-Mix (τ=0.5τ=0.5) 400K 9.85 10.02 145.61 0.68 (b) XL/2 (cfg=1.5, 800K training steps, 250 sampling steps) Model Training Steps FID ↓ sFID ↓ IS ↑ Precision ↑ DiT-XL 800K 6.41 6.67 175.01 0.73 DiT-XL 7M 2.27 4.60 278.24 0.83 SiT-XL 800K 6.22 6.65 157.46 0.73 SiT-XL-X 800K 6.19 6.72 155.25 0.74 SiT-XL 7M 2.06 4.60 258.09 0.81 SC-Flow-XL-V 800K 4.21 4.68 184.97 0.79 SC-Flow-XL-X 800K 4.28 4.68 183.48 0.79 SC-Flow-XL-Mix (τ=0.5τ=0.5) 800K 4.19 4.65 185.01 0.79 SC-Flow-XL-Mix (τ=0.5τ=0.5) 4M 1.86 4.21 285.93 0.85 Table˜2 presents our main results on ImageNet. SC-Flow substantially outperforms the Rectified Flow baselines across all metrics. On the L/4 model, our mixed-inference strategy (SC-Flow-L-Mix) improves the FID score of Rectified Flow from 11.53 to 9.85, a relative improvement of 14.6%. The gains are even more pronounced on the larger DiT-XL/2 model, where SC-Flow-XL-Mix reduces the FID from 6.22 to 4.19, a 32.6% relative improvement. Notably, SC-Flow also achieves a significantly higher Inception Score (IS) and Precision, indicating that the generated samples are not only more realistic but also more faithful to the training data. SC-Flow using the other two sampling methods also consistently outperforms the baseline, with the X-flow performing slightly better than the V-flow. Training Efficiency. Figure 2: Training Convergence. FID-50K vs. training iterations on ImageNet. SC-Flow achieves significantly faster convergence, reaching the performance of the SiT baseline in 3.5× fewer iterations. To evaluate the impact of dual-target supervision on optimization, we compare the training convergence of SC-Flow against standard SiT and DiT baselines. As illustrated in Figure 2, SC-Flow exhibits a markedly superior learning curve. By supervising both the local velocity and the global destination, the model benefits from the variance reduction properties established in our theoretical analysis. Specifically, SC-Flow reaches an FID of 2.0 in approximately 2M iterations, whereas the SiT baseline requires nearly 7M iterations to achieve comparable quality. This 3.5× acceleration in training efficiency highlights that the consistency loss stabilizes the gradient flow, allowing the network to capture the underlying data manifold more effectively in the early stages of training. 6.3 Ablation Studies. (a) The scale of LcL_c versus sampling steps. (b) Measurement of path straightness. Model Max-dev ↓ Mean-cos ↑ RectifiedFlow-L 0.256 0.828 SC-Flow-L-V 0.250 0.833 SC-Flow-L-X 0.248 0.833 (c) FID versus consistency weight wcw_c. wcw_c 0.0 0.1 0.2 0.3 SC-Flow-L-Mix 11.14 9.85 9.86 9.91 Figure 3: Analysis of the effect of the consistency term in SC-Flow. (a) The consistency loss LcL_c measured during a 250-step ODE solver. The gap between θm_θ and ~θ m_θ is largest at early steps and converges to zero. (b) The evaluation of path straightness shows SC-Flow generates more direct paths than Rectified Flow. (c) A sweep over the consistency weight wcw_c shows that wc>0w_c>0 is critical. To validate our design choices and understand how SC-Flow improves the generation performance, we conduct a series of ablation studies focusing on the role of the consistency loss (LcL_c). The X-flow or the V-flow does not work well separately. To isolate the effect of the X-flow training from minimizing Lx(θ)=‖θ~(t,t)−1‖22L_x(θ)=\| m_θ(x_t,t)-x_1\|_2^2, we can train a Rectified Flow model by minimizing Lx(θ)L_x(θ) only and then draw samples from ~θ v_θ derived from ~θ m_θ. As we mentioned before, this method is labeled as RectifiedFlow-X, and its performance is shown in Table˜2. Its performance is nearly identical to the performance of the baseline Rectified Flow. Note that the V-flow θv_θ is trained against a corrupted image 1−0x_1-x_0, while the X-flow is trained against a clean image 1x_1. This result demonstrates that the different training targets do not bring a clear performance difference. The consistency loss is necessary. In Figure˜3(c), we vary the the weight wcw_c of the consistency term Lc(θ)L_c(θ). The best performance is achieved with wc∈0.1,0.2w_c∈\0.1,0.2\. When wc=0w_c=0 eliminates the consistency constraint, SC-Flow only has a slight performance improvement over the baseline Rectified Flow (11.14 vs. 11.53 FID). We hypothesize that the improvement is from the network sharing, which is the focus of the next experiment. This result reveals that the consistency loss LcL_c is essential for unlocking the full potential of our method. Our qualitative study later in Figure˜6 also shows that the consistency loss improves the quality of the generated images. Table 3: The performance of SC-Flow models using two separate networks for the V-Flow and X-Flow. Model FID ↓ sFID ↓ SC-Flow-L-V-2net 10.92 12.15 SC-Flow-L-X-2net 10.57 10.77 The shared neural architecture brings performance gain. Sharing the same neural architecture clearly saves computation. At the same time, they learn targets that are quite related, so sharing the architecture should also be a reasonable choice for performance consideration. To verify this hypothesis, we train two independent DiT-L models for the V-flow and the X-flow. The training objective is the same as SC-Flow models above. We denote this new setup with the suffix “-2net”. The performance of the two models under this setup is shown in Table˜3. The performance still improves upon the baseline Flow Matching model. The improvement is solely due to the consistency term because that’s the only difference from the baseline. However, their performance cannot match that of SC-Flow models with shared networks, which indicates the performance benefit of learning related targets with a single network backbone. Table 4: Performance of models trained with the 1:4 ratio of training samples and noise samples on CIFAR-10. Model FID ↓ sFID ↓ RectifiedFlow (1:4) 2.57 2.94 SC-Flow-Mix (1:4) 2.28 2.73 Consistency helps to overcome randomness in training. As we analyzed in Section 3, the V-flow and the X-flow should be equivalent when there are infinite training examples, and the consistency term would not be useful. We hypothesize that the consistency between the V-flow and the X-flow is very beneficial when the model is trained with limited data and noise. To verify this hypothesis, we increase the amount of random noise examples to 4 times the training samples in each training batch, and therefore reduce the random noise in the training process. We conducted this experiment with the CIFAR-10 dataset. The performance of the trained models is shown in Table˜4. The new training strategy improves the performance of both models because it essentially increases the training batches of the both models. However, this new setup shows less performance improvement with SC-Flow than the standard setup: the reduction of FID is (2.57 - 2.28) from the previous reduction (3.12 - 2.41). This provides strong evidence supporting our hypothesis. SC-Fow slightly straightens sampling paths We compare SC-Flow and Rectified Flow in terms of the straightness of sampling paths. The straightness is measured by Max-dev (the maximum deviation from the chord connecting the two ends of the path) and Mean-cos (average cosine similarity between each step and the chord). Lower Max-dev or higher Mean-cos indicates more straight paths. The results are shown in Figure˜3(b). SC-Flow achieves slightly straighter paths. One possible explanation is that the X-flow aims to predict the destination and thus has a better chance to learn straight paths. We also plot the consistency loss LcL_c in Figure˜3(a) at each step of the ODE path. For both L and XL models, the difference is very small (at the scale of 1e-4), although the two models share a similar pattern. The inconsistency is highest near t=0t=0 where the path is most uncertain, and converges towards zero as t→1t→ 1. (a) FID-50K vs. Training Steps. Left: L Models. Right: XL Models. (b) Training and Sampling Time Comparison (seconds) on ImageNet Model Tr./epoch Spl./step SiT-L 0.80 0.09 SC-Flow-V-L 1.01 0.10 SiT-XL 0.78 0.51 SC-Flow-V-XL 0.81 0.56 Figure 4: Efficiency and Training Dynamics. (a) SC-Flow has lower FID score than the baseline at every checkpoint. (b) The training overhead is negligible and sampling cost is identical. Computation efficiency. Figure˜4 demonstrates that SC-Flow’s significant performance gains are achieved with high efficiency. The plots on the left show the FID-50K score as a function of training steps for both L and XL models. At every evaluation checkpoint, SC-Flow maintains a consistent and substantial advantage over the standard Rectified Flow baseline, indicating not only a better final result but also faster convergence. The table on the right quantifies the computational cost. The training time per epoch for SC-Flow is only marginally higher than the baseline. This is due to our efficient single-head design, which requires only one additional forward pass through the shared network backbone to compute both targets. Crucially, the sampling time per step is nearly identical, as both methods require just one model evaluation per ODE step. Taken together, these results confirm that SC-Flow is a "plug-and-play" upgrade, offering superior sample quality and faster training convergence with a negligible increase in training cost and no change to the sampling budget. Stability during inference. To empirically validate the asymptotic behavior described in Section˜5, we analyze the precision of the learned vector fields near the data manifold. This analysis demonstrates how different supervision signals affect the numerical stability of the ODE solver. (a) Full Range t∈[0,1]t∈[0,1] (b) Endpoint Region t∈[0.9,1.0]t∈[0.9,1.0] Figure 5: Velocity Error Comparison. We compare the Mean Squared Error (MSE) of velocity predictions against ground truth for SC-Flow and single-target baselines. As predicted by inference stability analysis in Section˜5, the derived velocity from endpoint predictors (red lines) spikes exponentially as t→1t→ 1 due to the (1−t)−1(1-t)^-1 error magnification. SC-Flow (blue solid) maintains the lowest overall error, demonstrating how joint supervision and consistency regularize the vector field against asymptotic instability. The right panel provides a focused view of this behavior near the data manifold. We evaluate the velocity prediction error using 2,000 images randomly sampled from the ImageNet validation set. From these 2,000 validation samples, we compute the learning objective ‖θ(t,t)−(1−0)‖02\|v_θ(x_t,t)-(x_1-x_0)\|^2_0 with v-s derived from different models: θv_θ from SC-Flow with b=0b=0 (SC-Flow-V), ~θ v_θ derived from SC-Flow with b=1b=1 (SC-Flow-X), θv_θ from the baseline trained with velocity (Single-V), and ~θ v_θ derived from the baseline trained with endpoints (Single-X). As shown in Figure 5, the empirical results show that X-Flow and V-Flow are not very distinguishable at the first stage of the path. When t>0.8t>0.8, the error of X-Flow begins to increase quickly because of the amplification effect in our discussion. SC-Flow clearly decreases the learning error throughout all time t. Even for SC-Flow, X-Flow still tends to have a large error at the end of the sampling stage. Our mixed sampling strategy avoids such error by using V-Flow in the latter part of the sampling procedure. Figure 6: Qualitative Comparison on ImageNet 256×256256× 256. We compare samples from the L/4 and XL/2 SC-Flow models using V-Flow θv_θ, X-Flow ~θ v_θ, and mixed inference. The bottom row (XL/2) shows higher fidelity than the L/4 model. The middle row ablates our consistency loss (wc=0.0w_c=0.0), revealing a clear visual divergence between the velocity and endpoint predictions. The top row (wc=0.1w_c=0.1) demonstrates that our proposed consistency loss forces the two predictions into alignment, producing more coherent and higher-quality samples. Qualitative Analysis. Figure˜6 provides a qualitative analysis of SC-Flow. As expected, the larger XL/2 model (bottom row) generates samples with noticeably higher fidelity and finer detail than the L/4 model (top row), consistent with the quantitative metrics. The critical comparison is between the model trained with our consistency loss (wc=0.1w_c=0.1, top row) and the ablation without it (wc=0.0w_c=0.0, middle row). When wc=0.0w_c=0.0, the model’s two predictions are unconstrained and learn inconsistent vector fields. This is visually apparent: the samples generated respectively from the V-flow and the X-flow exhibit clear discrepancies in texture, lighting, and fine details. For example, the parrot’s perch has noticeable artifacts in the V-flow sample that are absent in the X-flow. By introducing the consistency loss, these two predictions are forced into agreement. The resulting images from both flows become nearly identical and have reduced artifacts. This visually confirms the significance of the consistent loss, which enforces the entire model to learn a coherent generation flow. 7 Limitations and Conclusion Limitations and future work. While SC-Flow demonstrates strong empirical advantages, our current formulation presents a few limitations that offer avenues for future work. First, our training objective and consistency loss are specifically formulated for linear rectified paths (xt=(1−t)x0+tx1x_t=(1-t)x_0+tx_1) and ODE-based sampling. Extending SC-Flow to non-linear trajectories, such as variance-preserving diffusion paths, would require careful derivation of the consistency constraint in a different way. Second, SC-Flow needs to be validated on generation tasks with much higher resolutions and other modalities (e.g., text-to-image or video). As ambient dimensionality grows significantly larger than the intrinsic data manifold, joint optimization may require adaptive loss balancing to prevent the high-variance velocity targets from overpowering the shared network. Third, enforcing the consistency constraint slightly increases training time. Although the network architecture is shared, computing both the velocity and endpoint predictions for the LcL_c term requires an additional forward evaluation during each training step. Conclusion. In this work, we theoretically and empirically investigate the distinct behaviors of different prediction targets within the rectified flow framework. We reveal a fundamental trade-off: predicting the data endpoint provides a low-variance, on-manifold signal that stabilizes training, while predicting the instantaneous velocity ensures bounded integration error for stable sampling near the data manifold. To unify these complementary strengths, we introduced SC-Flow (Self-Consistent Flow). By employing a lightweight algebraic consistency penalty, SC-Flow trains a single network with a binary control bit to concurrently predict both the local velocity and the global destination. At inference, this dual-target parameterization enables a zero-overhead switching policy that seamlessly transitions from X-Flow to V-Flow. Extensive experiments on CIFAR-10 and ImageNet 256×256256×256 demonstrate that explicitly coupling local motion with global awareness significantly stabilizes optimization, straightens generation paths, and improves overall sample quality. Ultimately, SC-Flow offers a principled, plug-and-play approach to building stronger continuous-time generative models without requiring architectural upheaval or additional sampling compute. Acknowledgment The authors thank the reviewers for their insightful comments and constructive feedback, which have significantly contributed to the improvement of this work. Jiajing Hu and Li-Ping Liu’s work was supported by the U.S. National Science Foundation under Award No. 2239869. References Y. Benny and L. Wolf (2022) Dynamic dual-output diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 11482–11491. Cited by: Appendix A.6 Detailed Comparison with Dual-Output Diffusion Models, Appendix A.6 Detailed Comparison with Dual-Output Diffusion Models, Appendix A.6 Detailed Comparison with Dual-Output Diffusion Models, Appendix A.6 Detailed Comparison with Dual-Output Diffusion Models, Appendix A.6 Detailed Comparison with Dual-Output Diffusion Models, §2, §4. J. Deng, W. Dong, R. Socher, L. Li, K. Li, and L. Fei-Fei (2009) Imagenet: a large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, p. 248–255. Cited by: §6. J. R. Dormand and P. J. Prince (1980) A family of embedded runge-kutta formulae. Journal of computational and applied mathematics 6 (1), p. 19–26. Cited by: §6.2. P. Esser, S. Kulal, A. Blattmann, R. Entezari, J. Müller, H. Saini, Y. Levi, D. Lorenz, A. Sauer, F. Boesel, et al. (2024) Scaling rectified flow transformers for high-resolution image synthesis. In International Conference on Machine Learning, p. 12606–12633. Cited by: §5. M. Heusel, H. Ramsauer, T. Unterthiner, B. Nessler, and S. Hochreiter (2017) Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems 30. Cited by: §6. J. Ho, A. Jain, and P. Abbeel (2020) Denoising diffusion probabilistic models. Advances in neural information processing systems 33, p. 6840–6851. Cited by: Appendix A.6 Detailed Comparison with Dual-Output Diffusion Models, §1, §2. J. Ho and T. Salimans (2022) Classifier-free diffusion guidance. arXiv preprint arXiv:2207.12598. Cited by: §6.2. A. Krizhevsky (2009) Learning multiple layers of features from tiny images. Technical report Technical Report TR-2009, University of Toronto. External Links: Link Cited by: §6. T. Kynkänniemi, T. Karras, S. Laine, J. Lehtinen, and T. Aila (2019) Improved precision and recall metric for assessing generative models. Advances in neural information processing systems 32. Cited by: §6. T. Li and K. He (2025) Back to basics: let denoising generative models denoise, 2025. URL https://arxiv. org/abs/2511.13720 7. Cited by: §1, §2, §5, §5. Y. Lipman, R. T. Chen, H. Ben-Hamu, M. Nickel, and M. Le (2022) Flow matching for generative modeling. arXiv preprint arXiv:2210.02747. Cited by: §1, §1, §2, §2. X. Liu, C. Gong, and Q. Liu (2022) Flow straight and fast: learning to generate and transfer data with rectified flow. arXiv preprint arXiv:2209.03003. Cited by: Appendix A.6 Detailed Comparison with Dual-Output Diffusion Models, §1, §1, §2, §2, §5. N. Ma, M. Goldstein, M. S. Albergo, N. M. Boffi, E. Vanden-Eijnden, and S. Xie (2024) Sit: exploring flow and diffusion-based generative models with scalable interpolant transformers. In European Conference on Computer Vision, p. 23–40. Cited by: §2, §6.2. A. Q. Nichol and P. Dhariwal (2021) Improved denoising diffusion probabilistic models. In International conference on machine learning, p. 8162–8171. Cited by: §6.1. W. Peebles and S. Xie (2023) Scalable diffusion models with transformers. In Proceedings of the IEEE/CVF international conference on computer vision, p. 4195–4205. Cited by: §6.2. R. Rombach, A. Blattmann, D. Lorenz, P. Esser, and B. Ommer (2022) High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 10684–10695. Cited by: §1. O. Ronneberger, P. Fischer, and T. Brox (2015) U-net: convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computer-assisted intervention, p. 234–241. Cited by: §6.1. T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, and X. Chen (2016) Improved techniques for training gans. Advances in neural information processing systems 29. Cited by: §6. A. Siarohin, S. Lathuilière, S. Tulyakov, E. Ricci, and N. Sebe (2019) First order motion model for image animation. Advances in neural information processing systems 32. Cited by: §6. J. Song, C. Meng, and S. Ermon (2020a) Denoising diffusion implicit models. arXiv preprint arXiv:2010.02502. Cited by: §1, §2. Y. Song and S. Ermon (2019) Generative modeling by estimating gradients of the data distribution. Advances in neural information processing systems 32. Cited by: §1, §2. Y. Song, J. Sohl-Dickstein, D. P. Kingma, A. Kumar, S. Ermon, and B. Poole (2020b) Score-based generative modeling through stochastic differential equations. arXiv preprint arXiv:2011.13456. Cited by: §1, §2. P. Tsimpos, R. Zhi, J. Zech, and Y. Marzouk (2025) Optimal scheduling of dynamic transport. In The Thirty Eighth Annual Conference on Learning Theory, p. 5441–5505. Cited by: §5. A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin (2017) Attention is all you need. Advances in neural information processing systems 30. Cited by: §6.1. S. Zhang, H. Zhang, Z. Zhang, C. Ge, S. Xue, S. Liu, M. Ren, S. Y. Kim, Y. Zhou, Q. Liu, et al. (2025) Both semantics and reconstruction matter: making representation encoders ready for text-to-image generation and editing. arXiv preprint arXiv:2512.17909. Cited by: §5, §5. Appendix A Appendix Appendix A.1 Proof Proof. Let P=QQ⊤P=Q denote the orthogonal projection matrix onto the data manifold ℳM, and P⟂=I−QQ⊤P =I-Q denote the projection onto its orthogonal complement. We can decompose the optimal ambient velocity target into its intrinsic and orthogonal components: 1−0=P(1−0)+P⟂(1−0). _1-x_0=P(x_1-x_0)+P (x_1-x_0). (17) First, we analyze the orthogonal component. Because the data 1=Q1x_1=Qz_1 resides strictly on the manifold, it has no orthogonal component (P⟂1=0P x_1=0). Applying P⟂P to both sides of the flow trajectory t=t1+(1−t)0x_t=tx_1+(1-t)x_0 yields: P⟂t=(1−t)P⟂0⟹P⟂0=11−tP⟂t. P x_t=(1-t)P x_0 P x_0= 11-tP x_t. (18) Consequently, the orthogonal component of the velocity target is deterministic given tx_t: [P⟂(1−0)|t]=−11−tP⟂t=−11−t(I−QQ⊤)t. [P (x_1-x_0)|x_t]=- 11-tP x_t=- 11-t(I-Q )x_t. (19) Next, we evaluate the intrinsic manifold component. Using 1=Q1x_1=Qz_1 and the definition of the projected noise 0=Q⊤0z_0=Q x_0, we have: P(1−0)=Q(Q⊤1−Q⊤0)=Q(1−0). P(x_1-x_0)=Q(Q x_1-Q x_0)=Q(z_1-z_0). (20) Assuming the ambient noise 0x_0 is isotropic Gaussian, its orthogonal projection P⟂0P x_0 and intrinsic projection Q⊤0Q x_0 are statistically independent. Therefore, conditioning on the full ambient state tx_t for the intrinsic variables is mathematically equivalent to conditioning strictly on the projected intrinsic state t=Q⊤tz_t=Q x_t. Taking the conditional expectation yields: [P(1−0)|t]=Q[1−0|t]=Ql∗(t). [P(x_1-x_0)|x_t]=QE[z_1-z_0|z_t]=Qv^*_l(z_t). (21) Finally, by the linearity of expectation, summing the intrinsic and orthogonal conditional expectations completes the proof: h∗(t) ^*_h(x_t) =[P(1−0)|t]+[P⟂(1−0)|t] =E[P(x_1-x_0)|x_t]+E[P (x_1-x_0)|x_t] =Ql∗(Q⊤t)−11−t(I−QQ⊤)t. =Qv^*_l(Q x_t)- 11-t(I-Q )x_t. (22) ∎ Appendix A.2 ImageNet Experiment Details This section documents the full training and evaluation setup used for ImageNet 256×256256×256 with DiT-L/4 and DiT-XL/2 backbones. Unless stated, SC-Flow and the Rectified-Flow baselines share identical settings. Data and Latent Encoding Dataset and preprocessing. We train on ImageNet (train split) with class-conditional labels. Images are center-cropped and resized to 256×256256× 256, followed by random horizontal flip and normalization to [−1,1][-1,1]. Latent space (VAE). All models operate in the latent space of a frozen, pretrained VAE encoder (no finetuning). We use diffusers AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-ema"). Latents are scaled by the standard factor 0.182150.18215 (as in Stable Diffusion). Table 5: Latent-space and encoder specifics. Item Encoder Trainable Image Size Downsample Latent Size Latent Channels VAE SD-VAE-FT-ema|mse No (frozen) 256×256256×256 ×8× 8 32×3232×32 44 Model, Conditioning, and Mode Bit Backbones. We use DiT-L/4 and DiT-XL/2 transformers (patch sizes 44 and 22 respectively). Exact widths/depths follow DiT; we summarize placeholders below for completeness. Table 6: Backbone summary (filled from the provided model definitions). Model Input Size In Ch. Patch Tokens Depth Hidden Heads PosEnc DiT-L/4 3232 44 4×44×4 8×8=648×8=64 2424 10241024 1616 2D sin/cos (frozen) DiT-XL/2 3232 44 2×22×2 16×16=25616×16=256 2828 11521152 1616 2D sin/cos (frozen) Conditioning streams and SC-Flow mode. We sum three embeddings into the adaLN-Zero conditioning vector at every block: e(t,y,b)=Et(t)+Ey(y)+Eb(b).e(t,y,b)\;=\;E_t(t)\;+\;E_y(y)\;+\;E_b(b). Time uses a sinusoidal projection (frequency_embedding_size=256=256) followed by an MLP to the hidden size. Class labels use an embedding table of size num_classes + 1 when classifier-free guidance (CFG) dropout is enabled. The SC-Flow mode bit b∈0,1b\!∈\!\0,1\ selects which prediction the single head should output (local motion when b=0b=0, global endpoint when b=1b=1). Table 7: Embedding dimensions and fusion. Stream Source Dim Notes Fusion Time sinusoidal → MLP dhidd_hid freq emb size 256256 Et+Ey+EbE_t+E_y+E_b Class embedding table dhidd_hid (num_classes+1)( num\_classes+1) if CFG Mode bit b embedding table (2 entries) dhidd_hid b=0b=0: local motion; b=1b=1: endpoint Optimization and Training Schedule We train with AdamW (constant learning rate 1×10−41×10^-4, no weight decay) and exponential moving average (EMA) of weights. TensorFloat-32 (TF32) is enabled on A100/H200. Table 8: Optimizer, precision, and regularization. Setting Optimizer LR Weight Decay Betas Eps EMA Decay AMP All AdamW 1×10−41×10^-4 0 (0.9, 0.999)(0.9,\,0.999) 1×10−81×10^-8 0.99990.9999 False Sampling and Evaluation We integrate the probability-flow ODE using Dopri5 with a fixed budget of 250250 steps. For SC-Flow we keep compute parity by evaluating only the active branch per step (one forward pass per step). We report FID-50K, sFID, IS, and Precision. Table 9: Sampling configuration and guidance. Model Solver Steps Switch τ CFG Scale DiT-L/4 Dopri5 250 0.50.5 4.04.0 DiT-XL/2 Dopri5 250 0.50.5 1.51.5 Path Straightness Metrics: mean_cos and max-dev Setup and notation. For a batch of discrete sampling paths xk(b)k=0S\x_k^(b)\_k=0^S with b=1,…,Bb=1,…,B and xk(b)∈ℝDx_k^(b) ^D (flattened images), define the chord c(b)=xS(b)−x0(b),u(b)=c(b)‖c(b)‖(unit chord).c^(b)\;=\;x_S^(b)-x_0^(b), u^(b)\;=\; c^(b)\|c^(b)\|\;\;(unit chord). (23) Let the step vector be sk(b)=xk+1(b)−xk(b),k=0,…,S−1.s_k^(b)\;=\;x_k+1^(b)-x_k^(b), k=0,…,S-1. (24) Mean cosine to the chord (mean_cos). The per–time-step cosine between the step and the chord direction is γk(b)=⟨sk(b),u(b)⟩‖sk(b)‖=⟨xk+1(b)−xk(b),xS(b)−x0(b)‖xS(b)−x0(b)‖⟩‖xk+1(b)−xk(b)‖. _k^(b)\;=\; s_k^(b),\,u^(b) \|s_k^(b)\|\;=\; x_k+1^(b)-x_k^(b),\, x_S^(b)-x_0^(b)\|x_S^(b)-x_0^(b)\| \|x_k+1^(b)-x_k^(b)\|. (25) We average over steps and the batch: mean_cos=1BS∑b=1B∑k=0S−1γk(b). mean\_cos\;=\; 1BS _b=1^B _k=0^S-1 _k^(b). (26) Values closer to 11 indicate that steps remain well aligned with the global chord (straighter paths). Maximum lateral deviation (max-dev). For each intermediate point, decompose xk(b)x_k^(b) into chord-parallel progress and orthogonal residual. Define the signed progress along the chord, dk(b)=⟨xk(b)−x0(b),u(b)⟩,d_k^(b)\;=\; x_k^(b)-x_0^(b),\,u^(b) , (27) the orthogonal projection onto the chord, pk(b)=x0(b)+dk(b)u(b),p_k^(b)\;=\;x_0^(b)+d_k^(b)\,u^(b), (28) and the residual (lateral) displacement rk(b)=xk(b)−pk(b),δk(b)=‖rk(b)‖.r_k^(b)\;=\;x_k^(b)-p_k^(b), _k^(b)\;=\;\|r_k^(b)\|. (29) The per-path maximum lateral deviation (normalized by chord length) is max-dev(b)=1‖c(b)‖max0≤k≤Sδk(b). max-dev^(b)\;=\; 1\|c^(b)\|\; _0≤ k≤ S\, _k^(b). (30) We report the batch average: max-dev=1B∑b=1Bmax-dev(b). max-dev\;=\; 1B _b=1^B max-dev^(b). (31) Smaller values indicate paths that hug the straight line more tightly (fewer detours). Implementation notes. All vectors xk(b)x_k^(b) are flattened before inner products; norms are Euclidean. For numerical stability, denominators are clamped, e.g. ‖c(b)‖←max(‖c(b)‖,ε)\|c^(b)\|← (\|c^(b)\|, ) and ‖sk(b)‖←max(‖sk(b)‖,ε)\|s_k^(b)\|← (\|s_k^(b)\|, ) with ε≈10−8 ≈ 10^-8. Appendix A.3 Ablation on the Blending Threshold τ To provide deeper insight into the mixed sampling strategy defined in Equation˜11, we conduct an ablation study on the blending threshold τ. This threshold determines the exact timestep at which the inference procedure transitions from the derived X-Flow v~θ v_θ to the direct V-Flow vθv_θ. Table 10 presents the generation performance of the SC-Flow-XL-Mix model across a range of values τ∈0.3,0.4,0.5,0.6,0.7τ∈\0.3,0.4,0.5,0.6,0.7\ using 250 sampling steps. Table 10: Ablation of the blending threshold τ on ImageNet 256×256256× 256 (SC-Flow-XL-Mix). τ 0.3 0.4 0.5 0.6 0.7 FID 1.89 1.86 1.86 1.91 1.93 The empirical results align closely with our theoretical analysis regarding sampling instability (Section˜5). As the trajectory approaches the data manifold (t→1t→ 1), the prediction error of the X-Flow is magnified by the factor 1(1−t)2 1(1-t)^2. Consequently, higher values of τ (e.g., 0.6 or 0.7) force the ODE solver to rely on v~θ v_θ in a regime where its derived velocity becomes increasingly unstable, leading to a degradation in sample quality (FID rises to 1.93). Conversely, setting τ too low (e.g., 0.3) prematurely abandons the low-variance supervision of the endpoint predictor. By switching to the V-Flow too early, the model loses the trajectory-straightening benefits of the global destination prediction, resulting in a slight performance penalty (FID 1.89). Optimal performance is achieved in the middle range (τ∈[0.4,0.5]τ∈[0.4,0.5]). In this regime, the model maximally exploits the stable, on-manifold trajectory of the X-Flow during the highly uncertain early stages of generation, and seamlessly hands over control to the V-Flow just before the asymptotic instability of the endpoint prediction sets in. We therefore adopt τ=0.5τ=0.5 as a robust and theoretically justified default for our mixed inference strategy. Appendix A.4 Faster Sampling via Straighter Trajectories To evaluate whether the straighter sampling trajectories induced by our consistency objective allow for faster sampling, we measure the generation quality across a reduced number of integration steps. Experimental Setup. We evaluate the SC-Flow-XL model and the baseline SiT-XL model on the ImageNet 256×256256× 256 validation set. We vary the number of sampling steps N∈32,64,128,256N∈\32,64,128,256\ using the Dopri5 ODE solver and report the resulting FID scores. Results and Analysis. Figure 7 illustrate the generation quality as a function of the sampling budget. SC-Flow consistently maintains a significant performance advantage over the SiT baseline across all step counts. Notably, SC-Flow achieves an FID of 1.95 using only 128 sampling steps, which surpasses the performance of the baseline SiT-XL using 256 steps (FID 2.06). These results empirically confirm that the improved vector field approximation and straighter ODE trajectories learned by SC-Flow directly translate to faster sampling capabilities, allowing for a substantial reduction in the computational sampling budget without sacrificing generation quality. Figure 7: Generation quality (FID) versus the number of ODE sampling steps on ImageNet 256×256256× 256. SC-Flow consistently achieves better FID at lower step counts, demonstrating that its straighter trajectories enable faster sampling. Appendix A.5 2D Toy Experiment: Bridging Theory and High-Dimensional Generation To bridge our theoretical analysis of learning errors (Section˜5) with our high-dimensional image generation results, we evaluate SC-Flow on a 2D toy dataset embedded in higher ambient dimensions. Experimental Setup. We generate a 2D spiral with Gaussian noise, representing a data distribution with an intrinsic dimension of d=2d=2. To simulate high-dimensional learning dynamics, we embed this 2D data into a D-dimensional ambient space (D∈2,8,32D∈\2,8,32\) using a fixed, random column-orthogonal projection matrix. We train a lightweight generative model (a 5-layer MLP with SiLU activations and 256 hidden units) under three configurations: independent X-Flow, independent V-Flow, and our proposed SC-Flow. After training, the generated samples are projected back to the 2D subspace using the same orthogonal matrix for visualization. Results and Theoretical Connection. Figure 8 illustrates the generated distributions across increasing ambient dimensions. The empirical results perfectly align with our theoretical analysis: • High-Variance Collapse of V-Flow: As the ambient dimension D increases, the variance of the velocity target u=x1−x0u=x_1-x_0 grows substantially, as the additional orthogonal dimensions consist entirely of pure noise. As analyzed in Section 5.1, this high-variance target space causes the independent V-Flow to struggle, eventually collapsing into unstructured noise by D=32D=32. • Inference Instability of X-Flow: The independent X-Flow successfully learns the global structure across all dimensions because its target (x1x_1) is restricted to the low-variance data manifold. However, because sampling from X-Flow requires deriving the velocity via v~θ=(m~θ−xt)/(1−t) v_θ=( m_θ-x_t)/(1-t), it suffers from inference instability as t→1t→ 1 (Section 5.2). This singularity forces the trajectories to collapse onto the mean expectation of the manifold, stripping away the natural variance (the visual “thickness”) of the ground-truth data distribution. • Self-Consistent Flow: SC-Flow demonstrates the regularizing power of our dual-target framework. By supervising the shared network with the stable, low-variance X-Flow target, the network is heavily regularized against high-dimensional noise. While the independent V-Flow completely collapses at D=32D=32, the V-branch of SC-Flow successfully captures the underlying spiral structure. Although the high ambient variance still introduces some noise and degradation into the SC-Flow result at D=32D=32, the consistency loss clearly rescues the velocity prediction from catastrophic failure while avoiding the asymptotic division singularity of independent X-Flow. Figure 8: Toy Experiment: A d=2d=2 noisy spiral embedded in a D-dimensional space via an orthogonal projection matrix. As D increases to 32, independent V-Flow fails due to high-variance targets. Independent X-Flow survives but loses the intrinsic data variance (thickness) due to the t→1t→ 1 sampling singularity. SC-Flow (sampled via its V-output) leverages the stable X-Flow target to regularize the V-branch, successfully preventing the catastrophic collapse seen in independent V-Flow and preserving the broader manifold structure. Appendix A.6 Detailed Comparison with Dual-Output Diffusion Models While SC-Flow shares the high-level philosophy of dual-target prediction with the pioneering work of Benny and Wolf (2022) on Dynamic Dual-Output Diffusion Models, the two approaches differ fundamentally in their mathematical domains, architectural implementations, and training constraints. We detail these key technical distinctions below. Mathematical Framework. Benny and Wolf (2022) operate within the standard Denoising Diffusion Probabilistic Model (DDPM) (Ho et al., 2020) framework, where the network is trained to predict the added noise (ϵε) and the clean data (x0x_0) to reverse a Gaussian diffusion trajectory. In contrast, SC-Flow is formulated within the continuous-time Rectified Flow (Liu et al., 2022) framework. Our model learns a deterministic ODE vector field by predicting the instantaneous velocity (v) and the data endpoint (x1x_1) along a straight, linear probability flow path. Strict Algebraic Consistency vs. Multi-Task Learning. The most significant technical difference lies in how the dual targets are constrained. Benny and Wolf (2022) treat dual prediction primarily as a multi-task learning problem. While their network shares a feature-extraction backbone, the dual targets are learned via uncoupled loss functions and are not explicitly forced to mathematically equate to one another during training. SC-Flow, conversely, binds the two predictions together using a strict algebraic consistency loss (LcL_c). Because Rectified Flow operates on linear paths, the exact analytical relationship between the endpoint and the velocity is strictly defined: x1=xt+(1−t)vtx_1=x_t+(1-t)v_t. Our consistency loss explicitly penalizes deviations from this physical ODE constraint, guaranteeing that the network learns a singular, coherent vector field. Architectural Implementation. To accommodate dual outputs, Benny and Wolf (2022) utilize a branched architecture where a shared network trunk splits into two separate, dedicated output heads. SC-Flow employs a true single-head architecture. Rather than splitting the network, we introduce a binary mode indicator bit (b∈0,1b∈\0,1\) as a conditioning embedding. This forces the exact same output layer to dynamically switch its predictive behavior, maximizing parameter sharing and memory efficiency with zero architectural overhead. Inference and Asymptotic Stability. Benny and Wolf (2022) rely on a learned or scheduled mixing weight during inference to dynamically blend their two predictions, essentially reconciling the differing beliefs of their two uncoupled heads. In SC-Flow, because the consistency loss forces the X-Flow and V-Flow predictions to be mathematically equivalent, we do not need to blend them to resolve disagreements. Instead, our inference strategy is driven entirely by numerical stability. As proven in Section˜5, deriving the velocity from an endpoint predictor involves an unavoidable 1/(1−t)1/(1-t) scaling factor. The transition to the direct V-Flow output at late timesteps (e.g., our switch at τ=0.5τ=0.5) is not a blending heuristic, but a strict numerical intervention required to bypass the asymptotic singularity of X-Flow as the trajectory approaches the data manifold (t→1t→ 1). Appendix A.7 Pseudo-code of SC-Flow Algorithm 1 SC-Flow Training: PyTorch-like Pseudo-code ⬇ class SC-FlowTrainer(n.Module): def __init__(self, model, vae, transport, lr=1e-4, ema_decay=0.9999): super().__init__() self.net = model # single-head, b in 0,1 self.vae = vae.eval() # frozen encoder self.transport = transport # provides path plan, time sampling self.opt = torch.optim.AdamW(self.net.parameters(), lr=lr, weight_decay=0.0) self.ema = copy.deepcopy(self.net).eval() self.ema_decay = ema_decay torch.backends.cuda.matmul.allow_tf32 = True torch.backends.cudnn.allow_tf32 = True @torch.no_grad() def _update_ema(self): for p_ema, p in zip(self.ema.parameters(), self.net.parameters()): p_ema.mul_(self.ema_decay).add_(p, alpha=1.0 - self.ema_decay) def training_step(self, x_img, y, w_v=1.0, w_x=1.0, w_c=0.1, time_weight=False): with torch.no_grad(): z = self.vae.encode(x_img).latent_dist.sample().mul_(0.18215) # (B,4,32,32) # sample t, x0, x1, and path (xt, ut) from transport t, x0, x1 = self.transport.sample(z) # shapes match z t, xt, ut = self.transport.path_sampler.plan(t, x0, x1) b0 = torch.zeros(xt.size(0), device=xt.device, dtype=torch.long) # velocity branch b1 = torch.ones (xt.size(0), device=xt.device, dtype=torch.long) # endpoint branch v_pred = self.net(xt, t, y=y, b=b0) # local motion x1_pred = self.net(xt, t, y=y, b=b1) # global endpoint L_v = ((v_pred - ut) ** 2).mean(dim=(1,2,3)).mean() if time_weight: tw = 0.5 + t.view(-1,1,1,1) L_x1 = (tw * (x1_pred - x1) ** 2).mean(dim=(1,2,3)).mean() else: L_x1 = ((x1_pred - x1) ** 2).mean(dim=(1,2,3)).mean() t_exp = t.view(-1,1,1,1) x1_from_v = xt + (1 - t_exp) * v_pred L_c = ((x1_pred - x1_from_v) ** 2).mean(dim=(1,2,3)).mean() loss = w_v * L_v + w_x * L_x1 + w_c * L_c return loss, ’L_v’: L_v, ’L_x1’: L_x1, ’L_c’: L_c def train_loop(self, loader, epochs, log_every=100): self.net.train() for ep in range(epochs): for i, (x_img, y) in enumerate(loader): x_img, y = x_img.cuda(non_blocking=True), y.cuda(non_blocking=True) loss, logs = self.training_step(x_img, y) self.opt.zero_grad(set_to_none=True) loss.backward() self.opt.step() self._update_ema() if (i + 1) % log_every == 0: _ = (loss.item(), logs[’L_v’].item(), logs[’L_x1’].item(), logs[’L_c’].item()) Algorithm 2 SC-Flow-mix Sampling: PyTorch-like Pseudo-code ⬇ class SC-FlowSampler: def __init__(self, model, vae, transport, cfg_scale=1.0, tau=0.5): self.net = model.eval() self.vae = vae.eval() # frozen decoder (optional for image output) self.transport = transport self.cfg_scale = cfg_scale self.tau = tau # switch between endpoint-induced vs direct motion @torch.no_grad() def _drift(self, x, t, y): if t[0] <= self.tau: b = torch.ones(x.size(0), device=x.device, dtype=torch.long) # endpoint branch x1_pred = self.net(x, t, y=y, b=b) t_safe = torch.clamp(1 - t, min=1e-3) v = (x1_pred - x) / path.expand_t_like_x(t_safe, x) # endpoint-induced motion else: b = torch.zeros(x.size(0), device=x.device, dtype=torch.long) # velocity branch v = self.net(x, t, y=y, b=b) return v @torch.no_grad() def _drift_cfg(self, x, t, y): if self.cfg_scale <= 1.0: return self._drift(x, t, y) half = x[: len(x)//2] xin = torch.cat([half, half], dim=0) vin = self._drift(xin, t, y) eps, rest = vin[:, :3], vin[:, 3:] cond, uncond = torch.chunk(eps, 2, dim=0) guided = torch.cat([uncond + self.cfg_scale * (cond - uncond)]*2, dim=0) return torch.cat([guided, rest], dim=1) @torch.no_grad() def sample(self, B, y, steps=250, method=’euler’): z = torch.randn(B, 4, 32, 32, device=y.device) t0, t1 = self.transport.check_interval(self.transport.train_eps, self.transport.sample_eps, sde=False, eval=True) if method == ’euler’: dt = (t1 - t0) / steps for k in range(steps): t_scalar = t0 + k * dt t = torch.full((B,), t_scalar, device=z.device) v = self._drift_cfg(z, t, y) z = z + v * dt else: solver = ODESolver(self._drift_cfg, t0=t0, t1=t1, steps=steps) # placeholder z = solver.integrate(z, y) x = self.vae.decode(z / 0.18215) # optional decode return x, z Appendix A.8 Additional Visual Results for CIFAR-10 Figure 9: Samples for CIFAR-10. Appendix A.9 Additional Visual Results for Imagenet All samples are from SC-Flow-mix-XL, with cfg=4.0. Figure 10: Samples for ImageNet class 88 (macaw). Figure 11: Samples for ImageNet class 207 (golden retriever). Figure 12: Samples for ImageNet class 980 (volcano). Figure 13: Samples for ImageNet class 279 (arctic fox). Figure 14: Samples for ImageNet class 33 (loggerhead turtle). Figure 15: Samples for ImageNet class 417 (balloon). Figure 16: Samples for ImageNet class 387 (red panda). Figure 17: Samples for ImageNet class 974 (geyser).