Lecture 17: Generative Adversarial Networks Implementation

What this lecture covers

This is the implementation companion to the previous lecture on generative adversarial networks. Using the needle deep learning framework built earlier in the course, the instructor codes a GAN that learns to generate samples from a 2D Gaussian distribution, first with an explicit alternating training loop, then refactored so the GAN mechanism behaves like a reusable loss module.

After watching, you should be able to write generator and discriminator update functions in needle, understand how detaching the generator's output during the discriminator update prevents unwanted gradient flow, and see how a GAN can be repackaged as a forward-style loss module for use in a standard training loop.

Key ideas

• Target distribution: the example task is fitting a linear generator (a single 2x2 matrix and bias) to match a 2D Gaussian created by transforming random noise with a fixed matrix and mean.
• updateG: generates fake data from noise, passes it through the discriminator, computes a loss that treats the fake data as label 1 (real), and backpropagates only through the generator's optimizer.
• updateD: generates fake data with .detach() so no gradient flows back into the generator, scores both fake (label 0) and real (label 1) batches through the discriminator, sums the two losses, and steps the discriminator's optimizer.
• Softmax loss as binary classification: because the course's framework only implements softmax loss, a two-class softmax is used in place of a dedicated binary cross-entropy loss.
• Training loop: alternates a discriminator update and a generator update on each mini-batch, cycling through the training data across epochs.
• Modularized GAN loss: wrapping the discriminator, its loss, and its optimizer inside a single object whose forward method updates the discriminator internally and returns the generator's loss turns GAN training into something that looks like an ordinary supervised training loop.
• Verifying the fit: after training, the generator's learned matrix and bias are compared to the true covariance and mean of the target distribution to confirm the model has converged, even though the learned matrix itself need not exactly match the original transform matrix.

Walkthrough

Setting up the target distribution and generator (2:01)

The instructor samples 2D Gaussian data by transforming random noise with a fixed matrix and mean, and defines a generator as a single linear layer with a 2x2 weight matrix. A sampling function maps random noise through the generator, and plotting the untrained generator's output against the real data shows the two distributions do not yet match.

Discriminator and generator update functions (7:17)

A three-layer discriminator network is defined, using softmax loss for the binary real-versus-fake classification. The updateG function generates fake data, scores it through the discriminator, and computes a loss that pushes the discriminator to label it as real, updating only the generator. The updateD function generates fake data with the generator's output detached, scores both fake and real batches, sums their losses, and updates only the discriminator.

Training loop and results (18:45)

A train_GAN function cycles through mini-batches of the data, generating random noise for each batch and calling the generator update followed by the discriminator update, repeated over many epochs. Plotting the trained generator's output against the real data shows the generated distribution has moved close to the target, and comparing the learned matrix's covariance and mean to the original transform confirms the fit, even though the raw matrix values differ.

Modularizing GAN training as a loss (25:47)

The lecture rebuilds the same mechanism as a GANLoss module that stores the discriminator, its loss function, and its optimizer. Its forward method performs the discriminator update internally (using detached fake data and labeled real data) and then returns the generator-facing loss for the current batch, so the outer training loop looks like an ordinary supervised loop calling loss.backward() and opt.step().

Before you watch

• Watch the previous lecture, "Generative Adversarial Networks," which introduces the minimax objective and adversarial training mechanism implemented here.
• Be familiar with the needle framework's nn.Module, nn.Sequential, and optimizer interfaces from earlier homework.

Check your understanding

1. Why does updateD call .detach() on the generator's output, while updateG does not?
2. Why does the lecture use softmax loss instead of a dedicated binary classification loss?
3. What is the practical benefit of wrapping the discriminator update inside a GANLoss module's forward method?
4. Why can the learned generator matrix differ from the original data-generating matrix even when the fit looks correct?