diffusers/v0.43.0/es/api/pipelines/stable_diffusion/upscale.md

Superresolución

El modelo de difusión del upscaler de Stable Diffusion fue creado por los investigadores e ingenieros de CompVis, Stability AI y LAION. Se utiliza para mejorar la resolución de las imágenes de entrada por un factor de 4.

Asegúrate de consultar la sección Consejos de Stable Diffusion para aprender a explorar el equilibrio entre la velocidad y la calidad del programador, y a reutilizar los componentes del pipeline de manera eficiente.

Si te interesa utilizar uno de los puntos de control oficiales para una tarea, explora las organizaciones CompVis y Stability AI en Hub.

StableDiffusionUpscalePipeline[[diffusers.StableDiffusionUpscalePipeline]]

diffusers.StableDiffusionUpscalePipeline[[diffusers.StableDiffusionUpscalePipeline]]

diffusers.StableDiffusionUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, low_res_scheduler: DDPMScheduler, scheduler: KarrasDiffusionSchedulers, safety_checker: typing.Any | None = None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None = None, watermarker: typing.Any | None = None, max_noise_level: int = 350)

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 (clip-vit-large-patch14).

tokenizer (CLIPTokenizer) : Un CLIPTokenizer para tokenizar texto.

unet (UNet2DConditionModel) : Un UNet2DConditionModel para desruidar los latentes de imagen codificados.

low_res_scheduler (SchedulerMixin) : Un programador utilizado para añadir ruido inicial a la imagen de condicionamiento de baja resolución. Debe ser una instancia de DDPMScheduler.

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.

Pipeline para super-resolución de imágenes guiada por texto usando Stable Diffusion 2.

Este modelo hereda de DiffusionPipeline. Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

El pipeline también hereda los siguientes métodos de carga:

• load_textual_inversion() para cargar incrustaciones de inversión textual
• load_lora_weights() para cargar los pesos de LoRA
• save_lora_weights() para guardar los pesos de LoRA
• from_single_file() para la carga de archivos .ckpt

call[[diffusers.StableDiffusionUpscalePipeline.call]]

__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, num_inference_steps: int = 75, guidance_scale: float = 9.0, noise_level: int = 20, negative_prompt: 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, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int = None)

Fuente

Parámetros:

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

image (torch.Tensor, PIL.Image.Image, np.ndarray, list[torch.Tensor], list[PIL.Image.Image] o list[np.ndarray]) : Image o tensor que representa un lote de imágenes para aumentar su escala.

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.

