Multi-Resolution Flow Matching: Training-Free Diffusion Acceleration via Staged Sampling

Xingyu Zheng, Xianglong Liu, Yifu Ding, Weilun Feng, Junqing Lin, Jinyang Guo, Haotong Qin

MrFlow accelerates diffusion by generating structure at low resolution, upscaling via GANs, and refining with noise-injected high-resolution steps.

How can we accelerate high-resolution text-to-image diffusion models without training or custom kernels by using a staged, multi-resolution sampling strategy?

Diffusion models are computationally expensive because they perform high-resolution denoising across many timesteps. This cost scales quadratically with the number of image tokens, making high-resolution generation slow on standard hardware. MrFlow accelerates this by splitting the process: it generates the global structure at low resolution, uses a pretrained GAN to upscale the image in pixel space, and performs a single high-resolution refinement step after injecting low-strength noise to correct high-frequency artifacts. This training-free pipeline achieves over 10× speedup on FLUX.1-dev and Qwen-Image while maintaining generation quality within 1% of native trajectories, and can be combined with existing distillation methods for up to 25× acceleration.

Paper Primer

The core mechanism hinges on the observation that low-resolution sampling efficiently captures global structure, while high-resolution refinement only needs to correct local high-frequency residuals. By injecting low-strength noise after pixel-space super-resolution, the model forces the high-resolution flow prior to resample only the high-frequency band, effectively "fixing" GAN-induced artifacts without needing a full denoising schedule.

MrFlow achieves 10× end-to-end acceleration without training or runtime dynamic identification.

Quantitative evaluation on FLUX.1-dev and Qwen-Image-20B using OneIG-Bench metrics. Maintains generation quality within a 1% gap relative to native 50-step inference.

Orthogonal compatibility with timestep distillation.

Combining MrFlow with pre-trained Pi-Flow weights.

Why perform super-resolution in pixel space rather than the latent space?

Pixel space is a more robust domain for upsampling because natural image priors—edges and textures—are defined by pixels. Furthermore, the VAE encoder acts as a lightweight regularizer that attenuates high-frequency components exceeding the training distribution, which helps stabilize the output before the final refinement.

Why is only one high-resolution step sufficient for refinement?

The noised super-resolved latent is already close to the clean endpoint, where the flow trajectory is naturally straighter. Measurements show that a single Euler step at low noise strength achieves a CLIP consistency of 0.9974 relative to a multi-step reference, making additional steps redundant.

MrFlow demonstrates that multi-resolution pipelines can bypass the need for expensive training or complex runtime token-pruning by leveraging the frequency-specific strengths of different sampling stages. It establishes a new baseline for training-free acceleration that is both hardware-agnostic and stackable with existing distillation techniques.

Introduction and Motivation

Full-resolution diffusion spends most compute on unnecessary high-frequency details, motivating a multi-resolution approach.

Full-resolution diffusion models allocate the majority of their compute to refining high-frequency details that contribute little to the overall image semantics, leading to costly inference. Existing training-free multi-resolution strategies can speed up generation by over 5× but typically introduce blurring because they upsample in latent space, which lacks fine-grained pixel information.

High-frequency details dominate the computational budget of diffusion sampling while offering minimal semantic gain, so eliminating or postponing their processing can dramatically cut inference cost.

The inefficiency of full-resolution denoising drives the need for multi-resolution strategies.

Related Acceleration Methods

Key prior approaches to diffusion acceleration, multi‑resolution generation, and super‑resolution.

Flow matching (Lipman et al., 2022) and its variant rectified flow (Liu et al., 2022) recast diffusion training as learning a velocity field along linear interpolants between data and noise. For a data sample $x_0$ and noise $\epsilon\sim\mathcal{N}(0,I)$ the forward process is $x_t=(1-\sigma_t)x_0+\sigma_t\epsilon$, and the model learns $v_\theta(x_t,t)\approx\mathbb{E}[\epsilon-x_0\mid x_t]$. Sampling integrates $\dot{x}_t=v_\theta$ from $t=1$ to $t=0$.

