Diffusers documentation
Latent Consistency Models
Latent Consistency Models
Les Latent Consistency Models (LCMs) ont été proposés dans Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference par Simian Luo, Yiqin Tan, Longbo Huang, Jian Li et Hang Zhao.
L’abstract de l’article est le suivant :
Les modèles de diffusion latente (LDM) ont obtenu des résultats remarquables dans la synthèse d'images haute résolution. Cependant, le processus d'échantillonnage itératif est intensif en calculs et entraîne une génération lente. Inspirés par les Consistency Models (song et al.), nous proposons les Latent Consistency Models (LCM), permettant une inférence rapide en un minimum d'étapes sur n'importe quel LDM pré-entraîné, y compris Stable Diffusion (rombach et al). En considérant le processus de diffusion inverse guidé comme la résolution d'une ODE de flux de probabilité augmentée (PF-ODE), les LCM sont conçus pour prédire directement la solution de cette ODE dans l'espace latent, réduisant ainsi le besoin de nombreuses itérations et permettant un échantillonnage rapide et haute fidélité. Distillés efficacement à partir de modèles de diffusion guidés par classifier-free pré-entraînés, un LCM de haute qualité 768 x 768 en 2~4 étapes ne nécessite que 32 heures de GPU A100 pour l'entraînement. De plus, nous introduisons le Latent Consistency Fine-tuning (LCF), une méthode novatrice conçue pour l'ajustement fin des LCM sur des jeux de données d'images personnalisés. L'évaluation sur le jeu de données LAION-5B-Aesthetics démontre que les LCM atteignent des performances de pointe en génération d'images à partir de texte avec une inférence en peu d'étapes. Page du projet : this https URL.
Une démonstration du point de contrôle SimianLuo/LCM_Dreamshaper_v7 est disponible ici.
Les pipelines ont été contribué par luosiallen, nagolinc et dg845.
Les LCM et les LCM-LoRA sont disponibles pour Stable Diffusion v1.5, Stable Diffusion XL et le modèle SSD-1B. Vous pouvez trouver leurs points de contrôle sur les collections Latent Consistency.
Texte vers image
Pour utiliser les LCM, vous devez charger le checkpoint LCM de votre modèle pris en charge dans UNet2DConditionModel et remplacer le planificateur par le LCMScheduler. Vous pouvez ensuite utiliser le pipeline comme d'habitude et passer un prompt texte pour générer une image en seulement 4 étapes.
Quelques points à garder en tête lors de l'utilisation des LCM :
- En général, la taille du lot est doublée dans le pipeline pour le guidage sans classifieur. Cependant, LCM applique le guidage à l’aide d’embeddings de guidage et n’a pas besoin de doubler la taille du lot, ce qui entraîne une inférence plus rapide. L’inconvénient est que les prompts négatifs ne fonctionnent pas avec LCM, car ils n’ont aucun effet sur le processus de débruitage.
- La plage idéale pour
guidance_scaleest [3., 13.] car c'est la plage utilisée pour l'entraînement du UNet. Toutefois, désactiverguidance_scaleavec une valeur de 1.0 est également efficace dans la plupart des cas.
from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, LCMScheduler
import torch
unet = UNet2DConditionModel.from_pretrained(
"latent-consistency/lcm-sdxl",
dtype=torch.float16,
variant="fp16",
)
pipe = StableDiffusionXLPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0", unet=unet, dtype=torch.float16, variant="fp16",
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
generator = torch.manual_seed(0)
image = pipe(
prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=8.0
).images[0]
image
Pour utiliser les LCM-LoRAs, vous devez remplacer le planificateur par le LCMScheduler et charger les poids LCM-LoRA avec la méthode load_lora_weights(). Vous pouvez ensuite utiliser le pipeline comme d'habitude et passer un prompt texte pour générer une image en seulement 4 étapes.
Quelques points à garder en tête lors de l'utilisation des LCM-LoRAs :
- En général, la taille du lot est doublée dans le pipeline pour le guidage sans classifieur. Cependant, LCM applique le guidage à l’aide d’embeddings de guidage et n’a pas besoin de doubler la taille du lot, ce qui entraîne une inférence plus rapide. L’inconvénient est que les prompts négatifs ne fonctionnent pas avec LCM, car ils n’ont aucun effet sur le processus de débruitage.
- Vous pouvez utiliser le guidance avec les LCM-LoRAs, mais il est très sensible aux valeurs élevées de
guidance_scaleet peut entraîner des artefacts dans l’image générée. Les meilleures valeurs que nous avons trouvées se situent entre [1.0, 2.0]. - Remplacez stabilityai/stable-diffusion-xl-base-1.0 par n’importe quel modèle affiné. Par exemple, essayez d’utiliser le point de contrôle animagine-xl pour générer des images d’anime avec SDXL.
import torch
from diffusers import DiffusionPipeline, LCMScheduler
pipe = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0",
variant="fp16",
dtype=torch.float16
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")
prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
generator = torch.manual_seed(42)
image = pipe(
prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=1.0
).images[0]
image
Image vers image
Pour utiliser les LCM pour l'image-à-image, vous devez charger le point de contrôle LCM de votre modèle pris en charge dans UNet2DConditionModel et remplacer le planificateur par le LCMScheduler. Vous pouvez ensuite utiliser le pipeline comme d'habitude, en passant un prompt texte et une image initiale pour générer une image en seulement 4 étapes.
Expérimentez avec différentes valeurs pour
num_inference_steps,strengthetguidance_scaleafin d'obtenir les meilleurs résultats.
import torch
from diffusers import AutoPipelineForImage2Image, UNet2DConditionModel, LCMScheduler
from diffusers.utils import load_image
unet = UNet2DConditionModel.from_pretrained(
"SimianLuo/LCM_Dreamshaper_v7",
subfolder="unet",
dtype=torch.float16,
)
pipe = AutoPipelineForImage2Image.from_pretrained(
"Lykon/dreamshaper-7",
unet=unet,
dtype=torch.float16,
variant="fp16",
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png")
prompt = "Astronauts in a jungle, cold color palette, muted colors, detailed, 8k"
generator = torch.manual_seed(0)
image = pipe(
prompt,
image=init_image,
num_inference_steps=4,
guidance_scale=7.5,
strength=0.5,
generator=generator
).images[0]
image
Pour utiliser les LCM-LoRAs pour l'image-à-image, vous devez remplacer le planificateur par le LCMScheduler et charger les poids du LCM-LoRA avec la méthode load_lora_weights(). Vous pouvez ensuite utiliser le pipeline comme d'habitude, en passant un prompt texte et une image initiale pour générer une image en seulement 4 étapes.
Expérimentez avec différentes valeurs pour
num_inference_steps,strengthetguidance_scaleafin d'obtenir les meilleurs résultats.
import torch
from diffusers import AutoPipelineForImage2Image, LCMScheduler
from diffusers.utils import make_image_grid, load_image
pipe = AutoPipelineForImage2Image.from_pretrained(
"Lykon/dreamshaper-7",
dtype=torch.float16,
variant="fp16",
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png")
prompt = "Astronauts in a jungle, cold color palette, muted colors, detailed, 8k"
generator = torch.manual_seed(0)
image = pipe(
prompt,
image=init_image,
num_inference_steps=4,
guidance_scale=1,
strength=0.6,
generator=generator
).images[0]
image 
Inpainting
Pour utiliser les LCM-LoRAs pour l'inpainting, vous devez remplacer le planificateur par le LCMScheduler et charger les poids du LCM-LoRA avec la méthode load_lora_weights(). Vous pouvez ensuite utiliser le pipeline comme d'habitude, en passant un prompt texte, une image initiale et une image de masque pour générer une image en seulement 4 étapes.
import torch
from diffusers import AutoPipelineForInpainting, LCMScheduler
from diffusers.utils import load_image, make_image_grid
pipe = AutoPipelineForInpainting.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-inpainting",
dtype=torch.float16,
variant="fp16",
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")
prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
generator = torch.manual_seed(0)
image = pipe(
prompt=prompt,
image=init_image,
mask_image=mask_image,
generator=generator,
num_inference_steps=4,
guidance_scale=4,
).images[0]
image
Adaptateurs
Les LCM sont compatibles avec des adaptateurs tels que LoRA, ControlNet, T2I-Adapter et AnimateDiff. Vous pouvez apporter la rapidité des LCM à ces adaptateurs pour générer des images dans un style particulier ou conditionner le modèle sur une autre entrée, comme une image canny.
LoRA
Les adaptateurs LoRA peuvent être affinés rapidement pour apprendre un nouveau style à partir de quelques images seulement, puis intégrés à un modèle pré-entraîné afin de générer des images dans ce style.
Chargez le checkpoint LCM de votre modèle pris en charge dans UNet2DConditionModel et remplacez le scheduler par le LCMScheduler. Vous pouvez ensuite utiliser la méthode load_lora_weights() pour charger les poids LoRA dans le LCM et générer une image stylisée en quelques étapes.
from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, LCMScheduler
import torch
unet = UNet2DConditionModel.from_pretrained(
"latent-consistency/lcm-sdxl",
dtype=torch.float16,
variant="fp16",
)
pipe = StableDiffusionXLPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0", unet=unet, dtype=torch.float16, variant="fp16",
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("TheLastBen/Papercut_SDXL", weight_name="papercut.safetensors", adapter_name="papercut")
prompt = "papercut, a cute fox"
generator = torch.manual_seed(0)
image = pipe(
prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=8.0
).images[0]
image
Remplacez le planificateur par le LCMScheduler. Vous pouvez ensuite utiliser la méthode load_lora_weights() pour charger les poids LCM-LoRA et le LoRA de style que vous souhaitez utiliser. Combinez les deux adaptateurs LoRA avec la méthode ~loaders.UNet2DConditionLoadersMixin.set_adapters et générez une image stylisée en quelques étapes.
import torch
from diffusers import DiffusionPipeline, LCMScheduler
pipe = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0",
variant="fp16",
dtype=torch.float16
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl", adapter_name="lcm")
pipe.load_lora_weights("TheLastBen/Papercut_SDXL", weight_name="papercut.safetensors", adapter_name="papercut")
pipe.set_adapters(["lcm", "papercut"], adapter_weights=[1.0, 0.8])
prompt = "papercut, a cute fox"
generator = torch.manual_seed(0)
image = pipe(prompt, num_inference_steps=4, guidance_scale=1, generator=generator).images[0]
image
ControlNet
ControlNet sont des adaptateurs qui peuvent être entraînés sur une variété d’entrées telles que les contours canny, l’estimation de pose ou la profondeur. Le ControlNet peut être inséré dans le pipeline pour fournir un conditionnement et un contrôle supplémentaires au modèle, afin d’obtenir une génération plus précise.
Vous pouvez trouver d'autres modèles ControlNet entraînés sur d'autres entrées dans le dépôt de lllyasviel.
Chargez un modèle ControlNet entraîné sur des images canny et transmettez-le à ControlNetModel. Vous pouvez ensuite charger un modèle LCM dans StableDiffusionControlNetPipeline et remplacer le planificateur par LCMScheduler. Transmettez maintenant l'image canny au pipeline et générez une image.
Expérimentez avec différentes valeurs pour
num_inference_steps,controlnet_conditioning_scale,cross_attention_kwargsetguidance_scaleafin d’obtenir les meilleurs résultats.
import torch
import cv2
import numpy as np
from PIL import Image
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, LCMScheduler
from diffusers.utils import load_image, make_image_grid
image = load_image(
"https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((512, 512))
image = np.array(image)
low_threshold = 100
high_threshold = 200
image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image)
controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", dtype=torch.float16)
pipe = StableDiffusionControlNetPipeline.from_pretrained(
"SimianLuo/LCM_Dreamshaper_v7",
controlnet=controlnet,
dtype=torch.float16,
safety_checker=None,
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
generator = torch.manual_seed(0)
image = pipe(
"the mona lisa",
image=canny_image,
num_inference_steps=4,
generator=generator,
).images[0]
make_image_grid([canny_image, image], rows=1, cols=2)
Chargez un modèle ControlNet entraîné sur des images canny et transmettez-le à ControlNetModel. Vous pouvez ensuite charger un modèle Stable Diffusion v1.5 dans StableDiffusionControlNetPipeline et remplacer le planificateur par LCMScheduler. Utilisez la méthode load_lora_weights() pour charger les poids LCM-LoRA, puis transmettez l’image canny au pipeline et générez une image.
Expérimentez avec différentes valeurs pour
num_inference_steps,controlnet_conditioning_scale,cross_attention_kwargsetguidance_scaleafin d’obtenir les meilleurs résultats.
import torch
import cv2
import numpy as np
from PIL import Image
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, LCMScheduler
from diffusers.utils import load_image
image = load_image(
"https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((512, 512))
image = np.array(image)
low_threshold = 100
high_threshold = 200
image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image)
controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", dtype=torch.float16)
pipe = StableDiffusionControlNetPipeline.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5",
controlnet=controlnet,
dtype=torch.float16,
safety_checker=None,
variant="fp16"
).to("cuda") # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
generator = torch.manual_seed(0)
image = pipe(
"the mona lisa",
image=canny_image,
num_inference_steps=4,
guidance_scale=1.5,
controlnet_conditioning_scale=0.8,
cross_attention_kwargs={"scale": 1},
generator=generator,
).images[0]
image
T2I-Adapter
T2I-Adapter est un adaptateur encore plus léger que ControlNet, qui fournit une entrée supplémentaire pour conditionner un modèle pré-entraîné. Il est plus rapide que ControlNet, mais les résultats peuvent être légèrement moins bons.
Vous pouvez trouver d'autres points de contrôle T2I-Adapter entraînés sur d'autres entrées dans le dépôt de TencentArc.
Chargez un T2IAdapter entraîné sur des images canny et transmettez-le au StableDiffusionXLAdapterPipeline. Chargez ensuite un point de contrôle LCM dans UNet2DConditionModel et remplacez le planificateur par le LCMScheduler. Transmettez maintenant l'image canny au pipeline et générez une image.
import torch
import cv2
import numpy as np
from PIL import Image
from diffusers import StableDiffusionXLAdapterPipeline, UNet2DConditionModel, T2IAdapter, LCMScheduler
from diffusers.utils import load_image, make_image_grid
# detect the canny map in low resolution to avoid high-frequency details
image = load_image(
"https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((384, 384))
image = np.array(image)
low_threshold = 100
high_threshold = 200
image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image).resize((1024, 1216))
adapter = T2IAdapter.from_pretrained("TencentARC/t2i-adapter-canny-sdxl-1.0", dtype=torch.float16, variant="fp16").to("cuda") # or "mps", "xpu", "cpu"
unet = UNet2DConditionModel.from_pretrained(
"latent-consistency/lcm-sdxl",
dtype=torch.float16,
variant="fp16",
)
pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0",
unet=unet,
adapter=adapter,
dtype=torch.float16,
variant="fp16",
).to("cuda")
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
prompt = "the mona lisa, 4k picture, high quality"
negative_prompt = "extra digit, fewer digits, cropped, worst quality, low quality, glitch, deformed, mutated, ugly, disfigured"
generator = torch.manual_seed(0)
image = pipe(
prompt=prompt,
negative_prompt=negative_prompt,
image=canny_image,
num_inference_steps=4,
guidance_scale=5,
adapter_conditioning_scale=0.8,
adapter_conditioning_factor=1,
generator=generator,
).images[0]
Chargez un T2IAdapter entraîné sur des images canny et transmettez-le au StableDiffusionXLAdapterPipeline. Remplacez le planificateur par le LCMScheduler et utilisez la méthode load_lora_weights() pour charger les poids LCM-LoRA. Transmettez l’image canny au pipeline et générez une image.
import torch
import cv2
import numpy as np
from PIL import Image
from diffusers import StableDiffusionXLAdapterPipeline, UNet2DConditionModel, T2IAdapter, LCMScheduler
from diffusers.utils import load_image, make_image_grid
# detect the canny map in low resolution to avoid high-frequency details
image = load_image(
"https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((384, 384))
image = np.array(image)
low_threshold = 100
high_threshold = 200
image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image).resize((1024, 1024))
adapter = T2IAdapter.from_pretrained("TencentARC/t2i-adapter-canny-sdxl-1.0", dtype=torch.float16, variant="fp16").to("cuda") # or "mps", "xpu", "cpu"
pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0",
adapter=adapter,
dtype=torch.float16,
variant="fp16",
).to("cuda")
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")
prompt = "the mona lisa, 4k picture, high quality"
negative_prompt = "extra digit, fewer digits, cropped, worst quality, low quality, glitch, deformed, mutated, ugly, disfigured"
generator = torch.manual_seed(0)
image = pipe(
prompt=prompt,
negative_prompt=negative_prompt,
image=canny_image,
num_inference_steps=4,
guidance_scale=1.5,
adapter_conditioning_scale=0.8,
adapter_conditioning_factor=1,
generator=generator,
).images[0]
AnimateDiff
AnimateDiff est un adaptateur qui ajoute du mouvement à une image. Il peut être utilisé avec la plupart des modèles Stable Diffusion, les transformant ainsi en modèles de « génération de vidéo ». La génération de bons résultats avec un modèle vidéo nécessite généralement de générer plusieurs images (16-24), ce qui peut être très lent avec un modèle Stable Diffusion classique. LCM-LoRA peut accélérer ce processus en ne nécessitant que 4 à 8 étapes pour chaque image.
Chargez un AnimateDiffPipeline et passez-lui un MotionAdapter. Remplacez ensuite le planificateur par le LCMScheduler, puis combinez les deux adaptateurs LoRA à l'aide de la méthode ~loaders.UNet2DConditionLoadersMixin.set_adapters. Vous pouvez maintenant passer un prompt au pipeline et générer une image animée.
import torch
from diffusers import MotionAdapter, AnimateDiffPipeline, DDIMScheduler, LCMScheduler
from diffusers.utils import export_to_gif
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5")
pipe = AnimateDiffPipeline.from_pretrained(
"frankjoshua/toonyou_beta6",
motion_adapter=adapter,
).to("cuda") # or "mps", "xpu", "cpu"
# set scheduler
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
# load LCM-LoRA
pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5", adapter_name="lcm")
pipe.load_lora_weights("guoyww/animatediff-motion-lora-zoom-in", weight_name="diffusion_pytorch_model.safetensors", adapter_name="motion-lora")
pipe.set_adapters(["lcm", "motion-lora"], adapter_weights=[0.55, 1.2])
prompt = "best quality, masterpiece, 1girl, looking at viewer, blurry background, upper body, contemporary, dress"
generator = torch.manual_seed(0)
frames = pipe(
prompt=prompt,
num_inference_steps=5,
guidance_scale=1.25,
cross_attention_kwargs={"scale": 1},
num_frames=24,
generator=generator
).frames[0]
export_to_gif(frames, "animation.gif")
LatentConsistencyModelPipeline
classe diffusers.LatentConsistencyModelPipeline
< source >( vae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizerunet: UNet2DConditionModelscheduler: LCMSchedulersafety_checker: StableDiffusionSafetyCheckerfeature_extractor: CLIPImageProcessorPilimage_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = Nonerequires_safety_checker: bool = True )
Paramètres
- vae (AutoencoderKL) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
- text_encoder (CLIPTextModel) — Encodeur de texte figé (clip-vit-large-patch14).
- tokenizer (CLIPTokenizer) —
Un
CLIPTokenizerpour tokeniser le texte. - unet (UNet2DConditionModel) —
Un
UNet2DConditionModelpour débruyer les latents d'image encodés. - scheduler (SchedulerMixin) —
Un planificateur à utiliser en combinaison avec
unetpour débruyer les latents de l'image encodée. Actuellement, seul LCMScheduler est pris en charge. - safety_checker (
StableDiffusionSafetyChecker) — Module de classification qui estime si les images générées pourraient être considérées comme offensives ou nuisibles. Veuillez consulter la fiche modèle pour plus de détails sur les risques potentiels d’un modèle. - feature_extractor (CLIPImageProcessor) —
Un
CLIPImageProcessorpour extraire les caractéristiques des images générées ; utilisé comme entrées pour lesafety_checker. - requires_safety_checker (
bool, facultatif, par défautTrue) — Indique si le pipeline nécessite un composant de vérification de sécurité.
Pipeline pour la génération d'images à partir de texte utilisant un modèle de cohérence latente.
Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).
Le pipeline hérite également des méthodes de chargement suivantes :
- load_textual_inversion() pour charger les embeddings d'inversion textuelle
- load_lora_weights() pour charger les poids LoRA
- save_lora_weights() pour enregistrer les poids LoRA
- from_single_file() pour charger des fichiers
.ckpt - load_ip_adapter() pour charger des IP Adapters
__call__
< source >( prompt: str | list[str] = Noneheight: int | None = Nonewidth: int | None = Nonenum_inference_steps: int = 4original_inference_steps: int = Nonetimesteps: list = Noneguidance_scale: float = 8.5num_images_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecross_attention_kwargs: dict[str, typing.Any] | None = Noneclip_skip: int | None = Nonecallback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']**kwargs ) → StableDiffusionPipelineOutput or tuple
Paramètres
- prompt (
stroulist[str], facultatif) — Le prompt ou les prompts pour guider la génération d’images. S’il n’est pas défini, vous devez passerprompt_embeds. - height (
int, facultatif, par défautself.unet.config.sample_size * self.vae_scale_factor) — La hauteur en pixels de l’image générée. - width (
int, facultatif, par défautself.unet.config.sample_size * self.vae_scale_factor) — La largeur en pixels de l’image générée. - 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. - original_inference_steps (
int, facultatif) — Le nombre original d'étapes d'inférence utilisé pour générer un calendrier de timesteps linéairement espacés, à partir duquel nous extraironsnum_inference_stepstimesteps uniformément espacés comme calendrier final, conformément à la méthode Skipping-Step du papier (voir la section 4.3). S'il n'est pas défini, la valeur par défaut sera l'attributoriginal_inference_stepsdu scheduler. - timesteps (
list[int], facultatif) — Timesteps personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, desnum_inference_stepstimesteps équidistants sur l'agenda de timesteps d'entraînement/distillation LCM d'origine sont utilisés. Ils doivent être dans un ordre décroissant. - guidance_scale (
float, facultatif, valeur par défaut 7,5) — Une valeur de guidance scale plus élevée encourage le modèle à générer des images étroitement liées auprompttexte, au détriment de la qualité de l’image. Le guidance scale est activé lorsqueguidance_scale > 1. Notez que l’article original sur les modèles de cohérence latente utilise une formulation CFG différente où les échelles de guidance sont diminuées de 1 (ainsi, dans la formulation de l’article, le CFG est activé lorsqueguidance_scale > 0). - num_images_per_prompt (
int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite. - generator (
torch.Generatoroulist[torch.Generator], facultatif) — Untorch.Generatorpour rendre la génération déterministe. - latents (
torch.Tensor, 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 servir à ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents est généré par échantillonnage à l’aide dugeneratoraléatoire fourni. - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréeprompt. - ip_adapter_image — (
PipelineImageInput, facultatif) : Entrée d’image facultative pour travailler avec les IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], facultatif) — Embeddings d’image pré-générés pour IP-Adapter. Il doit s’agir d’une liste dont la longueur est égale au nombre d’IP-adapters. Chaque élément doit être un tenseur de forme(batch_size, num_images, emb_dim). Il doit contenir l’embedding d’image négatif sido_classifier_free_guidanceest défini surTrue. S’il n’est pas fourni, les embeddings sont calculés à partir de l’argument d’entréeip_adapter_image. - output_type (
str, facultatif, par défaut"pil") — Le format de sortie de l’image générée. Choisissez entrePIL.Imageounp.array. - return_dict (
bool, facultatif, par défautTrue) — Indique s'il faut retourner un StableDiffusionPipelineOutput plutôt qu'un simple tuple. - cross_attention_kwargs (
dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis auAttentionProcessortel que défini dansself.processor. - clip_skip (
int, facultatif) — Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de l'invite. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de l'invite. - 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_kwargscontiendra une liste de tous les tenseurs spécifiés parcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, facultatif) — La liste des entrées tensorielles pour la fonctioncallback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argumentcallback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut._callback_tensor_inputsde votre classe de pipeline.
Retourne
StableDiffusionPipelineOutput ou tuple
Si return_dict est True, StableDiffusionPipelineOutput est renvoyé,
sinon un tuple est renvoyé dont le premier élément est une liste des images générées et le
deuxième élément est une liste de bool indiquant si l’image générée correspondante contient
du contenu « not-safe-for-work » (nsfw).
La fonction d'appel du pipeline pour la génération.
Exemples :
>>> from diffusers import DiffusionPipeline
>>> import torch
>>> pipe = DiffusionPipeline.from_pretrained("SimianLuo/LCM_Dreamshaper_v7")
>>> # To save GPU memory, torch.float16 can be used, but it may compromise image quality.
>>> pipe.to(torch_device="cuda", torch_dtype=torch.float32)
>>> prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
>>> # Can be set to 1~50 steps. LCM support fast inference even <= 4 steps. Recommend: 1~8 steps.
>>> num_inference_steps = 4
>>> images = pipe(prompt=prompt, num_inference_steps=num_inference_steps, guidance_scale=8.0).images
>>> images[0].save("image.png")enable_freeu
< source >( s1: floats2: floatb1: floatb2: float )
Paramètres
- s1 (
float) — Facteur d'échelle pour l'étape 1 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de mitiger l'« effet de lissage excessif » dans le processus de débruitage amélioré. - s2 (
float) — Facteur d'échelle de l'étape 2 pour atténuer les contributions des caractéristiques de saut. Cela permet de mitiger l'« effet de sur-lissage » dans le processus de débruitage amélioré. - b1 (
float) — Facteur d'échelle pour l'étape 1 afin d'amplifier les contributions des fonctionnalités du backbone. - b2 (
float) — Facteur d'échelle pour l'étape 2 afin d'amplifier les contributions des fonctionnalités du backbone.
Active le mécanisme FreeU tel que décrit dans https://huggingface.co/papers/2309.11497.
Les suffixes qui suivent les facteurs d'échelle représentent les étapes où ils sont appliqués.
Veuillez consulter le dépôt officiel pour les combinaisons de valeurs qui fonctionnent bien avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.
Désactive le mécanisme FreeU s'il est activé.
encode_prompt
< source >( promptdevicenum_images_per_promptdo_classifier_free_guidancenegative_prompt = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonelora_scale: float | None = Noneclip_skip: int | None = None )
Paramètres
- prompt (
stroulist[str], facultatif) — prompt à encoder - device — (
torch.device) : torch device - num_images_per_prompt (
int) — nombre d'images à générer par invite - do_classifier_free_guidance (
bool) — indique s'il faut utiliser le classifier free guidance ou non - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - prompt_embeds (
torch.Tensor, 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éeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs 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, negative_prompt_embeds sera généré à partir de l'argument d'entréenegative_prompt. - lora_scale (
float, facultatif) — Un facteur d’échelle LoRA qui sera appliqué à toutes les couches LoRA de l’encodeur de texte si des couches LoRA sont chargées. - clip_skip (
int, facultatif) — Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de l'invite. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de l'invite.
Encode le prompt dans les états cachés de l'encodeur de texte.
get_guidance_scale_embedding
< source >( w: Tensorembedding_dim: int = 512dtype: dtype = torch.float32 ) → torch.Tensor
Paramètres
- w (
torch.Tensor) — Génère des vecteurs d’incorporation avec une échelle de guidage spécifiée afin d’enrichir ensuite les incorporations de pas de temps. - embedding_dim (
int, facultatif, par défaut 512) — Dimension des embeddings à générer. - dtype (
torch.dtype, facultatif, par défauttorch.float32) — Type de données des embeddings générés.
Retourne
torch.Tensor
Vecteurs d'embedding de forme (len(w), embedding_dim).
LatentConsistencyModelImg2ImgPipeline
classe diffusers.LatentConsistencyModelImg2ImgPipeline
< source >( vae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizerunet: UNet2DConditionModelscheduler: LCMSchedulersafety_checker: StableDiffusionSafetyCheckerfeature_extractor: CLIPImageProcessorPilimage_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = Nonerequires_safety_checker: bool = True )
Paramètres
- vae (AutoencoderKL) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
- text_encoder (CLIPTextModel) — Encodeur de texte figé (clip-vit-large-patch14).
- tokenizer (CLIPTokenizer) —
Un
CLIPTokenizerpour tokeniser le texte. - unet (UNet2DConditionModel) —
Un
UNet2DConditionModelpour débruyer les latents d'image encodés. - scheduler (SchedulerMixin) —
Un planificateur à utiliser en combinaison avec
unetpour débruyer les latents de l'image encodée. Actuellement, seul LCMScheduler est pris en charge. - safety_checker (
StableDiffusionSafetyChecker) — Module de classification qui estime si les images générées pourraient être considérées comme offensives ou nuisibles. Veuillez consulter la fiche modèle pour plus de détails sur les risques potentiels d’un modèle. - feature_extractor (CLIPImageProcessor) —
Un
CLIPImageProcessorpour extraire les caractéristiques des images générées ; utilisé comme entrées pour lesafety_checker. - requires_safety_checker (
bool, facultatif, par défautTrue) — Indique si le pipeline nécessite un composant de vérification de sécurité.
Pipeline pour la génération d'image à partir d'image à l'aide d'un modèle de cohérence latente.
Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).
Le pipeline hérite également des méthodes de chargement suivantes :
- load_textual_inversion() pour charger les embeddings d'inversion textuelle
- load_lora_weights() pour charger les poids LoRA
- save_lora_weights() pour enregistrer les poids LoRA
- from_single_file() pour charger des fichiers
.ckpt - load_ip_adapter() pour charger des IP Adapters
__call__
< source >( prompt: str | list[str] = Noneimage: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Nonenum_inference_steps: int = 4strength: float = 0.8original_inference_steps: int = Nonetimesteps: list = Noneguidance_scale: float = 8.5num_images_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecross_attention_kwargs: dict[str, typing.Any] | None = Noneclip_skip: int | None = Nonecallback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']**kwargs ) → StableDiffusionPipelineOutput or tuple
Paramètres
- prompt (
stroulist[str], facultatif) — Le prompt ou les prompts pour guider la génération d’images. S’il n’est pas défini, vous devez passerprompt_embeds. - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]oulist[np.ndarray]) —Imageou tenseur représentant un lot d'images à utiliser comme point de départ. Peut également accepter des latents d'image en tant queimage, mais si des latents sont transmis directement, ils ne sont pas réencodés. - 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. - strength (
float, facultatif, valeur par défaut 0.8) — Indique l'étendue de la transformation de l'imagede référence. Doit être compris entre 0 et 1. L'imageest utilisée comme point de départ et plus lestrengthest élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsquestrengthvaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dansnum_inference_steps. Une valeur de 1 ignore essentiellement l'image. - original_inference_steps (
int, facultatif) — Le nombre original d'étapes d'inférence utilisé pour générer un calendrier de timesteps linéairement espacés, à partir duquel nous extraironsnum_inference_stepstimesteps uniformément espacés comme calendrier final, conformément à la méthode Skipping-Step du papier (voir la section 4.3). S'il n'est pas défini, la valeur par défaut sera l'attributoriginal_inference_stepsdu scheduler. - timesteps (
list[int], facultatif) — Timesteps personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, desnum_inference_stepstimesteps équidistants sur l'agenda de timesteps d'entraînement/distillation LCM d'origine sont utilisés. Ils doivent être dans un ordre décroissant. - guidance_scale (
float, facultatif, valeur par défaut 7,5) — Une valeur de guidance scale plus élevée encourage le modèle à générer des images étroitement liées auprompttexte, au détriment de la qualité de l’image. Le guidance scale est activé lorsqueguidance_scale > 1. Notez que l’article original sur les modèles de cohérence latente utilise une formulation CFG différente où les échelles de guidance sont diminuées de 1 (ainsi, dans la formulation de l’article, le CFG est activé lorsqueguidance_scale > 0). - num_images_per_prompt (
int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite. - generator (
torch.Generatoroulist[torch.Generator], facultatif) — Untorch.Generatorpour rendre la génération déterministe. - latents (
torch.Tensor, 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 servir à ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents est généré par échantillonnage à l’aide dugeneratoraléatoire fourni. - prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entréeprompt. - ip_adapter_image — (
PipelineImageInput, facultatif) : Entrée d’image facultative pour travailler avec les IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], facultatif) — Embeddings d’image pré-générés pour IP-Adapter. Il doit s’agir d’une liste dont la longueur est égale au nombre d’IP-adapters. Chaque élément doit être un tenseur de forme(batch_size, num_images, emb_dim). Il doit contenir l’embedding d’image négatif sido_classifier_free_guidanceest défini surTrue. S’il n’est pas fourni, les embeddings sont calculés à partir de l’argument d’entréeip_adapter_image. - output_type (
str, facultatif, par défaut"pil") — Le format de sortie de l’image générée. Choisissez entrePIL.Imageounp.array. - return_dict (
bool, facultatif, par défautTrue) — Indique s'il faut retourner un StableDiffusionPipelineOutput plutôt qu'un simple tuple. - cross_attention_kwargs (
dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis auAttentionProcessortel que défini dansself.processor. - clip_skip (
int, facultatif) — Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de l'invite. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de l'invite. - 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_kwargscontiendra une liste de tous les tenseurs spécifiés parcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, facultatif) — La liste des entrées tensorielles pour la fonctioncallback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argumentcallback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut._callback_tensor_inputsde votre classe de pipeline.
Retourne
StableDiffusionPipelineOutput ou tuple
Si return_dict est True, StableDiffusionPipelineOutput est renvoyé,
sinon un tuple est renvoyé dont le premier élément est une liste des images générées et le
deuxième élément est une liste de bool indiquant si l’image générée correspondante contient
du contenu « not-safe-for-work » (nsfw).
La fonction d'appel du pipeline pour la génération.
Exemples :
>>> from diffusers import AutoPipelineForImage2Image
>>> import torch
>>> import PIL
>>> pipe = AutoPipelineForImage2Image.from_pretrained("SimianLuo/LCM_Dreamshaper_v7")
>>> # To save GPU memory, torch.float16 can be used, but it may compromise image quality.
>>> pipe.to(torch_device="cuda", torch_dtype=torch.float32)
>>> prompt = "High altitude snowy mountains"
>>> image = PIL.Image.open("./snowy_mountains.png")
>>> # Can be set to 1~50 steps. LCM support fast inference even <= 4 steps. Recommend: 1~8 steps.
>>> num_inference_steps = 4
>>> images = pipe(
... prompt=prompt, image=image, num_inference_steps=num_inference_steps, guidance_scale=8.0
... ).images
>>> images[0].save("image.png")enable_freeu
< source >( s1: floats2: floatb1: floatb2: float )
Paramètres
- s1 (
float) — Facteur d'échelle pour l'étape 1 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de mitiger l'« effet de lissage excessif » dans le processus de débruitage amélioré. - s2 (
float) — Facteur d'échelle de l'étape 2 pour atténuer les contributions des caractéristiques de saut. Cela permet de mitiger l'« effet de sur-lissage » dans le processus de débruitage amélioré. - b1 (
float) — Facteur d'échelle pour l'étape 1 afin d'amplifier les contributions des fonctionnalités du backbone. - b2 (
float) — Facteur d'échelle pour l'étape 2 afin d'amplifier les contributions des fonctionnalités du backbone.
Active le mécanisme FreeU tel que décrit dans https://huggingface.co/papers/2309.11497.
Les suffixes qui suivent les facteurs d'échelle représentent les étapes où ils sont appliqués.
Veuillez consulter le dépôt officiel pour les combinaisons de valeurs qui fonctionnent bien avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.
Désactive le mécanisme FreeU s'il est activé.
encode_prompt
< source >( promptdevicenum_images_per_promptdo_classifier_free_guidancenegative_prompt = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonelora_scale: float | None = Noneclip_skip: int | None = None )
Paramètres
- prompt (
stroulist[str], facultatif) — prompt à encoder - device — (
torch.device) : torch device - num_images_per_prompt (
int) — nombre d'images à générer par invite - do_classifier_free_guidance (
bool) — indique s'il faut utiliser le classifier free guidance ou non - negative_prompt (
stroulist[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passernegative_prompt_embedsà la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré siguidance_scaleest inférieur à1). - prompt_embeds (
torch.Tensor, 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éeprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs 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, negative_prompt_embeds sera généré à partir de l'argument d'entréenegative_prompt. - lora_scale (
float, facultatif) — Un facteur d’échelle LoRA qui sera appliqué à toutes les couches LoRA de l’encodeur de texte si des couches LoRA sont chargées. - clip_skip (
int, facultatif) — Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de l'invite. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de l'invite.
Encode le prompt dans les états cachés de l'encodeur de texte.
get_guidance_scale_embedding
< source >( w: Tensorembedding_dim: int = 512dtype: dtype = torch.float32 ) → torch.Tensor
Paramètres
- w (
torch.Tensor) — Génère des vecteurs d’incorporation avec une échelle de guidage spécifiée afin d’enrichir ensuite les incorporations de pas de temps. - embedding_dim (
int, facultatif, par défaut 512) — Dimension des embeddings à générer. - dtype (
torch.dtype, facultatif, par défauttorch.float32) — Type de données des embeddings générés.
Retourne
torch.Tensor
Vecteurs d'embedding de forme (len(w), embedding_dim).
StableDiffusionPipelineOutput
classe diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput
< source >( images: list[PIL.Image.Image] | numpy.ndarraynsfw_content_detected: list[bool] | None )
Paramètres
- images (
list[PIL.Image.Image]ounp.ndarray) — liste d'images PIL débruitées de longueurbatch_sizeou tableau NumPy de forme(batch_size, height, width, num_channels). - nsfw_content_detected (
list[bool]) — liste indiquant si l'image générée correspondante contient du contenu « not-safe-for-work » (nsfw) ouNonesi la vérification de sécurité n'a pas pu être effectuée.
Classe de sortie pour les pipelines Stable Diffusion.