hf-doc-build/doc / diffusers /main /es /api /pipelines /stable_diffusion /stable_diffusion_xl.md

|

102 kB

Stable Diffusion XL

Stable Diffusion XL (SDXL) fue propuesto en SDXL: Improving Latent Diffusion Models for High-Resolution Image Synthesis por Dustin Podell, Zion English, Kyle Lacey, Andreas Blattmann, Tim Dockhorn, Jonas Müller, Joe Penna y Robin Rombach.

El resumen del artículo es:

Presentamos SDXL, un modelo de difusión latente para la síntesis de imágenes a partir de texto. En comparación con versiones anteriores de Stable Diffusion, SDXL aprovecha un esqueleto UNet tres veces mayor: el aumento de los parámetros del modelo se debe principalmente a más bloques de atención y a un contexto de atención cruzada más grande, ya que SDXL utiliza un segundo codificador de texto. Diseñamos varios esquemas de condicionamiento novedosos y entrenamos SDXL en múltiples relaciones de aspecto. También introducimos un modelo de refinamiento que se utiliza para mejorar la fidelidad visual de las muestras generadas por SDXL mediante una técnica posterior de imagen a imagen. Demostramos que SDXL muestra un rendimiento drásticamente mejorado en comparación con las versiones anteriores de Stable Diffusion y logra resultados competitivos con los de los generadores de imágenes de última generación de caja negra.

Consejos

El uso de SDXL con un programador DPM++ durante menos de 50 pasos es conocido por producir artefactos visuales porque el solver se vuelve numéricamente inestable. Para corregir este problema, echa un vistazo a este PR que recomienda para los solvers ODE/SDE:
- Establezca use_karras_sigmas=True o lu_lambdas=True para mejorar la calidad de la imagen
- Establezca euler_at_final=True si está utilizando un solver con tamaños de paso uniformes (DPM++2M o DPM++2M SDE)
La mayoría de los puntos de control de SDXL funcionan mejor con un tamaño de imagen de 1024x1024. También se admiten tamaños de 768x768 y 512x512, pero los resultados no son tan buenos. No se recomienda nada por debajo de 512x512 y probablemente no lo sea para los puntos de control predeterminados como stabilityai/stable-diffusion-xl-base-1.0.
SDXL puede pasar un prompt diferente para cada uno de los codificadores de texto en los que fue entrenado. Incluso podemos pasar partes diferentes del mismo prompt a los codificadores de texto.
Las imágenes de salida de SDXL pueden mejorarse mediante el uso de un modelo refinador en una configuración de imagen a imagen.
SDXL ofrece negative_original_size, negative_crops_coords_top_left y negative_target_size para condicionar negativamente el modelo en los parámetros de resolución y recorte de la imagen.

¡Echa un vistazo a la organización de Stability AI en Hub para los puntos de control oficiales de los modelos base y refiner!

Asegúrate de tener instaladas las siguientes bibliotecas.

# uncomment to install the necessary libraries in Colab
#!pip install -q diffusers transformers accelerate invisible-watermark>=0.2.0

Recomendamos instalar la biblioteca invisible-watermark para ayudar a identificar las imágenes generadas. Si la biblioteca invisible-watermark está instalada, se utiliza de forma predeterminada. Para desactivar el marca de agua:
pipeline = StableDiffusionXLPipeline.from_pretrained(..., add_watermarker=False)

Cargar puntos de control de modelos

Los pesos del modelo pueden estar almacenados en subcarpetas separadas en el Hub o localmente, en cuyo caso, debes usar el método from_pretrained():

from diffusers import StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline
import torch

pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = StableDiffusionXLImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0", dtype=torch.float16, use_safetensors=True, variant="fp16"
).to("cuda")

También puede usar el método from_single_file() para cargar un punto de control de modelo almacenado en un formato de archivo único (.ckpt o .safetensors) desde el Hub o localmente:

from diffusers import StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline
import torch