Instead of predicting a denoising direction at each timestep, the model learns a single continuous velocity that moves a noisy sample back toward the data distribution.

Hardware‑oriented techniques that compress model weights or reduce attention complexity, yielding modest speedups that still depend on specific accelerators.

Diffusion‑specific strategies that cut the number of sampling steps or reuse intermediate activations, achieving acceleration without hardware changes.

Teacher‑student distillation that trains a smaller number of timesteps to mimic a full‑step diffusion, requiring costly fine‑tuning.

Generates images progressively, first at low resolution then up‑sampling, exploiting the natural information hierarchy of visual data.

Focuses on producing images larger than the model’s native resolution, without explicit concern for inference speed.

Three families of image enhancement: regression‑based (SwinIR), GAN‑based (Real‑ESRGAN), and diffusion‑based (OSEDiff); plus repainting methods that edit images via controlled noising.

The MrFlow Strategy

MrFlow accelerates diffusion by generating structure at low resolution then refining high‑resolution details.

Generating high‑resolution images with diffusion is costly because most compute is spent on fine details that could be added later.

First synthesize a coarse image in a compact latent space, upscale it to pixel space, then add a tiny amount of high‑frequency noise before a single high‑resolution refinement step.

The low‑resolution ODE scales roughly linearly with the number of image tokens, yielding about a 4× speedup when each spatial dimension is halved.

Step 1: Sample $z_{LR}^{(1)}\sim\mathcal{N}(0,I)$ → a 4×64×64 tensor of random values.

Step 2: Apply the velocity field once: $z_{t-1}=z_t - v_{\theta}(z_t, t, c)$, reducing variance.

Step 3: Repeat for two more steps, yielding $z_{LR}^{(0)}$ with noticeably smoother patterns.

Step 4: Decode with $D$ to obtain a 64×64 RGB image $x_{LR}$.

Step 5: Upscale $x_{LR}$ to 256×256 using the super‑resolution network.

Step 6: Inject Gaussian noise of std 0.1, then run a single high‑resolution denoising step to produce the final image.

The three ODE steps already encode the global scene, so the final high‑resolution step only needs to correct fine textures.

**Figure 2.** The framework of MrFlow. The compared strategies include the native inference scheme and methods that perform upsampling in the latent space such as LSSGen, RALU and SPEED.

How does MrFlow differ from latent‑upsampling methods like LSSGen that also operate in a low‑resolution latent space?

LSSGen performs a low‑resolution diffusion then directly decodes to high resolution, relying on a separate upsampler that does not receive any high‑resolution refinement. MrFlow, by contrast, inserts a pixel‑space super‑resolution step followed by a dedicated high‑resolution denoising pass, which lets the model correct fine details that latent upsampling alone cannot recover.

Pixel-Space Super-Resolution

Upscaling a low‑resolution image with a pretrained GAN‑based network to recover high‑frequency detail.

The low‑resolution image produced by MrFlow still lacks fine details; we therefore hand it to a dedicated upsampler that works directly on pixels.

We feed the low‑resolution pixel tensor into a pretrained GAN‑based upsampler, which keeps the coarse layout intact while synthesizing plausible high‑frequency textures.

How does this super‑resolution differ from simple bilinear interpolation?

Interpolation merely interpolates neighboring pixel values, preserving the low‑resolution structure but never adding new high‑frequency content. Real‑ESRGAN, by contrast, learns a generative mapping that synthesizes plausible textures and sharp edges, producing a visually richer result at the same computational cost.

Real‑ESRGAN first extracts overlapping $3\times3$ patches, pads the $2\times2$ input, and runs them through its convolutional backbone.

The network predicts a $4\times4$ output; a plausible high‑frequency pattern emerges, e.g. a checkerboard of values $\{12,18,22,28\}$ around the original coarse gradients.

The coarse layout (the monotonic increase from top‑left to bottom‑right) matches the low‑resolution input, while the added variations create sharper edges.

GAN‑based SR can inject realistic texture even when the input provides only a blurry gradient, but because it lacks the original text prompt it may mis‑render fine semantic details.

