A GAN trains two networks by setting them against each other — and the contest itself is the only training signal. One network forges data, the other judges it, and each improves only because the other does.

Where you meet it

• Your first generative-model assignment — a GAN on MNIST digits or faces, watching samples sharpen out of noise.
• Staring at a "generator loss" and a "discriminator loss" curve, unsure which one is supposed to go down (neither, really — see below).
• Anything labelled DCGAN, StyleGAN, or "adversarial" — the same duel, scaled up.
• The machinery behind deepfakes and photo-real face synthesis.

What it does

A GAN learns to sample from a complicated distribution — to turn cheap random noise into outputs that look like they came from the real data — without ever writing down what that distribution is. There is no formula for "a realistic face"; there are only examples, and a rival that keeps score.

The generator never sees a single real example — its only teacher is an opponent that is still learning too.

How it works

Two networks, one scoreboard read in opposite directions. The discriminator D takes a point and reports how real it thinks it is (1 = real, 0 = fake). The generator G takes random noise z and paints a fake. The whole game is one value function, averaged over real points and over noise:

min_G max_D   E[log D(x)]  +  E[log(1 − D(G(z)))]
#   D: push D(x)→1 on real,  push D(G(z))→0 on fakes
#   G: flip it — make D(G(z))→1  (fakes rated as real)

So D maximizes that line and G minimizes it — the same numbers, pulled two ways. You alternate: nudge D to catch fakes, then nudge G to fool the current D, repeat. The trick that makes it learn: G asks "which way do I move this fake so D rates it more real?", and backprop carries that question through D — the discriminator's gradient is the teacher. In theory it ends in a standstill where fakes match the real data and D is reduced to a coin flip, D(x) = ½ everywhere — the tool's "50/50". One detail already baked into the tool's g_loss: rather than minimizing log(1 − D(G(z))), which barely moves while fakes are obvious, G maximizes log D(G(z)) — the "non-saturating" form that gives a usable gradient early on.

Watch out

Two networks, one loss function read in opposite directions — that is the whole idea.

Go deeper

• Goodfellow et al. (2014) — Generative Adversarial Nets (the original paper)
• Stanford CS231n — Generative Models (course notes)
• Google Machine Learning — GAN course (generator, discriminator, training)

Ein GAN trainiert zwei Netze, indem es sie gegeneinander antreten lässt — und der Wettkampf selbst ist das einzige Trainingssignal. Eines fälscht Daten, das andere bewertet sie, und jedes wird nur besser, weil das andere besser wird.

Wo es vorkommt

• Deine erste Aufgabe zu generativen Modellen — ein GAN auf MNIST-Ziffern oder Gesichtern, und du siehst zu, wie aus Rauschen scharfe Samples werden.
• Der Blick auf eine „Generator-Loss"- und eine „Diskriminator-Loss"-Kurve, ohne zu wissen, welche runtergehen soll (eigentlich keine — s.u.).
• Alles mit „DCGAN", „StyleGAN" oder „adversarial" im Namen — dasselbe Duell, nur hochskaliert.
• Die Technik hinter Deepfakes und fotorealistischer Gesichts-Synthese.

Was es tut

Ein GAN lernt, aus einer komplizierten Verteilung zu sampeln — billiges Zufallsrauschen in Ausgaben zu verwandeln, die aussehen, als kämen sie aus den echten Daten — ohne diese Verteilung je aufzuschreiben. Es gibt keine Formel für „ein realistisches Gesicht"; es gibt nur Beispiele und einen Gegner, der mitzählt.

Der Generator sieht kein einziges echtes Beispiel — sein einziger Lehrer ist ein Gegner, der selbst noch dazulernt.

Wie es funktioniert

Zwei Netze, eine Wertung, in zwei Richtungen gelesen. Der Diskriminator D nimmt einen Punkt und meldet, wie echt er ihn hält (1 = echt, 0 = fake). Der Generator G nimmt Rauschen z und malt eine Fälschung. Das ganze Spiel steckt in einer Wertfunktion, gemittelt über echte Punkte und über Rauschen:

min_G max_D   E[log D(x)]  +  E[log(1 − D(G(z)))]
#   D: D(x)→1 bei echt,  D(G(z))→0 bei fake
#   G: dreht es um — D(G(z))→1  (fake wird für echt gehalten)

Also maximiert D diese Zeile und G minimiert sie — dieselben Zahlen, in zwei Richtungen gezogen. Man wechselt sich ab: D nachschärfen, damit es Fälschungen fängt, dann G nachschärfen, damit es das aktuelle D täuscht, und wieder von vorn. Der Kniff, der das Lernen erst möglich macht: G fragt „in welche Richtung schiebe ich diese Fälschung, damit D sie echter bewertet?", und die Backpropagation trägt diese Frage durch D — der Gradient des Diskriminators ist der Lehrer. Theoretisch endet es im Patt, in dem die Fälschungen zu den echten Daten passen und D nur noch raten kann, D(x) = ½ überall — die „50/50" im Tool. Ein Detail steckt schon im g_loss des Tools: statt log(1 − D(G(z))) zu minimieren (das bewegt sich kaum, solange die Fälschungen offensichtlich sind), maximiert G log D(G(z)) — die „non-saturating"-Form, die früh einen brauchbaren Gradienten liefert.

Worauf achten

Zwei Netze, eine Verlustfunktion in zwei Richtungen gelesen — das ist die ganze Idee.

Mehr dazu

• Goodfellow et al. (2014) — Generative Adversarial Nets (Originalpaper)
• Stanford CS231n — Generative Models (Kurs-Notizen)
• Google Machine Learning — GAN-Kurs (Generator, Diskriminator, Training)