Cross-Resolution Distribution Matching for Diffusion Distillation¶

Conference: ECCV 2026
Paper: ECCV
Area: Model Compression
Keywords: Diffusion Distillation, Few-Step Generation, Cross-Resolution Distribution Matching, logSNR Alignment, Cascaded Generation

TL;DR¶

The paper proposes RMD, which treats resolution reduction as a second acceleration axis alongside step reduction: it splits the denoising trajectory with logSNR curves and assigns each segment a resolution, projects low-resolution generator samples into the teacher's high-resolution space through a differentiable upsampling transform, and performs DMD-style distribution matching there, with predicted-noise re-injection for stable training — reaching up to 33.4× speedup on SDXL at 2+2 steps and 25.6× on Wan2.1-14B at 3+3 steps while preserving fidelity.

Background & Motivation¶

Diffusion and flow models owe their generation quality to hundreds of iterative denoising steps, each of which is a full forward pass through a large network; under the DiT architecture this cost is amplified further, since the token count grows with spatial dimensions and attention complexity rises quadratically with it. Existing acceleration work falls into roughly two families. Training-free solvers (DPM-Solver++, caching and token-pruning methods) squeeze the step count down to dozens but still need tens of forward passes. Step distillation — progressive distillation, trajectory-straightening methods such as InstaFlow, consistency models and their successors, and the DMD family of distribution-matching distillation — pushes sampling down to 4-8 steps while largely preserving quality. The problem is that empirical evidence shows pushing further to 1-3 steps causes a catastrophic drop in performance: step reduction alone is already near saturation around 4 steps, and another order of magnitude of speedup requires a different compressible axis.

The axis this paper picks is resolution. It has long been observed that denoising steps play different roles depending on the noise level: high-noise stages mainly recover the global structure and layout, whereas low-noise stages refine fine details and textures. If that is so, computing those not-yet-needed details at full resolution during the high-noise stage is pure waste, and the natural remedy is a coarse-to-fine multi-resolution cascade: recover the global structure with coarse denoising at low resolution first, then defer high-resolution compute to a later detail-refinement stage. This path, however, hits a hard obstacle: the same model induces noticeably different data distributions at different resolutions — the paper's Fig. 1 shows SDXL producing clearly distinct images at 512×512 and 1024×1024 under the same prompt and the same random seed. The root cause lies in the training paradigm of state-of-the-art diffusion models, which is itself a multi-stage curriculum: pretraining on large-scale, variable-quality low-resolution data, followed by fine-tuning on curated high-resolution data. Under a cascaded scheme, the global structure is therefore effectively sampled from a lower-quality low-resolution distribution rather than from the inherently higher-fidelity high-resolution one, and quality degradation is essentially inevitable.

Closing that gap is not a matter of simply asking the low-resolution model to "look like" the high-resolution one, since the two do not even live in the same data space. The angle taken here is that noise levels along the two trajectories can be compared with a single yardstick — the logSNR — so one can project low-resolution samples into the teacher's high-resolution space and perform distribution matching at timesteps whose noise levels coincide, explicitly pulling the generator's low-resolution distribution toward the teacher's high-resolution distribution. Core idea: treat resolution as a compression axis on par with step count, use logSNR invariance to align denoising timesteps across resolutions, project the low-resolution generator state into the teacher's space via differentiable upsampling, and run DMD-style score distillation in that space — maintaining high-fidelity generation under an effective compute budget of fewer than 4 steps.

Method¶

Overall Architecture¶

RMD takes a pretrained diffusion/flow model (the teacher \(p_\varphi\)) plus a batch of text prompts as input, and produces a cascaded generator \(G_\theta\) that generates in a few steps while switching resolutions along the way. The pipeline has four moving parts: partition the teacher's denoising trajectory into \(K\) segments by logSNR and assign each segment a resolution (resolution trajectory division); during training, turn the low-resolution generator state into a clean latent in one step, upsample it to the teacher's resolution, and re-noise it to the teacher's noise level at the corresponding timestep, yielding an aligned sample sitting at the same logSNR as the teacher (differentiable upsampling transform + cross-resolution distribution matching); match distributions with the DMD-style score-distillation objective, where the generator's score is estimated by an online-updated fake diffusion model; and inject, instead of pure Gaussian noise, a mixture of the upsampled predicted noise and Gaussian noise weighted by \(\alpha^2+\beta^2=1\), so that samples inherit the teacher's ODE direction while retaining the stochasticity the cross-resolution gap demands. Training distills only the low-logSNR semantic segment as a warm-up before the full trajectory is trained end to end; at inference the process starts from pure noise at the lowest resolution and steps up in resolution level by level until the target resolution is reached.

