acceptodds
Under review as a conference paper at ICLR 2027

Exploiting Low Frequencies as a Prior for Optimal Transport Flows

Abstract

Optimal transport (OT) couplings between prior and data straighten flow matching trajectories and enable fast, even single-step, generation. But computing OT is cubic in the number of samples and existing methods solve the problem approximately at the cost of persistent bias or significant overhead. Instead of treating the prior distribution (typically, a Gaussian) as a given, we treat it as a design choice. The question now is what prior distribution simplifies OT coupling? There might be many different priors that achieve this, leaving us free to choose one that is also tractable to sample. We identify low-frequency projection of natural images as such a choice, and show that the identity coupling between data and its low-frequency representation is OT-optimal for nearly all sampled pairs. The prior is structured enough to be sampled by a lightweight model at inference, and the remaining flow-matching task reduces to synthesizing high-frequency detail. The criterion admits more than the deterministic projection. Interpolating the prior with Gaussian noise improves generation quality and the identity coupling remains optimal. The approach requires no modifications to the flow model itself, and integrates naturally with latent-space models, classifier-free guidance, and one-step generation frameworks. Our method reduces trajectory curvature by more than relative to the strongest baseline on each benchmark.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
flow matching, few-step generation, prior design, trajectory straightening, optimal transport couplings

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.50 over 4 reviews, above 68% of the others.
Reviewer_xF5oOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes a two-stage generative framework. The key observation is that an image and its low-frequency representation naturally induce an optimal transport coupling, allowing the model to learn a coarse-to-fine transformation without explicitly solving the OT problem. To enable sampling from the proposed low-frequency prior at inference time, the authors additionally train a flow matching model to map Gaussian noise to the low-frequency image distribution. Since this intermediate distribution lies in a substantially lower-dimensional space, the authors argue that it can be modeled more efficiently using a lightweight network with fewer parameters and lower computational cost.

Critical strengths

The paper provides a theoretical analysis of the OT properties of low-frequency projection-based couplings, complemented by empirical investigations of their robustness to noise interpolation.

Critical weaknesses
  1. My primary concern is the limited novelty of the proposed method. PixelFlow[1] has already introduced a multi-stage coarse-to-fine generation framework that progressively generates images from low to high resolution during noise schedule. In contrast, this paper adopts a simplified two-stage pipeline, where a lightweight FM model first generates a fully denoised low-frequency image, followed by a noise-perturbed refinement stage. Despite this difference, the core idea remains highly similar. Both methods exploit low-frequency image representations to construct correlated training pairs for coarse-to-fine flow matching. Given the substantial methodological overlap, I find it difficult to identify a sufficiently novel algorithmic contribution. More concerningly, PixelFlow is neither discussed nor included as a baseline, making it difficult to assess the actual contribution of this work.

  2. Another concern is that the strong few-step generation performance may largely depend on the Reflow procedure applied to the first-stage generator, rather than the proposed OT-based coupling. Since the first stage is responsible for generating the global image structure, its ability to produce high-quality samples in a single step is crucial to the entire pipeline. However, the paper does not provide an ablation without Reflow, making it difficult to disentangle the contribution of Reflow from that of the proposed coupling strategy.

[1] PixelFlow: Pixel-Space Generative Models with Flow

Questions for authors
  1. Although the paper reports results on 256×256 images, these experiments are conducted in a 32×32 VAE latent space rather than directly in pixel space. It would be interesting to discuss whether the proposed two-stage framework could effectively scale to high-resolution pixel-space generation, and what potential challenges might arise in such settings.

  2. Figure 6(a) only reports FID at 1, 2, and 4 NFEs. Could the authors extend the comparison to larger numbers of sampling steps (e.g., 8, 16, and 32 NFEs)? It would be interesting to see whether the performance advantage persists or diminishes as the number of sampling steps increases.

  3. Could the authors provide an ablation study comparing the proposed framework with and without Reflow in the first-stage generator? In particular, how does removing Reflow affect the final few-step generation quality? This would help clarify to what extent the reported improvements depend on Reflow rather than the proposed OT-based coupling.

