ResilPhase: Plug-and-Play Phase Mapping and Noise-Resilient Macro-Trajectory Extrapolation for Diffusion Acceleration¶

Conference: ECCV 2026
arXiv: 2606.26769
Code: https://github.com/zqc214/ResilPhase
Area: Diffusion Model Acceleration
Keywords: Diffusion Model Acceleration, DiT, Training-Free Caching, Barycentric Lagrange Extrapolation, Phase Mapping, Runge Phenomenon

TL;DR¶

ResilPhase reformulates training-free acceleration for DiT from a layer-wise derivative extrapolation paradigm to macro-trajectory extrapolation in the ODE space. It eliminates layer-wise error cascades using an end-to-end Global Drift, bypasses chaotic derivative noise using derivative-free Barycentric Lagrange interpolation, and suppresses the Runge phenomenon by projecting discrete timesteps into a bounded phase space via Chebyshev/Balanced phase mapping. It maintains state-of-the-art generation quality on FLUX.1-dev even at an approximate 5x acceleration.

Background & Motivation¶

Background: Diffusion Transformers (DiTs) have become the core architecture for high-fidelity visual generation, adopted by mainstream models such as FLUX and HunyuanVideo. However, inference requires dozens to hundreds of sequential forward passes (e.g., FLUX.1-dev takes 23.69 seconds to generate a single image on an A100 GPU), which severely hinders real-time deployment.

Limitations of Prior Work: Training-free acceleration methods have evolved from early "cache-and-reuse" (DeepCache, TeaCache) to "cache-and-predict" (TaylorSeer, HiCache, SpeCa). The latter utilizes polynomials (Taylor series, Hermite interpolation) to extrapolate and predict intermediate feature trajectories. However, these methods suffer from severe image quality degradation at high speedup ratios. This paper identifies their root causes as three intertwined bottlenecks:

Spatial Dimension - Layer-wise Error Cascading: Performing polynomial fitting on high-frequency micro-features inside Transformer blocks layer-by-layer causes prediction errors to amplify exponentially with network depth (with an error bound of \(O((1+L_f)^L)\)) while incurring heavy caching and memory overheads.
Temporal Dimension - Derivative Chaos Amplification: While macro-trajectories are inherently smooth, their high-order temporal derivatives are intrinsically chaotic (as finite difference acts like a high-pass filter, exponentially magnifying noise). Derivative-reliant methods like TaylorSeer inject finite difference approximation errors into extrapolation, causing prediction divergence.
Numerical Dimension - Runge Phenomenon: Performing polynomial extrapolation on uniformly distributed discrete timesteps causes the error bound at the interval boundaries to grow uncontrollably, leading to catastrophic degradation at extreme acceleration ratios.

Key Challenge: Prior paradigms either discard the input prior to directly predict absolute outputs (FreqCa, which bounds its accuracy limit), or get trapped in local residual updates (\(\Delta\)-DiT, which loses macro-continuous dynamics). They lack an end-to-end prediction target that simultaneously preserves input priors and strictly aligns with the ODE vector field.

Core Idea: This work reformulates accelerated inference as a stable macro-trajectory extrapolation problem in the ODE space. The prediction target is elevated from layer-wise micro-features to the global drift of the network. Extrapolation is then solved using a derivative-free Barycentric Lagrange formulation to bypass derivative noise, combined with phase mapping to non-linearly project linear timesteps into a bounded space to tightly suppress the mathematical upper bound of extrapolation errors.

Method¶

Overall Architecture¶

