acceptodds
Under review as a conference paper at ICLR 2027

PathSpeed: Accelerating Structural Recovery in Flow Matching

Abstract

Learning a generative distribution requires recovering its modes, connected components, and loops. We study how training-time sampling can accelerate this recovery in flow matching. PathSpeed measures the motion of path marginals before velocity training and uses it to construct a fixed training-time distribution. We estimate squared path speed from adjacent marginal samples, then smooth and standardize the estimates. We show that this finite-difference measurement splits exactly into changes in projected means and scales and changes in standardized shape. In the continuous limit, squared path speed measures the energy of the conditional-average motion that transports the projected marginals. Integrated speed bounds changes in persistence diagrams at a fixed observation scale. On controlled distributions, PathSpeed reaches the final structural error of uniform time sampling (Uniform) with 33–49% fewer updates and achieves lower final errors. Ablations show that shape information and the placement of sampling probabilities along time both contribute. On CIFAR-10 and class-conditional latent ImageNet-256, PathSpeed obtains the lowest mean FID among the compared schedules and reaches Uniform's final FID with 42% and 52% fewer updates, respectively. The cached distribution adds no velocity-network forward or backward pass during training.

Primary area:
generative models
Keywords:
flow matching, training efficiency, time sampling, structural recovery, generative modeling

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_gWqGOpenReview ↗
Rating
3
Confidence
4
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes PathSpeed, an offline training-time sampler for flow matching that allocates timestep probability according to the estimated motion of the prescribed probability-path marginals.

The method estimates squared sliced-Wasserstein path speed from adjacent marginal samples, smooths and standardizes this profile, and converts it into a fixed sampling distribution used throughout training. The paper provides three main analytical results: an exact finite-difference decomposition of squared path speed into projected mean/scale and standardized-shape components; a continuous interpretation of squared speed as the energy of conditional-average projected motion; and a bound relating integrated path speed to changes in persistence diagrams at a fixed observation scale.

Empirically, the method is evaluated on controlled multimodal/topological distributions, COIL-100, CIFAR-10, and class-conditional ImageNet-256. PathSpeed improves structural recovery on the controlled tasks, gives strong gains over Uniform and several alternative timestep schedules on CIFAR-10, and obtains the best reported mean FID among the tested schedules on ImageNet-256. Ablations examine the shape component, probability placement across time, smoothing, calibration, and compression of the learned distribution.

Critical strengths
  1. The paper provides a principled and interpretable signal for timestep allocation. Rather than adapting to the model's current loss, PathSpeed measures a property of the prescribed probability path before training. The moment/shape decomposition and continuous conditional-average-motion interpretation make the construction substantially more informative than a purely heuristic schedule.

  2. The controlled experiments and ablations are strong. The structural benchmarks are well matched to the paper's motivation, and the permutation/negation controls are particularly convincing: preserving the same sampling probabilities but assigning them to different times removes the gain. The CIFAR-10 result is also substantial, with PathSpeed clearly outperforming Uniform, fixed schedules, Loss-CDF, and InfoNoise while requiring no additional velocity-network evaluation during training.

Critical weaknesses
  1. The comparison to recent adaptive allocation methods is incomplete. The related-work section identifies cDOL as a closely related method that combines an irreducible-loss reference, calibrated weighting, and remaining-gap sampling, but cDOL is not included in the experimental comparison. Since the paper's main empirical claim concerns improved training-time allocation, comparison against this recent method would materially affect my assessment of the practical contribution.

  2. The large-scale ImageNet advantage is modest and somewhat representation-dependent. PathSpeed obtains mean FID 27.40 versus 27.95 for InfoNoise with standard deviations 0.65 and 0.68 over three runs. This establishes competitive performance but does not, by itself, provide strong statistical evidence of superiority. Moreover, the ImageNet PathSpeed profile is constructed in decoded Inception-feature space, while FID and several other reported diagnostics also rely on feature-space geometry. I would like to understand how sensitive the result is to this representation choice.

A related conceptual limitation is that the theory explains what squared path speed measures and why structural change requires marginal motion, but it does not establish that sampling proportionally to the proposed calibrated speed profile is optimal for finite-budget optimization. I view the theoretical results as principled motivation rather than a convergence guarantee.