Key Designs¶

1. Dividing the resolution trajectory along the logSNR curve: putting different resolutions' denoising states on speaking terms

Where to switch resolution cannot be decided by intuition, because "how much noise has been added" is not equivalent across resolutions: for the same independent noise magnitude, a higher resolution suffers relatively weaker pixel corruption and thus a lower effective noise level. The paper quantifies this with logSNR (Fig. 3): the logSNR curves grow at different rates across resolutions — in the low-logSNR regime low-resolution trajectories denoise faster, whereas in the high-logSNR regime higher resolutions denoise faster. The teacher's logSNR curve is therefore partitioned at predefined thresholds \(\{\text{logSNR}_1,\dots,\text{logSNR}_{K-1}\}\) into \(K\) non-overlapping segments, each segment \(i\) carrying a timestep interval \([T_{i-1},T_i]\) and a preset resolution \(r_i\), with \(r_1<\dots<r_K\) and \(r_K\) equal to the teacher's generation resolution. Converting a threshold into a timestep uses the Rectified Flow logSNR-timestep relation:

\[\sigma_{T_i}=\frac{1}{1+\exp(\text{logSNR}_i/2)}\]

(Rectified Flow noises as \(x_t=(1-\sigma_t)x_0+\sigma_t\epsilon\), so \(\text{logSNR}=2\log\frac{1-\sigma}{\sigma}\) and inverting gives the expression above. ⚠️ this equation is OCR-corrupted in the cached PDF; it is restated here from the Rectified Flow definition and the exact form should be checked against the original paper.)

That alone is not enough, because the thresholds are defined at the teacher's resolution while the effective noise at a lower resolution differs. Following SD3's resolution-dependent scaling, the paper adds a compensation term proportional to the logarithm of the resolution ratio \(r_i/r_K\) to the logSNR, obtaining the effective logSNR at that resolution and converting it back into the timestep interval \([T_{i-1}^{(r_i)},T_i^{(r_i)}]\) where the student operates. In Fig. 3 the compensated low-resolution curves sit above the high-resolution ones, indicating a higher compensated logSNR (weaker effective noise) at each timestep. Together, these two steps mean that once the two curves are aligned in logSNR, the noise level the teacher sees at that moment is the same number the low-resolution generator sees — distillation thus happens at identical denoising states, regardless of spatial resolution. This is the premise on which all subsequent distribution matching rests. The default configuration is \(K=2\) and \(\text{logSNR}_1=-2.5\): with 4-step SDXL inference, the high-noise interval \(t\in[502,1000]\) runs at low resolution and the refinement interval \(t\in[0,502]\) runs at high resolution.

2. Cross-resolution distribution matching with a differentiable upsampling transform: aligning two distributions inside the teacher's space

RMD's objective is a joint KL divergence — the generator's "noising distribution × reverse denoising conditional" must match the teacher's corresponding joint distribution, written as \(\min_\theta \mathrm{KL}\big(p_\theta(\tilde{x}_{t_i})p_\theta(x_0\mid\tilde{x}_{t_i})\,\|\,p_\varphi(x_t)p_\varphi(x_0\mid x_t)\big)\), where the index \(t_i:=(r_i,t)\) denotes the resolution-aware timestep obtained by aligning resolution \(r_i\) with teacher timestep \(t\) in logSNR. The objective runs into two difficulties. First, point-wise matching along the generation trajectory is insufficient for effective distillation, as TDM already pointed out. Second, and specific to this setting, \(\tilde{x}_{t_i}\) is a low-resolution state while \(x_0\) and \(x_t\) are high-resolution, so denoising \(\tilde{x}_{t_i}\) directly back to \(x_0\) is ill-posed; worse, \(\tilde{x}_{t_i}\) carries stochastic diffusion noise, and naive upsampling distorts the structural priors the low-resolution stage worked to establish.

The paper's remedy is to first move the generator state into the teacher's space with a differentiable upsampling transform, and then match at the distribution level. Concretely, the generator's own noise prediction yields a one-step clean-latent estimate, which is interpolated up to the teacher's resolution and finally re-noised to the teacher's noise level at timestep \(t_j\):

