Buckets:
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
image initiale
image générée
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
image initiale
image générée
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
image initiale
image générée
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[[diffusers.LatentConsistencyModelPipeline]]
diffusers.LatentConsistencyModelPipeline[[diffusers.LatentConsistencyModelPipeline]]
diffusers.LatentConsistencyModelPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: LCMScheduler, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None, requires_safety_checker: bool = True)
Paramètres :
vae (AutoencoderKL) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de 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 CLIPTokenizer pour tokeniser le texte.
unet (UNet2DConditionModel) : un UNet2DConditionModel pour débruyer les latents d'image encodés.
scheduler (SchedulerMixin) : Un planificateur à utiliser en combinaison avec unet pour 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 préjudices potentiels d'un modèle.
feature_extractor (CLIPImageProcessor) : un CLIPImageProcessor pour extraire des caractéristiques des images générées ; utilisé comme entrées pour le safety_checker.
requires_safety_checker (bool, facultatif, par défaut True) : 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
appel[[diffusers.LatentConsistencyModelPipeline.call]]
__call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 4, original_inference_steps: int = None, timesteps: list[int] = None, guidance_scale: float = 8.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = 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: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_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'], **kwargs)
Paramètres :
prompt (str ou list[str], facultatif) : Le prompt ou les prompts pour guider la génération d’images. S’il n’est pas défini, vous devez passer prompt_embeds.
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.
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.
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 extrairons num_inference_steps timesteps 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'attribut original_inference_steps du planificateur.
timesteps (list[int], facultatif) : Timesteps personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, des timesteps num_inference_steps équidistants sur l'agenda de timesteps d'entraînement/distillation LCM d'origine sont utilisés. Ils doivent être dans l'ordre décroissant.
guidance_scale (float, facultatif, valeur par défaut 7,5) : Une valeur plus élevée de l'échelle de guidage encourage le modèle à générer des images étroitement liées au prompt texte, au détriment de la qualité de l'image. L'échelle de guidage est activée lorsque guidance_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 guidage sont diminuées de 1 (ainsi, dans la formulation de l'article, le CFG est activé lorsque guidance_scale > 0).
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 torch.Generator pour 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 ê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 est généré par échantillonnage à l'aide du generator aléatoire fourni.
prompt_embeds (torch.Tensor, facultatif) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée prompt.
ip_adapter_image : (PipelineImageInput, facultatif) : Entrée d'image facultative pour travailler avec les IP Adapters.
ip_adapter_image_embeds (list[torch.Tensor], facultatif) : Incrustations d’images pré-générées 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’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.Image ou np.array.
return_dict (bool, facultatif, par défaut True) : 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 à l'AttentionProcessor tel que défini dans self.processor.
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.
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[[diffusers.LatentConsistencyModelPipeline.enable_freeu]]
enable_freeu(s1: float, s2: float, b1: float, b2: 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 d'atténuer l'« effet de lissage excessif » dans le processus de débruitage amélioré.
s2 (float) : Facteur d'échelle pour l'étape 2 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de réduire l'« effet de lissage excessif » 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 connues pour fonctionner correctement avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.
disable_freeu[[diffusers.LatentConsistencyModelPipeline.disable_freeu]]
disable_freeu()
Désactive le mécanisme FreeU s'il est activé.
encode_prompt[[diffusers.LatentConsistencyModelPipeline.encode_prompt]]
encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
Paramètres :
prompt (str ou list[str], facultatif) : invite à encoder
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).
prompt_embeds (torch.Tensor, 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.Tensor, facultatif) : Embeddings de texte négatif 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, negative_prompt_embeds sera généré à partir de l'argument d'entrée negative_prompt.
lora_scale (float, facultatif) : une échelle LoRA qui sera appliquée à 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 prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt.
Encode le prompt dans les états cachés de l'encodeur de texte.
get_guidance_scale_embedding[[diffusers.LatentConsistencyModelPipeline.get_guidance_scale_embedding]]
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
Paramètres :
w (torch.Tensor) : Génère des vecteurs d'incorporation avec une échelle de guidage spécifiée afin d'enrichir par la suite 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éfaut torch.float32) : Type de données des embeddings générés.
Retourne : torch.Tensor
Vecteurs d'embedding de forme (len(w), embedding_dim).
LatentConsistencyModelImg2ImgPipeline[[diffusers.LatentConsistencyModelImg2ImgPipeline]]
diffusers.LatentConsistencyModelImg2ImgPipeline[[diffusers.LatentConsistencyModelImg2ImgPipeline]]
diffusers.LatentConsistencyModelImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: LCMScheduler, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None, requires_safety_checker: bool = True)
Paramètres :
vae (AutoencoderKL) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de 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 CLIPTokenizer pour tokeniser le texte.
unet (UNet2DConditionModel) : un UNet2DConditionModel pour débruyer les latents d'image encodés.
scheduler (SchedulerMixin) : Un planificateur à utiliser en combinaison avec unet pour 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 préjudices potentiels d'un modèle.
feature_extractor (CLIPImageProcessor) : un CLIPImageProcessor pour extraire des caractéristiques des images générées ; utilisé comme entrées pour le safety_checker.
requires_safety_checker (bool, facultatif, par défaut True) : 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
appel[[diffusers.LatentConsistencyModelImg2ImgPipeline.call]]
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, num_inference_steps: int = 4, strength: float = 0.8, original_inference_steps: int = None, timesteps: list[int] = None, guidance_scale: float = 8.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = 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: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_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'], **kwargs)
Paramètres :
prompt (str ou list[str], facultatif) : Le prompt ou les prompts pour guider la génération d’images. S’il n’est pas défini, vous devez passer prompt_embeds.
image (torch.Tensor, PIL.Image.Image, np.ndarray, list[torch.Tensor], list[PIL.Image.Image] ou list[np.ndarray]) : Image ou tenseur représentant un lot d'images à utiliser comme point de départ. Peut également accepter des latents d'image en tant que image, 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 dans quelle mesure transformer l'image de référence. Doit être compris entre 0 et 1. image est utilisé comme point de départ et plus le strength est élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque strength vaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dans num_inference_steps. Une valeur de 1 ignore essentiellement 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 extrairons num_inference_steps timesteps 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'attribut original_inference_steps du planificateur.
timesteps (list[int], facultatif) : Timesteps personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, des timesteps num_inference_steps équidistants sur l'agenda de timesteps d'entraînement/distillation LCM d'origine sont utilisés. Ils doivent être dans l'ordre décroissant.
guidance_scale (float, facultatif, valeur par défaut 7,5) : Une valeur plus élevée de l'échelle de guidage encourage le modèle à générer des images étroitement liées au prompt texte, au détriment de la qualité de l'image. L'échelle de guidage est activée lorsque guidance_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 guidage sont diminuées de 1 (ainsi, dans la formulation de l'article, le CFG est activé lorsque guidance_scale > 0).
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 torch.Generator pour 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 ê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 est généré par échantillonnage à l'aide du generator aléatoire fourni.
prompt_embeds (torch.Tensor, facultatif) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée prompt.
ip_adapter_image : (PipelineImageInput, facultatif) : Entrée d'image facultative pour travailler avec les IP Adapters.
ip_adapter_image_embeds (list[torch.Tensor], facultatif) : Incrustations d’images pré-générées 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’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.Image ou np.array.
return_dict (bool, facultatif, par défaut True) : 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 à l'AttentionProcessor tel que défini dans self.processor.
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.
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[[diffusers.LatentConsistencyModelImg2ImgPipeline.enable_freeu]]
enable_freeu(s1: float, s2: float, b1: float, b2: 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 d'atténuer l'« effet de lissage excessif » dans le processus de débruitage amélioré.
s2 (float) : Facteur d'échelle pour l'étape 2 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de réduire l'« effet de lissage excessif » 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 connues pour fonctionner correctement avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.
disable_freeu[[diffusers.LatentConsistencyModelImg2ImgPipeline.disable_freeu]]
disable_freeu()
Désactive le mécanisme FreeU s'il est activé.
encode_prompt[[diffusers.LatentConsistencyModelImg2ImgPipeline.encode_prompt]]
encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
Paramètres :
prompt (str ou list[str], facultatif) : invite à encoder
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).
prompt_embeds (torch.Tensor, 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.Tensor, facultatif) : Embeddings de texte négatif 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, negative_prompt_embeds sera généré à partir de l'argument d'entrée negative_prompt.
lora_scale (float, facultatif) : une échelle LoRA qui sera appliquée à 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 prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt.
Encode le prompt dans les états cachés de l'encodeur de texte.
get_guidance_scale_embedding[[diffusers.LatentConsistencyModelImg2ImgPipeline.get_guidance_scale_embedding]]
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
Paramètres :
w (torch.Tensor) : Génère des vecteurs d'incorporation avec une échelle de guidage spécifiée afin d'enrichir par la suite 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éfaut torch.float32) : Type de données des embeddings générés.
Retourne : torch.Tensor
Vecteurs d'embedding de forme (len(w), embedding_dim).
StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]
diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]
diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)
Paramètres :
images (list[PIL.Image.Image] ou np.ndarray) : liste d'images PIL débruitées de longueur batch_size ou tableau NumPy de forme (batch_size, height, width, num_channels).
nsfw_content_detected (list[bool]) : liste indiquant si l'image générée correspondante contient du contenu « not-safe-for-work » (nsfw) ou None si la vérification de sécurité n'a pas pu être effectuée.
Classe de sortie pour les pipelines Stable Diffusion.
Xet Storage Details
- Size:
- 62.2 kB
- Xet hash:
- c20b2f78388003c4556c7330992ebe768098bb406b8ad875225519bcb97bf49f
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.