Dynamic Diffusion Transformer

## Abstract

Abstract Diffusion Transformer (DiT), an emerging diffusion model for image generation, has demonstrated superior performance but suffers from substantial computational costs. Our investigations reveal that these costs stem from the static inference paradigm, which inevitably introduces redundant computation in certain diffusion timesteps and spatial regions . To address this inefficiency, we propose Dy namic Di ffusion T ransformer (DyDiT), an architecture that dynamically adjusts its computation along both timestep and spatial dimensions during generation. Specifically, we introduce a Timestep-wise Dynamic Width (TDW) approach that adapts model width conditioned on the generation timesteps. In addition, we design a Spatial-wise Dynamic Token (SDT) strategy to avoid redundant computation at unnecessary spatial locations. Extensive experiments on various datasets and different-sized models verify the superiority of DyDiT. Notably, with <3% additional fine-tuning iterations, our method reduces the FLOPs of DiT-XL by 51%, accelerates generation by 1.73 × \times × , and achieves a competitive FID score of 2.07 on ImageNet. The code is publicly available at https://github.com/NUS-HPC-AI-Lab/Dynamic-Diffusion-Transformer .

## 1 Introduction

Diffusion models (Ho et al., ; Dhariwal & Nichol, ; Rombach et al., ; Blattmann et al., ) have demonstrated significant superiority in visual generation tasks. Recently, the remarkable scalability of Transformers (Vaswani et al., ; Dosovitskiy et al., ) has led to the growing prominence of Diffusion Transformer (DiT) (Peebles & Xie, ). DiT has shown strong potential across a variety of generation tasks (Chen et al., ; Ma et al., ; Chen et al., ) and is considered a foundational component in the development of Sora (Brooks et al., ), a pioneering model for video generation. Like Transformers in other vision and language domains (Dosovitskiy et al., ; Brown et al., ), DiT faces significant efficiency challenges during generation.

Existing approaches to improving DiT’s efficiency include efficient diffusion samplers (Song et al., ; ; Salimans & Ho, ; Meng et al., ; Luo et al., ) and global acceleration techniques (Ma et al., ; Pan et al., ). In addition, reducing computational redundancy within the DiT architecture using model compression techniques, such as structural pruning (Fang et al., ; Molchanov et al., ; He et al., ), also shows significant promise.

However, pruning methods typically retain a *static* architecture across both the *timestep* and *spatial* dimensions throughout the diffusion process. As shown in Figure 1(c), both the original DiT and the pruned DiT employ a fixed model width across all diffusion timesteps and allocate the same computational cost to every image patch. This static inference paradigm overlooks the varying complexities associated with different timesteps and spatial regions, leading to significant computational inefficiency. To explore this redundancy in more detail, we analyze the training process of DiT, during which it is optimized for a noise prediction task. Our analysis yields two key insights:

*a) Timestep perspective:* We plot the loss value differences between a pre-trained small model (DiT-S) and a larger model (DiT-XL) in Figure 1(a). The results show that the loss differences diminish substantially for $t>\hat{t}$, and even approach negligible levels as $t$ nears the prior distribution ($t\to T$). This indicates that the prediction task becomes *progressively easier at later timesteps* and could be managed effectively even by *a smaller model*. However, DiT applies the same architecture across all timesteps, leading to excessive computational costs at timesteps where the task complexity is low.

*b) Spatial perspective:* We visualize the loss maps in Figure 1(b) and observe a noticeable imbalance in loss values across different spatial regions of the image. Loss values are higher in patches corresponding to the main object, while patches representing background regions exhibit relatively lower loss. This suggests that the difficulty of noise prediction varies across spatial regions. Consequently, uniform computational treatment of all patches introduces redundancy and is likely suboptimal.

Based on the above insights, a promising approach to improve DiT’s computational efficiency is dynamic computation. To this end, we propose Dynamic Diffusion Transformer (DyDiT), which adaptively allocates computational resources during the generation process, as illustrated in Figure 1(c). Specifically, from the timestep perspective, we introduce a *Timestep-wise Dynamic Width* (TDW) mechanism, where the model learns to adjust the width of the attention and MLP blocks based on the current *timestep*. From a spatial perspective, we develop a *Spatial-wise Dynamic Token* (SDT) strategy, which identifies image patches where noise prediction is relatively “easy”, allowing them to bypass computationally intensive blocks, thus reducing unnecessary computation.

Notably, both TWD and SDT are plug-and-play modules that can be easily implemented on DiT to build DyDiT. Moreover, our method contributes to significant speedup due to the hardware-friendly design: 1) the model architecture at each timestep can be pre-determined offline, eliminating additional overhead for width adjustments and enabling efficient batch processing (Section 3.2); and 2) the token gathering and scattering operations incur minimal overhead and are straightforward to implement (Section 3.3). Such hardware efficiency distinguishes our approach from traditional dynamic networks (Herrmann et al., ; Meng et al., ; Han et al., ), which adapt their inference graphs for each sample and struggle to improve practical efficiency in batched inference.

We conduct extensive experiments across multiple datasets and model scales to validate the effectiveness of the proposed method. For example, compared to the static counterpart DiT-XL, our DyDiT-XL reduces FLOPs by 51% and accelerates the generation by 1.73 times, with less than 3% fine-tuning iterations, while maintaining a competitive FID score of 2.07 on ImageNet (256 $\times$ 256) (Deng et al., ). Our method shows potential for further efficiency gains when combined with efficient samplers, such as DDIM (Song et al., ) and DPM Solver++ (Lu et al., ), or global acceleration techniques like DeepCache (Ma et al., ). We anticipate that DyDiT will inspire future research in the development of more efficient diffusion Transformers.

Figure: Figure 1: (a) The loss difference between DiT-S and DiT-XL across all diffusion timesteps ($T=1000$). The difference is slight at most timesteps. (b) Loss maps (normalized to the range [0, 1]) at different timesteps, show that the noise in different patches has varying levels of difficulty to predict. (c) Difference of the inference paradigm between the static DiT and the proposed DyDiT.
Refer to caption: x1.png

## 2 Related Works

#### Efficient Diffusion Models.

Although diffusion models (Ho et al., ; Rombach et al., ) have achieved remarkable performance in generation tasks, their generation speed has always hindered their further applications primarily due to long sampling steps and high computational costs. Existing attempts to make diffusion models efficient can be roughly categorized into sampler-based methods, model-based methods, and global acceleration methods. The sampler-based methods (Song et al., ; ; Salimans & Ho, ; Meng et al., ; Luo et al., ) aim to reduce the sampling steps. Model-based approaches (Fang et al., ; So et al., ; Shang et al., ; Yang et al., ) attempt to compress the size of diffusion models via pruning (Fang et al., ; Shang et al., ) or quantization (Li et al., ; Shang et al., ). Global acceleration methods like Deepcache (Ma et al., ) tend to reuse or share some features across different timesteps.

Our DyDiT is mostly relates to the model-based approaches and orthoganal to the other two lines of work. However, unlike the pruning methods yielding static architectures, DyDiT performs dynamic computation for different diffusion timesteps and image tokens.

#### Dynamic Neural Networks.

Compared to static models, dynamic neural networks (Han et al., ) can adapt their computational graph based on inputs, enabling superior trade-off between performance and efficiency. They generally realize dynamic architectures by varying the network depth (Teerapittayanon et al., ; Bolukbasi et al., ; Yang et al., ; Han et al., ; ) or width (Herrmann et al., ; Li et al., ; Han et al., ) during inference. Some works explore the spatial redundancy in image *recognition* (Wang et al., ; Song et al., ; Rao et al., ; Liang et al., ; Meng et al., ). Despite their promising theoretical efficiency, existing dynamic networks usually struggle in achieving *practical efficiency* during batched inference (Han et al., ) due to the per-sample inference graph. Moreover, the potential of dynamic architectures in diffusion models, where a *timestep* dimension is introduced, remains unexplored.

This work extends the research of dynamic networks to the image *generation* field. More importantly, our TDW adjusts the network structure only conditioned on the *timesteps*, avoiding the sample-conditioned tensor shapes in batched inference. Together with the efficient token gathering and scattering mechanism of SDT, DyDiT shows preferable realistic efficiency.

## 3 Dynamic Diffusion Transformer

We first provide an overview of diffusion models and DiT (Peebles & Xie, ) in Section 3.1. DyDiT’s timestep-wise dynamic width (TDW) and spatial-wise dynamic token (SDT) approaches are then introduced in Sections 3.2 and 3.3. Finally, Section 3.4 details the training process of DyDiT.

### 3.1 Preliminary

#### Diffusion Models

