Generative Adversarial Network (GAN)

Ein generatives adversariales Netzwerk (GAN) ist ein Modell für generative KI, das aus zwei gegeneinander trainierten neuronalen Netzwerken besteht: Ein Generator wandelt zufälliges Rauschen in Beispiele um, während ein Diskriminator versucht, diese von echten Trainingsdaten zu unterscheiden. Nach dem Training erzeugt der Generator neue Bilder, Audiodaten oder Tabellendatensätze in einem einzigen Vorwärtsdurchlauf. Ian Goodfellow und Kollegen an der Université de Montréal stellten GANs 2014 in der Arbeit Generative Adversarial Nets vor. GANs dominierten die Bildsynthese, bis Diffusionsmodelle sie 2021 überholten.

So funktioniert das GAN-Training#

Die beiden Netzwerke treten in einem Minimax-Spiel gegeneinander an. Der Diskriminator ist ein binärer Klassifikator, der die Wahrscheinlichkeit ausgibt, dass seine Eingabe echt ist. Er wird mit einer Kreuzentropie-Verlustfunktion trainiert, die echte Beispiele mit 1 und generierte mit 0 bewertet. Der Generator sieht nie echte Daten und lernt ausschließlich anhand der Gradienten des Diskriminators. Im theoretischen Optimum des Spiels entspricht die generierte Verteilung der Datenverteilung, und der Diskriminator gibt für jede Eingabe 0,5 aus. Zu Beginn des Trainings lassen sich Fälschungen leicht erkennen, sodass das ursprüngliche Optimierungsziel des Generators fast keine Gradienten liefert – eine Form des Problems der verschwindenden Gradienten. Daher sah Goodfellows Arbeit vor, dass der Generator die Wahrscheinlichkeit maximiert, mit der der Diskriminator seine Beispiele für echt hält. Der folgende Code verwendet diese nicht sättigende Verlustfunktion.

Ein eindimensionales GAN lernt in PyTorch anhand von Beispielen allein eine gaußsche Verteilung:

import torch
from torch import nn

torch.manual_seed(0)

# Generator maps 8-D noise to a number; discriminator scores a number as real (high) or fake (low)
generator = nn.Sequential(nn.Linear(8, 32), nn.ReLU(), nn.Linear(32, 1))
discriminator = nn.Sequential(nn.Linear(1, 32), nn.LeakyReLU(0.2), nn.Linear(32, 1))
opt_g = torch.optim.Adam(generator.parameters(), lr=1e-3)
opt_d = torch.optim.Adam(discriminator.parameters(), lr=1e-3)
bce = nn.BCEWithLogitsLoss()
real_label, fake_label = torch.ones(64, 1), torch.zeros(64, 1)

for step in range(3000):
    real = 4.0 + 1.25 * torch.randn(64, 1)  # training data: samples from N(4, 1.25^2)
    fake = generator(torch.randn(64, 8))

    # Discriminator step: label real samples 1 and generated samples 0
    loss_d = bce(discriminator(real), real_label) + bce(discriminator(fake.detach()), fake_label)
    opt_d.zero_grad()
    loss_d.backward()
    opt_d.step()

    # Generator step: push the discriminator to label generated samples 1
    loss_g = bce(discriminator(fake), real_label)
    opt_g.zero_grad()
    loss_g.backward()
    opt_g.step()

samples = generator(torch.randn(10000, 8)).detach()
print(f"Generated mean {samples.mean():.2f}, std {samples.std():.2f} (data: 4.00, 1.25)")
print(f"Discriminator's average P(real) on generated samples: {torch.sigmoid(discriminator(samples)).mean():.2f}")

Nach 3.000 abwechselnden Trainingsschritten haben die generierten Beispiele einen Mittelwert von 3,95 und eine Standardabweichung von 1,20, verglichen mit 4,00 und 1,25 bei den Daten. Der Diskriminator bewertet sie im Durchschnitt mit einer Wahrscheinlichkeit von 0,51 als echt – nahe am Münzwurf des theoretischen Optimums.

Wichtige GAN-Varianten#

