# SD3ControlNetModel

SD3ControlNetModel est une implémentation de ControlNet pour Stable Diffusion 3.

Le modèle ControlNet a été introduit dans [Adding Conditional Control to Text-to-Image Diffusion Models](https://huggingface.co/papers/2302.05543) par Lvmin Zhang, Anyi Rao et Maneesh Agrawala. Il offre un degré de contrôle supérieur sur la génération d’images à partir de texte en conditionnant le modèle sur des entrées supplémentaires telles que des cartes de contours, des cartes de profondeur, des cartes de segmentation et des points clés pour la détection de pose.

L'abstract de l'article est :

*Nous présentons ControlNet, une architecture de réseau de neurones permettant d’ajouter des contrôles de conditionnement spatial à de grands modèles de diffusion texte-vers-image pré-entraînés. ControlNet verrouille les grands modèles de diffusion prêts pour la production et réutilise leurs couches d’encodage profondes et robustes, pré-entraînées sur des milliards d’images, comme un socle solide pour apprendre un ensemble varié de contrôles conditionnels. L’architecture neuronale est connectée par des « zéro convolutions » (couches de convolution initialisées à zéro) qui font progressivement croître les paramètres depuis zéro et garantissent qu’aucun bruit nuisible ne puisse affecter l’ajustement fin. Nous testons divers contrôles de conditionnement, par exemple les contours, la profondeur, la segmentation, la pose humaine, etc., avec Stable Diffusion, en utilisant une ou plusieurs conditions, avec ou sans prompts. Nous montrons que l’entraînement des ControlNets est robuste avec des jeux de données petits (<50k) et grands (>1m). Des résultats étendus montrent que ControlNet peut faciliter des applications plus larges pour contrôler les modèles de diffusion d’images.*

## Chargement depuis le format d'origine

Par défaut, le [SD3ControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet_sd3#diffusers.SD3ControlNetModel) doit être chargé avec [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.from_pretrained).

```py
from diffusers import StableDiffusion3ControlNetPipeline
from diffusers.models import SD3ControlNetModel, SD3MultiControlNetModel

controlnet = SD3ControlNetModel.from_pretrained("InstantX/SD3-Controlnet-Canny")
pipe = StableDiffusion3ControlNetPipeline.from_pretrained("stabilityai/stable-diffusion-3-medium-diffusers", controlnet=controlnet)
```

## SD3ControlNetModel[[diffusers.SD3ControlNetModel]]

#### diffusers.SD3ControlNetModel[[diffusers.SD3ControlNetModel]]

```python
diffusers.SD3ControlNetModel(sample_size: int = 128, patch_size: int = 2, in_channels: int = 16, num_layers: int = 18, attention_head_dim: int = 64, num_attention_heads: int = 18, joint_attention_dim: int = 4096, caption_projection_dim: int = 1152, pooled_projection_dim: int = 2048, out_channels: int = 16, pos_embed_max_size: int = 96, extra_conditioning_channels: int = 0, dual_attention_layers: tuple[int, ...] = (), qk_norm: str | None = None, pos_embed_type: str | None = 'sincos', use_pos_embed: bool = True, force_zeros_for_pooled_projection: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet_sd3.py#L42)

**Paramètres :**

sample_size (`int`, par défaut `128`) : La largeur/hauteur des latents. Cette valeur est fixe pendant l'entraînement, car elle est utilisée pour apprendre un nombre d'embeddings de position.

patch_size (`int`, par défaut `2`) : Taille des patches pour découper les données d'entrée en petits patches.

in_channels (`int`, par défaut `16`) : Le nombre de canaux latents dans l'entrée.

num_layers (`int`, par défaut `18`) : Le nombre de blocs de transformeurs à utiliser.

attention_head_dim (`int`, par défaut `64`) : Le nombre de canaux dans chaque tête.

num_attention_heads (`int`, par défaut `18`) : Le nombre de têtes à utiliser pour l'attention multi-têtes.

joint_attention_dim (`int`, par défaut `4096`) : La dimension d'embedding à utiliser pour l'attention conjointe texte-image.

caption_projection_dim (`int`, par défaut `1152`) : La dimension d'incorporation des incorporations de légendes.

pooled_projection_dim (`int`, par défaut `2048`) : La dimension d'incorporation des projections de texte agrégées.

out_channels (`int`, par défaut `16`) : Le nombre de canaux latents dans la sortie.

pos_embed_max_size (`int`, par défaut `96`) : La hauteur/largeur latente maximale des embeddings positionnels.

extra_conditioning_channels (`int`, par défaut `0`) : Le nombre de canaux supplémentaires à utiliser pour le conditionnement de l'incorporation de patchs.

dual_attention_layers (`tuple[int, ...]`, par défaut `()`) : Le nombre de blocs de transformateur à double flux à utiliser.

qk_norm (`str`, *facultatif*, valeur par défaut `None`) : La normalisation à utiliser pour la requête et la clé dans la couche d'attention. Si `None`, aucune normalisation n'est utilisée.

pos_embed_type (`str`, par défaut `"sincos"`) : Le type d'incorporation positionnelle à utiliser. Choisissez entre `"sincos"` et `None`.

use_pos_embed (`bool`, par défaut `True`) : Indique s'il faut utiliser des embeddings positionnels.

force_zeros_for_pooled_projection (`bool`, par défaut `True`) : Indique s'il faut forcer des zéros pour les embeddings de projection poolée. Cela est géré dans les pipelines en lisant la valeur de configuration du modèle ControlNet.

Modèle ControlNet pour [Stable Diffusion 3](https://huggingface.co/papers/2403.03206).

#### enable_forward_chunking[[diffusers.SD3ControlNetModel.enable_forward_chunking]]

```python
enable_forward_chunking(chunk_size: int | None = None, dim: int = 0)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet_sd3.py#L178)

**Paramètres :**

chunk_size (`int`, *facultatif*) : La taille des blocs des couches feed-forward. Si non spécifiée, la couche feed-forward est exécutée individuellement sur chaque tenseur de dim=`dim`.

dim (`int`, *facultatif*, par défaut `0`) : La dimension sur laquelle le calcul feed-forward doit être découpé. Choisissez entre dim=0 (batch) ou dim=1 (longueur de séquence).

Définit le processeur d'attention à utiliser [feed forward chunking](https://huggingface.co/blog/reformer#2-chunked-feed-forward-layers).

#### forward[[diffusers.SD3ControlNetModel.forward]]

```python
forward(hidden_states: Tensor, controlnet_cond: Tensor, conditioning_scale: float = 1.0, encoder_hidden_states: Tensor = None, pooled_projections: Tensor = None, timestep: LongTensor = None, joint_attention_kwargs: dict[str, typing.Any] | None = None, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet_sd3.py#L272)

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch size, channel, height, width)`) : `hidden_states` en entrée.

controlnet_cond (`torch.Tensor`) : Le tenseur d'entrée conditionnel de forme `(batch_size, sequence_length, hidden_size)`.

conditioning_scale (`float`, par défaut `1.0`) : Le facteur d'échelle pour les sorties de ControlNet.

encoder_hidden_states (`torch.Tensor` de forme `(batch size, sequence_len, embed_dims)`) : Embeddings conditionnels (embeddings calculés à partir des conditions d'entrée telles que les prompts) à utiliser.

pooled_projections (`torch.Tensor` de forme `(batch_size, projection_dim)`) : Embeddings projetés à partir des embeddings des conditions d'entrée.

timestep ( `torch.LongTensor`) : Utilisé pour indiquer l'étape de débruitage.

joint_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~models.transformer_2d.Transformer2DModelOutput` plutôt qu'un simple tuple.

**Retourne :**

Si `return_dict` est True, un `~models.transformer_2d.Transformer2DModelOutput` est renvoyé, sinon un `tuple` dont le premier élément est le tenseur d'échantillon.

La méthode forward du [SD3Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel).

#### fuse_qkv_projections[[diffusers.SD3ControlNetModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet_sd3.py#L208)

Active les projections QKV fusionnées. Pour les modules d'auto-attention, toutes les matrices de projection (c'est-à-dire requête, clé, valeur) sont fusionnées. Pour les modules d'attention croisée, les matrices de projection des clés et des valeurs sont fusionnées.

> [!WARNING] > Cette API est 🧪 expérimentale.

#### unfuse_qkv_projections[[diffusers.SD3ControlNetModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet_sd3.py#L230)

Désactive la projection QKV fusionnée si elle est activée.

> [!WARNING] > Cette API est 🧪 expérimentale.

## SD3ControlNetOutput[[diffusers.models.controlnets.SD3ControlNetOutput]]

#### diffusers.models.controlnets.SD3ControlNetOutput[[diffusers.models.controlnets.SD3ControlNetOutput]]

```python
diffusers.models.controlnets.SD3ControlNetOutput(controlnet_block_samples: tuple[torch.Tensor])
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet_sd3.py#L38)