Tour rápido

Modelos de difusão são treinados para remover o ruído Gaussiano aleatório passo a passo para gerar uma amostra de interesse, como uma imagem ou áudio. Isso despertou um tremendo interesse em IA generativa, e você provavelmente já viu exemplos de imagens geradas por difusão na internet. 🧨 Diffusers é uma biblioteca que visa tornar os modelos de difusão amplamente acessíveis a todos.

Seja você um desenvolvedor ou um usuário, esse tour rápido irá introduzir você ao 🧨 Diffusers e ajudar você a começar a gerar rapidamente! Há três componentes principais da biblioteca para conhecer:

• O DiffusionPipeline é uma classe de alto nível de ponta a ponta desenhada para gerar rapidamente amostras de modelos de difusão pré-treinados para inferência.
• Modelos pré-treinados populares e módulos que podem ser usados como blocos de construção para criar sistemas de difusão.
• Vários Agendadores diferentes - algoritmos que controlam como o ruído é adicionado para treinamento, e como gerar imagens sem o ruído durante a inferência.

Esse tour rápido mostrará como usar o DiffusionPipeline para inferência, e então mostrará como combinar um modelo e um agendador para replicar o que está acontecendo dentro do DiffusionPipeline.

Antes de começar, certifique-se de ter todas as bibliotecas necessárias instaladas:

# uncomment to install the necessary libraries in Colab
#!pip install --upgrade diffusers accelerate transformers

• 🤗 Accelerate acelera o carregamento do modelo para geração e treinamento.
• 🤗 Transformers é necessário para executar os modelos mais populares de difusão, como o Stable Diffusion.

DiffusionPipeline

O DiffusionPipeline é a forma mais fácil de usar um sistema de difusão pré-treinado para geração. É um sistema de ponta a ponta contendo o modelo e o agendador. Você pode usar o DiffusionPipeline pronto para muitas tarefas. Dê uma olhada na tabela abaixo para algumas tarefas suportadas, e para uma lista completa de tarefas suportadas, veja a tabela Resumo do 🧨 Diffusers.

Comece criando uma instância do DiffusionPipeline e especifique qual checkpoint do pipeline você gostaria de baixar. Você pode usar o DiffusionPipeline para qualquer checkpoint armazenado no Hugging Face Hub. Nesse quicktour, você carregará o checkpoint stable-diffusion-v1-5 para geração de texto para imagem.

Para carregar o modelo com o método from_pretrained():

>>> from diffusers import DiffusionPipeline

>>> pipeline = DiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", use_safetensors=True)

O DiffusionPipeline baixa e armazena em cache todos os componentes de modelagem, tokenização, e agendamento. Você verá que o pipeline do Stable Diffusion é composto pelo UNet2DConditionModel e PNDMScheduler entre outras coisas:

>>> pipeline
StableDiffusionPipeline {
  "_class_name": "StableDiffusionPipeline",
  "_diffusers_version": "0.13.1",
  ...,
  "scheduler": [
    "diffusers",
    "PNDMScheduler"
  ],
  ...,
  "unet": [
    "diffusers",
    "UNet2DConditionModel"
  ],
  "vae": [
    "diffusers",
    "AutoencoderKL"
  ]
}

Nós fortemente recomendamos rodar o pipeline em uma placa de vídeo, pois o modelo consiste em aproximadamente 1.4 bilhões de parâmetros. Você pode mover o objeto gerador para uma placa de vídeo, assim como você faria no PyTorch:

>>> pipeline.to("cuda")

Agora você pode passar o prompt de texto para o pipeline para gerar uma imagem, e então acessar a imagem sem ruído. Por padrão, a saída da imagem é embrulhada em um objeto PIL.Image.

>>> image = pipeline("An image of a squirrel in Picasso style").images[0]
>>> image

Salve a imagem chamando o save:

>>> image.save("image_of_squirrel_painting.png")

Pipeline local

Você também pode utilizar o pipeline localmente. A única diferença é que você precisa baixar os pesos primeiro:

!git lfs install
!git clone https://huggingface.co./stable-diffusion-v1-5/stable-diffusion-v1-5

Assim carregue os pesos salvos no pipeline:

>>> pipeline = DiffusionPipeline.from_pretrained("./stable-diffusion-v1-5", use_safetensors=True)

Agora você pode rodar o pipeline como você faria na seção acima.

Troca dos agendadores

Agendadores diferentes tem diferentes velocidades de retirar o ruído e compensações de qualidade. A melhor forma de descobrir qual funciona melhor para você é testar eles! Uma das principais características do 🧨 Diffusers é permitir que você troque facilmente entre agendadores. Por exemplo, para substituir o PNDMScheduler padrão com o EulerDiscreteScheduler, carregue ele com o método from_config():

>>> from diffusers import EulerDiscreteScheduler

>>> pipeline = DiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", use_safetensors=True)
>>> pipeline.scheduler = EulerDiscreteScheduler.from_config(pipeline.scheduler.config)

Tente gerar uma imagem com o novo agendador e veja se você nota alguma diferença!

Na próxima seção, você irá dar uma olhada mais de perto nos componentes - o modelo e o agendador - que compõe o DiffusionPipeline e aprender como usar esses componentes para gerar uma imagem de um gato.

Modelos

A maioria dos modelos recebe uma amostra de ruído, e em cada timestep ele prevê o noise residual (outros modelos aprendem a prever a amostra anterior diretamente ou a velocidade ou v-prediction), a diferença entre uma imagem menos com ruído e a imagem de entrada. Você pode misturar e combinar modelos para criar outros sistemas de difusão.

Modelos são inicializados com o método from_pretrained() que também armazena em cache localmente os pesos do modelo para que seja mais rápido na próxima vez que você carregar o modelo. Para o tour rápido, você irá carregar o UNet2DModel, um modelo básico de geração de imagem incondicional com um checkpoint treinado em imagens de gato:

>>> from diffusers import UNet2DModel

>>> repo_id = "google/ddpm-cat-256"
>>> model = UNet2DModel.from_pretrained(repo_id, use_safetensors=True)

Para acessar os parâmetros do modelo, chame model.config:

>>> model.config

A configuração do modelo é um dicionário 🧊 congelado 🧊, o que significa que esses parâmetros não podem ser mudados depois que o modelo é criado. Isso é intencional e garante que os parâmetros usados para definir a arquitetura do modelo no início permaneçam os mesmos, enquanto outros parâmetros ainda podem ser ajustados durante a geração.

Um dos parâmetros mais importantes são:

• sample_size: a dimensão da altura e largura da amostra de entrada.
• in_channels: o número de canais de entrada da amostra de entrada.
• down_block_types e up_block_types: o tipo de blocos de downsampling e upsampling usados para criar a arquitetura UNet.
• block_out_channels: o número de canais de saída dos blocos de downsampling; também utilizado como uma order reversa do número de canais de entrada dos blocos de upsampling.
• layers_per_block: o número de blocks ResNet presentes em cada block UNet.

Para usar o modelo para geração, crie a forma da imagem com ruído Gaussiano aleatório. Deve ter um eixo batch porque o modelo pode receber múltiplos ruídos aleatórios, um eixo channel correspondente ao número de canais de entrada, e um eixo sample_size para a altura e largura da imagem:

>>> import torch

>>> torch.manual_seed(0)

>>> noisy_sample = torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size)
>>> noisy_sample.shape
torch.Size([1, 3, 256, 256])

Para geração, passe a imagem com ruído para o modelo e um timestep. O timestep indica o quão ruidosa a imagem de entrada é, com mais ruído no início e menos no final. Isso ajuda o modelo a determinar sua posição no processo de difusão, se está mais perto do início ou do final. Use o método sample para obter a saída do modelo:

>>> with torch.no_grad():
...     noisy_residual = model(sample=noisy_sample, timestep=2).sample

Para geração de exemplos reais, você precisará de um agendador para guiar o processo de retirada do ruído. Na próxima seção, você irá aprender como acoplar um modelo com um agendador.

Agendadores

Agendadores gerenciam a retirada do ruído de uma amostra ruidosa para uma amostra menos ruidosa dado a saída do modelo - nesse caso, é o noisy_residual.

Para o tour rápido, você irá instanciar o DDPMScheduler com o método from_config():

>>> from diffusers import DDPMScheduler

>>> scheduler = DDPMScheduler.from_config(repo_id)
>>> scheduler
DDPMScheduler {
  "_class_name": "DDPMScheduler",
  "_diffusers_version": "0.13.1",
  "beta_end": 0.02,
  "beta_schedule": "linear",
  "beta_start": 0.0001,
  "clip_sample": true,
  "clip_sample_range": 1.0,
  "num_train_timesteps": 1000,
  "prediction_type": "epsilon",
  "trained_betas": null,
  "variance_type": "fixed_small"
}

Um dos parâmetros mais importante são:

• num_train_timesteps: o tamanho do processo de retirar ruído ou em outras palavras, o número de timesteps necessários para o processo de ruídos Gausianos aleatórios dentro de uma amostra de dados.
• beta_schedule: o tipo de agendados de ruído para o uso de geração e treinamento.
• beta_start e beta_end: para começar e terminar os valores de ruído para o agendador de ruído.

Para predizer uma imagem com um pouco menos de ruído, passe o seguinte para o método do agendador step(): saída do modelo, timestep, e a atual amostra.

>>> less_noisy_sample = scheduler.step(model_output=noisy_residual, timestep=2, sample=noisy_sample).prev_sample
>>> less_noisy_sample.shape

O less_noisy_sample pode ser passado para o próximo timestep onde ele ficará ainda com menos ruído! Vamos juntar tudo agora e visualizar o processo inteiro de retirada de ruído.

Comece, criando a função que faça o pós-processamento e mostre a imagem sem ruído como uma PIL.Image:

>>> import PIL.Image
>>> import numpy as np


>>> def display_sample(sample, i):
...     image_processed = sample.cpu().permute(0, 2, 3, 1)
...     image_processed = (image_processed + 1.0) * 127.5
...     image_processed = image_processed.numpy().astype(np.uint8)

...     image_pil = PIL.Image.fromarray(image_processed[0])
...     display(f"Image at step {i}")
...     display(image_pil)

Para acelerar o processo de retirada de ruído, mova a entrada e o modelo para uma GPU:

>>> model.to("cuda")
>>> noisy_sample = noisy_sample.to("cuda")

Agora, crie um loop de retirada de ruído que prediz o residual da amostra menos ruidosa, e computa a amostra menos ruidosa com o agendador:

>>> import tqdm

>>> sample = noisy_sample

>>> for i, t in enumerate(tqdm.tqdm(scheduler.timesteps)):
...     # 1. predict noise residual
...     with torch.no_grad():
...         residual = model(sample, t).sample

...     # 2. compute less noisy image and set x_t -> x_t-1
...     sample = scheduler.step(residual, t, sample).prev_sample

...     # 3. optionally look at image
...     if (i + 1) % 50 == 0:
...         display_sample(sample, i + 1)

Sente-se e assista o gato ser gerado do nada além de ruído! 😻

Próximos passos

Esperamos que você tenha gerado algumas imagens legais com o 🧨 Diffusers neste tour rápido! Para suas próximas etapas, você pode

• Treine ou faça a configuração fina de um modelo para gerar suas próprias imagens no tutorial de treinamento.
• Veja exemplos oficiais e da comunidade de scripts de treinamento ou configuração fina para os mais variados casos de uso.
• Aprenda sobre como carregar, acessar, mudar e comparar agendadores no guia Usando diferentes agendadores.
• Explore engenharia de prompt, otimizações de velocidade e memória, e dicas e truques para gerar imagens de maior qualidade com o guia Stable Diffusion.
• Se aprofunde em acelerar 🧨 Diffusers com guias sobre PyTorch otimizado em uma GPU, e guias de inferência para rodar Stable Diffusion em Apple Silicon (M1/M2) e ONNX Runtime.