pipeline = StableDiffusionXLPipeline.from_single_file(
    "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/blob/main/sd_xl_base_1.0.safetensors",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = StableDiffusionXLImg2ImgPipeline.from_single_file(
    "https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/blob/main/sd_xl_refiner_1.0.safetensors", dtype=torch.float16
).to("cuda")

Texto a imagen

Para texto a imagen, pasa un prompt de texto. Por defecto, SDXL genera una imagen de 1024x1024 para obtener los mejores resultados. Puedes intentar establecer los parámetros height y width en 768x768 o 512x512, pero es poco probable que funcione con tamaños inferiores a 512x512.

from diffusers import AutoPipelineForText2Image
import torch

pipeline_text2image = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image = pipeline_text2image(prompt=prompt).images[0]
image

Imagen a imagen

Para la conversión de imagen a imagen, SDXL funciona especialmente bien con tamaños de imagen entre 768x768 y 1024x1024. Pasa una imagen inicial y un prompt de texto para condicionar la imagen con:

from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image, make_image_grid

# use from_pipe to avoid consuming additional memory when loading a checkpoint
pipeline = AutoPipelineForImage2Image.from_pipe(pipeline_text2image).to("cuda")  # or "mps", "xpu", "cpu"

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png"
init_image = load_image(url)
prompt = "a dog catching a frisbee in the jungle"
image = pipeline(prompt, image=init_image, strength=0.8, guidance_scale=10.5).images[0]
make_image_grid([init_image, image], rows=1, cols=2)

Inpainting

Para el inpainting, necesitarás la imagen original y una máscara de lo que deseas reemplazar en la imagen original. Crea un prompt para describir con qué quieres reemplazar el área enmascarada.

from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

# use from_pipe to avoid consuming additional memory when loading a checkpoint
pipeline = AutoPipelineForInpainting.from_pipe(pipeline_text2image).to("cuda")  # or "mps", "xpu", "cpu"

img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png"
mask_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-inpaint-mask.png"

init_image = load_image(img_url)
mask_image = load_image(mask_url)

prompt = "A deep sea diver floating"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, strength=0.85, guidance_scale=12.5).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)

Mejorar la calidad de la imagen

SDXL incluye un modelo refinador especializado en el desruido de imágenes de la etapa de bajo ruido para generar imágenes de mayor calidad a partir del modelo base. Hay dos formas de usar el refinador:

utilice los modelos base y refiner juntos para generar una imagen refinada
utilice el modelo base para generar una imagen y, a continuación, utilice el modelo refiner para añadir más detalles a la imagen (así es como se entrenó originalmente SDXL)

Modelo base + refinador

Cuando se utilizan el modelo base y el modelo refinador juntos para generar una imagen, esto se conoce como un conjunto de desruidadores expertos. El enfoque de conjunto de desruidadores expertos requiere menos pasos de desruido en total en comparación con pasar la salida del modelo base al modelo refinador, por lo que su ejecución debería ser significativamente más rápida. Sin embargo, no será posible inspeccionar la salida del modelo base porque aún contiene una gran cantidad de ruido.

Como un conjunto de desruidadores expertos, el modelo base actúa como el experto durante la etapa de difusión de alto ruido y el modelo refinador actúa como el experto durante la etapa de difusión de bajo ruido. Cargue el modelo base y el modelo refinador:

from diffusers import DiffusionPipeline
import torch

base = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base.text_encoder_2,
    vae=base.vae,
    dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
).to("cuda")

Para usar este enfoque, debes definir el número de pasos de tiempo para que cada modelo ejecute sus respectivas etapas. Para el modelo base, esto se controla mediante el parámetro denoising_end y, para el modelo refinador, mediante el parámetro denoising_start.

Los parámetros denoising_end y denoising_start deben ser un float entre 0 y 1. Estos parámetros se representan como una proporción de los pasos discretos definidos por el programador. Si también estás usando el parámetro strength, se ignorará porque el número de pasos de desruido está determinado por los pasos discretos en los que se entrenó el modelo y el corte fraccional declarado.

