Ctrl-Adapter: An Efficient and Versatile Framework for Adapting Diverse Controls to Any Diffusion Model

## Abstract

Abstract ControlNets are widely used for adding spatial control to text-to-image diffusion models with different conditions, such as depth maps, scribbles/sketches, and human poses. However, when it comes to controllable video generation, ControlNets cannot be directly integrated into new backbones due to feature space mismatches, and training ControlNets for new backbones can be a significant burden for many users. Furthermore, applying ControlNets independently to different frames cannot effectively maintain object temporal consistency.
To address these challenges,
we introduce Ctrl -Adapter , an efficient and versatile framework that adds diverse controls to any image/video diffusion model through the adaptation of pretrained ControlNets. Ctrl -Adapter offers strong and diverse capabilities, including image and video control, sparse-frame video control, fine-grained patch-level multi-condition control (via an MoE router), zero-shot adaptation to unseen conditions, and supports a variety of downstream tasks beyond spatial control, including video editing, video style transfer, and text-guided motion control.
With six diverse U-Net/DiT-based image/video diffusion models (SDXL, PixArt- α 𝛼 \alpha italic_α , I2VGen-XL, SVD, Latte, Hotshot-XL), Ctrl -Adapter matches the performance of pretrained ControlNets on COCO and achieves the state-of-the-art on DAVIS 2017 with significantly lower computation ( < < < 10 GPU hours).

## 1 Introduction

Recent diffusion models have achieved significant progress
in generating
high-fidelity
images [, , , ]
and videos [, , , , ]
from text descriptions.
As it is often hard to describe every image/video detail only with text,
there have been many works to control diffusion models in a more fine-grained manner
by providing additional condition inputs
such as bounding boxes [, ],
reference object images [, , ],
and
segmentation maps [, , ].
Among them,
Zhang *et al*. [] have released a variety of ControlNet checkpoints based on Stable Diffusion [] v1.5 (SDv1.5), and the user community has shared many ControlNets trained with different input conditions.
Until now, ControlNet has become one of the most popular methods for controllable image generation.

However, there are challenges when using the
existing pretrained image ControlNets
for controllable
video generation.
First, pretrained ControlNeta cannot be directly plugged into new backbone models, and
the cost for training ControlNets for new backbone models is a big burden for many users due to high computational costs.
For example, training a ControlNet for SDv1.5 takes 500-600 A100 GPU hours [, ].
Second, ControlNet was originally designed for controllable image generation; hence, applying pretrained image ControlNets directly to each video frame independently does not take the temporal consistency across frames into account.

To address this challenge,
we design Ctrl-Adapter,
a
novel, flexible
framework that enables the efficient reuse of pretrained ControlNets for diverse controls with any new image/video
diffusion models,
by
adapting
pretrained ControlNets
(and improving temporal alignment for videos).
We illustrate the overall capabilities of Ctrl-Adapter framework in Fig. 1.
As shown in Fig. 3
left,
Ctrl-Adapter trains
adapter layers [, ] to map the features of a pretrained image ControlNet to a target image/video diffusion model, while keeping the parameters of the ControlNet and the backbone diffusion model frozen.
As shown in Fig. 3 right,
each Ctrl-Adapter consists of four modules: spatial convolution, temporal convolution, spatial attention, and temporal attention.
The temporal convolution/attention modules effectively fuse the ControlNet features into image/video diffusion models for better temporal consistency.
Additionally, to ensure robust adaptation of ControlNets to backbone models of different noise scales and sparse frame control conditions, we propose skipping the visual latent variable from the ControlNet inputs. We also introduce inverse timestep sampling to effectively adapt ControlNets to new backbones equipped with continuous diffusion timestep samplers.
For more accurate control beyond a single condition, we designed a novel and powerful Mixture-of-Experts (MoE) router, which allows fine-grained, patch-level
composition of spatial feature maps from multiple control conditions via Ctrl-Adapters (see Sec. 3.3).

As shown in Table 1,
Ctrl-Adapter allows many useful capabilities, including image control, video control, video control with sparse frames, multi-condition control, and compatibility with different backbone models,
while previous methods only support a small subset of them (see details in Sec. 2).
We demonstrate the effectiveness of Ctrl-Adapter through extensive experiments and analyses. It exhibits strong performance when adapting ControlNets (pretrained with SDv1.5) to various video and image diffusion backbones, including image-to-video generation – I2VGen-XL [] and Stable Video Diffusion (SVD) [],
text-to-video generation – Latte [] and Hotshot-XL [],
and text-to-image generation – SDXL [] and PixArt-$\alpha$ [].
The ability of Ctrl-Adapter to seamlessly adapt to DiT-based models such as Latte and PixArt-$\alpha$, which are structurally different from U-Net based ControlNets, demonstrates the flexibility of our framework design.

In Sec. 5.1 and Sec. 5.2, we first show that Ctrl-Adapter matches the performance of a pretrained image ControlNet on COCO dataset []
and outperforms previous methods in controllable video generation (achieving state-of-the-art performance on the DAVIS 2017 dataset []) with significantly lower training costs (less than 10 GPU hours, see Fig. 2).
Next, we demonstrate that Ctrl-Adapter enables more accurate video generation with multiple conditions compared to a single condition.
Our fine-grained patch-level MoE router consistently outperforms both the equal weights baseline and the global weights MoE router (Sec. 5.3).
In addition,
we show that skipping the visual latent variable from ControlNet inputs allows video control only with a few frames of (*i.e*., sparse) conditions, eliminating the need for dense conditions across all frames (Sec. 5.4).
We also highlight zero-shot adaption – Ctrl-Adapter trained with one condition can easily adapt to another ControlNet trained with a different condition (Sec. 5.5).
Moreover, our Ctrl-Adapter can be flexibly applied to a variety of downstream tasks beyond spatial control, including video editing, video style transfer, and text-guided object motion control (Sec. 6).
Lastly, we provide comprehensive ablations for Ctrl-Adapter design choices and qualitative examples (Appendix E, Appendix F, and Appendix G).

**Table 1: Overview of the capabilities supported by controllable image/video generation methods.**
| Method | Image | Video | Video Control | Multi-Condition | Compatible w/ |
| --- | --- | --- | --- | --- | --- |
| Control | Control | w/ Sparse Frames | Control | Different Backbones |  |
| Image Control Methods |  |  |  |  |  |
| ControlNet [] | ✔ | ✘ | ✘ | ✘ | ✘ |
| Multi-ControlNet [] | ✔ | ✘ | ✘ | ✔ | ✘ |
| T2I-Adapter [] | ✔ | ✘ | ✘ | ✔ | ✘ |
| Uni-ControlNet [] | ✔ | ✘ | ✘ | ✔ | ✘ |
| X-Adapter [] | ✔ | ✘ | ✘ | ✘ | ✔ |
| Video Control Methods |  |  |  |  |  |
| ControlVideo [] | ✘ | ✔ | ✘ | ✘ | ✘ |
| VideoComposer [] | ✘ | ✔ | ✘ | ✔ | ✘ |
| SparseCtrl [] | ✘ | ✔ | ✔ | ✘ | ✘ |
| Ctrl-Adapter (Ours) | ✔ | ✔ | ✔ | ✔ | ✔ |

Figure: Figure 2: Training speed of Ctrl-Adapter for video (left) and image (right) control with depth maps, measured on A100 80GB GPUs. For both video and image controls, Ctrl-Adapter trained for 10 GPU hours outperforms strong baselines, including SDXL, which is trained for 700 GPU hours.
Refer to caption: x2.png

## 2 Related Works: Adding Control to Diffusion Models

There have been many works using different types of additional inputs to control the image/video diffusion models,
such as bounding boxes [, ],
reference object image [, , ],
segmentation map [, , ],
sketch [],
*etc*.,
and combinations of multiple conditions [, , , ].
As finetuning all the parameters of such image/video diffusion models is computationally expensive,
several methods, such as ControlNet [], have been proposed to add conditional control capability via parameter-efficient training [, , ].

X-Adapter [] learns an adapter module to reuse ControlNets pretrained with a smaller image diffusion model (*e.g*., SDv1.5) for a bigger image diffusion model (*e.g*., SDXL).
While they focus solely on learning an adapter for image control, Ctrl-Adapter features architectural designs (*e.g*., temporal convolution/attention layers)
for video generation as well.
In addition, X-Adapter needs to be used with the source image diffusion model (SDv1.5) during both training and inference, whereas Ctrl-Adapter does not require the smaller diffusion model for image or video generation, making it more memory and computationally efficient (see Sec. B.3 for details).

SparseCtrl [] guides a video diffusion model with conditional inputs of few frames (instead of full frames), to alleviate the cost of collecting video conditions.
Since SparseCtrl involves augmenting ControlNet with an additional channel for frame masks, it requires training a new variant of ControlNet from scratch.
In contrast, we leverage existing image ControlNets more efficiently by propagating information through temporal layers in adapters and enabling sparse frame control via skipping the latents from ControlNet inputs (see Sec. 3.2 for details).

Furthermore, compared with previous works that are specially designed for specific condition controls on a single modality (image [, ] or video [, ]),
our work presents a unified and versatile framework that supports diverse controls, including image control, video control, sparse frame control,
with significantly lower computational costs by reusing pretrained ControlNets (outperforms strong baselines in less than 10 GPU hours, see Fig. 2).
To the best of our knowledge, we are also the first work that extends multi-condition video control into fine-grained patch-level composition.
Table 1 compares Ctrl-Adapter with other relevant methods.
See Sec. A.1 for extended related works.

Figure: Figure 3: Left: Ctrl-Adapter (colored orange) enables to reuse pretrained image ControlNets (colored blue) for new image/video diffusion models (colored green). Right: Architecture details of Ctrl-Adapter. Temporal convolution and attention layers are skipped for image diffusion backbones.
Refer to caption: x4.png

## 3 Method

### 3.1 Preliminaries: Latent Diffusion Models and ControlNets

##### Latent Diffusion Models.

Many recent video generation works utilize latent diffusion models (LDMs) [] to learn the compact representations of videos.
First,
given a $F$-frame RGB video $\bm{x}\in\mathbb{R}^{F\times 3\times H\times W}$,
a video encoder (of a pretrained autoencoder) provides $C$-dimensional latent representation (*i.e*., latents):
$\bm{z}=\mathcal{E}(\bm{x})\in\mathbb{R}^{F\times C\times H^{\prime}\times W^{
\prime}}$,
where height and width are spatially downsampled
($H^{\prime}<H$ and $W^{\prime}<W$).
Next,
in the forward process,
a noise scheduler (*e.g*., DDPM []) adds noise to the latents $\bm{z}$.
Then, in the backward pass, a diffusion model
$\bm{\mathcal{F}_{\theta}}(\bm{z}_{t},t,\bm{c}_{\text{text/img}})$ learns to gradually denoise the latents,
given
a diffusion timestep $t$, and
a text prompt $\bm{c}_{\text{text}}$ (*i.e*., T2V)
and/or an initial frame $\bm{c}_{\text{img}}$ (*i.e*., I2V) if provided.
The diffusion model is trained with objective:
$\mathcal{L}_{\text{LDM}}=\mathbb{E}_{\bm{z},\bm{\epsilon}\sim N(0,\bm{I}),t}\|
\bm{\epsilon}-\bm{\epsilon_{\theta}}(\bm{z}_{t},t,\bm{c}_{\text{text/img}})\|_
{2}^{2}$, where $\bm{\epsilon}$ and $\bm{\epsilon_{\theta}}$ represent the added noise to latents and the predicted noise by $\bm{\mathcal{F}_{\theta}}$ respectively. We apply the same objective for Ctrl-Adapter training.