The core challenge ResilPhase aims to solve is accurate prediction of intermediate skipped steps in training-free DiT acceleration, where complete forward passes are performed only every \(N\) steps. The entire framework consists of three synergistic components addressing spatial, temporal, and numerical bottlenecks. Given the current latent state \(\mathbf{x}_t\), timestep \(t\), and conditioning \(c\), the system outputs the predicted global drift \(\hat{D}(\mathbf{x}_t)\), which is then used to reconstruct the final output via \(\hat{G}(\mathbf{x}_t) = \mathbf{x}_t + \hat{D}(\mathbf{x}_t)\).

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Input x_t, t, c"] --> B["Full forward every N steps?<br/>Yes → Compute full DiT stack"]
    B --> C["ODE-aligned macro-trajectory target<br/>Compute Global Drift D(x_t)=G(x_t)-x_t"]
    C --> D["Phase Mapping<br/>Chebyshev / Balanced t→s"]
    D --> E["Cache D_j, w_j to history window"]
    B -->|Skip Step| F["Retrieve m+1 points<br/>(s_j, D_j, w_j) from history window"]
    F --> G["Derivative-free Barycentric<br/>Lagrange extrapolator"]
    G --> H["Predict D(x_pred)"]
    E --> F
    H --> I["Reconstruct output<br/>G(x_pred)=x_pred+D(x_pred)"]
    I --> J["Next step"]

At each full computation step, ResilPhase performs three operations: (1) runs the full DiT stack to obtain \(G(\mathbf{x}_t)\) and computes the Global Drift \(D(\mathbf{x}_t) = G(\mathbf{x}_t) - \mathbf{x}_t\); (2) projects the timestep \(t\) to phase coordinate \(s\) via phase mapping; (3) caches the \((s, D, w)\) triplet into a history window. At skipped steps, it simply utilizes the \(m+1\) data points in the history window to extrapolate and predict \(D\) via the Barycentric Lagrange formula, followed by an additive reconstruction of the output. This entire process avoids accessing any internal Transformer layers and bypasses all derivative computations.

Key Designs¶

1. ODE-Aligned Macro-Trajectory Target: From Layer-wise Micro-Features to End-to-End Global Drift

The fundamental flaw of layer-wise prediction lies in the error cascading and magnifying along the network depth. Consider an \(L\)-layer DiT. Let the residual transformation of the \(l\)-th layer be \(f_l\), and the predictor be \(\mathcal{P}_l\). The estimated value for a skipped step is \(\hat{x}_t^l = \hat{x}_t^{l-1} + \mathcal{P}_l(\hat{x}_t^{l-1})\). Assuming \(f_l\) is Lipschitz continuous (with Lipschitz constant \(L_f\)), recursing from the first layer to the \(L\)-th layer yields an accumulated error upper bound of \(E_L \leq \sum_{l=1}^{L} (1+L_f)^{L-l} e_l\), where \(e_l\) represents the local prediction error of the \(l\)-th layer. This bound highlights the core issue: the tiny prediction error \(e_l\) from each layer is exponentially amplified by the factor \((1+L_f)^{L-l}\), compounding catastrophically as the layers deepen.

The fundamental breakthrough of ResilPhase is elevating the prediction target from \(L\) independent layer-wise residuals to the macro-evolution of the entire network. Global Drift (GD) is defined as the end-to-end state displacement between the final output and initial input of the DiT:

\[D(\mathbf{x}_t) = G(\mathbf{x}_t) - \mathbf{x}_t\]

where \(G(\mathbf{x}_t) = g_L(g_{L-1}(\dots g_1(\mathbf{x}_t, c)\dots))\) denotes the composite mapping of the entire DiT stack. During prediction, a single macro-predictor \(\mathcal{P}_{\text{macro}}\) outputs \(\hat{D}(\mathbf{x}_t)\), and the final result is reconstructed via simple addition: \(\hat{G}(\mathbf{x}_t) = \mathbf{x}_t + \hat{D}(\mathbf{x}_t)\). Here, the error degenerates into a single term: \(E_{\text{macro}} = \|\hat{D} - D\| = e_{\text{macro}}\), completely decoupling from the network depth \(L\)—the error bound plummets from \(O((1+L_f)^L)\) to \(O(1)\).

Comparison with alternative paradigms: directly predicting the absolute value \(G(\mathbf{x}_t)\) (as in FreqCa) also avoids layer-wise errors but discards the highly correlated input prior \(\mathbf{x}_t\), which restricts its upper-bound prediction accuracy; on the other hand, reusing residual displacements (as in \(\Delta\)-DiT) traps the execution in local micro-updates. GD elegantly unifies the strengths of both: it uses \(\mathbf{x}_t\) as an anchor to only predict the displacement, while tracing the macro-continuous dynamics of the ODE vector field rather than local micro-perturbations.