Establezcamos denoising_end=0.8 para que el modelo base realice el 80% inicial del desruido en los pasos de tiempo de alto ruido y establezcamos denoising_start=0.8 para que el modelo refinador realice el 20% final del desruido en los pasos de tiempo de bajo ruido. La salida del modelo base debe estar en espacio latente en lugar de ser una imagen PIL.

prompt = "A majestic lion jumping from a big stone at night"

image = base(
    prompt=prompt,
    num_inference_steps=40,
    denoising_end=0.8,
    output_type="latent",
).images
image = refiner(
    prompt=prompt,
    num_inference_steps=40,
    denoising_start=0.8,
    image=image,
).images[0]
image

modelo base predeterminado



conjunto de expertos desruidadores

El modelo refiner también se puede usar para inpainting en el StableDiffusionXLInpaintPipeline:

from diffusers import StableDiffusionXLInpaintPipeline
from diffusers.utils import load_image, make_image_grid
import torch

base = StableDiffusionXLInpaintPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = StableDiffusionXLInpaintPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base.text_encoder_2,
    vae=base.vae,
    dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
).to("cuda")

img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"

init_image = load_image(img_url)
mask_image = load_image(mask_url)

prompt = "A majestic tiger sitting on a bench"
num_inference_steps = 75
high_noise_frac = 0.7

image = base(
    prompt=prompt,
    image=init_image,
    mask_image=mask_image,
    num_inference_steps=num_inference_steps,
    denoising_end=high_noise_frac,
    output_type="latent",
).images
image = refiner(
    prompt=prompt,
    image=image,
    mask_image=mask_image,
    num_inference_steps=num_inference_steps,
    denoising_start=high_noise_frac,
).images[0]
make_image_grid([init_image, mask_image, image.resize((512, 512))], rows=1, cols=3)

¡Este método de conjunto de desruidadores expertos funciona bien con todos los programadores disponibles!

Modelo base al modelo refinador

SDXL mejora la calidad de la imagen al utilizar el modelo refiner para añadir detalles de alta calidad adicionales a la imagen completamente desruidada generada por el modelo base, en un contexto de imagen a imagen.

Cargue los modelos base y refiner:

from diffusers import DiffusionPipeline
import torch

base = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base.text_encoder_2,
    vae=base.vae,
    dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
).to("cuda")

Puedes usar el refiner de SDXL con un modelo base diferente. Por ejemplo, puedes usar las pipelines de Hunyuan-DiT o PixArt-Sigma para generar imágenes con una mejor adherencia al prompt. Una vez que hayas generado una imagen, puedes pasarla al modelo refiner de SDXL para mejorar la calidad de la generación final.

Genere una imagen desde el modelo base y establezca la salida del modelo en el espacio latent:

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

image = base(prompt=prompt, output_type="latent").images[0]

Pase la imagen generada al modelo de refinamiento:

image = refiner(prompt=prompt, image=image[None, :]).images[0]

modelo base



modelo base + modelo refinador

Para el inpainting, cargue el modelo base y el modelo refiner en el StableDiffusionXLInpaintPipeline, elimine los parámetros denoising_end y denoising_start y elija un número menor de pasos de inferencia para el refiner.

Micro-condicionamiento

El entrenamiento de SDXL implica varias técnicas adicionales de condicionamiento, conocidas como micro-conditioning. Estas incluyen el tamaño de la imagen original, el tamaño de la imagen objetivo y los parámetros de recorte. Los micro-conditionings pueden utilizarse en tiempo de inferencia para crear imágenes de alta calidad y centradas.

Puedes usar tanto los parámetros de micro-condicionamiento como los de micro-condicionamiento negativo gracias a la guía sin clasificador (classifier-free guidance). Están disponibles en StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline, StableDiffusionXLInpaintPipeline y StableDiffusionXLControlNetPipeline.

