diffusers/v0.43.0/fr/api/models/controlnet_sd3.md

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 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 doit être chargé avec from_pretrained().

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]]

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

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.

enable_forward_chunking[[diffusers.SD3ControlNetModel.enable_forward_chunking]]

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

Source

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.

forward[[diffusers.SD3ControlNetModel.forward]]

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

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.

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.

fuse_qkv_projections[[diffusers.SD3ControlNetModel.fuse_qkv_projections]]

fuse_qkv_projections()

Source

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.

> Cette API est 🧪 expérimentale.

unfuse_qkv_projections[[diffusers.SD3ControlNetModel.unfuse_qkv_projections]]

unfuse_qkv_projections()

Source

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

> Cette API est 🧪 expérimentale.

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

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

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

Source