# Stable unCLIP

  

Los puntos de control de Stable unCLIP se ajustan a partir de puntos de control de [Stable Diffusion 2.1](./stable_diffusion/stable_diffusion_2) para condicionar en los embeddings de imagen de CLIP. Stable unCLIP sigue condicionando en los embeddings de texto. Dado que existen dos condicionamientos separados, stable unCLIP puede utilizarse para la variación de imágenes guiada por texto. Cuando se combina con un prior de unCLIP, también puede emplearse para la generación completa de imágenes a partir de texto.

El resumen del artículo es:

*Los modelos contrastivos como CLIP han demostrado aprender representaciones robustas de imágenes que capturan tanto la semántica como el estilo. Para aprovechar estas representaciones para la generación de imágenes, proponemos un modelo de dos etapas: un prior que genera un embedding de imagen de CLIP dado un texto de descripción, y un decodificador que genera una imagen condicionada al embedding de imagen. Mostramos que generar explícitamente representaciones de imagen mejora la diversidad de las imágenes con una pérdida mínima en fotorrealismo y similitud con la descripción. Nuestros decodificadores condicionados a representaciones de imagen también pueden producir variaciones de una imagen que preservan tanto su semántica como su estilo, mientras varían los detalles no esenciales ausentes de la representación de imagen. Además, el espacio de embedding conjunto de CLIP permite manipulaciones de imagen guiadas por lenguaje de forma zero-shot. Utilizamos modelos de difusión para el decodificador y experimentamos con modelos tanto autoregresivos como de difusión para el prior, encontrando que estos últimos son computacionalmente más eficientes y producen muestras de mayor calidad.*

## Consejos

Stable unCLIP toma `noise_level` como entrada durante la inferencia, lo que determina la cantidad de ruido que se añade a los embeddings de imagen. Un `noise_level` más alto aumenta la variación en las imágenes finales sin ruido. De forma predeterminada, no se añade ningún ruido adicional a los embeddings de imagen (`noise_level = 0`).