##### ControlNets.

ControlNet [] is designed to add spatial controls (*e.g*., depth, sketch, segmentation maps, *etc*.) to image diffusion models.
Specifically,
given a pretrained backbone image diffusion model
$\bm{\mathcal{F}_{\theta}}$
that consists of input/middle/output blocks,
ControlNet has a similar architecture $\bm{\mathcal{F}_{\theta^{\prime}}}$, where
the input/middle blocks parameters of $\bm{{\theta^{\prime}}}$ are initialized from $\bm{{\theta}}$,
and the output blocks consist of $1\times 1$ convolution layers initialized with zeros.
ControlNet takes the
diffusion timestep $t$,
text prompt $\bm{c}_{\text{text}}$, control image $\bm{c}_{\text{f}}$ (*e.g*., depth map), and the noisy latents $\bm{z_{t}}$ as inputs,
and the output features are merged into the backbone model $\bm{\mathcal{F}_{\theta}}$ for final image generation.

### 3.2 Ctrl -Adapter

We introduce Ctrl-Adapter, a novel framework that enables the efficient reuse of existing image ControlNets (SDv1.5) for spatial control with new diffusion models.
We mainly describe our method details in the video generation settings, since Ctrl-Adapter can be flexibly adapted to image diffusion models by regarding images as single-frame videos.

Efficient adaptation of pretrained ControlNets.
As shown in Fig. 3 (left),
we train an
adapter module (colored orange) to map the middle/output blocks of a pretrained ControlNet (colored blue) to the corresponding middle/output blocks of the target video diffusion model (colored green).
If the target backbone does not have the same number of output blocks
Ctrl-Adapter maps the ControlNet features to the output block that handles the closest height and width of the latents.
We keep all parameters in both the ControlNet and the target video diffusion model frozen.
Therefore, training a Ctrl-Adapter can be significantly more efficient than training a new video ControlNet.

Ctrl-Adapter architecture.
As shown in Fig. 3 (right),
each block of Ctrl-Adapter
consists
of four modules:
spatial convolution, temporal convolution, spatial attention, and temporal attention.
We set the values for $N_{1},...,N_{4}$ and $N$ as 1 by default.
The temporal convolution and attention modules effectively fuse the ControlNet features to the video backbone models for better temporal consistency.
Moreover,
the spatial/temporal convolution modules
incorporate the current denoising timestep $t$
and
spatial/temporal attention modules
incorporate the conditions (*i.e*., text prompt/initial frame) $\bm{c}_{\text{text/img}}$. This design allows Ctrl-Adapter to dynamically adjust its features according to different denoising stages and the objects generated.
In addition, we skip the temporal convolution/attention modules when adapting to image diffusion models.
See Sec. B.1 for architecture details of the four modules, and Appendix E for detailed ablation studies on the design choices of Ctrl-Adapter.

Adaptation to DiT-based image/video backbones.
Our Ctrl-Adapter can also adapt U-Net based ControlNets
to DiT-based image/video generation backbones. One important observation we made is that the spatial features encoded in the U-Net of ControlNets and the DiT blocks are structurally different (see Fig. 22).
Specifically, the representation from U-Net blocks exhibits coarse-to-fine, hierarchical patterns (*e.g*., earlier blocks output smaller size feature maps and control high-level information such as object presence, while later blocks output larger feature maps and control lower-level details like textures), while all DiT blocks handle the feature maps of same sizes.
This indicates that mapping all middle/output blocks of ControlNet to DiT blocks might not be the optimal solution.
Therefore, we choose to map the feature maps of the largest size in ControlNet (*i.e*., block A) to the DiT blocks via Ctrl-Adapters, which are followed by zero-convolutions for channel dimension matching. To improve computational efficiency for DiT-based video generation models (*i.e*., Latte []), we only insert Ctrl-Adapters into every other DiT block (*i.e*., blocks 2, 4, 6…, 28, see (a) in Fig. 17).
See Sec. E.2
for more discussion on Ctrl-Adapter designs for DiT.

Figure: Figure 4: Left (default): latent $\bm{z}_{t}$ is given to ControlNet. Right: latent $\bm{z}_{t}$ not given to ControlNet.
Refer to caption: x5.png

Skipping the latent from ControlNet inputs: robust adaption to different noise scales & sparse frame conditions.
Although the original ControlNets take the latent $\bm{z}_{t}$ as part of their inputs,
we find that
skipping $\bm{z}_{t}$ from ControlNet inputs is effective for Ctrl-Adapter in certain settings,
as illustrated in Fig. 4.
(1) Different noise scales:
while SDv1.5 samples noise $\bm{\epsilon}$ from $N(\bm{0},\bm{I})$,
some recent diffusion models [, , ]
sample noise $\bm{\epsilon}$ of much bigger scale (*e.g*. SVD [] sample noise from $\sigma*N(\bm{0},\bm{I})$, where $\sigma\sim\text{LogNormal}(0.7,1.6)$; $\sigma\in[0,+\infty]$ and $\mathbb{E}[\sigma]=7.24$).
We find that adding larger-scale $\bm{z}_{t}$ from the new backbone models to image conditions $\bm{c}_{f}$ dilutes the $\bm{c}_{f}$ and makes the ControlNet outputs less informative,
whereas skipping $\bm{z}_{t}$ enables the adaptation of such new backbone models.
(2) Sparse frame conditions:
when the image conditions are provided only for the subset of video frames (*i.e*., $\bm{c}_{f}=\emptyset$ for most frames $f$),
ControlNet could rely on the information from $\bm{z}_{t}$ and ignore $\bm{c}_{f}$ during training.
Skipping $\bm{z}_{t}$ from ControlNet inputs also helps the Ctrl-Adapter to more effectively handle such sparse frame conditions (see Table 7).

Inverse timestep sampling: robust adaptation to continuous diffusion timestep samplers.
While SDv1.5 samples discrete timesteps $t$ uniformly from $\{0,1,...1000\}$,
some recent diffusion models [, , ] sample timesteps from continuous distributions, *e.g*., SVD []
samples timesteps from a LogNormal distribution.
This gap between discrete and continuous distributions means that we cannot assign the same timestep $t$ to both the video diffusion model and the ControlNet.
Therefore, we propose inverse timestep sampling, an algorithm that creates a timestep mapping between the continuous and discrete time distributions
(see Algorithm 1 for PyTorch [] code).
The high-level idea of this algorithm is inspired by inverse transform sampling []. Given the cumulative distribution functions (CDFs) of the continuous timestep distribution $F_{\text{cont.}}$ and the ControlNet timestep distribution $F_{\text{CNet}}$,
we first uniformly sample a value $u$ between $[0,1]$, and then returns the smallest timesteps $t_{\text{cont.}}\in[0,\infty]\subseteq\mathbb{R},t_{\text{CNet}}\in\{0,1,...,1
000\}\subseteq\mathbb{N}$, such that $F_{\text{cont.}}(t_{\text{cont.}})\geq u,F_{\text{CNet}}(t_{\text{CNet}})\geq u$. This procedure naturally creates a mapping between two distributions. See Sec. B.2 for details.

Figure: Figure 5: Left: Framework for multi-condition video generation by combining multiple ControlNets. $w_{1},w_{2},...,w_{N}$ are the weights allocated to each ControlNet. Right: Three MoE router variants. (a) operates globally, while (b) and (c) operate on the fine-grained patch-level. $C$ and $N$ represent feature dimensions and number of ControlNet experts respectively. $w_{k}^{i,j}$ represents the router weights at position ($i,j$) of the $k^{\text{th}}$ ControlNet 2D feature map. SM stands for Softmax.
Refer to caption: x6.png

### 3.3 Multi-Condition Generation via Ctrl -Adapter Composition

Multi-ControlNet [] is proposed for spatial control beyond a single condition. However, this method naively combines different conditions with equal weights during inference time without training.
For more effective control composition, we first experiment with some simple extensions, such as replacing these fixed weights with unconditional global learnable weights via a lightweight MoE [] router (see variant (a) in Fig. 5 right).
Next, we further propose refining the global weights MoE router into a more fine-grained, patch-level MoE router.
Variant (b) processes the patch-level features of each ControlNet into a scalar value independently, then uses softmax to assign ControlNet weights for each patch. Variant (c) takes in all $N$ ControlNet features associated with a patch, using an architecture design inspired by Q-Former [] to output expert weights.
Comparisons of different variants are discussed in Sec. 5.3 and Sec. E.4.

## 4 Experimental Setup

ControlNets and Target Diffusion Models.
We use ControlNets trained with SD v1.5.
For target diffusion models,
we experiment with
two I2V models – I2VGen-XL [] and Stable Video Diffusion (SVD) [],
two T2V models – Latte [] and Hotshot-XL [],
and two T2I models – SDXL [] and PixArt-$\alpha$ [].
Note that Latte and PixArt-$\alpha$ are generation models based on DiT instead of U-Net.

Training and Evaluation Datasets.
We use 200K videos sampled from Panda-70M training set [] and 300K images from the LAION POP [] dataset for video and image Ctrl-Adapters training respectively.
During training, we extract various control conditions (*e.g*., depth map) on-the-fly to simplify the data-preparation process.
Following previous works [, ],
we evaluate video Ctrl-Adapters on DAVIS 2017 [], and image Ctrl-Adapters on COCO val2017 split [].
Detailed training and inference setups for the experiments are provided in Appendix C and Appendix D.

Evaluation Metrics. We perform evaluation on two folds: visual quality and spatial control.
Following previous works [, ],
we use Frechet Inception Distance (FID) [] to measure the visual quality of generated images/videos.
For video datasets,
following VideoControlNet [], we report the L2 distance between the optical flow error [] between the input and generated videos.
For image datasets,
following Uni-ControlNet [], we report the Structural Similarity (SSIM) [] and mean squared error (MSE) between generated images and ground truth images.

