The Discriminator and Generator Loop

GAN training alternates updates between the discriminator and generator to maintain stability in their adversarial game.

Adversarial training is formulated as a sequential optimization process rather than a joint minimization. If we update both the generator and discriminator simultaneously, the parameters can oscillate, leading to training instability. To prevent this, we alternate updates. In each iteration, we first freeze the generator parameters and update the discriminator using a batch of real and generated images. This step improves the discriminator's ability to classify samples.

Next, we freeze the discriminator parameters and update the generator. The generator uses the frozen discriminator to evaluate its generated samples, backpropagating the classification error to update its own weights. In some implementations, the discriminator is updated for multiple steps (e.g., \\( k = 5 \\) steps) for every single generator update, ensuring that the generator receives high-quality feedback from an accurate discriminator.

Understanding gradient propagation in the alternating loop is essential for debugging. When updating the discriminator, gradients propagate through the discriminator network to update its weights, while gradient flow is stopped at the generator's outputs using the .detach() operation in PyTorch. This saves memory and prevents the generator's weights from being updated by the discriminator's objective.

When updating the generator, we pass the noise vector through the generator and pass the output through the discriminator. We compute the loss on the discriminator's classification scores, but we freeze the discriminator's weights. The gradients propagate backward through the discriminator layers without updating them, flowing into the generator's layers to update the generator's parameters. This gradient path is what allows the generator to learn how to fool the discriminator.

A detailed PyTorch training loop shows how to implement alternating optimizer steps and manage gradient detached states.

The following PyTorch training loop demonstrates the execution flow, tracking loss metrics and managing backpropagation steps:

In this training loop, it is crucial to verify tensor shapes. The noise vector z has shape [batch_size, latent_dim]. The generator outputs fake_imgs of shape [batch_size, img_dim]. The discriminator processes both real and fake images, outputting scalar scores of shape [batch_size, 1] representing probabilities.

Using fake_imgs.detach() during the discriminator update prevents PyTorch from allocating memory for the generator's computational graph. During the generator update, we pass the undetached fake_imgs to the discriminator, which retains the generator's graph and allows gradients to flow back through the discriminator to the generator weights.

GAN training is prone to pathologies like mode collapse and discriminator overpowering, which require architectural mitigations.

Mode collapse is a common training failure where the generator learns to output samples from only a few limited classes (modes) of the data, ignoring the rest of the distribution. For example, if trained on the MNIST digit dataset, a collapsed generator might only produce highly realistic "8"s, failing to generate any other digits. This occurs because the generator finds a single output type that consistently fools the discriminator, and the optimization objective does not penalize a lack of diversity.

If the discriminator adjusts to penalize this mode, the generator may shift to producing only "1"s, leading to cyclic oscillations. Mitigations for mode collapse include using Wasserstein GAN (WGAN) objectives, which measure distance using Earth Mover's Distance, or incorporating minibatch discrimination layers that allow the model to evaluate the diversity of a batch directly.

Another common pathology is discriminator overpowering. If the discriminator learns to distinguish real from fake samples too quickly, the discriminator's outputs for all generated samples will be 0. Because the discriminator is highly confident, the loss curve becomes flat, and the gradients with respect to the generator weights vanish. The generator stops learning.

To prevent this, the network architectures must be balanced. If the discriminator is too strong, we can reduce its learning rate, apply dropout, or use labels with noise injection (label smoothing) to reduce its confidence. Label smoothing replaces target values of 1 and 0 with 0.9 and 0.1, preventing the discriminator from outputting extreme logits that saturate gradients.