3 comments

We thank the reviewer for the constructive feedback.

Relation to PixelFlow (W1): We agree that PixelFlow is closely related. Following the reviewer's comment, we now discuss it in Sec. 2.2 and compare against it directly in Sec. 5 and App. B.4. The difference is where the low-resolution image comes from. In PixelFlow it is a noisy intermediate state produced by the same network, so all four of its resolution stages must run at every sampling budget. In our method it is a clean sample from a separate lightweight prior, decoupled from the second stage. Moreover, PixelFlow does not study optimal transport or other data couplings for training, which are our focus.

To compare with PixelFlow directly, we run the released ImageNet-256 PixelFlow checkpoint in our evaluation pipeline: FID-10k with the same reference statistics, and time per image on one A5000 GPU, including decoding (Fig. B.5). Its network is much larger (677M parameters, in pixel space, against 163M for our two networks), so step counts are not comparable and we compare time per image. At comparable FID ours is about 15× faster: 9.73 in 56 ms per image, against 10.25 in 837 ms for PixelFlow. In this setting, PixelFlow reaches a lower FID (8.33) with four steps per stage, at 30 times our cost. The two methods are also complementary: replacing PixelFlow's first stage with our prior improves its FID at nearly the same cost (Fig. B.5).

Role of Reflow (W2, Q3): Reflow is used in our pipeline only for speed, to reduce the overhead of generating the prior by cutting the number of GϕG_\phi steps. Without Reflow, GϕG_\phi needs several steps to produce good samples. For example, 8 steps cost about 0.72 of one vθv_\theta step, and Reflow cuts this overhead to about 0.09 with a single step. Reflow is not part of the coupling between the prior and the data, and GϕG_\phi is only a sampler of the low-frequency prior, so any other sampler could replace it. The requested ablation is in the new Tab. C.8 (App. C.3). It shows that removing Reflow and running GϕG_\phi for more steps gives a comparable FID. Thus, the gain does not depend on Reflow, which only reduces the cost of the prior. We also note that there is no clear way to compare against other methods with Reflow added only to a first stage, since they do not split generation into a prior stage and a refinement stage. We would be glad to run any further comparison the reviewer finds useful during the discussion period.

Pixel space at high resolution (Q1): Following the reviewer's remark, the revised version discusses high-resolution pixel-space generation in App. B.5. We expect the identity coupling to carry over to high resolution pixel space, since natural images have a steeper spectrum in pixels than in VAE latents, so the low-frequency projection keeps more of each image (Tab. B.4). The main challenge is cost. In pixel space both stages grow with the resolution. The prior can be kept small either by a larger downsampling factor, which loses structure (App. C.2), or by splitting its generation into further stages, each with its own decoupled prior. We did not train at this scale and leave it to future work.

Higher NFE (Q2): Our method is designed for the few-step regime and does not perform as well at high NFE. Our advantage comes from straighter trajectories, which need fewer steps to integrate accurately. With more steps the integration error shrinks for every method, so the advantage diminishes as the number of steps grows, as we expect. Following the reviewer's request, we extend the comparison to 32 NFE in Tab. B.5. On CIFAR-10 we still lead every baseline through 16 NFE. On FFHQ the strongest baseline, AlignFlow, leads from 8 NFE. The table also includes the noised oracle of App. B.2, the same vθv_\theta started from exact low-frequency images of training samples. The oracle leads every baseline on FFHQ from 8 NFE, so the gap at higher NFE comes mainly from the prior generator GϕG_\phi and not from the flow vθv_\theta. The oracle is a bound, since these priors come from training images. The revision also scopes the claims in Sec. 5 to the few-step regime.

Thank you for your answers. My concern is not simply that the method’s advantage diminishes at larger NFE, but that the learned prior ultimately becomes a liability despite being introduced to simplify generation. Stage 2 receives coarse structure in advance and uses the same backbone and training-step budget as the baselines, while the full system additionally benefits from a separately trained stage-1 generator. Nevertheless, Table B.5 shows that at 32 NFE, it underperforms every compared baseline on both CIFAR-10 and FFHQ—including standard IFM, which must generate the entire sample from unstructured noise.