(Ho et al., ; Song et al., ; Nichol & Dhariwal, ; Rombach et al., ) generate images from random noise through a series of diffusion steps. These models typically consist of a forward diffusion process and a reverse denoising process. In the forward process, given an image $\mathbf{x}_{0}\!\sim\!q(\mathbf{x})$ sampled from the data distribution, Gaussian noise $\epsilon\!\sim\!\mathcal{N}(0,I)$ is progressively added over $T$ steps. This process is defined as $q\left(\mathbf{x}_{t}\!\mid\!\mathbf{x}_{t-1}\right)\!=\!\mathcal{N}\left(
\mathbf{x}_{t};\sqrt{1-\beta_{t}}\mathbf{x}_{t-1},\beta_{t}\mathbf{I}\right)$, where $t$ and $\beta_{t}$ denote the timestep and noise schedule, respectively. In the reverse process, the model removes the noise and reconstructs $\mathbf{x}_{0}$ from $\mathbf{x}_{T}\!\sim\!\mathcal{N}(0,I)$ using $p_{\theta}\left(\mathbf{x}_{t-1}\!\mid\!\mathbf{x}_{t}\right)\!=\!\mathcal{N}
\left(\mathbf{x}_{t-1};\mu_{\theta}\left(\mathbf{x}_{t},t\right),\Sigma_{
\theta}\left(\mathbf{x}_{t},t\right)\right)$, where $\mu_{\theta}\left(\mathbf{x}_{t},t\right)$ and $\Sigma_{\theta}(\mathbf{x}_{t},t)$ represent the mean and variance of the Gaussian distribution.

#### Diffusion Transformer

(DiT) (Peebles & Xie, ) exhibits the scalability and promising performance of Transformers (Brooks et al., ). Similar to ViT (Dosovitskiy et al., ), DiT consists of layers composed of a multi-head self-attention (MHSA) block and a multi-layer perceptron (MLP) block, described as $\mathbf{X}\leftarrow\mathbf{X}+\alpha\text{MHSA}(\gamma\mathbf{X}+\beta),
\mathbf{X}\leftarrow\mathbf{X}+\alpha^{\prime}\text{MLP}(\gamma^{\prime}
\mathbf{X}+\beta^{\prime})$, where $\mathbf{X}\in\mathbb{R}^{N\times C}$ denotes image tokens. Here, $N$ is the number of tokens, and $C$ is the channel dimension. The parameters $\{\alpha,\gamma,\beta,\alpha^{\prime},\gamma^{\prime},\beta^{\prime}\}$ are produced by an adaptive layer norm (adaLN) block (Perez et al., ), which takes the class condition embedding $\mathbf{E}_{cls}$ and timestep embedding $\mathbf{E}_{t}$ as inputs.

### 3.2 Timestep-wise Dynamic Width

As aforementioned, DiT spends equal computation for different timesteps, although not all steps share the same generation difficulty (Figure 1(a)). Therefore, the *static* computation paradigm introduces significant redundancy in those “easy” timesteps. Inspired by structural pruning methods (He et al., ; Hou et al., ; Fang et al., ), we propose a *timestep-wise dynamic width* (TDW) mechanism, which adjusts the width of MHSA and MLP blocks in different timesteps. Note that TDW is *not a pruning method* that permanently removes certain model components, but rather retains the full capacity of DiT and *dynamically* activates different heads/channel groups at each timestep.

#### Heads and channel groups.

Given input $\mathbf{X}\!\in\!\mathbb{R}^{N\times C}$, an MHSA block employs three linear layers with weights $\mathbf{W}_{\text{Q}},\mathbf{W}_{\text{K}},\mathbf{W}_{\text{V}}\!\in\!
\mathbb{R}^{C\times(H\times C_{H})}$ to project it into Q, K, and V features, respectively. Here, $H$ denotes the head number and $C=\!\!H\!\times\!C_{H}$ in DiT. An output projection is performed using another linear layer with $\mathbf{W}_{\text{O}}\in\mathbb{R}^{(H\times C_{H})\times C}$. The operation of the conventional MHSA can be expressed as:

$$ $\text{MHSA}(\mathbf{X})=\sum_{h=1}^{H}\mathbf{X}_{\text{attn}}^{h}\mathbf{W}_{ \text{O}}^{h,:,:}=\sum_{h=1}^{H}(\operatorname{Softmax}((\mathbf{X}\mathbf{W}_ {\text{Q}}^{:,h,:})(\mathbf{X}\mathbf{W}_{\text{K}}^{:,h,:})^{\top})\mathbf{X} \mathbf{W}_{\text{V}}^{:,h,:})\mathbf{W}_{\text{O}}^{h,:,:}.$ (1) $$

An MLP block contains two linear layers with weights $\mathbf{W}_{1}\!\in\!\mathbb{R}^{C\times D}$ and $\mathbf{W}_{2}\!\in\!\mathbb{R}^{D\times C}$, where $D$ represents the hidden channels, set as $4C$ by default in DiT.
To dynamically control the MLP width, we divide $D$ hidden channels into $H$ groups, reformulating the weights into $\mathbf{W}_{1}\!\in\!\mathbb{R}^{C\times(H\times D_{H})}$ and $\mathbf{W}_{2}\!\in\!\mathbb{R}^{(H\times D_{H})\times C}$, where $D_{H}\!=\!D/H$. Hence, the operation in MLP can be formulated as:

$$ $\text{MLP}(\mathbf{X})=\sum_{h=1}^{H}\sigma(\mathbf{X}_{\text{hidden}}^{h}) \mathbf{W}_{2}^{h,:,:}=\sum_{h=1}^{H}\sigma(\mathbf{X}\mathbf{W}_{1}^{:,h,:}) \mathbf{W}_{2}^{h,:,:},$ (2) $$

where $\sigma$ denotes the activation layer.

Figure: Figure 2: Overview of the proposed dynamic diffusion transformer (DyDiT). It reduces the computational redundancy in DiT (Peebles & Xie, ) from both timestep and spatial dimensions.
Refer to caption: x2.png

#### Dynamic width control based on timestep.

To dynamically activate the heads and channel groups at each diffusion timestep, in each block, we feed the timestep embedding $\mathbf{E}_{t}\in\mathbb{R}^{C}$ into routers $\operatorname{R}_{\text{head}}$ and $\operatorname{R}_{\text{channel}}$ (Figure 2(a)). Each router comprises a linear layer followed by the Sigmoid function, producing the probability of each head and channel group to be activated:

$$ $\mathbf{S}_{\text{head}}=\operatorname{R}_{\text{head}}(\mathbf{E}_{t})\in[0,1 ]^{H},\quad\mathbf{S}_{\text{channel}}=\operatorname{R}_{\text{channel}}( \mathbf{E}_{t})\in[0,1]^{H}.$ (3) $$

A threshold of 0.5 is then used to convert the continuous-valued $\mathbf{S}_{\text{head}}$ and $\mathbf{S}_{\text{channel}}$ into binary masks $\mathbf{M}_{\text{head}}\!\in\!\{0,1\}^{H}$ and $\mathbf{M}_{\text{channel}}\!\in\!\{0,1\}^{H}$, indicating the activation decisions for attention heads and channel groups. The $h$-th head (group) is activated only when $\mathbf{M}_{\text{head}}^{h}\!=\!1$ ($\mathbf{M}_{\text{channel}}^{h}\!=\!1$).
Benefiting from the grouping operation, routers introduce negligible parameters and computation.

#### Inference.

After obtaining the discrete decisions $\mathbf{M}_{\text{head}}$ and $\mathbf{M}_{\text{channel}}$, each DyDiT block only computes the activated heads and channel groups during generation:

$$ $\displaystyle\text{MHSA}(\mathbf{X})$ $\displaystyle=\sum_{h:\mathbf{M}_{\text{head}}^{h}=1}\mathbf{X}_{\text{attn}}^ {h}\mathbf{W}_{\text{O}}^{h,:,:},$ (4) $\displaystyle\text{MLP}(\mathbf{X})$ $\displaystyle=\sum_{h:\mathbf{M}_{\text{channel}}^{h}=1}\sigma(\mathbf{X}_{ \text{hidden}}^{h})\mathbf{W}_{2}^{h,:,:}.$ $$

Let $\tilde{H}_{\text{head}}=\sum_{h}\mathbf{M}_{\text{head}}^{h}$ and $\tilde{H}_{\text{channel}}=\sum_{h}\mathbf{M}_{\text{channel}}^{h}$ denote the number of activated heads/groups. TWD reduces the MHSA computation from $\mathcal{O}(H\times(4NCC_{H}+2N^{2}C_{H}))$ to $\mathcal{O}(\tilde{H}_{\text{head}}\times(4NCC_{H}+2N^{2}C_{H}))$ and MLP blocks from $\mathcal{O}(H\times 2NCD_{H})$ to $\mathcal{O}(\tilde{H}_{\text{channel}}\times 2NCD_{H})$.
It is worth noting that as the activation choices depend solely on the timestep $\mathbf{E}_{t}$, we can pre-compute the masks offline once the training is completed, and *pre-define* the activated network architecture before deployment. This avoids the sample-dependent inference graph in traditional dynamic architectures (Meng et al., ; Han et al., ) and facilitates the realistic speedup in batched inference.

### 3.3 Spatial-wise Dynamic Token

In addition to the timestep dimension, the redundancy widely exists in the spatial dimension due to the varying complexity of different patches (Figure 1(b)). To this end, we propose a spatial-wise dynamic token (SDT) method to reduce computation for the patches where noise estimation is “easy”.

#### Bypassing the MLP block.

As shown in Figure 2 (b), SDT adaptively identifies the tokens associated with image regions that present lower noise prediction difficulty. These tokens are then allowed to bypass the computationally intensive MLP blocks. Theoretically, this block-bypassing operation can be applied to both MHSA and MLP. However, we find MHSA crucial for establishing token interactions, which is essential for the generation quality. More critically, varying token numbers across images in MHSA could result in incomplete tensor shapes in a batch, reducing the overall throughput in generation. Therefore, SDT is applied only in MLP blocks in each layer.

