Buckets:
| # ControlNetModel | |
| 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 [ControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet#diffusers.ControlNetModel) doit être chargé avec [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.from_pretrained), mais il peut également être chargé depuis le format d'origine à l'aide de `FromOriginalModelMixin.from_single_file` comme suit : | |
| ```py | |
| from diffusers import StableDiffusionControlNetPipeline, ControlNetModel | |
| url = "https://huggingface.co/lllyasviel/ControlNet-v1-1/blob/main/control_v11p_sd15_canny.pth" # can also be a local path | |
| controlnet = ControlNetModel.from_single_file(url) | |
| url = "https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5/blob/main/v1-5-pruned.safetensors" # can also be a local path | |
| pipe = StableDiffusionControlNetPipeline.from_single_file(url, controlnet=controlnet) | |
| ``` | |
| ## Chargement depuis Control LoRA | |
| Control-LoRA est introduit par Stability AI dans [stabilityai/control-lora](https://huggingface.co/stabilityai/control-lora) en ajoutant un fine-tuning efficace en paramètres de faible rang à ControlNet. Cette approche offre une méthode plus efficace et compacte pour apporter le contrôle du modèle à une plus grande variété de GPU grand public. | |
| ```py | |
| from diffusers import ControlNetModel, UNet2DConditionModel | |
| lora_id = "stabilityai/control-lora" | |
| lora_filename = "control-LoRAs-rank128/control-lora-canny-rank128.safetensors" | |
| unet = UNet2DConditionModel.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu" | |
| controlnet = ControlNetModel.from_unet(unet).to(device="cuda", dtype=torch.bfloat16) | |
| controlnet.load_lora_adapter(lora_id, weight_name=lora_filename, prefix=None, controlnet_config=controlnet.config) | |
| ``` | |
| ## ControlNetModel[[diffusers.ControlNetModel]] | |
| #### diffusers.ControlNetModel[[diffusers.ControlNetModel]] | |
| ```python | |
| diffusers.ControlNetModel(in_channels: int = 4, conditioning_channels: int = 3, flip_sin_to_cos: bool = True, freq_shift: int = 0, down_block_types: tuple[str, ...] = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str | None = 'UNetMidBlock2DCrossAttn', only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple[int, ...] = (320, 640, 1280, 1280), layers_per_block: int = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int = 1280, transformer_layers_per_block: int | tuple[int, ...] = 1, encoder_hid_dim: int | None = None, encoder_hid_dim_type: str | None = None, attention_head_dim: int | tuple[int, ...] = 8, num_attention_heads: int | tuple[int, ...] | None = None, use_linear_projection: bool = False, class_embed_type: str | None = None, addition_embed_type: str | None = None, addition_time_embed_dim: int | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', projection_class_embeddings_input_dim: int | None = None, controlnet_conditioning_channel_order: str = 'rgb', conditioning_embedding_out_channels: tuple[int, ...] | None = (16, 32, 96, 256), global_pool_conditions: bool = False, addition_embed_type_num_heads: int = 64) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet.py#L111) | |
| **Paramètres :** | |
| in_channels (`int`, par défaut 4) : Le nombre de canaux dans l'échantillon d'entrée. | |
| flip_sin_to_cos (`bool`, par défaut `True`) : Indique s'il faut inverser le sin en cos dans l'encodage temporel. | |
| freq_shift (`int`, par défaut 0) : Le décalage de fréquence à appliquer à l'embedding temporel. | |
| down_block_types (`tuple[str]`, par défaut `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : Le tuple de blocs de downsampling à utiliser. | |
| only_cross_attention (`bool | tuple[bool]`, par défaut `False`) -- | |
| block_out_channels (`tuple[int]`, par défaut `(320, 640, 1280, 1280)`) : Le tuple des canaux de sortie pour chaque bloc. | |
| layers_per_block (`int`, par défaut 2) : Le nombre de couches par bloc. | |
| downsample_padding (`int`, par défaut 1) : Le padding à utiliser pour la convolution de downsampling. | |
| mid_block_scale_factor (`float`, par défaut 1) : Le facteur d'échelle à utiliser pour le bloc intermédiaire. | |
| act_fn (`str`, par défaut "silu") : La fonction d'activation à utiliser. | |
| norm_num_groups (`int`, *facultatif*, valeur par défaut 32) : Le nombre de groupes à utiliser pour la normalisation. Si None, les couches de normalisation et d'activation sont ignorées lors du post-traitement. | |
| norm_eps (`float`, par défaut 1e-5) : L'épsilon à utiliser pour la normalisation. | |
| cross_attention_dim (`int`, par défaut 1280) : La dimension des fonctionnalités d'attention croisée. | |
| transformer_layers_per_block (`int` ou `tuple[int]`, *facultatif*, valeur par défaut 1) : Le nombre de blocs de transformateur de type `BasicTransformerBlock`. Ne concerne que `~models.unet_2d_blocks.CrossAttnDownBlock2D`, `~models.unet_2d_blocks.CrossAttnUpBlock2D`, `~models.unet_2d_blocks.UNetMidBlock2DCrossAttn`. | |
| encoder_hid_dim (`int`, *facultatif*, valeur par défaut None) : Si `encoder_hid_dim_type` est défini, `encoder_hidden_states` sera projeté de la dimension `encoder_hid_dim` vers `cross_attention_dim`. | |
| encoder_hid_dim_type (`str`, *facultatif*, par défaut `None`) : Si fourni, les `encoder_hidden_states` et d'autres embeddings éventuels sont projetés vers des embeddings de texte de dimension `cross_attention` selon `encoder_hid_dim_type`. | |
| attention_head_dim (`int | tuple[int]`, par défaut 8) : La dimension des têtes d'attention. | |
| use_linear_projection (`bool`, par défaut `False`) -- | |
| class_embed_type (`str`, *facultatif*, valeur par défaut `None`) : Le type d'embedding de classe à utiliser, qui est finalement additionné aux embeddings temporels. Choisissez parmi None, `"timestep"`, `"identity"`, `"projection"` ou `"simple_projection"`. | |
| addition_embed_type (`str`, *facultatif*, valeur par défaut `None`) : Configure un embedding facultatif qui sera additionné aux embeddings temporels. Choisissez entre `None` et "text". "text" utilisera la couche `TextTimeEmbedding`. | |
| num_class_embeds (`int`, *facultatif*, valeur par défaut 0) : Dimension d'entrée de la matrice d'incorporation apprenable à projeter vers `time_embed_dim`, lors de l'utilisation d'un conditionnement par classe avec `class_embed_type` égal à `None`. | |
| upcast_attention (`bool`, par défaut `False`) -- | |
| resnet_time_scale_shift (`str`, par défaut `"default"`) : Configuration du décalage de l'échelle temporelle pour les blocs ResNet (voir `ResnetBlock2D`). Choisissez entre `default` et `scale_shift`. | |
| projection_class_embeddings_input_dim (`int`, *facultatif*, par défaut `None`) : La dimension de l'entrée `class_labels` lorsque `class_embed_type="projection"`. Obligatoire lorsque `class_embed_type="projection"`. | |
| controlnet_conditioning_channel_order (`str`, par défaut `"rgb"`) : L'ordre des canaux de l'image conditionnelle. Sera converti en `rgb` s'il est `bgr`. | |
| conditioning_embedding_out_channels (`tuple[int]`, *facultatif*, par défaut `(16, 32, 96, 256)`) : Le tuple des canaux de sortie pour chaque bloc de la couche `conditioning_embedding`. | |
| global_pool_conditions (`bool`, par défaut `False`) : TODO(Patrick) - paramètre inutilisé. | |
| addition_embed_type_num_heads (`int`, par défaut 64) : Le nombre de têtes à utiliser pour la couche `TextTimeEmbedding`. | |
| Un modèle ControlNet. | |
| #### forward[[diffusers.ControlNetModel.forward]] | |
| ```python | |
| forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, controlnet_cond: Tensor, conditioning_scale: float = 1.0, class_labels: typing.Optional[torch.Tensor] = None, timestep_cond: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, added_cond_kwargs: dict[str, torch.Tensor] | None = None, cross_attention_kwargs: dict[str, typing.Any] | None = None, guess_mode: bool = False, return_dict: bool = True) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet.py#L602) | |
| **Paramètres :** | |
| sample (`torch.Tensor`) : Le tenseur d'entrée bruité. | |
| timestep (`torch.Tensor | float | int`) : Le nombre de pas de temps pour débruitiser une entrée. | |
| encoder_hidden_states (`torch.Tensor`) : Les états cachés de l'encodeur. | |
| 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. | |
| class_labels (`torch.Tensor`, *facultatif*, valeur par défaut `None`) : Étiquettes de classe optionnelles pour le conditionnement. Leurs embeddings seront additionnés aux embeddings du timestep. | |
| timestep_cond (`torch.Tensor`, *facultatif*, valeur par défaut `None`) : Incrustations conditionnelles supplémentaires pour le pas de temps. Si fournies, les incrustations seront additionnées à la timestep_embedding transmise à travers la couche `self.time_embedding` pour obtenir les incrustations de pas de temps finales. | |
| attention_mask (`torch.Tensor`, *facultatif*, par défaut `None`) : Un masque d'attention de forme `(batch, key_tokens)` est appliqué à `encoder_hidden_states`. Si la valeur est `1`, le masque est conservé ; sinon, si elle est `0`, il est ignoré. Le masque est converti en biais, qui ajoute de grandes valeurs négatives aux scores d'attention correspondant aux jetons « ignorés ». | |
| added_cond_kwargs (`dict`) : Conditions supplémentaires pour le UNet de Stable Diffusion XL. | |
| cross_attention_kwargs (`dict[str]`, *facultatif*, par défaut `None`) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis au `AttnProcessor`. | |
| guess_mode (`bool`, par défaut `False`) : Dans ce mode, l'encodeur ControlNet fait de son mieux pour reconnaître le contenu de l'entrée, même si vous supprimez tous les prompts. Un `guidance_scale` compris entre 3,0 et 5,0 est recommandé. | |
| return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un [ControlNetOutput](/docs/diffusers/v0.43.0/fr/api/models/controlnet#diffusers.models.controlnets.ControlNetOutput) plutôt qu'un simple tuple. | |
| **Retourne :** [ControlNetOutput](/docs/diffusers/v0.43.0/fr/api/models/controlnet#diffusers.models.controlnets.ControlNetOutput) **ou** `tuple` | |
| Si `return_dict` est `True`, un [ControlNetOutput](/docs/diffusers/v0.43.0/fr/api/models/controlnet#diffusers.models.controlnets.ControlNetOutput) est renvoyé, sinon un tuple est renvoyé dont le premier élément est le tenseur d’échantillon. | |
| La méthode forward du [ControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet#diffusers.ControlNetModel). | |
| #### from_unet[[diffusers.ControlNetModel.from_unet]] | |
| ```python | |
| from_unet(unet: UNet2DConditionModel, controlnet_conditioning_channel_order: str = 'rgb', conditioning_embedding_out_channels: tuple[int, ...] | None = (16, 32, 96, 256), load_weights_from_unet: bool = True, conditioning_channels: int = 3) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet.py#L444) | |
| **Paramètres :** | |
| unet (`UNet2DConditionModel`) : Les poids du modèle UNet à copier vers le [ControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet#diffusers.ControlNetModel). Toutes les options de configuration sont également copiées lorsque cela est applicable. | |
| Instanciez un [ControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet#diffusers.ControlNetModel) à partir de [UNet2DConditionModel](/docs/diffusers/v0.43.0/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel). | |
| #### set_attention_slice[[diffusers.ControlNetModel.set_attention_slice]] | |
| ```python | |
| set_attention_slice(slice_size: str | int | list[int]) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet.py#L537) | |
| **Paramètres :** | |
| slice_size (`str` ou `int` ou `list(int)`, *facultatif*, par défaut `"auto"`) : lorsque la valeur est `"auto"`, l’entrée des têtes d’attention est divisée par deux, de sorte que l’attention est calculée en deux étapes. Si la valeur est `"max"`, la quantité maximale de mémoire est économisée en n’exécutant qu’une seule tranche à la fois. Si un nombre est fourni, autant de tranches sont utilisées que `attention_head_dim // slice_size`. Dans ce cas, `attention_head_dim` doit être un multiple de `slice_size`. | |
| Activer le calcul de l'attention par tranches. | |
| Lorsque cette option est activée, le module d'attention divise le tenseur d'entrée en tranches pour calculer l'attention en plusieurs étapes. Cela est utile pour économiser de la mémoire au prix d'une légère diminution de la vitesse. | |
| #### set_default_attn_processor[[diffusers.ControlNetModel.set_default_attn_processor]] | |
| ```python | |
| set_default_attn_processor() | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet.py#L521) | |
| Désactive les processeurs d'attention personnalisés et définit l'implémentation d'attention par défaut. | |
| ## ControlNetOutput[[diffusers.models.controlnets.ControlNetOutput]] | |
| #### diffusers.models.controlnets.ControlNetOutput[[diffusers.models.controlnets.ControlNetOutput]] | |
| ```python | |
| diffusers.models.controlnets.ControlNetOutput(down_block_res_samples: tuple[torch.Tensor], mid_block_res_sample: Tensor) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/controlnets/controlnet.py#L47) | |
| **Paramètres :** | |
| down_block_res_samples (`tuple[torch.Tensor]`) : Un tuple d'activations de downsampling à différentes résolutions pour chaque bloc de downsampling. Chaque tenseur doit avoir la forme `(batch_size, channel * resolution, height //resolution, width // resolution)`. La sortie peut être utilisée pour conditionner les activations de downsampling du UNet d'origine. | |
| mid_down_block_re_sample (`torch.Tensor`) : L'activation du bloc central (la résolution d'échantillonnage la plus basse). Chaque tenseur doit avoir la forme `(batch_size, channel * lowest_resolution, height // lowest_resolution, width // lowest_resolution)`. La sortie peut être utilisée pour conditionner l'activation du bloc central du UNet d'origine. | |
| La sortie de [ControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet#diffusers.ControlNetModel). | |
Xet Storage Details
- Size:
- 16.5 kB
- Xet hash:
- 333c1a2341b7138e7e4cee5c8003afbbb3aa430f788c0c89b6148875ae95e0c7
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.