### Generación de texto a imagen
Stable unCLIP puede utilizarse para la generación de imágenes a partir de texto mediante su combinación en una tubería con el modelo previo de la réplica de código abierto de DALL-E 2 de KakaoBrain, [Karlo](https://huggingface.co/kakaobrain/karlo-v1-alpha):

```python
import torch
from diffusers import UnCLIPScheduler, DDPMScheduler, StableUnCLIPPipeline
from diffusers.models import PriorTransformer
from transformers import CLIPTokenizer, CLIPTextModelWithProjection

prior_model_id = "kakaobrain/karlo-v1-alpha"
data_type = torch.float16
prior = PriorTransformer.from_pretrained(prior_model_id, subfolder="prior", dtype=data_type)

prior_text_model_id = "openai/clip-vit-large-patch14"
prior_tokenizer = CLIPTokenizer.from_pretrained(prior_text_model_id)
prior_text_model = CLIPTextModelWithProjection.from_pretrained(prior_text_model_id, dtype=data_type)
prior_scheduler = UnCLIPScheduler.from_pretrained(prior_model_id, subfolder="prior_scheduler")
prior_scheduler = DDPMScheduler.from_config(prior_scheduler.config)

stable_unclip_model_id = "stabilityai/stable-diffusion-2-1-unclip-small"

pipe = StableUnCLIPPipeline.from_pretrained(
    stable_unclip_model_id,
    dtype=data_type,
    variant="fp16",
    prior_tokenizer=prior_tokenizer,
    prior_text_encoder=prior_text_model,
    prior=prior,
    prior_scheduler=prior_scheduler,
)

pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"
wave_prompt = "dramatic wave, the Oceans roar, Strong wave spiral across the oceans as the waves unfurl into roaring crests; perfect wave form; perfect wave shape; dramatic wave shape; wave shape unbelievable; wave; wave shape spectacular"

image = pipe(prompt=wave_prompt).images[0]
image
```
> [!WARNING]
> Para texto a imagen, usamos `stabilityai/stable-diffusion-2-1-unclip-small` porque fue entrenado con embeddings de CLIP ViT-L/14, los mismos que el prior del modelo Karlo. [stabilityai/stable-diffusion-2-1-unclip](https://hf.co/stabilityai/stable-diffusion-2-1-unclip) fue entrenado con OpenCLIP ViT-H, por lo que no recomendamos su uso.

### Variación de imagen a imagen guiada por texto

```python
from diffusers import StableUnCLIPImg2ImgPipeline
from diffusers.utils import load_image
import torch

pipe = StableUnCLIPImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1-unclip", dtype=torch.float16, variation="fp16"
)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/tarsila_do_amaral.png"
init_image = load_image(url)

images = pipe(init_image).images
images[0].save("variation_image.png")
```

Opcionalmente, también puedes pasar un prompt a `pipe` como:

```python
prompt = "A fantasy landscape, trending on artstation"

image = pipe(init_image, prompt=prompt).images[0]
image
```

> [!TIP]
> Asegúrate de consultar la [guía de Schedulers](../../using-diffusers/schedulers) para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección [reutilizar componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

## StableUnCLIPPipeline[[diffusers.StableUnCLIPPipeline]]

#### diffusers.StableUnCLIPPipeline[[diffusers.StableUnCLIPPipeline]]

```python
diffusers.StableUnCLIPPipeline(prior_tokenizer: CLIPTokenizer, prior_text_encoder: CLIPTextModelWithProjection, prior: PriorTransformer, prior_scheduler: KarrasDiffusionSchedulers, image_normalizer: StableUnCLIPImageNormalizer, image_noising_scheduler: KarrasDiffusionSchedulers, tokenizer: CLIPTokenizer, text_encoder: CLIPTextModel, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vae: AutoencoderKL)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_unclip.py#L70)

**Parámetros:**

prior_tokenizer (`CLIPTokenizer`) : A `CLIPTokenizer`.

prior_text_encoder (`CLIPTextModelWithProjection`) : codificador de texto `CLIPTextModelWithProjection` congelado.

prior ([PriorTransformer](/docs/diffusers/v0.43.0/es/api/models/prior_transformer#diffusers.PriorTransformer)) : El prior de unCLIP canónico para aproximar el embedding de imagen a partir del embedding de texto.

prior_scheduler (`KarrasDiffusionSchedulers`) : Programador utilizado en el proceso previo de eliminación de ruido.

image_normalizer (`StableUnCLIPImageNormalizer`) : Se utiliza para normalizar los embeddings de imagen predichos antes de aplicar el ruido y desnormalizar los embeddings de imagen después de que se haya aplicado el ruido.

image_noising_scheduler (`KarrasDiffusionSchedulers`) : Programa de ruido para añadir ruido a los embeddings de imagen predichos. La cantidad de ruido a añadir está determinada por `noise_level`.

tokenizer (`CLIPTokenizer`) : A `CLIPTokenizer`.

text_encoder (`CLIPTextModel`) : codificador de texto `CLIPTextModel` congelado.

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

scheduler (`KarrasDiffusionSchedulers`) : Un programador para usar en combinación con `unet` para desruidar los latentes de imagen codificados.

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

Pipeline para la generación de imágenes a partir de texto usando stable unCLIP.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/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:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual
- [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA

#### __call__[[diffusers.StableUnCLIPPipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 20, guidance_scale: float = 10.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Optional[torch.Generator] = 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, noise_level: int = 0, prior_num_inference_steps: int = 25, prior_guidance_scale: float = 4.0, prior_latents: typing.Optional[torch.Tensor] = None, clip_skip: int | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_unclip.py#L645)

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

height (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : La altura en píxeles de la imagen generada.

width (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, *opcional*, valor predeterminado 20) : 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 10.0) : 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`).

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](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores.

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

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*, por defecto `True`) : Si se debe devolver un [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) 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`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

noise_level (`int`, *opcional*, valor predeterminado `0`) : La cantidad de ruido que se añadirá a los embeddings de la imagen. Un `noise_level` más alto aumenta la varianza en las imágenes finales sin ruido. Consulte [StableUnCLIPPipeline.noise_image_embeddings()](/docs/diffusers/v0.43.0/es/api/pipelines/stable_unclip#diffusers.StableUnCLIPPipeline.noise_image_embeddings) para más detalles.

prior_num_inference_steps (`int`, *opcional*, valor predeterminado 25) : El número de pasos de desruido en el proceso de desruido del prior. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

prior_guidance_scale (`float`, *opcional*, valor predeterminado 4.0) : 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`.

prior_latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de incrustaciones de imagen en el proceso de desruido previo. Se pueden usar para ajustar la misma generación con diferentes indicaciones. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

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:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple`

`~ pipeline_utils.ImagePipelineOutput` 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.

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

Ejemplos:
```py
>>> import torch
>>> from diffusers import StableUnCLIPPipeline

>>> pipe = StableUnCLIPPipeline.from_pretrained(
...     "fusing/stable-unclip-2-1-l", torch_dtype=torch.float16
... )  # TODO update model path
>>> pipe = pipe.to("cuda")

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

#### enable_attention_slicing[[diffusers.StableUnCLIPPipeline.enable_attention_slicing]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2030)

**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.StableUnCLIPPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2067)

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.StableUnCLIPPipeline.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/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1975)

