GANs — Generative Adversarial Networks

GANs (Goodfellow, 2014) train a Generator and Discriminator in an adversarial game: Generator produces fake images trying to fool the Discriminator, which tries to distinguish real from fake. Diffusion models now dominate for image quality, but GANs are still faster for inference and used in real-time video and style transfer.

20 min•By Priygop Team•Updated 2026

GAN Architecture and Training

import torch
import torch.nn as nn
import torch.optim as optim

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# DCGAN -- Deep Convolutional GAN (standard baseline)
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

class Generator(nn.Module):
    '''Maps random noise z to fake image. z: [B, latent_dim] -> image: [B, C, H, W]'''
    def __init__(self, latent_dim: int = 100, channels: int = 3, image_size: int = 64):
        super().__init__()
        ngf = 64  # number of generator filters
        self.net = nn.Sequential(
            # Upsample from latent to spatial: z[B,100] -> feature maps
            nn.ConvTranspose2d(latent_dim, ngf * 8, 4, 1, 0, bias=False),  # [B, 512, 4, 4]
            nn.BatchNorm2d(ngf * 8), nn.ReLU(inplace=True),
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),    # [B, 256, 8, 8]
            nn.BatchNorm2d(ngf * 4), nn.ReLU(inplace=True),
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),    # [B, 128, 16, 16]
            nn.BatchNorm2d(ngf * 2), nn.ReLU(inplace=True),
            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),         # [B, 64, 32, 32]
            nn.BatchNorm2d(ngf), nn.ReLU(inplace=True),
            nn.ConvTranspose2d(ngf, channels, 4, 2, 1, bias=False),         # [B, 3, 64, 64]
            nn.Tanh(),  # output in [-1, 1]
        )

    def forward(self, z: torch.Tensor) -> torch.Tensor:
        return self.net(z.view(-1, 100, 1, 1))

class Discriminator(nn.Module):
    '''Classifies real vs fake. image: [B, C, H, W] -> [B, 1] (real probability)'''
    def __init__(self, channels: int = 3):
        super().__init__()
        ndf = 64
        self.net = nn.Sequential(
            nn.Conv2d(channels, ndf, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf, ndf*2, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf*2), nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf*2, ndf*4, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf*4), nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf*4, ndf*8, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf*8), nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf*8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid(),
        )

    def forward(self, img: torch.Tensor) -> torch.Tensor:
        return self.net(img).flatten(1)

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# GAN TRAINING LOOP
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
device = "cuda" if torch.cuda.is_available() else "cpu"
G = Generator().to(device)
D = Discriminator().to(device)

# Separate optimizers for G and D -- different learning rates
opt_G = optim.Adam(G.parameters(), lr=2e-4, betas=(0.5, 0.999))  # beta1=0.5 critical!
opt_D = optim.Adam(D.parameters(), lr=2e-4, betas=(0.5, 0.999))
loss_fn = nn.BCELoss()

def gan_train_step(real_images: torch.Tensor) -> dict:
    B = real_images.size(0)
    real_labels = torch.ones(B, 1, device=device)    # real = 1
    fake_labels = torch.zeros(B, 1, device=device)   # fake = 0

    # --- TRAIN DISCRIMINATOR ---
    z = torch.randn(B, 100, device=device)
    fake_images = G(z).detach()  # .detach() so G doesn't get D's gradients

    real_loss = loss_fn(D(real_images), real_labels)
    fake_loss = loss_fn(D(fake_images), fake_labels)
    d_loss = (real_loss + fake_loss) / 2

    opt_D.zero_grad(); d_loss.backward(); opt_D.step()

    # --- TRAIN GENERATOR ---
    z = torch.randn(B, 100, device=device)
    fake_images = G(z)
    g_loss = loss_fn(D(fake_images), real_labels)  # G wants D to say "real"

    opt_G.zero_grad(); g_loss.backward(); opt_G.step()

    return {"d_loss": d_loss.item(), "g_loss": g_loss.item()}

# GAN training instabilities and fixes:
gan_problems = {
    "Mode collapse":        "G produces only a few image types. Fix: Minibatch discrimination, Wasserstein loss",
    "Training instability": "D loss -> 0 or G loss diverges. Fix: Spectral normalization on D, gradient penalty",
    "Vanishing gradients":  "G gets no signal when D is too strong. Fix: Label smoothing, one-sided label smoothing",
}
print("GAN common issues:")
for problem, fix in gan_problems.items():
    print(f"  {problem:25s}: {fix}")

Tip

Practice GANs Generative Adversarial Networks in small, isolated examples before integrating into larger projects. Breaking concepts into small experiments builds genuine understanding faster than reading alone.

Diagram

Loading diagram…

Technical diagram.

Practice Task

Note

Practice Task — (1) Write a working example of GANs Generative Adversarial Networks from scratch without looking at notes. (2) Modify it to handle an edge case (empty input, null value, or error state). (3) Share your solution in the Priygop community for feedback.

Quick Quiz

Common Mistake

Warning

A common mistake with GANs Generative Adversarial Networks is skipping edge case testing — empty inputs, null values, and unexpected data types. Always validate boundary conditions to write robust, production-ready ai code.

Topics in This Module