• DCGAN: Das Design von Alec Radford, Luke Metz und Soumith Chintala aus dem Jahr 2015 ermöglichte ein zuverlässiges Training konvolutionaler Generatoren und Diskriminatoren. Es ersetzte Pooling-Schichten durch Strided Convolutions und ergänzte Batch Normalization.
• Bedingte GANs und pix2pix: Werden beiden Netzwerken ein Klassenlabel oder ein Eingabebild zugeführt, kann der Generator ein gewünschtes Ergebnis erzeugen. pix2pix von Phillip Isola und Kollegen (2017) lernt gepaarte Übersetzungen, etwa von Labelkarten zu Straßenfotos und von Kanten zu Produktfotos.
• CycleGAN: Lernt die Übertragung zwischen zwei Bildsammlungen ohne gepaarte Beispiele, etwa von Pferden zu Zebras oder von Sommer- zu Winterlandschaften. Dazu muss ein übertragenes Bild wieder dem ursprünglichen Bild zugeordnet werden können.
• Wasserstein-GAN (WGAN): Martin Arjovsky und Kollegen ersetzten den Klassifikator durch einen Kritiker, der den Wasserstein-Abstand zwischen echten und generierten Daten schätzt (2017). So bleiben die Gradienten auch dann nützlich, wenn sich die beiden Verteilungen kaum überschneiden.
• StyleGAN: NVIDIA führte bei StyleGAN (2018) und StyleGAN2 (2019) einen erlernten Stilvektor in jede Generatorschicht ein. StyleGAN2 erreichte bei Gesichtern mit 1024 x 1024 Pixeln aus dem FFHQ-Datensatz einen Fréchet Inception Distance (FID) von 2,84.

Anwendungen#

• Superauflösung: SRGAN (2017), ESRGAN (2018) und Real-ESRGAN (2021) ergänzen Vergrößerungsnetzwerke um einen adversarialen Verlust. So stellen sie scharfe Texturen wieder her, während ein reiner Pixelverlust zu Unschärfe führt.
• Erweiterung medizinischer Bilder: Maayan Frid-Adar und Kollegen trainierten GANs mit CT-Aufnahmen von 182 Leberläsionen und ergänzten das Training um synthetische Läsionen. Dadurch stieg die Sensitivität eines Klassifikators von 78,6 % auf 85,7 % und seine Spezifität von 88,4 % auf 92,4 %.
• Deepfakes: In einer Studie von Sophie Nightingale und Hany Farid aus dem Jahr 2022 erkannten die Teilnehmenden Gesichter von StyleGAN2 mit einer Genauigkeit von 48 % als echt oder synthetisch – geringfügig schlechter als durch Zufall. Außerdem bewerteten sie die synthetischen Gesichter als vertrauenswürdiger.

Von GANs erzeugte Bilder dienen als synthetische Daten, wenn echte Beispiele selten sind, und ergänzen die Datenerweiterung durch geometrische Transformationen wie Spiegelungen und Drehungen. Sie werden wie alle anderen Bilder in einen YOLO26-Trainingsdatensatz aufgenommen: Der Trainingssplit in einer Ultralytics-YAML-Datei für Erkennungsdatensätze akzeptiert eine Liste von Verzeichnissen. Synthetische Bilder können daher in einem eigenen Ordner neben den realen Bildern liegen und durch Änderung einer Zeile hinzugefügt oder entfernt werden.

GANs im Vergleich zu Diffusionsmodellen und VAEs#

Diffusionsmodelle überholten GANs bei der Bildqualität, nachdem Prafulla Dhariwal und Alex Nichol von OpenAI 2021 berichteten, dass ein Diffusionsmodell auf ImageNet einen besseren FID als BigGAN-deep erzielte, damals das leistungsstärkste GAN. Das Training von Diffusionsmodellen ist ein stabiles Regressionsproblem ohne Gegenspieler und deckt die Vielfalt der Daten umfassender ab. GANs können beim Training oszillieren, ohne zu konvergieren, oder in einen Modenkollaps geraten: Der Generator beschränkt sich dann auf wenige Ausgaben, die den Diskriminator täuschen, und erzeugt den Rest nicht mehr. Variationale Autoencoder lassen sich ebenfalls stabil trainieren, ihre Beispiele sind jedoch unschärfer. Der dauerhafte Vorteil von GANs ist ihre Geschwindigkeit, da für eine Stichprobe ein einziger Vorwärtsdurchlauf genügt. GigaGAN von Adobe Research, Carnegie Mellon University und POSTECH erzeugte 2023 Text-zu-Bild-Ergebnisse mit 512 Pixeln in 0,13 Sekunden. Adversariale Verluste kommen auch weiterhin in Diffusionssystemen zum Einsatz. Der Autoencoder von Stable Diffusion wird mit einem patchbasierten Diskriminator trainiert. SDXL Turbo von Stability AI nutzt die adversariale Diffusionsdestillation, eine Form der Wissensdestillation mit einem Diskriminator in der Verlustfunktion, um ein Bild in einem einzigen Schritt zu erzeugen.