2. Derivative-Free Barycentric Lagrange Extrapolator: Bypassing Derivative Chaotic Noise

Even though GD itself is a smooth macro-trajectory (as shown in Fig. 2(a)), the issue is not fully resolved because high-order temporal derivatives of GD remain chaotic. The paper demonstrates through visualization that derivative trajectories approximated by finite differences are riddled with high-frequency noise and spikes (Fig. 2(b)). Any derivative-reliant solver (e.g., Taylor series, Hermite interpolation) that injects such noise into extrapolation will cause prediction divergence. As shown in the mathematical comparison in Fig. 2(c), as the extrapolation interval \(N\) increases, the \(L_1\) relative error of the derivative-free Lagrange predictor remains substantially lower than that of Taylor and Hermite solvers, exhibiting a much gentler growth slope.

ResilPhase adopts a strictly derivative-free Lagrange interpolation formula. Given \(m+1\) historical data points \(\{(t_0, F_0), \dots, (t_m, F_m)\}\), where \(F_j = D(\mathbf{x}_{t_j})\) represents historical GD values, the unique interpolating polynomial of degree \(m\) is \(P(t) = \sum_{j=0}^{m} F_j L_j(t)\), with \(L_j(t)\) being the standard Lagrange basis functions. However, the standard formula has a computational complexity of \(O(m^2)\) since all weights must be re-computed at every extrapolation step.

To address this, the paper introduces the Barycentric Lagrange interpolation formula:

\[P(t) = \frac{\sum_{j=0}^{m} \frac{w_j}{t - t_j} F_j}{\sum_{j=0}^{m} \frac{w_j}{t - t_j}}, \quad w_j = \frac{1}{\prod_{k=0, k\neq j}^{m} (t_j - t_k)}\]

where the barycentric weights \(w_j\) depend solely on the relative coordinates of the interpolation nodes \(\{t_j\}\) and are independent of the feature values \(\{F_j\}\). This property is crucial: the weights can be pre-computed and cached during full computation steps, and all subsequent predictions reuse the same set of weights, reducing the complexity to \(O(m)\). The entire extrapolation process involves no derivative calculations or finite difference approximations, fundamentally blocking the injection of derivative noise.

3. Phase Mapping Mechanism: Suppressing the Runge Phenomenon via Chebyshev/Balanced Projection

Even when employing a derivative-free extrapolator, a deeper numerical issue persists: performing polynomial extrapolation on uniformly distributed discrete timesteps inherently triggers the Runge phenomenon—oscillatory errors at the boundaries of the interval grow uncontrollably with extrapolation distance (Fig. 1(a)). ResilPhase is the first study to identify this as a crucial bottleneck in diffusion acceleration.

Starting from the standard error formula of Lagrange interpolation: for an \((m+1)\)-times differentiable function \(F(t)\), the error is \(E(t) = \frac{F^{(m+1)}(\xi)}{(m+1)!} \prod_{j=0}^{m} (t - t_j)\). Here, \(D_{m+1} = \frac{F^{(m+1)}(\xi)}{(m+1)!}\) is an intrinsic model property and cannot be altered. The only manageable term is the node-dependent factor \(e(t) = \prod_{j=0}^{m} (t - t_j)\). The core strategy is using a non-linear mapping \(t \to s\) to redistribute the uniform timesteps \(\{t_j\}\) to a more stable node configuration to minimize \(\max |e(s)|\).

The paper proposes two mapping schemes:

Chebyshev Mapping (CM): Maps \(m+1\) historical timesteps to Chebyshev nodes \(s_k = \cos\big(\frac{(2k+1)\pi}{2(m+1)}\big), \; k=0,\dots,m\). Chebyshev nodes minimize the upper bound of the maximum interpolation polynomial error on the interval \([-1, 1]\), which is an optimal result in classical numerical analysis. For an extrapolation target \(t_{\text{target}} < t_m\), the corresponding phase coordinate \(s_{\text{target}}\) is calculated via linear extrapolation of the two nearest points. CM performs best on class-conditional generation tasks.
Balanced Mapping (BM): The rigid structure of Chebyshev nodes lacks the flexibility to adapt to varying temporal distributions in complex text-conditioned tasks. BM is a data-driven adaptive mapping: it first computes the mean \(\mu_t\) and maximum absolute deviation \(d_{\max}\) of the current \(m+1\) timesteps, then performs a non-linear projection using the \(\tanh\) function: \(s = \tanh\big(\alpha \cdot \frac{t - \mu_t}{d_{\max}}\big)\), where \(\alpha > 0\) controls the steepness of the mapping (default \(\alpha = 0.55\) is robust across various scenarios). The bounded output of \(\tanh\) in \((-1, 1)\) naturally compresses the extrapolation domain into a stable interval and dynamically adapts to the distribution of recent timesteps. BM outperforms CM in text-to-image/video tasks.

The error bounds of both mappings are strictly guaranteed. Taking the unmapped baseline as a reference, the error polynomial factor satisfies \(|e_{\text{ori}}(t_{\text{target}})| \leq \prod_{j=0}^{m} |(m-j+1)N-1|\); Chebyshev mapping tightens this to \(|e_{\text{cheby}}| \leq \prod_{j=0}^{m} |2(m-j+1) - 2/N|\). For any \(N \geq 2\) and \(m-j > 0\), it can be proven that Chebyshev mapping strictly reduces the absolute value of each factor, monotonically lowering the error upper bound across all acceleration ratios. The same holds for Balanced mapping.

Ultimately, ResilPhase completes the extrapolation using the Barycentric Lagrange formula on the phase coordinates \(s\):

\[\hat{D}(\mathbf{x}_{\text{pred}}) = P(s_{\text{pred}}) = \frac{\sum_{j=0}^{m} \frac{w_j}{s_{\text{pred}} - s_j} D_j}{\sum_{j=0}^{m} \frac{w_j}{s_{\text{pred}} - s_j}}\]

where \(s_{\text{pred}}\) is the mapped phase coordinate of the target timestep, and \(\{s_j, D_j, w_j\}_{j=0}^{m}\) are variables retrieved from the cached history window.

A Complete Example: From Caching to Extrapolation to Reconstruction¶

Taking the \(N=5, m=1\) configuration on FLUX.1-dev as an example (performing a full computation every 5 steps and using 2 historical points for linear extrapolation), let us walk through the complete pipeline. The total denoising steps are 50, starting gradually from \(t=49\).

t=49 (Anchor Step): Run the full DiT stack normally to obtain \(G(\mathbf{x}_{49})\), then compute \(D_{49} = G(\mathbf{x}_{49}) - \mathbf{x}_{49}\). Balanced mapping projects \(t=49\) to \(s_{49}\) (e.g., using the current window for \(\mu_t\) and the maximum deviation for \(d_{\max}\)) and caches \((s_{49}, D_{49})\).
t=48 (Skip Step): The target is \(t_{\text{target}}=48\). Map \(s_{48}\) via linear extrapolation from \(t=49\). Since the history window \(\{(s_{49}, D_{49})\}\) contains only 1 point (while \(m=1\) requires 2 points), the first skipped step degenerates to directly approximating with the nearest GD value, i.e., \(D_{48} \approx D_{49}\). Reconstruct the output as \(G(\mathbf{x}_{48}) = \mathbf{x}_{48} + D_{49}\).
t=47 (Skip Step): The window now has two points: \((s_{49}, D_{49})\) and \((s_{48}, D_{48})\) (where \(D_{48}\) is the predicted value from the previous step). The barycentric weights \(w_{49}, w_{48}\) are pre-computed once and reused. Extrapolating yields \(D_{47} = P(s_{47})\), and we reconstruct \(G(\mathbf{x}_{47}) = \mathbf{x}_{47} + D_{47}\).
t=46, 45: Similarly extrapolated using the 2 nearest points.
t=44 (Next Anchor Step): Run the full DiT stack again, updating the window with the ground-truth GD value and clearing any accumulated prediction errors. The sliding window always retains the latest \(m+1\) ground-truth GD points.

