# Variação de imagem

O modelo Stable Diffusion também pode gerar variações a partir de uma imagem de entrada. Ele utiliza uma versão ajustada de um modelo Stable Diffusion de [Justin Pinkney](https://www.justinpinkney.com/) da [Lambda](https://lambdalabs.com/).

O código original pode ser encontrado em [LambdaLabsML/lambda-diffusers](https://github.com/LambdaLabsML/lambda-diffusers#stable-diffusion-image-variations) e checkpoints oficiais adicionais para variação de imagem podem ser encontrados em [lambdalabs/sd-image-variations-diffusers](https://huggingface.co/lambdalabs/sd-image-variations-diffusers).

> [!TIP]
> Certifique-se de conferir a seção [Dicas](./overview#tips) do Stable Diffusion para aprender como explorar o equilíbrio entre a velocidade e a qualidade do agendador, e como reutilizar os componentes do pipeline de forma eficiente!

## StableDiffusionImageVariationPipeline[[diffusers.StableDiffusionImageVariationPipeline]]

#### diffusers.StableDiffusionImageVariationPipeline[[diffusers.StableDiffusionImageVariationPipeline]]

```python
diffusers.StableDiffusionImageVariationPipeline(vae: AutoencoderKL, image_encoder: CLIPVisionModelWithProjection, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, requires_safety_checker: bool = True)
```

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

**Parâmetros:**

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.

image_encoder ([CLIPVisionModelWithProjection](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPVisionModelWithProjection)) : Codificador de imagem CLIP congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/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/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Um `CLIPTokenizer` para tokenizar texto.

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

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/pt/api/schedulers/overview#diffusers.SchedulerMixin)) : Um scheduler para ser usado em combinação com `unet` para desruidar os latentes da imagem codificada. Pode ser um de [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/pndm#diffusers.PNDMScheduler).

safety_checker (`StableDiffusionSafetyChecker`) : Módulo de classificação que estima se as imagens geradas podem ser consideradas ofensivas ou prejudiciais. Consulte o [model card](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para mais detalhes sobre os potenciais danos de um modelo.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPImageProcessor)) : Um `CLIPImageProcessor` para extrair recursos de imagens geradas; usado como entradas para o `safety_checker`.

Pipeline para gerar variações de imagem a partir de uma imagem de entrada usando Stable Diffusion.

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

#### __call__[[diffusers.StableDiffusionImageVariationPipeline.__call__]]

```python
__call__(image: typing.Union[PIL.Image.Image, list[PIL.Image.Image], torch.Tensor], height: int | None = None, width: int | None = None, num_inference_steps: int = 50, guidance_scale: float = 7.5, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `list[PIL.Image.Image]` ou `torch.Tensor`) : Imagem ou imagens para orientar a geração de imagens. Se você fornecer um tensor, ele precisa ser compatível com [`CLIPImageProcessor`](https://huggingface.co/lambdalabs/sd-image-variations-diffusers/blob/main/feature_extractor/preprocessor_config.json).

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 50) : O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta. Este parâmetro é modulado por `strength`.

guidance_scale (`float`, *opcional*, padrão 7.5) : 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`.

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.

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 [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) 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.

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

Se `return_dict` for `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

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

Exemplos:

```py
from diffusers import StableDiffusionImageVariationPipeline
from PIL import Image
from io import BytesIO
import requests

pipe = StableDiffusionImageVariationPipeline.from_pretrained(
    "lambdalabs/sd-image-variations-diffusers", revision="v2.0"
)
pipe = pipe.to("cuda")

url = "https://lh3.googleusercontent.com/y-iFOHfLTwkuQSUegpwDdgKmOjRSTvPxat63dQLB25xkTs4lhIbRUFeNBWZzYf370g=s1200"

response = requests.get(url)
image = Image.open(BytesIO(response.content)).convert("RGB")

out = pipe(image, num_images_per_prompt=3, guidance_scale=15)
out["images"][0].save("result.jpg")
```

#### enable_attention_slicing[[diffusers.StableDiffusionImageVariationPipeline.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.StableDiffusionImageVariationPipeline.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.StableDiffusionImageVariationPipeline.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.StableDiffusionImageVariationPipeline.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/).

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

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

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

nsfw_content_detected (`list[bool]`) : lista indicando se a imagem gerada correspondente contém conteúdo "não seguro para o trabalho" (nsfw) ou `None` se a verificação de segurança não pôde ser realizada.

Classe de saída para pipelines do Stable Diffusion.