# Stable Diffusion 3 Stable Diffusion 3 (SD3) a été proposé dans [Scaling Rectified Flow Transformers for High-Resolution Image Synthesis](https://huggingface.co/papers/2403.03206) par Patrick Esser, Sumith Kulal, Andreas Blattmann, Rahim Entezari, Jonas Muller, Harry Saini, Yam Levi, Dominik Lorenz, Axel Sauer, Frederic Boesel, Dustin Podell, Tim Dockhorn, Zion English, Kyle Lacey, Alex Goodwin, Yannik Marek et Robin Rombach. L'abstract de l'article est : *Les modèles de diffusion créent des données à partir du bruit en inversant les chemins avant des données vers le bruit et se sont imposés comme une technique puissante de modélisation générative pour des données perceptuelles de haute dimension, telles que les images et les vidéos. Le rectified flow est une formulation récente de modèle génératif qui relie les données et le bruit par une ligne droite. Malgré ses meilleures propriétés théoriques et sa simplicité conceptuelle, il n'est pas encore définitivement établi comme pratique standard. Dans ce travail, nous améliorons les techniques existantes d'échantillonnage du bruit pour l'entraînement des modèles de rectified flow en les biaisant vers des échelles perceptuellement pertinentes. À travers une étude à grande échelle, nous démontrons la supériorité de cette approche par rapport aux formulations de diffusion établies pour la synthèse texte-vers-image haute résolution. De plus, nous présentons une nouvelle architecture basée sur des transformers pour la génération texte-vers-image qui utilise des poids séparés pour les deux modalités et permet un flux d'information bidirectionnel entre les jetons d'image et de texte, améliorant ainsi la compréhension du texte, la typographie et les notes de préférence humaine. Nous démontrons que cette architecture suit des tendances de mise à l'échelle prévisibles et que la perte de validation plus faible est corrélée à une meilleure synthèse texte-vers-image, mesurée par diverses métriques et évaluations humaines.* ## Exemple d'utilisation _Le modèle étant soumis à une autorisation, avant de l’utiliser avec diffusers, vous devez d’abord accéder à la [page Hugging Face de Stable Diffusion 3 Medium](https://huggingface.co/stabilityai/stable-diffusion-3-medium-diffusers), remplir le formulaire et accepter l’accès. Une fois admis, vous devez vous connecter afin que votre système prenne en compte votre acceptation._ Utilisez la commande ci-dessous pour vous connecter : ```bash hf auth login ``` > [!TIP] > Le pipeline SD3 utilise trois encodeurs de texte pour générer une image. Le déchargement des modèles est nécessaire pour qu'il puisse s'exécuter sur la plupart du matériel grand public. Veuillez utiliser le type de données `torch.float16` pour des économies de mémoire supplémentaires. ```python import torch from diffusers import StableDiffusion3Pipeline pipe = StableDiffusion3Pipeline.from_pretrained("stabilityai/stable-diffusion-3-medium-diffusers", dtype=torch.float16) pipe.to("cuda") # or "mps", "xpu", "cpu" image = pipe( prompt="a photo of a cat holding a sign that says hello world", negative_prompt="", num_inference_steps=28, height=1024, width=1024, guidance_scale=7.0, ).images[0] image.save("sd3_hello_world.png") ``` **Remarque :** Stable Diffusion 3.5 peut également être exécuté à l'aide du pipeline SD3, et toutes les optimisations et techniques mentionnées s'appliquent également à celui-ci. Au total, il existe trois modèles officiels dans la famille SD3 : - [`stabilityai/stable-diffusion-3-medium-diffusers`](https://huggingface.co/stabilityai/stable-diffusion-3-medium-diffusers) - [`stabilityai/stable-diffusion-3.5-large`](https://huggingface.co/stabilityai/stable-diffusion-3-5-large) - [`stabilityai/stable-diffusion-3.5-large-turbo`](https://huggingface.co/stabilityai/stable-diffusion-3-5-large-turbo) ## Image Prompting avec des IP-Adapters Un IP-Adapter vous permet de guider SD3 avec des images, en plus du prompt texte. C'est particulièrement utile pour décrire des concepts complexes difficiles à formuler par le texte seul, lorsque vous disposez d'images de référence. Pour charger et utiliser un IP-Adapter, vous avez besoin de : - `image_encoder` : modèle de vision pré-entraîné utilisé pour obtenir les caractéristiques d'image, généralement un encodeur d'image CLIP. - `feature_extractor` : Processeur d’images qui prépare l’image d’entrée pour le `image_encoder` choisi. - `ip_adapter_id` : Point de contrôle contenant les paramètres des couches d'attention croisée d'image et de projection d'image. Les IP-Adapters sont entraînés pour une architecture de modèle spécifique, ils fonctionnent donc également avec les variantes affinées du modèle de base. Vous pouvez utiliser la fonction `~SD3IPAdapterMixin.set_ip_adapter_scale` pour ajuster la force avec laquelle la sortie s'aligne sur le prompt d'image. Plus la valeur est élevée, plus le modèle suit fidèlement le prompt d'image. Une valeur par défaut de 0,5 est généralement un bon équilibre, garantissant que le modèle prend en compte les prompts texte et image de manière égale. ```python import torch from PIL import Image from diffusers import StableDiffusion3Pipeline from transformers import SiglipVisionModel, SiglipImageProcessor image_encoder_id = "google/siglip-so400m-patch14-384" ip_adapter_id = "InstantX/SD3.5-Large-IP-Adapter" feature_extractor = SiglipImageProcessor.from_pretrained( image_encoder_id, dtype=torch.float16 ) image_encoder = SiglipVisionModel.from_pretrained( image_encoder_id, dtype=torch.float16 ).to( "cuda") # or "mps", "xpu", "cpu" pipe = StableDiffusion3Pipeline.from_pretrained( "stabilityai/stable-diffusion-3.5-large", dtype=torch.float16, feature_extractor=feature_extractor, image_encoder=image_encoder, ).to("cuda") pipe.load_ip_adapter(ip_adapter_id) pipe.set_ip_adapter_scale(0.6) ref_img = Image.open("image.jpg").convert('RGB') image = pipe( width=1024, height=1024, prompt="a cat", negative_prompt="lowres, low quality, worst quality", num_inference_steps=24, guidance_scale=5.0, ip_adapter_image=ref_img ).images[0] image.save("result.jpg") ``` Exemples d'IP-Adapter avec le prompt « a cat » > [!TIP] > Découvrez [IP-Adapter](../../../using-diffusers/ip_adapter) pour en savoir plus sur le fonctionnement des IP-Adapters. ## Optimisations de la mémoire pour SD3 SD3 utilise trois encodeurs de texte, dont le très grand modèle T5-XXL. Cela rend difficile l'exécution du modèle sur des GPU disposant de moins de 24 Go de VRAM, même en utilisant la précision `fp16`. La section suivante présente quelques optimisations de mémoire dans Diffusers qui facilitent l'exécution de SD3 sur du matériel à ressources limitées. ### Exécution de l'inférence avec déchargement du modèle L’optimisation de mémoire la plus basique disponible dans Diffusers permet de décharger les composants du modèle sur le CPU pendant l’inférence afin d’économiser de la mémoire, au prix d’une légère augmentation de la latence d’inférence. Le déchargement du modèle ne déplace un composant du modèle sur le GPU que lorsqu’il doit être exécuté, tout en conservant les composants restants sur le CPU. ```python import torch from diffusers import StableDiffusion3Pipeline pipe = StableDiffusion3Pipeline.from_pretrained("stabilityai/stable-diffusion-3-medium-diffusers", dtype=torch.float16) pipe.enable_model_cpu_offload() image = pipe( prompt="a photo of a cat holding a sign that says hello world", negative_prompt="", num_inference_steps=28, height=1024, width=1024, guidance_scale=7.0, ).images[0] image.save("sd3_hello_world.png") ``` ### Suppression de l’encodeur de texte T5 lors de l’inférence Supprimer l’encodeur de texte T5-XXL, qui compte 4,7 milliards de paramètres et est gourmand en mémoire, lors de l’inférence permet de réduire considérablement les besoins en mémoire de SD3, avec une perte de performance très légère. ```python import torch from diffusers import StableDiffusion3Pipeline pipe = StableDiffusion3Pipeline.from_pretrained( "stabilityai/stable-diffusion-3-medium-diffusers", text_encoder_3=None, tokenizer_3=None, dtype=torch.float16 ) pipe.to("cuda") # or "mps", "xpu", "cpu" image = pipe( prompt="a photo of a cat holding a sign that says hello world", negative_prompt="", num_inference_steps=28, height=1024, width=1024, guidance_scale=7.0, ).images[0] image.save("sd3_hello_world-no-T5.png") ``` ### Utiliser une version quantifiée de l'encodeur de texte T5 Nous pouvons exploiter la bibliothèque `bitsandbytes` pour charger et quantifier l'encodeur de texte T5-XXL à une précision de 8 bits. Cela permet de continuer à utiliser les trois encodeurs de texte tout en n'impactant que légèrement les performances. Installez d'abord la bibliothèque `bitsandbytes`. ```shell pip install bitsandbytes ``` Chargez ensuite le modèle T5-XXL à l'aide de `BitsAndBytesConfig`. ```python import torch from diffusers import StableDiffusion3Pipeline from transformers import T5EncoderModel, BitsAndBytesConfig quantization_config = BitsAndBytesConfig(load_in_8bit=True) model_id = "stabilityai/stable-diffusion-3-medium-diffusers" text_encoder = T5EncoderModel.from_pretrained( model_id, subfolder="text_encoder_3", quantization_config=quantization_config, ) pipe = StableDiffusion3Pipeline.from_pretrained( model_id, text_encoder_3=text_encoder, device_map="balanced", dtype=torch.float16 ) image = pipe( prompt="a photo of a cat holding a sign that says hello world", negative_prompt="", num_inference_steps=28, height=1024, width=1024, guidance_scale=7.0, ).images[0] image.save("sd3_hello_world-8bit-T5.png") ``` Vous pouvez trouver le script de bout en bout [ici](https://gist.github.com/sayakpaul/82acb5976509851f2db1a83456e504f1). ## Optimisations des performances pour SD3 ### Utiliser Torch Compile pour accélérer l'inférence L'utilisation de composants compilés dans le pipeline SD3 peut accélérer l'inférence jusqu'à 4 fois. L'extrait de code suivant montre comment compiler les composants Transformer et VAE du pipeline SD3. ```python import torch from diffusers import StableDiffusion3Pipeline torch.set_float32_matmul_precision("high") torch._inductor.config.conv_1x1_as_mm = True torch._inductor.config.coordinate_descent_tuning = True torch._inductor.config.epilogue_fusion = False torch._inductor.config.coordinate_descent_check_all_directions = True pipe = StableDiffusion3Pipeline.from_pretrained( "stabilityai/stable-diffusion-3-medium-diffusers", dtype=torch.float16 ).to("cuda") # or "mps", "xpu", "cpu" pipe.set_progress_bar_config(disable=True) pipe.transformer.to(memory_format=torch.channels_last) pipe.vae.to(memory_format=torch.channels_last) pipe.transformer = torch.compile(pipe.transformer, mode="max-autotune", fullgraph=True) pipe.vae.decode = torch.compile(pipe.vae.decode, mode="max-autotune", fullgraph=True) # Warm Up prompt = "a photo of a cat holding a sign that says hello world" for _ in range(3): _ = pipe(prompt=prompt, generator=torch.manual_seed(1)) # Run Inference image = pipe(prompt=prompt, generator=torch.manual_seed(1)).images[0] image.save("sd3_hello_world.png") ``` Consultez le script complet [ici](https://gist.github.com/sayakpaul/508d89d7aad4f454900813da5d42ca97). ## Quantification La quantification aide à réduire les besoins en mémoire des très grands modèles en stockant les poids du modèle dans un type de données de précision inférieure. Cependant, la quantification peut avoir un impact variable sur la qualité de la vidéo selon le modèle vidéo. Reportez-vous à l’aperçu de la [Quantization](../../../quantization/overview) pour en savoir plus sur les backends de quantification pris en charge et sur la sélection d’un backend de quantification adapté à votre cas d’usage. L’exemple ci-dessous montre comment charger un [StableDiffusion3Pipeline](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/stable_diffusion_3#diffusers.StableDiffusion3Pipeline) quantifié pour l’inférence avec bitsandbytes. ```py import torch from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, SD3Transformer2DModel, StableDiffusion3Pipeline from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel quant_config = BitsAndBytesConfig(load_in_8bit=True) text_encoder_8bit = T5EncoderModel.from_pretrained( "stabilityai/stable-diffusion-3.5-large", subfolder="text_encoder_3", quantization_config=quant_config, dtype=torch.float16, ) quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True) transformer_8bit = SD3Transformer2DModel.from_pretrained( "stabilityai/stable-diffusion-3.5-large", subfolder="transformer", quantization_config=quant_config, dtype=torch.float16, ) pipeline = StableDiffusion3Pipeline.from_pretrained( "stabilityai/stable-diffusion-3.5-large", text_encoder=text_encoder_8bit, transformer=transformer_8bit, dtype=torch.float16, device_map="balanced", ) prompt = "a tiny astronaut hatching from an egg on the moon" image = pipeline(prompt, num_inference_steps=28, guidance_scale=7.0).images[0] image.save("sd3.png") ``` ## Utiliser de longs prompts avec l'encodeur de texte T5 Par défaut, le prompt de l'encodeur de texte T5 utilise une longueur de séquence maximale de `256`. Cette valeur peut être ajustée en définissant `max_sequence_length` pour accepter moins ou plus de jetons. Gardez à l'esprit que des séquences plus longues nécessitent des ressources supplémentaires et entraînent des temps de génération plus longs, par exemple lors d'une inférence par lots. ```python prompt = "A whimsical and creative image depicting a hybrid creature that is a mix of a waffle and a hippopotamus, basking in a river of melted butter amidst a breakfast-themed landscape. It features the distinctive, bulky body shape of a hippo. However, instead of the usual grey skin, the creature’s body resembles a golden-brown, crispy waffle fresh off the griddle. The skin is textured with the familiar grid pattern of a waffle, each square filled with a glistening sheen of syrup. The environment combines the natural habitat of a hippo with elements of a breakfast table setting, a river of warm, melted butter, with oversized utensils or plates peeking out from the lush, pancake-like foliage in the background, a towering pepper mill standing in for a tree. As the sun rises in this fantastical world, it casts a warm, buttery glow over the scene. The creature, content in its butter river, lets out a yawn. Nearby, a flock of birds take flight" image = pipe( prompt=prompt, negative_prompt="", num_inference_steps=28, guidance_scale=4.5, max_sequence_length=512, ).images[0] ``` ### Envoyer un prompt différent à l'encodeur de texte T5 Vous pouvez envoyer un prompt différent aux encodeurs de texte CLIP et à l'encodeur de texte T5 pour éviter que le prompt ne soit tronqué par les encodeurs de texte CLIP et pour améliorer la génération. > [!TIP] > Le prompt avec les encodeurs de texte CLIP est toujours tronqué à la limite de 77 jetons. ```python prompt = "A whimsical and creative image depicting a hybrid creature that is a mix of a waffle and a hippopotamus, basking in a river of melted butter amidst a breakfast-themed landscape. A river of warm, melted butter, pancake-like foliage in the background, a towering pepper mill standing in for a tree." prompt_3 = "A whimsical and creative image depicting a hybrid creature that is a mix of a waffle and a hippopotamus, basking in a river of melted butter amidst a breakfast-themed landscape. It features the distinctive, bulky body shape of a hippo. However, instead of the usual grey skin, the creature’s body resembles a golden-brown, crispy waffle fresh off the griddle. The skin is textured with the familiar grid pattern of a waffle, each square filled with a glistening sheen of syrup. The environment combines the natural habitat of a hippo with elements of a breakfast table setting, a river of warm, melted butter, with oversized utensils or plates peeking out from the lush, pancake-like foliage in the background, a towering pepper mill standing in for a tree. As the sun rises in this fantastical world, it casts a warm, buttery glow over the scene. The creature, content in its butter river, lets out a yawn. Nearby, a flock of birds take flight" image = pipe( prompt=prompt, prompt_3=prompt_3, negative_prompt="", num_inference_steps=28, guidance_scale=4.5, max_sequence_length=512, ).images[0] ``` ## Tiny AutoEncoder pour Stable Diffusion 3 Tiny AutoEncoder for Stable Diffusion (TAESD3) est une version distillée et compacte du VAE de Stable Diffusion 3 par [Ollin Boer Bohan](https://github.com/madebyollin/taesd), capable de décoder les latents de [StableDiffusion3Pipeline](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/stable_diffusion_3#diffusers.StableDiffusion3Pipeline) presque instantanément. Pour l'utiliser avec Stable Diffusion 3 : ```python import torch from diffusers import StableDiffusion3Pipeline, AutoencoderTiny pipe = StableDiffusion3Pipeline.from_pretrained( "stabilityai/stable-diffusion-3-medium-diffusers", dtype=torch.float16 ) pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd3", dtype=torch.float16) pipe = pipe.to("cuda") # or "mps", "xpu", "cpu" prompt = "slice of delicious New York-style berry cheesecake" image = pipe(prompt, num_inference_steps=25).images[0] image.save("cheesecake.png") ``` ## Chargement des points de contrôle originaux via `from_single_file` Les classes `SD3Transformer2DModel` et `StableDiffusion3Pipeline` prennent en charge le chargement des points de contrôle d'origine via la méthode `from_single_file`. Cette méthode permet de charger les fichiers de points de contrôle d'origine utilisés pour l'entraînement des modèles. ## Chargement des points de contrôle originaux pour le `SD3Transformer2DModel` ```python from diffusers import SD3Transformer2DModel model = SD3Transformer2DModel.from_single_file("https://huggingface.co/stabilityai/stable-diffusion-3-medium/blob/main/sd3_medium.safetensors") ``` ## Chargement du point de contrôle unique pour le `StableDiffusion3Pipeline` ### Chargement du point de contrôle en fichier unique sans T5 ```python import torch from diffusers import StableDiffusion3Pipeline pipe = StableDiffusion3Pipeline.from_single_file( "https://huggingface.co/stabilityai/stable-diffusion-3-medium/blob/main/sd3_medium_incl_clips.safetensors", dtype=torch.float16, text_encoder_3=None ) pipe.enable_model_cpu_offload() image = pipe("a picture of a cat holding a sign that says hello world").images[0] image.save('sd3-single-file.png') ``` ### Chargement du point de contrôle en fichier unique avec T5 > [!TIP] > L’exemple suivant charge un point de contrôle stocké au format flottant 8 bits, ce qui nécessite PyTorch 2.3 ou une version ultérieure. ```python import torch from diffusers import StableDiffusion3Pipeline pipe = StableDiffusion3Pipeline.from_single_file( "https://huggingface.co/stabilityai/stable-diffusion-3-medium/blob/main/sd3_medium_incl_clips_t5xxlfp8.safetensors", dtype=torch.float16, ) pipe.enable_model_cpu_offload() image = pipe("a picture of a cat holding a sign that says hello world").images[0] image.save('sd3-single-file-t5-fp8.png') ``` ### Chargement du point de contrôle en fichier unique pour le modèle Transformer Stable Diffusion 3.5 ```python import torch from diffusers import SD3Transformer2DModel, StableDiffusion3Pipeline transformer = SD3Transformer2DModel.from_single_file( "https://huggingface.co/stabilityai/stable-diffusion-3.5-large-turbo/blob/main/sd3.5_large.safetensors", dtype=torch.bfloat16, ) pipe = StableDiffusion3Pipeline.from_pretrained( "stabilityai/stable-diffusion-3.5-large", transformer=transformer, dtype=torch.bfloat16, ) pipe.enable_model_cpu_offload() image = pipe("a cat holding a sign that says hello world").images[0] image.save("sd35.png") ``` ## StableDiffusion3Pipeline[[diffusers.StableDiffusion3Pipeline]] #### diffusers.StableDiffusion3Pipeline[[diffusers.StableDiffusion3Pipeline]] ```python diffusers.StableDiffusion3Pipeline(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, image_encoder: SiglipVisionModel = None, feature_extractor: SiglipImageProcessorPil = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L148) **Paramètres :** transformer ([SD3Transformer2DModel](/docs/diffusers/main/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/main/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/main/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). 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.StableDiffusion3Pipeline.__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, 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, skip_guidance_layers: list[int] = None, skip_layer_guidance_scale: float = 2.8, skip_layer_guidance_stop: float = 0.2, skip_layer_guidance_start: float = 0.01, mu: float | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L772) **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 7.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. 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*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` 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`. skip_guidance_layers (`list[int]`, *facultatif*) : Une liste d'entiers qui spécifie les couches à ignorer lors du guidage. Si elle n'est pas fournie, toutes les couches seront utilisées pour le guidage. Si elle est fournie, le guidage ne sera appliqué qu'aux couches spécifiées dans la liste. La valeur recommandée par StabiltyAI pour Stable Diffusion 3.5 Medium est [7, 8, 9]. skip_layer_guidance_scale (`int`, *facultatif*) : L'échelle du guidage pour les couches spécifiées dans `skip_guidance_layers`. Le guidage sera appliqué aux couches spécifiées dans `skip_guidance_layers` avec une échelle de `skip_layer_guidance_scale`. Le guidage sera appliqué au reste des couches avec une échelle de `1`. skip_layer_guidance_stop (`int`, *facultatif*) : L'étape à laquelle le guidage pour les couches spécifiées dans `skip_guidance_layers` cessera. Le guidage sera appliqué aux couches spécifiées dans `skip_guidance_layers` jusqu'à la fraction spécifiée dans `skip_layer_guidance_stop`. La valeur recommandée par StabiltyAI pour Stable Diffusion 3.5 Medium est 0,2. skip_layer_guidance_start (`int`, *facultatif*) : L'étape à laquelle le guidage pour les couches spécifiées dans `skip_guidance_layers` commencera. Le guidage sera appliqué aux couches spécifiées dans `skip_guidance_layers` à partir de la fraction indiquée dans `skip_layer_guidance_start`. La valeur recommandée par StabiltyAI pour Stable Diffusion 3.5 Medium est 0.01. mu (`float`, *facultatif*) : valeur de `mu` utilisée pour `dynamic_shifting`. **Retourne :** `~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` ou `tuple` `~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` 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 StableDiffusion3Pipeline >>> pipe = StableDiffusion3Pipeline.from_pretrained( ... "stabilityai/stable-diffusion-3-medium-diffusers", torch_dtype=torch.float16 ... ) >>> pipe.to("cuda") >>> prompt = "A cat holding a sign that says hello world" >>> image = pipe(prompt).images[0] >>> image.save("sd3.png") ``` #### encode_image[[diffusers.StableDiffusion3Pipeline.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/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L696) **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.StableDiffusion3Pipeline.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/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L344) **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.StableDiffusion3Pipeline.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/main/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3.py#L716) **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`.