The oracle comparison makes this limitation particularly clear: keeping stage 2 unchanged and replacing only the generated low-frequency component with real low-frequency representations reduces FID from 7.54 to 5.01 on CIFAR-10 and from 21.89 to 13.99 on FFHQ. Thus, the second-stage model can achieve substantially better results, but the proposed prior generator prevents the full system from realizing that capability. More accurate integration does not resolve this bottleneck. This is not merely a secondary implementation issue. Generating a sufficiently accurate prior is an essential part of the proposed method, and attributing the performance gap to stage 1 does not address the weakness of the complete approach.

How do the authors propose to overcome this limitation—either by improving the learned prior or by training stage 2 to accommodate and correct its errors? Stage 2 is trained with starting states constructed from real low-frequency representations, whereas inference uses generated ones. The current results suggest that this discrepancy remains consequential even at larger sampling budgets. Without addressing this bottleneck, the method offers a low-NFE shortcut but falls short of the stronger promise of prior design. It supplies additional structure to simplify the task, yet at larger sampling budgets produces worse samples than a standard model that receives no such structural head start.

We thank the reviewer for the follow-up. We would like to clarify our choice of the stage 1 generator. We chose to change as little as possible in stage 1, and we use a basic, small and lightweight version of the stage 2 model. This was done to keep the pipeline as simple as possible. As the two stages are decoupled, the stage 1 prior can be improved orthogonally to the rest of the solution. As an example, the table below shows that using a pretrained generator as stage 1 gives a lower FID than IFM. We believe that our 2-part architecture, with the 2nd stage achieving empirical OT coupling, is our key contribution, and we hope that improving each of the two stages directs future work in a new, underexplored direction.

The table reports FID-50k on FFHQ at 16 and 32 NFE. As in the few-step results of the paper, our rows tune the inference noise level per step count:

16 NFE32 NFE
IFM18.7916.43
IFM, trained 2.6% more steps19.0716.40
Ours19.8718.62
Ours, stage 1 replaced by a pretrained StyleGAN217.4416.24
Ours, stage 2 fine-tuned for 2.6% more steps on generated starting states19.1417.89

Overcoming the limitation: We explored both ways the reviewer suggested, and both show directions to improve the full system. Improving the prior is the StyleGAN2 row discussed above. To train stage 2 to correct the prior's errors, we fine-tune it on starting states where half of the real low-frequency priors are partially noised and regenerated by GϕG_\phi, so they carry its errors while staying paired with their training images (last row). IFM trained for the same extra steps does not improve.

Following the reviewer's comment, we will add these rows to Tab. B.5 and this discussion to Sec. 6 in the final version. Finally, the reviewer's follow-up concerns only the higher-NFE question. We would be grateful to know whether our replies on PixelFlow (W1), the role of Reflow (W2, Q3) and high-resolution pixel space (Q1) resolved those concerns, or which issues remain, so that we can address them during the discussion period.

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

In this paper, the authors identify low-frequency projection of natural images as a choice, and show that the identity coupling between data and it slow frequency representation is OT-optimal for nearly all sampled pairs. The prior is structured enough to be sampled by a light weight model at inference, and the remaining flow-matching task reduces to synthesizing high-frequency detail. The writing is clear, it is easy to follow.

Critical strengths
  1. Present a new prespective on optimal transport in flow matching.
  2. Construct a prior using low-frequency projections of training images.
Critical weaknesses
  1. The comparisons in numerical results may be unfair. The illustrations in Figures are totally different. Could you please give the aligned comparsions with fixed seeds?
  2. Lack of computational complexity and runtime. Would you please add it?
  3. For those methods, would you please give some intuitive explanation about straightening? Why your trajectory is more straight?
  4. Lack of AlignFlow In Figure 7?
  5. Is it easy to extend to inverse problem as a prior like the vanilla FM?
Questions for authors

see the weaknesses.

4 comments