Condicionamiento por tamaño

Existen dos tipos de condicionamiento por tamaño:

La condición de original_size proviene de las imágenes ampliadas en el lote de entrenamiento (ya que sería un desperdicio descartar las imágenes más pequeñas, que representan casi el 40 % de los datos de entrenamiento totales). De esta manera, SDXL aprende que los artefactos de ampliación no deben estar presentes en las imágenes de alta resolución. Durante la inferencia, puedes usar original_size para indicar la resolución de la imagen original. Usar el valor predeterminado de (1024, 1024) produce imágenes de mayor calidad que se asemejan a las imágenes de 1024x1024 del conjunto de datos. Si eliges usar una resolución más baja, como (256, 256), el modelo sigue generando imágenes de 1024x1024, pero se verán como las imágenes de baja resolución (patrones más simples, desenfoque) del conjunto de datos.
La condición de target_size proviene del ajuste fino de SDXL para soportar diferentes relaciones de aspecto de imagen. Durante la inferencia, si usas el valor predeterminado de (1024, 1024), obtendrás una imagen que se asemeja a la composición de las imágenes cuadradas del conjunto de datos. Recomendamos usar el mismo valor para target_size y original_size, ¡pero no dudes en experimentar con otras opciones!

🤗 Diffusers también permite especificar condiciones negativas sobre el tamaño de una imagen para orientar la generación y evitar ciertas resoluciones de imagen:

from diffusers import StableDiffusionXLPipeline
import torch

pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image = pipe(
    prompt=prompt,
    negative_original_size=(512, 512),
    negative_target_size=(1024, 1024),
).images[0]

Imágenes condicionadas negativamente en resoluciones de imagen de (128, 128), (256, 256) y (512, 512).

Condicionamiento por recorte

Las imágenes generadas por modelos anteriores de Stable Diffusion a veces pueden parecer recortadas. Esto se debe a que las imágenes se recortan realmente durante el entrenamiento para que todas las imágenes de un lote tengan el mismo tamaño. Al condicionar en las coordenadas de recorte, SDXL aprende que la ausencia de recorte - coordenadas (0, 0) - suele correlacionarse con sujetos centrados y rostros completos (este es el valor predeterminado en 🤗 Diffusers). Puedes experimentar con diferentes coordenadas si quieres generar composiciones descentradas.

from diffusers import StableDiffusionXLPipeline
import torch

pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image = pipeline(prompt=prompt, crops_coords_top_left=(256, 0)).images[0]
image

También puede especificar coordenadas de recorte negativas para alejar la generación de ciertos parámetros de recorte:

from diffusers import StableDiffusionXLPipeline
import torch

pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image = pipe(
    prompt=prompt,
    negative_original_size=(512, 512),
    negative_crops_coords_top_left=(0, 0),
    negative_target_size=(1024, 1024),
).images[0]
image

Usa un prompt diferente para cada text-encoder

SDXL utiliza dos codificadores de texto, por lo que es posible pasar un prompt diferente a cada codificador, lo que puede mejorar la calidad. Pasa tu prompt original a prompt y el segundo prompt a prompt_2 (usa negative_prompt y negative_prompt_2 si estás usando prompts negativos):

from diffusers import StableDiffusionXLPipeline
import torch

pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

# prompt is passed to OAI CLIP-ViT/L-14
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# prompt_2 is passed to OpenCLIP-ViT/bigG-14
prompt_2 = "Van Gogh painting"
image = pipeline(prompt=prompt, prompt_2=prompt_2).images[0]
image

Los codificadores de texto duales también admiten incrustaciones de inversión textual que deben cargarse por separado, como se explica en la guía de inversión textual.

Optimizaciones

SDXL es un modelo grande y es posible que necesites optimizar la memoria para poder ejecutarlo en tu hardware. A continuación, se ofrecen algunos consejos para ahorrar memoria y acelerar la inferencia.

