LapFlow: Laplacian Multi-scale Flow Matching for Generative Modeling
Authors: Zelin Zhao
Petr Molodyk
Haotian Xue
Yongxin Chen
Venue: ICLR 2026 Poster (2026)
Keywords: flow matching
multi-scale
generative modeling
image generation
Primary area: generative models
TL;DR: In this paper, we present a multi-scale framework for flow matching, aiming to improve the scalability of image generative modeling.

Abstract: In this paper, we present Laplacian multiscale flow matching (LapFlow), a novel framework that enhances flow matching by leveraging multi-scale representations for image generative modeling. Our approach decomposes images into Laplacian pyramid residuals and processes different scales in parallel through a mixture-of-transformers (MoT) architecture with causal attention mechanisms. Unlike previous cascaded approaches that require explicit renoising between scales, our model generates multi-scale representations in parallel, eliminating the need for bridging processes. The proposed multi-scale architecture not only improves generation quality but also accelerates the sampling process and promotes scaling flow matching methods. Through extensive experimentation on CelebA-HQ and ImageNet, we demonstrate that our method achieves superior sample quality with fewer GFLOPs and faster inference compared to single-scale and multi-scale flow matching baselines. The proposed model scales effectively to high-resolution generation (up to 1024×1024) while maintaining lower computational overhead.