**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.StableUnCLIPPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2006)

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

#### encode_prompt[[diffusers.StableUnCLIPPipeline.encode_prompt]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_unclip.py#L297)

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

#### noise_image_embeddings[[diffusers.StableUnCLIPPipeline.noise_image_embeddings]]

```python
noise_image_embeddings(image_embeds: Tensor, noise_level: int, noise: typing.Optional[torch.Tensor] = None, generator: typing.Optional[torch.Generator] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_unclip.py#L599)

Añada ruido a los embeddings de la imagen. La cantidad de ruido se controla mediante la entrada `noise_level`. Un `noise_level` más alto aumenta la varianza en las imágenes finales sin ruido.

El ruido se aplica de dos formas:
1. Se aplica un programa de ruido directamente a las incrustaciones.
2. Se añaden un vector de incrustaciones sinusoidales de tiempo a la salida.

En ambos casos, la cantidad de ruido se controla mediante el mismo `noise_level`.

Los embeddings se normalizan antes de aplicar el ruido y se desnormalizan después de aplicar el ruido.

## StableUnCLIPImg2ImgPipeline[[diffusers.StableUnCLIPImg2ImgPipeline]]

#### diffusers.StableUnCLIPImg2ImgPipeline[[diffusers.StableUnCLIPImg2ImgPipeline]]

```python
diffusers.StableUnCLIPImg2ImgPipeline(feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection, image_normalizer: StableUnCLIPImageNormalizer, image_noising_scheduler: KarrasDiffusionSchedulers, tokenizer: CLIPTokenizer, text_encoder: CLIPTextModel, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vae: AutoencoderKL)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_unclip_img2img.py#L81)

**Parámetros:**

feature_extractor (`CLIPImageProcessor`) : Extractor de características para el preprocesamiento de imágenes antes de ser codificadas.

image_encoder (`CLIPVisionModelWithProjection`) : modelo de visión de CLIP para codificar imágenes.

image_normalizer (`StableUnCLIPImageNormalizer`) : Se utiliza para normalizar los embeddings de imagen predichos antes de aplicar el ruido y desnormalizar los embeddings de imagen después de que se haya aplicado el ruido.

image_noising_scheduler (`KarrasDiffusionSchedulers`) : Programa de ruido para añadir ruido a los embeddings de imagen predichos. La cantidad de ruido a añadir está determinada por `noise_level`.

tokenizer (`~transformers.CLIPTokenizer`) : A [`~transformers.CLIPTokenizer`)].

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : codificador de texto [CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel) congelado.

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

scheduler (`KarrasDiffusionSchedulers`) : Un programador para usar en combinación con `unet` para desruidar los latentes de imagen codificados.

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