Descarga el modelo a la CPU con enable_model_cpu_offload() para los errores de memoria insuficiente:

- base.to("cuda")  # or "mps", "xpu", "cpu"
- refiner.to("cuda")
+ base.enable_model_cpu_offload()
+ refiner.enable_model_cpu_offload()

Usa torch.compile para una aceleración del ~20% (necesitas torch>=2.0):

+ base.unet = torch.compile(base.unet, mode="reduce-overhead", fullgraph=True)
+ refiner.unet = torch.compile(refiner.unet, mode="reduce-overhead", fullgraph=True)

Habilita xFormers para ejecutar SDXL si torch<2.0:

+ base.enable_xformers_memory_efficient_attention()
+ refiner.enable_xformers_memory_efficient_attention()

Recursos

Si te interesa experimentar con una versión mínima del UNet2DConditionModel utilizado en SDXL, echa un vistazo a la implementación minSDXL, escrita en PyTorch y directamente compatible con 🤗 Diffusers.

StableDiffusionXLPipeline[[diffusers.StableDiffusionXLPipeline]]

diffusers.StableDiffusionXLPipeline[[diffusers.StableDiffusionXLPipeline]]

diffusers.StableDiffusionXLPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None)

Fuente

Parámetros:

vae (AutoencoderKL) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (CLIPTextModel) : Codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto de CLIP, específicamente la variante clip-vit-large-patch14.

text_encoder_2 ( CLIPTextModelWithProjection) : Segundo codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto y pool de CLIP, específicamente la variante laion/CLIP-ViT-bigG-14-laion2B-39B-b160k.

tokenizer (CLIPTokenizer) : Tokenizador de la clase CLIPTokenizer.

tokenizer_2 (CLIPTokenizer) : Segundo Tokenizer de la clase CLIPTokenizer.

unet (UNet2DConditionModel) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados.

scheduler (SchedulerMixin) : Un scheduler para usar en combinación con unet para desruidar los latentes de la imagen codificada. Puede ser uno de DDIMScheduler, LMSDiscreteScheduler o PNDMScheduler.

force_zeros_for_empty_prompt (bool, opcional, valor predeterminado "True") : Si las incrustaciones del prompt negativo deben forzarse a establecerse siempre en 0. Consulte también la configuración de stabilityai/stable-diffusion-xl-base-1-0.

add_watermarker (bool, opcional) : Si se debe usar la invisible_watermark library para aplicar marcas de agua a las imágenes de salida. Si no se define, el valor predeterminado será True si el paquete está instalado; de lo contrario, no se usará ninguna marca de agua.

Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion XL.

Este modelo hereda de DiffusionPipeline. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la 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
from_single_file() para la carga de archivos .ckpt
load_lora_weights() para cargar los pesos de LoRA
save_lora_weights() para guardar los pesos de LoRA
load_ip_adapter() para cargar IP Adapters

call[[diffusers.StableDiffusionXLPipeline.call]]

__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] | None = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)

Fuente

Parámetros:

prompt (str o list[str], opcional) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar prompt_embeds en su lugar.

prompt_2 (str o list[str], opcional) : El prompt o los prompts que se enviarán al tokenizer_2 y al text_encoder_2. Si no se define, se utiliza prompt en ambos text-encoders