guidance_scale (float, opcional, valor predeterminado 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al prompt de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando guidance_scale > 1.

noise_level (int, opcional, valor predeterminado 20) : La cantidad de ruido que se añadirá a la imagen de entrada ampliada. Debe estar en el rango [0, max_noise_level], donde max_noise_level está definido por el programador. Un noise_level más alto añade más ruido a la entrada, lo que aumenta la variación pero reduce la fidelidad a la imagen de origen.

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

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 (η) del artículo DDIM. Solo se aplica al DDIMScheduler y se ignora en otros programadores.

generator (torch.Generator o list[torch.Generator], opcional) : Un torch.Generator 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 proporciona, se genera un tensor de latentes mediante muestreo usando el generator aleatorio suministrado.

prompt_embeds (torch.Tensor, opcional) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada prompt.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, negative_prompt_embeds se generan a partir del argumento de entrada negative_prompt.

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

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

callback (Callable, opcional) : Una función que se llama cada callback_steps pasos durante la inferencia. La función se llama con los siguientes argumentos: callback(step: int, timestep: int, latents: torch.Tensor).

callback_steps (int, opcional, valor predeterminado 1) : La frecuencia con la que se llama a la función callback. Si no se especifica, la callback se llama en cada paso.

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

clip_skip (int, opcional) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

Devuelve: StableDiffusionPipelineOutput o tuple

Si return_dict es True, se devuelve StableDiffusionPipelineOutput; en caso contrario, se devuelve una tuple cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de bool que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

La función de llamada para el pipeline de generación.

Ejemplos:

>>> import requests
>>> from PIL import Image
>>> from io import BytesIO
>>> from diffusers import StableDiffusionUpscalePipeline
>>> import torch

>>> # load model and scheduler
>>> model_id = "stabilityai/stable-diffusion-x4-upscaler"
>>> pipeline = StableDiffusionUpscalePipeline.from_pretrained(
...     model_id, variant="fp16", torch_dtype=torch.float16
... )
>>> pipeline = pipeline.to("cuda")

>>> # let's download an  image
>>> url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale/low_res_cat.png"
>>> response = requests.get(url)
>>> low_res_img = Image.open(BytesIO(response.content)).convert("RGB")
>>> low_res_img = low_res_img.resize((128, 128))
>>> prompt = "a white cat"

>>> upscaled_image = pipeline(prompt=prompt, image=low_res_img).images[0]
>>> upscaled_image.save("upsampled_cat.png")

enable_attention_slicing[[diffusers.StableDiffusionUpscalePipeline.enable_attention_slicing]]

enable_attention_slicing(slice_size: str | int = 'auto')

Fuente

Parámetros:

slice_size (str o int, opcional, valor predeterminado "auto") : Cuando es "auto", divide a la mitad la entrada de las cabezas de atención, de modo que la atención se calculará en dos pasos. Si es "max", se ahorrará la máxima cantidad de memoria ejecutando solo una porción a la vez. Si se proporciona un número, se utilizan tantas porciones como attention_head_dim // slice_size. En este caso, attention_head_dim debe ser un múltiplo de slice_size.

Habilita el cálculo de atención segmentada. Cuando esta opción está habilitada, el módulo de atención divide el tensor de entrada en fragmentos para calcular la atención en varios pasos. Para más de una cabeza de atención, el cálculo se realiza de forma secuencial sobre cada cabeza. Esto es útil para ahorrar algo de memoria a cambio de una pequeña disminución en la velocidad.

> ⚠️ No actives el rebanado de atención si ya estás usando scaled_dot_product_attention (SDPA) de PyTorch > 2.0 o xFormers. Estos cálculos de atención ya son muy eficientes en memoria, por lo que no necesitarás habilitar > esta función. Si habilitas el rebanado de atención con SDPA o xFormers, ¡puede provocar una ralentización grave!

Ejemplos:

>>> import torch
>>> from diffusers import StableDiffusionPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )

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

disable_attention_slicing[[diffusers.StableDiffusionUpscalePipeline.disable_attention_slicing]]

disable_attention_slicing()

Fuente

Desactiva el cálculo de atención segmentada. Si enable_attention_slicing se llamó previamente, la atención se calcula en un solo paso.

enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionUpscalePipeline.enable_xformers_memory_efficient_attention]]

enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)

Fuente

Parámetros:

attention_op (Callable, opcional) : Anula el operador None predeterminado para su uso como argumento op de la función memory_efficient_attention() de xFormers.

Habilita la atención eficiente en memoria desde xFormers. Cuando esta opción está habilitada, debe observar un menor uso de memoria de GPU y una posible aceleración durante la inferencia. No se garantiza una aceleración durante el entrenamiento.

> ⚠️ Cuando la atención eficiente en memoria y la atención segmentada están ambas habilitadas, la atención eficiente attention tiene > precedencia.

Ejemplos:

>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)

disable_xformers_memory_efficient_attention[[diffusers.StableDiffusionUpscalePipeline.disable_xformers_memory_efficient_attention]]

disable_xformers_memory_efficient_attention()

Fuente

Desactivar la atención eficiente en memoria de xFormers.

encode_prompt[[diffusers.StableDiffusionUpscalePipeline.encode_prompt]]

encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)

Fuente

Parámetros:

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

device : (torch.device): dispositivo de torch

num_images_per_prompt (int) : número de imágenes que deben generarse por prompt

do_classifier_free_guidance (bool) : si se debe usar 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).

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.

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.

StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)

Fuente

Parámetros:

images (list[PIL.Image.Image] o np.ndarray) : lista de imágenes PIL desruidas de longitud batch_size o matriz NumPy de forma (batch_size, height, width, num_channels).

nsfw_content_detected (list[bool]) : lista que indica si la imagen generada correspondiente contiene contenido "no apto para el trabajo" (nsfw) o None si no se pudo realizar la verificación de seguridad.

Clase de salida para las tuberías de Stable Diffusion.