# Imagem para imagem

Image-to-image é semelhante a [text-to-image](conditional_image_generation), mas, além de um prompt, você também pode passar uma imagem inicial como ponto de partida para o processo de difusão. A imagem inicial é codificada no espaço latente e ruído é adicionado a ela. Em seguida, o modelo de difusão latente recebe o prompt e a imagem latente com ruído, prevê o ruído adicionado e remove o ruído previsto da imagem latente inicial para obter a nova imagem latente. Por fim, um decodificador decodifica a nova imagem latente de volta para uma imagem.

Com o 🤗 Diffusers, isso é tão fácil quanto 1-2-3:

1. Carregue um checkpoint na classe [AutoPipelineForImage2Image](/docs/diffusers/v0.43.0/pt/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image); esse pipeline trata automaticamente o carregamento da classe de pipeline correta com base no checkpoint:

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
```

> [!TIP]
> Você notará, ao longo do guia, que usamos [enable_model_cpu_offload()](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) e [enable_xformers_memory_efficient_attention()](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention) para economizar memória e aumentar a velocidade de inferência. Se você estiver usando PyTorch 2.0, não precisa chamar [enable_xformers_memory_efficient_attention()](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention) no seu pipeline, pois ele já estará usando o [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) nativo do PyTorch 2.0.

2. Carregue uma imagem para passar ao pipeline:

```py
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png")
```

3. Passe um prompt e uma imagem para o pipeline para gerar uma imagem:

```py
prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k"
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    imagem inicial
  
  
    
    imagem gerada
  

## Modelos populares

Os modelos de imagem-para-imagem mais populares são [Stable Diffusion v1.5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5), [Stable Diffusion XL (SDXL)](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) e [Kandinsky 2.2](https://huggingface.co/kandinsky-community/kandinsky-2-2-decoder). Os resultados dos modelos Stable Diffusion e Kandinsky variam devido às diferenças em suas arquiteturas e processos de treinamento; em geral, é possível esperar que o SDXL produza imagens de maior qualidade do que o Stable Diffusion v1.5. Vamos dar uma olhada rápida em como usar cada um desses modelos e comparar seus resultados.

### Stable Diffusion v1.5

Stable Diffusion v1.5 é um modelo de difusão latente inicializado a partir de um checkpoint anterior e, em seguida, refinado por 595K passos em imagens de 512x512. Para usar este pipeline para image-to-image, você precisará preparar uma imagem inicial para passar ao pipeline. Em seguida, você pode passar um prompt e a imagem ao pipeline para gerar uma nova imagem:

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    imagem inicial
  
  
    
    imagem gerada
  

### Stable Diffusion XL (SDXL)

SDXL é uma versão mais poderosa do modelo Stable Diffusion. Ele utiliza um modelo base maior e um modelo refinador adicional para aumentar a qualidade da saída do modelo base. Leia o guia [SDXL](../api/pipelines/stable_diffusion/stable_diffusion_xl) para um passo a passo mais detalhado sobre como usar este modelo e outras técnicas que ele utiliza para produzir imagens de alta qualidade.

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-sdxl-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, strength=0.5).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    imagem inicial
  
  
    
    imagem gerada
  

### Kandinsky 2.2

O modelo Kandinsky é diferente dos modelos Stable Diffusion porque utiliza um modelo de prior de imagem para criar incorporações de imagem. As incorporações ajudam a criar um melhor alinhamento entre texto e imagens, permitindo que o modelo de difusão latente gere imagens melhores.

A maneira mais simples de usar o Kandinsky 2.2 é:

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    imagem inicial
  
  
    
    imagem gerada
  

## Configure os parâmetros do pipeline

Existem vários parâmetros importantes que você pode configurar no pipeline que afetarão o processo de geração de imagem e a qualidade da imagem. Vamos dar uma olhada mais de perto no que esses parâmetros fazem e como alterá-los afeta a saída.

### Força

