# FluxControlNetModel

FluxControlNetModel est une implémentation de ControlNet pour Flux.1.

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 [FluxControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet_flux#diffusers.FluxControlNetModel) doit être chargé avec [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.from_pretrained).

```py
from diffusers import FluxControlNetPipeline
from diffusers.models import FluxControlNetModel, FluxMultiControlNetModel

controlnet = FluxControlNetModel.from_pretrained("InstantX/FLUX.1-dev-Controlnet-Canny")
pipe = FluxControlNetPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", controlnet=controlnet)

controlnet = FluxControlNetModel.from_pretrained("InstantX/FLUX.1-dev-Controlnet-Canny")
controlnet = FluxMultiControlNetModel([controlnet])
pipe = FluxControlNetPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", controlnet=controlnet)
```

## FluxControlNetModel[[diffusers.FluxControlNetModel]]

#### diffusers.FluxControlNetModel[[diffusers.FluxControlNetModel]]

```python
diffusers.FluxControlNetModel(patch_size: int = 1, in_channels: int = 64, num_layers: int = 19, num_single_layers: int = 38, attention_head_dim: int = 128, num_attention_heads: int = 24, joint_attention_dim: int = 4096, pooled_projection_dim: int = 768, guidance_embeds: bool = False, axes_dims_rope: list[int] = [16, 56, 56], num_mode: int = None, conditioning_embedding_channels: int = None)
```

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

#### forward[[diffusers.FluxControlNetModel.forward]]

```python
forward(hidden_states: Tensor, controlnet_cond: Tensor, controlnet_mode: Tensor = None, conditioning_scale: float = 1.0, encoder_hidden_states: Tensor = None, pooled_projections: Tensor = None, timestep: LongTensor = None, img_ids: Tensor = None, txt_ids: Tensor = None, guidance: Tensor = 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_flux.py#L157)

**Paramètres :**

hidden_states (`torch.FloatTensor` 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)`.

controlnet_mode (`torch.Tensor`) : Le tenseur de mode de forme `(batch_size, 1)`.

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

encoder_hidden_states (`torch.FloatTensor` 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.FloatTensor` 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.

img_ids (`torch.Tensor`) : Identifiants positionnels pour les jetons d'image.

txt_ids (`torch.Tensor`) : Identifiants positionnels pour les jetons de texte.

guidance (`torch.Tensor`, *facultatif*) : Tenseur d'échelle de guidage utilisé par les variantes du modèle distillées par guidage.

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 [FluxTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel).

## FluxControlNetOutput[[diffusers.models.controlnets.FluxControlNetOutput]]

#### diffusers.models.controlnets.FluxControlNetOutput[[diffusers.models.controlnets.FluxControlNetOutput]]

```python
diffusers.models.controlnets.FluxControlNetOutput(controlnet_block_samples: tuple[torch.Tensor], controlnet_single_block_samples: tuple[torch.Tensor])
```

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