**Table 2: Evaluation of video generation with single control condition on DAVIS 2017 dataset. The best number in each column is bolded, and the second best is underscored.**
| Method | Depth Map | Canny Edge |  |  |
| --- | --- | --- | --- | --- |
| FID ($\downarrow$) | Optical Flow Error ($\downarrow$) | FID ($\downarrow$) | Optical Flow Error ($\downarrow$) |  |
| Text2Video-Zero [] | 19.46 | 4.09 | 17.80 | 3.77 |
| ControlVideo [] | 27.84 | 4.03 | 25.58 | 3.73 |
| Control-A-Video [] | 22.16 | 3.61 | 22.82 | 3.44 |
| VideoComposer [] | 22.09 | 4.55 | - | - |
| Hotshot-XL backbone |  |  |  |  |
| SDXL ControlNet [] | 45.35 | 4.21 | 25.40 | 4.43 |
| SDv1.5 ControlNet + Ctrl-Adapter (Ours) | 14.63 | 3.94 | 20.83 | 4.15 |
| Latte backbone (DiT-Based) |  |  |  |  |
| SDv1.5 ControlNet + Ctrl-Adapter (Ours) | 16.92 | 3.98 | 17.87 | 2.73 |
| I2VGen-XL backbone |  |  |  |  |
| SDv1.5 ControlNet + Ctrl-Adapter (Ours) | 7.43 | 3.20 | 6.42 | 3.37 |
| SVD backbone |  |  |  |  |
| SVD Temporal ControlNet [] | 4.91 | 4.84 | - | - |
| SDv1.5 ControlNet + Ctrl-Adapter (Ours) | 3.82 | 2.96 | 3.96 | 2.39 |

## 5 Results and Analysis

### 5.1 Video Generation with Single Condition

Figure: Figure 6: Single-cond. video generation.
Refer to caption: x7.png

We compare SDv1.5 ControlNet + Ctrl-Adapter built on Hotshot-XL, I2VGen-XL, SVD, and Latte with video control methods including Text2Video-Zero [], Control-A-Video [], ControlVideo [], and VideoComposer [].
As the spatial layers of Hotshot-XL are initialized with SDXL and remain frozen, the SDXL ControlNets are directly compatible with Hotshot-XL, so we include Hotshot-XL + SDXL ControlNet as a baseline.
We also experiment with
a temporal ControlNet [] trained with SVD.

Table 2
shows that
in both depth map and canny edge input conditions,
Ctrl-Adapters on I2VGen-XL and SVD
outperforms all previous strong video control methods
in visual quality (FID) and spatial control (optical flow error) metrics.
Note that it takes $<$ 10 GPU hours for Ctrl-Adapter to outperform the baselines
(see Fig. 2).
In Fig. 6 and Sec. H.1, we visualize the comparison between Ctrl-Adapter and other video control baselines.
We study visual quality-spatial control trade-off in Sec. F.2.

**Table 3: Evaluation of image generation with single control condition on COCO val2017 split. The best number in each column is bolded, and the second best is underscored.**
| Method | Depth Map | Canny Edge | Soft Edge / HED |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| FID ($\downarrow$) | MSE ($\downarrow$) | SSIM ($\uparrow$) | FID ($\downarrow$) | SSIM ($\uparrow$) | FID ($\downarrow$) | SSIM ($\uparrow$) |  |
| SDv1.4 or v1.5 backbone |  |  |  |  |  |  |  |
| SDv1.5 ControlNet [] | 21.25 | 87.57 | - | 18.90 | 0.4828 | 26.59 | 0.4719 |
| T2I-Adapter [] | 21.35 | 89.82 | - | 18.98 | 0.4422 | - | - |
| GLIGEN [] | 21.46 | 88.22 | - | 24.74 | 0.4226 | 28.57 | 0.4015 |
| Uni-ControlNet [] | 21.20 | 91.05 | - | 17.79 | 0.4911 | 17.86 | 0.5197 |
| SDXL backbone |  |  |  |  |  |  |  |
| SDXL ControlNet [] | 17.91 | 86.95 | 0.8363 | 17.21 | 0.4458 | - | - |
| SDv1.5 ControlNet + X-Adapter [] | 20.71 | 90.08 | 0.7885 | 19.71 | 0.3002 | - | - |
| SDv1.5 ControlNet + Ctrl-Adapter (Ours) | 19.26 | 87.54 | 0.8534 | 21.04 | 0.5806 | 18.08 | 0.6454 |
| PixArt-$\alpha$ backbone (DiT-Based) |  |  |  |  |  |  |  |
| PixArt-$\delta$ ControlNet [] | - | - | - | - | - | 20.41 | 0.6938 |
| SDv1.5 ControlNet + Ctrl-Adapter (Ours) | 22.54 | 84.78 | 0.8496 | 18.75 | 0.6359 | 17.52 | 0.6812 |

Figure: Figure 7: Generated images on COCO val2017 split.
Refer to caption: x8.png

### 5.2 Image Generation with Single Condition

We compare SDv1.5 ControlNet + Ctrl-Adapter with controllable image generation methods that use SDv1.4, SDv1.5, SDXL, and PixArt-$\alpha$ as backbones,
including
pretrained SDv1.5/SDXL ControlNets [, ],
T2I-Adapter [],
GLIGEN [],
Uni-ControlNet [],
X-Adapter [],
and
PixArt-$\delta$ ControlNet [].

As shown in Table 3,
Ctrl-Adapter
outperforms baselines with SDv1.4/v1.5 backbones in almost all metrics.
When compared to the baselines with SDXL backbones,
Ctrl-Adapter outperforms X-Adapter in most metrics,
and matches (in FID/MSE with depth map inputs) or outperforms SDXL ControlNet (in SSIM with depth map and canny edge inputs).
Note that
SDXL ControlNet was trained for much longer than Ctrl-Adapter (700 vs. 44 A100 GPU hours)
and it takes less than 10 GPU hours for Ctrl-Adapter
to outperform the SDXL depth ControlNet in SSIM (see Fig. 2).
In addition, when applied to DiT-based backbone (*i.e*., PixArt-$\alpha$), Ctrl-Adapter achieves good
improvement in FID (17.52 ours vs. 20.41 PixArt-$\delta$ ControlNet on soft edge)
and competitive SSIM score.
In Fig. 6 and Fig. 7, we visualize the comparison between Ctrl-Adapter and other image control baselines. See Sec. H.3 for more visualizations.

**Table 4: Comparison of different weighting methods (see Fig. 5 right part for details) for multi-condition video generation. The control sources are abbreviated as D (depth map), C (canny edge), N (surface normal), S (softedge), Seg (semantic segmentation map), L (line art), and P (human pose).**
|  | D+C | D+P | D+C+N+S | D+C+N+S+Seg+L+P |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | FID ($\downarrow$) | Flow Error ($\downarrow$) | FID ($\downarrow$) | Flow Error ($\downarrow$) | FID ($\downarrow$) | Flow Error ($\downarrow$) | FID ($\downarrow$) | Flow Error ($\downarrow$) |
| Baseline: Equal Weights | 8.50 | 2.84 | 11.32 | 3.48 | 8.75 | 2.40 | 9.48 | 2.93 |
| (a) Unconditional Global Weights | 9.14 | 2.89 | 10.98 | 3.32 | 8.39 | 2.36 | 8.18 | 2.48 |
| (b) Patch-Level MLP Weights | 8.40 | 2.34 | 9.37 | 3.17 | 7.87 | 2.11 | 8.26 | 2.00 |
| (c) Patch-Level Q-Former Weights | 7.54 | 2.39 | 9.22 | 3.22 | 7.72 | 2.31 | 8.00 | 2.08 |

### 5.3 Video Generation with Multiple Control Conditions

As described in Sec. 3.3,
users can achieve multi-source control by simply
combining the control features of multiple ControlNets via our Ctrl-Adapter.
Table 4 shows the result in two folds: firstly, patch-level MoE routers (*i.e*., variants b and c in Fig. 5) consistently outperforms the equal weights baseline as well as the unconditional global weights (*i.e*., variant a in Fig. 5), which proves the effectiveness of patch-level fine-grained control composition. Secondly, as shown in (b) and (c), control with more conditions almost always yields better spatial control and visual quality
than control with a single condition.
Fig. 28 and Fig. 29 show that multi-condition composition provides more accurate control compared to a single condition.
Table 8 extends (a) by conditioning on image/text/timestep embeddings.

Figure: Figure 8: Video generation from sparse frame conditions with Ctrl-Adapter on I2VGen-XL (which generates 16 frames in total). We only provide controls for the 1st, 6th, 11th, and 16th frames.
Refer to caption: x9.png

### 5.4 Video Generation with Sparse Frames as Control Condition

We experiment Ctrl-Adapter with providing sparse frame conditions
using I2VGen-XL as backbone.
During each training step, we first randomly select an integer $k\in\{1,...,N\}$, where $N$ is equal to the total number of output frames (*e.g*., $N=16$ for I2VGen-XL). Next, we randomly select $k$ key frames from $N$ total frames.
We then extract these key frames’ depth maps and user scribbles as control conditions.
we do not give the latents $\bm{z}$ and only give the $k$ frames to ControlNet.
In Fig. 8, we can see that I2VGen-XL with our Ctrl-Adapter can correctly generate videos that follow the control conditions for the given 4 sparse key frames and make reasonable interpolations on the frames without conditions.
In Sec. E.3,
we show that skipping the latent from ControlNet inputs is important in improving the sparse control capability.

### 5.5 Zero-Shot Generalization on Unseen Conditions

ControlNet can be understood as an image feature extractor that maps different types of controls to the unified representation space of backbone generation models.
This begs an interesting question:
“Does Ctrl-Adapter learn general feature mapping from one (smaller) backbone to another (larger) backbone?”
To answer this question,
we experiment by directly plugging Ctrl-Adapter to ControlNets
that are not seen during training.
In Fig. 9,
we observe the Ctrl-Adapter trained on depth maps can adapt to normal map and soft edge ControlNets
in a zero-shot manner. Quantitative analysis of different training strategies based on such observation is illustrated in Sec. F.1.

Figure: Figure 9: Zero-shot transfer of Ctrl-Adapter trained only on depth maps to unseen conditions.
Refer to caption: x10.png

## 6 Downstream Tasks Beyond Spatial Control

Here, we aim to qualitatively explore how other types of ControlNets can be seamlessly integrated into our framework to enable a wide variety of downstream tasks beyond spatial control.
As shown in Fig. 10, we can achieve video editing by combining image and video Ctrl-Adapters with user edited prompts; video style transfer via shuffle ControlNet $+$ Ctrl-Adapter; and text-guided motion control for masked object via inpainting ControlNet $+$ Ctrl-Adapter. See Sec. H.4 for details.

Figure: Figure 10: Illustration of additional downstream tasks supported by our Ctrl-Adapter framework.
Refer to caption: x11.png

## 7 Conclusion

We propose Ctrl-Adapter,
an efficient, powerful, and versatile framework that adds diverse controls to any image/video diffusion model.
Training an Ctrl-Adapter is significantly more efficient than training a ControlNet for a new backbone, and it can outperform or match strong baselines in visual quality and spatial control.
Ctrl-Adapter not only provides many useful capabilities including image/video control, sparse frame control, multi-condition control, and zero-shot adaption to unseen conditions, but also can be easily and flexibly integrated into a variety of downstream tasks.

## Acknowledgments

This work was supported by DARPA ECOLE Program No. HR00112390060, NSF-AI Engage Institute DRL-2112635, DARPA Machine Commonsense (MCS) Grant N66001-19-2-4031, ARO Award W911NF2110220, ONR Grant N00014-23-1-2356, and a Bloomberg Data Science Ph.D. Fellowship. The views contained in this article are those of the authors and not of the funding agency.

## Appendix A Background

### A.1 Extended Related Works

##### Text-to-video and image-to-video generation models.

