Debugging Unstable GAN Training

Training Generative Adversarial Networks, especially advanced architectures, often feels more like an art than a science. Despite utilizing sophisticated stabilization techniques like Wasserstein loss with gradient penalties or spectral normalization, you'll inevitably encounter situations where training goes awry. Practical strategies for diagnosing and addressing common instability issues encountered during the implementation and refinement of complex GANs are provided.

Debugging GANs requires patience and a systematic approach. Unlike standard supervised learning, where a monotonically decreasing loss often signals progress, GAN training involves a delicate balance between two competing networks. Success isn't guaranteed by simply watching loss values drop; you need to interpret the dynamics and critically evaluate the output.

Observing the Symptoms

The first step in debugging is recognizing the signs of trouble. Unstable training manifests in several ways:

1. Diverging Losses: Either the generator ($G$) or discriminator ($D$) loss explodes towards infinity, or oscillates wildly without any trend towards convergence. Sometimes, one loss plummets towards zero while the other increases indefinitely.
2. Mode Collapse: The generator produces an extremely limited variety of outputs, sometimes collapsing to a single, repetitive sample, regardless of the input noise vector $z$. The generated samples might look plausible individually, but diversity is nonexistent.
3. Vanishing or Exploding Gradients: Gradients flowing back through either network become extremely small (vanishing), preventing effective weight updates, or excessively large (exploding), leading to numerical instability (often resulting in NaN loss values).
4. No Convergence: Losses might remain relatively stable but show no improvement over extended training periods. Generated sample quality remains poor or doesn't progress.
5. Poor Sample Quality: Generated samples consistently exhibit unrealistic features, artifacts (like checkerboard patterns), noise, or lack coherence.

Diagnostic Tools and Techniques

Effective debugging relies on careful monitoring. Simply running model.fit() and hoping for the best is rarely sufficient for advanced GANs.

Monitoring Loss Curves

Plotting the generator and discriminator losses over time is the most basic diagnostic tool. However, interpreting these plots requires understanding the adversarial dynamic:

• Healthy Training (Idealized): Both $G$ and $D$ losses decrease initially and then ideally stabilize or oscillate within a bounded range, indicating equilibrium. The absolute values are less important than the trends and stability, especially with losses like Wasserstein distance.
• Discriminator "Wins" Too Easily: $D$ loss drops rapidly towards zero. This often means $D$ can perfectly distinguish real from fake samples, providing no useful gradient information back to $G$. $G$ loss might stagnate or increase.
• Generator "Wins": $D$ loss increases significantly or oscillates wildly. This might happen if $G$ produces samples that consistently fool $D$, or if $D$ fails to learn effectively.
• Mode Collapse Indication: $D$ loss might decrease significantly (as it easily distinguishes the few modes $G$ produces from real data), while $G$ loss might stagnate or even decrease slightly if it finds a mode that temporarily fools $D$.

Example loss curves illustrating healthy convergence versus a scenario where the discriminator loss rapidly drops, potentially hindering generator training.

Visual Inspection of Samples

Loss values alone are insufficient. Regularly generate a grid of samples using fixed noise vectors and random noise vectors throughout training.

• Fixed Noise: Helps assess if the generator is learning consistently over time for specific inputs.
• Random Noise: Helps evaluate the diversity of generated outputs. Look for signs of mode collapse (repeated images) or increasing visual fidelity.
• Interpolation: Generate samples by interpolating between two noise vectors $z_1$ and $z_2$ in the latent space. Smooth transitions suggest a well-behaved latent space; abrupt changes can indicate instability or entanglement (relevant for metrics like PPL discussed in Chapter 5).

Save sample grids periodically (e.g., every N epochs or M training steps) to track progress visually. This qualitative assessment is often more revealing than raw loss numbers.

Gradient and Weight Monitoring

Modern deep learning frameworks and tools like TensorBoard or Weights & Biases make it easy to monitor gradient statistics (norms, distributions) and weight distributions for each layer.

• Vanishing Gradients: Look for layers where the average gradient magnitude is consistently close to zero. This is particularly problematic for the generator if the discriminator provides weak signals.
• Exploding Gradients: Monitor for sudden spikes in gradient norms or the appearance of NaN values. This suggests numerical instability. Gradient clipping can be a temporary fix, but addressing the root cause (e.g., learning rate, normalization) is better. WGAN-GP and Spectral Normalization are specifically designed to mitigate issues related to gradients in the discriminator.
• Weight Norms: Track the norms of weight matrices. Techniques like Spectral Normalization directly constrain these. Unbounded growth in weights can be a sign of instability.

Common Failure Modes and Debugging Steps