Two design choices underpin this stage: (1) performing upsampling in pixel space leverages well‑studied image priors (edges, textures, power‑spectrum statistics); (2) choosing a GAN‑based model ensures the upsampler can supply the missing high‑frequency residuals that a simple interpolator cannot.

**Figure 3.** Example comparison of MrFlow adopting different super-resolution strategies on Qwen-Image, where Low Resolution denotes the image after low-resolution generation followed by VAE decoding to the pixel space, with a resolution of $512 \times 512$. The rows of SR and High Resolution Refine are respectively the super-resolved image and the final image after high-resolution refinement, with a resolution of $1024 \times 1024$.

High-Frequency Resampling

Injecting weak noise preserves coarse structure while letting the high‑resolution flow fix fine details.

After the GAN‑based pixel‑space super‑resolution, the latent still carries high‑frequency artefacts that the diffusion prior must correct. Directly feeding this latent into a high‑resolution flow would waste compute on already‑correct low‑frequency structure.

We sprinkle a faint Gaussian “static” onto the latent so that only the fine‑grained details are perturbed, while the coarse layout stays essentially unchanged.

How does this low‑strength noise differ from the full‑strength noise used in standard diffusion sampling?

Standard diffusion starts from pure Gaussian noise ($\sigma$≈1), discarding any prior structure. Low‑strength noise only perturbs the high‑frequency subspace ($\sigma$≈0.1), preserving the coarse layout obtained from the low‑resolution stage while still allowing the diffusion prior to correct fine details.

Compute the scaling factor for the clean latent: $1-\sigma_t = 0.88$.

Scale the clean latent: $0.88 \times z_0 = [0.44,\,-0.264]$.

Scale the noise: $0.12 \times \epsilon = [0.012,\,-0.024]$.

Add the two contributions: $z_t = [0.44+0.012,\,-0.264-0.024] = [0.452,\,-0.288]$.

Only the high‑frequency components (the small deviations) are altered; the dominant low‑frequency direction (the sign and magnitude of the first entry) remains essentially unchanged.

**Figure 4.** Images generated by MrFlow under different high-resolution step configurations on Qwen-Image.

High-Resolution Refinement

Recover fine details with a single low‑strength Euler step after super‑resolution.

The high‑resolution stage must fix the local artifacts left by the super‑resolution output, but we cannot afford a full diffusion chain at full size. By exploiting the fact that the low‑strength noising leaves the latent already close to the clean target, a single Euler update suffices to add the missing fine detail.

Think of a sketch that already captures the overall shape; a single fine brushstroke is enough to sharpen the edges without redrawing the whole picture.

Compute the Euler update: $z' = z_{HR} - 0.5 \times 0.1 = \begin{bmatrix}0.75 & 0.65 \\ 0.55 & 0.45\end{bmatrix}$.

Feed $z'$ to the VAE decoder $D$; assume the decoder linearly scales values to the $[0,1]$ pixel range, yielding a 2 × 2 image $\begin{bmatrix}0.75 & 0.65 \\ 0.55 & 0.45\end{bmatrix}$.

Because the update is tiny, the overall structure of the image (relative ordering of intensities) is unchanged, but the subtle contrast adjustment adds the missing fine detail.

The single step moves the latent only a small amount, preserving the global layout while sharpening local variations—exactly what the low‑strength regime promises.

How does this one‑step refinement differ from a regular diffusion step at full resolution?

In a standard diffusion step the latent is far from the clean target and the velocity field is large, so many steps are needed to reduce the error. Here the low‑strength noise leaves the latent already within a tiny neighbourhood of the clean endpoint; the velocity field is almost flat, so one Euler step incurs negligible discretization error and still restores the missing high‑frequency detail.

Single‑step refinement is within 0.0025 of the 5‑step optimum on CLIP consistency.

Empirical evaluation shows 0.9974 for one step versus 0.9999 for five steps at the same noise scale.

Thus, the high‑resolution refinement stage adds the final crisp details with negligible extra compute, completing the MrFlow pipeline at the target resolution.

Qualitative Results