Generating videos from text descriptions or images (*e.g*., initial video frames) based on deep learning
and has increasingly gained much attention.
Early works for this task [, , , ]
have commonly used
variational autoencoders (VAEs) [] and generative adversarial networks (GANs) [],
while
most of recent video generation works are based on
denoising diffusion models [, ].
Powered by large-scale training, recent video diffusion models demonstrate impressive performance in generating highly realistic videos from text descriptions [, , , , , , , , , , , ]
or initial video frames (*i.e*., images) [, , , ].

##### Adding control to image/video diffusion models.

While recent image/video diffusion models demonstrate impressive performance in generating highly realistic images/videos from text descriptions,
it is hard to describe every detail of images/videos
only with text or first frame image.
Instead, there have been many works using different types of additional inputs to control the image/video diffusion models,
such as bounding boxes [, ],
reference object image [, , ],
segmentation map [, , ],
sketch [],
*etc*.,
and combinations of multiple conditions [, , , ].
As finetuning all the parameters of such image/video diffusion models is computationally expensive,
several methods, such as ControlNet [], have been proposed to add conditional control capability via parameter-efficient training [, , ].
X-Adapter [] learns an adapter module to reuse ControlNets pretrained with a smaller image diffusion model (*e.g*., SDv1.5) for a bigger image diffusion model (*e.g*., SDXL).
While they focus solely on learning an adapter for image control, Ctrl-Adapter features architectural designs (*e.g*., temporal convolution/attention layers)
for video generation as well.
In addition, X-Adapter needs the smaller image diffusion model (SDv1.5) during training and inference, whereas Ctrl-Adapter doesn’t need the smaller diffusion model at all (for image/video generation), hence being more memory and computationally efficient (see Sec. B.3 for details).
SparseCtrl [] guides a video diffusion model with conditional inputs of few frames (instead of full frames), to alleviate the cost of collecting video conditions.
Since SparseCtrl involves augmenting ControlNet with an additional channel for frame masks, it requires training a new variant of ControlNet from scratch.
In contrast, we leverage existing image ControlNets more efficiently by propagating information through temporal layers in adapters and enabling sparse frame control via skipping the latents from ControlNet inputs (see Sec. 3.2 for details).
Furthermore, compared with previous works that are specially designed for specific condition controls on a single modality (image [, ] or video [, ]),
our work presents a unified and versatile framework that supports diverse controls, including image control, video control, sparse frame control, and multi-source control,
with significantly lower computational costs by reusing pretrained ControlNets (*e.g*., Ctrl-Adapter outperforms baselines in less than 10 GPU hours).
Table 1 summarizes the
comparison of Ctrl-Adapter with related works.

### A.2 Extended Preliminaries: LDM and ControlNet

##### Latent Diffusion Models.

Many recent video generation works are based on
latent diffusion models (LDMs) [],
where a diffusion model learns the temporal dynamics of compact latent representations of videos.
First,
given a $F$-frame RGB video $\bm{x}\in\mathbb{R}^{F\times 3\times H\times W}$,
a video encoder (of a pretrained autoencoder) provides $C$-dimensional latent representation (*i.e*., latents):
$\bm{z}=\mathcal{E}(\bm{x})\in\mathbb{R}^{F\times C\times H^{\prime}\times W^{
\prime}}$,
where height and width are spatially downsampled
($H^{\prime}<H$ and $W^{\prime}<W$).
Next,
in the forward process,
a noise scheduler such as DDPM []
gradually adds noise to the latents $\bm{z}$:
$q(\bm{z}_{t}|\bm{z}_{t-1})=N(\bm{z}_{t};\sqrt{1-\beta_{t}}\bm{z}_{t-1},\beta_{
t}\bm{I})$,
where $\beta_{t}\in(0,1)$ is the variance schedule with $t\in\{1,...,T\}$.
Then, in the backward pass, a diffusion model (usually a U-Net architecture) $\bm{\mathcal{F}_{\theta}}(\bm{z}_{t},t,\bm{c}_{\text{text/img}})$ learns to gradually denoise the latents,
given
a diffusion timestep $t$, and
a text prompt $\bm{c}_{\text{text}}$ (*i.e*., T2V)
or an initial frame $\bm{c}_{\text{img}}$ (*i.e*., I2V) if provided.
The diffusion model is trained with following objective:
$\mathcal{L}_{\text{LDM}}=\mathbb{E}_{\bm{z},\bm{\epsilon}\sim N(0,\bm{I}),t}\|
\bm{\epsilon}-\bm{\epsilon_{\theta}}(\bm{z}_{t},t,\bm{c}_{\text{text/img}})\|_
{2}^{2}$, where $\bm{\epsilon}$ and $\bm{\epsilon_{\theta}}$ represent the added noise to latents and the predicted noise by $\bm{\mathcal{F}_{\theta}}$ respectively. We apply the same objective for Ctrl-Adapter training.

##### ControlNets.

ControlNet [] is designed to add spatial controls to image diffusion models in the form of different guidance images (*e.g*., depth, sketch, segmentation maps, *etc*.).
Specifically,
given a pretrained backbone image diffusion model
$\bm{\mathcal{F}_{\theta}}$
that consists of input/middle/output blocks,
ControlNet has a similar architecture $\bm{\mathcal{F}_{\theta^{\prime}}}$, where
the input/middle blocks parameters of $\bm{{\theta^{\prime}}}$ are initialized from $\bm{{\theta}}$,
and the output blocks consist of 1x1 convolution layers initialized with zeros.
ControlNet takes the
diffusion timestep $t$,
text prompt $\bm{c}_{\text{text}}$,
control image $\bm{c}_{\text{f}}$ (*e.g*., depth image), and the noisy latents $\bm{z_{t}}$ as inputs,
and provides the features that are merged into middle/output blocks of backbone image model $\bm{\mathcal{F}_{\theta}}$ to generate the final image.
The authors of ControlNet have released a variety of ControlNet checkpoints based on Stable Diffusion [] v1.5 (SDv1.5) and the user community have also shared many ControlNets trained with different input conditions based on SDv1.5.
However, these ControlNets cannot be used with more recently released bigger and stronger image/video diffusion models, such as SDXL [] and I2VGen-XL [].
Moreover, the input/middle blocks of the ControlNet are in the same size with those of the diffusion backbones (*i.e*., if the backbone model gets bigger, ControlNet also gets bigger).
Due to this, it becomes increasingly difficult to train new ControlNets for each bigger and newer model that is released over time.
To address this, we introduce Ctrl-Adapter for efficient adaption of existing ControlNets for new diffusion models.

## Appendix B Ctrl -Adapter Method and Architecture Details

### B.1 Ctrl -Adapter Architecture Details

Figure: Figure 11: Detailed architecture of Ctrl-Adapter blocks.
Refer to caption: x12.png

In Fig. 11,
we illustrate the detailed architecture of Ctrl-Adapter blocks.
See Fig. 3 for how the Ctrl-Adapter blocks are used to adapt ControlNets to image/video diffusion models. Fig. 11 is an extended version of
Fig. 3 (right) with more detailed visualizations, including skip connections, normalization layers in each module, and the linear projection layers (*i.e*., FFN) in each spatial/temporal attention modules.

### B.2 PyTorch Implementation for Inverse Timestep Sampling

In Algorithm 1, we provide the PyTorch [] implementation of inverse timestep sampling, described in Sec. 3.2.
In the example, inverse time stamping adapts to the SVD [] backbone.

During each training step, the procedure for this algorithm can be summarized as follows:

- •
Sample a variable $u$ from Uniform$[0,1]$. See line 19 in function inverse_timestamp_sample.
- •
Sample noise scale $\sigma_{\text{cont.}}$ via inverse transform sampling []; *i.e*., we derive the inverse cumulative density function of $\sigma_{\text{cont.}}$ and sample $\sigma_{\text{cont.}}$ by sampling $u$: $\sigma_{\text{cont.}}=F_{\text{cont.}}^{-1}(u)$. See function sample_sigma and line 21 in function inverse_timestamp_sample.
- •
Given a preconditioning function $g_{\text{cont.}}$ that maps noise scale to timestep (typically associated with the continuous-time noise sampler),
we can compute $t_{\text{cont.}}=g_{\text{cont.}}(\sigma_{\text{cont.}})$. See function sigma_to_timestep and line 23 in inverse_timestamp_sample.
- •
Set the timesteps and noise scales for both ControlNet and our Ctrl-Adapter as $t_{\text{CNet}}=\text{round}(1000u)$ and $\sigma_{\text{CNet}}=u$ respectively, where 1000 represents the denoising timestep range over which the ControlNet is trained. See line 25 in inverse_timestamp_sample.

During inference, we follow the similar sampling strategy, with the only change in the first step. Instead of uniformly sample a single value for $u$, we uniformly sample $k$ equidistant values for $u$ within $[0,1]$ and derive corresponding $t_{\text{cont./CNet}}$ and $\sigma_{\text{cont./CNet}}$ as inputs for denoising steps, where $k$ here is the number of denoising steps during inference.

Figure: Algorithm 1 PyTorch Implementation for Inverse Timestep Sampling

### B.3 Comparison of Ctrl -Adapter Variants and Related Methods

In Fig. 12,
we compare the variants of Ctrl-Adapter designs (with latent is given / not given to ControlNet; see Sec. 3.2 for details) and two related methods: SparseCtrl [] and X-Adapter [].
Unlike Ctrl-Adapter that leverages the pretrained image ControlNets,
SparseCtrl (Fig. 12 c) trains a video ControlNet with control conditions $c_{f}$ and frame masks $m$ as inputs.
While X-Adapter (Fig. 12 d) needs SDv1.5 U-Net as well as SDv1.5 ControlNet during training and inference,
Ctrl-Adapter doesn’t need to SDv1.5 U-Net at all.

Figure: Figure 12: Comparison of giving different inputs to ControlNet, where $\bm{z}_{t},\bm{c}_{\text{f}}$, and $t$ represent latents, input control features, and timesteps respectively. (a): Default Ctrl-Adapter design. (b): Variant of Ctrl-Adapter where latents $\bm{z}_{t}$ are not given to ControlNet (see Sec. 3.2 for details). (c): SparseCtrl [] trains a video ControlNet with control conditions $c_{f}$ and frame masks $m$ as inputs. (d): X-Adapter [] needs SDv1.5 U-Net as well as SDv1.5 ControlNet during training and inference, whereas Ctrl-Adapter doesn’t need to SDv1.5 U-Net at all.
Refer to caption: x13.png

## Appendix C Training and Inference Details

##### Model architectures.

Detailed illustration of our Ctrl-Adapter architecture has been provided across several parts of our paper, including Sec. 3, Sec. B.1, Appendix E, and Appendix F. In addition, for all the backbone models used in this paper, we kept all their parameters frozen and made no modifications.

##### Training details.

