What is a conditional GAN?

A conditional generative adversarial network (conditional GAN or cGAN) is a GAN that learns to generate examples based on a requested condition, such as an object class, attribute, or other side information. The core change is simple: both the generator and the discriminator receive the same condition. Mirza and Osindero introduced this approach in *Conditional Generative Adversarial Nets* (2014).

Conditional GAN versus ordinary GAN

• Unconditional GAN: The generator receives random noise z and creates G(z). It can learn a mixture of cats and dogs, but there is no explicit class input telling it which one to produce.
• Conditional GAN: The generator receives random noise and a condition y, producing G(z,y). For example, request y = cat to generate a cat, or y = dog to generate a dog.
• Unconditional discriminator: Evaluates whether an image looks real: D(x).
• Conditional discriminator: Receives the image and its proposed condition together: D(x,y). It learns whether the pair is plausible under the real training distribution.
• What is modeled? An ordinary GAN aims to match p_data(x); a cGAN aims to match `p_data(x|y)` for each condition, given suitable labeled data and sufficient training.

Key distinction: The condition provides the target *kind* of output; the noise provides randomness so the model can generate different examples within that same kind. Supplying the same noise with different labels does not guarantee that every other visual attribute will be preserved.

How does conditional GAN training work?

1. Prepare labeled examples: Training data contain pairs (x_real, y), such as a photograph of a cat and the label cat.
2. Sample a condition: Choose a label y from the training label distribution or a deliberately balanced sampling policy.
3. Sample noise: Draw a random latent vector z, independent of the label.
4. Generate a conditioned image: Combine z with the label and compute x_fake = G(z,y).
5. Train the discriminator: Show it real pairs (x_real,y) and generated pairs (x_fake,y). Update it to assign higher realness scores to real pairs than fake pairs.
6. Train the generator: Update G so the discriminator gives higher realness scores to its generated image–label pairs, while the generator remains sensitive to noise.
7. Generate on demand: At inference, select a desired condition and draw fresh noise values to obtain different candidate outputs for that condition.

Simple workflow: noise z + condition y → Generator G(z,y) → generated image x_fake, followed by (image, condition y) → Discriminator D(x,y) → real/fake score.

Beginner-friendly practical example: Generate cats or dogs on request

Suppose a small dataset has 50 cat photos and 50 dog photos. The model uses a two-dimensional random noise vector and one-hot encoded class labels.

Step 1 — Encode the requested class.

• Cat condition: y_cat = [1,0].
• Dog condition: y_dog = [0,1].
• Choose one illustrative noise vector: z = [0.2, −0.4].

Step 2 — Give the class to the generator.

Using the simplest concatenation approach:

• Cat generator input: concat(z,y_cat) = [0.2, −0.4, 1, 0].
• Dog generator input: concat(z,y_dog) = [0.2, −0.4, 0, 1].

The input has 2 noise values + 2 class values = 4 numbers. A successfully trained generator might output a cat for the first input and a dog for the second. These outputs are hypothetical; concatenating values alone does not create those images without learning.

Step 3 — Give the class to the discriminator too.

• Correct real pair: D(real_cat_image, y_cat).
• Generated pair: D(G(z,y_cat), y_cat).
• For dog training, use the corresponding dog label on both real and generated pairs.

This is what makes the adversarial game conditional: the discriminator can learn whether the generated image fits the requested class, not only whether it resembles a photograph in general.

Important caveat: The original cGAN objective uses matching real pairs and generated pairs with requested labels. Deliberately adding a mismatched real pair such as (real_cat_image,y_dog) as an extra negative example is an optional training extension, not an obligatory part of every cGAN.

Small numerical example: Conditional adversarial loss

For a toy cat-label training step, assume a sigmoid discriminator gives:

• D(real_cat, y_cat) = 0.9.
• D(fake_cat_request, y_cat) = 0.2.

Here 0.2 is the discriminator's realness score for the generated image paired with the cat condition, not a measured probability that the image is a cat.

Step 1 — Train the discriminator.

Using equally weighted binary cross-entropy terms averaged over one real and one fake example:

L_D = −[ln D(real_cat,y_cat) + ln(1−D(fake_cat_request,y_cat))]/2

