# Stable unCLIP

  

Os checkpoints do Stable unCLIP são ajustados a partir de checkpoints do [Stable Diffusion 2.1](./stable_diffusion/stable_diffusion_2) para condicionar em embeddings de imagem do CLIP. O Stable unCLIP ainda condiciona em embeddings de texto. Dado os dois condicionamentos separados, o Stable unCLIP pode ser usado para variação de imagem guiada por texto. Quando combinado com um prior do unCLIP, também pode ser usado para geração completa de imagem a partir de texto.

O resumo do artigo é:

*Modelos contrastivos como o CLIP demonstraram ser capazes de aprender representações robustas de imagens que capturam tanto a semântica quanto o estilo. Para aproveitar essas representações na geração de imagens, propomos um modelo de duas etapas: um prior que gera um embedding de imagem do CLIP dado um texto de legenda, e um decodificador que gera uma imagem condicionada ao embedding de imagem. Mostramos que a geração explícita de representações de imagem melhora a diversidade das imagens com perda mínima em fotorrealismo e similaridade com a legenda. Nossos decodificadores condicionados a representações de imagem também podem produzir variações de uma imagem que preservam tanto a semântica quanto o estilo, enquanto variam os detalhes não essenciais ausentes da representação de imagem. Além disso, o espaço de embedding conjunto do CLIP permite manipulações de imagem guiadas por linguagem de forma zero-shot. Usamos modelos de difusão para o decodificador e experimentamos com modelos autoregressivos e de difusão para o prior, constatando que os últimos são computacionalmente mais eficientes e produzem amostras de maior qualidade.*

## Dicas

Stable unCLIP recebe `noise_level` como entrada durante a inferência, o que determina a quantidade de ruído adicionada aos embeddings de imagem. Um `noise_level` mais alto aumenta a variação nas imagens finais sem ruído. Por padrão, não adicionamos nenhum ruído adicional aos embeddings de imagem (`noise_level = 0`).

