Texte vers image

Lorsqu’on évoque les modèles de diffusion, la génération d’images à partir de texte est souvent l’une des premières choses qui viennent à l’esprit. La génération d’images à partir de texte produit une image à partir d’une description textuelle (par exemple, « Astronaute dans une jungle, palette de couleurs froides, couleurs atténuées, détaillé, 8k »), également connue sous le nom de prompt.

À un niveau très élevé, un modèle de diffusion prend un prompt et un bruit initial aléatoire, puis retire itérativement le bruit pour construire une image. Le processus de denoising est guidé par le prompt, et une fois le processus de denoising terminé après un nombre prédéterminé d'étapes temporelles, la représentation de l'image est décodée en une image.

Lisez le billet de blog Comment fonctionne Stable Diffusion ? pour en savoir plus sur le fonctionnement d'un modèle de diffusion latente.

Vous pouvez générer des images à partir d'un prompt dans 🤗 Diffusers en deux étapes :

1. Chargez un point de contrôle dans la classe AutoPipelineForText2Image, qui détecte automatiquement la classe de pipeline appropriée à utiliser en fonction du point de contrôle :

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"

2. Passez un prompt au pipeline pour générer une image :

image = pipeline(
	"stained glass of darth vader, backlight, centered composition, masterpiece, photorealistic, 8k"
).images[0]
image

Modèles populaires

Les modèles de texte vers image les plus courants sont Stable Diffusion v1.5, Stable Diffusion XL (SDXL) et Kandinsky 2.2. Il existe également des modèles ControlNet ou des adaptateurs qui peuvent être utilisés avec les modèles de texte vers image pour un contrôle plus direct lors de la génération d’images. Les résultats de chaque modèle diffèrent légèrement en raison de leur architecture et de leur processus d’entraînement, mais quel que soit le modèle choisi, leur utilisation est plus ou moins la même. Utilisons le même prompt pour chaque modèle et comparons leurs résultats.

Stable Diffusion v1.5

Stable Diffusion v1.5 est un modèle de diffusion latente initialisé à partir de Stable Diffusion v1-4, puis affiné pendant 595K étapes sur des images de 512x512 issues du jeu de données LAION-Aesthetics V2. Vous pouvez utiliser ce modèle de la manière suivante :

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator("cuda").manual_seed(31)
image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", generator=generator).images[0]
image

Stable Diffusion XL

SDXL est une version beaucoup plus grande des modèles Stable Diffusion précédents et implique un processus de modèle en deux étapes qui ajoute encore plus de détails à une image. Il inclut également certains micro-conditionnements supplémentaires pour générer des images de haute qualité avec des sujets centrés. Consultez le guide plus complet sur SDXL pour en savoir plus sur son utilisation. En général, vous pouvez utiliser SDXL comme suit :

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator("cuda").manual_seed(31)
image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", generator=generator).images[0]
image

Kandinsky 2.2

Le modèle Kandinsky diffère légèrement des modèles Stable Diffusion, car il utilise également un modèle de prior d'image pour créer des embeddings qui servent à mieux aligner le texte et les images dans le modèle de diffusion.

La façon la plus simple d'utiliser Kandinsky 2.2 est :

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator("cuda").manual_seed(31)
image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", generator=generator).images[0]
image

ControlNet

Les modèles ControlNet sont des modèles auxiliaires ou des adaptateurs affinés sur des modèles texte-vers-image, tels que Stable Diffusion v1.5. L'utilisation de modèles ControlNet en combinaison avec des modèles texte-vers-image offre diverses options pour un contrôle plus explicite sur la manière de générer une image. Avec ControlNet, vous ajoutez une image d'entrée de conditionnement supplémentaire au modèle. Par exemple, si vous fournissez une image d'une pose humaine (généralement représentée par plusieurs points clés connectés en un squelette) en tant qu'entrée de conditionnement, le modèle génère une image qui suit la pose de l'image. Consultez le guide plus approfondi sur ControlNet pour en savoir plus sur les autres entrées de conditionnement et sur leur utilisation.

Dans cet exemple, conditionnons le ControlNet avec une image d'estimation de pose humaine. Chargez le modèle ControlNet pré-entraîné sur des estimations de pose humaine :

from diffusers import ControlNetModel, AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

