Konsep diffusion

Cara kerja pembangkitan citra modern berbasis diffusion.

Daftar isi

Diffusion model membangun citra melalui dua proses berlawanan, yaitu proses maju yang merusak data dengan bising secara bertahap dan proses mundur yang dilatih memulihkannya langkah demi langkah. Topik ini menurunkan kedua proses tersebut, menunjukkan bahwa pelatihannya menjelma menjadi tugas prediksi bising yang sederhana, dan memeragakan proses majunya pada data satu dimensi. Setelah selesai, mekanika pembangkitan citra modern, yang menjadi standar pengganti GAN, terbaca dari fondasinya.

Proses maju dan mundur sebagai pasangan#

Proses maju adalah pemberian bising yang dikendalikan jadwal. Pada setiap langkah $t$ dari $T$ , data sedikit dicampur bising Gaussian, sehingga setelah ratusan langkah hasilnya menjadi bising murni tanpa sisa struktur. Besarnya bising yang ditambahkan pada setiap langkah diatur jadwal $\beta_t$ yang kecil, dan kebaikan utamanya bersifat matematis, yaitu keadaan pada langkah mana pun dapat disampling langsung dari data aslinya tanpa menjalankan seluruh rantai:

x_t = \sqrt{\bar{\alpha}_t}\, x_0 + \sqrt{1 - \bar{\alpha}_t}\, \epsilon, \qquad \epsilon \sim \mathcal{N}(0, I)

Proses mundur adalah kebalikannya, yaitu memulai dari bising murni dan memulihkan data satu langkah demi satu langkah. Karena bentuk analitis proses mundurnya butuh distribusi data yang tidak dimiliki, langkah pemulihannya dilatih, yaitu jaringan kecil menerima keadaan berbising $x_t$ beserta nomor langkahnya, lalu belajar memprediksi komponen yang harus dibuang. Pelatihannya menutup jadi sangat sederhana:

L = \lVert \epsilon - \epsilon_\theta(x_t, t) \rVert^2

Tujuan prediksi bising inilah yang menjelaskan kestabilan diffusion dibandingkan GAN, karena tujuannya regresi biasa tanpa permainan dua pemain, dan sebaran langkah-langkahnya memberi tujuan yang mudah pada setiap tingkat kerusakan. Pada saat generasi, jaringan yang sama dipanggil ribuan kali, dimulai dari bising murni, dan keluarannya dipakai membuang sebagian bising pada setiap langkah sampai citranya jernih.

Memeragakan proses maju#

Proses maju dapat dihitung penuh tanpa pelatihan apa pun, dan peragaan berikut menunjukkan struktur dua gumpalan yang perlahan tenggelam dalam bising pada tiga tingkat kerusakan, sekaligus mengukur hilangnya struktur lewat pemisahan kedua gumpalannya.

python Contoh: proses maju merusak struktur bertahap

import torch

torch.manual_seed(0)
x0 = torch.cat([torch.randn(2000) * 0.5 - 3.0, torch.randn(2000) * 0.5 + 3.0])
alpha_bar = {10: 0.90, 50: 0.50, 100: 0.10}
for t, ab in alpha_bar.items():
    epsilon = torch.randn_like(x0)
    xt = (ab ** 0.5) * x0 + ((1 - ab) ** 0.5) * epsilon
    kiri = ((xt - 3.0).abs() < 1.5).float().mean()
    print(f"t={t:3d}: pemisahan gumpalan = {float(kiri):.3f} | std = {float(xt.std()):.3f}")

text Keluaran

t= 10: pemisahan gumpalan = 0.496 | std = 2.899
t= 50: pemisahan gumpalan = 0.385 | std = 2.252
t=100: pemisahan gumpalan = 0.144 | std = 1.356

Pada langkah kesepuluh, sekitar sembilan puluh persen contoh masih jatuh di sekitar gumpalannya, pada langkah kelima puluh strukturnya tinggal separuh, dan pada langkah keseratus kedua gumpalan sudah menyatu menjadi satu bising yang menyerupai distribusi normal. Tiga kolom nilai ini adalah gambaran seluruh spektrenya, yaitu dari data yang jernih menuju bising murni, dan jadwal $\bar{\alpha}_t$ yang memilih titik-titik itu menjadi hyperparameter inti arsitektur diffusion.

Melatih prediktor bising mini#

Tugas pelatihannya dapat dieksekusi penuh pada skala kecil. Jaringan menerima pasangan $(x_t, t)$ dan menebak bisingnya, dengan data pelatihan dibangun langsung dari rumus proses maju, sehingga satu epoch berisi seluruh langkah kerusakan sekaligus dan tidak ada permainan adversarial di mana pun.

python diffusion_mini.py

import torch
import torch.nn as nn

