Adaptive Caching for Faster Video Generation with Diffusion Transformers

## Abstract

Abstract Generating temporally-consistent high-fidelity videos can be computationally expensive, especially over longer temporal spans. More-recent Diffusion Transformers (DiTs)— despite making significant headway in this context— have only heightened such challenges as they rely on larger models and heavier attention mechanisms, resulting in slower inference speeds. In this paper, we introduce a training-free method to accelerate video DiTs, termed Adaptive Caching ( AdaCache ), which is motivated by the fact that “not all videos are created equal” : meaning, some videos require fewer denoising steps to attain a reasonable quality than others. Building on this, we not only cache computations through the diffusion process, but also devise a caching schedule tailored to each video generation, maximizing the quality-latency trade-off.
We further introduce a Motion Regularization ( MoReg ) scheme
to utilize video information within AdaCache, essentially controlling the compute allocation based on motion content. Altogether, our plug-and-play contributions grant significant inference speedups ( e.g . up to 4.7 × \times × on Open-Sora 720p - 2s video generation) without sacrificing the generation quality, across multiple video DiT baselines.

## 1 Introduction

Diffusion models (Ho et al., ; Song et al., ) have become the standard for generative modeling in recent years, arguably surpassing the quality of VAEs (Kingma, ; Rolfe, ), GANs (Karras et al., ; Goodfellow et al., ) and Auto-Regressive models (Chang et al., , ). This observation holds in a wide-range of applications including image (Rombach et al., ; Saharia et al., ), video (Singer et al., ; Blattmann et al., ), 3D (Poole et al., ; Liu et al., ), and audio (Kong et al., ; Huang et al., ) generation, as well as image (Hertz et al., ; Avrahami et al., ) and video (Qi et al., ; Wu et al., ) editing. More recent Diffusion Transformers (DiTs) (Peebles and Xie, ; Ma et al., ) show better promise in terms of scalability and generalization
compared to prior UNet-based diffusion models (Rombach et al., ), revealing intriguing horizons in GenAI for the years to come.

Despite the state-of-the-art performance, DiTs can also be computationally expensive both in terms of memory and computational requirements. This becomes especially critical when applied with a large number of input tokens (*e.g*. high-resolution long video generation). For instance, the reason for models such as Sora (OpenAI, ) not being publicly-served is speculated to be the high resource demands and slower inference speeds (Liu et al., ). To tackle these challenges and reduce the footprint of diffusion models, various research directions have emerged such as latent diffusion (Rombach et al., ), step-distillation (Sauer et al., ; Yin et al., ), caching (Wimbauer et al., ; Ma et al., ; Habibian et al., ), architecture-search (Zhao et al., ; Li et al., ), token reduction (Bolya and Hoffman, ; Li et al., ) and region-based methods (Nitzan et al., ; Kahatapitiya et al., ). Fewer techniques transfer readily from UNet-based pipelines to DiTs, whereas others often require novel formulations. Hence, DiT acceleration has been under-explored as of yet.

Figure: Figure 1: Effectiveness of Adaptive Caching: We show a qualitative comparison of AdaCache (right) applied on top of Open-Sora (Zheng et al., ) (left), a baseline video DiT. Here, we consider generating 720p - 2s video clips, and report VBench (Huang et al., ) quality and average latency (on a single A100 GPU) on the benchmark prompts from Open-Sora gallery. AdaCache generates videos significantly faster (*i.e*., 4.7$\times$ speedup) with a comparable quality. Also, the number of computed steps varies for each video. Best-viewed with zoom-in. Prompts given in supplementary.
Refer to caption: extracted/5985260/figures/teaser.png

Moreover, we note that not all videos are created equal. Some videos contain high-frequency textures and significant motion content, whereas others are much simpler (*e.g*. with homogeneous textures or static regions). Having a diffusion process tailored specifically for each video generation can be beneficial in terms of realizing the best quality-latency trade-off. This idea has been explored to some extent in region-based methods (Avrahami et al., ; Nitzan et al., ; Kahatapitiya et al., ), but not sufficiently in the context of video generation.

