{"id":"083b4f49-0494-468b-9985-c37b8ea10d9a","arxiv_id":"2506.02221","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"A reparameterization recipe that lets pre-trained Stable Diffusion checkpoints be finetuned as flow matching models, giving faster convergence and better performance under parameter-efficient constraints.","lead":"Diff2Flow converts a pre-trained diffusion model into a flow matching model by rescaling timesteps, aligning interpolants, and converting the model's v-prediction into a velocity. The method aims to make flow matching finetuning of large diffusion priors efficient, especially with LoRA.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Equation (16) is algebraically wrong: solving Eq. (8) and Eq. (14) gives FM velocity (α−σ)x − (α+σ)v, not (α−σ)(x−v); at α=σ the printed target is identically zero, so the central alignment mechanism cannot be as stated.","rationale":"The reader's weakest_assumption identifies exactly the same load-bearing flaw, and my independent re-derivation confirms it: Eq. (15) has the wrong inverse for x̂T and Eq. (16) has the wrong velocity formula, with an error of 2σv that is zero only at t = 0. This conversion is not an auxiliary detail; it is the entire bridge between the diffusion prior and the FM objective, used in both training and inference. A concrete consequence is that at the midpoint timestep (α = σ), the printed target and gradient vanish for every sample, which is clearly incompatible with a valid FM velocity field. Because no code is provided and no formal verification is present, the printed equations are the only specification of the method, and they are internally inconsistent. The empirical sections are extensive and I do not question the authors' effort or the possibility that a corrected variant of the recipe works; however, as written, the central derivation does not hold. The appropriate disposition is therefore conditional acceptance: the authors must correct Eqs. (15)–(16), show the corrected derivation, and verify that the released implementation matches it. This does not change the reader's verdict, but it sharpens the condition.","tokens_in":16497,"tokens_out":8239,"duration_ms":83617,"concrete_test":"Independently solve the linear system from Eq. (8) and Eq. (14) for x̂0 and x̂T, then evaluate both formulas at α = σ = 1/√2 with x0 = (1, 0) and ε = (0, 1): the paper's Eq. (16) returns (0, 0) while the correct velocity returns (1, −1). Also inspect the released Diff2Flow code: if Algorithm 1 or 2 uses Eq. (16) verbatim, the results in Tables 1–3 cannot validate the claimed mechanism; if the code uses the corrected velocity, the equations must be amended accordingly.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The load-bearing step is the velocity conversion in §3.2.2, Eq. (15)–(16), used by Algorithm 1 to build every FM training target and by Algorithm 2 for every sampling step. Combining the interpolant (8), x = αx0 + σxT, with the v-parameterization (3)/(14), v = αxT − σx0, gives a 2×2 linear system whose inverse is x̂0 = αx − σv and x̂T = σx + αv. The paper's second line of Eq. (15) instead states x̂T = αv − σx, and Eq. (16) then claims v_FM = (α − σ)(x − v). The correct velocity is x̂0 − x̂T = (α − σ)x − (α + σ)v, which differs from the printed formula by 2σv. This is not a harmless rescaling: at any timestep with α = σ (SNR = 1), the printed velocity collapses to zero for every sample, while the correct velocity equals x0 − ε; the two expressions even have different t-dependence. Since every experiment—text-to-image, reflow, and depth—uses this conversion as its training/sampling objective, the core claim that Diff2Flow 'derives FM-compatible velocity fields' is false as written. If the released code implements Eq. (16) verbatim, the reported gains cannot be attributed to the claimed alignment; if the code uses a corrected formula, the paper must state that and supply the code. No code is provided to disambiguate.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes Diff2Flow, a method to convert a pre-trained diffusion model into a flow matching model by (i) rescaling timesteps via the signal-to-noise ratio, (ii) rescaling interpolants, and (iii) converting the diffusion model's v-prediction into an FM velocity estimate. The method is applied to text-to-image fine-tuning at a different resolution, to trajectory rectification (reflow) enabling 2-step generation, and to monocular depth estimation with PEFT (LoRA). The experimental results show faster convergence than naive FM fine-tuning and better performance than diffusion fine-tuning, especially under LoRA constraints.","tokens_in":16877,"tokens_out":9790,"duration_ms":78230,"significance":"The general goal of reusing established Stable Diffusion checkpoints for flow matching is timely and practically important. The paper contains extensive experiments across three tasks, including a reflow variant and depth estimation, and the observation that alignment-aware fine-tuning helps under parameter constraints is interesting. However, the central algebraic derivation of the velocity conversion in Eq. (16) is incorrect, which invalidates the method as described. The paper does not provide code to disambiguate whether the experiments used the printed formula or a corrected variant. If the derivation is fixed and the code confirms the corrected formula, the approach could be a valuable contribution; as written, the core claim is not supported.","major_comments":[{"comment":"The velocity conversion is algebraically incorrect. Solving Eq. (8) and Eq. (14) for the clean and noise estimates gives x̂0 = (α x − σ v)/(α² + σ²) and x̂T = (σ x + α v)/(α² + σ²); the printed second line of Eq. (15), x̂T = α v − σ x, is therefore wrong, and the FM velocity x̂0 − x̂T equals (α − σ)x − (α + σ)v (for α² + σ² = 1), not (α − σ)(x − v) as in Eq. (16). This error changes the training target in Algorithm 1 and the sampling update in Algorithm 2; at α = σ the printed target is identically zero, which cannot produce a valid flow. Please provide the corrected formula and clarify whether the experiments were run with the printed formula or a corrected one, and make the code available to disambiguate.","section":"§3.2.2, Eqs. (15)–(16)"},{"comment":"The derivation implicitly assumes the variance-preserving condition α² + σ² = 1, but the paper also claims applicability to variance-exploding schedules (line after Eq. (8)) where α = 1 and σ varies. For VE schedules the inversion must divide by α² + σ² = 1 + σ²; as written, the formulas (even with corrected signs) would be wrong. Please either restrict the method to VP schedules or provide the general expressions.","section":"§3.2.2, Eqs. (15)–(16)"},{"comment":"The paper reports extensive experimental results but provides no code or model weights, and the algebraic error in Eq. (16) makes it impossible for a reader to determine whether the reported gains are due to the claimed alignment or to a different (possibly corrected) implementation. Given that the central formula is load-bearing, the authors should release the training and inference code, or at least specify the exact velocity conversion used in each experiment.","section":"§4 and Appendix A"}],"minor_comments":[{"comment":"The notation dxDM_0 and dxDM_T with hats is confusing; I recommend using \\hat{x}_0 and \\hat{x}_T to denote the estimated clean and noise samples.","section":"Eq. (15)"},{"comment":"The caption states that non-integer-shifted DDIM timesteps produce high-quality images, but does not mention which model and schedule were used; please add this information.","section":"Figure 2"},{"comment":"The CLIP scores of Diff2Flow at 25 steps are lower than SDv1.5+DPM Solver; the text describes the results as 'competitive' but this gap deserves a discussion, especially since FID is better.","section":"Table 3"},{"comment":"The claim that Diff2Flow solves the zero-terminal SNR issue is supported only by qualitative examples in Fig. 4; please consider adding a quantitative metric (e.g., average luminance of generated white/black images) to substantiate the claim.","section":"§4.1"},{"comment":"Minor typos: 'na¨ıve' should be 'naïve' (or 'naive') in the abstract and elsewhere; 'contrain' in §3.3 should be 'constrain'.","section":"Abstract and §3.3"}],"recommendation":"major_revision","confidential_remarks":"The paper addresses a timely and practically important problem, and the experimental effort is substantial. However, the algebraic error in Eq. (16) is central and must be corrected before the paper can be considered for publication. The lack of code is particularly problematic here, because the reader cannot tell whether the experiments implement the described method or a corrected variant. I recommend requiring the authors to provide the code and to re-derive the velocity conversion carefully."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Here's the short version: this is a genuinely useful paper with a load-bearing typo. The Diff2Flow recipe – rescale timesteps with ft, rescale the interpolant with fx, then convert the v-prediction to a flow matching velocity – is a practical, low-cost way to turn Stable Diffusion checkpoints into flow matching models. The experiments are broad and mostly convincing: faster convergence than naive FM finetuning, better LoRA results, 2/4-step reflow generation, and strong depth estimation. That is worth a serious referee even with the caveats below.\n\nWhat is actually new is the specific combination of the ft/fx mappings plus the objective conversion, and the systematic evaluation. It extends prior conversion work (Lee et al., DepthFM, PeRFlow), but the piecewise-linear timestep mapping and the boundary-condition alignment are clean ideas. The paper does not oversell; the claims match the presented numbers, and the depth results are competitive.\n\nThe soft spot is not minor. Section 3.2.2 has an algebraic error in the central conversion. From x = αx0 + σxT and v = αxT - σx0, solving gives x0_hat = αx - σv and xT_hat = σx + αv. The paper writes xT_hat = αv - σx, and then v_FM = (α-σ)(x-v). The correct velocity is x0_hat - xT_hat = (α-σ)x - (α+σ)v. The difference is 2σv, and at α=σ the printed target is zero for every input. Since the experiments do work, the most plausible explanation is that the implemented code uses the correct algebra and the paper has a sign typo. But that is only plausible, not verifiable, because the authors say they will release code but do not provide it.\n\nThe rest of the paper holds up. The timestep interpolation at non-integer tDM is plausible and supported by Figure 2. The reflow experiments are a sensible extension. The self-citation to DepthFM for baseline numbers is standard. My main request to the reviewers is to force a corrected derivation and the code. If the code matches the corrected formula, this is a well-executed engineering paper that the community will use. If it matches the printed formula, the results need a different explanation.\n\nFor peer review: yes, send it. The error is central but fixable, and the empirical contribution is solid enough to warrant referee time.","headline":"Solid practical recipe for converting diffusion priors to flow matching, but the printed velocity conversion is algebraically wrong; the experiments suggest the code is right and the paper is wrong, so it needs a correction before acceptance.","tokens_in":17403,"tokens_out":2879,"would_cite":true,"duration_ms":25010,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper claims that a pre-trained diffusion model can be directly fine-tuned as a flow matching model by rescaling timesteps, aligning interpolants, and converting v-predictions into velocities, yielding faster convergence and better…","keywords":["diffusion models","flow matching","fine-tuning","LoRA","parameter-efficient fine-tuning","generative modeling","monocular depth estimation","reflow"],"falsifier":"The decisive check is algebraic: substitute the v-parameterization into the diffusion interpolant (Eqs. (3) and (8)) and solve for the estimated noise and data, then form the velocity $\\hat{x}_0 - \\hat{x}_T$ and compare with Eq. (16). A direct substitution gives $\\hat{x}_T = \\sigma x_t + \\alpha v_\\theta$ (not $\\alpha v_\\theta - \\sigma x_t$), so the implied velocity is $(\\alpha-\\sigma)x_t - (\\alpha+\\sigma)v_\\theta$ rather than $(\\alpha-\\sigma)(x_t - v_\\theta)$; checking the released code against the printed equation settles whether the objective is the one the paper describes.","tokens_in":16291,"feed_emoji":"🖼️","tokens_out":8838,"duration_ms":86201,"temperature":0.7,"pith_summary":"This paper tries to establish that the knowledge in a pre-trained diffusion model can be transferred to a flow matching model without retraining from scratch, by aligning the two paradigms' timesteps, interpolants, and prediction targets. If true, this would make flow matching's faster inference and straighter sampling trajectories available to the large installed base of diffusion checkpoints, while keeping training budgets small enough for parameter-efficient fine-tuning. The paper shows results on text-to-image synthesis, resolution change, reflow-based fast sampling, and monocular depth estimation, where the aligned objective converges faster than naively applying the flow matching loss and often beats continued diffusion training. The central move is to treat the diffusion trajectory and the flow matching trajectory as two coordinate systems on the same generative path, connected by invertible maps.","feed_headline":"Diff2Flow rewires diffusion models for fast flow matching training","feed_subtitle":"The same weights predict flow velocities, enabling faster sampling and cheaper fine-tuning.","key_machinery":"The load-bearing object is the pair of invertible trajectory maps $(f_t, f_x)$ together with the velocity conversion formula. The timestep map $f_t$ sends the discrete diffusion timestep to the continuous flow matching time via the ratio $\\alpha/(\\alpha+\\sigma)$, and the interpolant map $f_x$ rescales the diffusion sample by $1/(\\alpha+\\sigma)$ so the boundary points (clean data and noise) coincide. The velocity conversion takes the diffusion model's $v$-prediction, which mixes noise and data, and re-expresses it as the flow-matching velocity field, so the network does not have to unlearn its output parameterization. This is what carries the argument: it removes the 'unlearning' cost that makes naive FM fine-tuning slow and that breaks down under parameter-efficient fine-tuning.","core_discovery":"The central claim is that a v-parameterized diffusion model can be reused as a flow matching model by applying three coordinate changes: rescale the diffusion timestep by $f_t(\\cdot)=\\alpha/(\\alpha+\\sigma)$, rescale the noisy-sample interpolant by $f_x(\\cdot)=x/(\\alpha+\\sigma)$, and convert the model's $v$-prediction into a velocity via the relation the paper derives as Eq. (16). With these changes, the standard flow matching loss $L_{\\mathrm{FM}}$ is applied directly to the pre-trained diffusion network, with the inverse maps used during sampling to run Euler steps on the flow matching path. The paper reports that this alignment accelerates convergence relative to naive FM fine-tuning, that the advantage grows under LoRA-style parameter constraints, and that it extends to reflow training for low-step generation and to monocular depth estimation.","pith_inferences":["Editorial extension: because the maps are bidirectional and require no extra parameters, the same conversion could be applied at inference time as a training-free wrapper, turning any off-the-shelf v-prediction diffusion checkpoint into a flow-style sampler; the paper presents the maps as part of fine-tuning, not as a standalone sampling trick.","Editorial extension: the paper's observation that non-integer diffusion timesteps with linearly interpolated noise schedules still produce high-quality images suggests diffusion timestep embeddings are effectively continuous; if that holds broadly, continuous-time diffusion sampling and schedule interpolation could be pushed further than the discrete training grid.","Editorial extension: the derivation is written for v-parameterization but the paper states it extends to epsilon-parameterization; if the same reasoning carries over, nearly any diffusion backbone could be converted to flow matching, which would broaden the transfer beyond image generation to video, audio, and dense prediction."],"forward_implications":["Directly fine-tuning a pre-trained diffusion model with the flow matching loss, without the proposed alignment, converges more slowly; with the alignment, competitive results appear in as few as 2.5k iterations in the paper's text-to-image experiments.","The alignment removes the zero-terminal-SNR artifact: the model can generate true black and white regions instead of gray, which the paper attributes to the rectified trajectories.","Reflow training becomes applicable to a diffusion prior: after one rectification pass, Stable Diffusion generates images with as few as 2-4 sampling steps without consistency distillation, using only a small fraction of tunable parameters.","For monocular depth estimation, the same recipe matches or improves on prior generative depth predictors with fewer training iterations, and LoRA with roughly a quarter of the parameters remains competitive with full fine-tuning.","Parameter-efficient fine-tuning with LoRA works when the alignment is used, but fails when the diffusion model is trained with a raw flow matching objective, because the model must learn an entirely new output parameterization."],"supporting_citations":[{"why":"Defines the flow matching objective and linear interpolant that Diff2Flow trains against.","marker":"[30]"},{"why":"Defines the diffusion forward process and noise-prediction loss the diffusion prior was trained with.","marker":"[19]"},{"why":"Defines the v-parameterization whose prediction Eq. (16) converts into a velocity.","marker":"[49]"},{"why":"Introduces Reflow, which Diff2Flow applies to straighten sampling trajectories.","marker":"[32]"},{"why":"Shows a prior diffusion-to-flow matching inheritance for depth estimation that Diff2Flow improves on.","marker":"[14]"},{"why":"Provides the diffusion-based depth estimation baseline that Diff2Flow compares against.","marker":"[24]"}],"fun_headline_variants":["Diff2Flow: Reuse diffusion weights for fast flow matching","Turn diffusion models into flow matching with Diff2Flow","Diff2Flow aligns diffusion and flow matching for efficient fine-tuning","Diff2Flow: Fast flow matching from pre-trained diffusion models"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The whole training target rests on Eq. (16), the formula that converts the diffusion model's v-prediction into a flow-matching velocity; if that conversion is algebraically wrong under the paper's own definitions, the fine-tuned model is trained to predict the wrong velocity.","fun_headline_variants_meta":{"raw":{"variants":["Diff2Flow: Reuse diffusion weights for fast flow matching","Turn diffusion models into flow matching with Diff2Flow","Diff2Flow aligns diffusion and flow matching for efficient fine-tuning","Diff2Flow: Fast flow matching from pre-trained diffusion models"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000294,"raw_usage":{"total_tokens":1676,"prompt_tokens":877,"completion_tokens":799,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":493,"completion_tokens_details":{"reasoning_tokens":730}},"tokens_in":493,"tokens_out":799,"duration_ms":7614,"temperature":1.0,"reasoning_tokens":730,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-07T11:28:47.896897+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"The decisive check is algebraic: substitute the v-parameterization into the diffusion interpolant (Eqs. (3) and (8)) and solve for the estimated noise and data, then form the velocity $\\hat{x}_0 - \\hat{x}_T$ and compare with Eq. (16). A direct substitution gives $\\hat{x}_T = \\sigma x_t + \\alpha v_\\theta$ (not $\\alpha v_\\theta - \\sigma x_t$), so the implied velocity is $(\\alpha-\\sigma)x_t - (\\alpha+\\sigma)v_\\theta$ rather than $(\\alpha-\\sigma)(x_t - v_\\theta)$; checking the released code against the printed equation settles whether the objective is the one the paper describes.","supporting_citations":[{"cited_title":"Denoising dif- fusion probabilistic models","cited_arxiv_id":null,"evidence_quote":"Defines the diffusion forward process and noise-prediction loss the diffusion prior was trained with."},{"cited_title":"Depthfm: Fast monocular depth estimation with flow matching","cited_arxiv_id":null,"evidence_quote":"Shows a prior diffusion-to-flow matching inheritance for depth estimation that Diff2Flow improves on."},{"cited_title":"Repurpos- ing diffusion-based image generators for monocular depth estimation","cited_arxiv_id":null,"evidence_quote":"Provides the diffusion-based depth estimation baseline that Diff2Flow compares against."}],"review_version":1}