### Geração de Imagem a partir de Texto
O Stable unCLIP pode ser utilizado para geração de imagem a partir de texto ao ser combinado em pipeline com o modelo anterior da replicação open source do DALL-E 2 da 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-para-imagem, usamos `stabilityai/stable-diffusion-2-1-unclip-small`, pois foi treinado com embeddings CLIP ViT-L/14, os mesmos do prior do modelo Karlo. [stabilityai/stable-diffusion-2-1-unclip](https://hf.co/stabilityai/stable-diffusion-2-1-unclip) foi treinado com OpenCLIP ViT-H, portanto não recomendamos seu uso.

### Variação de Imagem-para-Imagem 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, você também pode passar um prompt para `pipe`, como:

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

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

> [!TIP]
> Certifique-se de consultar o [guia](../../using-diffusers/schedulers) de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção [reutilização de componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários 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)
```

[Fonte](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/pt/api/models/prior_transformer#diffusers.PriorTransformer)) : O prior unCLIP canônico para aproximar o embedding da imagem a partir do embedding do texto.

prior_scheduler (`KarrasDiffusionSchedulers`) : Agendador usado no processo de remoção de ruído prévio.

image_normalizer (`StableUnCLIPImageNormalizer`) : Usado para normalizar os embeddings de imagem previstos antes da aplicação do ruído e desnormalizar os embeddings de imagem após a aplicação do ruído.

image_noising_scheduler (`KarrasDiffusionSchedulers`) : Agenda de ruído para adicionar ruído aos embeddings de imagem previstos. A quantidade de ruído a ser adicionada é determinada pelo `noise_level`.

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

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

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Um [UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel) para desruidar os latentes da imagem codificada.

scheduler (`KarrasDiffusionSchedulers`) : Um agendador a ser usado em combinação com `unet` para desruidar os latentes da imagem codificada.

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

Pipeline para geração de texto para imagem usando stable unCLIP.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

O pipeline também herda os seguintes métodos de carregamento:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/pt/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para carregar embeddings de inversão textual
- [load_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para carregar os pesos do LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para salvar os pesos do 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)
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração de imagens. Se não definido, você precisa passar `prompt_embeds`.

height (`int`, *opcional*, padrão `self.unet.config.sample_size * self.vae_scale_factor`) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão `self.unet.config.sample_size * self.vae_scale_factor`) : A largura em pixels da imagem gerada.

num_inference_steps (`int`, *opcional*, padrão 20) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

guidance_scale (`float`, *opcional*, padrão 10.0) : Um valor mais alto de guidance scale incentiva o modelo a gerar imagens fortemente ligadas ao `prompt` de texto, em detrimento de uma menor qualidade de imagem. O guidance scale é ativado quando `guidance_scale > 1`.

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar o que não incluir na geração de imagem. Se não definido, você precisa passar `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale < 1`).

num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.

eta (`float`, *opcional*, padrão 0.0) : Corresponde ao parâmetro eta (η) do paper [DDIM](https://huggingface.co/papers/2010.02502). Aplica-se apenas ao [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler) e é ignorado em outros agendadores.

generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

callback (`Callable`, *opcional*) : Uma função que é chamada a cada `callback_steps` etapas durante a inferência. A função é chamada com os seguintes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, padrão 1) : A frequência com que a função `callback` é chamada. Se não for especificada, o callback é chamado a cada etapa.

cross_attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado ao `AttentionProcessor` conforme definido em [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

noise_level (`int`, *opcional*, padrão `0`) : A quantidade de ruído a ser adicionada aos embeddings da imagem. Um `noise_level` maior aumenta a variância nas imagens finais sem ruído. Consulte [StableUnCLIPPipeline.noise_image_embeddings()](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_unclip#diffusers.StableUnCLIPPipeline.noise_image_embeddings) para mais detalhes.

prior_num_inference_steps (`int`, *opcional*, padrão 25) : O número de etapas de remoção de ruído no processo de remoção de ruído do prior. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

prior_guidance_scale (`float`, *opcional*, padrão 4.0) : Um valor mais alto de guidance scale incentiva o modelo a gerar imagens fortemente ligadas ao `prompt` de texto, em detrimento de uma menor qualidade de imagem. O guidance scale é ativado quando `guidance_scale > 1`.

prior_latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de incorporação de imagem no processo de desruidamento prévio. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.

clip_skip (`int`, *opcional*) : Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

`~ pipeline_utils.ImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas.

A função de chamada do pipeline para geração.

Exemplos:
```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')
```

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

**Parâmetros:**

slice_size (`str` ou `int`, *opcional*, padrão `"auto"`) : Quando `"auto"`, divide a entrada dos cabeçalhos de atenção pela metade, de modo que a atenção será calculada em duas etapas. Se `"max"`, a quantidade máxima de memória será economizada executando apenas uma fatia por vez. Se um número for fornecido, usa tantas fatias quanto `attention_head_dim // slice_size`. Nesse caso, `attention_head_dim` deve ser um múltiplo de `slice_size`.

Ativa o cálculo de atenção fatiado. Quando esta opção está ativada, o módulo de atenção divide o tensor de entrada em fatias para calcular a atenção em várias etapas. Para mais de uma cabeça de atenção, o cálculo é executado sequencialmente em cada cabeça. Isso é útil para economizar memória em troca de uma pequena diminuição na velocidade.

> [!WARNING] > ⚠️ Não ative o fatiamento de atenção se você já estiver usando `scaled_dot_product_attention` (SDPA)
do PyTorch > 2.0 ou xFormers. Esses cálculos de atenção já são muito eficientes em termos de memória, portanto, você não precisará habilitar > esta função. Se você habilitar o fatiamento de atenção com SDPA ou xFormers, isso pode levar a uma desaceleração significativa!

Exemplos:

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

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

Desativa o cálculo de atenção fatiado. Se `enable_attention_slicing` foi chamado anteriormente, a atenção é calculada em uma única etapa.

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

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

**Parâmetros:**

attention_op (`Callable`, *opcional*) : Substitui o operador padrão `None` para uso como argumento `op` da função [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) do xFormers.

Ative a atenção eficiente em memória do [xFormers](https://facebookresearch.github.io/xformers/). Quando essa opção estiver ativada, você deve observar um menor uso de memória de GPU e uma possível aceleração durante a inferência. A aceleração durante o treinamento não é garantida.

> [!WARNING] > ⚠️ Quando a atenção eficiente em memória e a atenção fatiada estão ambas habilitadas, a atenção eficiente
attention tem > precedência.

Exemplos:

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

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

Desative a atenção eficiente em memória do [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)
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado

device : (`torch.device`): dispositivo torch

num_images_per_prompt (`int`) : número de imagens que devem ser geradas por prompt

do_classifier_free_guidance (`bool`) : se deve ou não usar classifier free guidance

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.

lora_scale (`float`, *opcional*) : Uma escala LoRA que será aplicada a todas as camadas LoRA do codificador de texto, caso as camadas LoRA sejam carregadas.

clip_skip (`int`, *opcional*) : Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.

Codifica o prompt em estados ocultos do 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)
```

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

Adicione ruído aos embeddings da imagem. A quantidade de ruído é controlada pela entrada `noise_level`. Um `noise_level` mais alto aumenta a variância nas imagens finais sem ruído.

O ruído é aplicado de duas maneiras:
1. Um cronograma de ruído é aplicado diretamente aos embeddings.
2. Um vetor de embeddings sinusoidais de tempo é anexado à saída.

Nos dois casos, a quantidade de ruído é controlada pelo mesmo `noise_level`.

Os embeddings são normalizados antes da aplicação do ruído e desnormalizados após a aplicação do ruído.

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

[Fonte](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`) : Extrator de recursos para pré-processamento de imagens antes da codificação.