Key takeaway: The entire skipping process avoids executing any forward passes through the DiT blocks (saving 4/5 of the computation) and bypasses all derivative computations. All predictions are completed in \(O(m)\) time. Prediction errors only accumulate within a single extrapolation window between two anchor points and are 'calibrated' by the ground-truth value at the next anchor step.

Loss & Training¶

ResilPhase is completely training-free, requiring no loss functions or gradient updates. All components (GD computation, Barycentric Lagrange extrapolation, and phase mapping) are deterministic mathematical operations executed directly during inference. The only hyperparameters are the acceleration interval \(N\), the interpolation degree \(m\) (denoted as \(O\) in the paper), and the Balanced Mapping scaling factor \(\alpha\) (default 0.55).

Key Experimental Results¶

Main Results¶

FLUX.1-dev Text-to-Image (Selected from Table 1, ~5x acceleration tier):

Method	Speedup	ImageReward \(\uparrow\)	CLIP \(\uparrow\)	PSNR \(\uparrow\)	SSIM \(\uparrow\)	LPIPS \(\downarrow\)
FLUX.1-dev (50 steps)	1.00x	1.0804	32.711	-	-	-
FLUX.1-dev (11 steps)	4.55x	0.9541	32.485	28.397	0.5939	0.5001
TeaCache	4.82x	0.7850	32.588	27.954	0.3837	0.8349
SpeCa	4.78x	0.9798	32.571	28.366	0.5567	0.5324
PFDiff	4.07x	1.0386	32.816	28.671	0.6162	0.4670
FreqCa	4.88x	1.0130	32.114	28.120	0.4023	0.6877
TaylorSeer	4.65x	0.6241	31.895	27.940	0.3014	0.8012
ResilPhase	4.97x	1.0258	32.847	29.536	0.6655	0.3834

At the highest speedup ratio (4.97x), ResilPhase achieves an ImageReward of 1.0258, outperforming the strongest predictive baseline TaylorSeer by 64% while reducing LPIPS by 52%. PSNR and SSIM are also superior compared to all other acceleration methods. In the ~4.17x tier, ResilPhase's ImageReward (1.0591) even surpasses that of the full 50-step baseline.

HunyuanVideo Text-to-Video (~5x acceleration tier):

Method	Speedup	PSNR \(\uparrow\)	SSIM \(\uparrow\)	LPIPS \(\downarrow\)	VBench \(\uparrow\)
50-step Full	1.00x	-	-	-	80.87
TeaCache	4.62x	17.923	0.6547	0.3760	79.77
SpeCa	4.65x	16.461	0.5883	0.4219	79.59
TaylorSeer	4.63x	15.520	0.5641	0.4581	79.07
ResilPhase	4.98x	18.920	0.6709	0.3341	79.78

ResilPhase is equally robust in video tasks—at the fastest acceleration (4.98x), it achieves the best LPIPS and PSNR across all methods, with a VBench score (79.78) on par with the strongest TeaCache baseline (79.77), while improving SSIM by 0.0162.

DiT-XL/2 Class-Conditional Generation (ImageNet): At a 4.41x acceleration, ResilPhase achieves a FID of 2.832—not only far outperforming all caching baselines in the same tier (TeaCache/ToCa/ClusCa FID > 15, SpeCa FID 6.866) but also closely approaching the full 50-step DDIM baseline (2.367). At 2.78x speedup, FID decreases to 2.347, outperforming the full 50-step baseline (2.367), while IS reaches 233.57, which also exceeds the baseline.

Ablation Study¶

The following selected representative configurations are from the FLUX.1-dev ablation table (Table 4), with a fixed setting of \(N=5, m=1\) (approx. 4.17x speedup):

