‍

When discussing a GAN’s training, we refer to the training of the whole entity; however, a GAN is composed of two neural networks that are each trained alternately at different paces, in a setup where one neural network leverages the other’s feedback. Usually, the discriminator is trained for several epochs (training steps) before the generator effectuates one epoch. This allows the discriminator to always be a good classifier to facilitate the generator’s training.

In a GAN, the generator never actually sees the training data; it merely attempts to imitate the training data distribution.

First step: Set a loop where the discriminator is trained for several iterations (k > 1) to become a strong classifier. This helps ensure the discriminator can effectively guide the generator. A sample from the training dataset is fed to the discriminator, which learns to classify this sample as real.

Second step: A random vector with normal distribution is input into the generator, which outputs a random sample. Initially, this output is random because the generator has not yet learned to produce realistic data.

Third step: The generator's output is sent to the discriminator, which assesses whether the generated sample is real or fake. The discriminator outputs a probability value between 0 and 1, indicating how likely it believes the sample is real (closer to 1) or fake (closer to 0).

The generator's learning process depends on the discriminator's assessment of the samples it receives. The discriminator evaluates individual samples against the training data it has seen. If the generated sample is classified as fake, the generator is penalized; if classified as real, the generator is rewarded. Loss functions are generated for both networks: the generator aims to minimize its loss function, while the discriminator aims to maximize its own. Optimization is achieved through gradient descent via backpropagation applied separately to each network. This feedback helps the generator improve, enabling it to produce more realistic samples.

For each training step, the discriminator is trained first for several iterations before training the generator. This alternating training process ensures that each network improves iteratively while the other remains constant during its respective update phase.

Here’s a recap per neural network once the three first steps have been completed.

‍

Complete loop with discriminator training

The generator training is paused.

Data from the training dataset or produced by the generator is passed to the discriminator, which assesses the probability of it being real. Then, the discriminator’s loss function is computed and backpropagated via gradient descent. This updates the discriminator's parameters to improve its classification ability: if the discriminator had correctly labeled the data, its correct classification is reinforced, and if the discriminator labeled the data incorrectly, it is updated to better distinguish between real and artificial data, making it a better classifier for the next epoch.

‍

Focus on what’s happening in the discriminator

1. Data is received by the discriminator.
2. The discriminator examines the data and outputs a probability indicating whether the data is artificial (closer to 0) or real (closer to 1).
3. The loss function is computed based on the discriminator’s output versus the true label of the data (artificial or real).
4. Compute the gradient of the loss function with respect to the discriminator parameters and update the weights in the discriminator. Back to step 1.

‍

Complete loop with generator training

The discriminator training is paused.

The generator produces artificial data that is passed to the discriminator. The discriminator classifies the data received as real or artificial. The loss function of the generator is calculated based on the discriminator’s classification: if the discriminator identified the data as artificial, the generator's loss increases; if the discriminator was fooled and identified the data as real, the generator's loss decreases. This loss is then backpropagated via gradient descent. This process updates the generator's parameters, enabling it to produce more realistic data that is harder for the discriminator to distinguish from real data in the next epoch.

‍

Focus on what’s happening in the generator

1. The generator has its weights adjusted via gradient descent based on the discriminator's feedback.
2. It generates new data guided by this adjustment to better imitate the training data distribution.
3. This newly generated data is passed to the discriminator for classification.
4. Post-discriminator classification, the generator’s loss function is computed and backpropagated to the neural network via gradient descent. Back to step 1.