We thank the reviewer for the constructive feedback.

Fixed-seed comparisons (W1, W4): The reviewer is right that our CIFAR-10 and FFHQ figures drew a separate noise sample for each method, so the panels were not aligned. Following the reviewer's remark, the revised version replaces Figs. 5 and 7 with grids where all baselines share the same initial noise in each column, and adds AlignFlow to Fig. 7. Our method starts from a GϕG_\phi sample rather than Gaussian noise, so its content still differs from the baselines. Even with the aligned grids, the difference is clear at the first step, where in both figures our method already produces recognizable content while the baselines remain blurred.

Runtime and complexity (W2): Following the reviewer's remark, the revised version adds the full timing table (Tab. A.3) and the complexity to App. A.2. At equal NFE, end-to-end inference time is nearly identical across methods, since all share the same vθv_\theta architecture and we add a single GϕG_\phi step. For example, at 8 NFE on one A5000, ours takes 5.40 vs 5.32 ms/image for IFM on CIFAR-10, and 33.20 vs 33.13 ms on FFHQ.

On the training side, GϕG_\phi adds only 7 to 13% to the training time (App. A.2). In terms of complexity, our coupling only applies a fixed operator and draws noise per sample, so it is linear in the batch size, while exact minibatch OT, as used in OT-FM, is cubic in the batch size.

Why straighter (W3): Every training pair defines a straight line from its prior sample to its image, whatever the pairing. However, the model learns a single velocity per point and time, not one per pair. When several lines pass through the same point at time tt in different directions, the model can only learn their average. At inference the sample follows this averaged velocity, which changes as the sample moves, and so the trajectory bends even though every training line was straight. With random pairing (Fig. 1a), lines leave each prior point toward many different images, so this averaging is everywhere. An OT pairing avoids it. Its lines do not cross, so each point sees one direction, and the learned velocity simply follows the straight lines. While OT-based methods approximate such a pairing with a solver, our approach removes the need for one by designing the prior so that pairing each image with its own prior sample is already empirically OT-optimal (Fig. 1b). Each prior sample is the low-frequency part of its own image plus noise, so the lines from prior to data rarely conflict, and the learned trajectories stay nearly straight.

Inverse problems (W5): Although we have not evaluated inverse problems in this paper, guidance-based solvers apply to our method as they do for vanilla FM. We only change the prior distribution, so vθv_\theta and GϕG_\phi are still standard FM models. Super resolution is a special case, as the corrupted input can directly replace the output of GϕG_\phi.

Dear Reviewer wLmB, thank you again for your time.

As the discussion phase is closing soon, we would love to hear if our response has addressed your concerns, and if there is anything else to discuss.

I thank the authors for their detailed reply.

  • From the illustrations in Figure 7, their proposed method produces a clearer image than the other methods at the same NFEs.
  • Regarding runtime, it appears that the extra time is mainly due to the forward computation of GϕG_\phi (generation of the low-frequency initial image).
  • The reported time is consistent for the CIFAR-10 dataset but not for FFHQ.In addition, the time for AlignFlow on FFHQ is still missing, although the authors do report the time for ImageNet. It is strange. In W1, I mentioned that the authors miss the illustration of AlignFlow in Figure 7.

Thank you for pointing this out. On the same setup as Tab. A.3 (one A5000, including VAE decoding), AlignFlow on FFHQ takes 24.65, 26.13, 28.64 and 33.41 ms per image at 1, 2, 4 and 8 NFE, nearly identical to IFM since both use the same network. We will add this row to Tab. A.3 in the final version.

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

The paper proposes replacing the conventional Gaussian prior in flow matching with a structured prior obtained from low-frequency projections of training images. The proposed framework consists of two stages: Coarse generation and high-frequency refinement. It is claimed that the coupling between the projected samples and the original data is OT-optimal, eliminating the need for expensive OT solvers. They empirically verify the identity assignment using the Hungarian algorithm and show that the coupling remains largely preserved for moderate noise levels. Experiments on CIFAR-10, FFHQ, and ImageNet demonstrate lower trajectory curvature and improved FID compared with alternative algorithms.