MrFlow+ delivers the fastest training‑free acceleration, cutting inference cost dramatically.

High‑resolution diffusion spends most compute on redundant high‑frequency details; MrFlow first builds a low‑resolution global structure then refines it in a single step, cutting inference cost.

MrFlow+ attains a 25.1× speedup on Qwen‑Image while preserving visual fidelity.

Table 1 shows a 25.1× speedup compared to the baseline Qwen‑Image, the largest among all training‑free methods.

Across both FLUX.1‑dev and Qwen‑Image, MrFlow consistently outperforms other training‑free strategies, achieving the top speedup in every configuration (e.g., 5.78× on FLUX, 8.25× on Qwen‑Image).

**Figure 1.** Qualitative comparison between MrFlow and various methods on Qwen-Image. The dashed lines separate the pretrained model, training-free strategies, and strategies that rely on or exploit timestep distillation.

**Table 1.** Comparison of various training-free acceleration methods on FLUX.1-dev and Qwen-Image, generated at 1024 × 1024 resolution.

Quantitative Performance

Quantitative comparison shows MrFlow’s speedup and accuracy dominate alternatives.

MrFlow keeps Geneval loss within 2 % of the native 50‑step baseline while delivering large speedups.

On Qwen‑Image it reaches a 25.1× speedup with only a 0.85 Geneval score, comparable to the 0.85 of the native 50‑step run.

Ablation Study

We isolate the impact of each component by varying step counts and super‑resolution choices.

We run a full factorial sweep over low‑resolution (10–20 steps) and high‑resolution (1–3 steps) configurations, then evaluate several super‑resolution back‑ends. The goal is to see which knobs drive quality versus speed.

Increasing low‑resolution steps raises Geneval by roughly 0.02 while high‑resolution step count has almost no effect on the metric.

Experiments show a steady Geneval improvement as low‑resolution steps grow from 10 to 20, whereas adding a second or third high‑resolution step changes Geneval by less than 0.01.

One high‑resolution refinement step already restores crisp text strokes; a second step adds less than 0.01 Geneval.

Visual inspection (Figure 4) shows that the no‑refinement output is blurry, while a single HR step yields clear characters; the quantitative Geneval difference between one and two HR steps is under 0.01.

Real‑ESRGAN (12, 1)×2 attains the highest speedup (14.0×) among the SR options while keeping Geneval at 0.87.

Table 3 reports a 14.0× speedup for Real‑ESRGAN with Geneval 0.87, outperforming Interpolate (10.7×) and SwinIR (4.67×) on the same metric.

**Figure 5.** Trade-off curves between GenEval score and speedup for various training-free methods on FLUX.1-dev and Qwen-Image. Different shades of MrFlow correspond to different numbers of steps used in the high-resolution refinement stage.

Frequency Domain Analysis

We examine the frequency‑domain behavior and design choices that bound our method’s cost.

Applying a frequency‑domain low‑pass operator Pₗₒw to each sampled latent discards high‑frequency components, leaving a trajectory that is consistently about 58 % as long as the original ODE path.

The low‑resolution target distribution is equivalent to applying the same low‑pass filter to the high‑resolution distribution, so the low‑resolution stage only needs to traverse the low‑frequency portion of the path, which explains its ability to converge in fewer steps.

Upsampling in pixel space preserves the local spatial statistics required by the VAE decoder, whereas enlarging the latent feature map would introduce grid‑like artifacts that are visible in side‑by‑side comparisons with LSSGen.

Choosing a GAN‑class super‑resolution model trades the minimum‑MSE pixel loss for sharper, structurally plausible details; this concentrates the remaining bias in high‑frequency bands that the subsequent refine stage can effectively correct, unlike L2‑class or interpolation which leave high‑frequency attenuation and blur.

Table 9 measures k‑NN distance in DINOv2 space after refinement under various forward‑noise types. Gaussian and high‑frequency band‑pass noises are almost unchanged, while low‑frequency noise inflates the distance to 0.498 at strength 0.3—a >200 % increase—showing that the refine stage cannot correct low‑frequency bias.