Motivated by the above, we introduce Adaptive Caching (AdaCache) for accelerating video diffusion transformers. This approach requires no training and can seamlessly be integrated into a baseline video DiT at inference, as a plug-and-play component. The core idea of our proposal is to cache residual computations within transformer blocks (*e.g*. attention or MLP outputs) in a certain diffusion step, and reuse them through a number of subsequent steps that is dependent on the generated video. We do this by devising a caching schedule, *i.e*., deciding when-to-recompute-next whenever making a residual computation. This decision is guided by a distance metric that measures the rate-of-change between previously-stored and current representations. If the distance is high we would not cache for an extended period (*i.e*., #steps), to avoid reusing incompatible representations. We further introduce a Motion Regularization (MoReg) to allocate computations based on the motion content in the video being generated. This is inspired by the observation that high-moving sequences require more diffusion steps to achieve a reasonable quality.
Altogether, our pipeline is applied on top of multiple video DiT baselines showing much-faster inference speeds without sacrificing the generation quality (see Fig. 1). Finally, we validate the effectiveness of our contributions and justify our design decisions through ablations and qualitative comparisons.

## 2 Related Work

#### Diffusion-based Video Generation

(Singer et al., ; Ho et al., ; Blattmann et al., ; Girdhar et al., ; Chen et al., ) has surpassed the quality and diversity of GAN-based approaches (Vondrick et al., ; Saito et al., ; Tulyakov et al., ; Clark et al., ; Yu et al., ), while also being competitive with recent Auto-Regressive models (Yan et al., ; Hong et al., ; Villegas et al., ; Kondratyuk et al., ; Xie et al., ; Liu et al., ). They have become a standard component in the pipelines for frame interpolation (Wang et al., ; Feng et al., ), video outpainting (Fan et al., ; Chen et al., ; Wang et al., ), image-to-video (Guo et al., ; Blattmann et al., ; Xing et al., ), video-to-video (*i.e*., video editing or translation) (Yang et al., ; Yatim et al., ; Hu et al., ), personalization (Wu et al., ; Men et al., ), motion customization (Zhao et al., ; Xu et al., ) and compositional generation (Liu et al., ; Yang and Wang, ). The underlying architecture of video diffusion models has evolved from classical UNets (Ronneberger et al., ; Rombach et al., ) with additional spatio-temporal attention layers (He et al., ; Blattmann et al., ; Chen et al., ; Girdhar et al., ), to fully-fledged transformer-based (*i.e*., DiT (Peebles and Xie, )) architectures (Lu et al., ; Ma et al., ; Gao et al., ; Zhang et al., ). In the process, the latency of denoising (Song et al., ; Lu et al., ) has also scaled with larger models (Podell et al., ; Gao et al., ). This becomes critical especially in applications such as long-video generation (Yin et al., ; Wang et al., ; Zhao et al., ; Henschel et al., ; Tan et al., ; Zhou et al., ), while also affecting the growth of commercially-served video models (Runway AI, ; OpenAI, ; Luma AI, ; Kling AI, ).

#### Efficiency of Diffusion models

has been actively explored with respect to both training and inference pipelines. Multi-stage training at varying resolutions (Chen et al., , ; Gao et al., ) and high-quality data curation (Ramesh et al., ; Ho et al., ; Dai et al., ; Blattmann et al., ) have cut down training costs significantly. In terms of inference acceleration, there exist two main approaches: (1) methods that require re-training such as step-distillation (Salimans and Ho, ; Meng et al., ; Sauer et al., ; Liu et al., ), consistency regularization (Song et al., ; Luo et al., ), quantization (Li et al., ; Chen et al., ; He et al., ; Wang et al., ; Deng et al., ), and architecture search/compression (Zhao et al., ; Yang et al., ; Li et al., ), or (2) methods that require no re-training such as token reduction (Bolya and Hoffman, ; Li et al., ; Kahatapitiya et al., ) and caching (Ma et al., ; Wimbauer et al., ; Habibian et al., ; Chen et al., ; Zhao et al., ). Among these, training-free methods are more-attractive as they can be widely-adopted without any additional costs. This becomes especially relevant for video diffusion models that are both expensive to train and usually very slow at inference. In this paper, we explore a caching-based approach tailored for video DiTs. Different from prior fixed caching schedules in UNet-based (Ma et al., ; Wimbauer et al., ; Habibian et al., ) and DiT-based (Chen et al., ; Zhao et al., ) pipelines, we introduce a content-dependent (*i.e*., adaptive) caching scheme to squeeze out the best quality-latency trade-off.

#### Content-adaptive Generation

may focus on improving consistency (Couairon et al., ; Bar-Tal et al., ; Avrahami et al., , ; Wang et al., ; Xie et al., ), quality (Suin et al., ; Abu-Hussein et al., ), and/or efficiency (Tang et al., ; Nitzan et al., ; Kahatapitiya et al., ; Starodubcev et al., ). Most region-based methods (*e.g*. image or video editing) rely on a user-provided mask to ensue consistent generations aligned with context information (Avrahami et al., ; Xie et al., ). Some others automatically detect (Suin et al., ) or retrieve (Abu-Hussein et al., ) useful information to improve generation quality. Among efficiency-oriented approaches, there exist proposals for selectively-processing a subset of latents (Nitzan et al., ; Kahatapitiya et al., ), switching between diffusion models with varying compute budgets (Starodubcev et al., ), or adaptively-controlling the number of denoising steps (Tang et al., ; Wimbauer et al., ). AdaDiff (Tang et al., ) skips all subsequent computations in a denoising step, if an uncertainty threshold is met at a certain layer. Block caching (Wimbauer et al., ) introduces a caching schedule tailored for a given pretrained diffusion model. Both these handle image generation tasks. In contrast, our proposed AdaCache— which also controls #denoising-steps adaptively— provides better flexibility, and is applied to more-challenging video generation. It is flexible in the sense that (1) it can selectively-cache any layer or even just a specific module within a layer, and (2) it is tailored to each video generation instead of being fixed for a given architecture. Thus, AdaCache gains more control over the diffusion process, enabling a better-adaptive compute allocation.

## 3 Not All Videos Are Created Equal

In this section, we motivate the need for a content-dependent denoising process, and show how it can help maximize the quality-latency trade-off. This motivation is based on a couple of interesting observations which we describe below.

First, we note that each video is unique. Hence, videos have varying levels of complexity. Here, the complexity of a given video can be expressed by the rate-of-change of information across both space and time. Simpler videos may contain more homogeneous regions and/or static content. In contrast, complex videos have more high-frequency details and/or significant motion. The standard video compression techniques exploit such information to achieve the best possible compression ratios without sacrificing the quality (Wiegand et al., ; Sullivan et al., ). Motivated by the same, we explore how the compute-cost affects the quality of video generations based on DiTs. We measure this w.r.t. the number of denoising steps, and the observations are shown in Fig. 2 (Left). Some video sequences are very robust, and achieve a reasonable quality even at fewer denoising steps. Others break easily when we keep reducing the #steps, but the break-point varies. This observation suggests that the minimal #steps (or, computations) required to generate a video with a reasonable quality varies, and having a content-dependent denoising schedule can exploit this to achieve the best speedups.

Figure: Figure 2: Not all videos are created equal: We show frames from 720p - 2s video generations based on Open-Sora (Zheng et al., ). (Left) We try to break each generation by reducing the number of diffusion steps. Interestingly, not all videos have the same break point. Some sequences are extremely robust (*e.g*. first-two columns), while others break easily. (Right) When we plot the difference between computed representations in subsequent diffusion steps, we see unique variations (Feature distance vs. #steps). If we are to reuse similar representations, it needs to be tailored to each video. Both these observations suggest the need for a content-dependent denoising process, which is the founding motivation of Adaptive Caching. Best-viewed with zoom-in. Prompts given in supplementary.
Refer to caption: extracted/5985260/figures/step_change.png

Figure: Figure 3: Videos generated at a capped-budget: There exist different configurations for generating videos at an approximately-fixed latency (*e.g*. having an arbitrary #denoising-steps, yet only computing a fixed #representations and reusing otherwise). We observe a significant variance in quality in such videos. Best-viewed with zoom-in. Prompts given in supplementary.
Refer to caption: extracted/5985260/figures/30v100.png

Next, we observe how the computed representations (*i.e*., residual connections in attention or MLP blocks within DiT) change during the denoising process, across different video generations. This may reveal the level of compute redundancy in each video generation, enabling us to reuse representations and improve efficiency. More specifically, we visualize the feature differences between subsequent diffusion steps as histograms given in Fig. 2 (Right). Here, we report Feature distance (*e.g*. L1) vs. #steps. We observe that each histogram is unique. Despite having higher changes in early/latter steps and smaller changes in the middle, the overall distribution and the absolute values vary considerably. A smaller change corresponds to higher redundancy across subsequent computations, and an opportunity for re-using. This motivates the need for a non-uniform compute-schedule not only within the diffusion process of a given video (*i.e*., at different stages of denoising), but also across different videos.

Finally, we evaluate the video generation quality at a capped-budget (*i.e*., fixed computations or latency). We can have multiple generation configurations at an approximately-fixed latency, by computing a constant number of representations. For instance, we can cache and reuse representations more-frequently in a setup with more denoising steps, still having the same latency of a process with fewer steps. The observations of a study with either 30 or 100 base denoising steps is shown in Fig. 3. We see that the generation quality varies significantly despite spending a similar cost and having the same underlying pretrained DiT. This motivates us to think about how best to allocate our resources at inference, tailored for each video generation.

## 4 Adaptive Caching for Faster Video DiTs

Figure: Figure 4: Overview of Adaptive Caching: (Left) During the diffusion process, we choose to cache residual computations within selected DiT blocks. The caching schedule is content-dependent, as we decide when to compute the next representation based on a distance metric ($c_{t}$). This metric measures the rate-of-change from previously-computed (and, stored) representation to the current one, and can be evaluated per-layer or the DiT as-a-whole. Each computed residual can be cached and reused across multiple steps. (Right) We only cache the residuals (*i.e*., skip-connections) which amount to the actual computations (*e.g*. spatial-temporal/cross attention, MLP). The iteratively denoised representation (*i.e*., $f_{t+k}$, $f_{t}$) always gets updated either with computed or cached residuals.
Refer to caption: extracted/5985260/figures/main_fig.png

### 4.1 Preliminaries: Video Diffusion Transformers

Video Diffusion Transformers are extended from Latent Diffusion Transformers (DiTs) (Peebles and Xie, ) introduced for image generation. DiTs provide a much-more streamlined, scalable architecture compared to prior UNet-based diffusion models (Rombach et al., ), by only having transformer blocks with a homogeneous token resolution (instead of convolutional blocks with up/downsampling). A simplified transformer block (*i.e*., w/o normalizing or timestep conditioning layers) in a video DiT is shown in Fig. 4 (right)— gray block. It consists of spatial-temporal attention (STA), cross-attention (CA) and linear (MLP) layers. Depending on the implementation, STA may be a single joint spatio-temporal attention layer, or separate spatial and temporal attention layers repeated within alternating blocks. Without loss of generality, let us denote a latent feature at the input/output of such block by $f^{l}_{t}$ and $f^{l+1}_{t}$, respectively. Here, $l$ represents the layer index, and $t$, the diffusion timestep. A simplified flow of computations within each block can be represented as,

$$ $\displaystyle p^{l}_{t}$ $\displaystyle=\texttt{STA}(f^{l}_{t})\;$ $\displaystyle;\quad\tilde{f}^{l}_{t}=f^{l}_{t}+p^{l}_{t}\;,$ (1) $\displaystyle q^{l}_{t}$ $\displaystyle=\texttt{CA}(\tilde{f}^{l}_{t})\;$ $\displaystyle;\quad\bar{f}^{l}_{t}=\tilde{f}^{l}_{t}+q^{l}_{t}\;,$ (2) $\displaystyle r^{l}_{t}$ $\displaystyle=\texttt{MLP}(\bar{f}^{l}_{t})\;$ $\displaystyle;\quad f^{l+1}_{t}=\bar{f}^{l}_{t}+r^{l}_{t}\;.$ (3) $$

Here $p^{l}_{t}$, $q^{l}_{t}$ and $r^{l}_{t}$ are residual connections corresponding to each compute-element. Such computations repeat through $L$ layers, generating the noise prediction of each step $t$, and across a total of $T$ denoising steps. In the current streamlined video DiT architectures with homogeneous token resolutions, each layer of each denoising step costs the same.

### 4.2 Adaptive Caching

In this subsection, we introduce Adaptive Caching (AdaCache), a training-free mechanism for content-dependent compute allocation in video DiTs. The overview of Adaptive Caching is shown in Fig. 4. Compared to a standard DiT that computes representations for all layers across all diffusion steps, in AdaCache, we decide which layers or steps to compute, adaptively (*i.e*., dependent on each video being generated). This decision is based on the rate-of-change in the residual connections (*e.g*. $p^{l}_{t}$, $q^{l}_{t}$ or $r^{l}_{t}$) across diffusion steps, which amount to all significant computations within the DiT. Without loss of generality, let us assume that the residuals in block $l$ in current and immediately-prior diffusion steps $t$ and $t+k$ are already computed. Here, step $t+k$ is identified as ‘immediately-prior’ to step $t$ since any residuals between these two steps are assumed to be not computed (*i.e*., cached residuals are reused). We make a decision on the next computation step based on the distance metric ($c^{l}_{t}$) given by,

$$ $\displaystyle c^{l}_{t}$ $\displaystyle=\texttt{dist}(p^{l}_{t+k},\;p^{l}_{t})=\|p^{l}_{t}-p^{l}_{t+k}\| \;/\;k\;.$ (4) $$

Here, we use L1 distance by default, but other distance metrics can also be applied (*e.g*. L2, cosine). Once we have the distance metric, we select the next caching rate ($\tau^{l}_{t}$) based on a pre-defined codebook of basis cache-rates. Here, a ‘cache-rate’ is defined as the number subsequent steps during which, a previously-computed representation is re-used (*i.e*., a higher cache-rate gives more compute savings). The codebook is basically a collection of cache-rates defined based on the original denoising schedule (*i.e*., #steps), coupled with corresponding metric thresholds to select them. Simply put, a higher distance metric will sample a lower cache-rate from the codebook, resulting in more-frequent re-computations.

$$ $\displaystyle\tau^{l}_{t}$ $\displaystyle=\texttt{codebook}(c^{l}_{t})\;.$ (5) $$

For all denoising steps within $t$ and $t-\tau$, we reuse previously-cached representations and only recompute after the current caching schedule (while also estimating the metric, again).

$$ $\displaystyle p^{l}_{t-k}=\begin{cases}\hskip 5.69054ptp^{l}_{t}\quad&\text{if }\quad k<\tau^{l}_{t};\\ \hskip 5.69054ptp^{l}_{t-k}=\texttt{STA}(f^{l}_{t-k})\quad&\text{if}\quad k= \tau^{l}_{t}.\end{cases}$ (6) $$

The same applies to other residual computations (*e.g*. $q^{l}_{t-k}$, $r^{l}_{t-k}$) as well. By design, we can have unique caching schedules for each layer (and, each residual computation). However, we observe that it will make the generations unstable. Therefore, we decide to have a common metric (*i.e*., $c^{l}_{t}=c_{t}$) and hence, a common caching rate (*i.e*., $\tau^{l}_{t}=\tau_{t}$) across all DiT layers. For instance, we can consider an averaged metric across all layers, or a metric computed at a certain layer to decide the caching schedule. Meaning, when we recompute residuals in a certain step, we do so for the whole DiT rather than selectively for each layer.

Overall, this setup allows us to adaptively-control the compute spent on each video generation, based on frame-wise information (*i.e*., no temporal information used as of yet). If the rate-of-change between residuals is high, we will have a smaller caching rate, and otherwise, we have a higher rate. The choice of a lightweight distance metric (*e.g*. L1) helps us avoid any additional latency overheads.

### 4.3 Motion Regularization

To further improve Adaptive Caching by making use of video-specific (*i.e*., temporal) information, we introduce a Motion Regularization (MoReg). This is motivated by the observation that the optimal number of denoising steps varies based on the motion content of each generated video. The core idea here, is to cache less (*i.e*., recompute more) if a generated video has a high motion content. Simply put, we plan to regularize our caching schedule based on motion. However the problem is that, we need to estimate motion while the video is still being generated. Therefore, we can not rely on motion estimation algorithms in the pixel space, nor any compute-heavy ones as our focus is on efficiency. As a result, we estimate a noisy latent motion-score ($m^{l}_{t}$) based on residual frame differences. Without loss of generality, let us denote residual latent frames of $p^{l}_{t}$ as $\{p^{l}_{t,\;n}\;|\;n=0,\cdots,N-1\}$ where $N$ is the #frames in latent space (generated by the VAE encoder). We estimate the motion-score as,

$$ $\displaystyle m^{l}_{t}$ $\displaystyle=\|p^{l}_{t,\;i:N}-p^{l}_{t,\;0:N-i}\|\;.$ (7) $$

Here, $i$ denotes the frame step-size (or, frame-rate), $\|\cdot\|$, the distance metric (*e.g*. L1), and $i:j$, the slice of all frames within the corresponding range. However, since we operate on noisy-latents, we observe that our motion estimate, particularly in early diffusion steps is not reliable. Meaning, it does not provide a reasonable regularization in early steps (*i.e*., the change in caching schedule does not correlate well with the observed motion in pixel space). To alleviate this, we also compute a motion-gradient ($mg^{l}_{t}$) across diffusion steps, which can act as a reasonable early-predictor of motion that we may observe in latter diffusion steps (that also correlates with the motion in pixel space).

$$ $\displaystyle mg^{l}_{t}$ $\displaystyle=(m^{l}_{t}-m^{l}_{t+k})\;/\;k\;.$ (8) $$

Despite the motion-score being noisy, the motion-gradient acts as a better-estimate of trend, as the representations are getting denoised and converging to a noise-free distribution. Finally, we use both motion-score and motion-gradient as a scaling-factor of the distance metric ($c^{l}_{t}$) to regularize our caching schedule.

$$ $\displaystyle c^{l}_{t}$ $\displaystyle=c^{l}_{t}\cdot(m^{l}_{t}+mg^{l}_{t})\;.$ (9) $$

This means, when we have a higher estimated motion, the distance metric will be increased and a smaller basis cache-rate will be selected from the codebook. As previously discussed, we also enforce a common motion-regularization in all DiT layers by computing a common motion score (*i.e*., $m^{l}_{t}=m_{t}$, $mg^{l}_{t}=mg_{t}$), ensuring the stability of the denoising process. We can also choose to compute motion at different frame-rates, which we ablate in our experiments. Refer to the supplementary for concrete examples of motion-score and motion-gradient (Fig. A.1).

## 5 Experiments

### 5.1 Implementation details

We select multiple prominent open-source video DiTs as backbone video generation pipelines in our experiments, namely, Open-Sora-v1.2 (Zheng et al., ), Open-Sora-Plan-v1.1 (Lab and etc., ) and Latte (Ma et al., ). Since we focus on inference-based latency optimizations (*i.e*., without any re-training), we compare AdaCache against similar methods such as $\Delta$-DiT (Chen et al., ), T-GATE (Zhang et al., ) and PAB (Zhao et al., ). In our main experiments, we generate 900+ videos based on standard VBench (Huang et al., ) benchmark prompts at the corresponding generation settings of each baseline (*e.g*. 480p - 2s with 30-steps in Open-Sora, 512$\times$512 - 2.7s with 150-steps in Open-Sora-Plan and 512$\times$512 - 2s with 50-steps in Latte) measuring multiple quality-complexity metrics. We report VBench average and reference-based PSNR, SSIM and LPIPS as quality metrics, and also report FLOPs, Latency (s) and Speedup as complexity metrics. Here, Latency is measured on a single A100 GPU. Unless otherwise stated, in our ablations and qualitative results, we experiment on the prompts from Open-Sora benchmark gallery, generating 720p - 2s videos with 100-steps.

### 5.2 Main results

**Table 1: Quantitative evaluation of quality and latency: Here, we compare AdaCache with other training-free DiT acceleration methods (*e.g*. $\Delta$-DiT (Chen et al., ), T-GATE (Zhang et al., ), PAB (Zhao et al., )) on mutliple video baselines (*e.g*. Open-Sora (Zheng et al., ) 480p - 2s at 30-steps, Open-Sora-Plan (Lab and etc., ) 512$\times$512 - 2.7s at 150-steps, Latte (Ma et al., ) 512$\times$512 - 2s at 50-steps). We measure the generation quality with VBench (Huang et al., ), PSNR, LPIPS and SSIM, while reporting complexity with FLOPs, latency and speedup (measured on a single A100 GPU). AdaCache-fast consistently shows the best speedups at a comparable or slightly-lower generation quality. AdaCache-slow gives absolute-best quality while still being faster than prior methods. Our motion-regularization significantly improves the generation quality consistently, with a minimal added-latency.**
| Method | VBench (%) $\uparrow$ | PSNR $\uparrow$ | LPIPS $\downarrow$ | SSIM $\uparrow$ | FLOPs (T) | Latency (s) | Speedup |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Open-Sora (Zheng et al., ) | 79.22 | – | – | – | 3230.24 | 54.02 | 1.00$\times$ |
| $\;+$ $\Delta$-DiT (Chen et al., ) | 78.21 | 11.91 | 0.5692 | 0.4811 | 3166.47 | – | – |
| $\;+$ T-GATE (Zhang et al., ) | 77.61 | 15.50 | 0.3495 | 0.6760 | 2818.40 | 49.11 | 1.10$\times$ |
| $\;+$ PAB-fast (Zhao et al., ) | 76.95 | 23.58 | 0.1743 | 0.8220 | 2558.25 | 40.23 | 1.34$\times$ |
| $\;+$ PAB-slow (Zhao et al., ) | 78.51 | 27.04 | 0.0925 | 0.8847 | 2657.70 | 44.93 | 1.20$\times$ |
| $\;+$ AdaCache-fast | 79.39 | 24.92 | 0.0981 | 0.8375 | 1331.97 | 24.16 | 2.24$\times$ |
| $\;+$ AdaCache-fast (w/ MoReg) | 79.48 | 25.78 | 0.0867 | 0.8530 | 1383.66 | 25.71 | 2.10$\times$ |
| $\;+$ AdaCache-slow | 79.66 | 29.97 | 0.0456 | 0.9085 | 2195.50 | 37.01 | 1.46$\times$ |
| Open-Sora-Plan (Lab and etc., ) | 80.39 | – | – | – | 12032.40 | 129.67 | 1.00$\times$ |
| $\;+$ $\Delta$-DiT (Chen et al., ) | 77.55 | 13.85 | 0.5388 | 0.3736 | 12027.72 | – | – |
| $\;+$ T-GATE (Zhang et al., ) | 80.15 | 18.32 | 0.3066 | 0.6219 | 10663.32 | 113.75 | 1.14$\times$ |
| $\;+$ PAB-fast (Zhao et al., ) | 71.81 | 15.47 | 0.5499 | 0.4717 | 8551.26 | 89.56 | 1.45$\times$ |
| $\;+$ PAB-slow (Zhao et al., ) | 80.30 | 18.80 | 0.3059 | 0.6550 | 9276.57 | 98.50 | 1.32$\times$ |
| $\;+$ AdaCache-fast | 75.83 | 13.53 | 0.5465 | 0.4309 | 3283.60 | 35.04 | 3.70$\times$ |
| $\;+$ AdaCache-fast (w/ MoReg) | 79.30 | 17.69 | 0.3745 | 0.6147 | 3473.68 | 36.77 | 3.53$\times$ |
| $\;+$ AdaCache-slow | 80.50 | 22.98 | 0.1737 | 0.7910 | 4983.30 | 58.88 | 2.20$\times$ |
| Latte (Ma et al., ) | 77.40 | – | – | – | 3439.47 | 32.45 | 1.00$\times$ |
| $\;+$ $\Delta$-DiT (Chen et al., ) | 52.00 | 8.65 | 0.8513 | 0.1078 | 3437.33 | – | – |
| $\;+$ T-GATE (Zhang et al., ) | 75.42 | 19.55 | 0.2612 | 0.6927 | 3059.02 | 29.23 | 1.11$\times$ |
| $\;+$ PAB-fast (Zhao et al., ) | 73.13 | 17.16 | 0.3903 | 0.6421 | 2576.77 | 24.33 | 1.33$\times$ |
| $\;+$ PAB-slow (Zhao et al., ) | 76.32 | 19.71 | 0.2699 | 0.7014 | 2767.22 | 26.20 | 1.24$\times$ |
| $\;+$ AdaCache-fast | 76.26 | 17.70 | 0.3522 | 0.6659 | 1010.33 | 11.85 | 2.74$\times$ |
| $\;+$ AdaCache-fast (w/ MoReg) | 76.47 | 18.16 | 0.3222 | 0.6832 | 1187.31 | 13.20 | 2.46$\times$ |
| $\;+$ AdaCache-slow | 77.07 | 22.78 | 0.1737 | 0.8030 | 2023.65 | 20.35 | 1.59$\times$ |

In Table 1, we present a quantitative evaluation of quality and latency on VBench (Huang et al., ) benchmark. We consider three variants of AdaCache: a slow variant, a fast variant with more speedup and the same with motion regularization. We compare with other training-free acceleration methods, showing consistently better speedups with a comparable generation quality. With Open-Sora (Zheng et al., ) baseline, AdaCache-slow outperforms others on all quality metrics, while giving a 1.46$\times$ speedup compared to PAB (Zhao et al., ) with 1.20$\times$ speedup. AdaCache-fast gives the highest acceleration of 2.24$\times$ with a slight drop in quality. AdaCache-fast (w/ MoReg) shows a clear improvement in quality compared to AdaCache-fast, validating the effectiveness of our regularization and giving a comparable speedup of 2.10$\times$. All AdaCache variants outperform even the baseline (w/o any acceleration) on VBench average quality, which aligns better with human preference compared to other reference-based metrics. Similar observations hold with the other baselines as well. With Open-Sora-Plan (Lab and etc., ), AdaCache shows the best speedup of 3.70$\times$ compared to the previous-best 1.45$\times$ of PAB, and the best quality with a 2.20$\times$ speedup. With Latte (Ma et al., ), we gain the best speedup of 2.74$\times$ compared to prior 1.33$\times$, and the best overall quality with a 1.59$\times$ speedup.

Figure: Figure 5: User study: We collect human preferences, comparing AdaCache with PAB (Zhao et al., ) (left) and evaluating our motion regularization (right). AdaCache shows a significantly-higher preference-rate over PAB at a comparable latency. Our motion- regularized variant is better-preferred, yet often tied with AdaCache in terms of perceived quality.
Refer to caption: extracted/5985260/figures/user_study.png

#### User study:

Quantitative metrics on video generation quality can sometimes fall-short in aligning with the perceived visual quality. To better understand the human preference on AdaCache and its comparisons, we conduct a user study in the form of randomized A/B preference tests. Here, we create a questionnaire with 50 multiple-choice questions, each consisting of 3 variants of a single video sequence: the baseline, and two efficient generations in a randomized order (comparing either AdaCache vs. PAB (Zhao et al., ) at a similar speedup, or AdaCache vs. AdaCache w/ MoReg). We ask the users which efficient variant shows a better quality, and whether it is aligned with (*i.e*., indistinguishable from) the baseline. We collect a total of 1800 responses from 36 different users, and the results of the study are given in Fig. 5. Between AdaCache and PAB, we see a clear win for our method (70%) while being extremely-similar to the baseline more than half the time (41%). Among AdaCache variants, users find these to be often tied (60%) in-terms of perceived quality, yet still showing a better preference for motion-regularized variant (25% vs. 14%). This study validates the effectiveness of Adaptive Caching.

### 5.3 Ablation study

Figure: Figure 6: Quality-Latency trade-off: We show quality vs. latency curves for different configurations of AdaCache and PAB (Zhao et al., ), with Open-Sora (Zheng et al., ) 720p - 2s generations. AdaCache outperforms PAB consistently, showing a more-stable performance while reducing latency. This stability is more-prominent in reference-free metric VBench (Huang et al., ) compared to reference-based metrics, validating that AdaCache generations are aligned with human preference even at its fastest speeds, despite not being exactly-aligned with the reference.
Refer to caption: extracted/5985260/figures/tradeoff.png

#### Quality-Latency trade-off:

In Fig. 6, we compare the quality-latency trade-off of AdaCache with PAB (Zhao et al., ). First, we note that AdaCache enables significantly higher reduction rates (*i.e*., much-smaller absolute latency) compared to PAB. Moreover, across this whole range of latency configurations, AdaCache gives a more-stable performance over PAB, on all quality metrics. Such behavior is especially evident in reference-free metric VBench (Huang et al., ), that aligns better with human preference. Even if we see a drop in reference-based scores (*e.g*. PSNR, SSIM) at extreme reduction rates, the qualitative results suggest that the generations are still good (see Fig. 1), despite not being aligned exactly with the reference.

Figure: Figure 7: Impact of Motion Regularization on Adaptive Caching: We show a qualitative comparison of AdaCache and AdaCache (w/ MoReg), applied on top of Open-Sora (Zheng et al., ) baseline. Here, we consider generation of 720p - 2s clips at 100-steps. Despite giving a 4.7$\times$ speedup, AdaCache can also introduce some inconsistencies over time (*e.g*. artifacts, motion, color). Motion Regularization helps avoid most of them by allocating more computations proportional to the amount of motion (while still giving a 4.5$\times$ speedup). Best-viewed with zoom-in. Prompts and more visualizations (see Fig. A.2) are given in supplementary.
Refer to caption: extracted/5985260/figures/moreg.png

#### AdaCache with Motion Regularization:

We compare AdaCache with different versions of motion regularization in Table LABEL:tab:ablation:adacache_variants. Both vanilla and motion-regularized versions provide significant speedups, 4.7$\times$ and 4.5$\times$ respectively, at a comparable quality with baseline Open-Sora (Zheng et al., ). Considering motion-gradient as an early-predictor of motion at latter diffusion steps helps (83.50 vs. 83.36 on VBench). We also estimate motion at different frame-rates by considering a varying step-size in frame differences, which seems to increase the latency without necessarily improving quality. Overall, we consider AdaCache (w/ MoReg) as the configuration with the best quality-latency trade-off. This improvement in quality is more-prominent in qualitative examples shown in Fig. 7, Fig. A.2 and the benchmark comparison in Table 1.

Figure: Figure 8: Acceleration in multi-GPU setups: We evaluate the speedups with varying GPU parallelization, as cached-steps can avoid communication overheads among GPUs. Here, we compare AdaCache with PAB (Zhao et al., ), on baselines Open-Sora (Zheng et al., ) 480p - 2s generations at 30-steps and Open-Sora-Plan (Lab and etc., ) 512$\times$512 - 2.7s generations at 150-steps. (Left) AdaCache consistently shows better acceleration over PAB in all settings. (Right) When compared with baselines of similar parallelization, the additional speedup from AdaCache increases with more GPUs. All latency measurements are on A100 GPUs.
Refer to caption: extracted/5985260/figures/gpu-cost.png

#### Acceleration in multi-GPU setups:

Aligned with prior work that relies on Dynamic Sequence Parallelism (DSP) (Zhao et al., ) to support high-resolution long-video generation across multiple GPUs, we evaluate how AdaCache performs in such scenarios. This evaluation is relevant in the context of efficiency, as DSP incurs additional latency overheads corresponding to the communication between GPUs, and caching mechanisms can avoid such costs by re-using previous computations. We present the results of this study in Fig. 5.3 and Table 2. Here, we consider Open-Sora (Zheng et al., ) (480p - 2s at 30-steps) and Open-Sora-Plan (Lab and etc., ) (512$\times$512 - 2.7s at 150-steps) as baselines, and compare against prior-art PAB (Zhao et al., ) in terms of latency meansurements on A100 GPUs. In Fig. 5.3, we observe that AdaCache consistently outperforms PAB with better inference speeds across all settings. In Table 2, we further compare our method with the corresponding baselines with similar GPU parallelization. We observe that the additional speedup due to AdaCache increases with more GPUs, verifying the impact of caching on GPU communication overhead.

#### Speedups at different resolutions:

In Table LABEL:tab:ablation:resolution, we compare the trade-offs of AdaCache at various resolutions of video generations, namely, 480p - 2s, 480p - 4s and 720p - 2s, all at 100-steps. AdaCache provides consistent speedups across different resolutions without affecting the quality.

#### Cache metric, location and residual:

When adaptively deciding the caching schedule, we consider different metrics to compute the rate-of-change between representations, namely, L1/L2 distance or cosine distance. Among these, L1/L2 give an absolute measure which aligns better with the actual change. In contrast, cosine computes a normalized-distance, which is not a good estimate of change (*e.g*. if the representations differ only by a scale, the distance will be zero, even though we want to have a non-zero value). This observation is verified by the results in Table LABEL:tab:ablation:adacache_metric. Moreover, we consider computing the cache metric at various locations (*i.e*., layers) in the DiT. Doing so at a single layer (*e.g*. start, mid, end) is not significantly different from computing an aggregate over multiple-layers (see Table LABEL:tab:ablation:adacache_which_layer). By default, we compute the cache metric in the mid-layer as a reasonable choice without extra overheads. As for the choice of residual to be used for the cache metric computation, we resort to temporal-attention as it achieves the best trade-off (see Table LABEL:tab:ablation:cache_residual).

#### AdaCache variants:

To achieve a range of speedups (and quality), we consider different basis cache-rates in our AdaCache implementation. For instance, we can have higher-speedup with a slightly-lower quality (*e.g*. AdaCache-fast), a lower-speedup with a higher-quality (*e.g*. AdaCache-slow), or balance both (*e.g*. AdaCache-medium). We can conveniently control this by having corresponding basis cache-rates as shown in Table LABEL:tab:ablation:base_rates. By defualt, we resort to AdaCache-fast which gives the best speedups.

### 5.4 Qualitative results

Figure: Figure 9: Qualitative comparison: We show qualitative results on multiple video-DiT baselines including Open-Sora (Zheng et al., ) (720p - 2s at 100-steps), Open-Sora-Plan (Lab and etc., ) (512$\times$512 - 2.7s at 150-steps) and Latte (Ma et al., ) (512$\times$512 - 2s at 50-steps), while comparing against prior training-free inference acceleration method PAB (Zhao et al., ). AdaCache shows a comparable generation quality at much-faster speeds. Best-viewed with zoom-in. Prompts and additional qualitative results (Fig. A.3) are given in supplementary.
Refer to caption: extracted/5985260/figures/quali.png

In Fig. 9, we present qualitative results on mutliple video DiT baselines, including Open-Sora (Zheng et al., ), Open-Sora-Plan (Lab and etc., ) and Latte (Ma et al., ). We compare AdaCache against each baseline and prior training-free inference acceleration method for video DiTs, PAB (Zhao et al., ). Here, we consider three different configurations: 720p - 2s generations at 100-steps for Open-Sora, 512$\times$512 - 2.7s generations at 150-steps for Open-Sora-Plan, and 512$\times$512 - 2s generations at 50-steps for Latte, while considering prompts from Open-Sora gallery (see supplementary for prompt details). AdaCache shows a comparable generation quality, while having much-faster inference pipelines. In fact, it achieves 4.49$\times$ (vs. 1.26$\times$ in PAB), 3.53$\times$ (vs. 1.45$\times$ in PAB), 2.46$\times$ (vs. 1.33$\times$ in PAB) speedups respectively on the three considered baseline video DiTs. In most cases our generations are aligned well with the baseline in the pixel space. Yet this is not a strict requirement, as the denoising process can deviate considerably from that of the baseline, particularly at high caching rates. Still, AdaCache is faithful to the text prompt and is not affected by significant artifacts. Refer Fig. A.3 for additional qualitative comparisons.

## 6 Conclusion

In this paper, we introduced Adaptive Caching (AdaCache), a plug-and-play component that improves the the inference speed of video diffusion transformers without needing any re-training. It caches residual computations, while also devising the caching schedule dependent on each video generation. We further proposed a Motion Regularization (MoReg)
to utilize video information and allocate computations based on motion content, improving the quality-latency trade-off. We apply our contributions on multiple open-source video DiTs, showing comparable generation quality at a fraction of latency. We believe AdaCache is widely-applicable with minimal effort, helping democratize high-fidelity long-video generation.

### Acknowledgements

The authors would like to thank Ankit Khedia, Arvind Somasundaram, Dustin Johnson, Eugene Vecharynski, Ly Cao, SK Bong, and Yuzi He for the interesting discussions, and Shikun Liu for the support in setting-up the project page. The authors also appreciate the time and effort volunteered by the participants of the user study.

### Ethics Statement

This paper introduces a generic training-free inference acceleration mechanism for video diffusion transformers. The merits of the proposed method are evaluated on publicly-available open-source video-DiTs without being tied to a specific model or any commercial application. Consequently, the potential negative impacts of our method align with those of other video generation models and it pose no unique risk that requires special consideration.

### Reproducibility Statement

This paper considers open-source video DiTs (w/ publicly-available code and pretrained-weights) in all presented experiments. As it relies on zero-shot (*i.e*., training-free) inference acceleration, it requires no updates to pretrained weights. All quantitative evaluations and generated videos correspond to benchmark prompts that are publicly-available. The paper details all required steps to reproduce the proposed contributions and the code is also released to the public, supporting further research on efficient video generation.

## A Appendix

Figure: Figure A.1: Change in motion-score and motion-gradient across steps: We show the histograms of Motion Regularization metrics (namely, motion-score and motion-gradient) across diffusion steps. Here, motion-score is estimated as latent frame-differences, which correlates well with the perceived motion of a given video sequence. However, it can be unreliable in early denoising steps as such latent representations are noisy. To predict the actual motion (*i.e*., motion in latter steps $\approx$ motion in pixel space) early, we rely on motion-gradient across diffusion steps. Together, motion-score and motion-gradient provide a reasonable regularization. Best-viewed with zoom-in. Prompts given in supplementary.
Refer to caption: extracted/5985260/figures/supp_mo_grad.png

### A.1 Design decisions

#### Motion-score and motion-gradient:

We rely on two metrics in our Motion regularization: namely, motion-score ($m_{t}$) and motion-gradient ($mg_{t}$). As previously-discussed, motion-score can be unreliable particularly in early diffusion steps as it is estimated based on noisy-latents. For instance, in videos with higher motion content, our motion-score often starts small and gradually increases towards the end of diffusion process (see the two rightmost columns in Fig. A.1). In slow-moving videos, motion-score can start higher can converge to a smaller value (see the leftmost column in Fig. A.1). Simply put, we need a predictor of actual motion (*i.e*., motion in latter steps $\approx$ motion in pixel space) early in the diffusion process for a proper caching regularization. Therefore, we compute a motion-gradient across diffusion-steps, which can act as such a reasonable predictor (orange bars in Fig. A.1). Together, motion-score and motion-gradient regularize the caching schedule, allocating computations based on the motion content of the video being generated.

#### Codebook of basis cache-rates:

We devise our caching schedule based on a pre-defined codebook of basis cache-rates. It is a collection of cache-rates that is specific to a denoising schedule (*i.e*., #steps), coupled with distance metric ($c_{t}$) thresholds for selection. Both basis cache-rates and thresholds are hyperparameters. Here, optimal thresholds may need to be tuned per video-DiT baseline, whereas the cache-rates can be adjusted depending on the required speedup (*e.g*. AdaCache-fast, AdaCache-slow). For instance, on Open-Sora Zheng et al. () baseline, we use the codebook {0.08: 6, 0.16: 5, 0.24: 4, 0.32: 3, 0.40: 2, 1.00: 1} for AdaCache-fast in a 30-step denoising schedule, and the codebook {0.03: 12, 0.05: 10, 0.07: 8, 0.09: 6, 0.11: 4, 1.00: 3} in a 100-step schedule. For AdaCache-slow in a 30-step schedule, we use the codebook {0.08: 3, 0.16: 2, 0.24: 1.00: 1}. A specific cache-rate is selected if the distance metric is smaller than the corresponding threshold (and larger than any previous thresholds).

### A.2 Additional qualitative results

In Fig. A.2, we provide additional qualitative results, comparing AdaCache and AdaCache (w/ MoReg) with a baseline Open-Sora (Zheng et al., ). Here, we consider 480p - 2s video generations at 30-steps, based on a few VBench (Huang et al., ) prompts. Both versions with and without motion regularization achieve comparable speedups (2.10$\times$ and 2.24$\times$, respectively). Yet, MoReg helps stabilize the generation quality— especially towards the end-of-sequence in long-videos— by allocating computations proportional to the amount of motion. The generations with motion regularization also follow the corresponding baseline generations more-faithfully. In Fig. A.3, we present additional qualitative comparisons with prior-art at a comparable inference speedup. Here, we consider 720p - 2s video generations at 100-steps, based on a few Sora (OpenAI, ) prompts. Our comparison includes PAB (Zhao et al., ): another training-free video-DiT acceleration method. AdaCache consistently shows a better generation quality at a 2.61$\times$ speedup, compared to PAB, even at a 1.66$\times$ speedup. This behavior is also observed in Fig. 6, as the generation quality of PAB degrades quickly at faster speeds.

Figure: Figure A.2: Additional qualitative results on our Motion Regularization: We show a qualitative comparison of AdaCache and AdaCache (w/ MoReg), applied on top of Open-Sora (Zheng et al., ) baseline. Here, we consider generation of 480p - 2s clips at 30-steps. Despite giving a 2.24$\times$ speedup, AdaCache can also introduce some inconsistencies over time. Our Motion Regularization helps avoid most of them by allocating computations proportional to the amount of motion (still giving a 2.10$\times$ speedup). Best-viewed with zoom-in. Prompts given in supplementary.
Refer to caption: extracted/5985260/figures/supp_moreg.png

Figure: Figure A.3: Additional qualitative comparisons with prior-art: We show qualitative comparisons with prior-art on baseline Open-Sora (Zheng et al., ) (720p - 2s at 100-steps). Here, we evaluate against prior training-free inference acceleration method PAB (Zhao et al., ) at a comparable speedup. AdaCache consistently shows a better generation quality. Best-viewed with zoom-in. Prompts given in supplementary.
Refer to caption: extracted/5985260/figures/supp_sota.png

### A.3 Text prompts used in qualitative examples

In this subsection, we provide all the prompts used to generate the qualitative results shown in the paper. They consist of prompts from multiple sources including Open-Sora (Zheng et al., ) gallery, VBench (Huang et al., ) benchmark and Sora (OpenAI, ), all of which are publicly-available.

Text prompts corresponding to the video generations in Fig. 1:

- •
A Japanese tram glides through the snowy streets of a city, its sleek design cutting through the falling snowflakes with grace. The tram’s illuminated windows cast a warm glow onto the snowy surroundings, creating a cozy atmosphere inside. Snowflakes dance in the air, swirling around the tram as it moves along its tracks. Outside, the city is blanketed in a layer of snow, transforming familiar streets into a winter wonderland. Cherry blossom trees, now bare, stand quietly along the tram tracks, their branches dusted with snow. People hurry along the sidewalks, bundled up against the cold, while the tram’s bell rings softly, announcing its arrival at each stop.
- •
a picturesque scene of a tranquil beach at dawn. the sky is painted in soft pastel hues of pink and orange, reflecting on the calm, crystal-clear water. gentle waves lap against the sandy shore, where a lone seashell lies near the water’s edge. the horizon is dotted with distant, low-lying clouds, adding depth to the serene atmosphere. the overall mood of the video is peaceful and meditative, with no text or additional objects present. the focus is on the natural beauty and calmness of the beach, captured in a steady, wide shot.
- •
a bustling night market scene with vibrant stalls on either side selling food and various goods. the camera follows a person walking through the crowded, narrow alley. string lights hang overhead, casting a warm, festive glow. people of all ages are talking, browsing, and eating, creating an atmosphere full of lively energy. occasional close-ups capture the details of freshly cooked dishes and colorful merchandise. the video is dynamic with a mixture of wide shots and close-ups, capturing the essence of the night market without any text or sound.
- •
a dynamic aerial shot showcasing various landscapes. the sequence begins with a sweeping view over a dense, green forest, transitioning smoothly to reveal a winding river cutting through a valley. next, the camera rises to capture a panoramic view of a mountain range, the peaks dusted with snow. the shot shifts to a coastal scene, where waves crash against rugged cliffs under a partly cloudy sky. finally, the aerial view ends over a bustling cityscape, with skyscrapers and streets filled with motion and life. the video does not contain any text or additional overlays.
- •
a cozy living room scene with a christmas tree in the corner adorned with colorful ornaments and twinkling lights. a fireplace with a gentle flame is situated across from a plush red sofa, which has a few wrapped presents placed beside it. a window to the left reveals a snowy landscape outside, enhancing the festive atmosphere. the camera slowly pans from the window to the fireplace, capturing the warmth and tranquility of the room. the soft glow from the tree lights and the fire illuminates the room, casting a comforting ambiance. there are no people or text in the video, focusing purely on the holiday decor and cozy setting.

Text prompts corresponding to new video generations in Fig. 2:

- •
a breathtaking aerial view of a river meandering through a lush green landscape. the river, appearing as a dark ribbon, cuts through the verdant fields and hills, reflecting the soft light of the pinkish-orange sky. the sky, painted in hues of pink and orange, suggests the time of day to be either sunrise or sunset. the landscape is dotted with trees and bushes, adding to the natural beauty of the scene. the perspective of the video is from above, providing a bird’s eye view of the river and the surrounding landscape. the colors , the river, the landscape, and the sky all come together to create a serene and picturesque scene.
- •
A cozy living room, surrounded by soft cushions and warm lighting. Describe the scene in vivid detail, capturing the feeling of comfort and relaxation.
- •
a nighttime scene in a bustling city filled with neon lights and futuristic architecture. the streets are crowded with people, some dressed in high-tech attire and others in casual cyberpunk fashion. holographic advertisements and signs illuminate the area in vibrant colors, casting a glow on the buildings and streets. futuristic vehicles and motorcycles are speeding by, adding to the city’s dynamic atmosphere. in the background, towering skyscrapers with intricate designs stretch into the night sky. the scene is filled with energy, capturing the essence of a cyberpunk world.
- •
a close-up shot of a vibrant coral reef underwater. various colorful fish swim leisurely around the corals, creating a lively scene. the lighting is natural and slightly subdued, emphasizing the deep-sea environment. soft waves ripple across the view, occasionally bringing small bubbles into the frame. the background fades into a darker blue, suggesting deeper waters beyond. there are no texts or human-made objects visible in the video.
- •
a neon-lit cityscape at night, featuring towering skyscrapers and crowded streets. the streets are bustling with people wearing futuristic attire, and vehicles hover above in organized traffic lanes. holographic advertisements are projected onto buildings, illuminating the scene with vivid colors. a light rain adds a reflective sheen to the ground, enhancing the cyberpunk atmosphere. the camera pans slowly through the scene, capturing the energy and technological advancements of the city. the video does not contain any text or additional objects.
- •
a breathtaking view of a mountainous landscape at sunset. the sky is painted with hues of orange and pink, casting a warm glow over the scene. the mountains, bathed in the soft light, rise majestically in the background, their peaks reaching towards the sky. in the foreground, a woman is seated on a rocky outcrop, her body relaxed as she takes in the vie w. she is dressed in a black dress and boots, her attire contrasting with the natural surroundings. her position on the rock provides a vantage point over a river that meanders through the valley below. the river, a ribbon of blue, winds its way through the landscape, adding a dynamic element to the scene. the woman’s gaze is directed towards the river, suggesting a sense of contemplation or admiration for the beauty of nature. the video is taken from a high angle, looking down on the woman and the landscape. this perspective enhances the sense of depth and scale in the image, emphasizing the vastness of the mountains and the river.
- •
an animated scene featuring a young girl with short black hair and a bow tie, seated at a wooden desk in a warmly lit room. natural light filters through a window, illuminating the girl’s wide eyes and open mouth, conveying a sense of surprise or shock. she is dressed in a blue shirt with a white collar and dark vest. the room’s inviting atmosphere is complemented by wooden furniture and a framed picture on the wall. the animation style is reminiscent of japanese anime, characterized by vibrant colors and expressive character designs.

Text prompts corresponding to new video generations in Fig. 7:

- •
a breathtaking aerial view of a misty mountain landscape at sunrise. the sun is just beginning to peek over the horizon, casting a warm glow on the scene. the mountains, blanketed in a layer of fog, rise majestically in the background. the mist is so dense that it obscures the peaks of the mountains, adding a sense of mystery to the scene. in the foregro und, a river winds its way through the landscape, its path marked by the dense fog. the river appears calm, its surface undisturbed by the early morning chill. the colors in the video are predominantly cool, with the blue of the sky and the green of the trees contrasting with the warm orange of the sunrise. the video is taken from a high vantage point, p roviding a bird’s eye view of the landscape. this perspective allows for a comprehensive view of the mountains and the river, as well as the fog that envelops them. the video doe s not contain any text or human activity, focusing solely on the natural beauty of the landscape. the relative positions of the objects suggest a vast, untouched wilderness.
- •
a 3d rendering of a female character with curly blonde hair and striking blue eyes. she is wearing a black tank top and is standing in front of a fiery backdrop. the character is looking off to the side with a serious expression on her face. the background features a fiery orange and red color scheme, suggesting a volcanic or fiery environment. the lighting in the scene is dramatic, with the character’s face illuminated by a soft light that contrasts with the intense colors of the background. there are no texts or other objects in the image. the style of the image is realistic with a high level of detail, indicative of a high-quality 3d rendering.

Text prompts corresponding to new video generations in Fig. 3:

- •
a realistic 3d rendering of a female character with curly blonde hair and blue eyes. she is wearing a black tank top and has a neutral expression while facing the camera directly. the background is a plain blue sky, and the scene is devoid of any other objects or text. the character is detailed, with realistic textures and lighting, suitable for a video game or high-quality animation. there is no movement or additional action in the video. the focus is entirely on the character’s appearance and realistic rendering.

Text prompts corresponding to new video generations in Fig. 9:

- •
a scenic shot of a historical landmark. the landmark is an ancient temple with tall stone columns and intricate carvings. the surrounding area is lush with greenery and vibrant flowers. the sky above is clear and blue, with the sun casting a warm glow over the scene. tourists can be seen walking around, taking pictures and admiring the architecture. there is no text or additional objects in the video.
- •
a vibrant cyberpunk street scene at night. neon signs and holographic advertisements illuminate the narrow street, casting colorful reflections on the rain-slicked pavement. various characters, dressed in futuristic attire, move along the sidewalks while robotic street vendors sell their wares. towering skyscrapers with glowing windows dominate the background, creating a sense of depth. the camera takes a wide-angle perspective, capturing the bustling and lively atmosphere of the cyberpunk cityscape. there are no texts or other objects outside of the described scene.

Text prompts corresponding to new video generations in Fig. A.2:

- •
A cute happy Corgi playing in park, sunset, surrealism style
- •
An astronaut is riding a horse in the space in a photorealistic style.
- •
A panda playing on a swing set
- •
a backpack and an umbrella
- •
a black vase
- •
a shark is swimming in the ocean, Van Gogh style
- •
A teddy bear washing the dishes
- •
A tranquil tableau of a peaceful orchid garden showcased a variety of delicate blooms
- •
A tranquil tableau of the phone booth was tucked away in a quiet alley

Text prompts corresponding to new video generations in Fig. A.3:

- •
A gorgeously rendered papercraft world of a coral reef, rife with colorful fish and sea creatures.
- •
This close-up shot of a Victoria crowned pigeon showcases its striking blue plumage and red chest. Its crest is made of delicate, lacy feathers, while its eye is a striking red color. The bird’s head is tilted slightly to the side, giving the impression of it looking regal and majestic. The background is blurred, drawing attention to the bird’s striking appearance.
- •
This close-up shot of a chameleon showcases its striking color changing capabilities. The background is blurred, drawing attention to the animal’s striking appearance.
- •
a green blob and an orange blob are in love and dancing together
- •
New York City submerged like Atlantis. Fish, whales, sea turtles and sharks swim through the streets of New York.
- •
nighttime footage of a hermit crab using an incandescent lightbulb as its shell
- •
A large orange octopus is seen resting on the bottom of the ocean floor, blending in with the sandy and rocky terrain. Its tentacles are spread out around its body, and its eyes are closed. The octopus is unaware of a king crab that is crawling towards it from behind a rock, its claws raised and ready to attack. The crab is brown and spiny, with long legs and antennae. The scene is captured from a wide angle, showing the vastness and depth of the ocean. The water is clear and blue, with rays of sunlight filtering through. The shot is sharp and crisp, with a high dynamic range. The octopus and the crab are in focus, while the background is slightly blurred, creating a depth of field effect.
- •
A low to the ground camera closely following ants in the jungle down into the ground into their world.
- •
Photorealistic closeup video of two pirate ships battling each other as they sail inside a cup of coffee.
- •
a photorealistic video of a butterfly that can swim navigating underwater through a beautiful coral reef
- •
A computer hacker labrador retreiver wearing a black hooded sweatshirt sitting in front of the computer with the glare of the screen emanating on the dog’s face as he types very quickly.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. My main concerns regarding this paper are related to experiments results presentation and clarification of method hyperparameters:

a. Since method is not deterministic, the results should include std values for inference time and speedup (See Weakness 2a). Moreover, apart of adding std values, I recommend to conduct ablation studies on more than 32 videos (See Weakness 2b).

b. AdaCache without MoReg is not tied to video generation, I recommend to include image generation DiTs caching (See Weakness 2c).

c. I suggest authors to provide information about rate-of-change schedule hyperparameters selection, as it is crucial pert of the proposed method (See Weakness 1a).

2. Additional group of questions is not as important as the main one, but can also help to improve the quality of the manuscript:

a. Statement regarding unique caching schedules for each layer needs clarification (See Weakness 1a). 

b. The paper would greatly benefit from method’s limitations analysis (See Weakness 2).

c. The authors may include FORA [1] in comparisons.

d. It interesting to see how AdaCache performs on MMDiT models such as CogVideoX [2] and SD-3 [3].

e. In line 196, it would be beneficial to explain which features were used for visualization.


[1] Selvaraju, P., Ding, T., Chen, T., Zharkov, I., & Liang, L. (2024). Fora: Fast-forward caching in diffusion transformer acceleration. arXiv preprint arXiv:2407.01425.

[2] Yang, Z., Teng, J., Zheng, W., Ding, M., Huang, S., Xu, J., ... & Tang, J. (2024). Cogvideox: Text-to-video diffusion models with an expert transformer. arXiv preprint arXiv:2408.06072.

[3] Esser, P., Kulal, S., Blattmann, A., Entezari, R., Müller, J., Saini, H., ... & Rombach, R. (2024, March). Scaling rectified flow transformers for high-resolution image synthesis. In Forty-first International Conference on Machine Learning.
soundness: 2
strengths: 1. Novelty: The idea of adaptive caching seems novel in the field of diffusion model caching.
2. Motivation: The paper provides a clear motivation for AdaCache method.
3. Clearness: The method is simple and easy to understand.
summary: The paper proposes training-free Diffusion Transformer (DiT) acceleration named AdaCache. The method is motivated by the fact that different videos require different amounts of computation. AdaCache decides whether to skip or recompute the cache during the cache step defined by the schedule, using an introduced rate-of-change metric $c_t$, which is basically L1 distance between residual block features in current and previous cache schedule timesteps.  Authors further augment rate-of-change metric c_t with a Motion Regularization (MoReg) metric to add information about the motion content of the generated video.

Overall, the AdaCache idea has good potential. However, the current version of the manuscript needs significant revision to be accepted for this conference. Please refer to the Weaknesses and Questions sections for more details.
weaknesses: 1. Method section requires clarifications: 

a. The paper lacks information about the selection of rate-of-change schedule hyperparameters.

b. Lines 286-287 stat that authors observe that unique caching schedules for each layer will make the generations unstable. This important observation requires further explanation and clarification.

2. Experiment results require better presentation:

a. There are concerns regarding the reported speedup and latency. Given that AdaCache is not a deterministic method and inference time for different videos varies, it is incorrect to report just the mean inference time and speedup for all videos. Standard deviation (std) values should be included.

b. Ablation studies are performed on only 32 videos. Considering that AdaCache is not deterministic, the results may have low statistical significance.  

c. AdaCache without MoReg is a general method that could apply to image diffusion transformers. A comparison with prior works on DiT architectures for image generation, such as PIXART-α for T2I generation and DiT-XL for class-conditional image generation on ImageNet, is suggested.

d. The paper missed a comparison with another DiT caching method like FORA [1].

3. The paper lacks Limitation section. It would be interesting to see if there are videos on which AdaCache performs worse than its deterministic competitors.

---

confidence: 5
contribution: 3
initial_rating: 8
presentation: 4
questions: On the whole, I consider this paper to be well-executed. However, I'm intrigued by the possibility of identifying a metric that could more accurately assess the redundancy in the system. Furthermore, I'm curious about the potential of integrating layer-wise broadcasting dynamically with distillation techniques to enhance real-time video generation capabilities.
soundness: 4
strengths: 1. Adaptive Caching achieve very good performance even compared with recent PAB paper. I very appreciate it.

2. This approach requires no training and can seamlessly be integrated into a baseline video DiT at inference, as a plug-and-play component.

3. Motion Regularization (MoReg) to allocate computations based on the motion content in the video being generated seems to be very reasonable.
summary: The paper introduces a training-free method called Adaptive Caching (AdaCache) to accelerate video Diffusion Transformers (DiTs). AdaCache is based on the idea that "not all videos are created equal," meaning some videos require fewer denoising steps to achieve reasonable quality. It caches computations through the diffusion process and devises a caching schedule tailored to each video generation to maximize the quality-latency trade-off. Additionally, the paper introduces a Motion Regularization (MoReg) scheme to utilize video information within AdaCache, essentially controlling compute allocation based on motion content. These plug-and-play contributions significantly speed up inference (e.g., up to 4.7× faster on Open-Sora 720p - 2s video generation) without compromising generation quality across multiple video DiT baselines. The code for this method will be made publicly available.
weaknesses: 1. Regarding the choice of metric, why was the Mean Squared Error (MSE) selected directly? Can the MSE metric truly reflect the actual reduction in features between adjacent steps? Are there alternative metrics that might be more suitable, or can you provide comparisons with other metrics such as the cosine similarity metric or others?

2. Secondly, I'm interested in knowing if the proposed method is compatible with large Text-to-Image (T2I) base models, like FLUX. If it is, what would be the expected impact on the performance metrics?

3. Although above questions exists, I think this is a really valuable paper

---

confidence: 5
contribution: 4
initial_rating: 5
presentation: 4
questions: 1. The primary concern with this paper is the practical effectiveness of AdaCache. More qualitative comparisons are needed to robustly demonstrate AdaCache’s effectiveness in preserving visual quality, especially for the detail generations.
2. The authors need to provide more detailed methodological details, such as the construction and role of the codebook in caching rates.
soundness: 4
strengths: a. The approach presented is straightforward, and the method section is generally clear and easy to follow.
b. The motivation for the work is reasonable and interesting, i.e., "not all videos are created equal".
c. AdaCache provides a training-free acceleration method that can be applied to existing video diffusion models, achieving significant speedups without additional model training.
summary: The paper introduces Adaptive Caching (AdaCache), a plug-and-play, training-free method to accelerate video generation using diffusion transformers.  The authors note that "not all videos are created equal", meaning some videos don’t need as many processing steps to reach high quality. Based on this, they propose an adaptive caching strategy that reduces the computation of denoising steps based on the rate-of-change. The authors also introduce a Motion Regularization (MoReg) scheme to adjust the caching schedule, which can allocate computation based on video motion content for improving the quality-latency trade-off. Experimental results demonstrate that AdaCache significantly speeds up existing video diffusion models.
weaknesses: 1. Lines 285-287 mention that using unique caching schedules for each layer makes the generations unstable, but it’s unclear why this is the case. It would help if the authors provided an explanation.
2. Equation 5 introduces a codebook for the caching rate, but it’s not clear what this codebook is or how it’s created. The authors should add more details to clarify this part of the method.
3. While Table 1 shows AdaCache outperforming PAB, the qualitative comparison in Fig. 7 shows a different result. AdaCache seems to lose more visual detail, especially in the details. This raises concerns about its practical quality compared to PAB.
4. In Table 1, AdaCache achieves better VBench results than the baseline. The authors should explain why the accelerated video have better results, especially since the visual quality in Fig. 7 is noticeably worse than the baseline. 
5.  In Table 1, the SSIM of AdaCache-slow on Line 346 appears unusually high.

I’m concerned about the fairness of the experiments. On the OpenSora model, PAB results are based on text-to-video task, while AdaCache is tested on image-to-video task.  I keep my original Rating.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: 1. The caching rate for the steps following step t is determined based on the rate of feature change between steps t and t+k. The reviewer wonders whether this metric is reasonable. For instance, as shown in Fig. 2, during the early and late stages of sampling, the L1 curve exhibits rapid changes, characterized by a large derivative. Would relying on the differences at earlier time steps to determine the subsequent caching rate introduce errors?
2. Could the authors provide more visual quality comparison results? For example, visualizations of the sampling process under different configurations (fast, slow) and how different video content leads to varying caching schedules, to more intuitively demonstrate the mechanism and effectiveness of the designed caching schedule.
3. PAB demonstrates impressive results in multi-GPU parallel processing. Can the authors' method leverage similar techniques (e.g., DSP) to scale to multi-GPU parallel inference? What would the efficiency be like?
4. The reviewer wants to know the source of the Delta-DIT performance in Table 1 and why there is almost no acceleration.
soundness: 2
strengths: 1.A novel adaptive algorithm is designed to control the number of steps for reusing cached features.
summary: This paper presents AdaCache which accelerates video generation by caching residual computations and devising adaptive caching schedule without requiring re-training. It also introduces MoReg to optimize computation based on motion. This paper demonstrates the effectiveness of AdaCache across various open-source models.
weaknesses: 1. typo need to be corrected:
    1. Line346: SSIM of AdaCache-slow should be 0.7910?
2. The methodology section lacks clarity in certain areas. For example, in Line 276, a pre-defined codebook is mentioned, and the reviewer wants to know how this codebook was pre-defined. Was it manually set? If so, what criteria or method were used to set it? Is there any further detailed explanation regarding it?
3. The qualitative comparison provided by the authors is insufficient and does not adequately demonstrate the superiority of AdaCache. Although AdaCache achieves a higher acceleration speedup, as shown in Figure 7, its results on Open-Sora-Plan (e.g., Rows 1, 2, 6, 7) and Latte (e.g., Rows 2, 4, 6, 7) are significantly worse than those of PAB and the Baseline. Based on the visual quality presented in Figure 7, the reviewer expresses concerns about the stability of AdaCache in terms of visual quality.

---


After reviewing the authors' latest response to Reviewer 5tUr's comments, the reviewer has decided to further lower the score. The primary concerns stem from:

The reliability of quantitative comparison data

(i) In the latest responses (3) and (4), the authors stated: "We follow the original inference settings suggested by the original contributors—in OpenSora, this is image- and text-conditioned generation." This implies that in Table 1, the experimental setup for OpenSora involves image- and text-conditioned generation. However, as far as the reviewer knows, PAB does not use reference images as image conditions by default in OpenSora. Yet, the performance metrics listed for PAB in Table 1—including fidelity metrics such as PSNR and SSIM, as well as reference-free metrics like VBench—are entirely identical to those reported in the PAB paper. The reviewer is uncertain whether these data were directly from the PAB paper. If so, the comparison would be unfair since PAB defaults to operating without image conditioning.

(ii) The sources of the Delta-Dit and TGATE data in Table 1 are unclear. Additionally, the FLOPS and visual quality results are unusual, showing almost no speedup.

Insufficient clarity in the experimental details presented in the paper, which may lead to misunderstandings

(i) The authors conducted experiments on three models: Open-Sora, Open-Sora-Plan, and Latte. Open-Sora-Plan and Latte are text-conditioned, while Open-Sora uses a text- and image-conditioned setup. The reviewer believes that such a unique configuration should be explicitly clarified in the paper.

(ii) In the rebuttal, the authors mentioned that for OpenSora, reducing the timesteps from 100 to 30 leads to a dramatic change in the speedup factor, from 4.5x to 2.24x. This significant variation should be emphasized and analyzed in the paper. However, the reviewer could not find any related discussion in the manuscript.

---
**The final update**

The paper initially received a rating of 6 because the reviewer, while expressing concerns about the reliability and reproducibility of the methodology as well as the rigor of the experimental section, appreciated the motivation behind the work, encapsulated in the statement: "not all videos are created equal." Based on this, the reviewer assigned a rating of 6.

The reasons for the two rating reductions

(1) During the rebuttal period, the author mentioned that modifying the setup from 100 timesteps to 30 timesteps led to a significant change in speedup, decreasing from 4.5x to 2.24x. This detail, however, was neither thoroughly discussed nor emphasized in the paper. It is evident that **the influence of this variable is much greater than that of resolution and video size, which were included in the ablation study**.
The absence of detailed discussion and emphasis on such experimental findings and conclusions not only risks confusing readers but also raises questions about the reliability and reproducibility of AdaCache. As a result, the reviewer lowered the rating for the first time.

(2) The lack of rigor in experimental comparisons

(i) The authors mentioned that the use of image conditions in OpenSora was motivated by an issue raised in the original repository, which stated that "the lack of a reference image leads to inconsistencies in video quality," i.e., a decline in motion consistency and visual quality. This implies that **the introduction of image conditions improves visual quality**.

(ii) The authors further claimed that AdaCache **directly utilized data from PAB because they reproduced PAB and obtained similar quantitative numbers** (with negligible changes). However, to the reviewer’s knowledge, PAB does not employ image conditions. **If the authors introduced image conditions to PAB for a fair comparison but still achieved similar VBench metrics, this appears highly counterintuitive.** If this is the case, what is the rationale behind AdaCache incorporating reference images? It should be noted that synthesizing reference images incurs significant computational overhead.

(iii) Given that a significant portion of the paper, including the experiments in the ablation study, was conducted on OpenSora, the inclusion of image conditions cannot be overlooked. The introduction of image conditions not only affects visual quality but may also impact the L1 distance between features, thereby influencing the caching rate. **This aspect should have been emphasized in the experimental section, yet it is not mentioned even once throughout the paper.**

(iv) To ensure fair quantitative comparisons, AdaCache should follow PAB's experimental setup, exclude reference images, and retest metrics such as VBench, SSIM, and PSNR. 

Due to concerns about the rigor of the experiments, the reviewer downgraded the rating once again.

Meta-review: The paper introduces a novel adaptive algorithm but has several weaknesses. The choice of MSE as a metric is questioned, and the reviewer asks whether alternative metrics, like cosine similarity, would be more suitable. The compatibility with large T2I models like FLUX is unclear. The methodology section lacks clarity, especially regarding the pre-defined codebook. The qualitative comparison is insufficient, with AdaCache showing worse performance on certain datasets, raising concerns about stability. The reliability of the quantitative comparison is questionable, particularly regarding the experimental setup and data sources in Table 1. The experimental details, such as conditions for Open-Sora-Plan and Latte, should be clarified, and the speedup factor variation needs further discussion.

The review scores are mixed, but the detailed negative feedback from the reviewers highlights significant issues with the paper. After reviewing the paper and rebuttal, the Area Chair also concluded that the paper should be rejected.

Decision: Reject