# ControlNet avec Stable Diffusion 3 StableDiffusion3ControlNetPipeline est une implémentation de ControlNet pour Stable Diffusion 3. 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. Avec un modèle ControlNet, vous pouvez fournir une image de contrôle supplémentaire pour conditionner et contrôler la génération de Stable Diffusion. Par exemple, si vous fournissez une carte de profondeur, le modèle ControlNet génère une image qui préserve les informations spatiales de la carte de profondeur. C'est une méthode plus flexible et plus précise pour contrôler le processus de génération d'images. 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.* Ce code de ControlNet est principalement implémenté par [The InstantX Team](https://huggingface.co/InstantX). Le code lié à l'inpainting a été développé par [The Alimama Creative Team](https://huggingface.co/alimama-creative). Vous pouvez trouver des points de contrôle pré-entraînés pour SD3-ControlNet dans le tableau ci-dessous : | Type de ControlNet | Développeur | Lien | | -------- | ---------- | ---- | | Canny | [L'équipe InstantX](https://huggingface.co/InstantX) | [Lien](https://huggingface.co/InstantX/SD3-Controlnet-Canny) | | Profondeur | [L'équipe InstantX](https://huggingface.co/InstantX) | [Lien](https://huggingface.co/InstantX/SD3-Controlnet-Depth) | | Pose | [L'équipe InstantX](https://huggingface.co/InstantX) | [Lien](https://huggingface.co/InstantX/SD3-Controlnet-Pose) | | Tuile | [L'équipe InstantX](https://huggingface.co/InstantX) | [Lien](https://huggingface.co/InstantX/SD3-Controlnet-Tile) | | Inpainting | [L'équipe AlimamaCreative](https://huggingface.co/alimama-creative) | [lien](https://huggingface.co/alimama-creative/SD3-Controlnet-Inpainting) | > [!TIP] > Pensez à consulter le [guide des Schedulers](../../using-diffusers/schedulers) pour apprendre à explorer le compromis entre la vitesse et la qualité du scheduler, et à consulter la section [réutilisation des composants entre les pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) pour apprendre à charger efficacement les mêmes composants dans plusieurs pipelines. ## StableDiffusion3ControlNetPipeline[[diffusers.StableDiffusion3ControlNetPipeline]] #### diffusers.StableDiffusion3ControlNetPipeline[[diffusers.StableDiffusion3ControlNetPipeline]] ```python diffusers.StableDiffusion3ControlNetPipeline(transformer: SD3Transformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, text_encoder_2: CLIPTextModelWithProjection, tokenizer_2: CLIPTokenizer, text_encoder_3: T5EncoderModel, tokenizer_3: T5Tokenizer, controlnet: diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel | list[diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel] | tuple[diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel] | diffusers.models.controlnets.controlnet_sd3.SD3MultiControlNetModel, image_encoder: transformers.models.siglip.modeling_siglip.SiglipVisionModel | None = None, feature_extractor: transformers.models.siglip.image_processing_pil_siglip.SiglipImageProcessorPil | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L143) **Paramètres :** transformer ([SD3Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes. text_encoder (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14), avec une couche de projection supplémentaire initialisée avec une matrice diagonale de dimension `hidden_size`. text_encoder_2 (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), plus précisément la variante [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k). text_encoder_3 (`T5EncoderModel`) : encodeur de texte figé. Stable Diffusion 3 utilise [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl). tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_2 (`CLIPTokenizer`) : Second Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_3 (`T5TokenizerFast`) : Tokenizer de la classe [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). controlnet ([SD3ControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet_sd3#diffusers.SD3ControlNetModel) ou `list[SD3ControlNetModel]` ou `SD3MultiControlNetModel`) : Fournit un conditionnement supplémentaire au `unet` pendant le processus de débruitage. Si vous définissez plusieurs ControlNets sous forme de liste, les sorties de chaque ControlNet sont additionnées pour créer un conditionnement supplémentaire combiné. image_encoder (`SiglipVisionModel`, *facultatif*) : Modèle de vision pré-entraîné pour IP Adapter. feature_extractor (`SiglipImageProcessor`, *facultatif*) : Processeur d'images pour IP Adapter. #### __appel__[[diffusers.StableDiffusion3ControlNetPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, prompt_3: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, controlnet_conditioning_scale: float | list[float] = 1.0, controlnet_pooled_projections: typing.Optional[torch.FloatTensor] = None, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 256) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L819) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer `prompt_embeds` à la place. prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place prompt_3 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_3` et `text_encoder_3`. S'il n'est pas défini, `prompt` sera utilisé à la place height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats. width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats. num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente. sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé. guidance_scale (`float`, *facultatif*, valeur par défaut 5.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image. control_guidance_start (`float` ou `list[float]`, *facultatif*, valeur par défaut 0.0) : Le pourcentage des étapes totales à partir duquel le ControlNet commence à s'appliquer. control_guidance_end (`float` ou `list[float]`, *facultatif*, par défaut 1.0) : Le pourcentage des étapes totales auquel le ControlNet cesse d’appliquer son effet. control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` ou `list[list[PIL.Image.Image]]`) : La condition d’entrée ControlNet à fournir pour guider le `unet` lors de la génération. Si le type est spécifié comme `torch.Tensor`, il est transmis à ControlNet tel quel. `PIL.Image.Image` peut également être accepté en tant qu’image. Les dimensions de l’image de sortie sont par défaut celles de `image`. Si la hauteur et/ou la largeur sont passées, `image` est redimensionnée en conséquence. Si plusieurs ControlNets sont spécifiés dans `init`, les images doivent être passées sous forme de liste afin que chaque élément de la liste puisse être correctement groupé (batching) pour l’entrée d’un seul ControlNet. controlnet_conditioning_scale (`float` ou `list[float]`, *facultatif*, valeur par défaut 1.0) : Les sorties du ControlNet sont multipliées par `controlnet_conditioning_scale` avant d’être ajoutées au résidu dans le `unet` d’origine. Si plusieurs ControlNets sont spécifiés dans `init`, vous pouvez définir l’échelle correspondante sous forme de liste. controlnet_pooled_projections (`torch.FloatTensor` de forme `(batch_size, projection_dim)`) : Embeddings projetés à partir des embeddings des conditions d'entrée du controlnet. negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`). negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé à la place negative_prompt_3 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_3` et `text_encoder_3`. S’il n’est pas défini, `negative_prompt` est utilisé à la place num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite. generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe. latents (`torch.FloatTensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni. prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. Si non fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`. pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée `prompt`. negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, les pooled negative_prompt_embeds seront générés à partir de l'argument d'entrée `negative_prompt`. ip_adapter_image (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters. ip_adapter_image_embeds (`torch.Tensor`, *facultatif*) : Incrustations d’images pré-générées pour IP-Adapter. Doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. Doit contenir l’incrustation d’image négative si `do_classifier_free_guidance` est défini sur `True`. S’il n’est pas fourni, les incrustations sont calculées à partir de l’argument d’entrée `ip_adapter_image`. output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` plutôt qu'un simple tuple. 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). clip_skip (`int`, *facultatif*) : Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt. callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline. max_sequence_length (`int` par défaut 256) : Longueur maximale de la séquence à utiliser avec le `prompt`. **Retourne :** `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` ou `tuple` `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées. Fonction appelée lors de l'appel du pipeline pour la génération. Exemples : ```py >>> import torch >>> from diffusers import StableDiffusion3ControlNetPipeline >>> from diffusers.models import SD3ControlNetModel, SD3MultiControlNetModel >>> from diffusers.utils import load_image >>> controlnet = SD3ControlNetModel.from_pretrained("InstantX/SD3-Controlnet-Canny", torch_dtype=torch.float16) >>> pipe = StableDiffusion3ControlNetPipeline.from_pretrained( ... "stabilityai/stable-diffusion-3-medium-diffusers", controlnet=controlnet, torch_dtype=torch.float16 ... ) >>> pipe.to("cuda") >>> control_image = load_image( ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png" ... ) >>> prompt = "A bird in space" >>> image = pipe( ... prompt, control_image=control_image, height=1024, width=768, controlnet_conditioning_scale=0.7 ... ).images[0] >>> image.save("sd3.png") ``` #### encode_image[[diffusers.StableDiffusion3ControlNetPipeline.encode_image]] ```python encode_image(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], device: device) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L742) **Paramètres :** image (`PipelineImageInput`) : Image d'entrée à encoder. device : (`torch.device`) : Appareil Torch. **Retourne :** `torch.Tensor` La représentation des caractéristiques de l'image encodée. Encode l'image donnée en une représentation de caractéristiques à l'aide d'un encodeur d'images pré-entraîné. #### encode_prompt[[diffusers.StableDiffusion3ControlNetPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], prompt_2: str | list[str], prompt_3: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, clip_skip: int | None = None, max_sequence_length: int = 256, lora_scale: float | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L365) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte prompt_3 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_3` et au `text_encoder_3`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte device : (`torch.device`) : appareil torch num_images_per_prompt (`int`) : nombre d'images à générer par invite do_classifier_free_guidance (`bool`) : indique s'il faut utiliser le guidage sans classifieur ou non negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`). negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte. negative_prompt_3 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_3` et `text_encoder_3`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte. prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. Si non fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`. pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée `prompt`. negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, les pooled negative_prompt_embeds seront générés à partir de l'argument d'entrée `negative_prompt`. clip_skip (`int`, *facultatif*) : Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt. lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées. #### prepare_ip_adapter_image_embeds[[diffusers.StableDiffusion3ControlNetPipeline.prepare_ip_adapter_image_embeds]] ```python prepare_ip_adapter_image_embeds(ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L762) **Paramètres :** ip_adapter_image (`PipelineImageInput`, *facultatif*) : L'image d'entrée à partir de laquelle extraire les caractéristiques pour IP-Adapter. ip_adapter_image_embeds (`torch.Tensor`, *facultatif*) : Incrustations d'images précalculées. device : (`torch.device`, *facultatif*) : Appareil Torch. num_images_per_prompt (`int`, par défaut 1) : Nombre d'images à générer par invite. do_classifier_free_guidance (`bool`, par défaut True) : Indique s'il faut utiliser le guidage sans classifieur ou non. Prépare les embeddings d’images pour leur utilisation dans l’IP-Adapter. Il faut passer soit `ip_adapter_image`, soit `ip_adapter_image_embeds`. ## StableDiffusion3ControlNetInpaintingPipeline[[diffusers.StableDiffusion3ControlNetInpaintingPipeline]] #### diffusers.StableDiffusion3ControlNetInpaintingPipeline[[diffusers.StableDiffusion3ControlNetInpaintingPipeline]] ```python diffusers.StableDiffusion3ControlNetInpaintingPipeline(transformer: SD3Transformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, text_encoder_2: CLIPTextModelWithProjection, tokenizer_2: CLIPTokenizer, text_encoder_3: T5EncoderModel, tokenizer_3: T5Tokenizer, controlnet: diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel | list[diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel] | tuple[diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel] | diffusers.models.controlnets.controlnet_sd3.SD3MultiControlNetModel, image_encoder: SiglipModel = None, feature_extractor: transformers.models.siglip.image_processing_pil_siglip.SiglipImageProcessorPil | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L166) **Paramètres :** transformer ([SD3Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes. text_encoder (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14), avec une couche de projection supplémentaire initialisée avec une matrice diagonale de dimension `hidden_size`. text_encoder_2 (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), plus précisément la variante [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k). text_encoder_3 (`T5EncoderModel`) : encodeur de texte figé. Stable Diffusion 3 utilise [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl). tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_2 (`CLIPTokenizer`) : Second Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_3 (`T5TokenizerFast`) : Tokenizer de la classe [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). controlnet ([SD3ControlNetModel](/docs/diffusers/v0.43.0/fr/api/models/controlnet_sd3#diffusers.SD3ControlNetModel) ou `list[SD3ControlNetModel]` ou `SD3MultiControlNetModel`) : Fournit un conditionnement supplémentaire au `transformer` pendant le processus de débruitage. Si vous définissez plusieurs ControlNets sous forme de liste, les sorties de chaque ControlNet sont additionnées pour créer un conditionnement supplémentaire combiné. image_encoder (`PreTrainedModel`, *facultatif*) : Modèle de vision pré-entraîné pour IP Adapter. feature_extractor (`BaseImageProcessor`, *facultatif*) : Processeur d'images pour IP Adapter. #### __appel__[[diffusers.StableDiffusion3ControlNetInpaintingPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, prompt_3: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_mask: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, controlnet_conditioning_scale: float | list[float] = 1.0, controlnet_pooled_projections: typing.Optional[torch.FloatTensor] = None, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 256) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L986) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer `prompt_embeds` à la place. prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place prompt_3 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_3` et `text_encoder_3`. S'il n'est pas défini, `prompt` sera utilisé à la place height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats. width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats. num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente. sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé. guidance_scale (`float`, *facultatif*, valeur par défaut 5.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image. control_guidance_start (`float` ou `list[float]`, *facultatif*, valeur par défaut 0.0) : Le pourcentage des étapes totales à partir duquel le ControlNet commence à s'appliquer. control_guidance_end (`float` ou `list[float]`, *facultatif*, par défaut 1.0) : Le pourcentage des étapes totales auquel le ControlNet cesse d’appliquer son effet. control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d'images à inpainter (les parties de l'image à masquer avec `control_mask` et à repeindre selon `prompt`). Pour un tableau numpy et un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]`. S'il s'agit d'un tenseur ou d'une liste de tenseurs, la forme attendue doit être `(B, C, H, W)`. S'il s'agit d'un tableau numpy ou d'une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)`. control_mask (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d'images à masquer `image`. Les pixels blancs du masque sont repeints tandis que les pixels noirs sont conservés. Si `mask_image` est une image PIL, elle est convertie en un seul canal (luminance) avant utilisation. S'il s'agit d'un tableau numpy ou d'un tenseur pytorch, il doit contenir un seul canal de couleur (L) au lieu de trois, la forme attendue pour un tenseur pytorch étant donc `(B, 1, H, W)`. Et pour un tableau numpy, elle serait `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)` ou `(H, W)`. controlnet_conditioning_scale (`float` ou `list[float]`, *facultatif*, valeur par défaut 1.0) : Les sorties du ControlNet sont multipliées par `controlnet_conditioning_scale` avant d’être ajoutées au résidu dans le `unet` d’origine. Si plusieurs ControlNets sont spécifiés dans `init`, vous pouvez définir l’échelle correspondante sous forme de liste. controlnet_pooled_projections (`torch.FloatTensor` de forme `(batch_size, projection_dim)`) : Embeddings projetés à partir des embeddings des conditions d'entrée du controlnet. negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`). negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé à la place negative_prompt_3 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_3` et `text_encoder_3`. S’il n’est pas défini, `negative_prompt` est utilisé à la place num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite. generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe. latents (`torch.FloatTensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni. prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. Si non fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`. pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée `prompt`. negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, les pooled negative_prompt_embeds seront générés à partir de l'argument d'entrée `negative_prompt`. ip_adapter_image (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters. ip_adapter_image_embeds (`torch.Tensor`, *facultatif*) : Incrustations d’images pré-générées pour IP-Adapter. Doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. Doit contenir l’incrustation d’image négative si `do_classifier_free_guidance` est défini sur `True`. S’il n’est pas fourni, les incrustations sont calculées à partir de l’argument d’entrée `ip_adapter_image`. output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` plutôt qu'un simple tuple. 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). clip_skip (`int`, *facultatif*) : Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt. callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline. max_sequence_length (`int` par défaut 256) : Longueur maximale de la séquence à utiliser avec le `prompt`. **Retourne :** `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` ou `tuple` `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées. Fonction appelée lors de l'appel du pipeline pour la génération. Exemples : ```py >>> import torch >>> from diffusers.utils import load_image, check_min_version >>> from diffusers.pipelines import StableDiffusion3ControlNetInpaintingPipeline >>> from diffusers.models.controlnet_sd3 import SD3ControlNetModel >>> controlnet = SD3ControlNetModel.from_pretrained( ... "alimama-creative/SD3-Controlnet-Inpainting", use_safetensors=True, extra_conditioning_channels=1 ... ) >>> pipe = StableDiffusion3ControlNetInpaintingPipeline.from_pretrained( ... "stabilityai/stable-diffusion-3-medium-diffusers", ... controlnet=controlnet, ... torch_dtype=torch.float16, ... ) >>> pipe.text_encoder.to(torch.float16) >>> pipe.controlnet.to(torch.float16) >>> pipe.to("cuda") >>> image = load_image( ... "https://huggingface.co/alimama-creative/SD3-Controlnet-Inpainting/resolve/main/images/dog.png" ... ) >>> mask = load_image( ... "https://huggingface.co/alimama-creative/SD3-Controlnet-Inpainting/resolve/main/images/dog_mask.png" ... ) >>> width = 1024 >>> height = 1024 >>> prompt = "A cat is sitting next to a puppy." >>> generator = torch.Generator(device="cuda").manual_seed(24) >>> res_image = pipe( ... negative_prompt="deformed, distorted, disfigured, poorly drawn, bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, mutated hands and fingers, disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, NSFW", ... prompt=prompt, ... height=height, ... width=width, ... control_image=image, ... control_mask=mask, ... num_inference_steps=28, ... generator=generator, ... controlnet_conditioning_scale=0.95, ... guidance_scale=7, ... ).images[0] >>> res_image.save(f"sd3.png") ``` #### encode_image[[diffusers.StableDiffusion3ControlNetInpaintingPipeline.encode_image]] ```python encode_image(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], device: device) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L909) **Paramètres :** image (`PipelineImageInput`) : Image d'entrée à encoder. device : (`torch.device`) : Appareil Torch. **Retourne :** `torch.Tensor` La représentation des caractéristiques de l'image encodée. Encode l'image donnée en une représentation de caractéristiques à l'aide d'un encodeur d'images pré-entraîné. #### encode_prompt[[diffusers.StableDiffusion3ControlNetInpaintingPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], prompt_2: str | list[str], prompt_3: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, clip_skip: int | None = None, max_sequence_length: int = 256, lora_scale: float | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L387) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte prompt_3 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_3` et au `text_encoder_3`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte device : (`torch.device`) : appareil torch num_images_per_prompt (`int`) : nombre d'images à générer par invite do_classifier_free_guidance (`bool`) : indique s'il faut utiliser le guidage sans classifieur ou non negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`). negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte. negative_prompt_3 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_3` et `text_encoder_3`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte. prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. Si non fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`. pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée `prompt`. negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, les pooled negative_prompt_embeds seront générés à partir de l'argument d'entrée `negative_prompt`. clip_skip (`int`, *facultatif*) : Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt. lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées. #### prepare_ip_adapter_image_embeds[[diffusers.StableDiffusion3ControlNetInpaintingPipeline.prepare_ip_adapter_image_embeds]] ```python prepare_ip_adapter_image_embeds(ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L929) **Paramètres :** ip_adapter_image (`PipelineImageInput`, *facultatif*) : L'image d'entrée à partir de laquelle extraire les caractéristiques pour IP-Adapter. ip_adapter_image_embeds (`torch.Tensor`, *facultatif*) : Incrustations d'images précalculées. device : (`torch.device`, *facultatif*) : Appareil Torch. num_images_per_prompt (`int`, par défaut 1) : Nombre d'images à générer par invite. do_classifier_free_guidance (`bool`, par défaut True) : Indique s'il faut utiliser le guidage sans classifieur ou non. Prépare les embeddings d’images pour leur utilisation dans l’IP-Adapter. Il faut passer soit `ip_adapter_image`, soit `ip_adapter_image_embeds`. ## StableDiffusion3PipelineOutput[[diffusers.pipelines.stable_diffusion_3.pipeline_output.StableDiffusion3PipelineOutput]] #### diffusers.pipelines.stable_diffusion_3.pipeline_output.StableDiffusion3PipelineOutput[[diffusers.pipelines.stable_diffusion_3.pipeline_output.StableDiffusion3PipelineOutput]] ```python diffusers.pipelines.stable_diffusion_3.pipeline_output.StableDiffusion3PipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_3/pipeline_output.py#L10) **Paramètres :** images (`list[PIL.Image.Image]` ou `np.ndarray`) : liste d'images PIL débruitées de longueur `batch_size` ou tableau numpy de forme `(batch_size, height, width, num_channels)`. Les images PIL ou le tableau numpy présentent les images débruitées du pipeline de diffusion. Classe de sortie pour les pipelines Stable Diffusion.