In a generative adversarial network, two networks are trained together in competition. What is the specific job of the generator network in this setup?
Select an answer to reveal the explanation.
Short Explanation
Picture a forger and an art inspector locked in a rivalry. The generator is the forger — its whole job is to take random noise and turn it into fake data instances (images, audio, whatever the domain is) that look like they came from the real training set. It never sees real labels or 'real vs. fake' judgments directly; it only gets better because the discriminator keeps telling it 'not convincing enough.' Classifying real vs. fake is the discriminator's job, not the generator's. Compressing data into a latent code sounds like an autoencoder's encoder, not a GAN generator (though a generator does take a latent vector as input, it maps it forward into new data, not the other direction). And no, it's not managing anyone's learning rate — that's an optimizer's job.
Full Explanation
In a GAN, the generator network's role is to synthesize new data instances that mimic the statistical distribution of the training data, typically by mapping a random noise vector (sampled from a simple distribution like a Gaussian) through a series of learned transformations into the target data space — for example, generating a realistic-looking image from random noise. The generator never directly observes labeled 'real' vs. 'fake' examples; instead, it learns indirectly through the adversarial signal: the discriminator's feedback on how convincing its outputs are, backpropagated to improve the generator's parameters.
The first distractor — classifying real vs. synthetic — is the discriminator's job. The discriminator is a binary classifier trained to distinguish genuine training samples from the generator's output, and the two networks are trained in opposition (hence 'adversarial'). The second distractor describes the encoder half of an autoencoder or VAE, which maps input data down into a compressed latent representation; a GAN generator does the reverse — it maps FROM a latent vector INTO data space, so confusing the direction is a common exam trap. The fourth distractor invents a nonexistent responsibility; learning-rate scheduling is handled by the training loop or optimizer (e.g., Adam), not by either network in the GAN itself.
Memory aid: 'Generator generates, Discriminator discriminates.' The generator's success is measured by how often it fools the discriminator, and at convergence (in the ideal case) the generator produces samples indistinguishable from real data, and the discriminator's accuracy drops to chance (50%).
In practice, the two networks are trained in alternating steps within the same loop: the discriminator is updated to get better at spotting fakes, then the generator is updated to produce outputs that push the discriminator's real-vs-fake judgment closer to 'real.' This minimax dynamic is what makes GAN training notoriously sensitive to hyperparameters and prone to instability, including failure modes like mode collapse, where the generator learns to produce only a narrow slice of the data distribution because it found a small set of outputs that reliably fool the current discriminator. Understanding that the generator's only objective is to produce convincing new instances — never to judge, compress, or tune anything — is the key distinction the exam is testing.