Here's a breakdown of frequent issues and how to approach them:

Mode Collapse

• Symptoms: Low output diversity, repetitive samples. $D$ loss might be suspiciously low.
• Potential Fixes:
  • Loss Function: Ensure you're using a well-tuned loss like Wasserstein with a gradient penalty (WGAN-GP) or explore Relativistic GANs (Chapter 3). The original minimax or non-saturating loss are more prone to collapse.
  • Hyperparameters: Experiment with learning rates (TTUR might help), optimizer settings (AdamW instead of Adam), batch size.
  • Architecture: For some problems, older techniques like minibatch discrimination (less common now) or adding noise to discriminator inputs/outputs might help. Ensure generator capacity is sufficient.
  • Data Augmentation: Apply appropriate augmentation to real data.
  • Regularization: Increase the weight of the gradient penalty in WGAN-GP if using it.

Discriminator Overpowers Generator

• Symptoms: $D$ loss drops near zero, $G$ loss stagnates high or explodes. No learning occurs in $G$.
• Potential Fixes:
  • Training Ratio: Train $G$ more frequently than $D$ (e.g., 2 G updates per D update).
  • Learning Rates: Decrease $D$'s learning rate, potentially increase $G$'s (use TTUR principles).
  • Discriminator Capacity/Regularization: Simplify $D$'s architecture or increase its regularization (e.g., stronger weight decay, dropout - though less common with SN/GP). Ensure Spectral Normalization or Gradient Penalty is correctly implemented and applied.
  • Optimizer: Try different optimizers for $D$.

Generator Overpowers Discriminator

• Symptoms: $D$ loss increases, fails to decrease, or oscillates uncontrollably. $G$ might produce noise or nonsensical outputs.
• Potential Fixes:
  • Training Ratio: Train $D$ more frequently than $G$.
  • Learning Rates: Decrease $G$'s learning rate, potentially increase $D$'s.
  • Discriminator Capacity: Increase $D$'s complexity (more layers/filters) if it seems too simple to capture the real data distribution.
  • Loss Function Implementation: Double-check the $D$ loss calculation. Ensure real and fake batches are handled correctly.
  • Data Issues: Verify that real data is being fed correctly and is properly preprocessed.

General Instability / Non-Convergence

• Symptoms: Wildly oscillating losses, fluctuating sample quality, no clear progress.
• Potential Fixes:
  • Normalization: Ensure proper use of normalization layers (Batch Norm, Instance Norm, Layer Norm, or Spectral Norm in $D$). Be mindful of Batch Norm's potential issues with small batch sizes or conditional generation; alternatives like Instance Norm or Layer Norm might be better in some StyleGAN components.
  • Weight Initialization: Use appropriate initialization schemes (e.g., He initialization for ReLU/LeakyReLU). Re-run with different random seeds to check sensitivity.
  • Hyperparameters: This is often the culprit. Systematically tune learning rates, batch size, optimizer parameters (e.g., Adam betas $\beta_1, \beta_2$), and regularization strengths (gradient penalty coefficient).
  • Architecture Simplification: Temporarily simplify both $G$ and $D$ to see if a basic version can train stably.
  • Optimizer Choice: Experiment with AdamW, RMSprop, or even SGD with momentum, though Adam/AdamW are most common.

A Systematic Debugging Workflow

Avoid randomly changing parameters. Adopt a structured process:

A simplified workflow for debugging GAN training instability.

1. Establish a Baseline: Start with known good hyperparameters from literature or previous experiments if possible.
2. Monitor Extensively: Log losses, generate sample grids, and ideally monitor gradients/weights from the beginning.
3. Identify the Primary Symptom: What is the most obvious failure mode? (e.g., Mode collapse? Exploding $G$ loss?)
4. Formulate a Hypothesis: Based on the symptoms and your understanding of GAN dynamics, guess the likely cause (e.g., "Discriminator learning rate is too high, causing it to overpower the generator").
5. Change One Thing: Modify only one element based on your hypothesis (e.g., halve the discriminator learning rate).
6. Retrain and Compare: Run the training again for a sufficient duration and compare the monitoring outputs (losses, samples) to the baseline.
7. Evaluate: Did the change improve stability or address the symptom? If yes, keep the change and continue refining or address the next issue. If no, revert the change and formulate a new hypothesis.
8. Document: Keep careful records of your experiments, including hyperparameters, code versions, observed results, and generated samples.

Debugging GANs is an iterative process that blends theoretical understanding with empirical investigation. By carefully observing training dynamics, using appropriate diagnostic tools, and applying systematic changes, you can navigate the complexities and build stable, high-performing generative models.