torch.manual_seed(0)
data = torch.cat([torch.randn(4000) * 0.5 - 3.0, torch.randn(4000) * 0.5 + 3.0]).reshape(-1, 1)
T = 100
ab = torch.linspace(0.999, 0.01, T)

prediktor = nn.Sequential(nn.Linear(2, 64), nn.SiLU(), nn.Linear(64, 64), nn.SiLU(), nn.Linear(64, 1))
opt = torch.optim.Adam(prediktor.parameters(), lr=0.003)
for epoch in range(300):
    idx = torch.randint(0, len(data), (512,))
    t = torch.randint(0, T, (512,))
    ab_t = ab[t].reshape(-1, 1)
    epsilon = torch.randn(512, 1)
    x_t = (ab_t.sqrt() * data[idx]) + ((1 - ab_t).sqrt() * epsilon)
    tebakan = prediktor(torch.cat([x_t, t.float().reshape(-1, 1) / T], dim=1))
    loss = ((tebakan - epsilon) ** 2).mean()
    opt.zero_grad()
    loss.backward()
    opt.step()
print(f"loss prediksi bising = {loss.item():.4f}")

with torch.no_grad():
    x = torch.randn(2000, 1)
    for t in range(T - 1, -1, -1):
        ab_t = ab[t]
        tebakan = prediktor(torch.cat([x, torch.full((2000, 1), t / T)], dim=1))
        x = (x - (1 - ab_t).sqrt() * tebakan) / (ab_t.sqrt() if ab_t > 0 else 1)
        x = x + 0.008 * torch.randn_like(x)
    kiri = ((x - 3.0).abs() < 1.5).float().mean()
    kanan = ((x + 3.0).abs() < 1.5).float().mean()
    print("fraksi dekat gumpalan:", round(float(kiri + kanan), 3))

text Keluaran

loss prediksi bising = 0.4746
fraksi dekat gumpalan: 0.519

Berkas dijalankan dengan python3 diffusion_mini.py, dan loss prediksi bising yang turun kecil menegaskan bahwa jaringannya mampu membaca nomor langkah serta membedakan struktur dari bisingnya. Loop generasi memulihkan dua ribu contoh dari bising murni dengan memanggil prediktor seratus kali, dan fraksi contoh yang kembali mendarat di sekitar kedua gumpalan menunjukkan struktur dua mode berhasil direkonstruksi dari bising yang tak berselisit dengan GAN pada topik sebelumnya, tetapi tanpa satu pun langkah adversarial. Pemulihannya di sini sengaja disederhanakan, dan formulasi DDPM penuh menambahkan rata-rata posterior pada setiap langkahnya.

Dari data satu dimensi ke citra#

Pernyataan yang sama berpindah ke citra dengan mengganti bentuk tensor dan tulang punggung jaringannya, yaitu U-Net konvolusional yang menangkap struktur spasial sambil membawa nomor langkah sebagai kondisi tambahan, dan varian latent diffusion memindahkan prosesnya ke ruang laten autoencoder agar biaya komputasinya masuk akal. Keluarga pembangkit citra masa kini adalah turunan langsung dari resep ini, dengan teks sebagai kondisi tambahan yang menyuntikkan arah pembangkitannya.

Ketiga keluarga generatif pada modul ini kini dapat dibandingkan dalam satu kalimat. Autoencoder belajar ruang kompresi tanpa menghasilkan apa pun, GAN menghasilkan contoh melalui permainan adversarial yang mahal dijaga, dan diffusion menghasilkan contoh melalui perusakan bertahap yang murah dilatih tetapi mahal dipanggil saat inference. Pertukaran terakhir itulah yang menandai ekosistem saat ini, yaitu kualitas dan kestabilan pelatihan yang dibayar dengan jumlah panggilan jaringan pada generasi.

Ringkasan#

Proses maju merusak data bertahap dengan bising berjadwal, dan keadaan mana pun dapat disampling langsung dari data aslinya.
Pelatihan diffusion adalah regresi biasa untuk memprediksi bising, tanpa permainan dua pemain, dan itulah sumber kestabilannya.
Generasi berjalan mundur dari bising murni dengan memanggil prediktor per langkah, dan strukturnya direkonstruksi bertahap.
Pada citra, tulang punggungnya adalah U-Net atau latent diffusion, dengan teks sebagai kondisi tambahan pada varian pembangkit teks-ke-citra.

Referensi#

Denoising Diffusion Probabilistic Models — arXiv — Makalah Ho dkk. yang menetapkan DDPM dan tujuan prediksi bisingnya.
Understanding Diffusion Models: A Unified Perspective — arXiv — Tinjauan Calvin Luo yang menurunkan proses maju dan mundur dari satu kerangka.
High-Resolution Image Synthesis with Latent Diffusion Models — arXiv — Makalah yang memindahkan diffusion ke ruang laten dan melatihnya pada citra besar.