image_encoder (`CLIPVisionModelWithProjection`) : modelo de visão do CLIP para codificação de imagens.

image_normalizer (`StableUnCLIPImageNormalizer`) : Usado para normalizar os embeddings de imagem previstos antes da aplicação do ruído e desnormalizar os embeddings de imagem após a aplicação do ruído.

image_noising_scheduler (`KarrasDiffusionSchedulers`) : Agenda de ruído para adicionar ruído aos embeddings de imagem previstos. A quantidade de ruído a ser adicionada é determinada pelo `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/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Um [UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel) para desruidar os latentes da imagem codificada.

scheduler (`KarrasDiffusionSchedulers`) : Um agendador a ser usado em combinação com `unet` para desruidar os latentes da imagem codificada.

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

Pipeline para geração de imagem a partir de imagem guiada por texto usando stable unCLIP.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

O pipeline também herda os seguintes métodos de carregamento:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/pt/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para carregar embeddings de inversão textual
- [load_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para carregar os pesos do LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para salvar os pesos do 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)
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, `prompt_embeds` será usado ou o prompt será inicializado como `""`.

image (`torch.Tensor` ou `PIL.Image.Image`) : `Image` ou tensor representando um lote de imagens. A imagem é codificada em seu embedding CLIP, no qual o `unet` é condicionado. A imagem _não_ é codificada pelo `vae` e, em seguida, usada como latentes no processo de desruidamento, como ocorre no processo padrão de variação de imagem guiada por texto do Stable Diffusion.

height (`int`, *opcional*, padrão `self.unet.config.sample_size * self.vae_scale_factor`) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão `self.unet.config.sample_size * self.vae_scale_factor`) : A largura em pixels da imagem gerada.

num_inference_steps (`int`, *opcional*, padrão 20) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

guidance_scale (`float`, *opcional*, padrão 10.0) : Um valor mais alto de guidance scale incentiva o modelo a gerar imagens fortemente ligadas ao `prompt` de texto, em detrimento de uma menor qualidade de imagem. O guidance scale é ativado quando `guidance_scale > 1`.

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar o que não incluir na geração de imagem. Se não definido, você precisa passar `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale < 1`).

num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.

eta (`float`, *opcional*, padrão 0.0) : Corresponde ao parâmetro eta (η) do paper [DDIM](https://huggingface.co/papers/2010.02502). Aplica-se apenas ao [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler) e é ignorado em outros agendadores.

generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

callback (`Callable`, *opcional*) : Uma função que é chamada a cada `callback_steps` etapas durante a inferência. A função é chamada com os seguintes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, padrão 1) : A frequência com que a função `callback` é chamada. Se não for especificada, o callback é chamado a cada etapa.

cross_attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado ao `AttentionProcessor` conforme definido em [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

noise_level (`int`, *opcional*, padrão `0`) : A quantidade de ruído a ser adicionada aos embeddings da imagem. Um `noise_level` maior aumenta a variância nas imagens finais sem ruído. Consulte [StableUnCLIPPipeline.noise_image_embeddings()](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_unclip#diffusers.StableUnCLIPPipeline.noise_image_embeddings) para mais detalhes.

image_embeds (`torch.Tensor`, *opcional*) : Embebidos CLIP pré-gerados para condicionar o `unet`. Esses latentes não são usados no processo de desruidamento. Se você deseja fornecer latentes pré-gerados, passe-os para `__call__` como `latents`.

clip_skip (`int`, *opcional*) : Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

`~ pipeline_utils.ImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas.

