Salt la conținut

Ce sunt modelele de difuzie

ÎncepătorLectură: 9 min

Un model de difuzie (diffusion model) generează date noi, de exemplu o imagine, pornind de la zgomot aleator pe care îl curăță treptat, în zeci de pași. Seamănă cu ecranul unui televizor fără semnal, plin de „purici”, care s-ar limpezi încet până ar deveni o fotografie. Pe acest principiu funcționează generatoare de imagini precum Stable Diffusion, FLUX, DALL·E 3 și Imagen, generatoare video precum Sora și Veo și o parte dintre modelele care sintetizează vocea.

Un model de limbaj scrie răspunsul câte un token pe rând, de la stânga la dreapta. Un model de difuzie lucrează altfel: la fiecare pas, produce o versiune puțin mai curată a întregului rezultat. Mai întâi apar compoziția și culorile, apoi formele, iar detaliile fine apar la sfârșit.

Un model de difuzie are două procese, care merg în direcții opuse.

  • Procesul direct (forward process) pornește de la o imagine reală și îi adaugă, pas cu pas, puțin zgomot gaussian (Gaussian noise), adică valori aleatoare mici, distribuite după o curbă în formă de clopot. După TT pași (în articolele clasice, T=1.000T = 1.000), din imagine nu mai rămâne nimic recognoscibil. Procesul este fixat dinainte și nu are nimic de învățat.
  • Procesul invers (reverse process) face drumul înapoi. O rețea neuronală primește o imagine cu zgomot și numărul pasului și estimează ce zgomot conține imaginea. Dacă scădem o parte din acest zgomot, obținem o imagine puțin mai curată. Repetat de la zgomot pur până la pasul 0, procesul invers produce o imagine nouă.
Procesul direct și procesul invers al unui model de difuzieUn desen de 7 pe 7 pixeli cu litera A, la pașii 0, 250, 500, 750 și 1000. De la stânga la dreapta, procesul direct adaugă tot mai mult zgomot, până când desenul nu se mai vede. De la dreapta la stânga, procesul invers, învățat de o rețea neuronală, scoate zgomotul pas cu pas și ajunge la o imagine curată.Procesul direct: se adaugă zgomot (fix) →t = 0ᾱ = 1,00t = 250ᾱ = 0,85t = 500ᾱ = 0,50t = 750ᾱ = 0,15t = 1000ᾱ ≈ 0← Procesul invers: rețeaua scoate zgomotul (învățat)
Același zgomot, în proporții tot mai mari. ᾱ arată cât din desen mai rămâne la fiecare pas.

Ideea a fost propusă în 2015 de Jascha Sohl-Dickstein și colegii săi și vine din fizica statistică, unde difuzia descrie felul în care o picătură de cerneală se împrăștie într-un pahar cu apă. A devenit practică în 2020, odată cu articolul despre DDPM (denoising diffusion probabilistic models) al lui Jonathan Ho, Ajay Jain și Pieter Abbeel. Până atunci, cele mai bune imagini generate veneau de la rețelele generative adversariale (generative adversarial networks, GAN), în care două rețele concurează: una generează imagini, iar cealaltă încearcă să le deosebească de cele reale. În 2021, Prafulla Dhariwal și Alex Nichol au arătat că modelele de difuzie depășesc rețelele GAN la calitatea imaginilor, iar de atunci difuzia a devenit metoda dominantă.

Pentru calculator, o imagine este un șir de numere: intensitatea fiecărui pixel, pe fiecare canal de culoare. Notăm acest șir cu x0x_0 și îl scalăm în intervalul [−1,1][-1, 1]. Imaginea cu zgomot de la pasul tt, notată xtx_t, este o combinație între imaginea inițială și zgomot. Cu cât pasul este mai mare, cu atât din imagine rămâne mai puțin, iar la ultimul pas rămâne doar zgomot. Felul în care scade, de la un pas la altul, partea rămasă din imagine se numește programul de zgomot (noise schedule). DDPM folosea un program liniar, iar programul în formă de cosinus, propus în 2021 de Alex Nichol și Prafulla Dhariwal, păstrează mai multă informație în pașii de la mijloc.

Pentru curioșiProcesul direct de adăugare a zgomotului
xt=αˉt x0+1−αˉt ε,ε∼N(0,I)x_t = \sqrt{\bar\alpha_t}\, x_0 + \sqrt{1 - \bar\alpha_t}\, \varepsilon, \qquad \varepsilon \sim \mathcal{N}(0, I)