Questions for authors
  1. Comparison to cDOL: The paper discusses cDOL as a recent data/model-dependent training allocation method but does not compare against it experimentally. Can the authors provide a matched comparison on CIFAR-10, and ideally ImageNet-256? This would materially affect my assessment of the empirical novelty.

  2. Representation dependence: How sensitive is the ImageNet-256 result to the representation ϕ\phi used to estimate path speed? In particular, do similar gains hold when the schedule is constructed directly in latent space or using a feature encoder different from the Inception representation used by common image-generation metrics?

  3. ImageNet uncertainty: The mean ImageNet FID improvement over InfoNoise is 27.95 to 27.40, while the reported run-to-run standard deviations are approximately 0.68 and 0.65. Are the runs paired by seed, and if so, what is the paired difference or confidence interval? This would help determine whether the large-scale gain is consistent across runs rather than primarily a difference in means.

  4. Allocation principle: Proposition 3 gives an entropy-regularized variational interpretation of the softmax calibration, but the objective being optimized is not directly a training-convergence objective. Is there a stronger connection between squared path speed and an optimal finite-budget sampling distribution, for example through gradient variance, approximation error, or convergence rate? I view this as a clarification of the theoretical interpretation rather than a requirement for the method to be valid.

3 comments

Thank you for recognizing the interpretability of the path-derived signal and the strength of the structural experiments. We provide new results below on the cDOL comparison, representation dependence, paired ImageNet performance, and the relationship between path speed and approximation error.

1. Comparison with the full method of cDOL and transfer to DDPM++/EDM (W1, Q1)

We independently implemented the full method of cDOL, including optimal-loss estimation, calibrated loss weighting, and adaptive sampling. However, in our original TorchCFM setting, this implementation obtained FID-50K 90.53 at 100k updates. That configuration differs from the published cDOL experiments in architecture, training exposure, and inference protocol. We therefore conducted an additional comparison in the DDPM++/EDM framework used by Xu et al.

We applied PathSpeed's core allocation method to this framework and obtained FID-50K 2.14 after 100k updates. We measure changes between adjacent path marginals and cache a fixed training-time distribution before velocity training.

Both methods use the same DDPM++ network, optimizer configuration, batch size of 512, bf16 precision, and deterministic EDM Heun sampler with 35 network evaluations. Training lasts 100k updates, corresponding to 51.2 million training-image presentations. The cDOL implementation uses its calibrated loss weighting and adaptive sampler.

Fixed-budget quality: FID-50K

The table reports every scheduled FID-50K checkpoint. Each method has one training run, and all entries use the same generation and evaluation protocol.

Training updatesTraining-image presentationscDOL ↓\downarrowPathSpeed ↓\downarrow
25k12.8M11.663.92
50k25.6M8.332.61
75k38.4M7.842.33
100k51.2M7.432.14

PathSpeed gives lower FID at every evaluated checkpoint. At 100k updates, FID is 2.14 versus 7.43, a 71% reduction in this matched comparison. At just 25k updates, its FID of 3.92 already improves on our cDOL implementation's 100k result.

Earlier quality attainment: FID-10K monitoring

We additionally evaluated smaller generated sets throughout training to observe the early learning trajectory. The following values are all FID-10K and are kept separate from the FID-50K results above.

Training updatescDOL ↓\downarrowPathSpeed ↓\downarrow
4.9k142.1022.50
9.8k22.9012.80
14.7k19.009.40
19.6k16.107.28
25k13.906.00
50k10.604.66
75k9.894.39
100k9.434.18

On this monitoring metric, PathSpeed reaches FID-10K 9.40 at 14.7k updates, already below the 9.43 obtained by our cDOL implementation at 100k. The advantage appears early and persists as both models continue improving.

Our cDOL implementation has not recovered the published performance. Its final schedule assigns 32.9% of the probability mass to log⁡σ<−4\log\sigma < -4; reproducing the authors' allocation in this low-noise region remains unresolved. We therefore identify the comparison throughout as our independent implementation of cDOL.

Quality and training exposure in the published setting

For context, Xu et al. report the following unconditional CIFAR-10 results using 200 million training-image presentations. Their results use the best-checkpoint protocol; our result below is the fixed 100k-update checkpoint.

Source and methodTraining-image presentationsFID-50K ↓\downarrow
Xu et al.: FM + EDM sampler200M2.24
Xu et al.: FM + cDOL-based schedule200M2.03
PathSpeed in DDPM++/EDM51.2M2.14

Applying PathSpeed's core method reaches the quality range of the published FM results using 25.6% of their training exposure. This additional experiment extends the evidence for offline path-aware allocation to a different architecture and training pipeline, with rapid early improvement and continued gains through the final checkpoint.

2. Representation Independence on ImageNet-256 (W2, Q2)

Replacing Inception with DINOv2 preserves the benefit of path-derived allocation. We recomputed the time distribution using frozen DINOv2 ViT-B/14 features and trained under the same class-conditional SiT-B/2 protocol. All results below use 400k updates, no CFG, and Inception-based FID-50K evaluation (mean ±\pm SD over three training seeds):

