Hugging Face's logo

Diffusers documentation

Latent upscaler

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Latent upscaler

El modelo de escalado latente de Stable Diffusion fue creado por Katherine Crowson en colaboración con Stability AI. Se utiliza para mejorar la resolución de la imagen de salida en un factor de 2 (consulte este cuaderno para ver una demostración de la implementación original).

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.

StableDiffusionLatentUpscalePipeline

clase diffusers.StableDiffusionLatentUpscalePipeline

< >

( vae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizerunet: UNet2DConditionModelscheduler: EulerDiscreteScheduler )

Parámetros

Pipeline para aumentar la resolución de la imagen de salida de Stable Diffusion por un factor de 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:

__call__

< >

( 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 = 75guidance_scale: float = 9.0negative_prompt: str | list[str] | None = Nonegenerator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonepooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecallback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = Nonecallback_steps: int = 1 ) → StableDiffusionPipelineOutput or tuple

Parámetros

  • prompt (str o list[str]) — El prompt o los prompts para guiar el aumento de escala de la imagen.
  • 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 resolución. Si es un tensor, puede ser una salida latente de un modelo de Stable Diffusion o un tensor de imagen en el rango [-1, 1]. Se considera latent si image.shape[1] es 4; de lo contrario, se considera una representación de imagen y se codifica usando el codificador vae de este pipeline.
  • 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 de escala de guía más alto 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.
  • negative_prompt (str o list[str], opcional) — El prompt o los prompts para guiar lo que no debe incluirse en la generación de imágenes. Si no se define, es necesario pasar negative_prompt_embeds en su lugar. Se ignora cuando no se usa guía (guidance_scale < 1).
  • generator (torch.Generator o list[torch.Generator], opcional) — Un torch.Generator para hacer que la generación sea determinista.
  • latents (torch.Tensor, opcional) — Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando 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) — Incrustaciones de texto negativo pregeneradas. 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.
  • pooled_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto agrupadas pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporciona, las incrustaciones de texto agrupadas se generan a partir del argumento de entrada prompt.
  • negative_pooled_prompt_embeds (torch.Tensor, opcional) — Embeddings de texto agrupados negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporciona, los negative_prompt_embeds agrupados 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.

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.

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

Ejemplos:

>>> from diffusers import StableDiffusionLatentUpscalePipeline, StableDiffusionPipeline
>>> import torch

>>> pipeline = StableDiffusionPipeline.from_pretrained(
...     "CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16
... )
>>> pipeline.to("cuda")

>>> model_id = "stabilityai/sd-x2-latent-upscaler"
>>> upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16)
>>> upscaler.to("cuda")

>>> prompt = "a photo of an astronaut high resolution, unreal engine, ultra realistic"
>>> generator = torch.manual_seed(33)

>>> low_res_latents = pipeline(prompt, generator=generator, output_type="latent").images

>>> with torch.no_grad():
...     image = pipeline.decode_latents(low_res_latents)
>>> image = pipeline.numpy_to_pil(image)[0]

>>> image.save("../images/a1.png")

>>> upscaled_image = upscaler(
...     prompt=prompt,
...     image=low_res_latents,
...     num_inference_steps=20,
...     guidance_scale=0,
...     generator=generator,
... ).images[0]

>>> upscaled_image.save("../images/a2.png")

enable_sequential_cpu_offload

< >

( gpu_id: int | None = Nonedevice: typing.Union[torch.device, str] = None )

Parámetros

  • gpu_id (int, opcional) — El ID del acelerador que se utilizará en la inferencia. Si no se especifica, el valor predeterminado será 0.
  • device (torch.Device o str, opcional, valor predeterminado None) — El tipo de dispositivo de PyTorch del acelerador que se utilizará en la inferencia. Si no se especifica, se detectará automáticamente el acelerador disponible y se utilizará.

Descarga todos los modelos a la CPU usando 🤗 Accelerate, reduciendo significativamente el uso de memoria. Al llamarse, los state dicts de todos los componentes torch.nn.Module (excepto los que están en self._exclude_from_cpu_offload) se guardan en la CPU y luego se mueven a torch.device('meta') y se cargan en el acelerador solo cuando se llama al método forward de su submódulo específico. El offloading se realiza a nivel de submódulo. El ahorro de memoria es mayor que con enable_model_cpu_offload, pero el rendimiento es menor.

enable_attention_slicing

< >

( slice_size: str | int = 'auto' )

Parámetros

  • slice_size (str o int, opcional, valor predeterminado "auto") — Cuando es "auto", se divide a la mitad la entrada de las cabezas de atención, de modo que la atención se calcula en dos pasos. Si es "max", se ahorra la máxima cantidad de memoria al ejecutar solo una porción a la vez. Si se proporciona un número, se usan 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 secuencialmente 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 *slicing* 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 activar > esta función. Si activas el *slicing* de atención con SDPA o xFormers, ¡puede provocar ralentizamientos significativos!

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

< >

( )

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

< >

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

Parámetros

  • attention_op (Callable, opcional) — Sustituye el operador predeterminado None para usarlo 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, debería 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 en memoria 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

< >

( )

Desactivar la atención eficiente en memoria de xFormers.

encode_prompt

< >

( promptdevicedo_classifier_free_guidancenegative_prompt = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonepooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None )

Parámetros

  • prompt (str o list(int)) — prompt a codificar
  • device — (torch.device): dispositivo de torch
  • do_classifier_free_guidance (bool) — si se debe usar classifier free guidance o no
  • negative_prompt (str o list[str]) — El prompt o prompts que no deben guiar la generación de la imagen. Se ignora cuando no se usa guía (es decir, se ignora si guidance_scale es menor que 1).
  • prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, las incrustaciones de texto se generarán a partir del argumento de entrada prompt.
  • negative_prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada negative_prompt.
  • pooled_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto agrupadas pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporciona, las incrustaciones de texto agrupadas se generarán a partir del argumento de entrada prompt.
  • negative_pooled_prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto negativo agrupadas pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, se generarán pooled negative_prompt_embeds a partir del argumento de entrada negative_prompt.

Codifica el prompt en estados ocultos del codificador de texto.

StableDiffusionPipelineOutput

clase diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput

< >

( images: list[PIL.Image.Image] | numpy.ndarraynsfw_content_detected: list[bool] | None )

Parámetros

  • images (list[PIL.Image.Image] o np.ndarray) — lista de imágenes PIL desruidadas de longitud batch_size o array de NumPy de forma (batch_size, height, width, num_channels).
  • nsfw_content_detected (list[bool]) — lista que indica si la imagen generada correspondiente contiene contenido “no apto para el trabajo” (nsfw) o None si no se pudo realizar la verificación de seguridad.

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

Update on GitHub

←Inpainting SDXL Turbo→