Configuration	Prediction Target	Phase Mapping	ImageReward \(\uparrow\)	PSNR \(\uparrow\)	LPIPS \(\downarrow\)	Description
Lagrange Only (No PM)	GD	None	1.0404	29.013	0.3853	Derivative-free extrapolation baseline; already much better than derivative methods
Lagrange + Chebyshev	GD	Chebyshev	1.0528	29.472	0.3343	CM significantly improves PSNR by +0.46 dB compared to No PM
Lagrange + Balanced	GD	Balanced	1.0591	29.556	0.3342	BM slightly outperforms CM, further boosting ImageReward
Layer-wise Prediction + Lagrange + Balanced	Layer-wise	Balanced	1.0517	29.034	0.3811	Replacing GD with layer-wise prediction drops PSNR by 0.52 dB and severely degrades LPIPS
Lagrange + BM + Predict Final Output	Final Output	Balanced	1.0557	29.093	0.3808	Replacing GD with direct prediction of \(G(\mathbf{x}_t)\) drops PSNR by 0.46 dB

Key Findings¶

Global Drift is the most critical component: Replacing GD with layer-wise prediction in the ablation study causes LPIPS to deteriorate from 0.3342 to 0.3811 (a relative increase of 14%), representing the largest performance drop among all single-component removals.
Phase Mapping exhibits plug-and-play universality: Integrating Phase Mapping into TaylorSeer and HiCache yields consistent ImageReward improvements across all acceleration intervals (Fig. 7), verifying that PM is not merely exclusive to ResilPhase but serves as a universal stabilizer for existing derivative-based accelerators.
Balanced Mapping outperforms Chebyshev in text-conditioned tasks: The adaptive \(\tanh\) mapping of BM is more suited for volatile timestep distributions in text-to-image/video scenarios, whereas the fixed structure of CM excels in class-conditional generation. This task dependency aligns with theoretical expectations (class-conditional tasks have simpler dynamics where fixed nodes suffice).
More pronounced advantages at higher speedups: In the 4.97x tier, ResilPhase's ImageReward gain over the strongest predictive baseline (+64%) is far greater than that in the 3.58x tier (+0.5%), validating that suppressing the Runge phenomenon via Phase Mapping becomes increasingly critical at higher acceleration ratios.

Highlights & Insights¶

Shifting the acceleration paradigm from 'signal fitting' to 'numerical stability control': While prior works focused heavily on first-order approximations, second-order derivatives, and Hermite basis functions, ResilPhase directly pinpoints the root causes—the Runge phenomenon and derivative chaos. It then leverages classical numerical analysis (Chebyshev nodes, Barycentric formulation) to construct an elegant solution, redefining the problem at a higher conceptual level.
The elegance of GD lies in its 'additive reconstruction': The simple residual formulation \(G(\mathbf{x}_t) = \mathbf{x}_t + D(\mathbf{x}_t)\) simultaneously resolves three major constraints—preserving the input prior (unlike FreqCa which discards \(\mathbf{x}_t\)), avoiding layer-wise errors (unlike layer-wise methods tracking \(L\) residuals), and aligning with the macro-dynamics of the ODE (unlike \(\Delta\)-DiT trapped in local updates). A single equation elegantly satisfies three seemingly conflicting design goals.
Phase Mapping behaves as a perfect 'plug-and-play' module: Instead of being tightly coupled with ResilPhase, it acts as a standalone mathematical transformation independent of the predictor type. It can be integrated into any existing polynomial-based accelerator (such as TaylorSeer or HiCache) to yield performance gains. This high-cohesion, low-coupling design paradigm can be easily transferred to any inference acceleration scenario involving polynomial extrapolation.
A prime demonstration of bridging numerical analysis and deep learning: The core tools utilized in the paper (Chebyshev nodes, Barycentric Lagrange, and the Runge phenomenon) originate from classical numerical analysis textbooks, yet they are revitalized under the modern context of DiT acceleration. This inspires researchers that many bottlenecks in deep learning systems may already find mature solutions within classical numerical analysis.

Limitations & Future Work¶