\[\tilde{x}^{(t_{i,j})}_0=\tilde{x}_{t_{i,j}}-\sigma_{t_{i,j}}\,\epsilon_\theta(\tilde{x}_{t_{i,j}},t_{i,j}),\qquad x^{(t_{i,j})}_{t_j}=(1-\sigma_{t_j})\,U_{r_K}\!\big(\tilde{x}^{(t_{i,j})}_0\big)+\sigma_{t_j}\,\epsilon\]

Here \(U_{r_K}(\cdot)\) is the interpolation upsampling operator to the teacher's resolution (bilinear interpolation in the implementation), \(\epsilon_\theta\) is the generator's noise prediction, and the whole transform is differentiable with respect to \(\theta\); \(\tilde{x}^{(t_{i,j})}_0\) is the clean latent corresponding to the low-resolution distribution at timestep \(t_{i,j}\). Once aligned, minimizing the marginal reverse KL suffices, which is exactly the score-distillation form:

\[L(\theta)=\sum_{i=1}^{K}\lambda_{r_i}\,\mathbb{E}_{t_i}\Big[\mathrm{KL}\big(p_\theta(x_t^{(t_i)})\,\|\,p_\varphi(x_t)\big)\Big]\]

The generator score \(s_\theta\) is intractable, and the gradient is approximated by the score difference times the upsampling Jacobian:

\[\nabla_\theta L\approx\sum_{i=1}^{K}\lambda_{r_i}\,\mathbb{E}_{t_i}\Big[\big(s_\theta(x_t^{(t_i)},t)-s_\varphi(x_t,t)\big)\frac{\partial x_t^{(t_i)}}{\partial\theta}\Big]\]

Following DMD and TDM, a fake diffusion model \(s_\phi\) estimates the generator's score while \(s_\varphi\) acts as the true score, and the score-difference term is placed under a stop-gradient, yielding a regression objective that reads as one step of gradient-descent refinement:

\[L(\theta)=\sum_{i=1}^{K}\lambda_{r_i}\,\mathbb{E}_{t_i}\Big\|\,x_t^{(t_i)}-\mathrm{sg}\big[\,x_t^{(t_i)}-\sigma_t\big(s_\phi(x_t^{(t_i)},t)-s_\varphi(x_t,t)\big)\big]\,\Big\|_2^2\]

