Diffusers documentation
Modelos de consistencia latente
Modelos de consistencia latente
Los Latent Consistency Models (LCMs) fueron propuestos en Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference por Simian Luo, Yiqin Tan, Longbo Huang, Jian Li y Hang Zhao.
El resumen del artículo es el siguiente:
Los modelos de difusión latente (LDM) han logrado resultados notables en la síntesis de imágenes de alta resolución. Sin embargo, el proceso de muestreo iterativo es computacionalmente intensivo y provoca una generación lenta. Inspirados en los Consistency Models (song et al.), proponemos los Latent Consistency Models (LCM), que permiten una inferencia rápida con un mínimo de pasos en cualquier LDM preentrenado, incluido Stable Diffusion (rombach et al). Al considerar el proceso de difusión inversa guiado como la resolución de una EDO de flujo de probabilidad aumentada (PF-ODE), los LCM están diseñados para predecir directamente la solución de dicha EDO en el espacio latente, lo que mitiga la necesidad de numerosas iteraciones y permite un muestreo rápido y de alta fidelidad. Destilados de manera eficiente a partir de modelos de difusión preentrenados con guía libre de clasificador, un LCM de alta calidad de 768 x 768 con 2~4 pasos requiere solo 32 horas de GPU A100 para su entrenamiento. Además, introducimos el Latent Consistency Fine-tuning (LCF), un método novedoso diseñado específicamente para el ajuste fino de LCM en conjuntos de datos de imágenes personalizados. La evaluación en el conjunto de datos LAION-5B-Aesthetics demuestra que los LCM alcanzan un rendimiento de generación de texto a imagen de última generación con inferencia de pocos pasos. Página del proyecto: this https URL.
Puede encontrarse una demostración del punto de control SimianLuo/LCM_Dreamshaper_v7 aquí.
Los pipelines fueron contribuidos por luosiallen, nagolinc y dg845.
Los LCM y LCM-LoRA están disponibles para Stable Diffusion v1.5, Stable Diffusion XL y el modelo SSD-1B. Puedes encontrar sus puntos de control en las colecciones de Latent Consistency.
Texto a imagen
Para usar LCM, debes cargar el checkpoint de LCM para tu modelo compatible en UNet2DConditionModel y reemplazar el scheduler con LCMScheduler. Luego puedes usar el pipeline como de costumbre y pasar un prompt de texto para generar una imagen en solo 4 pasos.
Hay algunas notas que conviene tener en cuenta al usar LCMs:
- Por lo general, el tamaño del lote se duplica dentro del pipeline para la guía sin clasificador. Sin embargo, LCM aplica la guía mediante embeddings de guía y no necesita duplicar el tamaño del lote, lo que conduce a una inferencia más rápida. La desventaja es que los prompts negativos no funcionan con LCM porque no tienen ningún efecto en el proceso de desruido.
- El rango ideal para
guidance_scalees [3., 13.] porque es con lo que se entrenó el UNet. Sin embargo, desactivarguidance_scalecon un valor de 1.0 también es efectivo en la mayoría de los casos.
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
Para usar LCM-LoRAs, debes reemplazar el scheduler con LCMScheduler y cargar los pesos de LCM-LoRA con el método load_lora_weights(). Luego puedes usar el pipeline como de costumbre y pasar un prompt de texto para generar una imagen en solo 4 pasos.
Hay algunas notas que conviene tener en cuenta al usar LCM-LoRAs:
- Por lo general, el tamaño del lote se duplica dentro del pipeline para la guía sin clasificador. Sin embargo, LCM aplica la guía mediante embeddings de guía y no necesita duplicar el tamaño del lote, lo que conduce a una inferencia más rápida. La desventaja es que los prompts negativos no funcionan con LCM porque no tienen ningún efecto en el proceso de desruido.
- Puedes usar guidance con LCM-LoRAs, pero es muy sensible a valores altos de
guidance_scaley puede provocar artefactos en la imagen generada. Los mejores valores que hemos encontrado están entre [1.0, 2.0]. - Reemplace stabilityai/stable-diffusion-xl-base-1.0 por cualquier modelo afinado. Por ejemplo, pruebe usar el checkpoint animagine-xl para generar imágenes de anime con 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
Imagen a imagen
Para usar LCMs para image-to-image, debes cargar el checkpoint de LCM para tu modelo compatible en UNet2DConditionModel y reemplazar el scheduler con LCMScheduler. Luego puedes usar el pipeline como de costumbre, pasando un prompt de texto y una imagen inicial para generar una imagen en solo 4 pasos.
Experimenta con diferentes valores para
num_inference_steps,strengthyguidance_scalepara obtener los mejores resultados.
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
Para usar LCM-LoRAs para image-to-image, debes reemplazar el scheduler con LCMScheduler y cargar los pesos de LCM-LoRA con el método load_lora_weights(). Luego puedes usar el pipeline como de costumbre, pasando un prompt de texto y una imagen inicial para generar una imagen en solo 4 pasos.
Experimenta con diferentes valores para
num_inference_steps,strengthyguidance_scalepara obtener los mejores resultados.
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
Para usar LCM-LoRAs para inpainting, debes reemplazar el scheduler con LCMScheduler y cargar los pesos de LCM-LoRA con el método load_lora_weights(). Luego puedes usar el pipeline como de costumbre, pasando un prompt de texto, una imagen inicial y una imagen de máscara para generar una imagen en solo 4 pasos.
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
Adaptadores
Los LCM son compatibles con adaptadores como LoRA, ControlNet, T2I-Adapter y AnimateDiff. Puedes llevar la velocidad de los LCM a estos adaptadores para generar imágenes en un estilo determinado o condicionar el modelo con otra entrada, como una imagen canny.
LoRA
Los adaptadores LoRA pueden afinarse rápidamente para aprender un nuevo estilo a partir de solo unas pocas imágenes e integrarse en un modelo preentrenado para generar imágenes en ese estilo.
Carga el checkpoint de LCM para tu modelo compatible en UNet2DConditionModel y reemplaza el scheduler con LCMScheduler. Luego, puedes usar el método load_lora_weights() para cargar los pesos de LoRA en el LCM y generar una imagen estilizada en pocos pasos.
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
Sustituye el programador por el LCMScheduler. A continuación, puedes usar el método load_lora_weights() para cargar los pesos de LCM-LoRA y el LoRA de estilo que desees utilizar. Combina ambos adaptadores LoRA con el método ~loaders.UNet2DConditionLoadersMixin.set_adapters y genera una imagen con estilo en pocos pasos.
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 son adaptadores que pueden entrenarse con una variedad de entradas, como bordes canny, estimación de pose o profundidad. El ControlNet puede insertarse en el pipeline para proporcionar condicionamiento y control adicionales al modelo, logrando una generación más precisa.
Puedes encontrar modelos adicionales de ControlNet entrenados con otras entradas en el repositorio de lllyasviel.
Carga un modelo de ControlNet entrenado con imágenes canny y pásalo a ControlNetModel. Luego puedes cargar un modelo LCM en StableDiffusionControlNetPipeline y reemplazar el programador con LCMScheduler. Ahora pasa la imagen canny a la tubería y genera una imagen.
Experimenta con diferentes valores para
num_inference_steps,controlnet_conditioning_scale,cross_attention_kwargsyguidance_scalepara obtener los mejores resultados.
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)
Carga un modelo de ControlNet entrenado con imágenes canny y pásalo a ControlNetModel. Luego puedes cargar un modelo de Stable Diffusion v1.5 en StableDiffusionControlNetPipeline y reemplazar el scheduler con LCMScheduler. Usa el método load_lora_weights() para cargar los pesos de LCM-LoRA, y pasa la imagen canny a la pipeline para generar una imagen.
Experimenta con diferentes valores para
num_inference_steps,controlnet_conditioning_scale,cross_attention_kwargsyguidance_scalepara obtener los mejores resultados.
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 es un adaptador aún más ligero que ControlNet, que proporciona una entrada adicional para condicionar un modelo preentrenado. Es más rápido que ControlNet, pero los resultados pueden ser ligeramente peores.
Puedes encontrar puntos de control adicionales de T2I-Adapter entrenados con otras entradas en el repositorio de TencentArc.
Carga un T2IAdapter entrenado con imágenes canny y pásalo a StableDiffusionXLAdapterPipeline. Luego, carga un checkpoint de LCM en UNet2DConditionModel y reemplaza el scheduler con LCMScheduler. Ahora, pasa la imagen canny a la pipeline y genera una imagen.
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]
Carga un T2IAdapter entrenado con imágenes canny y pásalo a StableDiffusionXLAdapterPipeline. Reemplaza el scheduler con LCMScheduler y usa el método load_lora_weights() para cargar los pesos de LCM-LoRA. Pasa la imagen canny a la pipeline y genera una imagen.
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 es un adaptador que añade movimiento a una imagen. Puede usarse con la mayoría de los modelos de Stable Diffusion, convirtiéndolos efectivamente en modelos de “generación de video”. Generar buenos resultados con un modelo de video suele requerir generar múltiples fotogramas (16-24), lo cual puede ser muy lento con un modelo regular de Stable Diffusion. LCM-LoRA puede acelerar este proceso al requerir solo 4-8 pasos por cada fotograma.
Carga un AnimateDiffPipeline y pásale un MotionAdapter. Luego, reemplaza el scheduler con el LCMScheduler y combina ambos adaptadores LoRA con el método ~loaders.UNet2DConditionLoadersMixin.set_adapters. Ahora puedes pasar un prompt al pipeline y generar una imagen animada.
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
clase 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 )
Parámetros
- vae (AutoencoderKL) — Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes a partir de y hacia representaciones latentes.
- text_encoder (CLIPTextModel) — Codificador de texto congelado (clip-vit-large-patch14).
- tokenizer (CLIPTokenizer) —
Un
CLIPTokenizerpara tokenizar texto. - unet (UNet2DConditionModel) —
Un
UNet2DConditionModelpara desruidar los latentes de la imagen codificada. - scheduler (SchedulerMixin) —
Un scheduler para usar en combinación con
unetpara desruidar los latentes de la imagen codificada. Actualmente solo soporta LCMScheduler. - safety_checker (
StableDiffusionSafetyChecker) — Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la ficha del modelo para obtener más detalles sobre los posibles daños de un modelo. - feature_extractor (CLIPImageProcessor) —
Un
CLIPImageProcessorpara extraer características de las imágenes generadas; se utiliza como entrada para elsafety_checker. - requires_safety_checker (
bool, opcional, valor predeterminadoTrue) — Indica si el pipeline requiere un componente de verificación de seguridad.
Pipeline para la generación de imágenes a partir de texto utilizando un modelo de consistencia latente.
Este modelo hereda de DiffusionPipeline. Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).
El pipeline también hereda los siguientes métodos de carga:
- load_textual_inversion() para cargar incrustaciones de inversión textual
- load_lora_weights() para cargar los pesos de LoRA
- save_lora_weights() para guardar los pesos de LoRA
- from_single_file() para la carga de archivos
.ckpt - load_ip_adapter() para cargar 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
Parámetros
- prompt (
strolist[str], opcional) — El prompt o prompts para guiar la generación de imágenes. Si no se define, debe pasarprompt_embeds. - height (
int, opcional, valor predeterminadoself.unet.config.sample_size * self.vae_scale_factor) — La altura en píxeles de la imagen generada. - width (
int, opcional, valor predeterminadoself.unet.config.sample_size * self.vae_scale_factor) — El ancho en píxeles de la imagen generada. - num_inference_steps (
int, opcional, valor predeterminado 50) — El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. - original_inference_steps (
int, opcional) — El número original de pasos de inferencia utilizado para generar un calendario de pasos de tiempo espaciados linealmente, del cual extraeremosnum_inference_stepspasos de tiempo equiespaciados como nuestro calendario final de pasos de tiempo, siguiendo el método Skipping-Step del artículo (ver la sección 4.3). Si no se establece, este valor será por defecto el atributooriginal_inference_stepsdel programador. - timesteps (
list[int], opcional) — Pasos de tiempo personalizados para usar en el proceso de desruido. Si no se definen, se utilizannum_inference_stepspasos de tiempo equiespaciados en la programación original de pasos de tiempo de entrenamiento/destilación de LCM. Deben estar en orden descendente. - guidance_scale (
float, opcional, valor predeterminado 7.5) — Un valor de escala de guía más alto anima al modelo a generar imágenes estrechamente vinculadas al textoprompta costa de una menor calidad de imagen. La escala de guía se habilita cuandoguidance_scale > 1. Tenga en cuenta que el artículo original de los modelos de consistencia latente utiliza una formulación de CFG diferente en la que las escalas de guía se reducen en 1 (por lo que en la formulación del artículo, CFG se habilita cuandoguidance_scale > 0). - num_images_per_prompt (
int, opcional, valor predeterminado 1) — El número de imágenes que se generarán por indicación. - generator (
torch.Generatorolist[torch.Generator], opcional) — Untorch.Generatorpara hacer que la generación sea determinista. - latents (
torch.Tensor, opcional) — Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando elgeneratoraleatorio suministrado. - prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entradaprompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Debe contener la incrustación de imagen negativa sido_classifier_free_guidanceestá establecido enTrue. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - output_type (
str, opcional, por defecto"pil") — El formato de salida de la imagen generada. Elija entrePIL.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un StableDiffusionPipelineOutput en lugar de una tupla simple. - cross_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessortal como se define enself.processor. - clip_skip (
int, opcional) — Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la penúltima capa para calcular los embeddings del prompt. - callback_on_step_end (
Callable, opcional) — Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos:callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline.
Devuelve
StableDiffusionPipelineOutput o tuple
Si return_dict es True, se devuelve StableDiffusionPipelineOutput,
en caso contrario se devuelve una tuple cuyo primer elemento es una lista con las imágenes generadas y el
segundo elemento es una lista de bool que indica si la imagen generada correspondiente contiene
contenido “not-safe-for-work” (nsfw).
La función de llamada para el pipeline de generación.
Ejemplos:
>>> 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 )
Parámetros
- s1 (
float) — Factor de escala para la etapa 1 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el “efecto de sobre-almohadillado” en el proceso de desruido mejorado. - s2 (
float) — Factor de escala para la etapa 2 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el “efecto de sobre-almohadillado” en el proceso de desruido mejorado. - b1 (
float) — Factor de escala para la etapa 1 para amplificar las contribuciones de las características del backbone. - b2 (
float) — Factor de escala para la etapa 2 para amplificar las contribuciones de las características del backbone.
Habilita el mecanismo FreeU tal como se describe en https://huggingface.co/papers/2309.11497.
Los sufijos después de los factores de escalado representan las etapas en las que se están aplicando.
Consulte el repositorio oficial para conocer las combinaciones de valores que funcionan bien en diferentes pipelines, como Stable Diffusion v1, v2 y Stable Diffusion XL.
Desactiva el mecanismo FreeU si está habilitado.
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 )
Parámetros
- prompt (
strolist[str], opcional) — prompt a codificar - device — (
torch.device): dispositivo de torch - num_images_per_prompt (
int) — número de imágenes que deben generarse por prompt - do_classifier_free_guidance (
bool) — si se debe usar classifier free guidance o no - negative_prompt (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasarnegative_prompt_embedsen su lugar. Se ignora cuando no se usa guía (es decir, se ignora siguidance_scalees menor que1). - prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, las incrustaciones de texto se generarán a partir del argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entradanegative_prompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. - clip_skip (
int, opcional) — Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la penúltima capa para calcular los embeddings del prompt.
Codifica el prompt en estados ocultos del codificador de texto.
get_guidance_scale_embedding
< source >( w: Tensorembedding_dim: int = 512dtype: dtype = torch.float32 ) → torch.Tensor
Parámetros
- w (
torch.Tensor) — Genera vectores de incrustación con una escala de orientación especificada para enriquecer posteriormente las incrustaciones de paso temporal. - embedding_dim (
int, opcional, valor predeterminado 512) — Dimensión de los embeddings a generar. - dtype (
torch.dtype, opcional, valor predeterminadotorch.float32) — Tipo de datos de los embeddings generados.
Devuelve
torch.Tensor
Vectores de incrustación con forma (len(w), embedding_dim).
LatentConsistencyModelImg2ImgPipeline
clase 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 )
Parámetros
- vae (AutoencoderKL) — Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes a partir de y hacia representaciones latentes.
- text_encoder (CLIPTextModel) — Codificador de texto congelado (clip-vit-large-patch14).
- tokenizer (CLIPTokenizer) —
Un
CLIPTokenizerpara tokenizar texto. - unet (UNet2DConditionModel) —
Un
UNet2DConditionModelpara desruidar los latentes de la imagen codificada. - scheduler (SchedulerMixin) —
Un scheduler para usar en combinación con
unetpara desruidar los latentes de la imagen codificada. Actualmente solo soporta LCMScheduler. - safety_checker (
StableDiffusionSafetyChecker) — Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la ficha del modelo para obtener más detalles sobre los posibles daños de un modelo. - feature_extractor (CLIPImageProcessor) —
Un
CLIPImageProcessorpara extraer características de las imágenes generadas; se utiliza como entrada para elsafety_checker. - requires_safety_checker (
bool, opcional, valor predeterminadoTrue) — Indica si el pipeline requiere un componente de verificación de seguridad.
Pipeline para la generación de imagen a imagen utilizando un modelo de consistencia latente.
Este modelo hereda de DiffusionPipeline. Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).
El pipeline también hereda los siguientes métodos de carga:
- load_textual_inversion() para cargar incrustaciones de inversión textual
- load_lora_weights() para cargar los pesos de LoRA
- save_lora_weights() para guardar los pesos de LoRA
- from_single_file() para la carga de archivos
.ckpt - load_ip_adapter() para cargar 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
Parámetros
- prompt (
strolist[str], opcional) — El prompt o prompts para guiar la generación de imágenes. Si no se define, debe pasarprompt_embeds. - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[np.ndarray]) —Imageo tensor que representa un lote de imágenes para usarse como punto de partida. También puede aceptar latentes de imagen comoimage, pero si se pasan latentes directamente, no se vuelven a codificar. - num_inference_steps (
int, opcional, valor predeterminado 50) — El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. - strength (
float, opcional, valor predeterminado 0.8) — Indica el grado en que se transforma laimagede referencia. Debe estar entre 0 y 1.imagese utiliza como punto de partida y se añade más ruido a medida que aumenta elstrength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuandostrengthes 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado ennum_inference_steps. Un valor de 1 ignora esencialmenteimage. - original_inference_steps (
int, opcional) — El número original de pasos de inferencia utilizado para generar un calendario de pasos de tiempo espaciados linealmente, del cual extraeremosnum_inference_stepspasos de tiempo equiespaciados como nuestro calendario final de pasos de tiempo, siguiendo el método Skipping-Step del artículo (ver la sección 4.3). Si no se establece, este valor será por defecto el atributooriginal_inference_stepsdel programador. - timesteps (
list[int], opcional) — Pasos de tiempo personalizados para usar en el proceso de desruido. Si no se definen, se utilizannum_inference_stepspasos de tiempo equiespaciados en la programación original de pasos de tiempo de entrenamiento/destilación de LCM. Deben estar en orden descendente. - guidance_scale (
float, opcional, valor predeterminado 7.5) — Un valor de escala de guía más alto anima al modelo a generar imágenes estrechamente vinculadas al textoprompta costa de una menor calidad de imagen. La escala de guía se habilita cuandoguidance_scale > 1. Tenga en cuenta que el artículo original de los modelos de consistencia latente utiliza una formulación de CFG diferente en la que las escalas de guía se reducen en 1 (por lo que en la formulación del artículo, CFG se habilita cuandoguidance_scale > 0). - num_images_per_prompt (
int, opcional, valor predeterminado 1) — El número de imágenes que se generarán por indicación. - generator (
torch.Generatorolist[torch.Generator], opcional) — Untorch.Generatorpara hacer que la generación sea determinista. - latents (
torch.Tensor, opcional) — Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando elgeneratoraleatorio suministrado. - prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entradaprompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Debe contener la incrustación de imagen negativa sido_classifier_free_guidanceestá establecido enTrue. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - output_type (
str, opcional, por defecto"pil") — El formato de salida de la imagen generada. Elija entrePIL.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un StableDiffusionPipelineOutput en lugar de una tupla simple. - cross_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessortal como se define enself.processor. - clip_skip (
int, opcional) — Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la penúltima capa para calcular los embeddings del prompt. - callback_on_step_end (
Callable, opcional) — Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos:callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline.
Devuelve
StableDiffusionPipelineOutput o tuple
Si return_dict es True, se devuelve StableDiffusionPipelineOutput,
en caso contrario se devuelve una tuple cuyo primer elemento es una lista con las imágenes generadas y el
segundo elemento es una lista de bool que indica si la imagen generada correspondiente contiene
contenido “not-safe-for-work” (nsfw).
La función de llamada para el pipeline de generación.
Ejemplos:
>>> 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 )
Parámetros
- s1 (
float) — Factor de escala para la etapa 1 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el “efecto de sobre-almohadillado” en el proceso de desruido mejorado. - s2 (
float) — Factor de escala para la etapa 2 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el “efecto de sobre-almohadillado” en el proceso de desruido mejorado. - b1 (
float) — Factor de escala para la etapa 1 para amplificar las contribuciones de las características del backbone. - b2 (
float) — Factor de escala para la etapa 2 para amplificar las contribuciones de las características del backbone.
Habilita el mecanismo FreeU tal como se describe en https://huggingface.co/papers/2309.11497.
Los sufijos después de los factores de escalado representan las etapas en las que se están aplicando.
Consulte el repositorio oficial para conocer las combinaciones de valores que funcionan bien en diferentes pipelines, como Stable Diffusion v1, v2 y Stable Diffusion XL.
Desactiva el mecanismo FreeU si está habilitado.
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 )
Parámetros
- prompt (
strolist[str], opcional) — prompt a codificar - device — (
torch.device): dispositivo de torch - num_images_per_prompt (
int) — número de imágenes que deben generarse por prompt - do_classifier_free_guidance (
bool) — si se debe usar classifier free guidance o no - negative_prompt (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasarnegative_prompt_embedsen su lugar. Se ignora cuando no se usa guía (es decir, se ignora siguidance_scalees menor que1). - prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, las incrustaciones de texto se generarán a partir del argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entradanegative_prompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. - clip_skip (
int, opcional) — Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la penúltima capa para calcular los embeddings del prompt.
Codifica el prompt en estados ocultos del codificador de texto.
get_guidance_scale_embedding
< source >( w: Tensorembedding_dim: int = 512dtype: dtype = torch.float32 ) → torch.Tensor
Parámetros
- w (
torch.Tensor) — Genera vectores de incrustación con una escala de orientación especificada para enriquecer posteriormente las incrustaciones de paso temporal. - embedding_dim (
int, opcional, valor predeterminado 512) — Dimensión de los embeddings a generar. - dtype (
torch.dtype, opcional, valor predeterminadotorch.float32) — Tipo de datos de los embeddings generados.
Devuelve
torch.Tensor
Vectores de incrustación con forma (len(w), embedding_dim).
StableDiffusionPipelineOutput
clase diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput
< source >( images: list[PIL.Image.Image] | numpy.ndarraynsfw_content_detected: list[bool] | None )
Parámetros
- images (
list[PIL.Image.Image]onp.ndarray) — lista de imágenes PIL desruidadas de longitudbatch_sizeo array de NumPy de forma(batch_size, height, width, num_channels). - nsfw_content_detected (
list[bool]) — lista que indica si la imagen generada correspondiente contiene contenido “no apto para el trabajo” (nsfw) oNonesi no se pudo realizar la verificación de seguridad.
Clase de salida para las tuberías de Stable Diffusion.