📑 Daftar Isi — Part 7
- Discriminative vs Generative — Classify vs Create
- Autoencoder — Kompresi & rekonstruksi
- VAE — Variational Autoencoder untuk generasi
- GAN: Konsep — Generator vs Discriminator
- Kode: DCGAN — Generate MNIST digits dari noise
- Training Tips — GANs terkenal susah di-train
- Evolusi Generative Models
- Ringkasan & Preview Part 8
🎨
1. Discriminative vs Generative
Classify gambar kucing vs MEMBUAT gambar kucing baru📋 Discriminative (Part 1-5)
Input gambar → Output label. "Ini kucing atau anjing?" Model MENILAI. P(y|x). Contoh: CNN, LSTM, BERT.
🎨 Generative (Part 7)
Input noise → Output gambar BARU. "Buat gambar kucing yang belum pernah ada." Model MENCIPTAKAN. P(x). Contoh: GAN, VAE, Diffusion.
🔄
2. Autoencoder — Kompresi & Rekonstruksi
Compress gambar ke vektor kecil, lalu reconstruct kembali🔄 Autoencoder — Encoder (Compress) → Latent Space → Decoder (Reconstruct)
class Autoencoder(nn.Module):
def __init__(self):
super().__init__()
self.encoder = nn.Sequential(
nn.Linear(784, 256), nn.ReLU(),
nn.Linear(256, 64), nn.ReLU(),
nn.Linear(64, 16), # → Latent space (16 dim)
)
self.decoder = nn.Sequential(
nn.Linear(16, 64), nn.ReLU(),
nn.Linear(64, 256), nn.ReLU(),
nn.Linear(256, 784), nn.Sigmoid(), # → pixel [0,1]
)
def forward(self, x):
z = self.encoder(x) # Compress
return self.decoder(z) # Reconstruct
# Loss: seberapa mirip output dengan input
loss_fn = nn.MSELoss()
⚔️
4. GAN — Generator vs Discriminator
Pemalsu vs Detektif: dua network saling "bertarung"⚔️ GAN — Adversarial Training: Generator vs Discriminator
💡 Analogi: Pemalsu vs Detektif
Generator = pemalsu uang yang belajar membuat uang palsu semakin mirip asli. Discriminator = detektif yang belajar membedakan uang asli dan palsu. Keduanya saling "bertarung" — dan seiring waktu, kedua pihak makin jago. Akhirnya, Generator menghasilkan gambar yang tidak bisa dibedakan dari gambar asli, bahkan oleh Discriminator.
💻
5. Kode: DCGAN — Generate MNIST
Deep Convolutional GAN: generate angka dari random noiseimport torch
import torch.nn as nn
# ===== GENERATOR: Noise → Image =====
class Generator(nn.Module):
def __init__(self, latent_dim=100):
super().__init__()
self.net = nn.Sequential(
# z: [batch, 100] → reshape ke [batch, 100, 1, 1]
nn.ConvTranspose2d(100, 256, 7, 1, 0), # → 7×7
nn.BatchNorm2d(256), nn.ReLU(),
nn.ConvTranspose2d(256, 128, 4, 2, 1), # → 14×14
nn.BatchNorm2d(128), nn.ReLU(),
nn.ConvTranspose2d(128, 1, 4, 2, 1), # → 28×28
nn.Tanh() # Output: [-1, 1]
)
def forward(self, z):
return self.net(z.view(-1, 100, 1, 1))
# ===== DISCRIMINATOR: Image → Real/Fake =====
class Discriminator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Conv2d(1, 64, 4, 2, 1), # 28→14
nn.LeakyReLU(0.2),
nn.Conv2d(64, 128, 4, 2, 1), # 14→7
nn.BatchNorm2d(128), nn.LeakyReLU(0.2),
nn.Flatten(),
nn.Linear(128*7*7, 1),
nn.Sigmoid() # → P(real) ∈ [0, 1]
)
def forward(self, x):
return self.net(x)
# ===== TRAINING LOOP =====
G = Generator()
D = Discriminator()
loss_fn = nn.BCELoss()
opt_G = torch.optim.Adam(G.parameters(), lr=2e-4, betas=(0.5, 0.999))
opt_D = torch.optim.Adam(D.parameters(), lr=2e-4, betas=(0.5, 0.999))
for epoch in range(50):
for real_imgs, _ in dataloader:
batch = real_imgs.size(0)
real_labels = torch.ones(batch, 1)
fake_labels = torch.zeros(batch, 1)
# --- Train Discriminator ---
z = torch.randn(batch, 100)
fake_imgs = G(z).detach()
loss_D = loss_fn(D(real_imgs), real_labels) + \
loss_fn(D(fake_imgs), fake_labels)
opt_D.zero_grad(); loss_D.backward(); opt_D.step()
# --- Train Generator ---
z = torch.randn(batch, 100)
fake_imgs = G(z)
loss_G = loss_fn(D(fake_imgs), real_labels) # Trick D!
opt_G.zero_grad(); loss_G.backward(); opt_G.step()
# Epoch 1: Noisy blobs
# Epoch 10: Blurry shapes resembling digits
# Epoch 30: Clear, readable handwritten digits! ✅
⚠️
6. GAN Training Tips
GANs terkenal susah dan tidak stabil. Ini cara mengatasinya.| Masalah | Gejala | Solusi |
|---|---|---|
| Mode Collapse | Generator hanya produce 1-2 jenis gambar | Label smoothing, minibatch discrimination |
| Training Oscillation | Loss naik-turun terus, tidak converge | Two-Timescale Update Rule (TTUR) |
| Vanishing Gradients | G berhenti belajar | Wasserstein loss (WGAN) |
| D terlalu kuat | D selalu menang, G tidak bisa improve | Train D lebih jarang, learning rate rendah |
📈
7. Evolusi Generative Models
Dari GAN → Diffusion → Foundation Models| Tahun | Model | Breakthrough | Quality |
|---|---|---|---|
| 2014 | GAN (Goodfellow) | Adversarial training concept | Blurry |
| 2016 | DCGAN | CNN-based GAN, stable training | Decent |
| 2018 | StyleGAN (NVIDIA) | Photorealistic faces | Excellent |
| 2020 | DDPM | Diffusion models | Excellent |
| 2022 | Stable Diffusion | Text-to-image, open source | Amazing |
| 2024 | FLUX, SD3 | Consistency, quality, speed | Near-perfect |
| 2025-26 | Video Gen (Sora, Kling) | Text-to-video generation | Revolutionary |
📝
8. Ringkasan Part 7
Generative AI fundamentals| Konsep | Apa Itu | Kode Kunci |
|---|---|---|
| Autoencoder | Compress → latent → reconstruct | Encoder + Decoder + MSELoss |
| VAE | AE + sampling dari distribusi | μ, σ → reparameterization trick |
| Generator | Noise → fake image | ConvTranspose2d (upsampling) |
| Discriminator | Image → real/fake? | Conv2d → Sigmoid |
| BCELoss | Binary cross-entropy | nn.BCELoss() |
| Adversarial | G dan D saling "bertarung" | Alternating optimization |
Next: Part 8 — Transformer dari Nol
Build Transformer architecture from scratch: Self-Attention, Multi-Head Attention, Positional Encoding. Fondasi GPT, BERT, dan semua LLM modern.