LAPFLOW: LAPLACIAN MULTI-SCALE FLOW MATCH- ING FOR GENERATIVE MODELING
Zelin Zhao & Petr Molodyk & Haotian Xue & Yongxin Chen Georgia Institute of Technology Atlanta, GA 30332, USA
(zelin, pmo odyk3, huxue. ai, , @gatech.
ABSTRACT
In this paper, we present Laplacian multiscale flow matching (LapFlow), a novel framework that enhances flow matching by leveraging multi-scale representations for image generative modeling. Our approach decomposes images into Laplacian pyramid residuals and processes different scales in parallel through mixture- of-transformers (MoT) architecture with causal attention mechanisms. Unlike previous cascaded approaches that require explicit renoising between scales, our model generates multi-scale representations in parallel, eliminating the need for bridging processes. The proposed multi-scale architecture not only improves generation quality but also accelerates the sampling process and promotes scaling flow matching methods. Through extensive experimentation on CelebA-HQ and ImageNet, we demonstrate that our method achieves superior sample quality with fewer GFLOPs and faster inference compared to single-scale and multi-scale flow matching baselines. The proposed model scales effectively to high-resolution generation (up to 1024x1024) while maintaining lower computational overhead.
INTRODUCTION
Generative modeling has seen remarkable progress in recent years, with diffusion models and flow matching approaches achieving srate-of-the-ane results in image synthesis (Dhariwal and Nichol 2021 Lipman et al., 2203; Peebles and Xie 2023). These models have demonstrated impressive capabilities in generating realistic, high-quality, and diverse samples across various domains. However, as the demand for higher resolution and more complex content increases, scalability remains significant practical challenge (Tian et al.) [2024] Jii et al. | Atzzmnn et al. [2024]. As these methods typically generate the entire image at full resolution, they require substantial computational resources during training and inference phases. This motivates alternative approaches that maintain generation quality while potentially improving sampling efficiency and reducing inference overheads.
generation (Lai et al.
2017 Jin et al. 2025 Atzmon et al. 2024 Tian et al. 2024 Ho
al. 2022; Batzolis al. (022) has emerged as a promising direction to address these scalability
challenges. Existing multi-scale methods in both diffusion and flow matching paradigms, such as Cascaded Diffusion Models (Ho al.) 2022), EdifyImage (Atzmon al.) (004)), and Pyramidal Flow (Jin et al. 2025), have demonstrated improved efficiency by generating images progressively from lower to higher resolutions. However, each of these approaches faces challenges that have limited their adoption compared to popular single-scale methods like DiT (Peebles and Xie 2023).
Cascaded Diffusion Models (Ho et al. (2022) require training and maintaining separate networks for each resolution level, increasing implementation complexity. Edifylmage (Atzmon et al. (024h. while effective, operates directly in pixel space rather than latent space, resulting in significantly slower inference compared to latent-based methods. Pyramidal Flow (Jin et al., (025) has demonstrated impressive results when fine-tuning DiTs for video generation, where they initialize their MM-DiT model from SD3 Medium (Esser al. 2024) and fine-tune afterwards, but its effectiveness when trained from scratch for image generation tasks remains less thoroughly explored in the literature.
In this paper, we introduce Laplacian Multi-seale Flow Matching (LapFlow) enabling parallel modeling of multi-scale representations. As shown in Figure [] the proposed model progressively
"The code is available http://gihhu..oo//jjyyygggg

---

Ve
Ve
V
0 to 72
To
Va
Va
[ = 72
Denoise
1
Up Sample
Ve
LapFlow model
Figure 1: Multi-scale generation process of our model. The proposed model follows coarse-to- fine generation strategy across scales in Laplacian pyramid. This figure demonstrates a three-level version of ours, where T2. 7j are two critical points defining three sampling segments for three scales. Starting from random noise at f O, our model first denoises the coarsest scale until t = T2, then progressively conditions finer scales on completed coarser scales
T2 T2 and causal structure ensures coherent image generation by maintaining hierarchical dependencies across scales, ultimately producing high-fidelity samples with both global consistency and fine details.
1). This
generates Laplacian residuals through unified model, and then reconstructs the full image through hierarchical combination of these residuals following the Laplacian pyramid reconstruction process. Our approach enables parallel generation of multiple scales through a unified mixture-of teeee-fff-raffoomer (MoT (Liang et al. 2024)) model with scale-specifee modeling and shared- weight global attention. The model further employs causal attention mechanisms that enforce a natural information flow from lower to higher resolution scales, ensuring that finer details are coherently conditioned on broader structural elements while maintaining the hierarchical integrity of the image representation.
Through extensive experimentation on both CelebA-HQ (Karras et al. 2018) and ImageNet (Deng ctt al. 2009), we demonstrate that our approach achieves superior sample quality compared existing single-scale and multi-scale flow matching methods while requiring fewer compute (GFLOPs) during sampling. On CelebA-HQ, our method achieves an FID of 3.53 at 256x256 resolution (compared to 5.26 for LFM (Dao et al. 2023)). while our method keeps a strong performance scaling up to 1024 x 1024. Comprehensive ablation studies on CelebA-HQ demonstrate the effectiveness of our key design choices, including the MoT architecture, causal masking, and noise scheduler, etc. For class-conditional generation on ImageNet, our approach outperforms both single-scale and multi-scale flow matching methods while maintaining lower computational requirements.
Our contributions are summarized as follows:
We present multi-scale flow matching framework that decomposes images into Laplacian pyramid representations, enabling joint modeling of different scale components.
2. We introduce a specialized mixture-of trreoofofrrassfomrrsss (MoT) architecture with causal attention mechanisms that processes multiple scales sinultaneously, significantly reducing inference compute while enforcing natural information flow between resolution levels. Through time- weighted complexity analysis, we show that the effective attention cost of our progressive multi-scale design is theoretically lower than that of DiT (Peebles and Xie (023).
3. We develop a progressive training strategy that optimizes different scales across distinct time ranges, allocating computational resources according to each scale's contribution.
RELATED WORK
Diffusion and flow matching. Diffusion models (Peebles and Xie 2023 Ho et al. 2020) have emerged as dominant approach for generative modeling, achieving state-of-the-art results across various domains through iterative demoising processes. Despite their success, these models often require large number of function evaluations during sampling, leading to computational inefficiency. Flow matching (Lipman et al.) 2023 Albergo and Vanden- Vanden-Eijnden, 2022] Liu et al., (022) is simple yet effective framework for generative modeling, demonstrating strong performance across multiple
2

---

domains, particularly in image generation (Ma et al. 2024 Esser et al. 2024 Liu et al. 2022
Dao
iet al., 2023) and video generation (Jin et al. 2025; Google DeepMind 2025). Instead of using noise clean samples learning objectives, it learns velocity field that defines deterministic transformation from the prior to the target distribution.
Multi-scale generation. Multi-scale approaches have a rich history in generative modeling, be- ginning with LapGAN (Lai et al. 2017), which demonstrated the effectiveness of progressively generating high-resolution images from lower-resolution ones using GANs. This hierarchical con- cept was later adapted to diffusion models with cascaded architectures (Ho et al.) [022] Saharia (et al. 2022 Zhang et al. 2023), which employ sequences of separate models to generate images of increasing resolution, each conditioned on lower-resolution outputs. Later on, Non-Uniform Diffusion Models (Batzolis et al., 2022), Relay Diffusion (Teng et al., 2024) and Pyramidal Flow (Jin et al. 2025) utilize renoising operations to bridge between resolution levels in a full generation cycle, while EdifyImage (Atzmon et al. 2024) attenuates different frequency components at varying rates. However, these approaches typically require separate models complex bridging mechanisms between scales, ignoring the use of causal relationships between scales (Tian et al. (022).. In contrast, our LapFl 1 ow framework employs single mixture of transformers model that processes all scales simultaneously through causal attention mechanisms, eliminating the need for explicit bridging while allowing for more efficient generation.
Parameter-efficient architectures and auto-regressive generative models. Parameter efficiency has become increasingly important in generative modeling as model sizes continue to grow. Mixture- of-Experts (MoE) approaches (Shazeer et al. [2017] Fedus al.) (022) have emerged powerful paradigm for conditionally activating only relevant parameters, substantially improving computa- tional efficiency. These concepts have been adapted to vision tasks through Mixture-of- -oreeofff--afffomesss (MoT) (Liang et al. (024) architectures that enable specialized processing pathways. Concurrent developments in auto regressive generative models (Tian al. 2024 Sun al. 2024) have demon- strated the effectiveness of causal modeling. Our approach leverages flow matching with ODE-based parallel sampling, fundamentally differentiating from auto-regressive methods that generate content sequentially and suffer from inherent parallelization constraints.
3 BACKGROUND
Flow matching formulations. Flow matching (Lipman et al. 2023) learns a time-dependent vector field that smoothly interpolates between a prior distribution Po and data distribution q. We use x, to represent the evolving data sample over time. Flow matching directly optimizes regression objective (x
[[v:(x) ux(x[x:)l" minimizing the discrepancy between the learned vector field (x) and the conditional velocity of ground truth (x(xx)). called the Conditional Flow Matching (CFM) objective. Training flow-matching model requires defining a valid interpolation path between Po and g. Let Xg ~ (x()) be a noise variable, and x ~ q(x) be a data sample. We can derive the noisy data X; and the corresponding velocity field u, X₁ 0, + oxXo and ue (x(xxxx)) = x + 0,Xo, where at and o, are pre-defined coefficients for noise scheduling, while á and & are their temporal derivatives respectively. A simple yet effective choice (Lipman et al. 2023 Dao et al. 2023) of ag and oe is linear interpolation: a; = t. = t. Another popular probability path is the generalized variance preserving (GVP) (Ma al. 2024 :00, sin (L or = cos ml
We choose to model flows in latent space (Dao et al. 2023). aiming to reduce computational complexity and improve sample quality.
Latent flow matching. While some flow matching methods attempt to directly model in pixel space (Lipman et al.) 2003). LFM (Dao et al. (023) and SiT (Ma et al., (2024) propose to model the latent space through VAE, aiming to reduce computational complexity and improve sample quality.
Laplacian decomposition. Denote the unknown data distribution (the image distribution) by q(x)), We define Up the nearest neighbor upsampling operation and Down the average pooling operation, both with a scaling factor two for upsampling and downsampling, respectively. Given a data X1 q, decompose it into three residuals via the Laplacian decomposition (we formulate
3

---

Algorithm 1 LapFloo low Training
1: Input: image dataset D. number epochs M, critical time points 0 _ T3 < < 71 <1
2: Initialize weights I of the LapFl model Vi
3: for epoch= to M do
4: for each image x in D do
5: Sample random noise image Xo and generate Laplacian pyramid {x0 xx :x0
(1) (2))
6:
Sample stage 8 ~ (0, 1, and sample time ~ (7
7:
Compute noisy image through Equation 33 for k 2 and E {0, 1, 2]
8:
Compute velocity target through Equation 5) for
and k: (0, 1
9:
Forward the model to get the predictions through Equation 6
Calculate the multiscale velocity loss Lm as Equation 11: Run back-arcpppaaeeee propagation and update network parameters
12: end for
13:
end for
14:
Return: trained LapF 1l model V
Algorithm 2 LapF low Sampling
1: Input: trained flow model Vp, largest-scale random noise xo, critical time points Ti and T2
2: Get Laplacian pyramid {x. (0) (1) Xg J from Xo
(2)
X
3: (x ODEINT(VV {0, T2}, {x (2)
4: (xt) x7,1 (V, (T2, Ti (TT, Xg .T,
(1) (1) (2)
5: (x10) ;X] , x ODEINT(V, (Ti, 1,, (o X X (
(0) (0) (1)
6: &1 x = + Up(Up((("))
7: Return: the largest-scale sample x
three scales here for simplicity, while it can easily generalize to other numbers of scales):
2) (oxn(Dow)(xx)),
(I Do Up(x (2). (0)
X1 Up(Down(xx)) (1)
In this work, we the superscript to denote the smallest scale and 0 to denote the largest scale. Given the three scales' representation, the full data X can be reconstructed from three residuals as
(0) + Up(x(") + Up(Up(x(2)))
x1
METHODOLOGY
4.1 MULTI-SCALE NOISING PROCESS
We propose learning the components of three scales at different speeds. We identify two critical time points Ti and T3 as two hyperparameters, where 0 2 T3- < T2 < Ti < In addition, we denote To = 1 and T3 = 0 for convenience of notation. For the k-th scale, we train the model from t = Tk+1 1, which means that the model of larger scales trained for shorter period of time.
time step t (note that T < t < 1 ensured by our progressive multi-stage training strategy, which will be
presented Section 4.2 we construct the noisy data of scale ls via weighted sum of x(() and x (M).
(k) az x
(k) (k) + of X
(k) (k)
where {a.a) of pre-defined per-scale coefficients for data and noise. The interpolation can be conducted through a linear path or a GVP path by modifying the coefficients:
(k) (k)
Te+1
Linear:
a
(k)
ot
(k)
t,
(4a)
- Th+11
GVP: = sin
T(t Ts+1)
T di
(k)
= cos
2
(4b)
2(1 -Tr+1)
4

---

This multi-scale flow satisfies two key properties: (1) At the starting time t T for scale k, the (k)
(A) (R) (k),
noisy data contains only the scaled noise component, as T = 0 results in XTx11 = Tx x (2)
At the ending time = 1, the representation x1 converges to the clean Laplacian residual of scale k, completing the generation process. The proposed flow provides the following multi-scale velocity:
(x
( (+)) = dg x oz xxx
(k) (k)
(5)
where ag and a/ are temporal derivatives of at
(R) (k) and o respectively.
4.2 PROGRESSIVE MULTI-STAGE TRAINING AND TRAINING TARGETS
The training algorithm is presented in Algorithm We adopt a progressive training scheme (Karras) al. 2018), which trains different-scale models for different time ranges. We introduce the concept of stage (denoted by ([0, 1, 2]), where in different stages, we train different scales of models. In training stage s {0, 1, we train all scales &o such that k 2 s (noting that smaller & values represent higher resolutions, with k = 0 being the highest resolution and h = 2 being the lowest). After sampling s, the timestep is then sampled from the range [T&+1, 1] (Line As a result, the smallest scale (k- = 2) is trained throughout the time range [0, 1]. the mid-resolution scale (k 1) is
trained across [72, 1), and the highest resolution scale (k = 0) is trained only during (Ti, 1].
Our model takes noisy scale data {x; (k) 12=2 as input, and outputs corresponding multi-scale
velocities {v; 1s J. Both input and output consist of scales from the smallest scale (k 2) to the current scale (A: = 8), while they are conditioned on the same time Let Vo be the LapFlow model (see Section 4.4 for a detailed architecture). the model prediction (Line 9 is formulated as:
(k) J - (ox(
(1x( (k) (k=2)))))))
(6)
We apply a multiscale conditioning flow matching loss (Line 10 as:
Liv
wx ( (x.e(( |x(0))
u (x) (x(x )12
where wn is a balancing factor for scale k's loss, where in practice we set wp for simplicity.
4.3 MULTI-SCALE SAMPLING PROCESS
We present our sample algorithm in Algorithm 2 which is used to generate images with the highest resolution. The sampling algorithm starts with Laplacian of noise (Line 2). We then leverage the ODE solving function ODEINT, which takes three arguments (a model Vo. initial and end timesteps {4i, (e), and initial condition Xx,) as input and outputs the variable xt, corresponding to the end timestep le- popular implementation of ODEINT that we use is the torchdiffeq library (Chen et al. 2018). This general process can be formally expressed Xt, ODEINT(Vo, te). Xx,)
We first denoise the smallest scale from / = 0 to T2 to get the partially denoised state xx(2 (Line Then we continue the denoising procedure during T2 < L < Ti, where we denoise the mid-scate and smallest scale in parallel (Line 4). In this step, we leverage the fact that when
T2. the
mid-resolution noisy state becomes TTz Xo while the smallest noisy state becomes XT2 according
(1)
(2)
(1) to Equation 3 Therefore, this step would take an initial condition {o// x (2) Similarly, the last step would take {o/1 X
(2)) (1) Xx, X } as the initial condition. We finally evaluate the model from T to (Line 5), and these denoised residuals are then combined into full-scale data via Equation (2)
4.4 MULTI-SCALE DIT WITH MIXTURE OF- TRANSFORMERS
We present the LapFlow model, which is a multi-scale diffusion transformer (DIT) with Mixture- or-Trsssformsss (MoT (Liang et al. 2024)). The complete model architecture of LapFlos is shown in Figure 2 As formulated in Equation (6). our LapFlow architecture is designed with flexible input-output capabilities: can process noisy states of any subset of scales (from one to three scales) input, and will correspondingly output velocity predictions for exactly the same
5

---

PreAttnMod
Velocity Scale 2
Velocity Scale
PostAttnMod Scale
PostAttnMod
Scale
Scale, Shift
UnPatchity
UnPatchify
Layer Norm
Separation and Scale
Linear
Linear
Causal Masked Global Multi-Head Self-Attention
PostAttnMod
adeo
adaLN-Zero
Scale
QKV Concatenation
Nx
Multi-scale MoT Block
@
p(2)
Q
Pointwise
Feedforward
Embed
PreAttnMod Scale
PreAttMMod
Patchify
Patchify
Scale
Scale, Shift
Time
Noisy
Noisy
Tokens
Time-Label
Tokens
Layer-Norm
Scale
Scale
Label
Scale
Embeddings
Scale
Figure 2: (Left:) Schematic of the LapF low model Vg. The multi-scall transformer takes multi- scale noisy states as input, conditioned on time and label, and predicts velocities for each input scale. While the model (Middle:) Details of one multi-scale MoT block. We use separate QKVs for different scales, while the attention computed globally. Furthermore, adopt mask to enforce causal relationships across scales. (Right:) Details of scale-specific P PreAt nMod and PostAt t noodd modules (Peebles and where each PostAttnMod module includes feedforward network (FFN).
take arbitrary number of scales input, we show two here for simplicity.
Xie 2023)
scales that were provided as input. This flexibility enables the model to handle different stages of the generation process where varying numbers of scales active. We inherit best practices from DiT (Peebles and Xie 2023), including patchify, feature modulations, and in-context conditioning. In addition, utilize MoT (Liang et al. 2024) enable scale-specific processing (e.g., pre-attention and post-attention modulations) with global multi-head self-attention over all scales. In the global attention mechanism, LapF low implements a causal masking strategy that enforces unidirectional information flow from smaller scales (lower resolutions) to larger scales (higher resolutions).
Model schematic (left of Figure The input noisy states at each scale are first converted into sequences of tokens using the Pat chify operation (Peebles and Xie 2023). For each scale, sine-cosine positional embeddings (Dosovitskly et al. 2020) are added to its corresponding tokens. Conditions such time and label context conditioning (Peebles and Xie 2023), enabling flexible conditioning without architectural modifications. The input tokens are then processed by N multi-scale MoT blocks, followed by an adaptive Layer Norm layer with zero initialization (ada LN-Zero (Liang et al., (0044). Finally, a linear decoder and UnP aaPachhffy (rearrange) process are applied to get velocity predictions.
added additional tokens the input sequence (in-
Multi-scale MoT block (middle and right of Figure
For any scale k E {s, 2} (where (k) (k) 3 g .i
(k) and (())) denote parameters for scales and shifts regressed from conditional embeddings, following DiT convention (Peebles and Xie 2023). Firstly, we apply a pre-attention modulation process (PreAt tnMod) that includes both scale-and-shite operations through factors (k) and ( as well as scale-specific projections to obtain queries, keys, and values (QKVs). Let (a) be the tokens after the caal--and-shift, and the scale-specific QKVs are:
the current training stage), use a a2
(k) 2(k) (*) (()) (K) (()) ((())
where ((( w(()) and (((k) scale-specific weight matrices. Then, masked global multi-head self-attention is applied to concatenations of QKVs from all scales. The single-head formulation is:
[QKT
MaskedGl oba wtt.oobblllttttttt K, V) = Softmax
+ Me V.
Vd

---

Table 1: Evaluations on CelebA-HQ. For all multi-scale methods (Edifylmage (Atzmon 2024
Pyramidal Flow (Jin et al. 2025 and ours), we report averaged GFLOPs and time during inference.
Methods
Backhone
Resolution
Space
FID
Recallf
NFE
Time (s)
Params
GFLOPs
Standard
Resolution (256)
FM (Lipman et al.
2023
U- Net
256 256
Image
7.34
128
LDM [Rombach
2022
U-Net
256 256
Latent
5.11
0.49
2.90
150M
10.2
LFM 1550
DIT-L//2
256 256
Latent
5.26
0.46
1.70
541M
22.1
Pyramial F Flow Um el al. 2025
DIT-L/2
256 x 256
Latent
11.20
0.48
90
1.85
S44M
14.2
EdifyImage (Atziion
DIT-L/2
256 256
Image
0.47
2.10
602M
28.9
Ours
DIT-L/2
256 256
Latent
3.53
0.53
80
1.51
612M
16.5
High Resolation (512 and 1024)
LFM Dao et al.
2023
DIT-L/2
512 x 512
Latent
6.35
0.41
93
2.90
S44M
43.5
D/T-1/2
Latent
2.60
LFM
Dao al 2023
DiT-L/2
1024 1024
Latent
8.12
0.34
100
4.20
544M
154.8
Ours
D/T-L/2
1024 1024
Latent
5.51
0.39
3.30
680M
148.2
are concatenations of scale-specific QKVs, and d is the feature dimension. We use block causal mask (Tian al. 2024) Mc to ensure that each scale & can only attend to scales smaller than or equal to k (k' 2 k). The output of the global attention, unified sequence of token representations, subsequently partitioned according to scale, yielding separate feature sequences for each scale. Each scale's feature is then scaled by (+)), Finally, we apply the PostAt tnMod module, which consists of layer normalization,
where Q = IQ( K
K
V = [V())....
a scale-and -ni-sf operation (using 72
(k) and ()a)), point-wise feed-forward network (FFN), and
final scaling by (*) Residual connections are applied to connect scale-wise representations.
EXPERIMENTS
5.1 EXPERIMENTAL SETUP
Datasets. We conduct experiments two datasets: CelebA-HQ (Karras et al., 2018 and Ima- geNet (Deng et al. 2009). We use the term "resolution" indicate the largest-scale resolution we trying to generate (which is the resolution of the output to sampling algorithm Algorithm 2}. For CelebA-HQ. we experiment with resolutions 256 x 256, 512 x 512, and 1024 x 1024. For ImageNet, the resolution is set at 256 256 due to limited resources. CelebA-HQ is unconditional, while ImageNet is conditioned on class labels. The VAE down-sample factor eight, so the largest latent 32 32. We experiment with varied classifier-free guidance (CFG) (Ho and Salimans 2022) on ImageNet, while CFG is not enabled by default.
Baselines. We benchmark and compare against several flow matching baselines on CelebA-HQ. including LFM (Dao et al. 2023), which is a single-scale baseline. We also compare with a recent multi-scale method called Pyramida1Fl Fo (Jin et al. 2025) in the task of image generation. Be- sides, we compare with Edi fy Image, which is an mmae-sspace method using multi-scale generation. re-implement Edi fy Image and Pyrami 1Flow under the flow matching framework for comparison. On ImageNet, in both diffusion and flow matching paradigms. All models use DiT-L/2 for CelebA-HQ and we experiment with DiT-B/2 and DiT-XI/2 for ImageNet. We utilize the Dormand-Pring method (dopri5) implemented in the torchdiffeq library (Chen et (018).. We adopt the Fréchet inception distance (Heusel et al. 2017) with 50K images the main metric.
further evaluate model against broad range of recent works
VAE. While popular choice of VAE is the SDVAE (Rombach et al. 2022). a recent work called EQVAE (Kouzelis et al. 2025) introduces an equivariant regularization technique that enhances latent space structure by preserving scaling transformations. In practice, we find that EQVAE greatly benefits our multi-scale approach because it offers equivalent representations across scales. Since EQVAE is only trained on 256 x 256, we use SDVAE instead for higher resolutions.
Hyperparameters and training settings. For experiments that generate resolutions 256 x 256, use two levels in all multi-scale methods (Pyrami da Flw, Edi fy Image, and ours), where
7

---

Figure 3: Qualitative results on CelebA-HQ 1024 (left two), 512 (middle two), and 256 (right).
Table 2: Ablation studies on CelebA-HQ. We analyze various design choices, including VAE archi- tecture, mixture-of- Trannsfforrer (MoT) design, noise schedule, and other modeling configurations. We report FID-50K scores on 256 x 256 resolution images. Our default settings are marked in gray
(a) VAE choices. EQVAE (Kouzelis et al. 2025) ben-
(h) MoT design. Comparison between separate weights models and our proposed MoT model, MoT can reduce the GFL.Pss by selecting experts.
efits our method over SDVAE (Rombach et al. 2022 but it cannot improve LFM (Dao et al. 2002)).
Method
Ours (SDVAE) (EQVAE) (SDVAR) (EQVAE)
LFM
LFM
Ours
Metric
Separate Model
MoT
GFLOPs
38.9
16.5
FID
5.26
7.77
4.37
3.53
FID
3.60
3.53
(c) Causal masking. "None" means no mask used,
(d) Critical time point T'. Compare T values, which
"Self" means each scale is only attended on itself.
determines the temporal segments of two scales.
Mask
None
Self
Causal
T
0.1
0.2
0.5
0.9
FID
3.91
5.19
3.53
FID
5.12
4.37
3.53
4.92
(c) Learning rate decay final LR. The final learning rate of x 10- achieves optimal performance, with both higher and lower values degrading results.
(f)
Noise schedule. The simple linear schedule out- performs GVP our model, refer Equation {
Noise
LFM
LFM
Ours (Linear)
Ours (GVP)
Final I.R x 10-4 4
10 5
10
x 10-7
Schedule (Linear)
(GVP)
FID
4.12
3.81
3.53
4.82
FID
5.26
4.39
3,53
4.10
(g) Number of scales. Two-scale representation achieves optimal performance 256 with more scales increasing complexity without further gains.
(h) Modeling Space. Latent space modeling signifi- cantly outperforms image space for both approaches, with our method showing substantial gains in both.
(LFM) 2 (Ours)
(Ours) (Ours)
Method
LFM
LFM
Ours
Ours (Latent)
Scales
(Image)
(Latent)
(Image)
FID
5.26
3.53
3.59
5.12
FID
11.58
5.26
8.63
3.53
the default time segment is T 0.5. We use three levels for cases where resolutions are higher than 256 x 256, where time segments hyperparameters are T2 = 0.33 and T₃ = 0.67. We use the linear scheduler instead of GVP unless explicitly mentioned. For ImageNet 256 256,
constant Ir x 10 10-4, a global batch size of 256, and an EMA decay 0.9999. We train 600 steps for both the B/2 model and the XI.2 model. We further train the B/2 model until 7M steps following LFM (Dao et al. 2023). For CelebA-HQ, we adopt CosinenAneealing.... (Loshchilov and Hutter 2017) scheduler with an initial learning rate of 2 10-4 and final learning rate of 1 10-6 Training durations vary across resolutions, as higher resolutions typically require more iterations to converge. A complete list of training hyperparameters can be found in Appendix G All models are trained on a computing node with 8 NVIDIA H200 GPUs.
5.2
EXPERIMENTAL RESULTS
Unconditional generation CelebA-HQ. We evaluate method on the CelebA-HQ dataset resolutions of 256 x 256, 512 x 512, and 1024 x 1024, comparing against single-scale and multi-scale flow matching approaches. As shown in Table 1 our method achieves an FID of 3.53 256 256,
8

---

Table Results of class-conditional generation on ImageNet 256 256.
Methods
Backbone
Training Steps
CFG
FID
NFE
Time (s)
GFLOPs
DiT' (Peehles and Xie
2023
DiT-B/2
600K
x
41.27
250
1.87
LFM (Dao et al. 2023
D/T-B/2
600K
X
48.29
89
1.70
5.6
Pyramidal Flow Jmn et al.
2025
DIT-B/2
600K
X
39.40
90
1.74
5.7
Ours
DIT-B/2
600K
36.50 X
80
1.25
4.9
DIT (Peebles and Xie
2023
DIT-XL/2
600K
X
19.50
250
3.50
29.1
LFM (Dao et al. 2023
DiT-XL/2
600K
X
28.37
89
3.32
29.1
Pyramidal Plow (Jn ct al. 2025
DiT-X1/2
600K
X
17.10
90
4.02
29.9
Ours
DIT-XL/2
600K
X
14.38
80
2.85
20.5
LFM Dao
2023
DřT-B/2
X 20.38
89
1.70
LFM (Dao et al
2023
DiT-B/2
7M
1.5
4.46
89
1.70
5.6
Ours
DIT-B/2
7M
X
18.55
80
1.25
4,9
Ours
DIT-B/2
7M
1.5
4.12
80
1.25
4.9
Figure 4: Qualitative results on ImageNet 256 x 256 using our trained B/2 model with CFG-1.5.
outperforming LFM (5.26) and Pyramidal Flow (11.20). The performance gap becomes more pronounced at higher resolutions, where our method achieves FID scores of 4.04 and 5.51 at 512 x 512 and 1024 1024, respectively, compared to 6.35 and 8.12 for LFM. In particular,
method not only produces higher quality samples, but also requires fewer function evaluations (NFE) and less inference time compared flow matching baselines (LEM (Dao
2023), Pyrami da (Jin) et al. 2025), and Edi idiif f Image (Atzmon et al. 2024)), demonstrating the efficiency of our multi- scale architecture in preserving image fidelity while reducing computational requirements. While Relay Diffusion obtains a competitive FID of 3.15 at 256 x 256, it relies on image-space modeling and U-Net backbone, leading to significantly higher inference for ours). This indicates fundamentally different computational regime, as our latent-space DiT architecture provides far more favorable tradeoff between image fidelity and efficiency. Furthermore, Relay Diffusion is strictly formulated
(1221 GFLOPs vs. 16.5 GFLOPs
two-stage framework and, to our knowledge, has not been demonstrated beyond 256 x 256 resolutions, whereas our Laplacian multi-scale formulation scales effectively to 512 x 512 and 1024 x 1024 while retaining efficiency gains. Figure 3 shows qualitative results of our method across different resolutions, highlighting high-fidelity detail preservation and demonstrating that multi-scale formulation effective
megapixel resolution.
Ablation studies. Our comprehensive ablation studies CelebA-HQ (256 256 resolution) demonstrate several key insights for LapFl 1 ow. As shown in Table the choice of VAE architecture significantly impacts performance, with EQVAE providing substantial benefits our approach while proving detrimental to the baseline LFM. The proposed mixture-of-transformee (MoT) design (Table 2b) achieves both computational efficiency and improved generation quality compared to separate models. Furthermore, we find causal masking is optimal among attention strategies (Table 2c). We then ablate the choice of critical time points. For two-scale experiments, we observe critical time point of T = 0.5 (Table 2d strikes the ideal balance between model expressivity and complexity. Here we want to
that two scales there is only one critical time point T. As summarized in Table 2 and further discussed in Appendix D the linear pair of = 1 and a, (k) 1- achieves the strongest performance, outperforming quadratic and cubic decay well as the GVP formulation. As shown in Table 2g two scales yield the best performance at 256x256. This due to the latent resolution being only 32 32; adding third scale would require 8 8 stage, which we find too small to provide reliable semantic guidance during early flow integration. To further validate this resouution-dependent behavior, we extend this ablation to 5122 and 1024 generation. As
I-T

---

shown in Appendix B larger latent grids (64x64 and 128) benefit from a more-scale hierarchy, confirming that higher resolutions may require more number scales of LapFlow. A similar trend is reported in the concurrent work PixelFlow (Chen al. 2025), which observes degraded performance when the initial kickoff sequence becomes too short, although their model operates in pixel space rather than latent space. To validate temporal segmentation beyond the two-scale case, additionally ablate three-scale configurations and show that a balanced time allocation across scales yields the best results; see Appendix A for FID comparisons at 1024 1024. We further study the effect of the noise and coupling schedules used in our flow parameterization. Specifically, we compare the linear transport and noise decays with alternative polynomial and GVP-based schedules. These results support our choice of simple scale-wise linear schedules for stable multi-scale flow evolution. The performance advantage of latent space modeling instead of the image space counterpart particularly noteworthy (Table 2h.. where our approach substantially outperforms both image-space implementations and the LFM baseline two domains. These findings, combined with our optimized learning rate decay with final LR of 1 x 10 (Table 2eh, collectively contribute to our full model.
generation on ImageNet. As illustrated in Figure our method consis- tently shows superior performance compared to LFM (Dao et al. 2023 for both B/2 and XL/2 models. We present numerical results in Table 3 and qualitative results in Figure 4 Our ap- proach achieves the best FID score of 36.50 with the B/2 backbone and 14.38 with the XL/2 backbone 600K training steps, outperforming all baseline methods including DiT (Peebles) and Xie| 2023). LFM (Dao et al.) 2023), and Pyramidal Flow (Jin et al., 2025). Notably, our method works under fewer NFE (80 89-250) and demonstrates improved computational ef- ficiency with lower inference time (1.25s vs. 1.70-1.87s for B/2) and reduced GFLOPs (4.9 5.6-5.7 for B/2). When trained for 7M steps with classifier-free guidance (CFG=1.55, approach achieves an FID score of 4.12, surpassing LFM's 4.46 while being more efficient.
60
LFM-8.2
CONCLUSION
LFM XL2
Ours-822
Oun-XUU
In this paper, we presented LapFlow low, a novel framework that advances genera- tive modeling by integrating parallel multi- scale generation within the flow match-
FID-50K
30
ing paradigm. Our approach decomposes
20
images into Laplacian pyramid residu- als and processes them simultaneously through specialized MOT architecture with causal attention mechanisms that en- force hierarchical information flow. Exten- sive experimental results on CelebA-HO -HQ and ImageNet datasets demonstrate that our method consistently achieves superior FID scores than prior flow matching works while requiring fewer function evaluations and reduced computational resources dur- ing sampling. Performance advantages are particularly pronounced higher resolu- tions (up to 1024x102444 demonstrating its superior scalability for complex, detail-rich generation tasks even with limited training resources. An interesting future direction to integrate advanced training accelerators such REPA (Yu et al. 2025), which has demonstrated significantly faster convergence for flow-based generative models. We expect that combining training accelerators with the multi-scale Laplacian formulation could further reduce training cost.
10
200K
300K
600K
Training Steps
Figure 5: FID-50K on ImageNet (256x256) across training iterations comparing LFM (Dao et al. 2023) with ours using two backbones (B/2 and XL/2).
10

---

7 ACKNOWLEDGMENTS
The authors are supported in part by grant NSF 2409016.
REFERENCES
Michael S Albergo and Eric Vanden- Eijnden. Building normalizing flows with stochastic interpolants. arXiv preprint urXiv:2209.15529 2022.
Yuval Atzmon, Maciej Bala, Yogesh Balaji, Tiffany Cai, Yin Cui, Jiaojiao Fan, Yunhao Ge, Siddharth Gururani, Jacob Huffmann Ronald Isaac, Pooya Jannaty, Tero Karras, Grace Lam, J. Lewis, Aaron Licata, Yen-Chen Lin, Yu Liu, Qianli Ma, Arun Mallya, Ashlee Marr, Doug Mendez, Seungjun Nah, Chris Pruett, Fitsum Reda, Jiaming Song. Ting-Chun Wang, Fangyin Wei, Xiaohui Zeng, Yu Zeng, and Qinsheng Zhang. Edify image: High-quality image generation with pixel space laplacian diffusion models, 2024. URL httpt:ttt//artit
org/ abs 07126
Georgios Batzolis, Jan Stanczuk, Carola-Bibiane Schönlieb, and Christian Etmann. Non-uniform diffusion models, 2022. /tl.:ttss///xii..r/////a/a 229770978
Ricky T. Q. Chen, Yulia Rubanova, Jesse Bettencourt, and David Duvenaud. Neural ordinary differential equations. Advances in Neural Information Processing Systems, 2018.
Shoufa Chen, Chongjian Ge, Shilong Zhang, Peize Sun, and Ping Luo. Pixelflow: Pixel-space generative models with flow, 2025. M http::::/........t///
Quan Dao, Hao Phung, Binh Nguyen, and Anh Tran. Flow matching in latent space, 2023. URL httts::/arxiv.ct http://axxivv.rr/a////3/3/////
Jia Deng, Wei Dong, Richard Socher, Ii-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hier- archical image database. 2009 IEEE Conference on Computer Vision and Pattern Recognition, pages 248-255, 2009.
doi: 10. RLL.1///CVVR.20095500000
Prafulla Dhariwal and Alexander Quinn Nichol. Diffusion models beat GANs on image synthesis. In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https: https:s//ppereview..o wwwpeeewwwww.wefeoooooeeeeeeeeee forett/oooummcomm
AARuCvzaVE.
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly. et al. An image is worth 16x16 words: Transformers for image recognition scale. arXiv preprint arXiv:2010. 19299, 2020.
Patrick Esser, Sumith Kulal, Andreas Blattmann, Rahim Entezari. Jonas Müller, Harry Saini, Yam Levi, Dominik Lorenz, Axel Sauer, Frederic Boesel, et Scaling rectified flow transformers for high-resolution image synthesis. In Forty-first international conference machine learning, 2024.
William Fedus, Barret Zoph, and Noam Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. Journal of Machine Learning Research, 23(120):1-39 2022.
Google DeepMind. Veo 2. httppp////eeeeeehh...oooo/cee/er 2025. Accessed: 2025-05-09.
Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by two time-scale update rule converge local nash equilibrium. Advances in neural information processing systems, 30, 2017.
Jonathan Ho and Tim Salimans. Classifier- diffusion guidance. arXiv preprint arXiv:2207.12598 2022.
Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems, 33:6840-6851, 2020.
11

---

Jonathan Ho, Chitwan Saharia, William Chan, David Fleet, Mohammad Norouzi, and Tim Salimans. Cascaded diffusion models for high fidelity image generation. Journal of Machine Learning Research, 23(47):1-33, 2022.
Yang Jin, Zhicheng Sun, Ningyuan Li, Kun Xu, Kun Xu, Hao Jiang, Nan Zhuang, Quzhe Huang, Yang Song, Yadong MU, and Zhouchen Lin. Pyramidal flow matching for efficient video generative modeling. In The Thirteenth International Conference on Learning Representations, 2025. URL
htttps://ppenrewe weww net/ h 6oooumm2id=-66N2cRQQ0
Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of GANs for improved quality, stability, and variation. In International Conference on Learning Representations, 2018. URL URL /ttp:::://///eeeeeeeeeeee net htte//oooommmmo---oeeoe
Theodoros Kouzelis, loannis Kakogeorgiou, Spyros Gidaris, and Nikos Komodakis. Eq-vae: Equivariance regularized latent space for improved generative image modeling, 2025, URL
https://aaxiz> org/ wwtpg//b/////// abs2 09509
Wei-Sheng Lai, Jia-Bin Huang, Narendra Ahuja, and Ming-Hsuan Yang. Deep laplacian pyramid networks for fast and accurate super-resolution. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 624-632, 2017.
Weixin Liang, Lili Yu, Liang Luo, Srinivasan Iyer, Ning Dong, Chunting Zhou, Gargi Ghosh, Mike Lewis, Wen-tau Yih, Luke Zettlemoyer, al. fixture-of-transfoomme A sparse and scalable architecture for multi-modal foundation models. arXiv preprint arXiv:2411.04990 2024.
Yaron Lipman, Ricky T. Q. Chen, Heli Ben-Hamu, Maximilian Nickel, and Matthew Le. Flow matching for generative modeling. The Eleventh International Conference on Learning Repre- sentations, 2023. BRL https: // //t:///pp//... http://pppeeeeeeeeeeeeeeeeeeeeee http://wwe.eettuneeeee
.nt. Eorum? wttpiummmiipPppo www.dddddPPMDDV
Xingchao Liu, Chengyue Gong, and Qiang Liu. Flow straight and fast: Learning to generate and transfer data with rectified flow. arXiv preprint arXiv:2209.0300)) 2022.
Ilya Loshchilov and Frank Hutter. SGDR: Stochastic gradient descent with warm restarts. In International Conference on Learning Representations, 2017. URL htt.:ttts///ppeeeeee/
bet//forum2id-Skg$$See
Nanye Ma, Mark Goldstein, Michael S Albergo, Nicholas M Boffi, Eric Vanden- Eijden-Eijnden, and Saining Xie. Sit: Exploring flow and diffusion-based generative models with scalable interpolant transformers. In European Conference on Computer Vision, pages 23-40. Springer, 2024.
William Peebles and Saining Xie. Scalable diffusion models with transformers. In Proceedings of the IEEF/CVF International Conference on Computer Vision, pages
2023.
Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. High- resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF confer- ence on computer vision and pattern recognition, pages 10684-10695, 2022.
Chitwan Saharia, William Chan, Saurabh Saxena, Lala Li, Jay Whang, Emily L. Denton, Kamyar Ghasemipour, Raphael Gontijo Lopes, Bureu Karagol Ayan, Tim Salimans, et al. Photorealistic text-to-image diffusion models with deep language understanding. Advances in neural information processing systems, 35:36479-36494, 2022.
Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoe Le, Geoffrey Hinton, and Jeff Dean. Outragcously large neural networks: The sparscly-gated mixture-of-experts layer. In International Conference on Learning Representations (ICLR), 2017.
Peize Sun, Yi Jiang, Shoufa Chen, Shilong Zhang, Bingyue Peng, Ping Luo, and Zehuan Yuan. Autoregressive model beats diffusion: Llama for scalable image generation. arXiv preprint arXiv:2406.06555, 2024.
Jiayan Teng, Wendi Zheng, Ming Ding, Wenyi Hong. Jianqiao Wangni, Zhuoyi Yang, and Jie Tang. Relay diffusiom: Unifying diffusion process across resolutions for image synthesis. In The Twelfth International Conference on Learning Representations, 2024, URL URL hattps://openreiiees
het./forum2io=44lccbl.c
12

---

Keyu Tian, Yi Jiang. Zehuan Yuan, BINGYUE PENG, and Liwei Wang. Visual autoregressive modeling: Scalable image generation via next-scale prediction. In The ehirty- Annual Conference on Neural Information Processing Systems, 2024. URL httpp:///peneeeieer net//foum? i LL67f
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, ukasz Kaiser, and Illia Polosukhin. Attention all you need. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Gamett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017. URL https: wgs.ooeeeeddn.........o. new. cww.ipp.cc/pppp.rrr...eee.epepee www.fflleepppprrr/ essppaper2011/ File:3ffoo2243S70ee1110001o22123
Guyon, U. Von
Paper.
Sihyun Yu, Sangkyung Kwak, Huiwon Jang. Jongheon Jeong, Jonathan Huang, Jinwoo Shin, and Saining Xie. Representation alignment for generation: Training diffusion transformers is easier than you think. In International Conference on Learning Representations, 2025.
Shiwei Zhang, Jiayu Wang, Yingya Zhang. Kang Zhao, Hangjie Yuan, Zhiwu Qin. Xiang Wang, Deli Zhao, and Jingren Zhou. 12vgen-xl: High-quality image-to-videe synthesis via cascaded diffusion models. arXiv preprint arXiv:231 2..i:::3311.411100 1.0415,, 2023.
13

---

APPENDIX
A TEMPORAL SEGMENTATION THRESHOLD VALIDATION
As discussed in the main paper, progressive multi-scale diffusion training strategy allocates timesteps across spatial scales using temporal segmentation thresholds. While Table presents an ablation on a single segmentation point I in a two-scale setting, we provide additional justification for the selected three-scale thresholds. To address this concern, we provide extended ablation experiments on the temporal segmentation thresholds T1 and T2 for three-scale configuration at resolution of 1024 1024. Except for the threshold values, all other training configurations are identical to Table
Results are presented in Table These results empirically validate our threshold choice in the main paper, demonstrating that a balanced temporal allocation across scales (7₃ 0.67, T2 = 0.33) yields the best generation quality. This trend is consistent with our two-scale observations, where overly early or late transitions led to degraded FID.
We hypothesize that allocating sufficient diffusion steps to the coarse-scale stage stabilizes global structures before introducing sigh-frequency refinements in later stages. In contrast, excessively delayed transitions (c.g., T3 = 0.90) limit the optimization high-resolution layers, while overly early transitions (c.g.. T-2 0.10) destabilize global consistency and lead to artifacts.
complete grid search for optimal segmentation computationally prohibitive at high resolutions; however, the reported results provide strong empirical justification for selected thresholds.
Practical Recommendation. Based on this analysis, we recommend the following default heuristic for future multi-scale diffusion training:
2
T3
(10)
3'
3'
which we found to consistently improve stability and generation quality.
B ADDITIONAL ANALYSIS: NUMBER OF SCALES AT HIGHER RESOLUTIONS
In the main paper, we show that at 256 resolution, a two-scale Laplacian hierarchy achieves the best performance. Here, extend this analysis to higher resolutions.
As the resolution increases, the VAE latent grids become larger:
256 32 x 32, 512
64 x 64, 1024 128 128.
We present a further study at larger scales. Other unmentioned setups are the same as Table 2g
Table 4: FID vs. number of Laplacian scales across 256-1024 resolutions on CelebA-HQ.
Resolution
Latent size
# Scales
Decomposition
FID
256x256
32x32
32 + 16
3.53
256x256
32x32
3
32 - 16 - 8
3.59
256x256
32x32
32 - 16 +
5.12
512x512
64x64
2
64 + 32
5,45
512x512
64x64
64 32 -
4.04
512x512
64x64
4
64 - 32 - 16 - 8
4.12
1024x1024
128x 128
128 - 64
6.62
1024 1024
128x 128
128 - 64 + 32
5.51
1024x 1024
128x 128
128 - 64 32 16
5.45
At low resolution, additional Laplacian levels produce coarse grids too small to stabilize flow trajecto- ries, whereas at higher resolution, three-scale Laplacian modeling delivers consistent improvements. These results consistent with observations in concurrent PixelFlow (Chen et al.) 2025). which reports degraded performance when early-stage spatial support becomes too small, despite operating in pixel (not latent) space.
14

---

Resolution
T
FID
x024x 1024
0.67
0.33
5.51
1024 1024
0.90
0.33
6.72
1024x 1024
0.67
0.10
8.12
Table 5: Three-scale temporal segmentation ablation at 1024 resolution. Balanced allocation (T1 0.67, 72 0.33) achieves the best FID, confirming the trend observed in the two-scale case.
C TIME- WIIGHEED COMPLEXITY ANALYSIS OF MULTI-SCALE MoT
We provide formal complexity analysis of the proposed Mixture-of-Transformeee Transffrooosssss (MoT) architecture, taking into account that different Laplacian scales are active over different segments of the ODE time domain. Although global attention is applied over the concatenated token sequence of active scales at each time segment, the progressively shortened active ranges of higher-resolution scales reduce the time-averaged number of tokens processed during sampling.
Under the standard quadratic attention cost used in transformer analysis (Vaswani et al. 2017) the per-layer cost scales as 2dd, where N is the number of latent tokens and d is the embedding dimension; full self-attention scales quadratically with sequence length.
Let the finest latent resolution
x W with downsampling factor 8, so the largest-scale latent has N !W tokens. Following the Laplacian decomposition in Equation (2). the per-scale token counts - the three spatial resolutions
(0) N, _Q) N/4, and N2 N/ During sampling, the ODE is solved in three segments: from E [o, T2) only the coarsest scale is active, from & E [72, Ti
the coarsest and mid scales are active, and from [Ti, 1] all three scales are active. Thus, the total number of tokens processed in each segment is
(11) Let the segment lengths be At2 T2 O. Ar = Ti T2, and Aoo 1 - Ti. With our default choice T.2 and 71 3t (Sec. 4.3), have Ale An Aly Because attention cost in the k-thh segment is proportional to NEd. the time-weighhed attention complexity of one MoT layer over the whole ODE trajectory is
N2 = (2) = 16
N1 =1=N()) + (2)
SN 16
No = (o) + +N() + +2(2)
21N 16
21N 2 16
CostMOT Al2N3d AA AdNid AoNo
N
+
5N 16
d =z 0.61 N2d.
16
(12)
Therefore, under our default three-scale configuration the MoT layer enjoys reduction factor of about 0.61 in its attention term, i.e., roughly a 1.6x lower attention cost than single-scale DiT with the same finest latent size.
We emphasize that this is an idcalized, time-weighted analysis focusing on the dominant quadratic attention term. Empirical GFLOPs and runtime may differ from this constant factor due to (i) the adaptive ODE solver (Dormand-Prince producing different numbers of function evaluations across samples, (ii) kernel-level hardware efficiency, (iii) upsampling and residual fusion costs in Laplacian reconstruction, and (iv) framework-dependee attention kernel implementations. Nevertheless, the observed improvements Tables attention cost.
and 3 are consistent with this theoretical reduction effective
D ADDITIONAL DISCUSSION ON LINEAR TRANSPORT AND NOISE SCHEDULES
Clarification of schedule formulation. Both the noise decay schedule a² 1 t and the transport (coupling) schedule og I-T44
2-Tx+1 are linear functions of l. In particular,
1- 1-Tx41 -Tk+1
1
Tx+1
a
f
(13)
1 Tk+1
1 Th41
1 Tx+1
15

---

which is linear mapping that increases from 0 to 1 as moves from Tx+1 to 1. The two linear (k)
schedules play distinct roles: of (A) is globally shared across all scales, while a; provides a shift- rescale transformation that activates Laplacian levels gradually after their transition threshold Tk+1- This design offers a simple and stable mechanism for connecting consecutive Laplacian scales without requiring re-noising steps used in related multi-scale flow models such as Jin et al. (2025).
Ablation on alternative schedule choices. To support this design choice, we further evaluate several alternative combinations of a, and a; at the 256 x 256 resolution. This experiment extends the analysis in Table 2F while keeping all other settings identical the default configuration in Table 2
Noise schedule of
Coupling schedule aj
FID J (256")
1 (Linear)
I- Tx+1 (Linear)
f-Th-1
3.53
cos [ (GVP)
sin
2(1-Te41)
a(t-Te11)
(GVP)
4.10
(1 t)² (Quadratic)
T
(Linear)
3.78
(1 1)3 (Cubic)
(Linear)
4.25
These results indicate that the simple linear schedule o/ mance, while steeper decays such as (1 - 1)² and (1 11-1) 1) lead to noticeably worse sample quality.
t achieves the best overall perfor-
The GVP variant also performs competitively, but the linear pair (o!*), ax is both simpler and more stable across a wide range of settings, reinforcing the choice of linear schedules as the default configuration in our framework.
E EDIFYIMAGE FORMULATION DETAILS
The noising process is described as weighted interpolation between the clean image X1 and the standard Gaussian noise x!" AN I(0)) (note this is not residual) corresponding to the largest
(k) scale, where we get a noisy state x; for scale k = 0, 1, via:
k)) (1 - (owo)))o((x)) (0) 2n) + (k) xx.
(14)
where we use factor 2 for better compatibility of sampling across multiple scales, and we provide more discussions on this in the supplementary.
(k) Based the noisy target x
we construct the following ground-true velocity:
(k) (k) ut (x) (x) A
dx
dt
(15)
-Doon (0) , + dp (x1,
=
dt
where the last term is crucial because the data mean (x1, t) changes through timestep t. Based on this velocity, the model is trained through the following now-mitching target (Lipman et al. 2023):
E te
xx) 1l
(k) (xx u. (M)
(xc (1) (x:
(16)
where t is sampled from [Tk+1, 1] (we define T3 O, and To 1), (x
(t))
xx is the underlying
conditional probability path towards x, determined by (1) (x!" x1), and v (x! scale machine learning model to model the flow.
(b) (8) is the multi-
F PYRAMIDALFLOR
16

---

Algorithm 3 Pyramidal Flow Training
Input: Dataset of images D, number of stages K, number of epochs M, list of K start and end
times Sk. Ej:
2: Output: Trained flow model v(x, t).
3: Initialize the model weights randomly
4: for epoch=
5: for clean data X1 in D do
6: Determine the stage for X1
7: Sample timestep
(sk cx)
8:
Sample the start point Xg (0,
9:
Down-sample noise x
(k) Down(xo, 2*)
10:
Compute start points as Xs 8k Up Up(Down(xx 2k+l)) + (1 5k)
X0
11:
Compute endpoints x (k) ex Down 2*)
(k) X0
(R)
12:
Compute the midpoints as x
(k) c-t x
(k)
t-s Xe
(k) x1)
x(A)
Define the target as Ue (X:
Calculate loss MSE(u, u, (x: (8) (x),, v(x;
(1)))
15:
Run back-propagation, update parameters of
16:
end for
17:
end for
18: Return: V
Algorithm Pyramidal Flow Sampling
Input: Trained flow model v, number of stages K, list of K start times sk. total number of
timesteps N.
2: Output: Generated image.
3: Sample the starting point x k N (0, I. I.
4: Sample Gaussian noise maximum resolution xo 10,
5: for stage h = K - 1 to 0 do
X ODEINT(V (k) [Sk, (k)
(k-1)
6:
X82
7: Define the re-noising factor nık = (1 - 54-1) (Down(Xo. (0.00.00.22)) 2k-1)
Up(Down(So: 2+)))
8: Define the next starting point (k-1) Up(x(()) (k)) + +
9: end for
10: Return: XK-1
17

---

Algorithm 5 Ediffymaae Flow Matching Training
1: Input: Dataset of images D, number of epochs M, critical time points Ti and T2, where
< T2 <T> <1
2: Output: Trained flow model V V
3: Initialize the model weights
4: for epoch = 1 to M do
5: for in D do
6: Sample the stage k from uniform distribution over {0, 1,
7: Sample from uniform distribution over [T++1. where To and T3
8:
Sample the start point random Gaussian X0 N0, (())
9:
Compute noisy image x((²)
()Dow)(x
(0) 2* + (x1,))
Compute velocity target u, (R) (xg (8) (x)) -Down(xp
(0) 2*h (x)
dt
Forward the model to get ve (A) (xx(*)
11:
12: Calculate loss MSE (v: (x, (1)), u (1)
(xt (R)
(xi))
13:
Run back paok-propag,tion, update network parameters
14:
end for
15:
end for 16: Return: Trained flow model v
(1) Vi
(0)
Algorithm 6 EdifyImage Flow Matching Sampling
1: Input: Trained flow model v( (0) (1)
(2)
standard Gaussian noise of the largest scale x
(0)
critical time points Tj and T2
2: Output: Largest resolution sample x
3: x/; ODEINT(V;)) (0,T2),, Down (0)
.))
4: x/; Up(xL)) + (1-T2))ooow((x (0) 2) Up(Down(x) (0), 44)) # This is the re-noise step
5: X7 ODEINT(y;)) (1) [i,, (1)
6: T. Up(*))) + (1-T))(x)) - Up(Down(xx)
(0) ODEINT(V; (0) (Ti, 1).11,,1,) (0))
7: 1
8: Return: x
F.1 DISCUSSIONS WITH PIXELFLOW (CHIEN ET AL. 2025)
Here we discuss the relationship between the concurrent work PixelFlow (Chen et al. 2025) and
PyramidalFlow (Jin et al.) 2025). The algorithm of PyramidalFlow is shown in Algorithm 3 Line 10 and Line 11 are exactly the same as Equation (2-3) of the PixelFlow paper, while Line 12 the same as Equation (4) of FixelFlow. PixelFlow also uses a re-noising procedure as in PyramidalFoww, although details are not presented in their paper.
F.2 SAMPLING IN PYRAMID FLOW MATCHING
Sampling from a multiscale Pyramidal Flow model is sequential, starting from stage K - 1 and ending at stage O, where K the number of scales used in training. For each stage, two timesteps are defined: the start time 3y and the end time eg. In this section, assume the stages to have zero time overlap, that is, - = eg. Also, the stages together span the whole time interval, that is, 8K-1 = and c 1. The noise is sampled once in the largest dimension
A/(0, I). Within each stage the sampling process follows the standard flow path between x, = S Up(Down(xx 2*)) + (1 $g-1 1) Down(n, - 1,, and x, Ct-1 Down(x, (" 2h-1) (1 cg-1) Down(n,
The jump between consecutive stages needs to be handled carefully to enforce the consistency of the flow. Consider the jump from stage l stage k 1. The procedure starts with up-sampling the
18

---

Table 6: Training details across datasets and resolutions. We summarize hyperparameters.
computation complexity, and resource usage across benchmarks. Training time and speed may fluctuate due to hardware conditions.
Training Details
CelebA-HQ 256
CelebA-HQ 512
CelebA-HQ 1024
ImageNet 256
Backbone
DiT-L/2
DiT-L/2
DiT-L/2
DrT-B/2 / DiT-XL/2
Largest latent size
32 32
64 x 64
128 x 128
32 x 32 256
Batch size
256
256
128
Tnit I.R
2e-4
2e-4
20-4
le-4
LR schedule
Anneaiinne
CosineAmnellingL.R
CosineAmnealingg.
N/A
Final LR
Ic-6
lc-6
Ic-6
N/A
Optimizer
AdamW
Adam W
Adam
Adam W
Training epochs
S00
1000
2000
1400/120
Time segments
0.5
0.33, 0.67
0.33, 0.67
0.5
Number of scales
3
2 EQVAF 0,9999
VAF type
EQVAF
SDVAF N/A
SDVAE
EMA decay rate
N/A
Hardware
HxH200 42.2
8xH200
Hx
8x H200
Peak memory per GPU (GB)
82.8
120.5
24.9 / 68.3
Training wall-clock (days)
1.2
3.1
8.3
8.5
endpoint of stage k. yielding
Up(x.) -k-1 UDDown(DD 2")) + (1=s))U((Down(m)) (n,
The distribution of this data differs from the distribution of the startpoint x of the k - 1 stage. Down(x, 1 N (0, ) and similarly Down(æ; 2*) V (0, T. .t), however the up- sampled noise Up(Down(n, 2*)) ~ N (0, E 2z where a block-diagonal matrix that has x blocks of ones on the diagonal and zeroes elsewhere. Then if we define a different block-diagoma
matrix E' with blocks
L (11 -1 1
and set a V ge, and sample m NOO, we have Var(Up(x*) + (1 st-1)a m) Var(x 11), In practice this means that the end of stage k we sample _N 2") and set a Up(x + $k-1)a m the starting point of stage k 1.
G MORE TRAINING DETAILS
We present the detailed training settings in Table 6 highlighting key implementation differences across datasets and resolutions. For CelebA-HQ, we utilize DiT-L/2 backbone across all resolutions while adjusting the number of scales based on complexity two scales for 256 x 256 and three scales for higher resolutions. For ImageNet, we experiment with both DiT-B/2 and DiT-XL/2 backbones to demonstrate scaling properties. Notably, we use EQVAE for our lower-resolution models due to its superior reconstruction quality, while higher-resolution CelebA-HQ models leverage SDVAE for better stability. All models were trained on 8xH200 GPUs, with batch sizes adjusted according to memory constraints.
H LIMITATIONS
First, we didn't train our XL model on ImageNet for 7.M steps due to a restriction of computational resources. This limitation may have prevented our model from reaching its full potential in comparison to diffusion models that are typically trained for significantly longer periods. Second, our approach still requires storing part of the model weights for each scale, which increases memory requirements during training, although our MoT design partially mitigates this issue. Third, while our method shows excellent performance unconditional and conditional generation tasks, have yet
19

---

extended it to conditional generation scenarios such text-to-image synthesis inpainting, which are important applications for generative models. Finally, our method inherits limitations from the VAE architecture used for latent space projection, potentially limiting the fidelity of fine details in generated images. Future work could address these limitations by exploring more efficient parameter- sharing techniques across scales, developing conditional variants of our approach, implementing memory-efficient sampling strategies, and investigating improved latent space representations.
I
IMPACT STATEMENT
This paper presents Laplacian Multi-scale Flow Matching (LapF low), a novel approach for gener- ative image modeling. We believe this work has several potential positive impacts on the research community and society:
Our method improves computational efficiency in high-resolution image generation, potentially reducing the energy consumption and carbon footprint associated with training and deploying generative models. By requiring fewer function evaluations and reduced GFLOPs, LapFlow contributes to more sustainable Al development.
The technical innovations in multi-scale representations and unified transformer architectures may inspire new approaches to other generative tasks beyond images, such as audio, video, and 3D content creation. The proposed coattur--o--ransffrmme architecture with parameter sharing could influence more efficient model designs across various domains.
However, we acknowledge that advances in generative image modeling also come with potential societal concerns. Like other generative models, this technology could be misused create misleading or deceptive content. We encourage responsible development and deployment of systems based on research, including content safeguards and transparent disclosure of Al-generated media.
Our work focuses on advancing the technical capabilities of generative models rather than specific applications. We emphasize that any practical implementation should consider ethical implications and be developed in accordance with responsible Al principles.
20


Reviews:
[{"review_id": "af9KbGQLQr", "reviewer": "Reviewer_uzrb", "summary": "This paper introduces Laplacian Multi-scale Flow Matching (LapFlow), a novel framework designed to improve the efficiency and scalability of generative modeling. To tackle the high computational cost of generating high-resolution images, LapFlow moves away from single-scale generation. The core contribution is a method that decomposes images into multi-scale representations using a Laplacian pyramid. The model is then trained to generate these Laplacian residuals in parallel, which are finally combined using the pyramid reconstruction process to create the full-resolution image.The LapFlow architecture is based on a unified Mixture-of-Transformers (MoT) model, which processes all scales simultaneously. The model employs a progressive multi-stage training and sampling process, generating the coarsest scale first and subsequently adding finer residuals. Experiments conducted on CelebA-HQ and ImageNet demonstrate that LapFlow achieves superior sample quality (lower FID) and scalability, reaching resolutions up to $1024 \\times 1024$. Furthermore, it surpasses existing flow matching baselines in computational efficiency, requiring fewer GFLOPs and achieving faster inference speeds.", "questions": "- The core acceleration benefit stems from avoiding the cost of processing higher resolution scales for the entire duration of the flow matching process. Can the authors provide a formal theoretical derivation of the computational complexity (GFLOPs) of the multi-scale MoT attention mechanism and compare it to the complexity of a single-scale transformer (like DiT) as a function of the total number of tokens across scales? \n\n- For the ablation study on the number of scales (Table 2g), why does the performance degrade when moving from two scales to three and four scales at $256\\times256$ resolution? Does this suggest a fundamental limitation of the Laplacian pyramid decomposition at this resolution, or is it purely a model optimization challenge? \n\n- Can the authors provide an intuition or ablation on how the fixed coefficients $\\sigma_{t}^{(k)}=1-t$ and $\\alpha_{t}^{(k)}=\\frac{t-T_{k+1}}{1-T_{k+1}}$ for the linear path were chosen, particularly the decision to use $1-t$ for the noise decay, which is typically $\\sigma_{t}$ (or $1-\\alpha_{t}$) in flow matching, but here it is explicitly set to $1-t$ regardless of the non-linear $\\alpha_{t}^{(k)}$ term?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 3, "strengths": "+ LapFlow achieves superior FID scores across all tested resolutions, particularly at high resolutions ($1024\\times1024$) where the performance gap is pronounced (e.g., $5.51$ FID vs. $8.12$ for LFM). The method simultaneously requires fewer function evaluations (NFE) and reduced computational resources (GFLOPs and time) compared to baselines, validating its efficiency hypothesis.\n\n+ The use of a unified Mixture-of-Transformers (MoT) model with a causal attention mask to process multiple Laplacian residuals in parallel is an effective solution. This design eliminates the limitations of cascaded models (separate networks) while enforcing hierarchical dependencies.\n\n+ The ablation studies confirm the necessity of key components like the MoT architecture for computational efficiency (GFLOPs reduced from $38.9$ to $16.5$) and the optimality of causal masking over other strategies (FID $3.53$ vs. $5.19$ for self-attention).", "weaknesses": "The progressive training strategy relies on empirically selected critical time points $T_{1}$ and $T_{2}$ to segment the training time range $[T_{k+1}, 1]$ for each scale $k$. While an ablation is provided for a single critical point $T$ in a two-scale setup (Table 2d), a justification for the chosen three-scale points $T_{2}=0.33$ and $T_{1}=0.67$ at higher resolutions is needed. The complexity analysis (GFLOPs and time) reported in the tables is based on the average inference cost. Providing a formal theoretical complexity analysis (similar to the total quadratic cost in tokens in standard DiT) to prove the superior scaling property of the MoT over standard DiT as a function of output resolution would strengthen the theoretical contribution. The two-scale representation achieves optimal performance at $256\\times256$ (Table 2g), which seems counter-intuitive given the general goal of multi-scale modeling. A discussion on why increasing to three or four scales is detrimental (or offers no further gain) in this specific setting is warranted.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "7PfJ813iYy", "reviewer": "Reviewer_jpC7", "summary": "The paper proposes multi-scale flow matching training which offers efficiency inference and enhance the model performance across resolution compared to Edify, LFM and Pyramidal Flow. To enable the multi-scale training, the author proposes to use laplacian representation, jointly training algorithm for multiple scale and inference algorithm.", "questions": "1. Why the face image in resolution 1024 seems much better than 512 and 256 but the FID is lower. The quality of 1024 is close to the real training image.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "1. Paper is well-written and easy to understand\n2. Jointly training multiscale removes the complexity of rescaling noise technique when shifting to different scale like in Relay Diffusion and Pyramidal Flow.\n3. The ablation and experiment is conducted extensively.", "weaknesses": "1. The fig.2 is not clear enough for reader. It would make reader misunderstand that MoT block has no FFN layers.\n2. According to table 2g, two scale representation seems to be the best one, while more scale seems lag behind which not gaining much efficiency during the sampling.\n3. The author should include more comparison with relay diffusion in the table and I would suggest to also compare your method with Pixelflow [1] work.\n4. The results for imagenet is under-training which is hard for reviewer to judge the training convergence on this dataset.\n5. How training framework can be adapted to different architecture like Unet (not transformer) ?\n\nMinor: line 47 is not correct, pyramidal flow is not finetuning technique, it is training technique.\n\n[1] PixelFlow: Pixel‑Space Generative Models with Flow (Chen et al., 2025)", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "EzDFPftfT7", "reviewer": "Reviewer_nXwE", "summary": "The paper proposes LapFlow, a novel Laplacian multiscale flow matching. The proposed model follows a coarse-to-fine generation strategy across k scales in a Laplacian pyramid. It splits the time steps into k segments with k-1 critical points. In the early time steps, the model learns the lowest image scale. After passing each critical point, the Laplacian residual for the next level is added to be learned along with the previous scales. To learn the scales in parallel, the paper employs a mixture-of-transformers (MoT) architecture with causal attention mechanisms. LapFlow outperforms the baseline LFM and the recent multiscale approaches on CelebA-HQ and ImageNet datasets.", "questions": "- Beside inference speed and computation complexitity, memory consumption and training time comparison are recommended to add. \n- L430: The term \"temporal segment value\" was used without definition. How to use that value to construct critical time-step points?\n- It is interesting to see how advanced training techniques like REPA can be integrated in LapFlow to boost training convergence and output model quality.", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The proposed model follows a coarse-to-fine generation strategy, which is theoretically more efficient and easier to extend to higher resolutions compared with the standard approach.\n- To learn the scales in parallel, the paper employs a mixture-of-transformers (MoT) architecture with causal attention mechanisms, which is quite recent and novel.\n- LapFlow outperforms the baseline LFM and the recent multiscale approaches in performance and efficiency.", "weaknesses": "- Beside inference speed and computation complexitity, memory consumption and training time comparison are recommended to add. \n- Some denotations defined in L210 were used in L140. The authors should define the denotations before using.\n- L430: The term \"temporal segment value\" was used without definition. How to use that value to construct critical time-step points?\n- It is interesting to see how advanced training techniques like REPA can be integrated in LapFlow to boost training convergence and output model quality.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)