A função de chamada do pipeline para geração.

Exemplos:
```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')
```

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

**Parâmetros:**

slice_size (`str` ou `int`, *opcional*, padrão `"auto"`) : Quando `"auto"`, divide a entrada dos cabeçalhos de atenção pela metade, de modo que a atenção será calculada em duas etapas. Se `"max"`, a quantidade máxima de memória será economizada executando apenas uma fatia por vez. Se um número for fornecido, usa tantas fatias quanto `attention_head_dim // slice_size`. Nesse caso, `attention_head_dim` deve ser um múltiplo de `slice_size`.

Ativa o cálculo de atenção fatiado. Quando esta opção está ativada, o módulo de atenção divide o tensor de entrada em fatias para calcular a atenção em várias etapas. Para mais de uma cabeça de atenção, o cálculo é executado sequencialmente em cada cabeça. Isso é útil para economizar memória em troca de uma pequena diminuição na velocidade.

> [!WARNING] > ⚠️ Não ative o fatiamento de atenção se você já estiver usando `scaled_dot_product_attention` (SDPA)
do PyTorch > 2.0 ou xFormers. Esses cálculos de atenção já são muito eficientes em termos de memória, portanto, você não precisará habilitar > esta função. Se você habilitar o fatiamento de atenção com SDPA ou xFormers, isso pode levar a uma desaceleração significativa!

Exemplos:

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

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

Desativa o cálculo de atenção fatiado. Se `enable_attention_slicing` foi chamado anteriormente, a atenção é calculada em uma única etapa.

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

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

**Parâmetros:**

attention_op (`Callable`, *opcional*) : Substitui o operador padrão `None` para uso como argumento `op` da função [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) do xFormers.

Ative a atenção eficiente em memória do [xFormers](https://facebookresearch.github.io/xformers/). Quando essa opção estiver ativada, você deve observar um menor uso de memória de GPU e uma possível aceleração durante a inferência. A aceleração durante o treinamento não é garantida.

> [!WARNING] > ⚠️ Quando a atenção eficiente em memória e a atenção fatiada estão ambas habilitadas, a atenção eficiente
attention tem > precedência.

Exemplos:

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

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

Desative a atenção eficiente em memória do [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)
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado

device : (`torch.device`): dispositivo torch

num_images_per_prompt (`int`) : número de imagens que devem ser geradas por prompt

do_classifier_free_guidance (`bool`) : se deve ou não usar classifier free guidance

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.

lora_scale (`float`, *opcional*) : Uma escala LoRA que será aplicada a todas as camadas LoRA do codificador de texto, caso as camadas LoRA sejam carregadas.

clip_skip (`int`, *opcional*) : Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.

Codifica o prompt em estados ocultos do 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)
```

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

Adicione ruído aos embeddings da imagem. A quantidade de ruído é controlada pela entrada `noise_level`. Um `noise_level` mais alto aumenta a variância nas imagens finais sem ruído.

O ruído é aplicado de duas maneiras:
1. Um cronograma de ruído é aplicado diretamente aos embeddings.
2. Um vetor de embeddings sinusoidais de tempo é anexado à saída.

Nos dois casos, a quantidade de ruído é controlada pelo mesmo `noise_level`.

Os embeddings são normalizados antes da aplicação do ruído e desnormalizados após a aplicação do ruído.

## ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

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

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

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

**Parâmetros:**

images (`List[PIL.Image.Image]` ou `np.ndarray`) : Lista de imagens PIL desruídas de comprimento `batch_size` ou array NumPy de forma `(batch_size, height, width, num_channels)`.

Classe de saída para pipelines de imagem.