height (int, opcional, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados. Cualquier valor inferior a 512 píxeles no funcionará bien con stabilityai/stable-diffusion-xl-base-1.0 ni con puntos de control que no estén específicamente afinados en resoluciones bajas.

width (int, opcional, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados. Cualquier valor inferior a 512 píxeles no funcionará bien con stabilityai/stable-diffusion-xl-base-1.0 ni con puntos de control que no estén específicamente afinados en resoluciones bajas.

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.

timesteps (list[int], opcional) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento timesteps en su método set_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pase num_inference_steps. Debe estar en orden descendente.

sigmas (list[float], opcional) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento sigmas en su método set_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pase num_inference_steps.

denoising_end (float, opcional) : Cuando se especifica, determina la fracción (entre 0.0 y 1.0) del proceso total de desruido que debe completarse antes de que se termine prematuramente de forma intencional. Como resultado, la muestra devuelta aún conservará una cantidad sustancial de ruido, tal como lo determinan los pasos discretos seleccionados por el programador. El parámetro denoising_end debería utilizarse idealmente cuando esta pipeline forma parte de una configuración multipipeline de "Mixture of Denoisers", como se detalla en Refining the Image Output

guidance_scale (float, opcional, valor predeterminado 5.0) : Escala de orientación definida en Classifier-Free Diffusion Guidance. guidance_scale se define como w de la ecuación 2. de Imagen Paper. La escala de orientación se habilita estableciendo guidance_scale > 1. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al prompt de texto, generalmente a costa de una menor calidad de imagen.

negative_prompt (str o list[str], opcional) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar negative_prompt_embeds en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si guidance_scale es menor que 1).

negative_prompt_2 (str o list[str], opcional) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a tokenizer_2 y text_encoder_2. Si no se define, negative_prompt se utiliza en ambos text-encoders

num_images_per_prompt (int, opcional, valor predeterminado 1) : El número de imágenes a generar por indicación.

eta (float, opcional, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a schedulers.DDIMScheduler, se ignorará en los demás.

generator (torch.Generator o list[torch.Generator], opcional) : Uno o una lista de generadores de torch para hacer la generación 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 proporcionan, se generará un tensor de latentes mediante muestreo usando el generator aleatorio suministrado.

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada prompt.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada negative_prompt.

pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada prompt.

negative_pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada negative_prompt.

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 si do_classifier_free_guidance está establecido en True. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entrada ip_adapter_image.

output_type (str, opcional, por defecto "pil") : El formato de salida de la imagen generada. Elija entre PIL: PIL.Image.Image o np.array.

return_dict (bool, opcional, valor predeterminado True) : Indica si se debe devolver un ~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput en lugar de una tupla simple.

cross_attention_kwargs (dict, opcional) : Un diccionario de kwargs que, si se especifica, se pasa al AttentionProcessor tal como se define bajo self.processor en diffusers.models.attention_processor.

guidance_rescale (float, opcional, valor predeterminado 0.0) : Factor de reescalado de guía propuesto por Common Diffusion Noise Schedules and Sample Steps are Flawed guidance_scale se define como φ en la ecuación 16. de Common Diffusion Noise Schedules and Sample Steps are Flawed. El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero.

original_size (tuple[int], opcional, valor predeterminado (1024, 1024)) : Si original_size no es igual a target_size, la imagen parecerá haber sido reescalada hacia abajo o hacia arriba. original_size tiene como valor predeterminado (height, width) si no se especifica. Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de https://huggingface.co/papers/2307.01952.

crops_coords_top_left (tuple[int], opcional, valor predeterminado (0, 0)) : crops_coords_top_left se puede utilizar para generar una imagen que parezca "recortada" desde la posición crops_coords_top_left hacia abajo. Generalmente, se logran imágenes favorables y bien centradas estableciendo crops_coords_top_left en (0, 0). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de https://huggingface.co/papers/2307.01952.

target_size (tuple[int], opcional, valor predeterminado (1024, 1024)) : En la mayoría de los casos, target_size debe establecerse en la altura y el ancho deseados de la imagen generada. Si no se especifica, el valor predeterminado será (height, width). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de https://huggingface.co/papers/2307.01952.

negative_original_size (tuple[int], opcional, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de una resolución de imagen específica. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de https://huggingface.co/papers/2307.01952. Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208.

negative_crops_coords_top_left (tuple[int], opcional, valor predeterminado (0, 0)) : Para condicionar negativamente el proceso de generación en función de unas coordenadas de recorte específicas. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de https://huggingface.co/papers/2307.01952. Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208.

negative_target_size (tuple[int], opcional, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de la resolución de imagen objetivo. Debe ser igual que target_size en la mayoría de los casos. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de https://huggingface.co/papers/2307.01952. Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208.

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 capa previa a la final para calcular los embeddings del prompt.

callback_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, opcional) : una función o una subclase de PipelineCallback o MultiPipelineCallbacks que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs incluirá una lista de todos los tensores especificados por callback_on_step_end_tensor_inputs.

callback_on_step_end_tensor_inputs (list, opcional) : La lista de entradas de tensor para la función callback_on_step_end. Los tensores especificados en la lista se pasarán como argumento callback_kwargs. Solo podrá incluir variables enumeradas en el atributo ._callback_tensor_inputs de su clase de pipeline.

Devuelve: ~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput o tuple

~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput si return_dict es True, de lo contrario una tuple. Al devolver una tupla, el primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:

>>> import torch
>>> from diffusers import StableDiffusionXLPipeline

>>> pipe = StableDiffusionXLPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> image = pipe(prompt).images[0]

encode_prompt[[diffusers.StableDiffusionXLPipeline.encode_prompt]]

encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)

Fuente

Parámetros:

prompt (str o list[str], opcional) : prompt a codificar

prompt_2 (str o list[str], opcional) : El prompt o los prompts que se enviarán al tokenizer_2 y al text_encoder_2. Si no se define, se utiliza prompt en ambos text-encoders

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 o no la guía libre de clasificador

negative_prompt (str o list[str], opcional) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar negative_prompt_embeds en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si guidance_scale es menor que 1).

negative_prompt_2 (str o list[str], opcional) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a tokenizer_2 y text_encoder_2. Si no se define, negative_prompt se utiliza en ambos text-encoders

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada prompt.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada negative_prompt.

pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada prompt.

negative_pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada negative_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 capa previa a la final para calcular los embeddings del prompt.

Codifica el prompt en estados ocultos del codificador de texto.

get_guidance_scale_embedding[[diffusers.StableDiffusionXLPipeline.get_guidance_scale_embedding]]

get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)

