# Latent upscaler

El modelo de escalado latente de Stable Diffusion fue creado por [Katherine Crowson](https://github.com/crowsonkb/k-diffusion) en colaboración con [Stability AI](https://stability.ai/). Se utiliza para mejorar la resolución de la imagen de salida en un factor de 2 (consulte este [cuaderno](https://colab.research.google.com/drive/1o1qYJcFeywzCIdkfKJy7cTpgZTCM2EI4) para ver una demostración de la implementación original).

> [!TIP]
> Asegúrate de consultar la sección [Consejos](overview#tips) 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](https://huggingface.co/CompVis) y [Stability AI](https://huggingface.co/stabilityai) en Hub.

## StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

#### diffusers.StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

```python
diffusers.StableDiffusionLatentUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: EulerDiscreteScheduler)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L84)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto.

unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados.

scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un [EulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/euler#diffusers.EulerDiscreteScheduler) para usarse en combinación con `unet` para desruidar los latentes de la imagen codificada.

Pipeline para aumentar la resolución de la imagen de salida de Stable Diffusion por un factor de 2.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.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:
- [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt`

#### __call__[[diffusers.StableDiffusionLatentUpscalePipeline.__call__]]

```python
__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, negative_prompt: str | list[str] | None = None, 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, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L396)

**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 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`.

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`).

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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`.

pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, los embeddings de texto agrupados se generan a partir del argumento de entrada `prompt`.

negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo ya generados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación de prompts). Si no se proporcionan, los `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](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.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](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.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:
```py
>>> 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[[diffusers.StableDiffusionLatentUpscalePipeline.enable_sequential_cpu_offload]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L1293)

**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á y utilizará automáticamente el acelerador disponible.

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. La descarga 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[[diffusers.StableDiffusionLatentUpscalePipeline.enable_attention_slicing]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2048)

**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.

> [!WARNING] > ⚠️ 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:

```py
>>> 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.StableDiffusionLatentUpscalePipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2085)

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.StableDiffusionLatentUpscalePipeline.enable_xformers_memory_efficient_attention]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L1993)

**Parámetros:**

attention_op (`Callable`, *opcional*) : Anula el operador `None` predeterminado para su uso como argumento `op` de la función [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) de xFormers.

Habilita la atención eficiente en memoria desde [xFormers](https://facebookresearch.github.io/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.

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

Ejemplos:

```py
>>> 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.StableDiffusionLatentUpscalePipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2024)

Desactivar la atención eficiente en memoria de [xFormers](https://facebookresearch.github.io/xformers/).

#### encode_prompt[[diffusers.StableDiffusionLatentUpscalePipeline.encode_prompt]]

```python
encode_prompt(prompt, device, do_classifier_free_guidance, negative_prompt = 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L166)

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

negative_prompt (`str` o `list[str]`) : El prompt o los 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*) : 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.FloatTensor`, *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`.

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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)

**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.