Critical strengths
  1. Instead of approximating the OT coupling between a fixed Gaussian prior and the target distribution, the paper propose designing the prior to induce specific coupling. This makes the approach more adaptive and has the potential to be applicable beyond the specific setting considered.

  2. Promising empirical results. The method consistently improves trajectory curvature and few-step generation quality across the evaluated datasets. In particular, the results on CIFAR-10 and FFHQ show substantial improvements over the competing OT-based methods.

Critical weaknesses

The paper emphasizes that low-frequency projections induce an OT-optimal identity coupling. However, Appendix D shows that this property holds for any orthogonal projection, whether or not it preserves low-frequency information.

In addition, the practical area-downsampling/bicubic-upsampling operator is not strictly an orthogonal projection, and its OT-optimality is only empirically verified.

The proposed method requires a separately trained generator G_\phi to sample from the low-frequency prior. It introduces additional parameters, training costs, and inference overhead.

Questions for authors
  1. Can the authors provide a theoretical characterization of the OT-optimality gap for their actual projection operator?
  2. How does the addition of Gaussian noise affect OT-optimality at the population-distribution level?
  3. How does the proposed method compare with a conventional two-stage generative pipeline that uses low-resolution generation followed by conditional high-resolution refinement with the same computational budget?
  4. How sensitive are the results to the quality of the learned prior generator G_\phi?
  5. Does the identity coupling remain approximately OT-optimal when the prior is sampled from the learned model instead of constructed directly from real images?
2 comments

We thank the reviewer for the constructive feedback.

OT-optimality of the prior (W1, Q1, Q2): As App. D states, any orthogonal projection gives OT-optimal identity coupling. However, this leaves another degree of freedom, the choice of the prior itself. For example, the zero projection is trivially OT-optimal, but its prior is a single point from which nothing can be generated. This is the core distinction from the traditional approach that fixes the starting point to the Gaussian distribution. We demonstrate empirically that low-frequency projections under noise interpolation result in better generation (Tab. C.7), regardless of the theoretical OT property of orthogonal projections (W1).

The theoretical gap for our projection is that bicubic upsampling is not the mirror of area downsampling, and applying the operator twice gives a different result, so it is not an exact orthogonal projection and its OT-optimality is verified empirically (App. B.1). We use it over Fourier truncation, which is exactly orthogonal, only for its slightly better FID (W1, Q1).

Noise makes the identity no longer exactly optimal at the population level, since after adding noise, the noisy prior samples built from different images can overlap. However, we saw empirically that adding noise helps generation, and that this aligns with OT: FID improves as we increase the noise up to α=0.5\alpha=0.5, which is where the identity coupling starts to break, and degrades beyond it (Fig. B.3a, Sec. 4.1) (Q2).

Overhead of GϕG_\phi (W2): GϕG_\phi does add parameters, training cost and inference overhead (Sec. 6), but in practice the overhead is small. It adds about 33M parameters on top of about 130M for the SiT models, and 7 to 13% more training time (App. A.2). The revised appendix now reports the end-to-end inference times in Tab. A.3. At inference GϕG_\phi changes end-to-end time by at most about 5%, e.g. 0.66 vs 0.63 ms per image at 1 NFE on CIFAR-10.

Conditional cascade (Q3): We ran this on CIFAR-10 against a capacity-matched conditional cascade. It uses the same network with the coarse image concatenated as conditioning, starts from pure noise, and is sampled with the same GϕG_\phi, so both pipelines cost the same per step (50K FID, Sec. 5 and new Tab. B.6). The cascade does not reach comparable fidelity at any tested budget. Its best FID, 26.35 at 32 steps, is worse than ours at only four steps (11.74), and at 32 steps ours reaches 7.54. We lead at every step count from two steps on. The cascade is ahead only at a single step (55.51 vs 78.32), where its second stage ignores the noise, as redrawing the noise for a fixed coarse image changes only 0.02% of its output variance, against 7% for ours. The cascade thus acts as a deterministic upsampler of the coarse image, while ours samples the fine detail.