Table 10 reports the per‑band power spectrum $\lambda$(k) and the derived lower bound $\sigma^*$ₜ = √$\lambda$ / (1+√$\lambda$). Low‑frequency bands have $\lambda$≈0.32 and $\sigma^*$ₜ≈0.24, while high‑frequency bands have $\lambda$≈0.08 and $\sigma^*$ₜ≈0.075, confirming that high‑frequency residuals require only modest noise to be resampled.

Proposition 1 expresses the posterior mean of the high‑resolution refinement as a weighted combination $\kappa$ᵢ zₛᵣᵢ + (1 − $\kappa$ᵢ) $\mu$ᵢ + $\eta$ᵢ $\epsilon$ᵢ, where $\kappa$ᵢ is the Wiener gain. Large $\lambda$ᵢ (low‑frequency) yields $\kappa$ᵢ≈1, preserving the SR estimate; small $\lambda$ᵢ (high‑frequency) yields $\kappa$ᵢ≈0, letting the prior dominate.

Proposition 2 translates the Wiener‑gain condition into a concrete noise‑level lower bound $\sigma^*$ₜ(k) = √$\lambda$(k) / (1 + √$\lambda$(k)). For the high‑frequency band ($\lambda$≈0.08) this gives $\sigma^*$ₜ≈0.075, matching the empirical $\sigma$ₜ values (≈0.1–0.15) used in the main experiments.

Table 11 shows CLIP similarity between the refined output and an 8‑step reference. With strength s = 0.1 and $K_H$ = 1 the similarity is 0.9974, only 0.0025 below the 0.9999 achieved with $K_H$ = 5, confirming that a single refinement step is already near‑optimal at the recommended low strength.

Table 12 records the velocity norm ‖v_$\theta$‖, its change $\Delta$‖v_$\theta$‖, and turn angle as the refinement strength increases. All three metrics grow monotonically, indicating that stronger noise drives a larger, more rapidly rotating velocity field.

Table 13 compares seed‑sensitivity for low‑resolution (LR) versus high‑resolution (HR) stages. Varying the LR seed changes the low‑frequency MSE by a factor of ~8000 relative to HR, confirming that the final output’s structure is set by the low‑resolution stage while the HR stage only adds high‑frequency perturbations.

Finally, the single‑step sufficiency experiment (Table 11) demonstrates that, at the recommended low‑strength regime, adding more refinement steps yields diminishing returns, because the velocity field is nearly straight and the high‑frequency residuals are already well‑aligned after one step.

Generalization to Other Models

Open‑model tests show MrFlow delivers up to 27× speedup with minimal quality loss.

MrFlow achieves up to 26.92× speedup on 9B models by adding a single high‑resolution refinement step, while preserving OneIG‑En and OneIG‑Zh quality.

Table 14 reports a total cost of 4.8 versus 49 for the native 4‑step pipeline, yielding a 26.92× speedup on the 9B variant.

Across the open‑model families FLUX.2 Klein and Z‑Image, MrFlow consistently delivers multi‑fold speedups—from 5× on the 4B FLUX.2 Klein base up to 21× on Z‑Image‑Turbo—while keeping the OneIG‑En and OneIG‑Zh scores within a narrow margin of the native pipelines.

**Table.** Comparison of computational costs for the resolution pipeline: adding one high-resolution refinement step to the 4-step model reaches 20.10× on 4B and 26.92× on 9B relative to their base counterparts, denoted as MrFlow$^\ddagger$ in the table.

A timing breakdown on Qwen‑Image (12+1) shows low‑resolution sampling consumes 3.24 s, high‑resolution refinement 1.03 s, and the fixed overhead of noise generation, VAE decoding, and Real‑ESRGAN super‑resolution totals about 0.30 s.

Background and Implementation Details

Appendix provides detailed experimental data and analysis of MrFlow’s low‑resolution acceleration.

Diffusion‑generation acceleration has followed two broad tracks. General‑purpose compression (quantization, efficient attention) relies on hardware tricks, while diffusion‑specific methods focus on timestep reduction, feature caching, or token pruning to cut sampling cost without extra hardware.