Aici ε\varepsilon este un vector de zgomot gaussian, de aceeași dimensiune cu imaginea, iar αˉt\bar\alpha_t (citit „alfa barat”) este un număr între 0 și 1 care spune cât din imagine mai rămâne la pasul tt. La t=0t = 0, αˉ0≈1\bar\alpha_0 \approx 1 și avem imaginea originală. La t=Tt = T, αˉT≈0\bar\alpha_T \approx 0 și avem doar zgomot. Programul de zgomot este felul în care scade αˉt\bar\alpha_t de la un pas la altul.

Procesul direct are o proprietate importantă: putem sări dintr-odată la orice pas tt, fără să calculăm pașii de dinainte. Asta face antrenarea eficientă, pentru că fiecare exemplu de antrenare poate folosi alt pas, ales la întâmplare.

Rețeaua, notată εθ\varepsilon_\theta (unde θ\theta sunt parametrii rețelei), învață să ghicească zgomotul dintr-o imagine. Un pas de antrenare arată astfel:

  1. Alegem o imagine x0x_0 din setul de antrenare.

  2. Alegem la întâmplare un pas tt între 1 și TT și un zgomot gaussian ε\varepsilon.

  3. Calculăm imaginea cu zgomot xtx_t, cu formula procesului direct.

  4. Rețeaua primește xtx_t și tt și estimează zgomotul, εθ(xt,t)\varepsilon_\theta(x_t, t).

  5. Comparăm estimarea cu zgomotul adevărat și ajustăm parametrii prin retropropagare și coborâre pe gradient, ca să micșorăm eroarea pătratică.

    Pentru curioșiFuncția de pierdere
    L=∥ε−εθ(xt,t)∥2L = \left\lVert \varepsilon - \varepsilon_\theta(x_t, t) \right\rVert^2

Este o problemă obișnuită de regresie: rețeaua primește o intrare și învață să prezică un număr pentru fiecare pixel. Antrenarea este stabilă, spre deosebire de cea a rețelelor GAN, unde cele două rețele concurente se pot dezechilibra ușor.

A estima zgomotul este echivalent cu a estima imaginea curată.

Pentru curioșiImaginea curată, calculată din zgomotul estimat

Dacă știm xtx_t și zgomotul estimat ε^\hat\varepsilon, putem inversa formula procesului direct.

x^0=xt−1−αˉt ε^αˉt\hat{x}_0 = \frac{x_t - \sqrt{1 - \bar\alpha_t}\, \hat\varepsilon}{\sqrt{\bar\alpha_t}}

DDPM și primele versiuni Stable Diffusion folosesc o rețea de tip U-Net, creată în 2015 pentru segmentarea imaginilor medicale. Rețeaua U-Net micșorează imaginea în mai multe etape, apoi o mărește la loc, cu legături directe între nivelurile care au aceeași rezoluție. Modelele mai noi folosesc un Transformer, așa cum arată pagina despre generarea imaginilor.

La generare pornim de la zgomot pur, xT∼N(0,I)x_T \sim \mathcal{N}(0, I), și coborâm pas cu pas până la t=0t = 0. La fiecare pas, rețeaua estimează zgomotul ε^\hat\varepsilon, iar din zgomotul estimat obținem o estimare a imaginii curate, x^0\hat x_0. Apoi calculăm xt−1x_{t-1}, o imagine cu ceva mai puțin zgomot decât xtx_t, combinând cele două estimări în proporțiile potrivite pentru pasul t−1t - 1.

Pentru curioșiUn pas al procesului invers
xt−1=αˉt−1 x^0+1−αˉt−1 ε^x_{t-1} = \sqrt{\bar\alpha_{t-1}}\, \hat{x}_0 + \sqrt{1 - \bar\alpha_{t-1}}\, \hat\varepsilon

Aceasta este regula metodei DDIM (denoising diffusion implicit models, 2020), folosită și în exemplul de mai jos. Cu această regulă, generarea este deterministă: același zgomot inițial duce mereu la aceeași imagine. DDPM adaugă în plus, la fiecare pas, puțin zgomot nou, ales la întâmplare.