Concretely, before each MLP block, we feed the input $\mathbf{X}\!\in\!\mathbb{R}^{N\times C}$ into a token router $\operatorname{R}_{\text{token}}$, which predicts the probability $\mathbf{S}_{\text{token}}\in\mathbb{R}^{N}$ of each token to be processed. This can be formulated as:

$$ $\mathbf{S}_{\text{token}}=\operatorname{R}_{\text{token}}(\mathbf{X})\in[0,1]^ {N}.$ (5) $$

We then convert it into a binary mask $\mathbf{M}_{\text{token}}$ using a threshold of 0.5. Each element $\mathbf{M}^{i}_{\text{token}}\in\{0,1\}$ in the mask indicates whether the $i$-th token should be processed by the block (if $\mathbf{M}_{\text{token}}^{i}=1$) or directly bypassed (if $\mathbf{M}_{\text{token}}^{i}=0$). The router parameters are not shared across different layers.

#### Inference.

During inference (Figure 2(b)), we gather the tokens based on the mask $\mathbf{M}_{\text{token}}$ and feed them to the MLP, thereby avoiding unnecessary computational costs for other tokens. Then, we adopt a scatter operation to reposition the processed tokens. This further reduces the computational cost of the MLP block from $\mathcal{O}(\tilde{H}_{\text{channel}}N\times 2CD_{H})$ to $\mathcal{O}(\tilde{H}_{\text{channel}}\tilde{N}\times 2CD_{H})$, where $\tilde{N}=\sum_{i}\mathbf{M}_{\text{token}}^{i}$ denotes the actual number of tokens to be processed. Since there is no token interaction within the MLP, the SDT operation supports batched inference, improving the practical generation efficiency.

### 3.4 FLOPs-aware end-to-end Training

In the following, we first present the details of end-to-end training, followed by the loss design for controlling the computational complexity of DyDiT and techniques to stabilize fine-tuning.

#### End-to-end training.

During training, in TWD, we multiply $\mathbf{M}_{\text{head}}$ and $\mathbf{M}_{\text{channel}}$ with their corresponding features ($\mathbf{X}_{\text{attn}}$ and $\mathbf{X}_{\text{hidden}}$) to zero out the deactivated heads and channel groups, respectively. Similarly, in SDT, we multiply $\mathbf{M}_{\text{token}}$ with $\text{MLP}(\mathbf{X})$ to deactivate the tokens that should not be processed by MLP. Straight-through-estimator (Bengio et al., ) and Gumbel-Sigmoid (Meng et al., ) are employed to enable the end-to-end training of routers.

#### Training with FLOPs-constrained loss.

We design a FLOPs-constrained loss to control the computational cost during the generation process. We find it impractical to obtain the entire computation graph during $T$ timesteps since the total timestep $T$ is large *e.g*. $T=1000$. Fortunately, the timesteps in a batch are sampled from $t\sim\text{Uniform}(0,T)$ during training, which approximately covers the entire computation graph. Let $B$ denote the batch size, with $t_{b}$ as the timestep for the $b$-th sample, we compute the total FLOPs at the sampled timestep, $F^{t_{b}}_{\text{dynamic}}$, using masks $\{\mathbf{M}_{\text{head}}^{t_{b}},{\mathbf{M}}_{\text{channel}}^{t_{b}},
\mathbf{M}_{\text{token}}^{t_{b}}\}$ from each transformer layer, as detailed in Section 3.2 and Section 3.3. Let $F_{\text{static}}$ denote the total FLOPs of MHSA and MLP blocks in the static DiT. We formulate the FLOPs-constrained loss as:

$$ $\mathcal{L}_{\text{FLOPs}}=(\frac{1}{B}\sum_{t_{b}:b\in[1,B]}\frac{F^{t_{b}}_{ \text{dynamic}}}{F_{\text{static}}}-\lambda)^{2},$ (6) $$

where $\lambda$ is a hyperparameter representing the target FLOPs ratio, and $t_{b}$ is uniformly sampled from the interval $[0,T]$. The overall training objective combines this FLOPs-constrained loss with the original DiT training loss, expressed as $\mathcal{L}=\mathcal{L}_{\text{DiT}}+\mathcal{L}_{\text{FLOPs}}$.

#### Fine-tuning stabilization.

In practice, we find directly fine-tuning DyDiT with $\mathcal{L}$ might occasionally lead to unstable training. To address this, we employ two stabilization techniques. First, for a warm-up phase we maintain a complete DiT model supervised by the same diffusion target, introducing an additional item, $\mathcal{L}_{\text{DiT}}^{\text{complete}}$ along with $\mathcal{L}$. After this phase, we remove this item and continue training solely with $\mathcal{L}$. Additionally, prior to fine-tuning, we rank the heads and hidden channels in MHSA and MLP blocks based on a magnitude criterion (He et al., ). We consistently select the most important head and channel group in TDW. This ensures that at least one head and channel group is activated in each MHSA and MLP block across all timesteps, thereby alleviating the instability.

## 4 Experiments

#### Implementation details.

Our DyDiT can be built easily by fine-tuning on pre-trained DiT weights. We experiment on three different-sized DiT models denoted as DiT-S/B/XL. For DiT-XL, we directly adopt the checkpoint from the official DiT repository (Peebles & Xie, ), while for DiT-S and DiT-B, we use pre-trained models provided in Pan et al. ().
All experiments are conducted on a server with 8$\times$NVIDIA A800 80G GPUs. More details of model configurations and training setup can be found in Appendix A.1 and A.2, respectively.
Following DiT (Peebles & Xie, ), the strength of classifier-free guidance (Ho & Salimans, ) is set to 1.5 and 4.0 for evaluation and visualization, respectively. Unless otherwise specified, 250 DDPM (Ho et al., ) sampling steps are used. All speed tests are performed on an NVIDIA V100 32G GPU.

**Table 1: Comparison with state-of-the-art diffusion models on ImageNet 256$\times$256. DyDiT-XL achieves competitive performance while significantly reducing the computational cost.**
| Model | Params. (M) $\downarrow$ | FLOPs (G) $\downarrow$ | FID $\downarrow$ | sFID $\downarrow$ | IS $\uparrow$ | Precision $\uparrow$ | Recall $\uparrow$ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| *Static* |  |  |  |  |  |  |  |
| ADM | 608 | 1120 | 4.59 | 5.25 | 186.87 | 0.82 | 0.52 |
| LDM-4 | 400 | 104 | 3.95 | - | 178.22 | 0.81 | 0.55 |
| U-ViT-L/2 | 287 | 77 | 3.52 | - | - | - | - |
| U-ViT-H/2 | 501 | 113 | 2.29 | - | 247.67 | 0.87 | 0.48 |
| DiffuSSM-XL | 673 | 280 | 2.28 | 4.49 | 269.13 | 0.86 | 0.57 |
| DiM-L | 380 | 94 | 2.64 | - | - | - | - |
| DiM-H | 860 | 210 | 2.21 | - | - | - | - |
| DiT-L | 468 | 81 | 5.02 | - | 167.20 | 0.75 | 0.57 |
| DiT-XL | 675 | 118 | 2.27 | 4.60 | 277.00 | 0.83 | 0.57 |
| *Dynamic* |  |  |  |  |  |  |  |
| DyDiT-XLλ=0.7 | 678 | 84.33 | 2.12 | 4.61 | 284.31 | 0.81 | 0.60 |
| DyDiT-XLλ=0.5 | 678 | 57.88 | 2.07 | 4.56 | 248.03 | 0.80 | 0.61 |

#### Datasets.

Following the protocol in DiT (Peebles & Xie, ), we mainly conduct experiments on ImageNet (Deng et al., ) at a resolution of $256\times 256$. To comprehensively evaluate our method, we also assess performance and efficiency on four fine-grained datasets used by Xie et al. (): Food (Bossard et al., ), Artbench (Liao et al., ), Cars (Gebru et al., ) and Birds (Wah et al., ). We conduct experiments in both in-domain fine-tuning and cross-domain transfer learning manners on these dataset. Images of these datasets are also resized into 256$\times$256 resolution.

#### Metrics.

Following prior works (Peebles & Xie, ; Teng et al., ), we sample 50,000 images to measure the Fréchet Inception Distance (FID) (Heusel et al., ) score with the ADM’s TensorFlow evaluation suite (Dhariwal & Nichol, ). Inception Score (IS) (Salimans et al., ), sFID (Nash et al., ), and Prevision-Recall (Kynkäänniemi et al., ) are also reported for complementary. Bold font and underline denote the best and the second-best performance, respectively.

### 4.1 Comparison with State-of-the-Art Diffusion Models

In Table 1, we compare our method with other representative diffusion models, including ADM (Dhariwal & Nichol, ), LDM (Rombach et al., ), U-ViT (Bao et al., ), DiffuSSM (Yan et al., ), DiM (Teng et al., ), and DiT (Peebles & Xie, ), on $256\times 256$ ImageNet generation. All methods except ours adopt a static architecture. DyDiT-XL is fine-tuned with fewer than 3% additional iterations based on DiT to adapt the dynamic architecture, as detailed in Appendix A.1.