(⚠️ this equation is badly OCR-corrupted in the cached PDF; it is restated in DMD2's stop-gradient form and the exact expression should be checked against the original paper.) The fake diffusion model tracks score variations along generated trajectories with a standard denoising objective, fitting \(U_{r_K}(\tilde{x}^{(t_i)}_0)\) as the clean target and using the SNR at that timestep and resolution as the weight. One further engineering trade-off matters here: aligning point-wise at every timestep as written above is both expensive and imbalanced in supervision, because different resolution segments require different numbers of sampling steps and the gradient scales become inconsistent, slowing convergence. The paper therefore performs distribution matching per resolution segment — a timestep \(t_i\sim\mathcal{U}\big([T_{i-1}^{(r_i)},T_i^{(r_i)}]\big)\) is sampled uniformly within each segment and aligned there, with each segment weighted by \(\lambda_{r_i}\) and the expectation approximated by Monte Carlo sampling during training.

The difference from DMD is exactly where this paper stakes its claim: DMD matches at a single resolution, with the student and the teacher sharing the same \(x_t\); in RMD the \(x_t^{(t_i)}\) entering the match is produced by "low-resolution generation → differentiable upsampling → re-noising", so the gradient must pass through the upsampling operator (the Jacobian of \(U_{r_K}\) inside \(\partial x_t^{(t_i)}/\partial\theta\) is what lets gradients reach the low-resolution generator), and the matched timestep is the outcome of logSNR alignment rather than the same \(t\).

3. Predicted-noise re-injection: letting upsampled samples both inherit the teacher's trajectory and keep cross-resolution stochasticity

What noise \(\epsilon\) to use in the re-noising step of design 2 decides whether training converges at all. Pure Gaussian noise aligns the two distributions across resolutions, but it amounts to re-solving an SDE trajectory and fully discards the teacher's ODE trajectory, weakening structural consistency. Conversely, using the upsampled predicted noise as \(\epsilon\) strictly follows the teacher trajectory, but when the resolution gap is large the upsampling artifacts are treated as hard guidance and degradation is severe. The paper mixes the two under \(\alpha^2+\beta^2=1\):

\[\epsilon_{t_i}=\alpha\,U_{r_K}\!\big(\epsilon_\theta(\tilde{x}_{t_i},t_i)\big)+\beta\,\epsilon,\qquad \epsilon\sim\mathcal{N}(0,I)\]

The predicted component supplies trajectory direction and the stochastic component supplies cross-resolution freedom. Intuitively, the larger the resolution gap and the more severe the distribution mismatch, the more stochasticity is needed to bridge it, so \(\alpha\) should decrease as the gap grows. The sweep in Fig. 7 (PixArt-α, NFE = 2+2) settles on \(\alpha=0.2\) as optimal: \(\alpha=0\) gives weak structural consistency, \(\alpha=1\) degrades under large resolution gaps, and 0.2 attains the best generation fidelity by balancing trajectory inheritance against stochastic flexibility. Notably the optimum sits clearly toward the stochastic side rather than at the midpoint.

4. Low-logSNR semantic-segment warm-up and multi-resolution cascaded inference

The distribution induced by the low-resolution generative trajectory largely determines the global layout of the final high-resolution distribution. If the whole cascaded trajectory were trained end to end from the start, the large mismatch between the generated low-resolution distribution and the target high-resolution distribution would hinder convergence. Borrowing Wan2.2's logSNR partitioning scheme, the paper takes the threshold \(\text{logSNR}_{K/2}\) to separate a semantic interval (low logSNR) from a detail interval, distills the low-logSNR semantic interval alone as a warm-up to give the cascade a stable initialization, and then trains the full trajectory end to end, which accelerates the overall distillation process. Inference mirrors this with a multi-resolution cascaded scheme: denoising starts from pure Gaussian noise at the lowest resolution \(r_1\), and at every timestep the procedure decides whether an upsampling step is needed — if the resolution is unchanged at the next timestep, standard conditional denoising is performed; if the resolution changes, the current-stage distribution is first projected to the target stage and then upsampled with noise re-injected to match the higher-resolution distribution at the next timestep. Resolution thus grows level by level to the target while temporal consistency is preserved across stages (full pseudocode in Algorithm 1/2 of the appendix, which the cache does not include).

Loss & Training¶

The overall training loss has two parts: on the generator side, the stop-gradient cross-resolution score-distillation loss above; on the fake-score side, a standard denoising regression loss weighted by the SNR at that timestep and resolution, which makes the weight resolution-aware. Training is entirely image-free, relying only on JourneyDB prompts with no real images or videos. CFG scales are set to 7.5 (SDXL), 3.5 (PixArt-α), 4.5 (SD3.5) and 5.0 (Wan2.1); upsampling is bilinear throughout, and all benchmarks and speed measurements are run on a single NVIDIA A100. The main experiments scale resolution from 512px to 1024px for images and from 480p (834×480) to 720p (1280×720) for video, i.e. \(K=2\) with \(\text{logSNR}_1=-2.5\). The paper reports that RMD's distillation training cost is comparable to TDM's and lower than DMD2's (details in Appendix B).

Key Experimental Results¶

Main Results¶

On the image side, RMD is compared against adversarial distillation (SDXL-Turbo, SDXL-Lighting, YOSO, SD3.5-Turbo) and distribution-matching distillation (DMD2, TDM) across three backbones — SDXL (UNet), PixArt-α (Transformer) and SD3.5 medium — always using two low-resolution steps followed by two high-resolution steps (denoted NFE 2+2). HPS is the average of the four categories from HPS v2.1 (Animation / Art / Painting / Photo).

Backbone	Method	NFE	Speedup	HPS↑	Aes↑	CLIP↑
SDXL	Base Model-1024	40×2	1.0×	29.14	6.48	35.64
SDXL	SDXL-Turbo-512	4	20.0×	29.46	6.41	34.36
SDXL	SDXL-Lighting	4	20.0×	30.83	6.54	34.62
SDXL	DMD2	4	20.0×	31.30	6.71	35.10
SDXL	TDM	4	20.0×	31.93	6.70	35.03
SDXL	RMD (Ours)	2+2	33.4×	31.99	6.73	35.13
PixArt-α	Base Model-1024	25×2	1.0×	30.74	6.73	34.12
PixArt-α	YOSO-512	4	12.5×	30.60	6.23	31.83
PixArt-α	DMD2	4	12.5×	31.36	6.71	33.53
PixArt-α	TDM	4	12.5×	32.05	6.82	33.63
PixArt-α	RMD (Ours)	2+2	21.0×	32.23	6.89	33.89
SD3.5	Base Model-1024	40×2	1.0×	30.29	6.49	34.76
SD3.5	SD3.5-Turbo	4	20.0×	28.23	6.35	32.97
SD3.5	DMD2	4	20.0×	30.42	6.32	32.16
SD3.5	TDM	4	20.0×	30.03	6.37	32.25
SD3.5	RMD (Ours)	2+2	32.0×	30.56	6.38	32.51

On the video side, RMD is extended to Wan2.1-T2V-14B with three low-resolution plus three high-resolution steps, compared against 6-step DMD2 and TDM and evaluated with VBench and T2V-CompBench.

Method	NFE	Speedup	VBench Total↑	Quality↑	Semantic↑	T2V-CompBench↑
Base Model-720p	50×2	1.0×	83.75	85.44	76.95	54.17
DMD2	6	16.7×	80.30	81.98	73.60	52.81
TDM	6	16.7×	80.48	81.85	75.00	52.27
RMD (Ours)	3+3	25.6×	82.51	84.37	75.05	54.00

Ablation Study¶

The component ablation runs on SDXL / Wan2.1 under a unified protocol: RM denotes cross-resolution distribution matching and UP denotes cascaded upsampling, training always starts from the 512px/480p base resolution, and the target resolution is determined by the UP module.

Target Resolution	RM	UP	HPS↑	Aes↑	CLIP↑	VBench↑
512px/480p	×	×	22.64	6.15	28.76	80.01
512px/480p	✓	×	30.28	6.63	34.81	80.81
512px/480p	×	✓	29.57	6.58	33.68	81.11
1024px/720p	✓	✓	31.99	6.73	35.13	82.51

The logSNR threshold \(\text{logSNR}_1\) governs how steps are allocated between the two resolutions (PixArt-α):

\(N_{512}+N_{1024}\)	\(\text{logSNR}_1\)	Speedup	HPS↑	Aes↑	CLIP↑
0+4	–	1×	32.05	6.82	33.63
1+3	-6.00	1.25×	32.12	6.87	33.64
2+2	-2.50	1.68×	32.13	6.83	33.86
3+1	0.00	2.54×	24.79	6.03	32.22

Pushing the cascade from two stages to three and four (SDXL; the parenthesised number is the NFE at that stage, omitted when it is 1):

Method	Resolution (NFE)	\(\text{logSNR}_1,\text{logSNR}_2\)	Speedup	HPS↑	Aes↑	CLIP↑
Baseline	1024(4)	–	1.00×	31.93	6.70	35.03
Baseline	512(2)→1024(2)	-2.5	1.56×	29.57	6.58	33.68
RMD	512(2)→1024(2)	-2.5	1.56×	31.99	6.73	35.13
RMD	256→512→1024(2)	-6.0, -2.5	1.73×	31.59	6.70	34.84
RMD	256→512(2)→1024	-6.0, -0.0	2.54×	31.48	6.68	34.77
RMD	256(2)→512→1024	-2.5, -0.0	2.90×	31.03	6.67	34.57
RMD	128→256→512→1024	-6.0, -2.5, -0.0	3.08×	29.48	6.59	33.41

Key Findings¶

The gains come from cross-resolution alignment, not from upsampling itself. The most telling row of the component ablation is that naive cascaded upsampling without RM reaches only 29.57 HPS — below the 30.28 of the "no resolution increase but RM applied" setting — while the 512px baseline with neither reaches a mere 22.64. Multi-resolution cascading on its own buys nothing, and can even hurt, because the low-resolution stage fails to establish strong structural priors and the subsequent upsampling amplifies that into artifacts (the qualitative comparison in Fig. 6 corroborates this). The whole benefit traces back to RM pulling the low-resolution distribution toward the teacher's high-resolution distribution; the two together at 1024px give the best 31.99 / 6.73 / 35.13.
What can be cheapened is the high-noise stage's resolution; what cannot is the refinement stage's step count. In the step-allocation table, 1+3 gains slightly in aesthetic score (6.87 vs 6.83) but only speeds up by 1.25×; compressing high-resolution refinement to a single step (3+1) reaches 2.54× yet collapses HPS to 24.79 and CLIP to 32.22, visually manifesting as pronounced blurriness and total loss of fine texture. This matches the prior that the low-noise stage does detail refinement: running the high-noise stage at low resolution is a bargain, but the low-noise stage needs its steps.
The noise-re-injection coefficient \(\alpha\) is non-monotonic, with the optimum clearly toward the stochastic side. Both extremes are worse and the middle (0.2) is best, which says that inheriting the teacher's ODE trajectory and retaining cross-resolution stochasticity must be traded off explicitly — and that the balance point sits closer to stochasticity than a half-and-half split, since a larger resolution gap needs more stochasticity to bridge the mismatch.
The cascade extrapolates, but the lowest resolution becomes the bottleneck first. Three stages (256→512→1024) still hold HPS 31.03 at 2.90× speedup, confirming that the coarse-to-fine logic scales; going to four stages starting at 128px drops to 29.48 while gaining only 3.08×, far less than the quality lost — the limiting factor is that the semantic structure recoverable at the lowest resolution is simply not reliable enough.
Video benefits more than images, though semantic alignment still trails. At 6 steps DMD2 and TDM fall to 80.30 / 80.48 VBench Total and quality around 82, whereas RMD's 3+3 reaches 82.51 / 84.37, already close to the 50-step teacher's 83.75 / 85.44; but the semantic score of 75.05 still sits below the teacher's 76.95, so text-semantic consistency remains the part of this route not yet closed.
One phenomenon worth noting: distribution-matching methods generally exceed the teacher base on SDXL HPS (29.14), which the authors attribute to replacing error-prone multi-step trajectories with direct mappings and thereby eliminating cumulative sampling drift. The explanation is plausible, but HPS and Aes are preference-style metrics that reward appealing images, which is not the same as being closer to the teacher at the distribution level.

Highlights & Insights¶

Resolution is promoted to a full acceleration axis on par with step count, and logSNR is the ruler that unifies the two. This is the most transferable idea in the paper: acceleration need not come only from fewer iterations but also from cheaper per-iteration representations, and as long as two trajectories can be aligned by noise level, "the same denoising state" becomes comparable across compute budgets.
The differentiable upsampling transform turns "student and teacher live in different spaces" into a trainable problem. As long as \(U\) is differentiable, the score-distillation gradient passes through it back to the low-resolution generator (the Jacobian \(\partial x_t^{(t_i)}/\partial\theta\) is the core of this mechanism). In principle any differentiable spatial or modality transform — a super-resolution network, temporal frame interpolation, token upsampling — can be slotted into this framework, for instance distilling a video teacher into an image generator or a multi-view teacher into a single-view one.
The noise-re-injection \(\alpha\) interpolation is a clean, practical trick. Whether re-noising in DMD-style distillation should use true randomness or predicted noise used to be a matter of convention; here it becomes an explicit, sweepable continuous interpolation (\(\alpha^2+\beta^2=1\)), and the experiments show the optimum clearly favors the stochastic side.
Low-logSNR semantic warm-up is nearly free. Distilling the semantic segment that determines the global layout first and only then training end to end is essentially curriculum learning applied to cross-resolution distillation, and it aligns with the empirical rule that high-noise stages fix the layout.
The source of the speedup deserves its own accounting. Reducing SDXL from 40×2 to 2+2 is only a 20× NFE reduction, yet the measured figure is 33.4×; the extra comes from the two low-resolution steps avoiding the quadratic attention cost at 1024px. On Wan2.1, 100 forward passes reduced to 6 (16.7× nominal) measures 25.6× for the same reason. Low-resolution steps therefore deliver far more real speedup on DiTs than their NFE share suggests.

Limitations & Future Work¶

The partitioning scheme is entirely hand-tuned. The number of segments \(K\), the threshold \(\text{logSNR}_1\), and the per-stage resolutions \(r_i\) are all set manually: the main experiments use \(K=2\) and \(\text{logSNR}_1=-2.5\), but different backbones use different schedules (Appendix B), which shows the configuration is not universal and must be re-swept per model. No automatic search or adaptive segmentation is offered.
The resolution compensation term itself is never ablated. Cross-resolution alignment rests entirely on the SD3-style compensation in Eq. (2), yet the paper does not report how much is lost by dropping the compensation and using the teacher's timestep directly. This is the experiment most worth adding, since it directly determines how much weight the central "logSNR alignment" claim can bear.
No distribution-distance metric. Evaluation uses preference/consistency metrics (HPS, Aes, CLIP, VBench), none of which directly measures the distance to the teacher's distribution, and no FID appears in the tables. That cross-resolution matching really shrinks the distribution gap is currently supported only by the qualitative figure (Fig. 6).
Both training and evaluation are image-free (JourneyDB prompts only), so behaviour with real image-text or video-text pairs is untested; the practical gains in memory and batch size are also not reported — the low-resolution stages could run with larger batches, a benefit the paper leaves on the table.
A cascade forces one set of weights to work at several resolutions, so the model may overfit to resolutions; the drop to HPS 29.48 at four stages also suggests that semantic fidelity at the lowest resolution is a hard ceiling.
Directions for improvement: make the thresholds and segment count learnable or adaptively searched per backbone; replace the fixed bilinear \(U_{r_K}\) with a learnable lightweight upsampler that also removes upsampling artifacts; add an explicit distribution-distance term (FID, or a feature-based MMD) against the teacher to constrain cross-resolution alignment; and extend the framework to cross-modal "upsampling".

vs DMD / DMD2: all three are distribution-matching distillation, but DMD's student and teacher share the same \(x_t\) at one resolution, so the match is within a single space; RMD's student sample must first go through "low-resolution generation → differentiable upsampling → re-noising" to enter the teacher's space, the matched timestep comes from logSNR alignment rather than the same \(t\), and the gradient must traverse the upsampling Jacobian. DMD2 adds a discriminator for GAN-style alignment, whereas RMD has no discriminator and stabilizes with cross-resolution score matching plus noise re-injection.
vs TDM: TDM diagnoses that point-wise matching along the trajectory is insufficient and calls for trajectory-level distribution matching; RMD keeps that diagnosis but swaps the matched object from "the teacher's whole trajectory" to "segments cut by resolution", and relaxes per-timestep alignment to per-segment sampled alignment — both for efficiency and to remove the imbalance in supervision across resolution segments.
vs consistency models / consistency trajectory models: consistency-style methods demand instance-level trajectory self-consistency and therefore suffer from numerical error when solving the teacher's probability-flow ODE and from the one-to-one trajectory correspondence problem; RMD only requires distributional agreement and sidesteps instance-level correspondence entirely.
vs Bottleneck Sampling: it also uses a high-low-high resolution schedule, but as a training-free sampler modification in which the distribution shift introduced by the low-resolution stage must simply be absorbed; RMD folds multi-resolution cascading into distillation training and explicitly compensates that shift through distribution matching (the paper cites [41] precisely as the problem to be solved).
vs SD3's resolution-dependent noise schedule: SD3 uses it to train a single model that works across resolutions; RMD inverts the use — once the model is fixed, the schedule converts and aligns timesteps across resolutions, turning resolution from an obstacle into a usable acceleration lever.
vs pixel-space cascaded generation such as PixelFlow: PixelFlow trains cascaded flows in pixel space from scratch, whereas RMD leaves the teacher untouched and introduces the resolution cascade only at distillation time, so it drops directly onto off-the-shelf models such as SDXL, PixArt-α, SD3.5 and Wan2.1.

Rating¶

Novelty: ⭐⭐⭐⭐ The framework that folds resolution into distribution-matching distillation and aligns cross-resolution timesteps via logSNR invariance is clean and convincing; but the parts — DMD's score distillation, SD3's resolution compensation, DMD2's stop-gradient, bottleneck sampling's multi-resolution schedule — all have precedents, making this a compositional contribution.
Experimental Thoroughness: ⭐⭐⭐⭐ Four backbones, both image and video modalities, component ablations and two levels of hyper-parameter analysis, with the 14B video model being especially convincing; but distribution-distance metrics such as FID are missing and the resolution compensation term is never ablated.
Writing Quality: ⭐⭐⭐ The method and motivation are clearly narrated and the motivation chain for cross-resolution matching is complete; however, key hyper-parameters and training-cost details are deferred to the appendix (not visible in the cache), and the presentation quality of some equations is mediocre.
Value: ⭐⭐⭐⭐ It offers an acceleration axis orthogonal to step reduction, measured to speed up a 6-step baseline by a further 1.53× on a 14B video model, which is directly relevant to deploying few-step generation in practice.