Fiecare pas înseamnă o trecere completă prin rețea, deci numărul de pași decide direct cât durează generarea. DDPM avea nevoie de 1.000 de pași, iar DDIM obține imagini bune în aproximativ 50. Modelele distilate (distilled), antrenate să imite în câțiva pași rezultatul obținut în zeci de pași, generează o imagine în 1–4 pași. Un exemplu este SDXL Turbo (Stability AI, 2023).

Ordinea în care apar detaliile are o explicație simplă. Când zgomotul este mare, rețeaua nu poate ști care dintre multele imagini posibile se află sub zgomot, așa că cea mai bună estimare este o medie a acestor imagini, adică o imagine încețoșată. Pe măsură ce zgomotul scade, estimarea se poate fixa pe o singură variantă. Generarea trece astfel de la ansamblu la detalii, cam cum lucrează un pictor care face întâi schița.

Exemplul de mai jos rulează procesul direct și procesul invers pe un set de antrenare minuscul: patru desene de 7 × 7 pixeli, cu literele A, I, O și X. Pentru un set atât de mic nu avem nevoie de o rețea antrenată, pentru că putem calcula exact cea mai bună estimare a imaginii curate. Pentru o imagine cu zgomot xtx_t, calculăm cât de probabil este ca imaginea să provină din fiecare desen x(i)x^{(i)}, apoi facem media desenelor, ponderată cu aceste probabilități.

Pentru curioșiEstimarea exactă pentru cele patru desene
pi∝exp⁡(−∥xt−αˉt x(i)∥22(1−αˉt)),x^0=∑ipi x(i)p_i \propto \exp\left(-\frac{\lVert x_t - \sqrt{\bar\alpha_t}\, x^{(i)} \rVert^2}{2(1 - \bar\alpha_t)}\right), \qquad \hat{x}_0 = \sum_i p_i\, x^{(i)}

Media ponderată este răspunsul pe care l-ar da o rețea antrenată perfect pe aceste patru desene. Programul de zgomot este o variantă simplificată a celui în formă de cosinus, cu T=50T = 50 de pași.

import numpy as np
# Setul de antrenare: patru desene de 7 x 7 pixeli (# este alb, . este negru)
desene = {
"A": ["..###..", ".#...#.", "#.....#", "#######", "#.....#", "#.....#", "#.....#"],
"I": [".#####.", "...#...", "...#...", "...#...", "...#...", "...#...", ".#####."],
"O": [".#####.", "#.....#", "#.....#", "#.....#", "#.....#", "#.....#", ".#####."],
"X": ["#.....#", ".#...#.", "..#.#..", "...#...", "..#.#..", ".#...#.", "#.....#"],
}
date = np.array([[1.0 if c == "#" else -1.0 for c in "".join(d)] for d in desene.values()])
def afiseaza(imagini, titluri):
nuante = " .:-=+*#%@"
print(" ".join(f"{t:^7}" for t in titluri))
for rand in range(7):
bucati = []
for img in imagini:
valori = np.clip((img.reshape(7, 7)[rand] + 1) / 2, 0, 1)
bucati.append("".join(nuante[round(v * 9)] for v in valori))
print(" ".join(bucati))
print()
# Cât din imagine rămâne la pasul t: aproape toată la t = 0, aproape nimic la t = T
T = 50
alfa_bar = np.clip(np.cos(np.linspace(0, 1, T + 1) * np.pi / 2) ** 2, 1e-4, 0.9999)
rng = np.random.default_rng(seed=1)
# 1. Procesul direct: adăugăm zgomot peste desenul „A”
pasi = [0, 15, 30, 50]
zgomotoase = [np.sqrt(alfa_bar[t]) * date[0] + np.sqrt(1 - alfa_bar[t]) * rng.normal(size=49) for t in pasi]
print("Procesul direct\n")
afiseaza(zgomotoase, [f"t={t}" for t in pasi])
# 2. Cât de probabil este ca imaginea cu zgomot x_t să provină din fiecare desen
def probabilitati_desene(x_t, t):
distante = np.sum((x_t - np.sqrt(alfa_bar[t]) * date) ** 2, axis=1)
scoruri = -distante / (2 * (1 - alfa_bar[t]))
p = np.exp(scoruri - scoruri.max())
return p / p.sum()
# 3. Procesul invers: pornim de la zgomot pur și scoatem zgomotul pas cu pas
x = rng.normal(size=49)
estimari, titluri = [], []
print("Procesul invers\n")
for t in range(T, 0, -1):
p = probabilitati_desene(x, t)
x0_estimat = p @ date
zgomot_estimat = (x - np.sqrt(alfa_bar[t]) * x0_estimat) / np.sqrt(1 - alfa_bar[t])
x = np.sqrt(alfa_bar[t - 1]) * x0_estimat + np.sqrt(1 - alfa_bar[t - 1]) * zgomot_estimat
if t % 5 == 0 and t >= 30:
print(f"t={t} " + " ".join(f"{nume}{pi:5.0%}" for nume, pi in zip(desene, p)))
if t in (50, 45, 40):
estimari.append(x0_estimat)
titluri.append(f"t={t}")
print()
afiseaza(estimari + [x], titluri + ["final"])

Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).