Fuente

Parámetros:

w (torch.Tensor) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal.

embedding_dim (int, opcional, valor predeterminado 512) : Dimensión de las incrustaciones a generar.

dtype (torch.dtype, opcional, valor predeterminado torch.float32) : Tipo de datos de los embeddings generados.

Devuelve: torch.Tensor

Vectores de incrustación con forma (len(w), embedding_dim).

Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298

StableDiffusionXLImg2ImgPipeline[[diffusers.StableDiffusionXLImg2ImgPipeline]]

diffusers.StableDiffusionXLImg2ImgPipeline[[diffusers.StableDiffusionXLImg2ImgPipeline]]

diffusers.StableDiffusionXLImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, requires_aesthetics_score: bool = False, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None)

Fuente

Parámetros:

vae (AutoencoderKL) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (CLIPTextModel) : Codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto de CLIP, específicamente la variante clip-vit-large-patch14.

text_encoder_2 ( CLIPTextModelWithProjection) : Segundo codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto y pool de CLIP, específicamente la variante laion/CLIP-ViT-bigG-14-laion2B-39B-b160k.

tokenizer (CLIPTokenizer) : Tokenizador de la clase CLIPTokenizer.

tokenizer_2 (CLIPTokenizer) : Segundo Tokenizer de la clase CLIPTokenizer.

unet (UNet2DConditionModel) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados.

scheduler (SchedulerMixin) : Un scheduler para usar en combinación con unet para desruidar los latentes de la imagen codificada. Puede ser uno de DDIMScheduler, LMSDiscreteScheduler o PNDMScheduler.

requires_aesthetics_score (bool, opcional, valor predeterminado "False") : Indica si el unet requiere que se pase una condición aesthetic_score durante la inferencia. Consulte también la configuración de stabilityai/stable-diffusion-xl-refiner-1-0.

