Dua minggu terakhir saya iseng membuka tab baru di browser dan mengetik prompt gambar ke model text-to-image. Hasilnya bikin saya senyum-senyum sendiri: gambar kucing astronot yang lumayan meyakinkan. Dari situ saya jadi penasaran, sebenarnya di balik layar bagaimana mesin bisa “menggambar”? Episode ini catatan saya membedah tiga keluarga besar generative AI untuk citra: GAN, diffusion model, dan pipeline text-to-image. Sebagai programmer, saya coba jelaskan pakai analogi yang familiar di dunia kode.
Apa Itu Generative AI?
Generative AI adalah model yang tidak sekadar mengklasifikasi atau memprediksi label, tapi membuat data baru: gambar, teks, audio. Kalau model klasifikasi itu seperti fungsi validate(input) → bool, model generatif lebih seperti fungsi generate(seed) → artifact. Ia mempelajari distribusi data latih, lalu mengambil sampel dari distribusi itu. Kuncinya bukan menghafal gambar latih, tapi menangkap “gaya” statistiknya sehingga sampel barunya terasa asli.
GAN: Dua Model yang Saling Menipu
GAN (Generative Adversarial Network) punya dua aktor: generator dan discriminator. Analogi favorit saya: generator itu developer yang mencetak uang palsu, discriminator adalah petugas bank yang memeriksa keaslian. Generator menghasilkan gambar dari vektor noise acak, discriminator menilai asli atau palsu, lalu keduanya saling mendorong untuk membaik lewat pelatihan bersaing. Konsepnya elegan, tapi siapa pun yang pernah melatih GAN tahu penderitaannya: training sering tidak stabil, mudah mode collapse (generator hanya menghasilkan variasi terbatas), dan butuh tuning hyperparameter yang teliti. Saya sendiri belum berhasil melatih GAN dari nol dengan hasil yang pantas dipamerkan — dan itu catatan jujur dari proses belajar ini.
VAE: Exploring Latent Space
Selain GAN dan diffusion, ada arsitektur ketiga yang layak dipahami: Variational Autoencoder (VAE). Konsep dasarnya mirip autoencoder biasa — kompresi input ke representasi lebih kecil (latent space), lalu rekonstruksi kembali. Bedanya, VAE tidak sekadar memetakan input ke titik tunggal di latent space, melainkan memetakan ke distribusi probabilitas (mean dan variance). Ini memaksa latent space menjadi “terstruktur” dan kontinu, sehingga kita bisa sampel titik baru dari distribusi itu dan menghasilkan gambar baru yang masuk akal.
Analogi untuk programmer: kalau autoencoder biasa seperti hash map yang memetakan input ke key, VAE seperti ruang koordinat berkelanjutan di mana titik-titik berdekatan merepresentasikan gambar yang mirip. Interpolasi antara dua titik di latent space menghasilkan transisi visual yang mulus — ini yang sering saya lihat di demo “morphing” wajah. Berikut kode sederhana VAE minimal pakai PyTorch:
class SimpleVAE(nn.Module):
def __init__(self, latent_dim=64):
super().__init__()
self.encoder = nn.Sequential(
nn.Linear(784, 256), nn.ReLU(),
nn.Linear(256, 128), nn.ReLU(),
)
self.fc_mu = nn.Linear(128, latent_dim)
self.fc_logvar = nn.Linear(128, latent_dim)
self.decoder = nn.Sequential(
nn.Linear(latent_dim, 128), nn.ReLU(),
nn.Linear(128, 256), nn.ReLU(),
nn.Linear(256, 784), nn.Sigmoid(),
)
def reparameterize(self, mu, logvar):
std = torch.exp(0.5 * logvar)
eps = torch.randn_like(std)
return mu + eps * std
def forward(self, x):
h = self.encoder(x.view(-1, 784))
mu, logvar = self.fc_mu(h), self.fc_logvar(h)
z = self.reparameterize(mu, logvar)
return self.decoder(z), mu, logvarKekurangan VAE dibanding GAN atau diffusion: hasil rekonstruksi cenderung agak buram karena loss function mendorong rata-rata (mean) daripada detail tajam. Tapi VAE sangat berguna sebagai komponen di dalam pipeline yang lebih besar — Stable Diffusion sendiri memakai VAE untuk encode dan decode di latent space.
Diffusion Model: Menghapus Noise Bertahap
Diffusion model bekerja dengan logika terbalik yang menarik. Saat pelatihan, gambar asli “dirusak” sedikit demi sedikit dengan noise selama ratusan langkah. Model dilatih untuk memprediksi noise pada tiap langkah. Saat inference, kita mulai dari murni noise acak, lalu model mengurangi noise bertahap sampai gambar koheren muncul. Analoginya seperti restore foto rusak: kalau Anda tahu pola kerusakannya, Anda bisa membaliknya. Model populer seperti Stable Diffusion adalah latent diffusion — denoising dilakukan di ruang laten yang lebih kecil sehingga jauh lebih hemat komputasi dibanding bekerja di piksel mentah. Di praktiknya, hasil diffusion saat ini umum lebih stabil dan beragam daripada GAN untuk text-to-image, dengan trade-off proses sampling yang lebih lambat karena banyak langkah.
Stable Diffusion Pipeline: Langkah demi Langkah
Saya merasa penting untuk membongkar pipeline Stable Diffusion menjadi langkah-langkah konkret agar tidak terasa seperti kotak ajaib. Begini alurnya:
- Text Encoder (CLIP): Prompt teks dimasukkan ke model CLIP yang mengubahnya menjadi vektor embedding. Vektor ini “mewakili” makna semantik dari prompt dalam bahasa yang dipahami model.
- UNet + Scheduler: Di latent space, UNet menerima vektor noise acak dan embedding prompt sebagai kondisi (conditioning). Scheduler menentukan langkah denoising — berapa iterasi, berapa banyak noise yang dihapus per langkah. UNet memprediksi noise pada tiap langkah berdasarkan kondisi teks.
- VAE Decoder: Setelah semua langkah denoising selesai, vektor latent yang bersih dikirim ke decoder VAE yang mengubahnya menjadi piksel gambar nyata (misalnya 512×512).
Poin kunci: teks tidak menggambar gambar secara langsung. Teks hanya “memberi tahu” model arah mana di ruang laten yang harus dituju. Kreativitas sebenarnya terjadi di ruang laten, bukan di ruang teks.
ControlNet: Conditioning Generation
Satu hal yang sebelumnya membuat saya frustasi: text-to-image sulit dikontrol secara presisi. Saya bisa menulis “kucing berdiri tegak”, tapi pose persisnya selalu random. ControlNet menjawab masalah ini. ControlNet bekerja dengan menambahkan lapisan conditional tambahan ke UNet yang menerima input tambahan seperti edge map, depth map, pose skeleton, atau segmentasi. Artinya, selain prompt teks, kita bisa memberikan “kerangka” visual yang harus diikuti model. Analogi programmer: kalau text prompt itu seperti parameter fungsi, ControlNet seperti constraint — membatasi output space ke subset yang kita inginkan. Ini sangat powerful untuk workflow produksi di mana konsistensi pose atau komposisi sangat penting.
Text-to-Image: Merakit Semua Jadi Pipeline
Model text-to-image modern biasanya menggabungkan tiga bagian: text encoder (misalnya turunan transformer bahasa) yang mengubah prompt menjadi embedding, diffusion U-Net (atau arsitektur lain) yang melakukan denoising di ruang laten, dan decoder/VAE yang mengubah hasil laten menjadi gambar utuh. Prompt engineering sederhana pun berpengaruh: subjek, gaya, pencahayaan, komposisi. Contoh minimal memakai library diffusers:
from diffusers import StableDiffusionPipeline
import torch
pipe = StableDiffusionPipeline.from_pretrained(
"stable-diffusion-v1-5/stable-diffusion-v1-5",
torch_dtype=torch.float16,
)
pipe = pipe.to("cuda")
image = pipe(
"a watercolor painting of a cat astronaut, soft light",
num_inference_steps=30,
guidance_scale=7.5,
).images[0]
image.save("kucing-astronot.png")Catatan penting: menjalankan pipeline di atas butuh GPU dengan VRAM cukup dan persetujuan lisensi model di Hugging Face. Di laptop tanpa GPU, jangan harapkan cepat.
Prompt Engineering untuk Image Generation
Dari pengalaman saya bereksperimen, ada beberapa pola prompt yang konsisten menghasilkan gambar lebih baik. Pertama, gunakan struktur yang jelas: subjek + gaya + pencahayaan + detail teknis. Misalnya, “portrait of an old fisherman, oil painting style, golden hour lighting, sharp focus, 8k”. Kedua, guidance_scale (atau CFG scale) mengontrol seberapa ketat model mengikuti prompt — nilai terlalu rendah menghasilkan gambar acak, terlalu tinggi menghasilkan gambar yang “kaku” dan over-saturated. Angka 7-12 biasanya sweet spot. Ketiga, negative prompt sangat membantu: menuliskan apa yang tidak diinginkan (misalnya “blurry, deformed hands, extra fingers”) memaksa model menghindari artefak umum. Saya pribadi sering menambahkan “low quality, watermark” ke negative prompt sebagai default.
Audio Generative AI: Melampaui Gambar
Pembicaraan generative AI tidak berhenti di gambar. Di ranah audio, kemajuan secepat imagen di bidang visual. MusicGen dari Meta menghasilkan musik dari deskripsi teks — cukup ketik “melancholic piano solo, minimal” dan model menghasilkan klip audio. AudioCraft dari Meta adalah framework yang mencakup MusicGen dan AudioGen (suara lingkungan). Di sisi komersial, Suno dan Udio muncul sebagai platform generative music berbasis AI yang bisa menghasilkan lagu lengkap dengan vokal dan lirik. Sebagai programmer, saya terkesan bahwa arsitektur di balik model-model ini sering kali transformer yang sama seperti yang kita pakai untuk teks — hanya input/output-nya yang berbeda. Tokenisasi audio menjadi vektor numerik memungkinkan model bahasa yang sama dipakai untuk menghasilkan gelombang suara.
Video Generation: Status 2026
Video generation adalah frontiers berikutnya. Pada 2026, beberapa pemain utama sudah cukup matang. OpenAI Sora menghasilkan video dari prompt teks dengan kualitas yang mengejutkan — koherensi temporal antar frame lebih baik dari yang saya bayangkan. Runway Gen-3 menjadi tools populer di kalangan kreator konten untuk b-roll dan konsep visual. Pika Labs menawarkan pendekatan yang lebih ringan dan aksesibel untuk pengguna non-teknis. Tantangan utama video generation masih pada konsistensi objek lintas frame dan biaya komputasi yang sangat besar. Satu klip video 5 detik bisa membutuhkan waktu generasi yang jauh lebih lama dibanding satu gambar statis. Bagi saya, ini area yang sangat menarik untuk diikuti — tapi juga reminder bahwa kita masih di awal perjalanan.
Copyright dan Ethical Concerns
Saya tidak bisa menulis tentang generative AI tanpa menyentuh isu etika. Model dilatih pada miliaran gambar dari internet, termasuk karya seniman yang tidak memberikan persetujuan. Pertanyaan yang mengganjal: apakah output model yang dilatih pada karya orang lain bisa dianggap “asli”? Secara teknis, model tidak meng-copy-paste — ia belajar statistik gaya. Tapi batas antara “terinspirasi” dan “menjiplak” sering kabur. Di sisi lain, generative AI membuka akses desain visual ke orang-orang yang tidak memiliki kemampuan menggambar — ini democratization yang nyata. Saya pribadi berpikir: gunakan tools ini untuk brainstorming dan iterasi cepat, tapi hormati karya seniman manusia, terutama untuk produksi komersial.
Perbandingan: GAN vs VAE vs Diffusion
| Aspek | GAN | VAE | Diffusion |
|---|---|---|---|
| Ide inti | Generator vs discriminator | Encode ke distribusi, decode kembali | Denoising bertahap |
| Kualitas gambar | Tajam, sering artefak | Cenderung buram | Sangat detail dan koheren |
| Stabilitas training | Rentang tidak stabil | Sangat stabil | Relatif stabil |
| Kecepatan sampling | Satu pass, cepat | Satu pass, cepat | Banyak langkah, lebih lambat |
| Kegagalan khas | Mode collapse | Hasil blur | Lambat jika langkah banyak |
| Contoh pemakaian | Deepfake, augmentasi data | Anomaly detection, latent interp. | Text-to-image, inpainting |
Catatan Pribadi
Pengalaman pertama saya generate gambar dengan AI sungguh mengubah cara saya memandang teknologi ini. Saya ingat malam itu, mengetik prompt “cyberpunk cityscape at sunset, neon reflections on wet streets” ke Stable Diffusion, menunggu beberapa detik, dan melihat gambar yang — jujur — lebih baik dari yang bisa saya bayangkan. Ada sensasi aneh: kagum sekaligus sedikit cemas. Kagum karena kemampuan teknisnya luar biasa, cemas karena membayangkan dampak jangka panjang ke profesi desainer grafis yang saya kagumi. Malam itu saya tidak tidur sampai larut, terus bereksperimen dengan prompt yang berbeda, mencoba memahami bagaimana tiap kata memengaruhi hasil. Pengalaman ini yang memicu seluruh seri belajar AI ini.
- Mulai dari memakai pretrained model dulu, jangan langsung melatih dari nol.
- Pahami konsep latent space: banyak keajaiban text-to-image sebenarnya interpolasi di ruang laten.
- Seed acak menentukan hasil; simpan seed kalau ingin mereproduksi gambar.
- Diffusion lebih ramah pemula untuk eksplorasi, GAN menarik untuk memahami adversarial training.
- Jangan remehkan negative prompt — seringkali perbedaan antara gambar bagus dan sampah.
- Generative AI untuk audio dan video berkembang pesat; ini bukan hanya soal gambar.
Berikutnya saya mau coba ControlNet supaya pose karakter bisa dikontrol. Tapi itu cerita nanti — yang jelas, paham cara kerja GAN, VAE, dan diffusion membuat saya membaca demo AI di Twitter/X dengan mata yang lebih kritis.
Komentar Terbaru