La t=50t = 50, imaginea este aproape numai zgomot, cele patru desene sunt aproape la fel de probabile, iar estimarea imaginii curate este media desenelor, o suprapunere a celor patru litere. În câțiva pași, probabilitățile se concentrează pe un singur desen, iar procesul invers îl reconstruiește. Valoarea seed alege zgomotul de pornire, iar o altă valoare poate duce la alt desen.

Exemplul arată și o limită. O estimare perfectă pentru un set de antrenare finit poate produce doar copii ale imaginilor din acel set. Fenomenul se numește memorare (memorization). O rețea reală, antrenată pe sute de milioane sau miliarde de imagini, nu ajunge la această estimare perfectă. În schimb, învață regulile generale ale imaginilor (margini, texturi, forme, lumină) și le poate combina în imagini noi. De ce se întâmplă asta atât de bine este încă un subiect de cercetare. Memorarea nu dispare însă complet. În 2023, Nicholas Carlini și colegii săi au extras din Stable Diffusion imagini aproape identice cu unele din setul de antrenare, mai ales imagini care apăreau de multe ori în date.

Multe modele recente, precum Stable Diffusion 3 și FLUX.1, folosesc o metodă înrudită, numită potrivirea fluxului (flow matching), în varianta cea mai simplă, fluxul rectificat (rectified flow). Aici imaginea și zgomotul sunt legate printr-o linie dreaptă.

Pentru curioșiLinia dreaptă dintre imagine și zgomot
xt=(1−t) x0+t ε,t∈[0,1]x_t = (1 - t)\, x_0 + t\, \varepsilon, \qquad t \in [0, 1]

Rețeaua învață viteza (velocity) v=ε−x0v = \varepsilon - x_0, adică direcția în care se schimbă xtx_t atunci când tt crește. Generarea pornește de la zgomot, la t=1t = 1, și se deplasează în pași mici în sens opus vitezei, până la t=0t = 0. Pentru că drumurile dintre zgomot și imagini sunt aproape drepte, pot fi parcurse cu mai puțini pași. Principiul rămâne același: un proces fix care transformă datele în zgomot și o rețea care învață să-l inverseze.

AspectModel de limbaj (autoregresiv)Model de difuzie
Ce produce la un pasUn singur token nouO versiune mai curată a întregului rezultat
OrdineaDe la stânga la dreaptaDe la ansamblu la detalii
Numărul de pașiCât de lung este răspunsulAles dinainte, de la 1–4 la câteva zeci
Revenirea asupra unei alegeriUn token generat rămâne în textFiecare pas poate corecta tot rezultatul
Unde dominăText și codImagini, video și o parte din audio

Granița dintre cele două familii nu este strictă. Există modele de limbaj bazate pe difuzie, precum LLaDA (2025), Mercury (Inception Labs, 2025) și modelul experimental Gemini Diffusion (Google, 2025). LLaDA, de exemplu, nu folosește zgomot gaussian: ascunde tokenurile textului în spatele unei măști, iar rețeaua le reconstituie pe toate deodată, în mai mulți pași. Pagina despre generarea textului prin difuzie arată cum funcționează aceste modele. Invers, unele generatoare de imagini, precum cel bazat pe GPT-4o, lansat în ChatGPT în 2025, lucrează autoregresiv, câte un token de imagine pe rând.

Paginile următoare arată cum este aplicată difuzia la imagini, la voce, la video și la text, împreună cu semnele după care putem recunoaște conținutul generat. Laboratorul Imagini și sunete cu modele de difuzie rulează aceleași idei pe modele reale, cu librăria Diffusers, de la procesul de difuzie scris de mână până la imagini și sunete generate din text.