Notably, our model DyDiTλ=0.5 achieves a 2.07 FID score with less than 50% FLOPs of its counterpart, DiT-XL, and outperforms other models obviously. This verify that our method can effectively remove the redundant computation in DiT and maintain the generation performance. It accelerates the generation speed by $1.73\times$, which is detailed in Appendix B.1. Increasing the target FLOPs ratio $\lambda$ from 0.5 to 0.7 enables DyDiTλ=0.7 to achieve competitive performance with DiT-XL across most metrics and obtains the best IS score. This improvement is likely due to DyDiT’s dynamic architecture, which offers greater flexibility compared to static architectures, allowing the model to address each timestep and image patch specifically during the generation process. With around 80G FLOPs, our DyDiTλ=0.7 method significantly outperforms U-ViT-L/2 and DiT-L, further validing the advantages of our dynamic generation paradigm.

### 4.2 Comparison with Pruning Methods

#### Benchmarks.

The proposed timestep-wise dynamic width and spatial-wise dynamic token improve efficiency from the model *architecture* and *token* redundancy perspective, respectively. To evaluate the superiority of our approach, we compare our methods against representative static structure and token pruning techniques. More details of this experiment can be found in Appendix A.3.

*Pruning-based methods.* We include Diff pruning Fang et al. () in the comparison, which is a Taylor-based (Molchanov et al., ) pruning method specifically optimized for the diffusion process and has demonstrated superiority on diffusion models with U-Net (Ronneberger et al., ) architecture (Fang et al., ). Following Fang et al. (), we also include Random pruning, Magnitude pruning (He et al., ), and Taylor pruning (Molchanov et al., ) in the comparison. We adopt these four pruning approaches to distinguish important heads and channels in DiT from less significant ones, which can be removed to reduce the model width.

*Token merging.* We also compare our methods with a training-free token pruning technique, ToMe (Bolya et al., ), which progressively prunes tokens in each vision transformer (Dosovitskiy et al., ) layer through adaptive token merging. Its enhanced version (Bolya & Hoffman, ) can also accelerate diffusion models based on U-Net architectures *e.g*. Stable Diffusion Rombach et al. (). We directly apply the enhanced version in each layer of DiT.

Figure: Figure 3: FLOPs-FID trade-off for S, B, and XL size models on ImageNet. For clarity, we omit the results of applying ToMe to DiT-B and DiT-XL, as it does not surpass the random pruning.
Refer to caption: x3.png

#### Results.

We present the FLOPs-FID curves for S, B, and XL size models in Figure 3. Across differense sizes, DyDiT significantly outperforms all pruning methods with similar or even lower FLOPs, highlighting the superiority of dynamic architecture over static pruning in diffusion transformers.

Interestingly, Magnitude pruning shows slightly better performance among structural pruning techniques on DiT-S and DiT-B, while Diff pruning and Taylor pruning perform better on DiT-XL. This indicates that different-sized DiT prefer distinct pruning criteria. Although ToMe (Bolya & Hoffman, ) successfully accelerates U-Net models with acceptable performance loss, its application to DiT results in performance degradation, as also observed in Moon et al. (). We conjecture that the errors introduced by token merging become irrecoverable in DiT due to the absence of convolutional layers and long-range skip connections present in U-Net architectures.

#### Scaling up ability.

We can observe from Figure 3 that the performance gap between DyDiT and DiT diminishes as model size increases. Specifically, DyDiT-S achieves a comparable FID to the original DiT only at $\lambda=0.9$, while DyDiT-B achieves this with a lower FLOPs ratio, e.g., $\lambda=0.7$. When scaled to XL, DyDiT-XL attains a slightly better FID even at $\lambda=0.5$. This is due to increased computation redundancy with larger models, allowing our method to reduce redundancy without compromising FID. These results validate the scalability of our approach, which is crucial in the era of large models, encouraging further exploration of larger models in the future.

### 4.3 Results on fine-grained datasets

#### Quantitative results.

We further compare our method with structural pruning and token pruning approaches on fine-grained datasets under the in-domain fine-tuning setting, where the DiT is initially pre-trained on the corresponding dataset and subsequently fine-tuned on the same dataset for pruning or dynamic adaptation. Detailed experiment settings are presented in Appendix A.4. Results are summarized in Table LABEL:tab:fine_grained. With the pre-defined FLOPs ratio $\lambda=0.5$, our method significantly reduces computational cost and enhances generation speed while maintaining performance levels comparable to the original DiT. To ensure fair comparisons, we set width pruning ratios to 50% for pruning methods, aiming for similar FLOPs. Among structural pruning techniques, Magnitude pruning shows relatively better performance, yet DyDiT consistently outperforms it by a substantial margin. With a 20% merging ratio, ToMe also speeds up generation but sacrifices performance. As mentioned, the lack of convolutional layers and skip connections makes applying ToMe to DiT suboptimal.

**Table 2: Results on fine-grained datasets. The model marked with ${\dagger}$ corresponds to fine-tuning directly on the target dataset. See the main texts for details.**
| Model | s/image $\downarrow$ | FLOPs (G) $\downarrow$ | FID $\downarrow$ |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Food | Artbench | Cars | Birds | #Average |  |  |  |
| DiT-S | 0.65 | 6.07 | 14.56 | 17.54 | 9.30 | 7.69 | 12.27 |
| pruned w/ random | 0.38 | 3.05 | 45.66 | 76.75 | 60.26 | 48.60 | 57.81 |
| pruned w/ magnitude | 0.38 | 3.05 | 41.93 | 42.04 | 31.49 | 26.45 | 35.44 |
| pruned w/ taylor | 0.38 | 3.05 | 47.26 | 74.21 | 27.19 | 22.33 | 42.74 |
| pruned w/ diff | 0.38 | 3.05 | 36.93 | 68.18 | 26.23 | 23.05 | 38.59 |
| pruned w/ ToMe 20% | 0.61 | 4.82 | 43.87 | 62.96 | 32.16 | 15.20 | 38.54 |
| DyDiT-Sλ=0.5 | 0.41 | 3.16 | 16.74 | 21.35 | 10.01 | 7.85 | 13.98 |
| DyDiT-S${}_{\lambda=0.5}{\dagger}$ | 0.41 | 3.17 | 13.03 | 19.47 | 12.15 | 8.01 | 13.16 |

#### Qualitative visualization.

Figure 4 presents images generated by DyDiT-S on fine-grained datasets, compared to those produced by the original or pruned DiT-S. These qualitative results demonstrate that our method maintains the FID score while producing images of quality comparable to DiT-S.

#### Cross-domain transfer learning.

Transferring to downstream datasets is a common practice to leverage pre-trained generations models. In this experiment, we fine-tune a model pre-trained on ImageNet to perform cross-domain adaptation on the target dataset while concurrently learning the dynamic architecture, yielding DyDiT-S${}_{\lambda=0.5}{\dagger}$ in Table LABEL:tab:fine_grained. More details are presented in Appendix A.5. We can observe that learning the dynamic architecture during the cross domain transfer learning does not hurt the performance, and even leads to slight better average FID score than DyDiT-Sλ=0.5. This further broadens the application scope of our method.

Figure: Figure 4: Qualitative comparison of images generated by the original DiT, DiT pruned with magnitude, and DyDiT. All models are of “S” size. The FLOPs ratio $\lambda$ in DyDiT is set to 0.5.
Refer to caption: x6.png

### 4.4 Ablation Study

#### Main components.

We first conduct experiments to verify the effectiveness of each component in our method. We summarize the results in Table 3. “I” and “II” denote DiT with only the proposed timstep-wise dynamic width (TDW) and spatial-wise dynamic token (SDT), respectively. We can find that “I” performs much better than “II”. This is attributed to the fact that, with the target FLOPs ratio $\lambda$ set to 0.5, most tokens in “II” have to bypass MLP blocks, leaving only MHSA blocks to process tokens, significantly affecting performance (Dong et al., ). “III” represents the default model that combines both TDW and SDT, achieving obviously better performance than “I” and “II”. Given a computational budget, the combination of TDW and SDT allows the model to discover computational redundancy from both the time-step and spatial perspectives.

#### Importance of routers in temporal-wise dynamic width.

Routers in TDW adaptively adjust the model width for each block across all timesteps.
Replacing the learnable router with a random selection, resulting in “I (random)”, leads to model collapse across all datasets. This is due to the random activation of heads and channel groups, which hinders the model’s ability to generate high-quality images. We also experiment a manually-designed strategy, termed “I (manual)”, in which we activate $5/6$, $1/2$, $1/3$, $1/3$ of the heads and channels for the intervals [0, $1/T$], [$1/T$, $2/T$], [$2/T$, $3/4T$], and [$3/4T$, $T$] timesteps, respectively. This results in around 50% average FLOPs reduction. Since this strategy aligns the observation in Figure 1(a) and allocates more computation to timesteps approaching 0, “I (manual)” outperforms “I (random)” obviously. However, it does not surpass “I”, highlighting the importance of learned routers.

#### Importance of token-level bypassing in spatial-wise dynamic token.

We also explore an alternative design to conduct token bypassing. Specifically, each MLP block adopts a router to determine whether all tokens of an image should bypass the block. This modification causes SDT to become a layer-skipping approach (Wang et al., ). We replace SDT in “III” with this design, resulting in “III (layer-skip)” in Table 3. As outlined in Section 1, varying regions of an image face distinct challenges in noise prediction. A uniform token processing strategy fails to address this heterogeneity effectively. For example, tokens from complex regions might bypass essential blocks, resulting in suboptimal noise prediction. The results presented in Table 3 further confirm that the token-level bypassing in SDT, obviously improves the performance of “III” compared to “III (layer-skip)”.

