GAN (Generative Adversarial Network)

Ein GAN besteht aus zwei konkurrierenden neuronalen Netzen, die sich gegenseitig verbessern:

Generator (G): Erzeugt synthetische Daten (z. B. Bilder, Audio, Text) aus zufälligem Rauschen.
Diskriminator (D): Versucht zu unterscheiden, ob Daten echt (aus dem Trainingsdatensatz) oder gefälscht (vom Generator) sind.

Das Training ist ein Minimax-Spiel: Der Generator versucht den Diskriminator zu täuschen, während der Diskriminator immer besser im Erkennen von Fakes wird.

Funktionsweise

Latenter Vektor z (Rauschen)
        │
        ▼
   [Generator G] ──▶ Gefälschte Daten
                              │
   Echte Daten ──────────────▶ [Diskriminator D] ──▶ Echt / Fake?

Die Loss-Funktion lautet vereinfacht:

min_G max_D [ E[log D(x)] + E[log(1 - D(G(z)))] ]

Praxisbeispiel mit PyTorch (vereinfacht)

import torch
import torch.nn as nn

# Einfacher Generator
class Generator(nn.Module):
    def __init__(self, latent_dim=100, output_dim=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.ReLU(),
            nn.Linear(256, output_dim),
            nn.Tanh()  # Ausgabe normiert auf [-1, 1]
        )
    def forward(self, z):
        return self.net(z)

# Einfacher Diskriminator
class Discriminator(nn.Module):
    def __init__(self, input_dim=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 1),
            nn.Sigmoid()  # Ausgabe: Wahrscheinlichkeit 'echt'
        )
    def forward(self, x):
        return self.net(x)

G = Generator()
D = Discriminator()
criterion = nn.BCELoss()
optimizer_G = torch.optim.Adam(G.parameters(), lr=0.0002)
optimizer_D = torch.optim.Adam(D.parameters(), lr=0.0002)

# Training-Loop (ein Schritt)
def train_step(real_data):
    batch_size = real_data.size(0)
    real_labels = torch.ones(batch_size, 1)
    fake_labels = torch.zeros(batch_size, 1)

    # Diskriminator trainieren
    z = torch.randn(batch_size, 100)
    fake_data = G(z).detach()
    loss_D = criterion(D(real_data), real_labels) + \
             criterion(D(fake_data), fake_labels)
    optimizer_D.zero_grad()
    loss_D.backward()
    optimizer_D.step()

    # Generator trainieren
    z = torch.randn(batch_size, 100)
    loss_G = criterion(D(G(z)), real_labels)  # G will D täuschen
    optimizer_G.zero_grad()
    loss_G.backward()
    optimizer_G.step()

    return loss_D.item(), loss_G.item()

Bekannte GAN-Varianten

Variante	Einsatzgebiet
DCGAN	Bildgenerierung mit CNNs
StyleGAN	Hochrealistische Gesichter / Portraits
CycleGAN	Bild-zu-Bild-Übersetzung (z. B. Pferd → Zebra)
Pix2Pix	Bedingte Bildtransformation
WGAN	Stabileres Training durch Wasserstein-Distanz

Typische Herausforderungen

Mode Collapse: Der Generator erzeugt immer dieselben Outputs, weil er eine Schwäche des Diskriminators ausnutzt.
Instabiles Training: Generator und Diskriminator müssen im Gleichgewicht bleiben – zu starke oder zu schwache Diskriminatoren blockieren das Lernen.
Evaluation: Qualität von GAN-Outputs ist schwer objektiv zu messen (häufig genutzte Metrik: FID-Score).

GAN vs. Diffusion Models

Moderne Bildgenerierung (Stable Diffusion, DALL-E) nutzt zunehmend Diffusion Models statt GANs, da diese stabiler trainieren und qualitativ oft besser abschneiden. GANs bleiben aber relevant für Echtzeit-Anwendungen (schnelle Inferenz) und spezialisierte Tasks wie Super-Resolution oder Video-Generierung.

Praktische Einsatzgebiete

Synthetische Trainingsdaten generieren (Data Augmentation)
Bild-Upscaling / Super Resolution
Deepfake-Erkennung (Diskriminator als Classifier)
Domain Adaptation (CycleGAN)
Anomalie-Erkennung in der Produktion

GAN (Generative Adversarial Network)