controlnet = ControlNetModel.from_pretrained(
	"lllyasviel/control_v11p_sd15_openpose", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
pose_image = load_image("https://huggingface.co/lllyasviel/control_v11p_sd15_openpose/resolve/main/images/control.png")

Passez le controlnet à AutoPipelineForText2Image et fournissez le prompt ainsi que l’image d’estimation de pose :

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", controlnet=controlnet, dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator("cuda").manual_seed(31)
image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", image=pose_image, generator=generator).images[0]
image

Configurer les paramètres du pipeline

Plusieurs paramètres peuvent être configurés dans le pipeline et influencent la manière dont une image est générée. Vous pouvez modifier la taille de sortie de l’image, spécifier un prompt négatif pour améliorer la qualité de l’image, et plus encore. Cette section détaille comment utiliser ces paramètres.

Hauteur et largeur

Les paramètres height et width contrôlent la hauteur et la largeur (en pixels) de l'image générée. Par défaut, le modèle Stable Diffusion v1.5 génère des images de 512x512, mais vous pouvez modifier cette taille pour n'importe quelle dimension qui est un multiple de 8. Par exemple, pour créer une image rectangulaire :

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline(
	"Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", height=768, width=512
).images[0]
image

D’autres modèles peuvent avoir des tailles d’image par défaut différentes, en fonction des tailles d’image du jeu de données d’entraînement. Par exemple, la taille d’image par défaut de SDXL est de 1024x1024 et l’utilisation de valeurs plus faibles pour height et width peut entraîner des images de qualité inférieure. Assurez-vous de consulter d’abord la référence de l’API du modèle !

Échelle de guidage

Le paramètre guidance_scale détermine dans quelle mesure le prompt influence la génération d’images. Une valeur plus basse accorde au modèle une certaine « créativité » pour générer des images plus librement liées au prompt. Des valeurs de guidance_scale plus élevées poussent le modèle à suivre le prompt plus fidèlement ; si cette valeur est trop élevée, vous pouvez observer des artefacts dans l’image générée.

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline(
	"Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", guidance_scale=3.5
).images[0]
image

Prompt négatif

Tout comme un prompt guide la génération, un negative prompt oriente le modèle pour l'éloigner des éléments que vous ne souhaitez pas voir apparaître. Cette technique est couramment utilisée pour améliorer la qualité globale de l'image en éliminant les défauts visuels indésirables, tels que « low resolution » ou « bad details ». Vous pouvez également utiliser un negative prompt pour supprimer ou modifier le contenu et le style d'une image.

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline(
	prompt="Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
	negative_prompt="ugly, deformed, disfigured, poor details, bad anatomy",
).images[0]
image

Générateur

Un objet torch.Generator permet d’assurer la reproductibilité d’un pipeline en définissant une graine manuelle. Vous pouvez utiliser un Generator pour générer des lots d’images et améliorer itérativement une image générée à partir d’une graine, comme détaillé dans le guide Améliorer la qualité des images avec une génération déterministe.

Vous pouvez définir une graine et un Generator comme indiqué ci-dessous. La création d'une image avec un Generator doit renvoyer le même résultat à chaque fois, au lieu de générer aléatoirement une nouvelle image.

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
generator = torch.Generator(device="cuda").manual_seed(30)
image = pipeline(
	"Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
	generator=generator,
).images[0]
image

Contrôler la génération d'images

Il existe plusieurs façons d’exercer un contrôle plus fin sur la génération d’une image, au-delà de la configuration des paramètres d’un pipeline, telles que le pondération des prompts et les modèles ControlNet.

Pondération des prompts

Le pondération des prompts est une technique permettant d’augmenter ou de diminuer l’importance des concepts dans un prompt afin de mettre en avant ou d’atténuer certaines caractéristiques d’une image. Nous recommandons d’utiliser la bibliothèque Compel pour vous aider à générer les embeddings de prompts pondérés.

Apprenez à créer les embeddings de prompt dans le guide Pondération des prompts. Cet exemple se concentre sur l'utilisation des embeddings de prompt dans le pipeline.

Une fois que vous avez créé les embeddings, vous pouvez les passer au paramètre prompt_embeds (et negative_prompt_embeds si vous utilisez un prompt négatif) du pipeline.

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
	"stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline(
	prompt_embeds=prompt_embeds, # generated from Compel
	negative_prompt_embeds=negative_prompt_embeds, # generated from Compel
).images[0]

ControlNet

Comme vous l’avez vu dans la section ControlNet, ces modèles offrent une méthode plus flexible et plus précise pour générer des images en intégrant une image de conditionnement supplémentaire. Chaque modèle ControlNet est pré-entraîné sur un type particulier d’image de conditionnement afin de générer de nouvelles images qui lui ressemblent. Par exemple, si vous prenez un modèle ControlNet pré-entraîné sur des cartes de profondeur, vous pouvez fournir au modèle une carte de profondeur comme entrée de conditionnement et il générera une image qui préserve les informations spatiales qu’elle contient. C’est plus rapide et plus simple que de spécifier les informations de profondeur dans un prompt. Vous pouvez même combiner plusieurs entrées de conditionnement avec un Multi-ControlNet !

Il existe de nombreux types d'entrées de conditionnement que vous pouvez utiliser, et 🤗 Diffusers prend en charge ControlNet pour les modèles Stable Diffusion et SDXL. Consultez le guide plus complet sur ControlNet pour apprendre à utiliser ces modèles.

Optimiser

Les modèles de diffusion sont volumineux, et la nature itérative du débruitage d'une image est coûteuse et intensive en calcul. Mais cela ne signifie pas qu'il faut disposer de GPU puissants – ou même nombreux – pour les utiliser. Il existe de nombreuses techniques d'optimisation pour exécuter des modèles de diffusion sur des ressources grand public et des offres gratuites. Par exemple, vous pouvez charger les poids du modèle en demi-précision pour économiser de la mémoire GPU et augmenter la vitesse, ou décharger le modèle entier sur le GPU pour économiser encore plus de mémoire.

PyTorch 2.0 prend également en charge un mécanisme d'attention plus efficace en mémoire, appelé scaled dot product attention, qui est activé automatiquement si vous utilisez PyTorch 2.0. Vous pouvez combiner cela avec torch.compile pour accélérer encore davantage votre code :

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16").to("cuda")  # or "mps", "xpu", "cpu"
pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True)

Pour plus de conseils sur l’optimisation de votre code afin d’économiser de la mémoire et d’accélérer l’inférence, consultez les guides Accelerate inference et Reduce memory usage.