Generative Adversarial Networks

Most models learn from a fixed dataset and a fixed loss function that never changes during training. A generative adversarial network (GAN) does something stranger: it sets up a contest between two networks whose losses are each other's problem, and lets that contest itself do the training.

Picture a forger and an appraiser locked in a loop. The forger paints a fake, the appraiser inspects it and says real or fake, and both learn from the outcome — the forger studies what gave it away and paints a better fake next time, the appraiser studies what fooled them and sharpens their eye next time. Neither one ever sees a rulebook for "what makes a good painting"; both improve purely by competing against an opponent who is also improving. Run that loop long enough and the forger's fakes become good enough that the appraiser is reduced to guessing.

The mechanics, one symbol at a time

The generator $G$ takes random noise $z$ (just a vector of random numbers, the raw material it sculpts into a fake) and produces a fake sample $G(z)$. The discriminator $D$ takes a sample — real or fake — and outputs a number between 0 and 1, its estimate of the probability the sample is real. They're trained on opposing objectives:

$$\min_G \max_D \; \mathbb{E}[\log D(x)] + \mathbb{E}[\log(1 - D(G(z)))]$$

In words: the discriminator $D$ wants to maximize this expression — assign real data $x$ a high probability of being real ($D(x)$ close to 1, making $\log D(x)$ close to 0, its best case) and assign generated fakes $G(z)$ a low probability of being real ($D(G(z))$ close to 0, making $\log(1-D(G(z)))$ close to 0 too). The generator $G$ wants to minimize the same expression, which it can only do by making $D(G(z))$ close to 1 — fooling the discriminator into thinking its fakes are real. Training alternates: hold $G$ fixed and update $D$ to get better at catching the current fakes, then hold $D$ fixed and update $G$ to get better at fooling the current discriminator, back and forth.

Worked example 1: one discriminator update, scored

A discriminator sees a batch of one real sample and one fake sample. On the real sample $x$, it outputs $D(x) = 0.6$ (60% confident it's real — a middling call). On the fake $G(z)$, it outputs $D(G(z)) = 0.7$ (70% confident the fake is real — it's actually being fooled here).

Discriminator's loss contribution: $-[\log(0.6) + \log(1-0.7)] = -[\log(0.6) + \log(0.3)] = -[-0.511 + (-1.204)] = 1.715$.

Compare to a discriminator doing its job well: $D(x) = 0.95$, $D(G(z)) = 0.05$. Loss: $-[\log(0.95) + \log(0.95)] = -[-0.051 + -0.051] = 0.103$, much lower. The gradient computed from the first, higher-loss scenario pushes the discriminator's weights toward being more skeptical of samples like that particular fake — sharpening exactly the blind spot the generator just exploited.

Worked example 2: the generator exploiting that same blind spot

Continue from the first discriminator above, which currently rates the fake $G(z)$ at $D(G(z)) = 0.7$ — already fooling it more than half the time. The generator's loss (in the common practical form, maximize $\log D(G(z))$ rather than the theoretically equivalent minimize form, because it produces stronger gradients early in training) is $-\log(0.7) = 0.357$.

If instead the discriminator had confidently caught the fake, $D(G(z)) = 0.05$: the generator's loss is $-\log(0.05) = 3.00$, over 8 times larger. That larger loss produces a much stronger gradient pushing the generator's weights to change — specifically, in whatever direction makes future outputs like this one score higher under the current discriminator. This is the mechanism, concretely: whichever network is currently losing the contest gets the larger gradient, which is what keeps the competition balanced instead of one side running away with it early.

GAN training is notoriously harder to watch converge than the single, well-behaved loss surface in the explorer above — because $G$ and $D$ are each other's moving target, the loss can oscillate rather than settle, and the explorer's clean "crawling vs. converging vs. overshooting" distinction is a simplification of a genuinely trickier two-player dynamic.

What this means in practice

GANs are used to generate synthetic financial time series and order-book data for stress-testing and augmenting scarce training data (rare regimes, crisis periods) without waiting for history to repeat itself. Training is genuinely finicky compared to a normal network: the two-player game can fail to converge, oscillate indefinitely, or collapse into mode collapse, where the generator finds one narrow type of output that reliably fools the current discriminator and stops exploring anything else — producing samples that are realistic individually but far less diverse than the real data. Diagnosing a GAN therefore requires watching both losses together and checking output diversity directly, not just watching one loss curve go down the way you would for an ordinary supervised model.