We use a learning rate of $5\times e^{-5}$; AdamW [] optimizer with values for $\beta_{1}$, $\beta_{2}$, $\epsilon$, and weight decay as 0.9, 0.999, $1\times e^{-8}$, and $1\times e^{-2}$ respectively. We set the max gradient norm as 1.
All our experiments are trained on 4 A100 80GB GPUs with batch size of 1. Detailed study of
per-GPU training memory for different model architecture variants are shown in Fig. 13. Please note that other than mixed-precision training with data type bfloat16, we didn’t use any additional methods to speed up the training/inference clock time, or to save GPU memory. To be more specific, we didn’t use any of the following methods: xformers [], gradient checkpointing, 8bit Adam optimizer, and DeepSpeed []. In addition, to make our framework easy to use directly from raw input images/videos, we extract all control condition images/frames on-the-fly during training. We train the image and video Ctrl-Adapters for 80k and 40k steps respectively, which can be finished in 24 hours measured by training clock time. The fast convergence of our method is shown in Fig. 2.

##### Inference details.

All inference can be done on a single A6000 GPU with 48GB memory. During inference, we use the default hyper-parameters for each backbone model, including the number of frames to generate, the number of denoising steps, and classifier-free guidance scale, *etc*..

##### Safeguards.

When we generate images during inference, we also activate the NSFW filter of the backbone models. This ensures that users are protected from unnecessary exposure to explicit or objectionable materials. For training, the datasets we used [, ] both filter out the image/video samples with harmful contents. For example, as stated in the “Risk mitigation” section of Panda70M paper, they used the internal automatic pipeline to filter out the video
samples with harmful or violent language and texts that
include drugs or hateful speech. They also use the NLTK
framework to replace all people’s names with "person". LAION-POP dataset is also created by filtering out samples based on the safety tags (using a customized trained NSFW classifier that they built).

## Appendix D Experimental Setup

### D.1 ControlNets and Target Diffusion Models

##### ControlNets.

