Modelos de Difusão: fundamentos e aplicações avançadas

Explorando Geração de Imagens com IA - Introdução

Apresentando o instrutor e o curso

Olá! Meu nome é João Vitor Alencar Rosa Ataíde e serei o instrutor de vocês no curso de modelos de difusão, Deep Learning (aprendizado profundo) com PyTorch.

Descrevendo o conteúdo e objetivos do curso

No nosso curso, vamos aprender de A a Z, desde o processo de intuição sobre como surgiram os modelos de difusão, passando por um pouco do estado da arte, até efetivamente colocar a mão na massa. Vamos trabalhar em nossos códigos para gerar nossa própria rede neural de difusão e um projeto final. Esse projeto incluirá uma pequena interface onde poderemos gerar imagens sintéticas, e a rede neural será responsável por criar essas imagens, salvando os arquivos que poderão ser reutilizados em outros trabalhos.

Explorando Geração de Imagens com IA - Histórico das redes difusoras

Explorando a geração de imagens com IA

Na aula de hoje, vamos explorar a geração de imagens com IA, focando nos modelos generativos, suas diferenças e algumas aplicações práticas. Utilizaremos um framework chamado diffusers, em vez do PyTorch, para gerar resultados interessantes e entender o funcionamento das redes neurais de difusão.

A inteligência artificial generativa já está presente em nosso dia a dia, com impacto revolucionário em áreas como moda, design, publicidade e até programação. É essencial que nós, profissionais de TI, compreendamos o funcionamento dessas redes neurais e como podemos replicá-las, treiná-las e aplicá-las em nosso trabalho diário.

Discutindo subcategorias de modelos generativos

Os modelos generativos são subdivididos em três subcategorias principais, especialmente no que diz respeito ao treinamento e à criação de novas imagens ou imagens sintéticas. Temos os Variational Autoencoders (VAEs), que operam no espaço latente dos dados, permitindo uma amostragem mais controlada. Eles trabalham com imagens que são mais semelhantes dentro desse espaço latente.

Já as Generative Adversarial Networks (GANs) colocam dois modelos em competição para criar dados realistas, tentando distinguir o que é real do que não é. Os modelos entram em conflito, com um tentando construir a imagem e o outro tentando identificar se a imagem é real.

Focando nos modelos de difusão

Nosso foco principal são os modelos de difusão, que aprendem a destruir uma imagem adicionando ruído e treinam um modelo para reverter esse processo, gerando uma imagem completamente nova. Comparando os três tipos de modelos mais utilizados, os modelos de difusão se destacam por sua estabilidade e alta fidelidade na geração de dados. Eles capturam a variabilidade das amostras, permitindo aprender com uma variedade de exemplos. Um ponto forte é que não possuem o processo de competição presente nas GANs. No entanto, o principal desafio é a lentidão na geração dos dados, pois o processo de adicionar ruído e reverter é demorado, exigindo aprendizado a cada passo.

As GANs são modelos mais probabilísticos, focados em trabalhar na estrutura latente dos dados e gerar dados de forma estável. Contudo, o desafio é que os dados gerados tendem a ser regularizados e um pouco embaçados, o que limita seu uso para gerar imagens extremamente realistas.

Analisando desafios e vantagens das GANs

As GANs, por sua vez, são modelos de competição, com um modelo gerador e um discriminador. Eles operam em uma competição onde um tenta construir a imagem e o outro tenta distinguir se a imagem é real. Um ponto forte é que geram imagens bastante nítidas, sendo populares na replicação de arte e no estilo de outros artistas.

Quando treinamos um modelo para gerar imagens a partir de uma pintura, os resultados têm sido bastante interessantes. No entanto, o maior desafio está no treinamento. Como estamos lidando com duas redes neurais que trabalham em conjunto, é possível que essas redes entrem em colapso. Isso pode resultar em um aprendizado que mantém, por exemplo, a média dos valores de pixels, gerando dados muito semelhantes, não realistas ou que não são utilizados no nosso cotidiano. Essa é uma das grandes desvantagens dos GANs (Redes Adversárias Generativas).

Explorando o estado da arte dos modelos de difusão

Falando sobre nosso foco principal, que são os modelos de difusão, vamos explorar o estado da arte desses modelos, com base no artigo "State of Art on Diffusion Models from Visual Computing". Esse artigo apresenta a história dos modelos de difusão, desde sua concepção até os mais avançados na época da publicação. Os modelos de difusão surgiram em 2015, baseados em uma analogia com a termodinâmica. Veremos mais adiante como essa analogia foi feita. Naquela época, eles ainda não produziam imagens realistas ou práticas para uso diário.

Em 2019, ocorreu o primeiro sampling (amostragem) eficiente. O sampling é o processo de gerar amostras com etapas de ruído, e começamos a desenvolver um processo mais eficiente, introduzindo um matching score para reverter esse processo. Em 2020, surgiu o DDPM (Denoising Diffusion Probabilistic Models), que começou a apresentar resultados comparáveis aos GANs. Os DDPMs combinaram a intuição inicial com processos mais avançados.

Evoluindo os modelos de difusão

Em 2021, surgiram os DDPMs, que introduziram um processo para reduzir o número de etapas nas amostragens e uma aprendizagem voltada à variância, incorporando a variabilidade dos dados na concepção do modelo. Nesse mesmo ano, surgiu o DDIM, um sample determinístico mais rápido, voltado para criar amostras de forma mais eficiente. Um dos problemas dos modelos de difusão é o tempo necessário para gerar dados.

Em 2022, surgiram os primeiros LDMs (Latent Diffusion Models), que conectaram os DDPMs com os VAEs, trabalhando no espaço latente. Foi então que o Stable Diffusion popularizou a geração de imagens hiper-realísticas e fantasiosas, causando grande impacto na comunidade e nas redes sociais.

Avançando para modelos de difusão em 4D

Em 2023, surgiram os primeiros modelos com ControlNet, focados em formas e bordas, permitindo que as redes neurais gerassem formas mais nítidas para aplicações específicas, utilizando amostras de formas, poses, entre outros. No mesmo ano, surgiu o Sora, que começou a criar modelos de difusão para vídeos, e o Motion Synthetics, que trata de movimentos sintéticos nas imagens.

Em 2024, os modelos evoluíram sob a perspectiva de 4D, com avanços em vídeos e consistência temporal. As imagens e quadros de um vídeo perdem a similaridade, por exemplo, de um rosto, e esses modelos começaram a melhorar nesse aspecto, mantendo a consistência temporal dos dados gerados. Além disso, passaram a gerar animações complexas, incluindo memes que vemos nas redes sociais.

Explorando Geração de Imagens com IA - Intuição dos modelos

Explicando a intuição dos modelos de difusão

Falando sobre a intuição dos modelos de difusão, eles têm origem no movimento Browniano da termodinâmica. De forma clara, é como se estivéssemos acrescentando calor sobre determinadas partículas, fazendo com que elas se movimentem. Esses movimentos, nos quais estamos acrescentando entropia, aumentam o distanciamento em relação a um ponto inicial, como o ponto zero. Essa foi a intuição retirada da termodinâmica para ser aplicada nos modelos de redes neurais.

Basicamente, esse processo de acrescentar entropia, ou ruídos, sobre um determinado dado, pode ser revertido utilizando redes neurais. Elas aprendem como esse processo é realizado e conseguem determinar o posicionamento inicial da partícula ou calcular um novo distanciamento para encontrar o ponto inicial. Essa foi a virada de chave que trouxe um conceito da termodinâmica para as redes neurais.

Apresentando a simulação do movimento Browniano

Apresentamos uma simulação do movimento Browniano para entender como esse conceito técnico da termodinâmica foi adaptado para a computação. Vamos criar uma simulação onde os pixels de uma imagem são partículas, e acrescentamos passos nos quais essas partículas se movimentam. O número de partículas pode ser entendido como imagens, e vamos observar o movimento a partir de um ponto focal de uma partícula ao longo do tempo, dentro dos passos em que ela se movimenta com o acréscimo de ruído.

Para isso, utilizaremos quatro bibliotecas: NumPy, Matplotlib e IPython. Importamos NumPy como np, Matplotlib.pyplot e Matplotlib.animation, que criará a animação do processo de acréscimo de ruído, e from IPython.display para observar o GIF no Jupyter Notebook.

# Importa as bibliotecas
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import Image

Configurando a simulação

O primeiro passo para gerar uma configuração é definir o número de passos, que será 500, e o número de partículas, que será 100. Consideramos que cada partícula representa uma imagem, os passos são os movimentos, e os ruídos são os acréscimos.

# Configuração
n_steps = 500
n_particles = 100
np.random.seed(42)

Inicialmente, criamos um array com o número de passos e partículas, onde cada linha representa uma partícula e cada valor da linha é um passo que ela realizará, começando em zero e movendo-se para outras coordenadas nas três dimensões: x, y e z.

x = np.zeros((n_steps, n_particles))
y = np.zeros((n_steps, n_particles))
z = np.zeros((n_steps, n_particles))

Simulando o movimento Browniano

Para simular o movimento Browniano, criamos um laço de repetição que percorre o índice da imagem e acrescenta o ruído normalizado na escala de 0 a 0.2 para cada partícula do array.

# Simular movimento browniano
for i in range(1, n_steps):
    x[i] = x[i-1] + np.random.normal(0, 0.2, n_particles)
    y[i] = y[i-1] + np.random.normal(0, 0.2, n_particles)
    z[i] = z[i-1] + np.random.normal(0, 0.2, n_particles)

Vamos percorrer o range do número de steps. A cada interação, acrescentamos ruído dentro do array e trazemos novas coordenadas. Além disso, fixamos uma partícula, lembrando que precisamos entender, de forma abstrata, o movimento dessa partícula para conceber como funcionam os modelos de difusão.

# Parâmetros para destacar a partícula
particle_index = 10 # a partícula que vamos acompanhar

Criando a visualização em 3D

O próximo passo é criar a figura em três dimensões, na qual fixamos a partícula de índice 10 e verificamos os movimentos ao longo do tempo. O primeiro passo é criar a figura com dimensão de 8 por 8.

# Criar figura 3D
fig = plt.figure(figsize=(8,8))
ax = fig.add_subplot(111, projection='3d')

Acrescentamos um subplot com projeção em 3D e criamos um scatterplot com as coordenadas iniciais, tamanho 20 e translucidez de 0.6.

# Inicializar scatter para todas partículas
sc = ax.scatter(x[0], y[0], z[0], c='blue', alpha=0.6)

Destacamos a partícula selecionada, de índice 10, gerando um destaque específico.

# Inicializar destaque para a partícula selecionada
highlight = ax.scatter(x[0, particle_index], y[0, particle_index], z[0, particle_index],
                        s=100, c='lime', edgecolors='black', label=f'Partícula {particle_index}')

Plotando a trajetória e configurando a visualização

Plotamos também a trajetória da partícula, utilizando as coordenadas em cada dimensão (x, y, z), e geramos o scatterplot do início, em verde, e do fim dos passos, em vermelho.

# Plotar a trajetória completa como uma linha fina
traj_line, = ax.plot(x[:, particle_index], y[:, particle_index], z[:, particle_index],
                    color='black', lw=1, alpha=0.5, label='Trajetória')

# Marcar início e fim com cores distintas
start_point = ax.scatter(x[0, particle_index], y[0, particle_index], z[0, particle_index],
                        color='green', s=80, label='Início')
end_point = ax.scatter(x[-1, particle_index], y[-1, particle_index], z[-1, particle_index],
                        color='red', s=80, label='Fim')

Um ponto importante é configurar os limites das coordenadas para que o fenômeno seja observável. Adicionamos o título "3D Brownian Motion com Destaque" e a legenda para cada marcação e plot criado.

# Configurar limites e título
ax.set_xlim(-20, 20)
ax.set_ylim(-20, 20)
ax.set_zlim(-20, 20)
ax.set_title("3D Brownian Motion com Destaque")
ax.legend()

Criando e exibindo a animação

Para criar a animação, precisamos de uma função chamada update, que cria um offset sobre o array e um offset 3D sobre a partícula específica. Essa função gera a interação que observamos no vídeo.

# Função update da animação
def update(frame):
    sc._offsets3d = (x[frame], y[frame], z[frame])
    highlight._offsets3d = ([x[frame, particle_index]],
                            [y[frame, particle_index]],
                            [z[frame, particle_index]])
    ax.view_init(elev=30, azim=frame/2)
    return sc, highlight, traj_line, start_point, end_point

Ao criar a função, ela retorna a trajetória, o destaque e outras configurações feitas anteriormente. Para criar a animação, utilizamos o animation.FuncAnimation, passando a figura, a função update, o número de steps, o intervalo e a configuração de blit.

# Criar animação
ani = animation.FuncAnimation(fig, update, frames=n_steps, interval=50, blit=False)
ani.save('brownian_motion_highlight.gif', writer='pillow')
plt.close(fig)

Salvamos o gif em pillow, fechamos o arquivo e exibimos a imagem, lendo o arquivo.

# Exibir no Jupyter
Image(filename='brownian_motion_highlight.gif')

A animação mostra o início da partícula de índice 10, que se movimenta a cada step até alcançar o movimento final. Esse é o processo do movimento Browniano, onde há uma probabilidade das partículas se movimentarem. A chave é entender que as partículas se movem a cada step, permitindo criar um processo que reverta esses passos e, por exemplo, identifique onde a partícula iniciou, fazendo uma analogia com imagens, resultando em uma nova imagem.

Sobre o curso Modelos de Difusão: fundamentos e aplicações avançadas

O curso Modelos de Difusão: fundamentos e aplicações avançadas possui 297 minutos de vídeos, em um total de 69 atividades. Gostou? Conheça nossos outros cursos de IA para Dados em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Explorando Geração de Imagens com IA
• Fundamentos do Ruído: Intuição Matemática da Difusão
• Codificando o Processo Forward
• Entendendo a U-Net no Processo Reverso
• Aprofundado a U-Net no Processo Reverso
• Difusão Condicional com Rótulos
• Difusão Condicionamento Espacial
• Avaliação de Modelos de Difusão
• Projeto Final: Geração e Exportação