L_D = −[ln(0.9) + ln(0.8)]/2 ≈ 0.1643

Smaller discriminator loss means these two labeled real/fake decisions were scored better in this toy step.

Step 2 — Train the generator using the common non-saturating objective.

L_G = −ln D(G(z,y_cat),y_cat) = −ln(0.2) ≈ 1.6094

The generator attempts to make the discriminator assign its generated, cat-labeled pair a higher realness score. This non-saturating generator objective is common in implementations; the original minimax form expresses the same conditional adversarial setup with a different generator optimization form.

Step 3 — Imagine generator improvement at a fixed discriminator.

If the score on the generated cat-labeled pair rises to 0.8, then:

L_G,new = −ln(0.8) ≈ 0.2231.

The generator loss falls from 1.6094 to 0.2231 in this illustrative comparison. This is not evidence by itself that the new image really depicts a cat; assess actual condition correctness separately.

How do we evaluate condition fidelity and diversity?

A conditional generator has two important responsibilities: obey the condition and produce varied plausible examples.

Suppose we request 100 cats and 100 dogs, using different noise vectors for each request:

• 100 cat requests: A reliable evaluator identifies 90 cats and 10 wrong-class images. Cat-condition fidelity = 90/100 = 90%.
• 100 dog requests: The evaluator identifies 85 dogs and 15 wrong-class images. Dog-condition fidelity = 85/100 = 85%.
• Overall condition accuracy: (90+85)/200 = 175/200 = 87.5%.

These results are invented for explanation, and depend on an accurate label evaluator or human annotation.

Condition accuracy is not enough: If all 90 valid cat images depict the *same cat in the same pose*, condition accuracy may be high while within-cat diversity is poor. Test variation in pose, color, background and identity within each requested class, as well as image realism and coverage of rare styles.

Applications and benefits

• Class-controlled image synthesis: Request a particular digit, object or visual category. The original cGAN paper demonstrated label-conditioned MNIST digit generation.
• Attribute-controlled generation: Condition on a known category or property when trustworthy labels and suitable architecture are available.
• Synthetic-data augmentation: Generate additional labeled candidates for underrepresented classes, but validate their labels, realism, independence and downstream effects before adding them to training.
• Other side information: Conditions can be metadata, text representations or images; the method of injecting a condition into the networks depends on the architecture.

Benefits: More control than unconditional random generation, ability to model distinct conditional distributions, and multiple outputs from different noise values for one condition.

Limitations and practical considerations

• Requires meaningful condition data: The model cannot reliably generate a new class simply because a label is provided; it must learn that class from suitable examples.
• Ignoring the condition: The generator or discriminator may underuse y, especially if the class is imbalanced or the network can succeed using shortcuts. Inspect outputs per class.
• Poor diversity within a label: Even if classes are correct, repeated poses or prototypes can indicate a conditional diversity failure. Revisit noise use, dataset coverage and adversarial training.
• Imbalanced or noisy labels: Sampling may overrepresent frequent classes, and incorrect training labels can confuse the conditional relationship.
• Discriminator shortcut risks: The discriminator may rely on simple artifacts or label correlations instead of judging meaningful image–condition compatibility.
• Implementation: One-hot concatenation is easy for a few classes; label embeddings and conditional network layers are common for larger problems. Match batch labels precisely, and provide the same requested label to the generator and discriminator for generated pairs.
• Evaluation: Track per-class fidelity, diversity, image quality and coverage. A low adversarial loss is not a guarantee of usefulness or fairness.

Curriculum boundary: Questions 280–283 covered GAN mode collapse, WGAN, gradient penalty and spectral normalization. This question focuses on conditioning both GAN networks. Question 285, “How do Pix2Pix and CycleGAN differ?”, will explain those specific image-translation approaches separately.

Key takeaway: A conditional GAN learns to generate `G(z,y)` by showing the generator and discriminator the condition `y`; it enables requested classes while still needing careful evaluation of label fidelity and within-class diversity.

Research: Mirza & Osindero, *Conditional Generative Adversarial Nets* (2014); Goodfellow et al., *Generative Adversarial Nets* (2014).