Konsep GAN

Gagasan pelatihan adversarial antara generator dan discriminator.

Daftar isi

GAN (generative adversarial network) melatih dua jaringan yang berlawanan tujuan, yaitu generator yang memalsukan data dan discriminator yang membedakan data asli dari data palsu, dan keseimbangan antara keduanya menghasilkan contoh baru yang meyakinkan. Topik ini menurunkan tujuan adversarialnya, melatih GAN mini satu dimensi sampai distribusinya tertangkap, dan menetapkan mode kegagalan pelatihannya. Setelah selesai, gagasan pelatihan adversarial, yang berbeda arah dari rekonstruksi autoencoder, memiliki contoh yang dapat dihitung penuh.

Tujuan adversarial sebagai permainan#

Kedua pemain melatih satu tujuan yang bertentangan. Discriminator dilatih klasifikasi biner biasa, yaitu memaksimalkan kemampuannya membedakan contoh asli dari contoh buatan, sedangkan generator dilatih membalikkan hasil itu dengan membuat contoh palsu yang semakin sulit dibedakan. Bentuk min-max-nya ditulis:

\min_G \max_D \mathbb{E}_{x \sim p_{\text{data}}}[\log D(x)] + \mathbb{E}_{z \sim p_z}[\log(1 - D(G(z)))]

Generator memetakan vektor bising acak $z$ ke ruang data, dan di situlah letak perbedaannya dengan autoencoder, karena tidak ada masukan nyata yang direkonstruksi, melainkan contoh baru yang dibangkitkan dari bising. Pada optimum teoretis, distribusi generator sama dengan distribusi data dan discriminator tidak dapat berbuat apa pun selain menebak dengan peluang setengah, dan praktik pelatihan memantau kedekatan ke keadaan itu lewat dua loss yang saling mendorong.

Dua detail praktis lahir dari bentuk tujuan ini. Pada langkah discriminator, contoh palsu dilepaskan dari grafik generator lewat .detach(), sehingga pembaruan discriminator tidak menyeret bobot generator. Pada langkah generator, gradien justru mengalir menembus discriminator yang bobotnya tidak diperbarui optimizer mana pun. Selain itu, generator dilatih dengan suku yang memaksimalkan $\log D(G(z))$ alih-alih meminimalkan $\log(1 - D(G(z)))$ , karena bentuk kedua menghasilkan gradien yang nyaris nol tepat ketika generator masih buruk, dan kedua bentuk ini sama pada optimum teoretisnya.

Melatih GAN mini satu dimensi#

Contoh berikut melatih GAN untuk meniru distribusi satu dimensi, yaitu campuran dua gumpalan Gaussian, dengan jaringan yang sangat kecil agar pelatihannya selesai dalam hitungan detik. Satu langkah pelatihan terdiri atas satu pembaruan discriminator pada data asli dan palsu, lalu satu pembaruan generator, dan keduanya diulang seribu langkah.

python gan_mini.py

import torch
import torch.nn as nn

torch.manual_seed(0)
asli = torch.cat([torch.randn(2000) - 3.0, torch.randn(2000) + 3.0]).reshape(-1, 1)

G = nn.Sequential(nn.Linear(8, 32), nn.ReLU(), nn.Linear(32, 1))
D = nn.Sequential(nn.Linear(1, 32), nn.ReLU(), nn.Linear(32, 1))
optG = torch.optim.Adam(G.parameters(), lr=0.002)
optD = torch.optim.Adam(D.parameters(), lr=0.002)

for langkah in range(1, 1001):
    z = torch.randn(256, 8)
    data_asli = asli[torch.randint(0, len(asli), (256,))]
    optD.zero_grad()
    lossD = (nn.functional.binary_cross_entropy_with_logits(D(data_asli), torch.ones(256, 1))
             + nn.functional.binary_cross_entropy_with_logits(D(G(z).detach()), torch.zeros(256, 1)))
    lossD.backward()
    optD.step()
    optG.zero_grad()
    lossG = nn.functional.binary_cross_entropy_with_logits(D(G(z)), torch.ones(256, 1))
    lossG.backward()
    optG.step()
    if langkah in (1, 500, 1000):
        print(f"langkah {langkah}: loss D = {lossD.item():.4f} | loss G = {lossG.item():.4f}")

with torch.no_grad():
    palsu = G(torch.randn(4000, 8)).squeeze()
    jarak = ((palsu + 3).abs() < 1.5).float().mean() + ((palsu - 3).abs() < 1.5).float().mean()
    print("fraksi palsu dekat dua gumpalan:", round(float(jarak), 3))