Only supports DiT architectures: All experiments are conducted on FLUX, SDXL, HunyuanVideo, and DiT-XL/2, without validation on U-Net-based diffusion models (such as SD 1.5/2.1). Since the definition of GD depends on the composite structure of Transformer blocks, the skip connections in U-Net may prevent the error bound analysis of GD from directly holding true.
Lack of fine-tuning for the Phase Mapping hyperparameter \(\alpha\): The scaling factor \(\alpha\) in Balanced Mapping is fixed at a default value of 0.55 across experiments, and a systematic ablation study on \(\alpha\) is missing. It remains unresolved whether the optimal \(\alpha\) is consistent across different models/tasks, and whether there is a coupling relationship between \(\alpha\) and the acceleration interval \(N\).
Evaluated solely on a 50-step sampling schedule: Experiments are conducted with a fixed 50-step sampling schedule without testing performance under other step configurations (e.g., 20 steps, 100 steps). Variations in timestep distribution under different total steps could influence the efficacy of Phase Mapping.
Lack of joint experiments with orthogonal methods like quantization/pruning: ResilPhase operates purely at the algorithmic level and is theoretically orthogonal and complementary to model compression methods (quantization, pruning). However, joint ablation studies are not included. Combining ResilPhase with 4-bit quantization to achieve 10x+ speedup would significantly boost its practical value.
Future Directions: (1) Explore adaptive interpolation degree \(m\)—dynamically adjusting it at different denoising stages (e.g., lower order during early high-noise stages and higher order during late fine-detail stages); (2) Extend Phase Mapping to more general ODE solver acceleration frameworks (such as DPM-Solver) beyond the predictive caching paradigm.

vs TaylorSeer / SpeCa (Derivative-Series Extrapolation): These methods use Taylor series to predict layer-wise features, relying on finite differences to approximate derivatives. This paper proves that derivative chaos is the key reason these methods collapse at high speedups, replacing them with derivative-free Lagrange extrapolation. ResilPhase is not just 'better' but reveals the mathematical upper bound of the old paradigm.
vs HiCache / FreqCa (Hermite Interpolation): Hermite interpolation uses both function and derivative values, theoretically capturing more information than pure Lagrange. However, since the derivatives themselves are noisy, any informational gain is overwhelmed by noise. The ablation studies (Fig. 2(c)) quantitatively confirm that the extrapolation error of derivative-free Lagrange is consistently lower than that of Hermite.
vs \(\Delta\)-DiT (Residual Displacement Reuse): \(\Delta\)-DiT reuses residual displacements instead of predicting them, avoiding prediction errors but failing to track ODE macro-dynamics. The GD in this work can be viewed as a macro-version of the \(\Delta\)-DiT concept: it is also a displacement, but upgraded from a 'layer-wise local residual' to an 'end-to-end global drift'.
vs FoCa (ODE Prediction Calibration): FoCa also utilizes Lagrange extrapolation but remains trapped in the layer-wise prediction + derivative framework, lacking Phase Mapping. The contribution of ResilPhase lies in the synergy between Lagrange extrapolation, GD, and Phase Mapping, rather than simply swapping the basis function.

Rating¶

Novelty: ⭐⭐⭐⭐⭐ Formulates DiT acceleration as an ODE macro-extrapolation problem and introduces Chebyshev nodes/the Runge phenomenon to the diffusion acceleration context, offering high originality at the problem definition level.
Experimental Thoroughness: ⭐⭐⭐⭐ Evaluated across 4 models and 3 task types, with comparisons against 10 baselines and solid ablation designs; lacks validation on U-Net models and joint experiments with quantization/pruning.
Writing Quality: ⭐⭐⭐⭐⭐ The logical flow from 'phenomenon \(\rightarrow\) root cause \(\rightarrow\) three bottlenecks \(\rightarrow\) three components' is exceptionally clear. The error analysis comparing \(O(1)\) versus \(O((1+L_f)^L)\) is highly compelling.
Value: ⭐⭐⭐⭐⭐ Highly practical due to its training-free and plug-and-play nature. Phase Mapping acts as a universal stabilizer that can be integrated into any existing accelerator, presenting substantial ecological value.