Pipeline para la generación de imagen a imagen guiada por texto usando stable unCLIP.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/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:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual
- [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA

#### __call__[[diffusers.StableUnCLIPImg2ImgPipeline.__call__]]

```python
__call__(image: typing.Union[torch.Tensor, PIL.Image.Image] = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 20, guidance_scale: float = 10, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Optional[torch.Generator] = 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, noise_level: int = 0, image_embeds: typing.Optional[torch.Tensor] = None, clip_skip: int | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_unclip_img2img.py#L624)

**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 usará `prompt_embeds` o el prompt se inicializará en `""`.

image (`torch.Tensor` o `PIL.Image.Image`) : `Image` o tensor que representa un lote de imágenes. La imagen se codifica en su embedding de CLIP, sobre el cual se condiciona el `unet`. La imagen _no_ se codifica con el `vae` y luego se utiliza como latentes en el proceso de desruido, como ocurre en el proceso estándar de variación de imágenes guiadas por texto de Stable Diffusion.

height (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : La altura en píxeles de la imagen generada.

width (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, *opcional*, valor predeterminado 20) : 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 10.0) : 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`).

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](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores.

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

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*, por defecto `True`) : Si se debe devolver un [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) 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`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

noise_level (`int`, *opcional*, valor predeterminado `0`) : La cantidad de ruido que se añadirá a los embeddings de la imagen. Un `noise_level` más alto aumenta la varianza en las imágenes finales sin ruido. Consulte [StableUnCLIPPipeline.noise_image_embeddings()](/docs/diffusers/v0.43.0/es/api/pipelines/stable_unclip#diffusers.StableUnCLIPPipeline.noise_image_embeddings) para más detalles.

image_embeds (`torch.Tensor`, *opcional*) : Embeddings de CLIP pregenerados para condicionar el `unet`. Estos latentes no se utilizan en el proceso de desruido. Si deseas proporcionar latentes pregenerados, pásalos a `__call__` como `latents`.

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:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple`

`~ pipeline_utils.ImagePipelineOutput` 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.

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

Ejemplos:
```py
>>> import requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO

>>> from diffusers import StableUnCLIPImg2ImgPipeline

>>> pipe = StableUnCLIPImg2ImgPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-2-1-unclip-small", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")

>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"

>>> response = requests.get(url)
>>> init_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> init_image = init_image.resize((768, 512))

>>> prompt = "A fantasy landscape, trending on artstation"

>>> images = pipe(init_image, prompt).images
>>> images[0].save("fantasy_landscape.png")
```

#### enable_attention_slicing[[diffusers.StableUnCLIPImg2ImgPipeline.enable_attention_slicing]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2030)

**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.StableUnCLIPImg2ImgPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2067)

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.StableUnCLIPImg2ImgPipeline.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/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1975)

**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.StableUnCLIPImg2ImgPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2006)

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

#### encode_prompt[[diffusers.StableUnCLIPImg2ImgPipeline.encode_prompt]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_unclip_img2img.py#L259)

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

#### noise_image_embeddings[[diffusers.StableUnCLIPImg2ImgPipeline.noise_image_embeddings]]

```python
noise_image_embeddings(image_embeds: Tensor, noise_level: int, noise: typing.Optional[torch.Tensor] = None, generator: typing.Optional[torch.Generator] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_unclip_img2img.py#L578)

Añada ruido a los embeddings de la imagen. La cantidad de ruido se controla mediante la entrada `noise_level`. Un `noise_level` más alto aumenta la varianza en las imágenes finales sin ruido.

El ruido se aplica de dos formas:
1. Se aplica un programa de ruido directamente a las incrustaciones.
2. Se añaden un vector de incrustaciones sinusoidales de tiempo a la salida.

En ambos casos, la cantidad de ruido se controla mediante el mismo `noise_level`.

Los embeddings se normalizan antes de aplicar el ruido y se desnormalizan después de aplicar el ruido.

## ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

#### diffusers.ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

```python
diffusers.ImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L135)

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

Clase de salida para pipelines de imágenes.