text Keluaran

langkah 1: loss D = 1.8571 | loss G = 0.6801
langkah 500: loss D = 0.9730 | loss G = 1.1318
langkah 1000: loss D = 0.9843 | loss G = 1.0494
fraksi palsu dekat dua gumpalan: 0.993

Berkas dijalankan dengan python3 gan_mini.py, dan pola kedua loss yang berayun menggambarkan permainannya, yaitu discriminator unggul sebentar, generator menyusul, dan keadaan seimbangnya menyisakan kedua loss yang tidak menuju nol. Fraksi contoh palsu yang jatuh di dekat kedua gumpalan memperlihatkan bahwa generator menemukan struktur bimodalnya, karena vektornya sendiri tidak diberi tahu apa pun tentang gumpalan tersebut. .detach() pada contoh palsu saat melatih discriminator menegaskan bahwa generator tidak ikut diperbarui pada langkah itu, sesuai aturan gradien yang disebut di atas.

Mode kegagalan dan stabilisatornya#

Pelatihan GAN terkenal karena tiga mode kegagalannya yang masing-masing punya gejala khas. Mode pertama adalah collapsing mode, yaitu generator menghasilkan satu atau beberapa keluaran yang sama terus-menerus, dan gejalanya adalah keragaman contoh yang runtuh meskipun lossnya terlihat sehat. Mode kedua adalah osilasi yang tidak konvergen, yaitu kedua loss berayun tanpa pernah menetap karena kedua pemain saling mengejar tanpa titik tenang. Mode ketiga adalah ketimpangan kekuatan, yaitu discriminator yang terlalu kuat membuat gradien generatornya nyaris nol, dan gejalanya adalah loss generator yang berhenti turun sejak awal.

Stabilisator yang dipakai praktik dapat dirangkum menjadi empat. Pertama, keseimbangan langkah, yaitu satu pembaruan discriminator per satu pembaruan generator sebagai titik awal. Kedua, arah loss generator yang memaksimalkan $\log D(G(z))$ sebagaimana dipakai contoh di atas. Ketiga, normalisasi spektral pada discriminator yang menahan pertumbuhan skala bobotnya. Keempat, arsitektur konvolusional yang khusus GAN dengan batch normalization dan lapisan dekonvolusi pada citra, yang menstabilkan gradien sepanjang kedalaman.

Dari mini ke citra dan penerusnya#

Pada citra sungguhan, resep DCGAN menetapkan arsitektur konvolusional untuk keduanya, dan penyempurnaan bertahap seperti WGAN serta tanda inception score mengatasi dan mengukur kestabilannya. Peran historisnya yang paling besar adalah mengajarkan pelatihan adversarial sebagai pola, dan pola itu berlanjut hingga hari ini pada keamanan model yang membahas kerapuhan adversarial, serta pada adversarial training yang menjadi bentuk regularisasi.

Namun pada generasi citra masa kini, keluarga diffusion pada topik Konsep diffusion menggantikan GAN sebagai standar, dan alasan utamanya adalah kestabilan pelatihannya yang tidak memerlukan keseimbangan dua pemain. Pemahaman adversarial tetap bernilai karena mekanismenya muncul di banyak tempat lain, dari pembelajaran kontras hingga pertahanan model.

Ringkasan#

GAN melatih generator dan discriminator dengan tujuan bertentangan, dan optimum teoretisnya adalah distribusi generator yang sama dengan data.
Generator diperbarui melalui discriminator yang dibekukan dengan .detach(), dan suku $\log D(G(z))$ menjaga gradien tetap hidup saat generator masih buruk.
Tiga mode kegagalan utamanya adalah mode collapse, osilasi, dan ketimpangan discriminator, dengan stabilisator keseimbangan langkah dan normalisasi spektral.
Adversarial training sebagai pola bertahan lebih lama daripada dominasi GAN pada generasi citra yang kini diambil alih diffusion.

Referensi#

Generative Adversarial Networks — arXiv — Makalah asli Goodfellow dkk. yang menurunkan tujuan min-max dan bukti optimumnya.
Unsupervised Representation Learning with DCGANs — arXiv — Makalah yang menetapkan resep arsitektur konvolusional untuk GAN.
Generative Adversarial Networks — Dive into Deep Learning — Bab yang menurunkan pelatihan GAN dari nol dengan kode lengkap.