Imagem para imagem

Image-to-image é semelhante a text-to-image, 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:

Carregue um checkpoint na classe AutoPipelineForImage2Image; esse pipeline trata automaticamente o carregamento da classe de pipeline correta com base no checkpoint:

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

Você notará, ao longo do guia, que usamos enable_model_cpu_offload() e 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() no seu pipeline, pois ele já estará usando o scaled-dot product attention nativo do PyTorch 2.0.

Carregue uma imagem para passar ao pipeline:

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

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

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, Stable Diffusion XL (SDXL) e Kandinsky 2.2. 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:

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 para um passo a passo mais detalhado sobre como usar este modelo e outras técnicas que ele emprega para produzir imagens de alta qualidade.

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 é:

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.

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.

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.

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:

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:

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:

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]

É 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:

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:

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:

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]

É 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:

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:

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

AutoPipelineForImage2Image possui um parâmetro prompt_embeds (e negative_prompt_embeds, se você estiver usando um prompt negativo) onde você pode passar os embeddings que substituem o parâmetro prompt.

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.

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:

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:

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 à imagem gerada pelo ControlNet encadeando-a com um pipeline de imagem para imagem:

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 do PyTorch 2.0 ou o xFormers (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.

+ pipeline.enable_model_cpu_offload()
+ pipeline.enable_xformers_memory_efficient_attention()

Com torch.compile, você pode aumentar ainda mais a velocidade de inferência envolvendo seu UNet com ele:

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

Para saber mais, consulte os guias Reduzir o uso de memória e Acelerar a inferência.

Update on GitHub