Sensitivity to GϕG_\phi (Q4): The results are very sensitive to the quality of the prior. The revision contains the new Tab. C.8, which shows that at one vθv_\theta step on CIFAR-10, running GϕG_\phi without Reflow for one step gives FID 177.86, and running it for 16 steps improves it to 82.44. This also means that since the two stages are decoupled, a stronger generator of the low-frequency prior can replace our simple GϕG_\phi and further improve the results.

Generated priors (Q5): During training every prior is built from a real image, so the identity coupling holds by construction and our assignment results apply to the coupling vθv_\theta learns. The reviewer's question becomes important at inference, where we do not start from data and the prior comes from GϕG_\phi. To measure this, App. B.2 runs the same vθv_\theta from generated priors and from exact low-frequency images of training samples (the noised oracle). The oracle outperforms every baseline at every step count on both CIFAR-10 and FFHQ (Tab. B.5), and the generated priors stay close to it at few steps, with even straighter trajectories (App. B.2).

Dear Reviewer ALF3, thank you again for your time.

As the discussion phase is closing soon, we would love to hear if our response has addressed your concerns, and if there is anything else to discuss.

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

This paper proposes a new generative model paradigm. Unlike traditional methods that generate images directly from Gaussian noise, this approach utilizes a low-frequency representation of an image as the starting point for the flow. The method employs two generators: the first maps Gaussian noise to a low-frequency representation, p~0\tilde{p}_0, which only requires generating a coarse, low-frequency approximation of the image; the second maps p~0\tilde{p}_0 to the final image. Both processes are formulated as Flow Matching and are mutually decoupled. During inference, a lightweight, independently trained first-stage model generates a coarse, low-frequency representation, which is then evolved by the second Flow Matching model into a full-resolution image, recovering the missing high-frequency details. Experimental results on the CIFAR-10, FFHQ, and ImageNet datasets demonstrate that this approach significantly reduces the curvature of the generative trajectory compared to baseline methods, and achieves superior generation quality in few-step generation settings.

Critical strengths
  1. Most existing methods keep the prior fixed and approximate OT couplings. This paper flips the problem: fix identity coupling and design a compatible prior. This perspective avoids expensive per‑batch or global OT solvers, which is a meaningful conceptual contribution for flow‑based generation.
Critical weaknesses
  1. Only the mapping from the learned low‑frequency prior to target data exhibits empirical OT optimality. The lightweight auxiliary generator itself is still trained with independent random pairing. The full pipeline is not fully OT‑coupled.
  2. The identity‑coupling OT property heavily relies on the well‑known spectral decay statistics of natural images. It may not directly transfer to other data modalities. No cross‑modality experiments are provided to demonstrate generalizability.
Questions for authors
  1. This method relies on a lightweight model to learn a low-frequency prior distribution, which in turn depends heavily on the statistical assumption that the energy of natural images is concentrated in the low-frequency domain. Does the method’s performance degrade significantly when applied to data characterized by dense textures and critical fine-grained information?
  2. The generalization capability and generation diversity of this approach depend largely on the noise interpolation coefficient α\alpha used in the first stage. Could the authors further elaborate on how α\alpha is selected across different datasets? Is this choice empirical?
  3. Could the authors provide a direct comparison of end-to-end inference times between this method and baseline models (such as IFM, OT-FM, and AlignFlow)?
3 comments

We thank the reviewer for the constructive feedback.

Partial OT coupling (W1): The full pipeline is not fully OT-coupled, as we discussed in Sec. 6. An OT solution from the initial Gaussian prior to the data is a hard problem to solve, and instead of trying to approximate it, we choose to change the problem to a different space, where empirically OT optimality is given with an identity coupling between the data and a simple low-frequency transformation of it. The first stage can be trained differently, and is decoupled from the full process. In our implementation, GϕG_\phi is reflowed (App. C.3), so it is retrained on pairs from its own trajectories rather than on independent random pairs, without changing the coupling between the prior and the data.

