Back to Articles Generative AI • 17 min read

GANs: How AI Generates Realistic Images from Scratch

In 2014, Ian Goodfellow and colleagues published a paper that would become one of the most cited in AI history — introducing Generative Adversarial Networks (GANs). The idea was startling in its simplicity: pit two neural networks against each other in a game, and watch them collectively produce outputs indistinguishable from reality. Today, GANs generate photorealistic human faces, compose original artwork, synthesize medical imaging data, and drive the AI art revolution.

"The most interesting idea in the last ten years in machine learning." — Yann LeCun on GANs

---

1. The Generator vs. Discriminator Game

A GAN consists of two competing neural networks:

This adversarial setup is formalized as a minimax game:

The Discriminator maximizes this objective (better at detecting fakes). The Generator minimizes it (better at fooling the Discriminator). At Nash equilibrium, G produces samples that D cannot distinguish from real with better than 50% accuracy — random guessing.

---

2. Training Walkthrough

1. Sample real data — draw a batch of real images from the training dataset.
2. Generate fakes — sample random noise vectors z and pass through G to create fake images.
3. Train D — maximize D's ability to classify real as 1 and fake as 0. Update D's weights via backprop.
4. Train G — freeze D, generate new fakes, compute D's output on them, and backpropagate the fooling loss into G's weights.
5. Repeat — alternate thousands of times until G produces convincing outputs.

import torch
import torch.nn as nn

# Minimal Generator
class Generator(nn.Module):
    def __init__(self, noise_dim=100, img_dim=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(noise_dim, 256), nn.ReLU(),
            nn.Linear(256, 512),       nn.ReLU(),
            nn.Linear(512, img_dim),   nn.Tanh()
        )
    def forward(self, z):
        return self.net(z)

# Minimal Discriminator
class Discriminator(nn.Module):
    def __init__(self, img_dim=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(img_dim, 512), nn.LeakyReLU(0.2),
            nn.Linear(512, 256),     nn.LeakyReLU(0.2),
            nn.Linear(256, 1),       nn.Sigmoid()
        )
    def forward(self, x):
        return self.net(x)
            

---

3. GAN Variants Timeline

Year	Model	Innovation
2014	Original GAN	Adversarial training concept introduced.
2015	DCGAN	Deep Convolutional GAN. Used conv layers for stable image generation.
2017	Progressive GAN	NVIDIA's method of growing both G and D progressively from low to high resolution.
2018	StyleGAN	Style-based generator enabling per-level style control. Powered thispersondoesnotexist.com.
2021	StyleGAN3	Alias-free generation; eliminated texture sticking artifacts.
2022+	Diffusion Models	Gradually replaced GANs for highest-quality synthesis (DALL-E 2, Stable Diffusion).

---

4. Real-World Applications

• Medical imaging: GANs synthesize rare medical scans to augment training data for diagnostic models, without exposing real patient data.
• Fashion design: Brands use GANs to generate thousands of novel garment designs for rapid prototyping.
• Video game asset generation: Texture synthesis and character face generation at zero marginal cost.
• Data augmentation: Generating synthetic labeled training data for object detectors when real data is scarce.
• Deepfake detection: Ironically, discriminators trained within GAN frameworks make the best deepfake detectors.

While GANs have been significantly challenged by diffusion models in raw quality benchmarks, they remain faster to sample from and easier to condition, keeping them highly relevant in real-time and resource-constrained applications.