Generative Adversarial Networks (GANs)

GANs generate data so realistic that humans can't tell it's fake. They do this through an adversarial game between two networks.

The Game

**Generator (G):** Creates fake data from random noise **Discriminator (D):** Tries to distinguish real from fake

They compete: - G tries to fool D - D tries to catch G

As they improve, G generates increasingly realistic data.

``` Random Noise ──> [Generator] ──> Fake Image │ [Discriminator] ──> Real or Fake? │ Real Image ─────────────────────────┘ ```

Simple GAN Implementation

```python import tensorflow as tf from tensorflow.keras.layers import Dense, LeakyReLU, BatchNormalization, Reshape, Flatten from tensorflow.keras.models import Sequential

Generator: noise -> image def build_generator(latent_dim): model = Sequential([ Dense(256, input_dim=latent_dim), LeakyReLU(0.2), BatchNormalization(), Dense(512), LeakyReLU(0.2), BatchNormalization(), Dense(1024), LeakyReLU(0.2), BatchNormalization(), Dense(784, activation='tanh'), Reshape((28, 28, 1)) ]) return model

Discriminator: image -> real/fake def build_discriminator(): model = Sequential([ Flatten(input_shape=(28, 28, 1)), Dense(512), LeakyReLU(0.2), Dense(256), LeakyReLU(0.2), Dense(1, activation='sigmoid') ]) return model

latent_dim = 100 generator = build_generator(latent_dim) discriminator = build_discriminator() ```

Training Loop

```python cross_entropy = tf.keras.losses.BinaryCrossentropy() g_optimizer = tf.keras.optimizers.Adam(1e-4) d_optimizer = tf.keras.optimizers.Adam(1e-4)

@tf.function def train_step(real_images): batch_size = tf.shape(real_images)[0] noise = tf.random.normal([batch_size, latent_dim]) with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape: # Generate fake images fake_images = generator(noise, training=True) # Discriminator predictions real_output = discriminator(real_images, training=True) fake_output = discriminator(fake_images, training=True) # Losses d_loss_real = cross_entropy(tf.ones_like(real_output), real_output) d_loss_fake = cross_entropy(tf.zeros_like(fake_output), fake_output) d_loss = d_loss_real + d_loss_fake g_loss = cross_entropy(tf.ones_like(fake_output), fake_output) # Update weights d_gradients = disc_tape.gradient(d_loss, discriminator.trainable_variables) g_gradients = gen_tape.gradient(g_loss, generator.trainable_variables) d_optimizer.apply_gradients(zip(d_gradients, discriminator.trainable_variables)) g_optimizer.apply_gradients(zip(g_gradients, generator.trainable_variables)) return g_loss, d_loss ```

Common GAN Variants

| Type | Use Case | |------|----------| | DCGAN | Images using convolutions | | StyleGAN | High-quality face generation | | CycleGAN | Image-to-image translation | | Pix2Pix | Paired image translation | | WGAN | More stable training |

Training Challenges

GANs are notoriously hard to train:

1. **Mode Collapse:** Generator produces limited variety 2. **Training Instability:** D or G dominates 3. **Vanishing Gradients:** G can't learn when D is too good

Practical Tips

```python # Tips for stable training:

1. Use labels wisely (label smoothing) real_labels = 0.9 # Not 1.0 fake_labels = 0.0

2. Add noise to discriminator inputs noisy_real = real_images + 0.1 * tf.random.normal(tf.shape(real_images))

3. Train D more often than G for _ in range(2): # Train D twice train_discriminator(real_images) train_generator()

4. Use spectral normalization from tensorflow_addons.layers import SpectralNormalization Dense = SpectralNormalization(Dense(256)) ```

Applications

- Face generation and editing - Image super-resolution - Data augmentation - Art creation - Video generation - Drug discovery

Key Takeaway

GANs learn to generate data through adversarial training between generator and discriminator. They produce amazingly realistic images but are tricky to train. Start with DCGAN for images, use established architectures, and monitor both losses carefully. For production use, consider pre-trained StyleGAN models.