Other modalities (W2, Q1): Our work focuses on natural images (Sec. 6), and beyond pixels we also show results in a compressed VAE latent space (FFHQ, ImageNet), although it is still derived from natural images. For a new modality, the projection must be checked to keep the identity coupling with a small reconstruction error, even under noise interpolation (Fig. B.2).

This depends on how much of each sample the projection keeps, which for images is set by the spectrum. Following the reviewer's remark, the revised version now contains Tab. B.4, in which we flatten the CIFAR-10 spectrum as a proxy for dense textures (Q1). The projection then keeps 12% of the energy instead of 86%, and only 15% of samples stay paired at α=0.5\alpha=0.5. On CIFAR-10, when noise breaks the coupling (α>0.5\alpha > 0.5), FID degrades (Fig. B.3a), so we expect a similar drop for such data. FFHQ latents, with a much flatter spectrum than pixels, keep 51% and stay fully paired.

Choice of α\alpha (Q2): We chose α=0.5\alpha=0.5 empirically, once, from a CIFAR-10 FID sweep at 2 NFE after 40K training steps (App. B.1), inside the range where the identity coupling holds, and used it unchanged on FFHQ and ImageNet with no further sweep. The sweep shows that the noise level strongly affects how well the generated distribution matches the data. FID is much worse at small α\alpha, where the prior lies on a low-dimensional subspace. It is best around α=0.5\alpha=0.5 and degrades again with more noise. At inference the level is mildly tuned per NFE (App. A.4).

Inference time (Q3): Following the reviewer's remark, the revised version includes the full end-to-end timing in the new Tab. A.3 (one A5000, ms per image, including VAE decoding on FFHQ). At equal NFE the times are nearly identical, since all methods share the vθv_\theta architecture and we add one GϕG_\phi step. E.g. at 8 NFE ours takes 5.40 ms vs 5.32 for IFM on CIFAR-10, and 33.20 vs 33.13 on FFHQ, where VAE decoding (24.06 ms) dominates.

Dear Reviewer Uwvx, thank you again for your time.

As the discussion phase is closing soon, we would love to hear if our response has addressed your concerns, and if there is anything else to discuss.

I think the authors’ response addresses my questions, and I will retain my score.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response to all reviewers

We thank all reviewers for their careful reading and detailed comments. Reviewers found the main idea a meaningful new perspective (Uwvx, ALF3, wLmB). Instead of approximating OT for a fixed Gaussian prior, we design the prior so that the identity coupling is already OT-optimal, with no OT solver.

Shared concerns

Inference cost (Uwvx, ALF3, wLmB): the new Tab. A.3 reports end-to-end time per image. At equal NFE all methods take nearly the same time, since they share the vθv_\theta architecture and we add one GϕG_\phi step (e.g. 5.40 vs 5.32 ms at 8 NFE on CIFAR-10).

Coarse-to-fine baselines (ALF3, xF5o): Sec. 5 and App. B.4 now compare against a capacity-matched conditional cascade and against PixelFlow. Ours is better from two steps on against the cascade, and about 15× faster than PixelFlow at comparable FID.

Main revisions in the uploaded PDF (all changes are marked in red)

  • Tab. A.3 and App. A.2: end-to-end inference time and the complexity of our coupling.
  • App. B.1 and Tab. B.4: dependence on the spectrum and projection energy.
  • App. B.3 and Tab. B.5: comparison up to 32 NFE, with the noised oracle.
  • App. B.4, Tab. B.6 and Fig. B.5: conditional cascade and PixelFlow.
  • App. C.3 and Tab. C.8: GϕG_\phi without Reflow.
  • Figs. 5 and 7: shared initial noise across baselines, and AlignFlow added to Fig. 7.
  • Sec. 2.2: coarse-to-fine generation and PixelFlow in related work.
  • Sec. 5: a new paragraph on coarse-to-fine baselines, and claims scoped to the few-step regime.
  • Sec. 6: an example where flattening the spectrum breaks the coupling.
  • App. B.5: high-resolution pixel space.

We reply to each reviewer individually, in a separate response under their review.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.