force_zeros_for_empty_prompt (bool, opcional, valor predeterminado "True") : Si las incrustaciones del prompt negativo deben forzarse a establecerse siempre en 0. Consulte también la configuración de stabilityai/stable-diffusion-xl-base-1-0.

add_watermarker (bool, opcional) : Si se debe usar la invisible_watermark library para aplicar marcas de agua a las imágenes de salida. Si no se define, el valor predeterminado será True si el paquete está instalado; de lo contrario, no se usará ninguna marca de agua.

Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion XL.

Este modelo hereda de DiffusionPipeline. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la 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
from_single_file() para la carga de archivos .ckpt
load_lora_weights() para cargar los pesos de LoRA
save_lora_weights() para guardar los pesos de LoRA
load_ip_adapter() para cargar IP Adapters

call[[diffusers.StableDiffusionXLImg2ImgPipeline.call]]

__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, strength: float = 0.3, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_start: float | None = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, aesthetic_score: float = 6.0, negative_aesthetic_score: float = 2.5, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)

Fuente

Parámetros:

prompt (str o list[str], opcional) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar prompt_embeds en su lugar.

prompt_2 (str o list[str], opcional) : El prompt o los prompts que se enviarán al tokenizer_2 y al text_encoder_2. Si no se define, se utiliza prompt en ambos text-encoders

image (torch.Tensor o PIL.Image.Image o np.ndarray o list[torch.Tensor] o list[PIL.Image.Image] o list[np.ndarray]) : La(s) imagen(es) que se modificarán con el pipeline.

strength (float, opcional, valor predeterminado 0.3) : Conceptualmente, indica cuánto transformar la image de referencia. Debe estar entre 0 y 1. image se utilizará como punto de partida, añadiendo más ruido a medida que aumenta el strength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando strength es 1, el ruido añadido será máximo y el proceso de desruido se ejecutará durante el número completo de iteraciones especificado en num_inference_steps. Un valor de 1, por lo tanto, ignora esencialmente image. Tenga en cuenta que, en el caso de que denoising_start se declare como un entero, el valor de strength se ignorará.

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.

timesteps (list[int], opcional) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento timesteps en su método set_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pase num_inference_steps. Debe estar en orden descendente.

sigmas (list[float], opcional) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento sigmas en su método set_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pase num_inference_steps.

denoising_start (float, opcional) : Cuando se especifica, indica la fracción (entre 0.0 y 1.0) del proceso total de desruido que se omitirá antes de iniciarlo. En consecuencia, se omite la parte inicial del proceso de desruido y se asume que la image pasada es una imagen parcialmente desruidada. Tenga en cuenta que, cuando se especifica esto, la strength se ignorará. El parámetro denoising_start resulta especialmente beneficioso cuando este pipeline se integra en una configuración multipipeline de "Mixture of Denoisers", tal como se detalla en Refine Image Quality.

denoising_end (float, opcional) : Cuando se especifica, determina la fracción (entre 0.0 y 1.0) del proceso total de desruido que debe completarse antes de que se termine prematuramente de forma intencional. Como resultado, la muestra devuelta aún conservará una cantidad sustancial de ruido (aprox. se necesitan los últimos 20% de los pasos de tiempo) y debe desrudiarse mediante un pipeline sucesor que tenga denoising_start establecido en 0.8 para que solo desruidice el 20% final del programador. El parámetro denoising_end debería utilizarse idealmente cuando este pipeline forma parte de una configuración multipipeline de "Mixture of Denoisers", como se detalla en Refine Image Quality.

guidance_scale (float, opcional, valor predeterminado 7.5) : Escala de orientación definida en Classifier-Free Diffusion Guidance. guidance_scale se define como w de la ecuación 2. de Imagen Paper. La escala de orientación se habilita estableciendo guidance_scale > 1. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al prompt de texto, generalmente a costa de una menor calidad de imagen.