MethodFeatures used to construct the scheduleFID-50K ↓\downarrow
Uniform—33.20 ±\pm 0.65
InfoNoise—27.95 ±\pm 0.68
PathSpeedDINOv227.62 ±\pm 0.63
PathSpeedInception27.40 ±\pm 0.65

The DINOv2 construction reaches 27.6227.62 FID, retaining 96% of the FID reduction over Uniform (27.6227.62 vs. 27.4027.40, a difference of 0.220.22 FID) and maintaining a lower mean FID than InfoNoise. This experiment separates the encoder used to construct the time distribution from the encoder used for FID.

The improvement also persists throughout training: at 200k updates, the DINOv2 and Inception constructions obtain 32.38±0.6432.38 \pm 0.64 and 32.04±0.5932.04 \pm 0.59, respectively, compared with 39.48±0.6139.48 \pm 0.61 for Uniform and 33.61±0.8333.61 \pm 0.83 for InfoNoise (full 100k–400k progression in our response to Reviewer jcKC, Section 1).

By construction, feature extraction occurs only during the one-time precomputation, and velocity training subsequently uses only the cached 64-bin time distribution. We did not test a latent-identity construction on ImageNet-256 within the discussion period. On CIFAR-10, the default schedule is constructed directly in raw pixels (ϕ=id\phi = \text{id}), with no feature encoder, and reduces FID from 5.925.92 (InfoNoise) to 4.614.61.

3. Paired ImageNet-256 Runs and Scope of the Gain (W2, Q3)

Yes, the ImageNet-256 runs are paired by training seed. Their individual 400k-update FIDs and interpolated update counts to reach Uniform's final mean FID threshold (33.20) are:

Paired runInfoNoise FID ↓\downarrowPathSpeed FID ↓\downarrowInfoNoise updates to threshold ↓\downarrowPathSpeed updates to threshold ↓\downarrow
A28.4927.61223k (0.56)193k (0.48)
B27.1926.67197k (0.49)188k (0.47)
C28.1727.92213k (0.53)196k (0.49)

PathSpeed obtains a lower final FID and reaches the threshold earlier in all three paired runs. The per-seed FID differences (PathSpeed minus InfoNoise) are −0.88-0.88, −0.52-0.52, and −0.25-0.25, with a mean paired difference of −0.55-0.55 FID (SD 0.320.32; 95% paired-tt CI [−1.34,+0.24][-1.34, +0.24], n=3n = 3). Because the three-seed interval includes zero, we describe this as competitive ImageNet performance with a consistent direction across runs rather than a statistically conclusive final-FID separation from InfoNoise. In addition, the paired runs reach the 33.20 threshold 30k, 9k, and 17k updates earlier (193k, 188k, and 196k for PathSpeed vs. 223k, 197k, and 213k for InfoNoise).

ImageNet-256 tests whether the allocation stays competitive when the useful time distribution is smooth; there PathSpeed matches the strongest online schedule without online tracking. The paper's main claim concerns structural recovery, where the effect is large: on controlled distributions, whose structural errors are computed directly in data space, PathSpeed reaches Uniform's final error with 33–49% fewer updates and lowers the 2rings loop error from 0.0150.015 to 0.0010.001 (Table 1).

4. Connection to Reducible Training Error and Structural Recovery (W3, Q4)

We agree with your interpretation of Proposition 3 as a principled characterization of the calibrated allocation. Its guarantee concerns the stated entropy-regularized objective; we do not have a result that establishes optimality or a convergence rate for training. The connection to finite-budget learning is supported by the conditional-average-motion interpretation and the following measurements.

On Gaussian25, the known mixture distribution allows us to evaluate the conditional-mean velocity vt⋆(x)=E[Ut∣Xt=x]v_t^\star(x) = \mathbb{E}[U_t \mid X_t = x] and decompose the regression loss across time bins:

ℓθ(t)=eθ(t)+r⋆(t),eθ(t)=E[∥vθ(Xt,t)−vt⋆(Xt)∥2],r⋆(t)=E[∥Ut−vt⋆(Xt)∥2],\ell_\theta(t) = e_\theta(t) + r^\star(t), \quad e_\theta(t) = \mathbb{E}\big[\|v_\theta(X_t,t) - v_t^\star(X_t)\|^2\big], \quad r^\star(t) = \mathbb{E}\big[\|U_t - v_t^\star(X_t)\|^2\big],

where eθ(t)e_\theta(t) is learnable approximation error and r⋆(t)r^\star(t) is irreducible pairing variance. Measured at saved checkpoints from Uniform training:

Correlation with path speed across time1k updates3.5k updates10k updates
Total velocity MSE ℓθ(t)\ell_\theta(t)-0.99-0.97-0.97
Approximation error eθ(t)e_\theta(t)0.790.590.25
Pairing variance r⋆(t)r^\star(t)-0.99-0.99-0.99

Path speed is positively associated with the model's early approximation error (0.790.79 at 1k updates). This association weakens as training proceeds (0.59,0.250.59, 0.25). Total MSE remains strongly anticorrelated with speed (−0.99-0.99 to −0.97-0.97) because it is dominated by the pairing variance r⋆(t)r^\star(t), whose profile is fixed by the data and path. These measurements connect the offline signal to the error component that learning can reduce.

The structural controls test how this information affects the trained distribution. With representation and calibration held fixed, adding the shape component reduces CIFAR-10 FID by 0.240.24 (4.85→4.614.85 \to 4.61) and reduces the final 2rings loop error tenfold from 0.010±0.0050.010 \pm 0.005 to 0.001±0.0010.001 \pm 0.001 (reaching the threshold in 1,000 updates instead of 1,400), while permuting the same probabilities across time removes the benefit (Table 3). Relative to InfoNoise on CIFAR-10, Recall also increases from 0.6550.655 to 0.6720.672 and H0H_0 discrepancy decreases from 1.161.16 to 1.081.08 (Table 2). We have added these new experimental results and analyses to Appendix I in the revised version.

Reviewer_jcKCOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper reveals that uniform time sampling in flow matching ignores uneven marginal motion, leading to slow recovery of distributional structures. To optimize training update allocation, the authors propose PathSpeed, a novel offline sampler that constructs a fixed time distribution based on the energy of projected marginal motion measured via Sliced-Wasserstein distances. This method systematically accelerates structural recovery without introducing extra forward/backward pass overhead during velocity training, with experiments confirming their findings.

Critical strengths

(1) Good presentation with extensive experiments

(2) Amazing experimental results.

Critical weaknesses

(1) Potential feature bias in evaluation. For experiment regarding ImageNet-256, PathSpeed constructs its offline time-sampling distribution through a frozen Inception net. However, the core evaluation metric for ImageNet is FID, which relies directly on Inception features, leading to the concern of potential information leakage. The authors are encouraged to perform experiments with other visual features.

(2) Evaluation at late-stage stability. While Fig. 3 provides excellent step-by-step convergence curves for synthesized datasets, it is better to report FID of latter training steps on ImageNet-256. These additional results demonstrate that non-uniform time scheduling does not induce late-stage performance degradation [a,b]. Could the authors include an explicit learning curve or discrete FID metrics at standard intermediate checkpoints (e.g., 100k, 200k, and 300k steps) for ImageNet-256 during the rebuttal?

(3) The authors adopt a fixed setting of L=64L=64 for Sliced-Wasserstein speed estimation across all benchmarks. Although L=64L=64 is a standard empirical value for lower-dimensional data, the ImageNet-256 benchmark operates in a 2048-dimensional Inception feature space. It would be insightful if the authors could provide a sensitivity analysis showing whether increasing LL (e.g., L=128L=128) leads to better FID scores.

Minor: The authors could introduce the evaluation metrics in detail as some metrics (e.g., Geometry Score) is not commonly used for image quality assessment.

Ref:

[a] Noise Scheduling as Information-Guided Allocation in Diffusion Training. In ICML Workshop'26.

[b] SiT: Exploring flow and diffusion-based generative models with scalable interpolant transformers. In ECCV'24.

Questions for authors

Please refer to "Critical Weaknesses"

3 comments

Thank you for your positive assessment of the paper's presentation and experimental results.

1. Schedule Construction Without Inception Features (W1)

To test whether constructing the ImageNet-256 schedule with Inception features biases evaluation toward Inception-based FID, we reconstructed the offline PathSpeed time distribution on ImageNet-256 using frozen DINOv2 ViT-B/14 features (ϕ(zt)=DINOv2(Decode(zt/0.18215))\phi(z_t) = \text{DINOv2}(\text{Decode}(z_t/0.18215))) and trained class-conditional SiT-B/2 models for 400k updates under the same protocol. The table below reports FID-50K (mean ±\pm SD over 3 seeds; 50,000 generated samples, EMA weights, 250 Euler–Maruyama steps, no CFG at all checkpoints):

Method100k updates200k updates300k updates400k updates
Uniform54.12 ±\pm 0.9439.48 ±\pm 0.6135.07 ±\pm 0.7833.20 ±\pm 0.65
InfoNoise48.63 ±\pm 0.7133.61 ±\pm 0.8328.94 ±\pm 0.6427.95 ±\pm 0.68
PathSpeed (DINOv2)47.35 ±\pm 0.8232.38 ±\pm 0.6428.71 ±\pm 0.6927.62 ±\pm 0.63
PathSpeed (Inception)46.92 ±\pm 0.8932.04 ±\pm 0.5928.53 ±\pm 0.7327.40 ±\pm 0.65