Multi‑resolution generation splits into (i) resolution‑extension pipelines that first produce a low‑resolution structure and then upscale (e.g., SR3, Cascaded Diffusion, Imagen), and (ii) acceleration pipelines that upsample in latent or frequency space (e.g., LSSGen, RALU, SPD) to reduce inference steps.

Pixel‑space super‑resolution spans regression, GAN, and diffusion families; diffusion‑based methods such as OSEDiff perform a single‑step distillation. Image‑repainting techniques (SDEdit, InstructPix2Pix) edit existing images via noise‑denoise cycles, whereas MrFlow uses low‑strength noise to preserve global structure while resampling high‑frequency details.

Our main acceleration experiments run on FLUX.1‑dev and Qwen‑Image‑20B, comparing MrFlow against a spectrum of baselines: TeaCache, DB‑Taylor, ToMA, LSSGen, RALU, SPEED, and the training‑free distillation methods SenseFlow and Pi‑Flow. All baselines are evaluated at two operating points to match comparable speed regimes.

**Table 4.** Parameter settings on FLUX.1-dev used in the main comparison tables. $N_{LR}$ and $N_{ref}$ denote the low-resolution denoising and high-resolution refinement steps of MrFlow.

**Table 8.** Path length of 30-step pure txt2img trajectories of Qwen-Image, averaged over 3 prompts × 4 seeds.

Stage‑wise analysis (Section C) aligns with the four design stages introduced in the main text. Sections C.1–C.4 map one‑to‑one to Sections 3.1–3.4, while C.5 discusses the division of labor between low‑ and high‑resolution stages.

C.1 establishes that the low‑resolution stage supplies the bulk of MrFlow’s speedup. Two independent factors contribute: each sampling step processes fewer image tokens, and the low‑resolution stage converges in fewer steps.

When the image side length is halved, the token count drops by a factor of four, yielding an empirical single‑step speedup of roughly 4×. The self‑attention component could theoretically gain up to 16×, but linear layers temper the overall gain to the observed factor.

Beyond raw speed, low resolution accelerates convergence because the image queries attend more strongly to the text keys. We quantify this with the text‑to‑image interaction strength

$T(\ell) \;=\; \frac{1}{|Q_{\text{img}}|}\sum_{q\in Q_{\text{img}}}\sum_{k\in K_{\text{txt}}} A(\ell)_{q,k}$, where $A(\ell)$ is the attention matrix at layer $\ell$, $Q_{\text{img}}$ the set of image queries, and $K_{\text{txt}}$ the set of text keys.

**Table 6.** Layer-wise text-to-image attention mass $\mathcal{T}^{(\ell)}$ of Qwen-Image under 10-step pure txt2img.

We also evaluate downstream semantic alignment with CLIP similarity $\text{CLIP}(x,c)=\cos\bigl(\phi_I(x),\phi_T(c)\bigr)$. Table 7 compares a pure high‑resolution schedule (HR11) against a low‑resolution‑first schedule (LR10 HR1) under equal step budgets.

**Table 1.** Comparison of MSE values for different control variables.

Trajectory length further illustrates the advantage. For a latent path $\{z_t^k\}_{k=0}^{K}$ we define $L\{z_t^k\}=\sum_{k=0}^{K-1}\|z_t^{k+1}-z_t^{k}\|_2^{2}$. Table 8 shows that low‑resolution paths are about 57 % as long as full‑resolution ones.

Generation Examples

We show extra visual results, runtime breakdowns, and prompt details to illustrate MrFlow’s performance.

The PDF compression ratio exceeds 90%, so fine‑grained details may appear blurred. This artifact is a document‑preparation issue, not a limitation of the model.

F.1 compares MrFlow against several training‑free and timestep‑distillation baselines. Visual inspection reveals a clear fidelity gap despite comparable quantitative scores.

**Figure 7.** Comparison of the effects of various methods on FLUX.1-dev. The dashed lines separate the pretrained model, training-free strategies, and strategies that rely on or exploit timestep distillation.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers