Procesul de difuzie, pas cu pas
Pagina despre modelele de difuzie descrie procesul invers prin formule: rețeaua estimează zgomotul din imagine, din zgomotul estimat obținem o estimare a imaginii curate, apoi facem un pas spre o imagine cu mai puțin zgomot. Pe această pagină scriem procesul invers în Python, pe un model real. Folosim google/ddpm-cat-256, unul dintre modelele publicate de autorii articolului DDPM, convertit pentru Diffusers. Este un U-Net cu aproximativ 114 milioane de parametri, antrenat pe fotografiile cu pisici din setul de date LSUN, care generează imagini de 256 × 256 pixeli. Modelul nu primește niciun text: pornește doar de la zgomot.
Programul de zgomot
Secțiune intitulată „Programul de zgomot”Diffusers separă rețeaua de metoda de eșantionare (scheduler). Rețeaua, aici un UNet2DModel, primește o imagine cu zgomot și pasul și estimează zgomotul. Metoda de eșantionare păstrează programul de zgomot și calculează, din estimarea rețelei, imaginea de la pasul următor. Codul de mai jos încarcă doar metoda de eșantionare și afișează, pentru câțiva pași, coeficienții din formula procesului direct, .
from diffusers import DDPMScheduler
# Metoda de eșantionare DDPM, cu programul de zgomot folosit la antrenarea modelului.scheduler = DDPMScheduler.from_pretrained("google/ddpm-cat-256")print(f"beta_schedule = {scheduler.config.beta_schedule}, T = {scheduler.config.num_train_timesteps}")
for t in [0, 250, 500, 750, 999]: alpha_bar = scheduler.alphas_cumprod[t] # ᾱ_t print(f"t = {t:3d}: {alpha_bar.sqrt():.3f} × imaginea + {(1 - alpha_bar).sqrt():.3f} × zgomotul")beta_schedule = linear, T = 1000t = 0: 1.000 × imaginea + 0.010 × zgomotult = 250: 0.722 × imaginea + 0.692 × zgomotult = 500: 0.279 × imaginea + 0.960 × zgomotult = 750: 0.057 × imaginea + 0.998 × zgomotult = 999: 0.006 × imaginea + 1.000 × zgomotulDiffusers numără pașii de la 0 la 999, nu de la 1 la 1.000, ca în articole. Programul este cel liniar din articolul DDPM: la jumătatea drumului, la , din imagine a mai rămas un coeficient de 0,279, iar la ultimul pas, unul de 0,006, adică aproape nimic. Valorile sunt fixate dinainte, în fișierul scheduler_config.json al modelului, și nu se învață.
Procesul invers, scris de mână
Secțiune intitulată „Procesul invers, scris de mână”Codul de mai jos pornește de la zgomot pur, , și face 50 de pași cu metoda DDIM, a cărei regulă este descrisă pe pagina despre generare. La câțiva pași, codul salvează două imagini într-o grilă: imaginea cu zgomot, , și estimarea imaginii curate, , calculată de metoda de eșantionare din zgomotul estimat de rețea.
import torchfrom diffusers import DDIMScheduler, UNet2DModelfrom PIL import Image
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"model_id = "google/ddpm-cat-256"unet = UNet2DModel.from_pretrained(model_id).to(device)scheduler = DDIMScheduler.from_pretrained(model_id) # aceeași rețea, cu metoda de eșantionare DDIMscheduler.set_timesteps(50)
def to_image(x): # Un tensor cu valori între -1 și 1 devine o imagine cu pixeli între 0 și 255. x = (x[0].clamp(-1, 1) + 1) / 2 return Image.fromarray((x.permute(1, 2, 0).cpu().numpy() * 255).round().astype("uint8"))
generator = torch.Generator("cpu").manual_seed(0)x = torch.randn((1, 3, 256, 256), generator=generator).to(device) # x_T, zgomot purshown = [0, 10, 20, 30, 40, 49] # pașii afișați în grilăgrid = Image.new("RGB", (len(shown) * 256, 2 * 256))for i, t in enumerate(scheduler.timesteps): with torch.no_grad(): noise_pred = unet(x, t).sample # zgomotul estimat de rețea, ε̂ step = scheduler.step(noise_pred, t, x) if i in shown: grid.paste(to_image(x), (256 * shown.index(i), 0)) # sus: x_t grid.paste(to_image(step.pred_original_sample), (256 * shown.index(i), 256)) # jos: x̂_0 x = step.prev_sample # x_{t-1}, cu ceva mai puțin zgomot
grid.save("pasi.png")to_image(x).save("pisica.png")Fișierul pisica.png conține pisica generată, iar pasi.png, drumul până la această imagine. Rândul de sus arată imaginea cu zgomot de la începutul fiecărui pas. Rândul de jos arată ce crede rețeaua că se află sub zgomot. La primul pas, estimarea este o pată încețoșată, aproape fără detalii. Este media tuturor imaginilor posibile care s-ar putea ascunde sub acel zgomot. Pe măsură ce zgomotul scade, estimarea se fixează pe o singură pisică: întâi apar forma și culorile, apoi blana și ochii.
Codul are doar câteva linii esențiale.
scheduler.set_timesteps(50)alege 50 de pași din cei 1.000 ai antrenării, aici 980, 960, …, 20, 0.unet(x, t).sampleeste estimarea zgomotului, . Rețeaua primește pasul , ca să știe cât zgomot are de eliminat.scheduler.stepaplică regula DDIM și întoarce atât imaginea de la pasul următor,prev_sample, cât și estimarea imaginii curate,pred_original_sample.
Merită schimbat manual_seed(0) în alte valori, pentru alte pisici, și numărul de pași, de exemplu 10 sau 200. Cu mai puțini pași, generarea este mai rapidă, dar imaginea pierde din detalii.
DDPM și DDIM
Secțiune intitulată „DDPM și DDIM”Aceeași rețea poate fi folosită cu metode de eșantionare diferite, fără nicio antrenare suplimentară. Codul de mai jos generează câte o pisică prin DDPM, cu toți cei 1.000 de pași, și prin DDIM, cu 50 de pași, pornind de la același zgomot, și măsoară cât durează fiecare. Pentru că pipeline-urile DDPMPipeline și DDIMPipeline fac aceiași pași ca mai sus, codul este mai scurt.
import time
import torchfrom diffusers import DDIMPipeline, DDIMScheduler, DDPMPipelinefrom PIL import Image
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"ddpm = DDPMPipeline.from_pretrained("google/ddpm-cat-256").to(device)# Aceeași rețea, cu metoda de eșantionare DDIM.ddim = DDIMPipeline(unet=ddpm.unet, scheduler=DDIMScheduler.from_config(ddpm.scheduler.config))
grid = Image.new("RGB", (2 * 256, 256))for column, (name, pipe, steps) in enumerate([("DDPM", ddpm, 1000), ("DDIM", ddim, 50)]): start = time.time() generator = torch.Generator("cpu").manual_seed(0) image = pipe(num_inference_steps=steps, generator=generator).images[0] print(f"{name}: {steps} de pași în {time.time() - start:.1f} secunde") grid.paste(image, (256 * column, 0))grid.save("ddpm_ddim.png")Fiecare pas înseamnă o trecere prin rețea, așa că timpul crește aproape proporțional cu numărul de pași, iar DDPM durează de aproximativ 20 de ori mai mult. Pe procesor, cei 1.000 de pași DDPM durează mult, așa că pentru acest exemplu merită folosită o placă grafică, de exemplu cea din Google Colab.
Cele două pisici sunt diferite, deși pornesc de la același zgomot. DDPM adaugă la fiecare pas puțin zgomot nou, ales la întâmplare, deci drumul lui DDPM se îndepărtează treptat de cel al lui DDIM, care este determinist. Imaginea DDIM este, în schimb, practic aceeași cu pisica generată de codul scris de mână: același zgomot de pornire, aceeași rețea și aceiași pași. Alte metode de eșantionare, precum DPMSolverMultistepScheduler sau EulerDiscreteScheduler, se schimbă la fel și sunt comparate în documentația despre metodele de eșantionare.
Procesul direct
Secțiune intitulată „Procesul direct”Procesul direct nu are nevoie de rețea: este doar formula programului de zgomot. Metoda add_noise o aplică direct pentru orice pas , fără pașii de dinainte, exact ca la antrenare. Codul de mai jos adaugă zgomot pisicii generate mai sus, salvată în pisica.png, și compară rezultatul cu formula scrisă de mână.
import numpy as npimport torchfrom diffusers import DDPMSchedulerfrom PIL import Image
scheduler = DDPMScheduler.from_pretrained("google/ddpm-cat-256")# Pisica generată mai sus, cu pixelii aduși între -1 și 1.x0 = torch.from_numpy(np.array(Image.open("pisica.png"))).permute(2, 0, 1)[None].float() / 127.5 - 1noise = torch.randn(x0.shape, generator=torch.Generator().manual_seed(0)) # ε
grid = Image.new("RGB", (5 * 256, 256))for column, t in enumerate([0, 250, 500, 750, 999]): x_t = scheduler.add_noise(x0, noise, torch.tensor([t])) alpha_bar = scheduler.alphas_cumprod[t] by_hand = alpha_bar.sqrt() * x0 + (1 - alpha_bar).sqrt() * noise # x_t = √ᾱ_t · x_0 + √(1 − ᾱ_t) · ε print(f"t = {t:3d}: diferența maximă față de formula scrisă de mână este {(x_t - by_hand).abs().max():.1e}") pixels = ((x_t[0].clamp(-1, 1) + 1) * 127.5).permute(1, 2, 0).round().byte().numpy() grid.paste(Image.fromarray(pixels), (256 * column, 0))grid.save("procesul_direct.png")Diferențele afișate sunt zero sau de ordinul erorilor de rotunjire, deci add_noise este chiar formula de pe pagina despre procesul direct. În grilă, pisica dispare treptat, cu coeficienții afișați la începutul paginii: la încă se mai ghicește, iar la a rămas doar zgomot.
Antrenarea unui astfel de model folosește exact aceste piese: o imagine din setul de date, un pas ales la întâmplare, add_noise și o eroare pătratică între zgomotul adevărat și cel estimat de rețea. Diffusers are un tutorial de antrenare care antrenează de la zero un UNet2DModel pe un set mic de imagini.
Bibliografie
Secțiune intitulată „Bibliografie”- Ho, J., Jain, A. și Abbeel, P. (2020). Denoising Diffusion Probabilistic Models. NeurIPS 2020.
- Ronneberger, O., Fischer, P. și Brox, T. (2015). U-Net: Convolutional Networks for Biomedical Image Segmentation. MICCAI 2015.
- Song, J., Meng, C. și Ermon, S. (2021). Denoising Diffusion Implicit Models. ICLR 2021.
- Yu, F. et al. (2015). LSUN: Construction of a Large-scale Image Dataset using Deep Learning with Humans in the Loop. Preprint arXiv:1506.03365.
Cookie-uri
Site-ul folosește Google Analytics pentru statistici de trafic. Cookie-urile de analiză se activează doar după acceptare. Detalii în politica de cookie-uri.