Replacing Inception with DINOv2 for schedule construction retains 96% of the FID reduction over Uniform at 400k updates (27.62±0.6327.62 \pm 0.63 vs. 27.40±0.6527.40 \pm 0.65, a difference of 0.22 FID), while achieving a lower mean FID than InfoNoise at every checkpoint, within seed variation.

By construction, the encoder ϕ\phi is used only during offline precomputation and can influence training only through 64 bin probabilities qpath∈Δ64q_{\text{path}} \in \Delta_{64} estimated from 512 endpoint pairs per time comparison. The velocity network never receives encoder features or gradients during training. In addition, our default CIFAR-10 schedule is constructed directly in raw pixel space (ϕ=id\phi = \text{id}, using no feature encoder) and reduces FID from 7.95 (Uniform) and 5.92 (InfoNoise) to 4.61.

2. Intermediate Checkpoints and Late-Stage Stability on ImageNet-256 (W2)

The checkpoint table above also addresses late-stage stability across 100k, 200k, 300k, and 400k updates:

  • Early threshold crossing: At 200k updates, both PathSpeed–Inception (32.04±0.5932.04 \pm 0.59) and PathSpeed–DINOv2 (32.38±0.6432.38 \pm 0.64) are already below Uniform's final 400k FID (33.20±0.6533.20 \pm 0.65), whereas InfoNoise crosses 33.20 shortly after 200k (33.61±0.8333.61 \pm 0.83), consistent with the interpolated crossing ratios (Rsteps=0.48R_{\text{steps}} = 0.48 and 0.520.52) in Table 2.
  • Sustained relative gain in late training: Both PathSpeed schedules continue to improve between 300k and 400k updates (from 28.53 to 27.40 for Inception, and from 28.71 to 27.62 for DINOv2). PathSpeed's relative FID reduction over Uniform stays between 17% and 19% across the second half of training (19% at 200k, 19% at 300k, and 17% at 400k updates), showing no late-stage degradation.

3. Sensitivity to Projection Count LL in High-Dimensional Spaces (W3)

To test whether L=64L=64 is sufficient in high-dimensional representations, we first measured how increasing LL affects the constructed time distribution in the 2048-dimensional ImageNet-256 Inception feature space. Increasing LL from 64 to 256 and 1024 yields total variation distances of dTV(qL=256,qL=64)=0.0084d_{\text{TV}}(q_{L=256}, q_{L=64}) = 0.0084 and dTV(qL=1024,qL=64)=0.0091d_{\text{TV}}(q_{L=1024}, q_{L=64}) = 0.0091. Training depends on LL only through these 64 probabilities, so an ImageNet-256 model trained with L=1024L = 1024 sees a time distribution that differs from the default in less than 1% of its mass.

We also evaluated downstream training sensitivity to LL in the 3072-dimensional CIFAR-10 pixel space (32×32×332 \times 32 \times 3, which is higher-dimensional than 2048-D Inception features), alongside alternative feature representations at L=64L=64 (using the Seed C initialization and data order, where the default pixel L=64L=64 construction obtains 4.67 FID vs. the 3-seed mean of 4.61±0.124.61 \pm 0.12; for the pixel projection sweep, dTV(qL=256,qL=64)=0.0048d_{\text{TV}}(q_{L=256}, q_{L=64}) = 0.0048 and dTV(qL=1024,qL=64)=0.0053d_{\text{TV}}(q_{L=1024}, q_{L=64}) = 0.0053):

Speed representationProjections LLFID-50K ↓\downarrow
Pixels: default (3-seed mean ±\pm SD)644.61 ±\pm 0.12
Pixels: default (Seed C)644.67
Inception (Seed C)644.56
DINOv2 (Seed C)644.48
Pixels (Seed C)2564.59
Pixels (Seed C)10244.57

Increasing LL from 64 to 256 and 1024 changes the pixel time distribution by ~0.5% in total variation and FID by at most 0.10 on the same seed (4.59 and 4.57 vs. 4.67), indicating that L=64L=64 is sufficient in thousands of dimensions.

4. Clarification of Geometry Score and Structural Metrics