**Table 3: Ablation Study on DyDiT-Sλ=0.5. All models evoke around 3.16 GFLOPs.**
| Model | TDW | SDT | FID $\downarrow$ |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ImageNet | Food | Artbench | Cars | Birds | #Average |  |  |  |
| I | ✓ |  | 31.89 | 15.71 | 28.19 | 19.67 | 9.23 | 20.93 |
| II |  | ✓ | 70.06 | 23.79 | 52.78 | 16.90 | 12.05 | 35.12 |
| III | ✓ | ✓ | 28.75 | 16.74 | 21.35 | 10.01 | 7.85 | 16.94 |
| I (random) |  |  | 124.38 | 111.88 | 151.99 | 127.53 | 164.29 | 136.01 |
| I (manual) |  |  | 34.08 | 23.89 | 40.02 | 22.34 | 20.17 | 28.10 |
| III (layer-skip) | ✓ |  | 30.95 | 17.75 | 23.15 | 10.53 | 9.01 | 18.29 |

Figure: Figure 5: Visualization of dynamic architecture. and indicates the deactivated and activated heads in an MHSA block, while and denotes that the channel group is deactivated or activated in an MLP block, respectively. We conduct 250-step DDPM generation.
Refer to caption: x7.png

### 4.5 Visualization

#### Learned timestep-wise dynamic strategy.

Figure 5 illustrates the activation patterns of heads and channel groups during the 250-step DDPM generation process. Throughout this process, TWD progressively activates more MHSA heads and MLP channel groups as it transitions from noise to image. As discussed in Section 1, prediction is more straightforward when generation is closer to noise (larger $t$) and becomes increasingly challenging as it approaches the image (smaller $t$). Our visualization corroborates this observation, demonstrating that the model allocates more computational resources to more complex timesteps. Notably, the activation rate of MLP blocks surpasses that of MHSA blocks at $t=255$ and $t=100$. This can be attributed to the token bypass operation in the spatial-wise dynamic token (SDT), which reduces the computational load of MLP blocks, enabling TWD to activate additional channel groups with minimal computational overhead.

#### Spatial-wise dynamic token adapts computational cost on each image patch.

We quantify and normalize the computational cost on different image patches during generation, ranging from [0, 1] in Figure 6. These results verify that our SDT effectively learns to adjust computational expenditure based on the complexity of image patches. SDT prioritizes challenging patches containing detailed and colorful main objects. Conversely, it allocates less computation to background regions characterized by uniform and continuous colors. This behavior aligns with our findings in Figure 1(b).

Figure: Figure 6: Computational cost across different image patches. We quantify the FLOPs cost on image patches over the generation process and normalize them into [0, 1] for better clarity.
Refer to caption: x8.png

### 4.6 Compatibility with Other Efficient Diffusion Approaches

#### Combination with efficient samplers.

Our DyDiT is a general architecture which can be seamlessly incorporated with efficient samplers such as DDIM (Song et al., ) and DPM-solver++ (Lu et al., ). As presented in Table 4, when using the 50-step DDIM, both DiT-XL and DyDiT-XL exhibit significantly faster generation, while our method consistently achieving higher efficiency due to its dynamic computation paradigm. When we further reduce the sampling step to 20 and 10 with DPM-solver++, we observe an FID increasement on all models, while our method still achieves competitive performance compared to the original DiT. These findings highlight the potential of integrating our approach with efficient samplers, suggesting a promising avenue for future research.

**Table 4: Combination with efficient samplers (Song et al., ; Lu et al., ).**
| Model | 250-DDPM | 50-DDIM | 20-DPM-solver++ | 10-DPM-solver++ |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| s/image $\downarrow$ | FID $\downarrow$ | s/image $\downarrow$ | FID $\downarrow$ | s/image $\downarrow$ | FID $\downarrow$ | s/image $\downarrow$ | FID $\downarrow$ |  |
| DiT-XL | 10.22 | 2.27 | 2.00 | 2.26 | 0.84 | 4.62 | 0.42 | 11.66 |
| DyDiT-XLλ=0.7 | 7.76 | 2.12 | 1.56 | 2.16 | 0.62 | 4.28 | 0.31 | 11.10 |
| DyDiT-XLλ=0.5 | 5.91 | 2.07 | 1.17 | 2.36 | 0.46 | 4.22 | 0.23 | 11.31 |

**Table 5: Combination with global acceleration. “interval” denotes the interval of cached timestep in DeepCache (Ma et al., ).**
| Model | interval | s/image $\downarrow$ | FID $\downarrow$ |
| --- | --- | --- | --- |
| DiT-XL | 0 | 10.22 | 2.27 |
| DiT-XL | 2 | 5.02 | 2.47 |
| DiT-XL | 5 | 2.03 | 6.73 |
| DyDiT-XLλ=0.5 | 0 | 5.91 | 2.07 |
| DyDiT-XLλ=0.5 | 2 | 2.99 | 2.43 |
| DyDiT-XLλ=0.5 | 3 | 2.01 | 3.37 |

#### Combination with global acceleration.

DeepCache (Ma et al., ) is a train-free technique which globally accelerates generation by caching feature maps at specific timesteps and reusing them in subsequent timesteps. As shown in Table 5, with a cache interval of 2, DyDiT achieves further acceleration with only a marginal performance drop. In contrast, DiT with DeepCache requires a longer interval (*e.g*. 5) to achieve comparable speed with ours, resulting in an inferior FID score.
These results demonstrate the compatibility and effectiveness of our approach in conjunction with DeepCache.

## 5 Discussion and Conclusion

In this study, we investigate the training process of the Diffusion Transformer (DiT) and identify significant computational redundancy associated with specific diffusion timesteps and image patches. To this end, we propose Dynamic Diffusion Transformer (DyDiT), an architecture that can adaptively adjust the computation allocation across different timesteps and spatial regions. Comprehensive experiments on various datasets and model sizes validate the effectiveness of DyDiT. We anticipate that the proposed method will advance the development of transformer-based diffusion models.

#### Limitations and future works.

Similarly to DiT, the proposed DyDiT is currently focusing on image generation. In future works, DyDiT could be further explored to be applied to other tasks, such as video generation  (Ma et al., ) and controllable generation (Chen et al., ).

## Appendix A Experimental Settings.

### A.1 Training details of DyDiT on ImageNet

In Table 6, we present the training details of our model on ImageNet. For DiT-XL, which is pre-trained over 7,000,000 iterations, only 200,000 additional fine-tuning iterations (around 3%) are needed to enable the dynamic architecture ($\lambda=0.5$) with our method. For a higher target FLOPs ratio $\lambda=0.7$, the iterations can be further reduced.

Table: Table 6: Experimental settings of our adaption framework.

### A.2 Details of DiT and DyDiT models

