GANs (Generative Adversarial Networks)

Two networks competing to create realistic data.

What are GANs?

Generator creates fake data, Discriminator judges if it's real.

Idea: They improve each other through competition!

How GANs Work

Generator: Creates fake images
Discriminator: Detects real vs fake
Training: Generator tries to fool Discriminator

Simple GAN Example

import tensorflow as tf
from tensorflow import keras

# Generator model
def make_generator():
    model = keras.Sequential([
        keras.layers.Dense(256, activation='relu', input_dim=100),
        keras.layers.Dense(512, activation='relu'),
        keras.layers.Dense(1024, activation='relu'),
        keras.layers.Dense(784, activation='sigmoid')  # 28x28 image
    ])
    return model

# Discriminator model
def make_discriminator():
    model = keras.Sequential([
        keras.layers.Dense(1024, activation='relu', input_dim=784),
        keras.layers.Dropout(0.3),
        keras.layers.Dense(512, activation='relu'),
        keras.layers.Dropout(0.3),
        keras.layers.Dense(256, activation='relu'),
        keras.layers.Dense(1, activation='sigmoid')  # Real or Fake
    ])
    return model

generator = make_generator()
discriminator = make_discriminator()

# Compile
discriminator.compile(optimizer='adam', loss='binary_crossentropy')

Training GANs

import numpy as np

# Prepare real data (example with MNIST)
(X_train, _), (_, _) = keras.datasets.mnist.load_data()
X_train = X_train.reshape(-1, 784) / 255.0

batch_size = 128
epochs = 10000

for epoch in range(epochs):
    # Train Discriminator
    # 1. Real images
    idx = np.random.randint(0, X_train.shape[0], batch_size)
    real_images = X_train[idx]
    real_labels = np.ones((batch_size, 1))
    
    # 2. Fake images
    noise = np.random.normal(0, 1, (batch_size, 100))
    fake_images = generator.predict(noise)
    fake_labels = np.zeros((batch_size, 1))
    
    # Train discriminator
    d_loss_real = discriminator.train_on_batch(real_images, real_labels)
    d_loss_fake = discriminator.train_on_batch(fake_images, fake_labels)
    
    # Train Generator
    noise = np.random.normal(0, 1, (batch_size, 100))
    misleading_labels = np.ones((batch_size, 1))  # Fool discriminator!
    
    # Combined model
    discriminator.trainable = False
    combined = keras.Sequential([generator, discriminator])
    combined.compile(optimizer='adam', loss='binary_crossentropy')
    g_loss = combined.train_on_batch(noise, misleading_labels)
    discriminator.trainable = True
    
    if epoch % 1000 == 0:
        print(f"Epoch {epoch}, D Loss: {(d_loss_real + d_loss_fake)/2:.4f}, G Loss: {g_loss:.4f}")

Types of GANs

DCGAN: Uses convolutional layers
StyleGAN: High-quality face generation
CycleGAN: Image-to-image translation
Pix2Pix: Paired image translation

Applications

• Generate realistic faces
• Create art and designs
• Data augmentation
• Image enhancement

Remember

• GANs are hard to train (unstable)
• Require lots of data and compute
• Generator and Discriminator must balance
• Used for creative AI applications