`strength` é um dos parâmetros mais importantes a considerar e terá um grande impacto na sua imagem gerada. Ele determina o quanto a imagem gerada se assemelha à imagem inicial. Em outras palavras:

- 📈 um valor de `strength` maior dá ao modelo mais "criatividade" para gerar uma imagem diferente da imagem inicial; um valor de `strength` de 1.0 significa que a imagem inicial é mais ou menos ignorada
- 📉 um valor de `strength` menor significa que a imagem gerada é mais semelhante à imagem inicial

Os parâmetros `strength` e `num_inference_steps` estão relacionados, pois `strength` determina o número de etapas de ruído a serem adicionadas. Por exemplo, se `num_inference_steps` for 50 e `strength` for 0,8, isso significa adicionar 40 (50 * 0,8) etapas de ruído à imagem inicial e, em seguida, realizar a remoção de ruído por 40 etapas para obter a imagem gerada.

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, strength=0.8).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    strength = 0.4
  
  
    
    strength = 0.6
  
  
    
    strength = 1.0
  

### Escala de orientação

O parâmetro `guidance_scale` é usado para controlar o quão alinhados estão a imagem gerada e o prompt de texto. Um valor mais alto de `guidance_scale` significa que sua imagem gerada está mais alinhada com o prompt, enquanto um valor mais baixo de `guidance_scale` significa que sua imagem gerada tem mais espaço para se desviar do prompt.

Você pode combinar `guidance_scale` com `strength` para um controle ainda mais preciso sobre o quão expressivo o modelo é. Por exemplo, combine um alto `strength + guidance_scale` para máxima criatividade ou use uma combinação de baixo `strength` e baixo `guidance_scale` para gerar uma imagem que se assemelhe à imagem inicial, mas que não esteja tão estritamente vinculada ao prompt.

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, guidance_scale=8.0).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    guidance_scale = 0.1
  
  
    
    guidance_scale = 5.0
  
  
    
    guidance_scale = 10.0
  

### Prompt negativo

Um prompt negativo condiciona o modelo a *não* incluir elementos em uma imagem e pode ser usado para melhorar a qualidade da imagem ou modificá-la. Por exemplo, você pode melhorar a qualidade da imagem incluindo prompts negativos como "poor details" ou "blurry" para incentivar o modelo a gerar uma imagem de maior qualidade. Ou você pode modificar uma imagem especificando o que deve ser excluído dela.

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy"

# pass prompt and image to pipeline
image = pipeline(prompt, negative_prompt=negative_prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy"
  
  
    
    negative_prompt = "jungle"
  

## Pipelines de imagem para imagem encadeados

Existem outras formas interessantes de usar um pipeline de imagem-para-imagem, além de simplesmente gerar uma imagem (embora isso também seja bastante legal). Você pode dar um passo além e encadear esse pipeline com outros.

### Texto-para-imagem-para-imagem

Encadear um pipeline de texto para imagem e um pipeline de imagem para imagem permite gerar uma imagem a partir de texto e usar a imagem gerada como imagem inicial para o pipeline de imagem para imagem. Isso é útil se você quiser gerar uma imagem completamente do zero. Por exemplo, vamos encadear um modelo Stable Diffusion e um modelo Kandinsky.

Comece gerando uma imagem com o pipeline de texto para imagem:

```py
from diffusers import AutoPipelineForText2Image, AutoPipelineForImage2Image
import torch
from diffusers.utils import make_image_grid

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

text2image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k").images[0]
text2image
```

Agora você pode passar esta imagem gerada para o pipeline de imagem-para-imagem:

```py
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

image2image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", image=text2image).images[0]
make_image_grid([text2image, image2image], rows=1, cols=2)
```

### Imagem-para-imagem-para-imagem

Você também pode encadear vários pipelines de imagem-para-imagem para criar imagens mais interessantes. Isso pode ser útil para realizar transferências de estilo iterativamente em uma imagem, gerar GIFs curtos, restaurar a cor de uma imagem ou restaurar áreas ausentes de uma imagem.

Comece gerando uma imagem:

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, output_type="latent").images[0]
```

> [!TIP]
> É importante especificar `output_type="latent"` no pipeline para manter todas as saídas no espaço latente e evitar uma etapa desnecessária de decodificação-encodificação. Isso só funciona se os pipelines encadeados estiverem usando o mesmo VAE.

Passe a saída latente deste pipeline para o próximo pipeline para gerar uma imagem em [estilo de arte de quadrinhos](https://huggingface.co/ogkalu/Comic-Diffusion):

```py
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "ogkalu/Comic-Diffusion", dtype=torch.float16
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# need to include the token "charliebo artstyle" in the prompt to use this checkpoint
image = pipeline("Astronaut in a jungle, charliebo artstyle", image=image, output_type="latent").images[0]
```

Repita mais uma vez para gerar a imagem final em [estilo pixel art](https://huggingface.co/kohbanye/pixel-art-style):

```py
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "kohbanye/pixel-art-style", dtype=torch.float16
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# need to include the token "pixelartstyle" in the prompt to use this checkpoint
image = pipeline("Astronaut in a jungle, pixelartstyle", image=image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

### Imagem-para-upscaler-para-super-resolução

Outra forma de encadear seu pipeline de imagem-para-imagem é com um upscaler e um pipeline de super-resolução para realmente aumentar o nível de detalhes em uma imagem.

Comece com um pipeline de imagem para imagem:

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import make_image_grid, load_image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image_1 = pipeline(prompt, image=init_image, output_type="latent").images[0]
```

> [!TIP]
> É importante especificar `output_type="latent"` no pipeline para manter todas as saídas no espaço *latente* e evitar uma etapa desnecessária de decodificação-encodificação. Isso só funciona se os pipelines encadeados estiverem usando o mesmo VAE.

Encadeie-o a um pipeline de upscaler para aumentar a resolução da imagem:

```py
from diffusers import StableDiffusionLatentUpscalePipeline

upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(
    "stabilityai/sd-x2-latent-upscaler", dtype=torch.float16, use_safetensors=True
)
upscaler.enable_model_cpu_offload()
upscaler.enable_xformers_memory_efficient_attention()

image_2 = upscaler(prompt, image=image_1).images[0]
```

Por fim, encadeie-o a um pipeline de super-resolução para aprimorar ainda mais a resolução:

```py
from diffusers import StableDiffusionUpscalePipeline

super_res = StableDiffusionUpscalePipeline.from_pretrained(
    "stabilityai/stable-diffusion-x4-upscaler", dtype=torch.float16, variant="fp16", use_safetensors=True
)
super_res.enable_model_cpu_offload()
super_res.enable_xformers_memory_efficient_attention()

image_3 = super_res(prompt, image=image_2).images[0]
make_image_grid([init_image, image_3.resize((512, 512))], rows=1, cols=2)
```

## Controlar a geração de imagens

Tentar gerar uma imagem que fique exatamente como você deseja pode ser difícil, o que torna as técnicas e os modelos de geração controlada tão úteis. Embora você possa usar o `negative_prompt` para controlar parcialmente a geração de imagens, existem métodos mais robustos, como o ponderamento de prompts e os ControlNets.

### Ponderação de prompts

O ponderamento de prompts permite dimensionar a representação de cada conceito em um prompt. Por exemplo, em um prompt como "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", você pode escolher aumentar ou diminuir os embeddings de "astronaut" e "jungle". A biblioteca [Compel](https://github.com/damian0815/compel) fornece uma sintaxe simples para ajustar os pesos dos prompts e gerar os embeddings. Você pode aprender a criar os embeddings no guia [Ponderamento de prompts](weighted_prompts).

[AutoPipelineForImage2Image](/docs/diffusers/v0.43.0/pt/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image) possui um parâmetro `prompt_embeds` (e `negative_prompt_embeds`, se você estiver usando um prompt negativo) onde você pode passar os embeddings, substituindo o parâmetro `prompt`.

```py
from diffusers import AutoPipelineForImage2Image
import torch

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

image = pipeline(prompt_embeds=prompt_embeds, # generated from Compel
    negative_prompt_embeds=negative_prompt_embeds, # generated from Compel
    image=init_image,
).images[0]
```

### ControlNet

ControlNets oferecem uma maneira mais flexível e precisa de controlar a geração de imagens, pois você pode usar uma imagem de condicionamento adicional. A imagem de condicionamento pode ser uma imagem canny, um mapa de profundidade, uma segmentação de imagem e até mesmo rabiscos! Independentemente do tipo de imagem de condicionamento que você escolher, o ControlNet gera uma imagem que preserva as informações contidas nela.

Por exemplo, vamos condicionar uma imagem com um mapa de profundidade para manter as informações espaciais da imagem.

```py
from diffusers.utils import load_image, make_image_grid

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
init_image = init_image.resize((958, 960)) # resize to depth image dimensions
depth_image = load_image("https://huggingface.co/lllyasviel/control_v11f1p_sd15_depth/resolve/main/images/control.png")
make_image_grid([init_image, depth_image], rows=1, cols=2)
```

Carregue um modelo ControlNet condicionado em mapas de profundidade e o [AutoPipelineForImage2Image](/docs/diffusers/v0.43.0/pt/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image):

```py
from diffusers import ControlNetModel, AutoPipelineForImage2Image
import torch

controlnet = ControlNetModel.from_pretrained("lllyasviel/control_v11f1p_sd15_depth", dtype=torch.float16, variant="fp16", use_safetensors=True)
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", controlnet=controlnet, dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
```

Agora, gere uma nova imagem condicionada ao mapa de profundidade, à imagem inicial e ao prompt:

```py
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image_control_net = pipeline(prompt, image=init_image, control_image=depth_image).images[0]
make_image_grid([init_image, depth_image, image_control_net], rows=1, cols=3)
```

  
    
    imagem inicial
  
  
    
    imagem de profundidade
  
  
    
    Imagem do ControlNet
  

Vamos aplicar um novo [estilo](https://huggingface.co/nitrosocke/elden-ring-diffusion) à imagem gerada pelo ControlNet encadeando-a com um pipeline de imagem para imagem:

```py
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "nitrosocke/elden-ring-diffusion", dtype=torch.float16,
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

prompt = "elden ring style astronaut in a jungle" # include the token "elden ring style" in the prompt
negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy"

image_elden_ring = pipeline(prompt, negative_prompt=negative_prompt, image=image_control_net, strength=0.45, guidance_scale=10.5).images[0]
make_image_grid([init_image, depth_image, image_control_net, image_elden_ring], rows=2, cols=2)
```

  

## Otimizar

Executar modelos de difusão é computacionalmente caro e intensivo, mas com alguns truques de otimização, é totalmente possível executá-los em GPUs de consumo e de nível gratuito. Por exemplo, você pode usar uma forma de atenção mais eficiente em memória, como a [atenção de produto escalar](../optimization/fp16#scaled-dot-product-attention) do PyTorch 2.0 ou o [xFormers](../optimization/attention_backends) (você pode usar um ou o outro, mas não há necessidade de usar ambos). Você também pode descarregar o modelo para a GPU enquanto os outros componentes do pipeline aguardam na CPU.

```diff
+ pipeline.enable_model_cpu_offload()
+ pipeline.enable_xformers_memory_efficient_attention()
```

Com [`torch.compile`](../optimization/fp16#torchcompile), você pode aumentar ainda mais a velocidade de inferência envolvendo seu UNet com ele:

```py
pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True)
```

Para saber mais, consulte os guias [Reduzir o uso de memória](../optimization/memory) e [Acelerar a inferência](../optimization/fp16).