We present the configuration details of the DiT and DyDiT models in Table 7. For DiT-XL, we use the checkpoint from the official DiT repository(^*^**[https://github.com/facebookresearch/DiT](https://github.com/facebookresearch/DiT)) Pan et al. (). For DiT-S and DiT-B, we leverage pre-trained models from a third-party repository(^†^††[https://github.com/NVlabs/T-Stitch](https://github.com/NVlabs/T-Stitch)) provided by Pan et al. ().

**Table 7: Details of DiT and DyDiT models. The router in DyDiT introduce a small number of parameters. ${\dagger}$ denotes that the architecture is dynamically adjusted during generation.**
| model | params. (M) $\downarrow$ | layers | heads | channel | pre-training | source |
| --- | --- | --- | --- | --- | --- | --- |
| DiT-S | 33 | 12 | 6 | 384 | 5M iter | Pan et al. () |
| DiT-B | 130 | 12 | 12 | 768 | 1.6M iter | Pan et al. () |
| DiT-XL | 675 | 28 | 16 | 1152 | 7M iter | Peebles & Xie () |
| DyDiT-S | 33 | 12 | 6 ${\dagger}$ | 384 ${\dagger}$ | - | - |
| DyDiT-B | 131 | 12 | 12 ${\dagger}$ | 768 ${\dagger}$ | - | - |
| DyDiT-XL | 678 | 28 | 16 ${\dagger}$ | 1152 ${\dagger}$ | - | - |

### A.3 Comparison with pruning methods on ImageNet.

We compare our method with structure pruning and token pruning methods on ImageNet dataset.

- •
Random pruning, Magnitude Pruning (He et al., ), Taylor Pruning (Molchanov et al., ), and Diff Pruning (Fang et al., ): We adopt the corresponding pruning strategy to rank the importance of heads in multi-head self-attention blocks and channels in MLP blocks. Then, we prune the least important 50% of heads and channels. The pruned model is then fine-tuned for the same number of iterations as its DyDiT counterparts.
- •
ToMe (Bolya & Hoffman, ): Originally designed to accelerate transformer blocks in the U-Net architecture, ToMe operates by merging tokens before the attention block and then unmerging them after the MLP blocks. We set the token merging ratio to 20% in each block.

### A.4 In-domain fine-tuning on fine-trained datasets.

We first fine-tune a DiT-S model, which is initialized with parameters pre-trained on ImageNet, on a fine-grained dataset. Following the approach in (Xie et al., ), we set the training iteration to 24,000. Then, we further fine-tune the model on the same dataset by another 24,000 iterations to adapt the pruning or dynamic architecture to improve the efficiency of the model on the same dataset. We also conduct the generation at a resolution off $224\times 224$. We search optimal classifier-free guidance weights for these methods.

- •
Random pruning, Magnitude Pruning (He et al., ), Taylor Pruning (Molchanov et al., ), and Diff Pruning (Fang et al., ): For each method, we rank the importance of heads in multi-head self-attention blocks and channels in MLP blocks, pruning the least important 50%.
- •
ToMe (Bolya & Hoffman, ): Originally designed to accelerate transformer blocks in the U-Net architecture, ToMe operates by merging tokens before the attention block and then unmerging them after the MLP blocks. We set the token merging ratio to 20% in each block.

### A.5 Cross-domain transfer learning

In contrast to the aforementioned in-domain fine-tuning, which learns the dynamic strategy within the same dataset, this experiment employs cross-domain fine-tuning. We fine-tune a DiT-S model (pre-trained exclusively on ImageNet) to adapt to the target dataset while simultaneously learning the dynamic architecture. The model is fine-tuned over 48,000 iterations with a batch size of 256.

## Appendix B Additional Results

### B.1 Inference acceleration.

In Table 8, we present the acceleration ratio of DyDiT compared to the original DiT across different FLOPs targets $\lambda$. The results demonstrate that our method effectively enhances batched inference speed, distinguishing our approach from traditional dynamic networks (Herrmann et al., ; Meng et al., ; Han et al., ), which adapt inference graphs on a per-sample basis and struggle to improve practical efficiency in batched inference.

**Table 8: We conduct batched inference on an NVIDIA V100 32G GPU using the optimal batch size for each model. The actual FLOPs of DyDiT may fluctuate around the target FLOPs ratio.**
| model | s/image $\downarrow$ | acceleration $\uparrow$ | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- | --- |
| DiT-S | 0.65 | 1.00 $\times$ | 6.07 | 21.46 | +0.00 |
| DyDiT-Sλ=0.9 | 0.63 | 1.03 $\times$ | 5.72 | 21.06 | -0.40 |
| DyDiT-Sλ=0.8 | 0.56 | 1.16 $\times$ | 4.94 | 21.95 | +0.49 |
| DyDiT-Sλ=0.7 | 0.51 | 1.27 $\times$ | 4.34 | 23.01 | +1.55 |
| DyDiT-Sλ=0.5 | 0.42 | 1.54 $\times$ | 3.16 | 28.75 | +7.29 |
| DyDiT-Sλ=0.4 | 0.38 | 1.71 $\times$ | 2.63 | 36.21 | +14.75 |
| DyDiT-Sλ=0.3 | 0.32 | 2.03 $\times$ | 1.96 | 59.28 | +37.83 |
| DiT-B | 2.09 | 1.00 $\times$ | 23.02 | 9.07 | +0.00 |
| DyDiT-Bλ=0.9 | 1.97 | 1.05 $\times$ | 21.28 | 8.78 | -0.29 |
| DyDiT-Bλ=0.8 | 1.76 | 1.18 $\times$ | 18.53 | 8.79 | -0.28 |
| DyDiT-Bλ=0.7 | 1.57 | 1.32 $\times$ | 16.28 | 9.40 | +0.33 |
| DyDiT-Bλ=0.5 | 1.22 | 1.70 $\times$ | 11.90 | 12.92 | +3.85 |
| DyDiT-Bλ=0.4 | 1.06 | 1.95 $\times$ | 9.71 | 15.54 | +6.47 |
| DyDiT-Bλ=0.3 | 0.89 | 2.33 $\times$ | 7.51 | 23.34 | +14.27 |
| DiT-XL | 10.22 | 1.00 $\times$ | 118.69 | 2.27 | +0.00 |
| DyDiT-XLλ=0.7 | 7.76 | 1.32 $\times$ | 84.33 | 2.12 | -0.15 |
| DyDiT-XLλ=0.6 | 6.86 | 1.49 $\times$ | 67.83 | 2.18 | -0.09 |
| DyDiT-XLλ=0.5 | 5.91 | 1.73 $\times$ | 57.88 | 2.07 | -0.20 |
| DyDiT-XLλ=0.3 | 4.26 | 2.40 $\times$ | 38.85 | 3.36 | +1.09 |

### B.2 Effectiveness on U-ViT.

We evaluate the architecture generalization capability of our method through experiments on U-ViT (Bao et al., ), a transformer-based diffusion model with skip connections similar to U-Net (Ronneberger et al., ). The results, shown in Table 9, indicate that configuring the target FLOPs ratio $\lambda$ to 0.4 and adapting U-ViT-S/2 to our dynamic architecture (denoted as DyUViT-S/2 λ=0.4) reduces computational cost from 11.34 GFLOPs to 4.73 GFLOPs, while maintaining a comparable FID score. We also compare our method with the structure pruning method Diff Pruning (Fang et al., ) and sparse pruning methods ASP (Pool & Yu, ; Mishra et al., ) and SparseDM (Wang et al., ). The results verify the superiority of our dynamic architecture over static pruning.

In Table 10, we apply our method to the largest model, U-ViT-H/2, and conduct experiments on ImageNet. The results demonstrate that our method effectively accelerates U-ViT-H/2 with only a marginal performance drop. These results verify the generalizability of our method in U-ViT.

**Table 9: U-ViT (Bao et al., ) performs image generation on the CIFAR-10 dataset (Krizhevsky et al., ). Aligning with its default configuration, we generate images using 1,000 diffusion steps with the Euler-Maruyama SDE sampler (Song et al., ).**
| model | s/image $\downarrow$ | acceleration $\uparrow$ | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- | --- |
| U-ViT-S/2 | 2.19 | 1.00 $\times$ | 11.34 | 3.12 | 0.00 |
| DyU-ViT-S/2λ=0.4 | 1.04 | 2.10 $\times$ | 4.73 | 3.18 | +0.06 |
| pruned w/ Diff | - | - | 5.32 | 12.63 | +9.51 |
| pruned w/ ASP | - | - | 5.76 | 319.87 | +316.75 |
| pruned w/ SparseDM | - | - | 5.67 | 4.23 | +1.11 |

**Table 10: U-ViT (Bao et al., ) performs image generation on the ImageNet (Deng et al., ). Aligning with its default configuration, we generate images using 50-step DPM-solver++(Lu et al., ).**
| model | s/image $\downarrow$ | acceleration $\uparrow$ | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- | --- |
| U-ViT-H/2 | 2.22 | 1.00 $\times$ | 113.00 | 2.29 | 0.00 |
| DyU-ViT-H/2λ=0.5 | 1.35 | 1.57 $\times$ | 67.09 | 2.42 | +0.13 |

### B.3 Further fine-tune original DiT on ImageNet.

our method is not attributed to additional fine-tuning. In Table 11, we fine-tune the original DiT for 150,000 and 350,000 iterations, observing a slight improvement in the FID score, which fluctuates around 2.16. Under the same iterations, DyDiT achieves a better FID while significantly reducing FLOPs, verifying that the improvement is due to our design rather than extended training iterations.

**Table 11: Further fine-tuneing original DiT on ImageNet.**
| model | pre-trained iterations | fine-tuning iterations | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- | --- |
| DiT-XL | 7,000,000 | - | 118.69 | 2.27 | +0.00 |
| DiT-XL | 7,000,000 | 150,000 (2.14%) | 118.69 | 2.16 | -0.11 |
| DiT-XL | 7,000,000 | 350,000 (5.00%) | 118.69 | 2.15 | -0.12 |
| DyDiT-XLλ=0.7 | 7,000,000 | 150,000 (2.14%) | 84.33 | 2.12 | -0.15 |

### B.4 Effectiveness in High-resolution Generation.

We conduct experiments to generate images at a resolution of 512$\times$512 to validate the effectiveness of our method for high-resolution generation. We use the official checkpoint of DiT-XL 512$\times$512 as the baseline, which is trained on ImageNet (Deng et al., ) for 3,000,000 iterations. We fine-tune it for 150,000 iterations to enable its dynamic architecture, denoted as DyDiT-XL 512$\times$512. The target FLOP ratio is set to 0.7. The experimental results, presented in Table 12, demonstrate that our method achieves a superior FID score compared to the original DiT-XL, while requiring fewer FLOPs.

**Table 12: Image generation at 512$\times$512 resolution on ImageNet (Deng et al., ). We sample 50,000 images and leverage FID to measure the generation quality. We adopt 100 DDPM steps to generate images.**
| model | s/image $\downarrow$ | acceleration $\uparrow$ | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- | --- |
| DiT-XL 512$\times$512 | 18.36 | 1.00$\times$ | 514.80 | 3.75 | 0.00 |
| DyDiT-XL 512$\times$512 λ=0.7 | 14.00 | 1.31$\times$ | 375.35 | 3.61 | -0.14 |

### B.5 Effectiveness in Text-to-Image Generation.

We further validate the applicability of our method in text-to-image generation, which is more challenging than the class-to-image generation. We adopt PixArt-$\alpha$ (Chen et al., ), a text-to-image generation model built based on DiT (Peebles & Xie, ) as the baseline. PixArt-$\alpha$ is pre-trained on extensive private datasets and exhibits superior text-to-image generation capabilities.
Our model is initialized using the official PixArt-$\alpha$ checkpoint fine-tuned on the COCO dataset (Lin et al., ). We further fine-tune it with our method to enable dynamic architecture adaptation, resulting in the DyPixArt-$\alpha$ model, as shown in Table 13. Notably, DyPixArt-$\alpha$ with $\lambda=0.7$ achieves an FID score comparable to the original PixArt-$\alpha$, while significantly accelerating the generation.

**Table 13: Text-to-image generation on COCO (Lin et al., ). We randomly select text prompts from COCO and adopt 20-step DPM-solver++ (Lu et al., ) to sample 30,000 images for evaluating the FID score.**
| Model | s/image $\downarrow$ | acceleration $\uparrow$ | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- | --- |
| PixArt-$\alpha$ | 0.91 | 1.00 $\times$ | 141.09 | 19.88 | +0.00 |
| DyPixArt-$\alpha$λ=0.7 | 0.69 | 1.32 $\times$ | 112.44 | 19.75 | -0.13 |

### B.6 Exploration of Combining LCM with DyDiT .

Some sampler-based efficient methods (Meng et al., ; Song et al., ; Luo et al., ) adopt distillation techniques to reduce the generation process to several steps. In this section, we combine our DyDiT, a model-based method, with a representative method, the latent consistency model (LCM) (Luo et al., ) to explore their compatibility for superior generation speed. In LCM, the generation process can be reduced to 1-4 steps via consistency distillation and the 4-step generation achieves an satisfactory balance between performance and efficiency. Hence, we conduct experiments in the 4-step setting. Under the target FLOPs ratio $\lambda=0.9$, our method further accelerates generation and achieves comparable performance, demonstrating its potential with LCM. However, further reducing the FLOPs ratio leads to model collapse. This issue may arise because DyDiT’s training depends on noise prediction difficulty, which is absent in LCM distillation, causing instability at lower FLOPs ratios. This encourage us to develop dynamic models and training strategies for distillation-based efficient samplers to achieve superior generation efficiency in the future.

**Table 14: Combining DyDiT with Latent Consistency Model (LCM) (Luo et al., ) . We conduct experiments under the 4-step LCM setting, as it achieves a satisfactory balance between performance and efficiency.**
| model | s/image $\downarrow$ | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- |
| DiT-XL+250-step DDPM | 10.22 | 118.69 | 2.27 | +0.00 |
| DiT-XL + 4-step LCM | 0.082 | 118.69 | 6.53 | +4.26 |
| DyDiT-XLλ=0.9 + 4-step LCM | 0.076 | 104.43 | 6.52 | +4.25 |

### B.7 Comparison with the Early Exiting Method.

We compare our approach with the early exiting diffusion model ASE (Moon et al., ; ), which implements a strategy to selectively skip layers for certain timesteps. Following their methodology, we evaluate the FID score using 5,000 samples. Results are summarized in Table 15. Despite similar generation performance, our method achieves a better acceleration ratio, demonstrating the effectiveness of our design.

**Table 15: Comparison with the early exiting method (Moon et al., ; ). As methods may be evaluated on different devices, we report only the acceleration ratio for speed comparison.**
| model | acceleration $\uparrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- |
| DiT-XL | 1.00 $\times$ | 9.08 | 0.00 |
| DyDiT-XLλ=0.5 | 1.73 $\times$ | 8.95 | -0.13 |
| ASE-D4 DiT-XL | 1.34 $\times$ | 9.09 | +0.01 |
| ASE-D7 DiT-XL | 1.39 $\times$ | 9.39 | +0.31 |

### B.8 Training efficiency

Our approach enhances the inference efficiency of the diffusion transformer while maintaining training efficiency. It requires only a small number of additional fine-tuning iterations to learn the dynamic architecture. In Table 16, we present our model with various fine-tuning iterations and their corresponding FID scores. The original DiT-XL model is pre-trained on the ImageNet dataset over 7,000,000 iterations with a batch size of 256. Remarkably, our method achieves a 2.12 FID score with just 50,000 fine-tuning iterations to adopt the dynamic architecture-approximately 0.7% of the pre-training schedule. Furthermore, when extended to 100,000 and 150,000 iterations, our method performs comparably to DiT. We observe that the actual FLOPs during generation converge as the number of fine-tuning iterations increases.

**Table 16: Training efficiency. The original DiT-XL model is pre-trained on the ImageNet dataset over 7,000,000 iterations with a batch size of 256.**
| model | fine-tuning iterations | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- |
| DiT-XL | - | 118.69 | 2.27 | +0.00 |
| DyDiT-XLλ=0.7 | 10,000 (0.14%) | 103.08 | 45.95 | 43.65 |
| DyDiT-XLλ=0.7 | 25,000 (0.35%) | 91.97 | 2.97 | +0.70 |
| DyDiT-XLλ=0.7 | 50,000 (0.71%) | 85.07 | 2.12 | -0.15 |
| DyDiT-XLλ=0.7 | 100,000 (1.43%) | 84.30 | 2.17 | -0.10 |
| DyDiT-XLλ=0.7 | 150,000 (2.14%) | 84.33 | 2.12 | -0.15 |

### B.9 Data efficiency

To evaluate the data efficiency of our method, we randomly sampled 10% of the ImageNet dataset (Deng et al., ) for training. DyDiT was fine-tuned on this subset to adapt the dynamic architecture. As shown in Table 17, when fine-tuned on just 10% of the data, our model DyDiT-XLλ=0.7 still achieves performance comparable to the original DiT. When we further reduce the fine-tuning data ratio to 1%, the FID score increase slightly by 0.06. These results indicate that our method maintains robust performance even with limited fine-tuning data.

**Table 17: Data efficiency. The slight difference in FLOPs of our models is introduced by the learned TDW and SDT upon fine-tuning convergence.**
| model | fine-tuning data ratio | FLOPs (G) $\downarrow$ | FID $\downarrow$ | FID $\Delta\downarrow$ |
| --- | --- | --- | --- | --- |
| DiT-XL | - | 118.69 | 2.27 | +0.00 |
| DyDiT-XLλ=0.7 | 100% | 84.33 | 2.12 | -0.15 |
| DyDiT-XLλ=0.7 | 10% | 84.43 | 2.13 | -0.14 |
| DyDiT-XLλ=0.7 | 1% | 84.37 | 2.31 | +0.06 |

## Appendix C Visualization

### C.1 Additional Visualization of Loss Maps

In Figure 7, we visualize the loss maps (normalized to the range [0, 1]) for several timesteps, demonstrating that noise in different image patches exhibits varying levels of prediction difficulty.

### C.2 Additional Visualization of Computational Cost on Image Patches

In Figure 8, we quantify and normalize the computational cost across different image patches during generation, ranging from [0, 1]. The proposed spatial-wise dynamic token strategy learns to adjust the computational cost for each image patch.

### C.3 Visualization of samples from DyDiT-XL

We visualize the images generated by DyDiT-XLλ=0.5 on the ImageNet (Deng et al., ) dataset at a resolution of $256\times 256$ from Figure 10 to Figure 22. The classifier-free guidance scale is set to 4.0. All samples here are uncurated.

Figure: Figure 7: Additional visualization of loss maps from DiT-XL. The loss values are normalized to the range [0, 1]. Different image patches exhibit varying levels of prediction difficulty.
Refer to caption: x9.png

Figure: Figure 8: Additional visualizations of computational cost across different image patches. Complementary to Figure 6, we visualize more generated images and their corresponding FLOPs cost across different image patches. The map is normalized to [0, 1] for clarity.
Refer to caption: x10.png

Figure: Figure 9: Uncurated 256$\times$256 DyDiT-XLλ=0.5 samples. Loggerhead turtle (33).
Refer to caption: x11.png

Figure: Figure 11: Uncurated 256$\times$256 DyDiT-XLλ=0.5 samples. Kakatoe galerita (89).
Refer to caption: x13.png

Figure: Figure 13: Uncurated 256$\times$256 DyDiT-XLλ=0.5 samples. Siberian husky (250).
Refer to caption: x15.png

Figure: Figure 15: Uncurated 256$\times$256 DyDiT-XLλ=0.5 samples. Lesser panda(387).
Refer to caption: x17.png

Figure: Figure 17: Uncurated 256$\times$256 DyDiT-XLλ=0.5 samples. Dogsled (537).
Refer to caption: x19.png

Figure: Figure 19: Uncurated 256$\times$256 DyDiT-XLλ=0.5 samples. Ice cream (928).
Refer to caption: x21.png

Figure: Figure 21: Uncurated 256$\times$256 DyDiT-XLλ=0.5 samples. Lakeside (975).
Refer to caption: x23.png

## Peer Reviews

confidence: 5
contribution: 3
initial_rating: 3
presentation: 3
questions: Please refer to the weaknesses.
soundness: 3
strengths: - The motivation is sound and clearly presented, supported by a well-designed teaser figure.
- The proposed TDW and SDT mechanisms enable dynamic adjustment of model modules, and the FLOPs-constrained loss effectively -controls the desired FLOPs of the final model.
- Extensive experiments and thorough ablation studies validate the module's effectiveness.
summary: This paper introduces the Dynamic Diffusion Transformer (DyDiT), an architecture that dynamically allocates FLOPs to the most demanding areas based on varying timesteps and spatial locations. The paper begins by analyzing computational cost requirements across temporal and spatial dimensions, suggesting that a fixed architecture may be unnecessary during the sampling stage. To address this, it proposes the Timestep-wise Dynamic Width (TDW) mechanism and the Spatial-wise Dynamic Token (SDT) strategy, which can be seamlessly integrated with the attention and MLP blocks in a diffusion model. DyDiT initializes from pre-trained model weights and employs routers to dynamically determine which attention heads, groups, and spatial tokens to process. Extensive experiments demonstrate that DyDiT achieves comparable results to pre-trained diffusion models while adhering to predefined FLOP constraints.
weaknesses: - It is unclear how the "pre-define" in L214 benefit the sampling stage? I understand that the activation of attention heads and groups is based solely on timesteps, allowing the masks to be precomputed once training is completed. However, tt seems impractical or inefficient to store all possible pre-defined structures, so it primarily saves computational costs on the attention routers. However, this cost doesn’t seem substantial—am I correct?
- The adaptation of the proposed modules to efficient samplers or to samplers with varying sampling steps remains unclear. Since the activation mask depends solely on the timestep t, different samplers using step t could yield the same activation mask, even though 
t might represent different stages of denoising (e.g., one sampler is at the beginning of denoising, while another is close to full denoising). I'm wondering the activation masks should be very different under this scenario right (just as shown in Fig. 5)?

---

confidence: 4
contribution: 3
initial_rating: 8
presentation: 3
questions: please refer to the weakness.
soundness: 3
strengths: - This paper is easy to follow.
- The authors conduct sufficient ablation studies to evaluate the proposed modules.
- The authors conduct experiments on a wide range of datasets, including ImageNet, Food, Artbench, Cars, and Birds, and compare a lot of state-of-the-art diffusion backbones. The results show the effectiveness of the proposed method.
- The authors also perform experiments on text-to-image generation, demonstrating the plug-and-play nature of SDT and TDW.
summary: The paper introduces a new efficient architecture, Dynamic Diffusion Transformer (DyDiT), for diffusion-based image generation. The authors observe the redundancy of DiTs in processing small timesteps and unnecessary spatial regions. Accordingly, they propose two main modifications: the timestep-wise Dynamic Width (TDW) and the spatial-wise Dynamic Token (SDT). These two modules dynamically allocate proper computational resources for different timesteps and spatial regions. The method significantly reduces FLOPs and accelerates generation without sacrificing visual quality.
weaknesses: - The authors demonstrate the results of their method on PixArt-$\alpha$, which is commendable. However, the acceleration achieved in this text-to-image model is inferior to that in class-to-image generation. A more in-depth analysis of this discrepancy would be valuable. Moreover, providing image samples generated by the accelerated text-to-image model could be helpful for the analysis.

- Providing the image samples generated by the diffusion models accelerated with **different** $\mathbf{\lambda}~$**s** could help understand the FLOPs-Quality trade-offs of the proposed method.

- In Figure 5, the first head is always activated across different timesteps. Is this head manually set or just a result of the learned strategy?

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: Please see the weakness section for details.

Also, i suggest the author provides more implementation details, including training precision. For instance, Fast-DiT [4] has achieved a 95% increase in speed.

[4] https://github.com/chuanyangjin/fast-DiT
soundness: 2
strengths: - The proposed approach reduces GFLOPs by 51% and achieves a 1.73x speed-up during training.
- Detailed ablation studies are presented to demonstrate the contribution of each component to overall performance.
summary: - This paper proposes the Dynamic Diffusion Transformer, a model that dynamically adjusts both timesteps and spatial dimensions during the generation process to reduce computational costs. 
- In the temporal dimension, the model width is adaptively scaled; 
- in the spatial dimension, a dynamic token strategy with a token router is introduced to further reduce computation.
weaknesses: - The model appears to be somewhat incremental in its contributions. it trains multiple routers to selectively mask certain MHSA heads and MLP blocks.

- I recommend including some state-of-the-art models in Table 1, such as DiffiT [1], SiT [2], and DiMR [3], as these also introduce architectural innovations to the DiT model.

- Also, it would be beneficial to move the 512 result in supp into the main table (and also add other methods), as training speed is a more critical factor in larger-scale generation for the DiT model.


[1] Hatamizadeh, Ali, et al. "Diffit: Diffusion vision transformers for image generation." European Conference on Computer Vision. Springer, Cham, 2025.

[2] Ma, Nanye, et al. "Sit: Exploring flow and diffusion-based generative models with scalable interpolant transformers." arXiv preprint arXiv:2401.08740 (2024).

[3] Liu, Qihao, et al. "Alleviating Distortion in Image Generation via Multi-Resolution Diffusion Models." arXiv preprint arXiv:2406.09416 (2024).

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: 1. Why there is a significant performance drop when using SDT only (II). Could the authors provide a detailed explanation?

2. How about using layer-skip only in Table 3 III (layer-skip), i.e., removing TDW? 

3. Could the authors provide a detailed description about how to obtain the results in Fig 6.

4. Why the authors use 100 DDPM in Table 12 instead of 250 like DiT. How about the results using 250 DDPM?

5. For other questions, please see weakness.

Minor issue: Line954 our-> Our
soundness: 2
strengths: 1. The paper is easy to follow and well-written with many figure to clearly illustrate the idea of the paper as well as the results.

2. The observation is interesting and the method is intuitive and effective.

3. The authors conduct extensive experiments on various datasets, such as ImageNet and Food dataset, and DiT variants like DiT-S and DiT-XL.
summary: The authors propose Dynamic Diffusion Transformer (DyDiT) that dynamically adjusts its computation along both timestep and spatial dimensions during generation to reduce computational redundancy. This method contains two key components including a Timestep-wise Dynamic Width (TDW) approach and a Spatial-wise Dynamic Token (SDT) strategy. TDW is motivated by the observation in the difference of loss curve between DiT-S and DiT-XL across various time step. SDT is inspired by loss map showing patch-wise difficulty of noise prediction. Extensive experiments are conducted to show the effectiveness of the proposed method. But I fail to see the code or pseudocode.
weaknesses: 1. This method is built on a well-pretrained DiT model, which may restrict its application. Is this method applicable for training a DiT model from scratch? 

2. In Fig 3 and Appendix A 3, the comparison with other pruning methods may not be convincing. The authors is recommended to compare the proposed method with other dynamic methods such as repurposed ITOP [1], SViTE, and S2ViTE [2]. And why the authors do not provide the results of lambda over 0.7 in DiT-XL. 

3. It seems that the authors do not choose a consistent lambda value for studies, such as 0.4 in Table 9, 0.5 in Table 10, and 0.9 in Table 14. In other words, this hyperparameter is relatively sensitive to obtain satisfying results under different settings. It would be better to provide some suggestions about the selection of this hyperparameter.

4. The comparison of maintaining the same training iterations for models in Appendix B3 may be partially reasonable. In addition to comparing DyDiT with DiT, the authors should also compare DyDiT with a DiT variant that incorporates the same gating module as DyDiT in the same position, multiplies the module output with the original input, and then uses this weighted input as the final input. In this way, we may keep the same number of parameters and further show the effectiveness of the proposed method. 

5. Though the authors combine DyDiT with LCM (a 4-step model) to show the effectiveness of proposed method, inevitably LCM is contradictory with the motivation of DyDiT because DyDiT, especially the TDW, is inspired by the observation in a 250-step model. I speculate SDT may play a dominant role. In a nutsheel, this method may have a weak influence to those 1-step, 2-step, or 4-step models like LCM.

[1] Do We Actually Need Dense Over-Parameterization? In-Time Over-Parameterization in Sparse Training.

[2] Chasing Sparsity in Vision Transformers: An End-to-End Exploration.

Meta-review: The paper introduces DyDiT, a method aimed at enhancing computational efficiency in diffusion models by dynamically adjusting resources during image generation. The proposed approach leverages mechanisms like TDW and SDT to reduce redundant computations while maintaining competitive visual quality. Extensive experiments demonstrate significant reductions in FLOPs and generation time across multiple datasets and models, validating the approach’s effectiveness and adaptability.

Reviewers generally appreciated the paper’s solid motivation, clear presentation, and strong empirical validation. They agreed on its practical impact, particularly in improving inference efficiency, but expressed concerns about the incremental nature of the contributions and the reliance on the baseline DiT architecture. Reviewer TEwe criticized the dependence on pretrained models and requested experiments involving training from scratch, while Reviewer NdkH questioned the lack of fundamental architectural innovation and limited performance improvements compared to state-of-the-art models. The authors addressed these concerns comprehensively, defending the practicality of fine-tuning and distinguishing DyDiT from unrelated methodologies, such as sparse training. Additional experiments were provided, including comparisons to state-of-the-art models and evaluations under different conditions, to strengthen the claims.

While some concerns about incrementalism persist, the authors’ responses successfully clarified the scope and novelty of the work, and the demonstrated practical impact justifies its inclusion in the conference. The disagreements, particularly with TEwe, rooted more in methodological preferences rather than unresolved flaws in the submission. Considering the detailed rebuttals and the paper's contributions to improving diffusion model efficiency, the AC recommends acceptance.

Decision: Accept (Poster)