We use ControlNets trained with SDv1.5.(^1^11[https://huggingface.co/lllyasviel/ControlNet](https://huggingface.co/lllyasviel/ControlNet))
SDv1.5 has the most number of publicly released ControlNets
and has a much smaller training cost
compared to recent image/video diffusion models.
Note that unlike X-Adapter [], Ctrl-Adapter does not need to load the source diffusion model (SDv1.5) during training or inference (see (a) and (d) in Fig. 12 for model architecture comparison).

##### Target diffusion models (where ControlNets are to be adapted).

For video generation models, we experiment with two text-to-video generation models – Latte [] and Hotshot-XL [],
and two image-to-video generation models – I2VGen-XL [] and Stable Video Diffusion (SVD) [].
For image generation model, we experiment with PixArt-$\alpha$ [] and the base model in SDXL [].
For all models, we use their default settings during training and inference (*e.g*., number of output frames, resolution, number of denoising steps, classifier-free guidance scale, *etc*.).

### D.2 Training Datasets for Ctrl -Adapter

##### Video datasets.

For training Ctrl-Adapter for video diffusion models, we download around 1.5M videos randomly sampled from the Panda-70M training set [].
Following recent works [, ], we filter out videos of static scenes by removing videos whose average optical flow [, ] magnitude is below a certain threshold.
Concretely,
we
use the Gunnar Farneback’s algorithm(^2^22 [https://docs.opencv.org/4.x/d4/dee/tutorial_optical_flow.html](https://docs.opencv.org/4.x/d4/dee/tutorial_optical_flow.html)) []
at 2FPS, calculate the averaged the optical flow for each video and re-scale it between 0 and 1, and filter out videos whose average optical flow error is below a threshold of 0.25.
This process gives us a total of 200K remaining videos.

##### Image datasets.

For training Ctrl-Adapter for image diffusion models,
we use 300K images randomly sampled from LAION POP,(^3^33[https://laion.ai/blog/laion-pop/](https://laion.ai/blog/laion-pop/)) which is a subset of LAION 5B [] dataset and contains 600K images in total with aesthetic values of at least 0.5 and a minimum resolution of 768 pixels on the shortest side.
As suggested by the authors, we use the image captions generated with CogVLM [].

### D.3 Input Conditions

We extract various input conditions
from the video and image datasets described above.

- •
Depth map:
As recommended in Midas(^4^44[https://github.com/isl-org/MiDaS](https://github.com/isl-org/MiDaS)) [],
we employ dpt_swin2_large_384 for the best speed-performance trade-off.
- •
Canny edge, surface normal, line art, softedge, and user sketching/scribbles:
Following ControlNet [], we utilize the same annotator implemented in the controlnet_aux(^5^55[https://github.com/huggingface/controlnet_aux](https://github.com/huggingface/controlnet_aux)) library.
- •
Semantic segmentation map: To obtain higher-quality segmentation maps
than
UPerNet [] used in ControlNet,
we employ SegFormer [] segformer-b5-finetuned-ade-640-640 finetuned on ADE20k dataset at 640$\times$640 resolution.
- •
Human pose: We employ ViTPose [] ViTPose_huge_simple_coco to improve both processing speed and estimation quality, compared to OpenPose  [] used in ControlNet.

### D.4 Evaluation Datasets

##### Video datasets.

Following previous works [, ],
we evaluate our video ControlNet adapters on DAVIS 2017 [], a public benchmark dataset
also used in other controllable video generation works [].
We first combine all video sequences from TrainVal, Test-Dev 2017 and Test-Challenge 2017.
Then, we chunk each video into smaller clips, with the number of frames in each clip being the same as the default number of frames generated by each video backbone (*e.g*., 8 frames for Hotshot-XL, 16 frames for I2VGen-XL, and 14 frames for SVD). This process results in a total of 1281 video clips of 8 frames, 697 clips of 14 frames, and 608 video clips of 16 frames.

##### Image datasets.

We evaluate our image ControlNet adapters on COCO val2017 split [], which contains 5k images that cover diverse range of daily objects. We resize and center crop the images to 1024 by 1024 for SDXL evaluation.

### D.5 Evaluation Metrics

##### Visual quality.

Following previous works [, ],
we use Frechet Inception Distance (FID) [] to measure the distribution distance between our generated images/videos and input images/videos.(^6^66To be consistent with the numbers reported in Uni-ControlNet [], we use pytorch-fid ([https://github.com/mseitzer/pytorch-fid](https://github.com/mseitzer/pytorch-fid)) in Table 3. For other results, we use clean-fid [] ([https://github.com/GaParmar/clean-fid](https://github.com/GaParmar/clean-fid)) which is more robust to aliasing artifacts.)

##### Spatial control.

For video datasets,
following VideoControlNet [], we report the L2 distance between the optical flow [] of the input video and the generated video (Optical Flow Error).
For image datasets,
following Uni-ControlNet [], we report the Structural Similarity (SSIM) [](^7^77[https://scikit-image.org/docs/stable/auto_examples/transform/plot_ssim.html](https://scikit-image.org/docs/stable/auto_examples/transform/plot_ssim.html)) and mean squared error (MSE)(^8^88[https://scikit-learn.org/stable/modules/classes.html#module-sklearn.metrics](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.metrics)) between generated images and ground truth images.

## Appendix E Variants of Ctrl -Adapter Architecture Design

### E.1 Ctrl -Adapter Design Ablations

#### E.1.1 Combinations of components within each Ctrl -Adapter

Figure: Figure 13: Comparison of different architecture of Ctrl-Adapter for image and video control, measured with visual quality (FID) and spatial control (MSE/optical flow error) metrics. The metrics are calculated from 1000 randomly selected COCO val2017 images and 150 videos from DAVIS 2017 dataset respectively. Left: image control on SDXL backbone. Right: video control on I2VGen-XL backbone. For both plots, data points in the bottom-left are ideal. SC, TC, SA, and TA: Spatial Convolution, Temporal Convolution, Spatial Attention, and Temporal Attention. ${}^{*}N$ represents the number of blocks in each Ctrl-Adapter. The diameters of bubbles represent training GPU memory.
Refer to caption: x14.png

Figure: Figure 14: Comparison of inserting Ctrl-Adapter to different U-Net blocks. ‘Mid’ represents the middle block, whereas ‘Out ABCD’ represents output blocks A, B, C, and D. The metrics are calculated from 150 videos from DAVIS 2017 dataset.
Refer to caption: x16.png

Figure: Figure 15: Comparison of inserting different numbers of Ctrl-Adapters to the backbone diffusion U-Net’s output blocks. We use output block D here for illustration. We insert three Ctrl-Adapters to the output blocks of the same feature map size by default.
Refer to caption: x18.png

Figure: Figure 16: Comparison of inserting different numbers of Ctrl-Adapters to each U-Net output block. The metrics are calculated from 150 videos from DAVIS 2017 dataset. We insert 3 Ctrl-Adapters to each output block by default.
Refer to caption: x19.png

As described in Sec. 3.2,
each Ctrl-Adapter module consists of four components:
spatial convolution (SC), temporal convolution (TC), spatial attention (SA), and temporal attention (TA).
We experiment with different architecture combinations of the adapter components for image and video control, and plot the results in Fig. 13.
Compared to X-Adapter [], which uses a stack of three spatial convolution modules (*i.e*., ResNet [] blocks) for adapters, and VideoComposer [], which employs spatial convolution + temporal attention for spatiotemporal condition encoder,
we explore a richer combination that enhances global understanding of spatial information through spatial attention and improves temporal ability via a combination of temporal convolution and temporal attention.
For image control (Fig. 13 left),
we find that the combining of SC+SA is more effective than stacking SC or SA layers only.
Stacking SC+SA twice further improves the visual quality (FID) slightly but hurts the spatial control (MSE) as a tradeoff. Stacking SC+SA three times hurts the performance due to insufficient training. We use the single SC+SA layer for image Ctrl-Adapter by default.
For video control (Fig. 13 right),
we find that SC+TC+SA+TA shows the best balance of visual quality (FID) and spatial control (optical flow error). Notably,
we find that the combinations with both temporal layers, SC+TC+SA+TA and (TC+TA)*2, achieve the lowest optical flow error.
We use SC+TC+SA+TA for video Ctrl-Adapter by default.

#### E.1.2 Where to fuse Ctrl -Adapter outputs in backbone diffusion

We compare the integration of Ctrl-Adapter outputs at different positions of video diffusion backbone model.
As illustrated in
Fig. 3,
we experiment with integrating Ctrl-Adapter outputs to different positions of I2VGen-XL’s U-Net: middle block, output block A, output block B, output block C, and output block D.
Specifically, we compared our default design (Mid + Out ABCD) with four other variants (Out ABCD, Out ABC, Out AB, and Out A) that gradually remove Ctrl-Adapters from the middle block and output blocks at positions from B to D.
As shown in Fig. 14, removing the Ctrl-Adapters from the middle block and the output block D does not lead to a noticeable increase in FID or optical flow error (*i.e*., the performances of ‘Mid+Out ABCD’, ‘Out ABCD’, and ‘Out ABC’ are similar in both left and right plots).
However, Fig. 14 (right) shows that removing Ctrl-Adapters from block C causes a significant increase in optical flow error.
Therefore, we recommend users retain our Ctrl-Adapters in the mid and output blocks A/B/C to ensure good performance.

#### E.1.3 Number of Ctrl -Adapters in each output block position

As illustrated in Fig. 3, there are three output blocks for each feature map dimension in the video diffusion model (represented by $\times 3$ in each output block).
Here, we conduct an ablation study by adding Ctrl-Adapters to only one or two of the three output blocks of the same feature size.
The motivation is that using fewer Ctrl-Adapters can almost linearly decrease the number of trainable parameters, thereby reducing GPU memory usage during training.
We visualize the architectural changes with output block D as an example in Fig. 15. We insert Ctrl-Adapters for three blocks as our default setting. As observed in Fig. 16, reducing the number of Ctrl-Adapters increases the optical flow error. Therefore, we recommend adding Ctrl-Adapters to each output block to maintain optimal performance.

### E.2 Adaptation to DiT-Based Backbones

As illustrated in Sec. 3, we have observed that the spatial features encoded in the U-Net of ControlNets and
the DiT blocks are structurally different (see Fig. 22 for visualization of such observation). Therefore, mapping all
middle/output blocks of ControlNet to DiT blocks might not be the optimal solution. In Fig. 17, we implement three different strategies to insert Ctrl-Adapters to the DiT blocks. Specifically, variant (a) inserts Ctrl-Adapters interleavingly into the DiT blocks, while variant (b) and (c) insert Ctrl-Adapters to the first 14 and the last 14 DiT blocks respectively. In Table 5, we perform quantitative analysis of these three variants on the DiT-based video generation model, Latte [], with soft edge as control condition. As we can see, inserting Ctrl-Adapters interleavingly into the DiT blocks gives the best performance. This is consistent with our finding: since all DiT blocks encode global information of the generated objects, it is optimal to treat these blocks equally, rather than inserting Ctrl-Adapters only at the beginning or end. Between locations A and B, we use location A as our default setting because its feature map size ($64\times 64$) directly matches the features of the DiT blocks (also $64\times 64$) without resizing.

After finalizing where to insert Ctrl-Adapters, the next question is which block(s) of the ControlNet we should create Ctrl-Adapters to map from. In Table 6, we implement several variants on the DiT-based image generation model, PixArt-$\alpha$ [], including mapping from the block(s) at location A, location B, location C, and location D, respectively (see Fig. 3 for the definitions of these locations). As we can see, mapping from location A or location B gives the best performance. Again, this is consistent with our findings in Fig. 22, since feature maps at locations C and D are too coarse to be informative. Moreover, we implemented two additional variants: (1) combining the ControlNet features from locations A and B (*i.e*., Output Blocks A+B), and (2) mapping more blocks from the same location (*i.e*., the second and third columns in Table 6). However, neither of these approaches provides sufficient gain compared to mapping a single block from location A or B. Therefore, we use mapping one block from location A as our default setting in our main paper.

Figure: Figure 17: Visualization of different routing methods for combining multiple ControlNet outputs. We use (a) as our default setting, and show the settings (b) and (c) as ablations.
Refer to caption: x20.png

**Table 5: Ablation of inserting Ctrl-Adapters to different DiT blocks in Latte []. Visualization of the three architecture variants (interleaved, first half, and second half) are shown in Fig. 17. We use soft edge as control condition here for evaluation.**
| (a) Interleave (default) | (b) First Half | (c) Second Half |  |  |  |
| --- | --- | --- | --- | --- | --- |
| FID ($\downarrow$) | Optical Flow Error ($\downarrow$) | FID ($\downarrow$) | Optical Flow Error ($\downarrow$) | FID ($\downarrow$) | Optical Flow Error ($\downarrow$) |
| 18.32 | 2.98 | 19.66 | 3.09 | 23.18 | 3.31 |

**Table 6: Ablation study of mapping ControlNet features from different locations, and mapping different number of blocks from the same location to the DiT blocks. The best numbers in each row are bolded, and the best numbers in each column are underscored.**
| Insert Locations | 1 Block (default) | 2 Blocks | 3 Blocks |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| FID ($\downarrow$) | SSIM ($\downarrow$) | FID ($\downarrow$) | SSIM ($\downarrow$) | FID ($\downarrow$) | SSIM ($\downarrow$) |  |
| Output Block A (default) | 17.90 | 0.6802 | 19.08 | 0.6971 | 19.28 | 0.6855 |
| Output Block B | 18.23 | 0.6712 | 18.61 | 0.6720 | 21.47 | 0.6549 |
| Output Blocks A+B | 17.52 | 0.6812 | - | - | - | - |
| Output Block C | 22.22 | 0.5273 | - | - | - | - |
| Output Block D | 34.16 | 0.3506 | - | - | - | - |

### E.3 Skipping Latent from ControlNet Inputs

**Table 7: Skipping latent from ControlNet inputs helps Ctrl-Adapter for (1) adaptation to backbone models with different noise scales and (2) video control with sparse frame conditions. We evaluate SVD and I2VGen-XL on depth maps and scribbles as control conditions respectively.**
| Method | Latent $\bm{z}$ is given to ControlNet | FID ($\downarrow$) | Optical Flow Error ($\downarrow$) |
| --- | --- | --- | --- |
| Adaptation to different noise scales |  |  |  |
| SVD [] + Ctrl-Adapter | ✔ | 4.48 | 2.77 |
| SVD [] + Ctrl-Adapter | ✘ | 3.82 | 2.96 |
| Sparse frame conditions |  |  |  |
| I2VGen-XL [] + Ctrl-Adapter | ✔ | 7.20 | 5.13 |
| I2VGen-XL [] + Ctrl-Adapter | ✘ | 5.98 | 4.88 |

As described in Sec. 3.2,
we find skipping the latent $z$ from ControlNet inputs can help Ctrl-Adapter to more robustly handle
(1) adaption to the backbone with noise scales different from SDv1.5, such as SVD
and
(2) video control with sparse frame conditions.
For the first scenario, we can see from Table 7 that skipping latents in SVD leads to better visual quality (lower FID), but slightly worse spatial control (higher optical flow error). This is reasonable since skipping the noisy latents can avoid introducing large noise into the ControlNet, but it also risks losing information encoded in the latents.
For the second scenario, skipping latents results in both better visual quality and better spatial control, as adding dense noisy latents can make the sparse control conditions less informative.

### E.4 Different weighing modules for multi-condition generation

**Table 8: Comparison of global weighting methods for multi-condition video generation (see Fig. 18 for visualization of the additional weighting methods (a.2, a.3, and a.4) developed based on (a.1) unconditional global weights). The control sources are abbreviated as D (depth map), C (canny edge), N (surface normal), S (softedge), Seg (semantic segmentation map), L (line art), and P (human pose).**
|  | D+C | D+P | D+C+N+S | D+C+N+S+Seg+L+P |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | FID ($\downarrow$) | Flow Error ($\downarrow$) | FID ($\downarrow$) | Flow Error ($\downarrow$) | FID ($\downarrow$) | Flow Error ($\downarrow$) | FID ($\downarrow$) | Flow Error ($\downarrow$) |
| Baseline |  |  |  |  |  |  |  |  |
| Equal Weights | 8.50 | 2.84 | 11.32 | 3.48 | 8.75 | 2.40 | 9.48 | 2.93 |
| Global MoE Router |  |  |  |  |  |  |  |  |
| (a.1) Unconditional Global Weights | 9.14 | 2.89 | 10.98 | 3.32 | 8.39 | 2.36 | 8.18 | 2.48 |
| (a.2) Timestep Emb. Weights | 9.41 | 3.51 | 11.13 | 3.35 | 9.51 | 2.78 | 8.17 | 2.45 |
| (a.3) Text/Image Emb. Weights | 8.73 | 3.16 | 11.35 | 3.37 | 7.91 | 2.76 | 8.83 | 2.48 |
| (a.4) Timestep + Text/Image Emb. Weights | 8.64 | 3.31 | 10.69 | 3.43 | 8.09 | 2.69 | 8.51 | 2.43 |
| Patch-Level MoE Router |  |  |  |  |  |  |  |  |
| (b) MLP Weights | 8.40 | 2.34 | 9.37 | 3.17 | 7.87 | 2.11 | 8.26 | 2.00 |
| (c) Q-Former Weights | 7.54 | 2.39 | 9.22 | 3.22 | 7.72 | 2.31 | 8.00 | 2.08 |

Figure: Figure 18: Visualization of different global MoE routing methods.
Refer to caption: x21.png

**Table 9: Ablation of training a unified Ctrl-Adapter v.s. training an individual Ctrl-Adapter for each condition. The results are evaluated with SDXL as the backbone model.**
| Training Strategy | Depth Map | Canny Edge |  |  |
| --- | --- | --- | --- | --- |
| FID ($\downarrow$) | SSIM ($\uparrow$) | FID ($\downarrow$) | SSIM ($\uparrow$) |  |
| Individual Ctrl-Adapter (default) | 19.26 | 0.8534 | 21.04 | 0.5806 |
| Unified Ctrl-Adapter | 19.95 | 0.8437 | 22.31 | 0.5684 |

For multi-condition generation described in Sec. 3.3,
in addition to the simple unconditional global weights,
we also experimented with
learning a router module that takes additional inputs such as diffusion time steps and image/text embeddings and outputs weights for different ControlNets.
Specifically, we introduce three variants based on (a.1) unconditional global weights, which are
(a.2) MLP router - taking timestep as inputs;
(a.3) MLP router - taking image/text embedding as inputs;
and
(a.4) MLP router - taking timestep and image/text embedding as inputs.
The MoE router in these variants are constructed as a 3-layer MLP.
We illustrate the five methods in Fig. 18.

Table 8
show that
all four global weighting schemes for fusing different ControlNet outputs
perform effectively, and no specific method outperforms other methods with significant margins in all settings. With no surprise, patch-level MoE router performs consistently better than global MoE router in all control settings.
Testing the effectiveness of incorporating text/image/timestep embeddings to patch-level MoE routers are left for future work.

## Appendix F Additional Quantitative Analysis

### F.1 Train individual Ctrl -Adapter v.s. train a unified Ctrl -Adapter

In our main paper, we train Ctrl-Adapter for each control conditions. An interesting question to ask is: can we have a single and unified Ctrl-Adapter that works for all control conditions?
In this part, we perform such analysis with SDXL as the backbone model on a new training strategy. Specifically, during each training step, we randomly choose one control condition from a pool of 8 control conditions, including depth map, canny edge, soft edge, normal map, semantic segmentation, line art, user scribbles, and human pose. We train this variant with the same hyper-parameter settings as the depth map or canny edge Ctrl-Adapter mentioned in our main paper.

As shown in Table 9, training a unified Ctrl-Adapter across all control conditions does suffer from a performance decrease. However, this decrease is not very significant. Therefore, from a practical point of view, if a user has computational constraints but still needs to work on multiple control conditions, training a unified Ctrl-Adapter can be a viable workaround.

### F.2 Trade-off between Visual Quality and Spatial Control

In Fig. 19,
Fig. 20,
and
Fig. 21,
we show
the visual quality (FID) and spatial control (SSIM/optical flow error) metrics
with different numbers of denoising steps with spatial control (with the fusion of Ctrl-Adapter outputs) on SDXL, SVD, and I2VGen-XL backbones respectively.
Specifically, suppose we use $N$ denoising steps during inference, a control guidance level of $x\%$ means that we fuse Ctrl-Adapter features to the video diffusion U-Net during the first $x\%\times N$ denoising steps, followed by $(100-x)\%\times N$ regular denoising steps.
In all experiments, we find that increasing the number of denoising steps with spatial control improves the spatial control accuracies (SSIM/optical flow error) but hurts visual quality (FID).

Figure: Figure 19: Trade-off between generated visual quality (FID) and spatial control accuracy (SSIM) on SDXL. Control guidance level of $x$ represents that we apply Ctrl-Adapter in the first $x\%$ of the denoising steps during inference. A control guidance level between $30\%$ and $60\%$ usually achieves the best balance between image quality and spatial control accuracy.
Refer to caption: extracted/5618618/img/appendix_sdxl_depth_fid_ssim_tradeoff.png

Figure: Figure 20: Trade-off between generated visual quality (FID) and spatial control accuracy (Optical Flow Error) on SVD. Control guidance level of $x$ represents that we apply Ctrl-Adapter in the first $x\%$ of the denoising steps during inference. A control guidance level between $40\%$ and $60\%$ usually achieves the best balance between image quality and spatial control accuracy
Refer to caption: extracted/5618618/img/appendix_svd_depth_fid_flow_error_tradeoff.png

Figure: Figure 21: Trade-off between generated visual quality (FID) and spatial control accuracy (Optical Flow Error) on I2VGen-XL. Control guidance level of $x$ represents that we apply Ctrl-Adapter in the first $x\%$ of the denoising steps during inference. A control guidance level between $40\%$ and $60\%$ usually achieves the best balance between image quality and spatial control accuracy.
Refer to caption: x22.png

## Appendix G Additional Qualitative Analysis

### G.1 Visualization of Spatial Feature Maps

As mentioned in Sec. 3 and Sec. E.2, the spatial features encoded in the U-Net of ControlNets and the DiT blocks are structurally different. We visualize this difference in Fig. 22. For the DiT-based model, we use PixArt-$\alpha$ as a representative. We follow the visualization method mentioned in []. Specifically, we first extract the spatial features from different DiT blocks and U-Net middle/output blocks at the last denoising step during inference. For each block, we applied PCA to the extracted features and visualized the top three leading components.

As shown in Fig. 22, almost all 28 DiT blocks capture global and semantic information about the object "cactus". This observation is consistent with the findings in []. On the other hand, the U-Net blocks in ControlNet demonstrate a coarse-to-fine pattern as the feature map size increases. This indicates that mapping output blocks A/B of ControlNet to DiT blocks is a better option compared to using middle or output blocks C/D of the ControlNet.

Figure: Figure 22: Visualization of spatial feature maps in PixArt-$\alpha$ and canny edge ControlNet. We first extract the spatial features from different DiT blocks and U-Net middle/output blocks at the last denoising step during inference. For each block, we applied PCA to the extracted features and visualized the top three leading components. Almost all 28 DiT blocks capture global and semantic information about the object "cactus", while the U-Net blocks in ControlNet demonstrate a coarse-to-fine pattern as the feature map size increases.
Refer to caption: x24.png

### G.2 Fast Training Convergence

In addition to the quantitative results shown in Fig. 2, we provide a more straightforward visualization for SDXL depth ControlNet + Ctrl-Adapter training. The training speed test is performed on 4 A100 80GB GPUs, with a batch size of 1 per GPU. As shown in Fig. 23, for relatively easy examples (*i.e*., bedroom, sandwich, bus), our Ctrl-Adapter training can converge within 4.5 GPU hours (which is equivalent to around 1.125 hours measured in training clock time). For complex examples and those requiring fine details (*i.e*., surfing man, group of kids), our Ctrl-Adapter can also converge within around 6 to 7.5 GPU hours (which is equivalent to 1.5 to 1.875 hours measured in training clock time), which proves the training efficiency of our Ctrl-Adapter.

Figure: Figure 23: Training efficiency of Ctrl-Adapter on SDXL backbone. Total training GPU hours are measured on 4 A100 80GB GPUs, with batch size per GPU equal to 1.
Refer to caption: x25.png

## Appendix H Additional Visualization Examples

We provide more qualitative examples in this section.

### H.1 Video Generation Visualization Examples

In Fig. 24,
we show video generation results on COCO val2017 split using depth map and canny edge as control conditions. We visualize baseline methods as well as Ctrl-Adapters built on top of Hotshot-XL [], SVD [], I2VGen-XL [], and Latte [].

In Fig. 25 and Fig. 26, we show video generation results with I2VGen-XL using depth map and canny edge extracted from videos from Sora(^9^99[https://openai.com/sora](https://openai.com/sora)) and the internet.

In Fig. 27, we show video generation results with Latte using soft edge extracted from videos from Sora(^10^1010[https://openai.com/sora](https://openai.com/sora)) and the internet.

Figure: Figure 24: Videos generated from different video control methods and Ctrl-Adapter on DAVIS 2017, using depth map (left) and canny edge (right) conditions.
Refer to caption: x26.png

Figure: Figure 25: Video generation with I2VGen-XL + Ctrl-Adapter using depth map as a control condition.
Refer to caption: x27.png

Figure: Figure 26: Video generation with I2VGen-XL + Ctrl-Adapter using canny edge as control condition.
Refer to caption: x28.png

Figure: Figure 27: Video generation with Latte + Ctrl-Adapter using soft edge as control condition.
Refer to caption: x29.png

### H.2 Multi-Condition Video Generation Visualization Examples

Fig. 28 shows example videos generated with single and multiple conditions.
While all videos correctly capture the high-level dynamics of
‘a woman wearing purple strolling during sunset’,
the videos generated with more conditions show more robustness in several minor artifacts.
For example,
when only depth map is given (Fig. 28 a),
the building behind the person is blurred.
When depth map and human pose are given (Fig. 28 b),
the color of the purse changes from white to purple.
When four conditions (depth map, canny edge, human pose, and semantic segmentation) are given, such artifacts are removed (Fig. 28 c).

In Fig. 29, we show multi-condition control examples with I2VGen-XL.

Figure: Figure 28: Video generation from single and multiple conditions with Ctrl-Adapter on I2VGen-XL. (a) single condition: depth map; (b) 2 conditions: depth map + human pose; (c) 4 conditions: depth map + human pose + canny edge + semantic segmentation. Adding more conditions can help fix several minor artifacts (*e.g*., in (a) – building is blurred; in (b) – purse color changes).
Refer to caption: x30.png

Figure: Figure 29: Video generated with I2VGen-XL + Ctrl-Adapter from 4 control conditions: depth map + human pose + canny edge + semantic segmentation map.
Refer to caption: x31.png

### H.3 Image Generation Visualization Examples

In Fig. 30
and
Fig. 31,
we show image generation results on COCO val2017 split using depth map and canny edge as control conditions.

In
Fig. 32,
Fig. 33, and Fig. 34,
we show image generation results on
prompts from Lexica(^11^1111[https://lexica.art/](https://lexica.art/))
using depth map, canny edge, and soft edge as control conditions.

Figure: Figure 30: Image generation from different SDXL-based image control methods and Ctrl-Adapter on COCO val2017 split using depth map as control condition.
Refer to caption: x32.png

Figure: Figure 31: Image generation from different SDXL-based image control methods and Ctrl-Adapter on COCO val2017 split using canny edge as control condition.
Refer to caption: x33.png

Figure: Figure 32: Image generation with SDXL + Ctrl-Adapter using depth map as a control condition.
Refer to caption: x34.png

Figure: Figure 33: Image generation with SDXL + Ctrl-Adapter using canny edge as a control condition.
Refer to caption: x35.png

Figure: Figure 34: Image generation with PixArt-$\alpha$ + Ctrl-Adapter using soft edge as a control condition.
Refer to caption: x36.png

### H.4 Visualization Examples for Additional Downstream Tasks

Here, we describe in detail how our Ctrl-Adapter can be seamlessly integrated into a wide variety of downstream tasks including video editing, video style transfer, and text-guided motion control, as mentioned in Sec. 6. Additional visualizations are also shown in this part.

##### Video editing.

Video editing can be achieved by combining image and video Ctrl-Adapters. The procedure is as follows:

- •
Firstly, given a source video, we first extract the control condition(s). We can either extract a single control condition (*e.g*., depth map), or multiple control conditions (*e.g*., depth map, canny edge, segmentation, *etc*.) to enhance performance (as we observe in Sec. H.2 that multi-condition control improves spatial control accuracy) .
- •
Next, given a user-provided prompt together with the extracted control condition(s), we can use image Ctrl-Adapter (*i.e*., SDXL + Ctrl-Adapter) to generate the first frame of the video.
- •
Finally, we can use video Ctrl-Adapter (*i.e*., I2VGen-XL + Ctrl-Adapter), with the generated first frame image, text prompt, and extracted control conditions as inputs for final video generation.

In Fig. 35, we provide additional visualizations of the camel example in our main paper.

Figure: Figure 35: Video editing by combining SDXL and I2VGen-XL, where both models are equipped with spatial control via Ctrl-Adapter. First, we extract conditions (*e.g*., depth map) from the original video. Next, we create the initial frame with SDXL + Ctrl-Adapter. Lastly, we provide the newly generated initial frame and frame-wise conditions to I2VGen-XL + Ctrl-Adapter to obtain the final edited video. This video editing framework can edit both object and background.
Refer to caption: x37.png

##### Text-Guided Motion Control.

This task can be achieved by combining video Ctrl-Adapter with inpainting ControlNet. We train such Ctrl-Adapter as follows:

- •
Firstly, for each training video, we randomly select a random block in the image, with the width and height of the block uniformly sampled from $0.25$ to $0.75$ of the image size.
- •
Next, we color the block area of the video frames as black color (these processed frames can be regarded as control condition sequences like depth maps).
- •
Finally, we can train Ctrl-Adapter with the frozen inpainting ControlNet similar as other types of Ctrl-Adapters mentioned in our main paper.

In Fig. 36, we provide additional visualizations of text-guided image amination.

Figure: Figure 36: Text-guided motion control by combining inpainting ControlNet with I2VGen-XL + Ctrl-Adapter. Specifically, inpainting ControlNet takes the masked frames as well as text prompt as inputs. The output feature maps of inpainting ControlNet are then given to Ctrl-Adapter built on top of I2VGen-XL to generate the final video. Object(s) in the masked area can follow the motion described in the text prompt. The unmasked area can be either static or dynamic.
Refer to caption: x38.png

##### Video style transfer.

This task can be achieved by combining video Ctrl-Adapter with shuffle ControlNet. We train such Ctrl-Adapter as follows:

- •
Firstly, for the first frame of each training video, we apply the content shuffle detector implemented in the controlnet_aux(^12^1212[https://github.com/huggingface/controlnet_aux](https://github.com/huggingface/controlnet_aux)) library, to get a shuffled image.
- •
Next, we repeat this shuffled image $N$ times, with $N$ equal to the number of output frames of the backbone video diffusion model. These repeated images can be regarded as control condition sequences like depth maps.
- •
Finally, we can train Ctrl-Adapter with the frozen shuffle ControlNet similar as other types of Ctrl-Adapters mentioned in our main paper.

in Fig. 37, we provide additional visualizations of video style transfer.

Figure: Figure 37: Video style transfer by combining shuffle ControlNet with Latte + Ctrl-Adapter. Specifically, shuffle ControlNet takes the shuffled image as well as text prompt as inputs. The output feature maps of shuffle ControlNet are then given to Ctrl-Adapter built on top of Latte to generate the final video. The generated videos maintain similar style as the input image before shuffling.
Refer to caption: x39.png

## Appendix I Broader Impacts

Ctrl-Adapter is motivated by the fact that training ControlNets for new diffusion models, especially video diffusion models that need to consider temporal consistency, can be a huge burden for many users. As shown in Fig. 2, by adopting pretrained ControlNets, training Ctrl-Adapter can be significantly faster than training other controllable image or video generation methods. For example, with the same type of compute (*i.e*., A100 80GB GPUs), Ctrl-Adapter trained on SDXL depth ControlNet for 10 GPU hours can outperform SDXL ControlNet trained for 700 GPU hours. This drastically reduces the carbon emissions footprint by over 70 times.
Therefore, we believe that our work can be a strong contribution to efficient and controllable image and video generation.

While our framework can benefit numerous applications in controllable generation, similar to other image and video generation frameworks, it can also be used for potentially harmful purposes (e.g., creating false information or misleading videos). Therefore, it should be used with caution in real-world applications.

## Appendix J Limitations

Note that since Ctrl-Adapter is a method to equip current open-source image and video diffusion models with better control, its performance, quality, and potential visual artifacts largely depend on the capabilities (e.g., motion styles and video length) of the backbone models used.
For example, if a diffusion model cannot handle complex motions, Ctrl-Adapter built on top of this backbone might lead to non-optimal complex motion control.

## Appendix K License

We use standard licenses from the community
and provide the following links to the licenses for the datasets, codes, and models that we used in this
paper. For further information, please refer to the specific link.

PyTorch []: [BSD-style](https://github.com/pytorch/pytorch/blob/main/LICENSE)

HuggingFace Transformers []: [Apache License 2.0](https://github.com/huggingface/transformers/blob/main/LICENSE)

HuggingFace Diffusers []: [Apache License 2.0](https://github.com/huggingface/diffusers/blob/main/LICENSE)

ControlNet []: [Apache License 2.0](https://github.com/lllyasviel/ControlNet?tab=Apache-2.0-1-ov-file)

SDXL []: [MiT License](https://github.com/Stability-AI/generative-models?tab=MIT-1-ov-file)

PixArt-$\alpha$ []: [AGPL-3.0 License](https://github.com/PixArt-alpha/PixArt-alpha?tab=AGPL-3.0-1-ov-file)

I2VGen-XL []: [MiT License](https://huggingface.co/ali-vilab/i2vgen-xl)

Stable Video Diffusion (SVD) []: [MiT License](https://github.com/Stability-AI/generative-models?tab=MIT-1-ov-file)

Latte []: [Apache License 2.0](https://github.com/Vchitect/Latte/blob/main/LICENSE)

Hotshot-XL []: [Apache License 2.0](https://github.com/hotshotco/Hotshot-XL/blob/main/LICENSE)

LAION dataset []: [MiT License](https://github.com/LAION-AI/laion-datasets/blob/main/LICENSE)

Panda70M dataset []: [License](https://github.com/snap-research/Panda-70M/blob/main/LICENSE)

COCO dataset []: [CC BY 4.0](https://cocodataset.org/#termsofuse)

DAVIS 2017 dataset []: [CC BY 4.0](https://davischallenge.org/challenge2017/rulesdates.html)

## Peer Reviews

confidence: 3
contribution: 4
initial_rating: 8
presentation: 2
questions: Additional comments (no need to address):
- typo in in L069 "Controlnet a cannot"
soundness: 4
strengths: - The results proposed in the paper are interesting and convincing. 
- Adapting pre-trained ControlNets to new diffusion frameworks including videos is interesting and the method is novel. 
- The paper is well written and the experiments to validate the proposed method are significant. 
- The code is provided.
summary: The paper proposes an efficient method for adapting pretrained ControlNets to various image and video diffusion frameworks. The authors also proposed a mixture of expert method for multi conditioning, and a mapping between discrete and continuous diffusion timesteps. Overall, the paper address an important problem (adapting pre-trained ControlNets efficiently), provide useful insights and achieves superior results.
weaknesses: - Poor presentation: the main paper is packed with experiments but lacks many essential details about the method such as the adapter architecture, more details about the MoE method, etc. 
- Unjustified architecture choices: the authors proposed to use a 1-1 mapping between the ControlNet layer to ones with similar dimension in the new diffusion model. This assumes that these layers learn similar features but the authors did not touch on this topic or justified their choices. 
- What is the rational behind conditioning the CTRL-Adapter with the first frame? How does the proposed method perform without such conditioning?

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 4
questions: Please see weaknesses
soundness: 3
strengths: + The presentation and writing quality of this manuscript are are generally strong and well-structured.
+ The framework supports a wide range of applications, from image and video control to video editing and style transfer.
+ CTRL-Adapter requires fewer computational resources. This method significantly reduces the training time, outperforming baselines in less than 10 GPU hours
+ The authors provide comprehensive experiments that validate the performance of CTRL-Adapter.
summary: This paper introduces a new framework called CTRL-Adapter, aimed at enhancing the control capabilities of image and video diffusion models. By adapting pretrained ControlNets, CTRL-Adapter allows for the efficient integration of various control conditions into new diffusion models, supporting image control, video control, and sparse frame control. The results demonstrate that CTRL-Adapter maintains high performance on various datasets with significantly reduced computational costs compared to training ControlNets from scratch.
weaknesses: + While skipping latents can increase efficiency, it may inadvertently lead to loss of fine-grained detail in frames without direct conditioning. I'm wondering if there are any issues with this method that I'm concerned about?
+ Providing more detailed results from an ablation study about Weaknesses 1 could offer valuable insights into the impact of this strategy. It could reveal conditions where skipping latents is beneficial versus scenarios where it may compromise quality.
+ Whether skipping latents reduces the ability of the CTRL-Adapter to generalize between certain control types.
+ In my experience, the most significant advantage of this work is the value of a wide range of applications. In terms of technical contributions, it seems to extend multiple adapters in various generative models. Could the authors provide more elaboration on the technical contribution or insights?

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. What is the additional inference cost associated with using multiple condition ControlNets along with their corresponding control adapters, for example, when handling seven different conditions in Table 3? While the paper mentions significant reductions in training costs by focusing on adapting image-based ControlNets for video tasks, how does the increase in inference complexity, due to maintaining multiple controls, impact overall efficiency and performance? 

2. Would integrating control adapters directly inside each ControlNet simplify the adaptation process and make it more efficient, like a fine-tuning task from image to video ControlNet? Could this approach be a viable and efficient baseline, particularly for single-condition scenarios?
soundness: 3
strengths: 1. The proposed method stands out for its simplicity and efficiency. It presents a cost-effective approach to adapting image-based ControlNet models for video-based applications. It also offers valuable insights into merging multiple conditions using three strategic choices. It incorporates a fine-grained, patch-level Mixture of Experts (MoE) routing to enhance the generation process by enabling precise and adaptive control over features.

2. The evaluation is thorough and well-executed, providing extensive comparisons across both single-condition and multi-condition video generation. Additionally, it demonstrates the model's versatility by showcasing its performance on tasks such as video editing, style transfer, and text-guided object motion control, highlighting its wide applicability.

3. The paper is exceptionally well-written, with a logical and coherent structure that ensures ease of understanding.
summary: CTRL-Adapter is an efficient and versatile framework designed to integrate diverse controls into image and video diffusion models by adapting pretrained ControlNets. This method achieves comparable performance to training ControlNet from scratch while significantly reducing training costs. It introduces fine-grained, patch-level MoE (Mixture of Experts) routing to compose ControlNet features more effectively, as opposed to prior methods that operate only at the image or frame level. CTRL-Adapter is compatible with both UNet-based and DiT-based backbones, continuous timestep samplers, and varying noise scales. Extensive experiments demonstrate that CTRL-Adapter performs well on image and video generation and can be applied to various tasks, including video editing, style transfer, and text-guided object motion control.
weaknesses: 1. The comparison of training costs might not be entirely fair. Since the CTRL-Adapter leverages a pre-trained image ControlNet and then adapts it for video tasks, it benefits from the substantial pre-training cost in the image control task. Given that the image ControlNet is already proficient at extracting information from various conditions, this adaptation should inherently be faster. Therefore, when evaluating training efficiency, it is crucial to account for the advantages gained from the pre-trained ControlNet. 

2. The explanation of how multiple conditions are integrated in the proposed method could be clearer and more detailed. The paper briefly outlines three possible integration strategies in a single paragraph, accompanied by a figure, which might be insufficient for comprehending the intricacies involved. This section deserves more space and elaboration in the main text rather than being relegated to the appendix.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: See weakness part. Overall, I lean to accept the paper. I need more explanation compared to X-Adapter in the technical side: (1) the architecture difference; (2) the training difference; (3) explain what is the performance and training speed come from.
soundness: 3
strengths: - The major technical contribution is to extend X-Adapter by involving temporal convolutions for the support of adapting from image to video. 

- There are a bunch of engineering contributions to improve performance: (1) the utilization of Q-former; (2) skipping latents; (3) handling noise scheduling shift.

- A really extensive experiments to demonstrate the strength of their work in various scenarios: single condition, multi conditions, zero-shot, from image to image, from image to video.
summary: This work Ctrl-Adapter extends X-Adapter to a more general setting: the pretrained ControlNet and downstream diffusion models can now differ in modality (images, videos) and architecture (e.g., UNet or Transformers). The authors show in extensive experiments that Ctrl-Adapter works well in many scenarios and outperforms X-Adapter.
weaknesses: 1.	Overall, the writing could be improved to enhance clarity. The methodology section should be more focused and closely aligned with the key contributions. Currently, it is cluttered with engineering details and lacks mathematical formulation, which makes it harder to grasp the technical novelty.

2.	Does skipping latent require retraining ControlNet? 

3.	The Multi-ControlNet setup is unclear:
	•	Are six conditions trained simultaneously in each iteration?
	•	In Section 4.5, Figure 8 (zero-shot results), the zero-shot inferences under different conditions do not appear to align accurately with the intended conditions, which is understandable since they were not trained on these. However, could you provide an example without ControlNet for comparison? Could you also add quantitative results for the zero-shot experiment in Table 4? (Consider adding a row for models trained solely on depth but applied to other conditions, and a row with plain diffusion without ControlNet as a baseline for comparison.)

4.  What is architecture difference with X-Adapter? What is the training speed improvement over X-Adapter come from?

Meta-review: The paper introduces the CTRL adapter that adapts the pre-trained ControlNets to the new backbones in image and video generation. It allows to use a mixture of ControlNets for conditioning on multiple control signals. The authors provide comprehensive experiments on multiple applications, such as video editing, style transfer, and text-guided object motion control. The paper addresses an important problem of incorporating controls into image/video generative models in the computationally-efficient manner. I recommend the paper for Accept (Oral).

Decision: Accept (Oral)