We have expanded the metric descriptions in Section 5 and Appendix D of the revised version. Recall (Kynkäänniemi et al., 2019) is the fraction of reference samples inside the kk-NN support of the generated samples (k=5k=5) and measures coverage. Geometry Score (Khrulkov & Oseledets, 2018) compares loop structure through the mean relative living times of one-dimensional holes in witness complexes. MST-H0H_0 compares sorted minimum-spanning-tree edge lengths (Eq. D.3) and is sensitive to merged or fragmented components. On image benchmarks all three are computed in Inception-v3 feature space. We have also added the new DINOv2 schedule experiments, intermediate checkpoint progression, and projection-sensitivity analysis above to the Appendix in the revised version.

Thanks for the authors' reply. All of my concerns are addressed and I would like to keep my initial rating.

Reviewer_wES7OpenReview ↗
Rating
3
Confidence
1
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes PathSpeed, an offline time sampler for flow matching that allocates training updates according to the estimated motion of path marginals. It estimates squared path speed from adjacent marginal samples, decomposes it into moment and shape components, and uses a smoothed and standardized score to define a fixed training-time distribution. The method is evaluated on controlled structural-recovery tasks and on CIFAR-10 and class-conditional latent ImageNet-256, where the authors report improved structural errors and FID with fewer updates and no extra velocity-network forward or backward passes during training.

Critical strengths
  1. PathSpeed constructs a training-time distribution from the geometry of the target probability path before the velocity model is trained. This connects time allocation to the motion of the marginals, where the quantities being estimated are determined by the data and the prescribed path rather than by the current model's training state.

  2. The offline estimator is directly computable from paired endpoint samples and random projections, and the method is straightforward to combine with existing flow-matching training pipelines, supporting its practical value beyond the controlled settings.

  3. PathSpeed reaches the final Uniform structural-error thresholds with substantially fewer updates on Checkerboard, Gaussian25, and 2rings, and it also obtains lower final errors.

  4. The paper isolates several possible explanations for the improvement. Gaussian-only retains the moment component and obtains FID 4.85, while the full shape-aware allocation improves this to 4.61 and reduces the 2rings error from 0.010 to 0.001. Removing standardization raises CIFAR-10 FID from 4.61 to 14.50, and permuting or negating the time distribution removes most or all of the benefit. These comparisons support the specific claim that both shape information and correct temporal placement are responsible for the gains.

Critical weaknesses
  1. The reported update-reduction statistic provides evidence that PathSpeed reaches Uniform's final ImageNet FID in fewer evaluated updates, but I think that it does not establish robust end-to-end acceleration relative to the strongest baseline or a fixed high-quality target, because the crossing estimate lacks seed-level uncertainty and does not include offline construction or sampler-specific overhead.

  2. I cannot find robustness for KK, Δ\Delta, nn, LL, and the speed representation. I notice that Table 3(a) tests smoothing and standardization, but Table 4 only compares priors on Gaussian25 and does not measure downstream performance. The representation also changes across datasets, from coordinates to pixels to Inception features, without an ablation. I therefore cannot judge how much tuning is required or whether the method transfers reliably to new datasets and architectures.

  3. Proposition 2 shows only that a change in persistent structure requires marginal movement; it does not show that training more often where the marginal moves fastest is more effective under a finite update budget. Appendix C.1 explicitly notes that the conditional minimizer is unchanged by the positive time density qq and that only the time-weighted risk and finite-budget optimization depend on qq, yet the paper does not prove a convergence, variance, or optimization advantage for its particular allocation. Thus, I find that the theoretical contribution does not explain the observed acceleration mechanism.

Questions for authors
  1. Across time bins, how closely does the PathSpeed score correlate with the actual velocity MSE, approximation error, and pairing variance from saved checkpoints (Section 3.1; Appendix A.3 and C.1)? This would show that marginal speed targets the regression tasks that matter.

  2. Does the advantage persist under a substantially larger batch or longer training on Gaussian25 or Checkerboard, given that qq leaves the population minimizer unchanged?

  3. For ImageNet-256, the current mean difference is smaller than the reported standard deviations, can you provide per-seed FID values and per-seed relative update crossings for PathSpeed and InfoNoise?

  4. Can you provide paired per-seed CIFAR-10 results for moment-only and full PathSpeed, and, if feasible, add the same comparison at a reduced ImageNet-256 budget?

2 comments

Thank you for recognizing the connection between path geometry and structural recovery, and the value of the shape and temporal-placement controls.

1. How Path Speed Relates to Learnable Error and Pairing Variance (W3, Q1)

We do not prove a convergence-rate advantage; the measurement below shows which part of the regression loss the allocation follows. On Gaussian25, the ground-truth conditional-mean velocity vt⋆(x)=E[Ut∣Xt=x]v_t^\star(x) = \mathbb{E}[U_t \mid X_t = x] is available analytically from the mixture density, allowing an exact decomposition of the velocity-regression loss across time bins:

ℓθ(t)=eθ(t)+r⋆(t),eθ(t)=E[∥vθ(Xt,t)−vt⋆(Xt)∥2],r⋆(t)=E[∥Ut−vt⋆(Xt)∥2].\ell_\theta(t) = e_\theta(t) + r^\star(t), \quad e_\theta(t) = \mathbb{E}\big[\|v_\theta(X_t,t) - v_t^\star(X_t)\|^2\big], \quad r^\star(t) = \mathbb{E}\big[\|U_t - v_t^\star(X_t)\|^2\big].

Because the pairing variance r⋆(t)r^\star(t) is a property of the target path and does not depend on θ\theta, its cross-time correlation with the PathSpeed profile is fixed at −0.99-0.99. For the model-dependent terms ℓθ(t)\ell_\theta(t) and eθ(t)e_\theta(t), we measured their cross-time correlation with PathSpeed at saved checkpoints from Uniform training:

Correlation across time1k updates3.5k updates10k updates
Path speed vs. total velocity MSE ℓθ(t)\ell_\theta(t)-0.99-0.97-0.97
Path speed vs. approximation error eθ(t)e_\theta(t)0.790.590.25

The offline path speed is positively correlated with learnable approximation error early in training, even though it is strongly negatively correlated with total velocity MSE. Specifically:

  1. On the linear identity-representation path, projected marginal speed energy and projected pairing variance sum to a time-independent constant (Section 3.1; Appendix A.3), yielding the −0.99-0.99 correlation between path speed and r⋆(t)r^\star(t). Because r⋆(t)r^\star(t) accounts for most of the variation in ℓθ(t)\ell_\theta(t) across time, total velocity MSE is also negatively correlated with path speed (−0.99-0.99 to −0.97-0.97). Allocating updates by raw loss magnitude therefore emphasizes time regions with high endpoint-pairing variance rather than rapid marginal evolution, consistent with Loss-CDF being the only sampler that does not reach the threshold on Gaussian25 (Table 1).
  2. At 1k updates the approximation error is concentrated where path speed is high (correlation 0.790.79); this alignment weakens as training proceeds (0.59,0.250.59, 0.25). The acceleration we report on Gaussian25 occurs during this early phase: PathSpeed reaches Uniform's final error at 3.5k updates versus 6k.

2. Downstream Robustness to Hyperparameters and Representations (W2)

All image experiments share (K,δ,n,L)=(64,2,512,64)(K, \delta, n, L) = (64, 2, 512, 64) and the same smoothing kernel. To supplement the prior-sensitivity comparison in Table 4 with downstream metrics, we trained models on Gaussian25 and 2rings while varying the time-bin count KK, finite-difference offset δ\delta, endpoint sample count nn, and projection count LL around the planar default (64,2,12000,64)(64, 2, 12000, 64) under the same 10k-update protocol (3 seeds, mean ±\pm SD):

Construction settingGaussian25 CellDisc ↓\downarrow2rings Dβ1D_{\beta_1} ↓\downarrow
Uniform0.131 ±\pm 0.0050.015 ±\pm 0.008
PathSpeed: default0.098 ±\pm 0.0070.001 ±\pm 0.001
Finer grid: K=128,δ=4K=128,\delta=40.097 ±\pm 0.0060.001 ±\pm 0.001
Larger interval: δ=4\delta=40.101 ±\pm 0.0070.002 ±\pm 0.001
Fewer endpoint pairs: n=3000n=30000.100 ±\pm 0.0080.002 ±\pm 0.001
Fewer projections: L=16L=160.103 ±\pm 0.0080.003 ±\pm 0.002

Every tested construction retains lower structural error than Uniform on both tasks, including a fourfold reduction in endpoint pairs (n=3000n=3000) or random projections (L=16L=16).

We also tested sensitivity to the speed representation ϕ\phi and projection count LL on CIFAR-10 (single-seed runs using the Seed C initialization and data order, where the default pixel L=64L=64 construction obtains 4.67 FID vs. the 3-seed mean of 4.61±0.124.61 \pm 0.12):

Speed representationProjections LLFID-50K ↓\downarrow
Pixels: default (3-seed mean ±\pm SD)644.61 ±\pm 0.12
Pixels: default (Seed C)644.67
Inception (Seed C)644.56
DINOv2 (Seed C)644.48
Pixels (Seed C)2564.59
Pixels (Seed C)10244.57

All variants fall within the seed-to-seed range of the default (4.47–4.69) and well below InfoNoise (5.92±0.155.92 \pm 0.15). On ImageNet-256, replacing Inception with DINOv2 ViT-B/14 for schedule construction achieves 27.62±0.6327.62 \pm 0.63 FID at 400k updates vs. 27.40±0.6527.40 \pm 0.65 for PathSpeed–Inception and 33.20±0.6533.20 \pm 0.65 for Uniform.

