Diffusers documentation
Modelos de Consistência Latente
Modelos de Consistência Latente
Os Latent Consistency Models (LCMs) foram propostos em Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference por Simian Luo, Yiqin Tan, Longbo Huang, Jian Li e Hang Zhao.
O resumo do artigo é o seguinte:
Os modelos de difusão latente (LDMs) alcançaram resultados notáveis na síntese de imagens de alta resolução. No entanto, o processo de amostragem iterativo é computacionalmente intenso e resulta em uma geração lenta. Inspirados nos Consistency Models (song et al.), propomos os Latent Consistency Models (LCMs), que permitem inferência rápida com um mínimo de passos em qualquer LDM pré-treinado, incluindo o Stable Diffusion (rombach et al). Ao considerar o processo de difusão reversa guiado como a solução de uma EDO de fluxo de probabilidade aumentada (PF-ODE), os LCMs são projetados para prever diretamente a solução dessa EDO no espaço latente, mitigando a necessidade de numerosas iterações e permitindo amostragem rápida e de alta fidelidade. Destilados eficientemente a partir de modelos de difusão pré-treinados com guia livre de classificador, um LCM de alta qualidade de 768 x 768 com 2~4 passos leva apenas 32 horas de GPU A100 para treinamento. Além disso, introduzimos o Latent Consistency Fine-tuning (LCF), um método novo projetado para o ajuste fino de LCMs em conjuntos de dados de imagens personalizados. A avaliação no conjunto de dados LAION-5B-Aesthetics demonstra que os LCMs alcançam desempenho de estado da arte na geração de texto para imagem com inferência de poucos passos. Página do projeto: this https URL.
Uma demonstração do checkpoint SimianLuo/LCM_Dreamshaper_v7 pode ser encontrada aqui.
Os pipelines foram contribuídos por luosiallen, nagolinc e dg845.
LCMs e LCM-LoRAs estão disponíveis para Stable Diffusion v1.5, Stable Diffusion XL e o modelo SSD-1B. Você pode encontrar seus checkpoints nas coleções Latent Consistency.
Texto para imagem
Para usar LCMs, você precisa carregar o checkpoint LCM para o modelo suportado em UNet2DConditionModel e substituir o scheduler pelo LCMScheduler. Em seguida, você pode usar o pipeline como de costume e passar um prompt de texto para gerar uma imagem em apenas 4 etapas.
Algumas observações a ter em mente ao usar LCMs:
- Normalmente, o tamanho do lote é dobrado dentro do pipeline para a orientação sem classificador. Mas o LCM aplica a orientação com embeddings de orientação e não precisa dobrar o tamanho do lote, o que leva a uma inferência mais rápida. A desvantagem é que os prompts negativos não funcionam com o LCM, pois não têm nenhum efeito no processo de desruidamento.
- O intervalo ideal para
guidance_scaleé [3., 13.] porque é com isso que a UNet foi treinada. No entanto, desativarguidance_scalecom um valor de 1.0 também é eficaz na maioria dos 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, você precisa substituir o scheduler pelo LCMScheduler e carregar os pesos do LCM-LoRA com o método load_lora_weights(). Em seguida, você pode usar o pipeline como de costume e passar um prompt de texto para gerar uma imagem em apenas 4 etapas.
Algumas observações a ter em mente ao usar LCM-LoRAs:
- Normalmente, o tamanho do lote é dobrado dentro do pipeline para a orientação sem classificador. Mas o LCM aplica a orientação com embeddings de orientação e não precisa dobrar o tamanho do lote, o que leva a uma inferência mais rápida. A desvantagem é que os prompts negativos não funcionam com o LCM, pois não têm nenhum efeito no processo de desruidamento.
- Você pode usar guidance com LCM-LoRAs, mas ele é muito sensível a valores altos de
guidance_scalee pode levar a artefatos na imagem gerada. Os melhores valores que encontramos estão entre [1.0, 2.0]. - Substitua stabilityai/stable-diffusion-xl-base-1.0 por qualquer modelo finetuned. Por exemplo, experimente usar o checkpoint animagine-xl para gerar imagens de anime com 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
Imagem para imagem
Para usar LCMs para image-to-image, você precisa carregar o checkpoint LCM para o modelo suportado em UNet2DConditionModel e substituir o scheduler pelo LCMScheduler. Em seguida, você pode usar o pipeline como de costume, passando um prompt de texto e uma imagem inicial para gerar uma imagem em apenas 4 etapas.
Experimente com diferentes valores para
num_inference_steps,strengtheguidance_scalepara obter os melhores 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, você precisa substituir o scheduler pelo LCMScheduler e carregar os pesos do LCM-LoRA com o método load_lora_weights(). Em seguida, você pode usar o pipeline como de costume, passando um prompt de texto e uma imagem inicial para gerar uma imagem em apenas 4 etapas.
Experimente com diferentes valores para
num_inference_steps,strengtheguidance_scalepara obter os melhores 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, você precisa substituir o scheduler pelo LCMScheduler e carregar os pesos do LCM-LoRA com o método load_lora_weights(). Em seguida, você pode usar o pipeline como de costume, passando um prompt de texto, uma imagem inicial e uma imagem de máscara para gerar uma imagem em apenas 4 etapas.
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
Os LCMs são compatíveis com adaptadores como LoRA, ControlNet, T2I-Adapter e AnimateDiff. Você pode levar a velocidade dos LCMs a esses adaptadores para gerar imagens em um determinado estilo ou condicionar o modelo em outra entrada, como uma imagem canny.
LoRA
Adaptadores LoRA podem ser ajustados rapidamente para aprender um novo estilo a partir de apenas algumas imagens e inseridos em um modelo pré-treinado para gerar imagens nesse estilo.
Carregue o checkpoint do LCM para o modelo suportado em UNet2DConditionModel e substitua o scheduler pelo LCMScheduler. Em seguida, você pode usar o método load_lora_weights() para carregar os pesos do LoRA no LCM e gerar uma imagem estilizada em poucas etapas.
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
Substitua o scheduler pelo LCMScheduler. Em seguida, você pode usar o método load_lora_weights() para carregar os pesos do LCM-LoRA e o LoRA de estilo que deseja usar. Combine os dois adaptadores LoRA com o método ~loaders.UNet2DConditionLoadersMixin.set_adapters e gere uma imagem estilizada em poucas etapas.
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 são adaptadores que podem ser treinados em uma variedade de entradas, como bordas canny, estimativa de pose ou profundidade. O ControlNet pode ser inserido no pipeline para fornecer condicionamento e controle adicionais ao modelo, resultando em uma geração mais precisa.
Você pode encontrar modelos adicionais de ControlNet treinados em outras entradas no repositório de lllyasviel.
Carregue um modelo ControlNet treinado em imagens canny e passe-o para o ControlNetModel. Em seguida, você pode carregar um modelo LCM no StableDiffusionControlNetPipeline e substituir o scheduler pelo LCMScheduler. Agora, passe a imagem canny para o pipeline e gere uma imagem.
Experimente com diferentes valores para
num_inference_steps,controlnet_conditioning_scale,cross_attention_kwargseguidance_scalepara obter os melhores 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)
Carregue um modelo ControlNet treinado em imagens canny e passe-o para o ControlNetModel. Em seguida, você pode carregar um modelo Stable Diffusion v1.5 no StableDiffusionControlNetPipeline e substituir o scheduler pelo LCMScheduler. Use o método load_lora_weights() para carregar os pesos do LCM-LoRA, e passe a imagem canny para o pipeline e gere uma imagem.
Experimente com diferentes valores para
num_inference_steps,controlnet_conditioning_scale,cross_attention_kwargseguidance_scalepara obter os melhores 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 é um adaptador ainda mais leve que o ControlNet, que fornece uma entrada adicional para condicionar um modelo pré-treinado. Ele é mais rápido que o ControlNet, mas os resultados podem ser ligeiramente piores.
Você pode encontrar checkpoints adicionais do T2I-Adapter treinados em outras entradas no repositório do TencentArc.
Carregue um T2IAdapter treinado em imagens canny e passe-o para o StableDiffusionXLAdapterPipeline. Em seguida, carregue um checkpoint LCM no UNet2DConditionModel e substitua o scheduler pelo LCMScheduler. Agora, passe a imagem canny para o pipeline e gere uma imagem.
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]
Carregue um T2IAdapter treinado em imagens canny e passe-o para o StableDiffusionXLAdapterPipeline. Substitua o scheduler pelo LCMScheduler e use o método load_lora_weights() para carregar os pesos do LCM-LoRA. Passe a imagem canny para o pipeline e gere uma imagem.
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 é um adaptador que adiciona movimento a uma imagem. Ele pode ser usado com a maioria dos modelos Stable Diffusion, transformando-os efetivamente em modelos de “geração de vídeo”. Gerar bons resultados com um modelo de vídeo geralmente requer a geração de múltiplos quadros (16-24), o que pode ser muito lento com um modelo Stable Diffusion regular. O LCM-LoRA pode acelerar esse processo, exigindo apenas 4-8 etapas para cada quadro.
Carregue um AnimateDiffPipeline e passe um MotionAdapter para ele. Em seguida, substitua o scheduler pelo LCMScheduler e combine os dois adaptadores LoRA com o método ~loaders.UNet2DConditionLoadersMixin.set_adapters. Agora você pode passar um prompt para o pipeline e gerar uma imagem 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
classe diffusers.LatentConsistencyModelPipeline
< source >( vae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizerunet: UNet2DConditionModelscheduler: LCMSchedulersafety_checker: StableDiffusionSafetyCheckerfeature_extractor: CLIPImageProcessorPilimage_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = Nonerequires_safety_checker: bool = True )
Parâmetros
- vae (AutoencoderKL) — Modelo Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.
- text_encoder (CLIPTextModel) — Codificador de texto congelado (clip-vit-large-patch14).
- tokenizer (CLIPTokenizer) —
Um
CLIPTokenizerpara tokenizar texto. - unet (UNet2DConditionModel) —
Um
UNet2DConditionModelpara desruidar os latentes da imagem codificada. - scheduler (SchedulerMixin) —
Um scheduler a ser usado em combinação com
unetpara desruidar os latentes da imagem codificada. Atualmente, suporta apenas LCMScheduler. - safety_checker (
StableDiffusionSafetyChecker) — Módulo de classificação que estima se as imagens geradas podem ser consideradas ofensivas ou prejudiciais. Consulte o model card para mais detalhes sobre os potenciais danos de um modelo. - feature_extractor (CLIPImageProcessor) —
Um
CLIPImageProcessorpara extrair recursos de imagens geradas; usado como entradas para osafety_checker. - requires_safety_checker (
bool, opcional, padrãoTrue) — Se o pipeline requer um componente de verificação de segurança.
Pipeline para geração de texto para imagem usando um modelo de consistência latente.
Este modelo herda de DiffusionPipeline. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
O pipeline também herda os seguintes métodos de carregamento:
- load_textual_inversion() para carregar embeddings de inversão textual
- load_lora_weights() para carregar os pesos do LoRA
- save_lora_weights() para salvar os pesos do LoRA
- para carregar arquivos
.ckptcom from_single_file() - load_ip_adapter() para carregar 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 (
stroulist[str], opcional) — O prompt ou os prompts para orientar a geração de imagens. Se não for definido, você precisa passarprompt_embeds. - height (
int, opcional, padrãoself.unet.config.sample_size * self.vae_scale_factor) — A altura em pixels da imagem gerada. - width (
int, opcional, padrãoself.unet.config.sample_size * self.vae_scale_factor) — A largura em pixels da imagem gerada. - num_inference_steps (
int, opcional, padrão 50) — O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, à custa de uma inferência mais lenta. - original_inference_steps (
int, opcional) — O número original de etapas de inferência usado para gerar um cronograma de timesteps linearmente espaçados, do qual extrairemosnum_inference_stepstimesteps igualmente espaçados como nosso cronograma final de timesteps, seguindo o método Skipping-Step do artigo (veja a Seção 4.3). Se não for definido, o valor padrão será o atributooriginal_inference_stepsdo scheduler. - timesteps (
list[int], opcional) — Timesteps personalizados para usar no processo de remoção de ruído. Se não definidos, são usadosnum_inference_stepstimesteps igualmente espaçados na agenda original de timesteps de treinamento/destilação do LCM. Devem estar em ordem decrescente. - guidance_scale (
float, opcional, padrão 7.5) — Um valor mais alto para a escala de orientação incentiva o modelo a gerar imagens fortemente ligadas aopromptde texto, em detrimento da qualidade da imagem. A escala de orientação é ativada quandoguidance_scale > 1. Observe que o artigo original sobre modelos de consistência latente utiliza uma formulação de CFG diferente, na qual as escalas de orientação são reduzidas em 1 (ou seja, na formulação do artigo, o CFG é ativado quandoguidance_scale > 0). - num_images_per_prompt (
int, opcional, padrão 1) — O número de imagens a serem geradas por prompt. - generator (
torch.Generatoroulist[torch.Generator], opcional) — Umtorch.Generatorpara tornar a geração determinística. - latents (
torch.Tensor, opcional) — Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando ogeneratoraleatório fornecido. - prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entradaprompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagem opcional para trabalhar com IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incorporações de imagem pré-geradas para IP-Adapter. Deve ser uma lista com o mesmo comprimento que o número de IP-adapters. Cada elemento deve ser um tensor de forma(batch_size, num_images, emb_dim). Deve conter a incorporação de imagem negativa sedo_classifier_free_guidanceestiver definido comoTrue. Se não for fornecido, as incorporações são calculadas a partir do argumento de entradaip_adapter_image. - output_type (
str, opcional, padrão"pil") — O formato de saída da imagem gerada. Escolha entrePIL.Imageounp.array. - return_dict (
bool, opcional, padrãoTrue) — Se deve ou não retornar um StableDiffusionPipelineOutput em vez de uma tupla simples. - cross_attention_kwargs (
dict, opcional) — Um dicionário de kwargs que, se especificado, é passado aoAttentionProcessorconforme definido emself.processor. - clip_skip (
int, opcional) — Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt. - callback_on_step_end (
Callable, opcional) — Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos:callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargsincluirá uma lista de todos os tensores, conforme especificado porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — A lista de entradas de tensor para a funçãocallback_on_step_end. Os tensores especificados na lista serão passados como argumentocallback_kwargs. Você só poderá incluir variáveis listadas no atributo._callback_tensor_inputsda sua classe de pipeline.
Retorna
StableDiffusionPipelineOutput ou tuple
Se return_dict for True, StableDiffusionPipelineOutput é retornado,
caso contrário, uma tuple é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o
segundo elemento é uma lista de bools indicando se a imagem gerada correspondente contém
conteúdo “not-safe-for-work” (nsfw).
A função de chamada do pipeline para geração.
Exemplos:
>>> 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) — Fator de escala para a etapa 1 para atenuar as contribuições dos recursos de skip. Isso é feito para mitigar o “efeito de suavização excessiva” no processo aprimorado de remoção de ruído. - s2 (
float) — Fator de escala para o estágio 2 para atenuar as contribuições dos recursos de skip. Isso é feito para mitigar o “efeito de suavização excessiva” no processo aprimorado de remoção de ruído. - b1 (
float) — Fator de escala para o estágio 1 para amplificar as contribuições dos recursos do backbone. - b2 (
float) — Fator de escala para o estágio 2 para amplificar as contribuições dos recursos do backbone.
Ativa o mecanismo FreeU, conforme descrito em https://huggingface.co/papers/2309.11497.
Os sufixos após os fatores de escala representam as etapas em que eles estão sendo aplicados.
Consulte o repositório oficial para as combinações de valores que são conhecidas por funcionar bem em diferentes pipelines, como Stable Diffusion v1, v2 e Stable Diffusion XL.
Desativa o mecanismo FreeU, se estiver ativado.
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 (
stroulist[str], opcional) — prompt a ser codificado - device — (
torch.device): dispositivo torch - num_images_per_prompt (
int) — número de imagens que devem ser geradas por prompt - do_classifier_free_guidance (
bool) — se deve usar classifier free guidance ou não - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto negativas pré-geradas. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entradanegative_prompt. - lora_scale (
float, opcional) — Uma escala LoRA que será aplicada a todas as camadas LoRA do codificador de texto, caso as camadas LoRA sejam carregadas. - clip_skip (
int, opcional) — Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.
Codifica o prompt em estados ocultos do codificador de texto.
get_guidance_scale_embedding
< source >( w: Tensorembedding_dim: int = 512dtype: dtype = torch.float32 ) → torch.Tensor
Parâmetros
- w (
torch.Tensor) — Gera vetores de incorporação com uma escala de orientação especificada para, em seguida, enriquecer as incorporações de passo de tempo. - embedding_dim (
int, opcional, padrão 512) — Dimensão dos embeddings a serem gerados. - dtype (
torch.dtype, opcional, padrãotorch.float32) — Tipo de dados dos embeddings gerados.
Retorna
torch.Tensor
Vetores de incorporação com forma (len(w), embedding_dim).
LatentConsistencyModelImg2ImgPipeline
classe diffusers.LatentConsistencyModelImg2ImgPipeline
< source >( vae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizerunet: UNet2DConditionModelscheduler: LCMSchedulersafety_checker: StableDiffusionSafetyCheckerfeature_extractor: CLIPImageProcessorPilimage_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = Nonerequires_safety_checker: bool = True )
Parâmetros
- vae (AutoencoderKL) — Modelo Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.
- text_encoder (CLIPTextModel) — Codificador de texto congelado (clip-vit-large-patch14).
- tokenizer (CLIPTokenizer) —
Um
CLIPTokenizerpara tokenizar texto. - unet (UNet2DConditionModel) —
Um
UNet2DConditionModelpara desruidar os latentes da imagem codificada. - scheduler (SchedulerMixin) —
Um scheduler a ser usado em combinação com
unetpara desruidar os latentes da imagem codificada. Atualmente, suporta apenas LCMScheduler. - safety_checker (
StableDiffusionSafetyChecker) — Módulo de classificação que estima se as imagens geradas podem ser consideradas ofensivas ou prejudiciais. Consulte o model card para mais detalhes sobre os potenciais danos de um modelo. - feature_extractor (CLIPImageProcessor) —
Um
CLIPImageProcessorpara extrair recursos de imagens geradas; usado como entradas para osafety_checker. - requires_safety_checker (
bool, opcional, padrãoTrue) — Se o pipeline requer um componente de verificação de segurança.
Pipeline para geração de imagem a imagem usando um modelo de consistência latente.
Este modelo herda de DiffusionPipeline. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
O pipeline também herda os seguintes métodos de carregamento:
- load_textual_inversion() para carregar embeddings de inversão textual
- load_lora_weights() para carregar os pesos do LoRA
- save_lora_weights() para salvar os pesos do LoRA
- para carregar arquivos
.ckptcom from_single_file() - load_ip_adapter() para carregar 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 (
stroulist[str], opcional) — O prompt ou os prompts para orientar a geração de imagens. Se não for definido, você precisa passarprompt_embeds. - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]oulist[np.ndarray]) —Imageou tensor representando um lote de imagens a ser usado como ponto de partida. Também pode aceitar latentes de imagem comoimage, mas, se latentes forem passados diretamente, eles não são codificados novamente. - num_inference_steps (
int, opcional, padrão 50) — O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, à custa de uma inferência mais lenta. - strength (
float, opcional, padrão 0.8) — Indica o grau de transformação daimagede referência. Deve estar entre 0 e 1. Aimageé usada como ponto de partida e mais ruído é adicionado quanto maior for ostrength. O número de etapas de desruidamento depende da quantidade de ruído inicialmente adicionada. Quandostrengthé 1, o ruído adicionado é máximo e o processo de desruidamento é executado pelo número total de iterações especificado emnum_inference_steps. Um valor de 1 essencialmente ignora aimage. - original_inference_steps (
int, opcional) — O número original de etapas de inferência usado para gerar um cronograma de timesteps linearmente espaçados, do qual extrairemosnum_inference_stepstimesteps igualmente espaçados como nosso cronograma final de timesteps, seguindo o método Skipping-Step do artigo (veja a Seção 4.3). Se não for definido, o valor padrão será o atributooriginal_inference_stepsdo scheduler. - timesteps (
list[int], opcional) — Timesteps personalizados para usar no processo de remoção de ruído. Se não definidos, são usadosnum_inference_stepstimesteps igualmente espaçados na agenda original de timesteps de treinamento/destilação do LCM. Devem estar em ordem decrescente. - guidance_scale (
float, opcional, padrão 7.5) — Um valor mais alto para a escala de orientação incentiva o modelo a gerar imagens fortemente ligadas aopromptde texto, em detrimento da qualidade da imagem. A escala de orientação é ativada quandoguidance_scale > 1. Observe que o artigo original sobre modelos de consistência latente utiliza uma formulação de CFG diferente, na qual as escalas de orientação são reduzidas em 1 (ou seja, na formulação do artigo, o CFG é ativado quandoguidance_scale > 0). - num_images_per_prompt (
int, opcional, padrão 1) — O número de imagens a serem geradas por prompt. - generator (
torch.Generatoroulist[torch.Generator], opcional) — Umtorch.Generatorpara tornar a geração determinística. - latents (
torch.Tensor, opcional) — Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando ogeneratoraleatório fornecido. - prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entradaprompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagem opcional para trabalhar com IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incorporações de imagem pré-geradas para IP-Adapter. Deve ser uma lista com o mesmo comprimento que o número de IP-adapters. Cada elemento deve ser um tensor de forma(batch_size, num_images, emb_dim). Deve conter a incorporação de imagem negativa sedo_classifier_free_guidanceestiver definido comoTrue. Se não for fornecido, as incorporações são calculadas a partir do argumento de entradaip_adapter_image. - output_type (
str, opcional, padrão"pil") — O formato de saída da imagem gerada. Escolha entrePIL.Imageounp.array. - return_dict (
bool, opcional, padrãoTrue) — Se deve ou não retornar um StableDiffusionPipelineOutput em vez de uma tupla simples. - cross_attention_kwargs (
dict, opcional) — Um dicionário de kwargs que, se especificado, é passado aoAttentionProcessorconforme definido emself.processor. - clip_skip (
int, opcional) — Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt. - callback_on_step_end (
Callable, opcional) — Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos:callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargsincluirá uma lista de todos os tensores, conforme especificado porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — A lista de entradas de tensor para a funçãocallback_on_step_end. Os tensores especificados na lista serão passados como argumentocallback_kwargs. Você só poderá incluir variáveis listadas no atributo._callback_tensor_inputsda sua classe de pipeline.
Retorna
StableDiffusionPipelineOutput ou tuple
Se return_dict for True, StableDiffusionPipelineOutput é retornado,
caso contrário, uma tuple é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o
segundo elemento é uma lista de bools indicando se a imagem gerada correspondente contém
conteúdo “not-safe-for-work” (nsfw).
A função de chamada do pipeline para geração.
Exemplos:
>>> 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) — Fator de escala para a etapa 1 para atenuar as contribuições dos recursos de skip. Isso é feito para mitigar o “efeito de suavização excessiva” no processo aprimorado de remoção de ruído. - s2 (
float) — Fator de escala para o estágio 2 para atenuar as contribuições dos recursos de skip. Isso é feito para mitigar o “efeito de suavização excessiva” no processo aprimorado de remoção de ruído. - b1 (
float) — Fator de escala para o estágio 1 para amplificar as contribuições dos recursos do backbone. - b2 (
float) — Fator de escala para o estágio 2 para amplificar as contribuições dos recursos do backbone.
Ativa o mecanismo FreeU, conforme descrito em https://huggingface.co/papers/2309.11497.
Os sufixos após os fatores de escala representam as etapas em que eles estão sendo aplicados.
Consulte o repositório oficial para as combinações de valores que são conhecidas por funcionar bem em diferentes pipelines, como Stable Diffusion v1, v2 e Stable Diffusion XL.
Desativa o mecanismo FreeU, se estiver ativado.
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 (
stroulist[str], opcional) — prompt a ser codificado - device — (
torch.device): dispositivo torch - num_images_per_prompt (
int) — número de imagens que devem ser geradas por prompt - do_classifier_free_guidance (
bool) — se deve usar classifier free guidance ou não - negative_prompt (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incorporações de texto negativas pré-geradas. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entradanegative_prompt. - lora_scale (
float, opcional) — Uma escala LoRA que será aplicada a todas as camadas LoRA do codificador de texto, caso as camadas LoRA sejam carregadas. - clip_skip (
int, opcional) — Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.
Codifica o prompt em estados ocultos do codificador de texto.
get_guidance_scale_embedding
< source >( w: Tensorembedding_dim: int = 512dtype: dtype = torch.float32 ) → torch.Tensor
Parâmetros
- w (
torch.Tensor) — Gera vetores de incorporação com uma escala de orientação especificada para, em seguida, enriquecer as incorporações de passo de tempo. - embedding_dim (
int, opcional, padrão 512) — Dimensão dos embeddings a serem gerados. - dtype (
torch.dtype, opcional, padrãotorch.float32) — Tipo de dados dos embeddings gerados.
Retorna
torch.Tensor
Vetores de incorporação com forma (len(w), embedding_dim).
StableDiffusionPipelineOutput
classe 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]ounp.ndarray) — lista de imagens PIL desruidas de comprimentobatch_sizeou array NumPy de forma(batch_size, height, width, num_channels). - nsfw_content_detected (
list[bool]) — lista indicando se a imagem gerada correspondente contém conteúdo “não seguro para o trabalho” (nsfw) ouNonese a verificação de segurança não pôde ser realizada.
Classe de saída para pipelines do Stable Diffusion.