3. Larger Batches and Longer Training on Gaussian25 (W3, Q2)

We repeated the Gaussian25 comparison with a fourfold larger batch size and with twice the training budget (3 seeds, mean ±\pm SD):

Training settingUniform ↓\downarrowPathSpeed ↓\downarrow
Standard: batch 1,024; 10k updates0.131 ±\pm 0.0050.098 ±\pm 0.007
Larger batch: batch 4,096; 10k updates0.119 ±\pm 0.0050.088 ±\pm 0.006
Longer training: batch 1,024; 20k updates0.125 ±\pm 0.0050.091 ±\pm 0.006

PathSpeed maintains lower structural error under both a fourfold larger batch and double the training horizon, while Uniform at 20k updates (0.125) still does not reach PathSpeed's 10k-update error (0.098).

4. Paired Per-Seed Comparisons on ImageNet-256 and CIFAR-10 (W1, Q3, Q4)

ImageNet-256. The table below reports paired per-seed final FIDs at 400k updates and update counts (with RstepsR_{\text{steps}} in parentheses) required to reach the Uniform final mean FID threshold of 33.20, linearly interpolated across the evaluated 100k, 200k, 300k, and 400k checkpoints. All checkpoints are evaluated using FID-50K (50,000 generated samples, EMA weights, 250 Euler–Maruyama steps, no CFG).

Paired runInfoNoise FID ↓\downarrowPathSpeed FID ↓\downarrowInfoNoise updates to threshold ↓\downarrowPathSpeed updates to threshold ↓\downarrow
A28.4927.61223k (0.56)193k (0.48)
B27.1926.67197k (0.49)188k (0.47)
C28.1727.92213k (0.53)196k (0.49)

PathSpeed yields a lower final FID and reaches the threshold earlier in all three paired runs. Across seeds A, B, and C, PathSpeed reduces final FID relative to InfoNoise by 0.880.88, 0.520.52, and 0.250.25 (mean paired reduction of 0.550.55 FID, with SD 0.320.32 across the n=3n = 3 paired differences); with three seeds and a mean gap smaller than the run-to-run SD, this reflects a consistent directional improvement across seeds rather than statistical separation from InfoNoise, while both schedules remain far ahead of Uniform (33.20). For reaching the 33.20 threshold, PathSpeed requires 30k, 9k, and 17k fewer updates than InfoNoise across the three seeds (4.6%–13.5% fewer updates than InfoNoise, and 51%–53% fewer than Uniform). Against the stricter target of InfoNoise's final 400k mean FID (27.95), linear interpolation between PathSpeed's 300k (28.53) and 400k (27.40) mean checkpoints places the crossing at approximately 351k updates (~12% fewer updates than InfoNoise).

CIFAR-10 shape component. Below are the paired per-seed results comparing moment-only (Gaussian-only) and full PathSpeed under the same representation, interval, calibration, and 100k-update protocol. We did not run an additional moment-only training comparison on ImageNet-256 within the rebuttal period.

VariantFID-50K (mean ±\pm SD) ↓\downarrowRun A FID ↓\downarrowRun B FID ↓\downarrowRun C FID ↓\downarrow
Gaussian-only4.85 ±\pm 0.165.034.724.80
PathSpeed4.61 ±\pm 0.124.694.474.67

Adding the shape component lowers FID in all three paired runs by 0.340.34, 0.250.25, and 0.130.13 (mean paired reduction of 0.240.24 FID, with SD 0.110.11 across the n=3n = 3 paired differences). On CIFAR-10 the moment component alone is already below InfoNoise (4.85 vs. 5.92), while the shape component provides a consistent additional gain and is decisive where topological structure is concentrated (2rings: 0.010→0.0010.010 \to 0.001; 1400→10001400 \to 1000 updates).

5. One-Time Offline Construction Cost (W1)

As reported in Appendix G (Table 5), the one-time schedule construction takes ~10 seconds on CIFAR-10 and ~4 minutes on ImageNet-256, including VAE decoding and feature extraction. This one-time precomputation takes under 4 minutes before training begins, whereas PathSpeed reduces the training updates needed to reach Uniform's final FID by 42% on CIFAR-10 (42k fewer updates) and 52% on ImageNet-256 (208k fewer updates). During training, sampling from the cached 64-bin distribution requires no additional network evaluation. We have added the new error-correlation analysis, downstream sensitivity experiments, and paired per-seed comparisons above to the Appendix in the revised version.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.