PyTorch Generative Adversarial Network (GAN)

Generative Adversarial Network (GAN)ist eine der kreativsten Modellarchitekturen im Deep Learning. Indem zwei neuronale Netzwerke gegeneinander antreten und voneinander lernen, kann es letztendlich sehr realistische Daten generieren. GANs werden in Szenarien wie Bildgenerierung, Style Transfer und Data Augmentation weit verbreitet eingesetzt.


1. Kernprinzipien von GAN

Die Kernidee von GAN stammt aus dem "Nullsummenspiel" der Spieltheorie. Sie besteht aus zwei konkurrierenden Netzwerken:

  • Generator: Lernt, gefälschte Daten zu erzeugen, mit dem Ziel, dass der Diskriminator generierte Daten nicht von echten Daten unterscheiden kann
  • Diskriminator: Lernt, echte Daten von generierten Daten zu unterscheiden, mit dem Ziel, möglichst genaue Beurteilungen zu treffen

Die beiden konkurrieren während des Trainings miteinander und verbessern sich kontinuierlich, bis sie schließlich einen Nash-Gleichgewichtszustand erreichen.

1.1 Zielfunktion von GAN

Das Trainingsziel von GAN kann als folgendes Minimax-Spiel ausgedrückt werden:

\[ \min_G \max_D \mathbb{E}_{x \sim p_{data}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))] \]

wobei:

  • \(G\) bezeichnet das Generatornetzwerk
  • \(D\) bezeichnet das Diskriminatornetzwerk
  • \(x\) bezeichnet reale Daten
  • \(z\) bezeichnet den Zufallsrauschvektor (der normalerweise einer Standardnormalverteilung folgt)
  • \(G(z)\) bezeichnet die vom Generator aus Rauschen erzeugten gefälschten Daten

1.2 Den Trainingsprozess verstehen

Das GAN-Training ist in zwei Phasen unterteilt:

Phase 1: Den Diskriminator trainieren

Generator einfrieren und die Unterscheidungsfähigkeit des Diskriminators verbessern:

\[ \max_D \mathbb{E}_{x \sim p_{data}}[\log D(x)] + \mathbb{E}_{z \sim p_z}[\log(1 - D(G(z)))] \]

Phase 2: Den Generator trainieren

Diskriminator einfrieren und die Täuschungsfähigkeit des Generators verbessern:

\[ \min_G \mathbb{E}_{z \sim p_z}[\log(1 - D(G(z)))] \]

Im tatsächlichen Training wird normalerweise zuerst der Diskriminator für k Schritte trainiert, dann der Generator für 1 Schritt, um das Gleichgewicht zu wahren.


2. Grundlegende GAN-Implementierung

Im Folgenden finden Sie eine minimale GAN-Implementierung – sie wird verwendet, um zweidimensionale Datenpunkte zu generieren.

2.1 Generator und Diskriminator definieren

Beispiel

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# Zufallsstartwert festlegen
torch.manual_seed(42)

# ── Generator-Netzwerk ──────────────────────────────────────
class Generator(nn.Module):
    """
Generator: Daten aus zufälligem Rauschen generieren
Eingabe: Rauschvektor (batch_size, noise_dim)
Ausgabe: generierte Daten (batch_size, data_dim)
    """

    def __init__(self, noise_dim, data_dim, hidden_dim=64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(noise_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, data_dim),
            # Ausgabe ist nicht aktiviert; GAN wird die geeignete Verteilung erlernen
        )

    def forward(self, x):
        return self.net(x)


# ── Diskriminator-Netzwerk ──────────────────────────────────────
class Discriminator(nn.Module):
    """
Diskriminator: Echte Daten von generierten Daten unterscheiden
Eingabe: Datenpunkte (batch_size, data_dim)
Ausgabe: Wahrscheinlichkeit echter Daten (batch_size, 1)
    """

    def __init__(self, data_dim, hidden_dim=64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(data_dim, hidden_dim),
            nn.LeakyReLU(0.2),  # LeakyReLU verhindert verschwindende Gradienten
            nn.Linear(hidden_dim, hidden_dim),
            nn.LeakyReLU(0.2),
            nn.Linear(hidden_dim, 1),
            nn.Sigmoid()  # Ausgabewahrscheinlichkeit
        )

    def forward(self, x):
        return self.net(x)


# Hyperparameter
NOISE_DIM = 16
DATA_DIM = 2
HIDDEN_DIM = 64
BATCH_SIZE = 128

# Netzwerke erstellen
generator = Generator(NOISE_DIM, DATA_DIM, HIDDEN_DIM)
discriminator = Discriminator(DATA_DIM, HIDDEN_DIM)

print(f"Anzahl der Generator-Parameter: {sum(p.numel() for p in generator.parameters()):,}")
print(f"Anzahl der Discriminator-Parameter: {sum(p.numel() for p in discriminator.parameters()):,}")

2.2 Trainingsschleife

Beispiel

# ── Optimierer ──────────────────────────────────────
lr = 0.001
g_optimizer = optim.Adam(generator.parameters(), lr=lr)
d_optimizer = optim.Adam(discriminator.parameters(), lr=lr)

# Verlustfunktion: binäre Kreuzentropie
criterion = nn.BCELoss()

# ── Trainingsdaten: Ringverteilung ──────────────────────────
def generate_real_data(batch_size):
    """Erzeuge echte Daten mit einer Ringverteilung"""
    angles = torch.rand(batch_size) * 2 * torch.pi
    radius = 1.0 + torch.randn(batch_size) * 0.1  # Radius ist ungefähr 1
    x = radius * torch.cos(angles)
    y = radius * torch.sin(angles)
    return torch.stack([x, y], dim=1)


# ── Trainingsschleife ──────────────────────────────────────
NUM_EPOCHS = 1000
d_losses = []
g_losses = []

for epoch in range(NUM_EPOCHS):
    # 1. Den Diskriminator trainieren
    # Fake-Daten generieren
    noise = torch.randn(BATCH_SIZE, NOISE_DIM)
    fake_data = generator(noise).detach()  # detach, um die Berechnung der Generator-Gradienten zu vermeiden

    # Echte Daten generieren
    real_data = generate_real_data(BATCH_SIZE)

    # Diskriminator-Verlust
    real_pred = discriminator(real_data)
    fake_pred = discriminator(fake_data)
    d_loss = criterion(real_pred, torch.ones_like(real_pred)) + \
             criterion(fake_pred, torch.zeros_like(fake_pred))

    # Diskriminator aktualisieren
    d_optimizer.zero_grad()
    d_loss.backward()
    d_optimizer.step()

    # 2. Den Generator trainieren
    # Einen neuen Batch gefälschter Daten generieren
    noise = torch.randn(BATCH_SIZE, NOISE_DIM)
    fake_data = generator(noise)

    # Generatorverlust: Den Diskriminator glauben lassen, dass die generierten Daten echt sind
    fake_pred = discriminator(fake_data)
    g_loss = criterion(fake_pred, torch.ones_like(fake_pred))

    # Generator aktualisieren
    g_optimizer.zero_grad()
    g_loss.backward()
    g_optimizer.step()

    # Verluste aufzeichnen
    d_losses.append(d_loss.item())
    g_losses.append(g_loss.item())

    if (epoch + 1) % 100 == 0:
        print(f"Epoche {epoch+1:4d} | D_loss: {d_loss:.4f} | G_loss: {g_loss:.4f}")

print("Training abgeschlossen!")

2.3 Generierte Ergebnisse visualisieren

Beispiel

# Daten generieren und visualisieren
def visualize_results(generator, num_samples=1000):
    noise = torch.randn(num_samples, NOISE_DIM)
    generated_data = generator(noise).detach().numpy()

    plt.figure(figsize=(6, 6))
    plt.scatter(generated_data[:, 0], generated_data[:, 1],
                alpha=0.5, s=10, c='blue', label='Generiert')
    plt.xlim(-2, 2)
    plt.ylim(-2, 2)
    plt.xlabel('x')
    plt.ylabel('y')
    plt.title('GAN-generierte Daten')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.show()


# Generierungsergebnisse anzeigen
visualize_results(generator)

3. DCGAN - Deep Convolutional GAN

DCGAN ist eine klassische Architektur, die Convolutional Neural Networks in GAN einführt und die Qualität der Bilderzeugung erheblich verbessert.

3.1 Wichtige Punkte der DCGAN-Architektur

  • Verwenden Sie transponierte Faltung für Upsampling, um Bilder zu erzeugen
  • Verwenden Sie Faltung mit Schrittweite für Downsampling, um Bilder zu diskriminieren
  • Verwenden Sie BatchNorm sowohl im Generator als auch im Diskriminator (aber nicht in der Ausgabeschicht oder Eingabeschicht)
  • Der Generator verwendet ReLU, der Diskriminator verwendet LeakyReLU

3.2 DCGAN-Implementierung

Beispiel

import torch
import torch.nn as nn

# ── DCGAN Generator ─────────────────────────────────
class DCGenerator(nn.Module):
    """
DCGAN Generator: Upsampling mit transponierter Faltung
    """

    def __init__(self, noise_dim=100, channels=3, features_g=64):
        super().__init__()
        self.noise_dim = noise_dim

        # Eingabe: noise_dim x 1 x 1
        self.net = nn.Sequential(
            # Transponierte Faltung: (batch, features_g*8, 4, 4)
            nn.ConvTranspose2d(noise_dim, features_g * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(features_g * 8),
            nn.ReLU(True),

            # (batch, features_g*4, 8, 8)
            nn.ConvTranspose2d(features_g * 8, features_g * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g * 4),
            nn.ReLU(True),

            # (batch, features_g*2, 16, 16)
            nn.ConvTranspose2d(features_g * 4, features_g * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g * 2),
            nn.ReLU(True),

            # (batch, features_g, 32, 32)
            nn.ConvTranspose2d(features_g * 2, features_g, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g),
            nn.ReLU(True),

            # Ausgabe: (batch, channels, 64, 64)
            nn.ConvTranspose2d(features_g, channels, 4, 2, 1, bias=False),
            nn.Tanh()  # Ausgabebereich [-1, 1]
        )

    def forward(self, x):
        # x: (batch, noise_dim) -> (batch, noise_dim, 1, 1)
        x = x.view(x.size(0), x.size(1), 1, 1)
        return self.net(x)


# ── DCGAN-Diskriminator ─────────────────────────────────
class DCDiscriminator(nn.Module):
    """
DCGAN-Diskriminator: Downsampling mittels Faltung
    """

    def __init__(self, channels=3, features_d=64):
        super().__init__()

        # Eingabe: (batch, channels, 64, 64)
        self.net = nn.Sequential(
            # (Batch, features_d, 32, 32)
            nn.Conv2d(channels, features_d, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),

            # (Batch, features_d*2, 16, 16)
            nn.Conv2d(features_d, features_d * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 2),
            nn.LeakyReLU(0.2, inplace=True),

            # (Batch, features_d*4, 8, 8)
            nn.Conv2d(features_d * 2, features_d * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 4),
            nn.LeakyReLU(0.2, inplace=True),

            # (Batch, features_d*8, 4, 4)
            nn.Conv2d(features_d * 4, features_d * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 8),
            nn.LeakyReLU(0.2, inplace=True),

            # Ausgabe: (Batch, 1, 1, 1)
            nn.Conv2d(features_d * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.net(x).view(x.size(0), -1)


# Testnetzwerk
noise_dim = 100
generator = DCGenerator(noise_dim=noise_dim, channels=3, features_g=64)
discriminator = DCDiscriminator(channels=3, features_d=64)

# Vorwärtsdurchlauf testen
noise = torch.randn(2, noise_dim)
fake_images = generator(noise)
print(f"Form des generierten Bildes: {fake_images.shape}")  # torch.Size([2, 3, 64, 64])

decision = discriminator(fake_images)
print(f"Form des Diskriminator-Ergebnisses: {decision.shape}")     # torch.Size([2, 1])

3.3 Vollständiger DCGAN-Trainingscode

Beispiel

# ── Trainingskonfiguration ─────────────────────────────────────
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

NOISE_DIM = 100
LEARNING_RATE = 0.0002
BETA1 = 0.5  # Adam-Parameter

# Netzwerke erstellen
generator = DCGenerator(noise_dim=NOISE_DIM).to(device)
discriminator = DCDiscriminator().to(device)

# Optimierer
g_optimizer = optim.Adam(generator.parameters(), lr=LEARNING_RATE, betas=(BETA1, 0.999))
d_optimizer = optim.Adam(discriminator.parameters(), lr=LEARNING_RATE, betas=(BETA1, 0.999))

criterion = nn.BCELoss()

# ── Trainingsschleife ─────────────────────────────────────
fixed_noise = torch.randn(64, NOISE_DIM, device=device)  # Zur Visualisierung

def train_dcgan(generator, discriminator, g_optimizer, d_optimizer, criterion,
                num_epochs, device, fixed_noise):
    G_losses = []
    D_losses = []

    for epoch in range(num_epochs):
        for batch_idx in range(100):  # Angenommen, jede Epoche hat 100 Batches
            # Diskriminator trainieren
            discriminator.zero_grad()

            # Echte Bilder (als verfügbar angenommen)
            # real_images = ...
            # Hier zufälliges Rauschen zur Simulation verwenden
            real_images = torch.randn(32, 3, 64, 64).to(device)

            batch_size = real_images.size(0)
            labels_real = torch.ones(batch_size, 1).to(device)
            labels_fake = torch.zeros(batch_size, 1).to(device)

            # Verlust für echte Bilder
            output = discriminator(real_images)
            d_loss_real = criterion(output, labels_real)

            # Verlust für generierte Bilder
            noise = torch.randn(batch_size, NOISE_DIM).to(device)
            fake_images = generator(noise)
            output = discriminator(fake_images.detach())
            d_loss_fake = criterion(output, labels_fake)

            # Gesamtverlust
            d_loss = d_loss_real + d_loss_fake
            d_loss.backward()
            d_optimizer.step()

            # Generator trainieren
            generator.zero_grad()

            noise = torch.randn(batch_size, NOISE_DIM).to(device)
            fake_images = generator(noise)
            output = discriminator(fake_images)
            g_loss = criterion(output, labels_real)  # Hoffentlich werden die generierten Bilder als echt beurteilt

            g_loss.backward()
            g_optimizer.step()

            # Verlust aufzeichnen
            if batch_idx % 50 == 0:
                G_losses.append(g_loss.item())
                D_losses.append(d_loss.item())
                print(f"[{epoch}/{num_epochs}][{batch_idx}/100] "
                      f"D_loss: {d_loss:.4f} | G_loss: {g_loss:.4f}")

    return G_losses, D_losses


# Training starten
# G_losses, D_losses = train_dcgan(generator, discriminator, g_optimizer,
# d_optimizer, criterion, 5, device, fixed_noise)
print("Die DCGAN-Architektur wurde definiert, das Training kann beginnen!")

4. Tipps für das GAN-Training

4.1 Häufige Probleme und Lösungen

Problem Ursache Lösung
Modus-Kollaps Der Generator erzeugt nur eine begrenzte Vielfalt an Samples WGAN verwenden, Minibatch-Diskriminierung hinzufügen, Label-Smoothing verwenden
Diskriminator zu stark Generator-Gradienten verschwinden, wodurch er nicht lernen kann Trainiere den Generator mehrmals, reduziere die Lernrate des Diskriminators, verwende LeakyReLU
Instabiles Training Die GAN-Zielfunktion ist nicht konvex und schwierig zu konvergieren Verwende spektrale Normalisierung, Gradientenstrafe, Lernraten-Warmup
Schlechte Generierungsqualität Unzureichende Netzwerkkapazität oder unzureichendes Training Erhöhe die Netzwerktiefe, verwende mehr Trainingsdaten, trainiere länger

4.2 Verbesserungen der Verlustfunktion

Das ursprüngliche GAN verwendet die JS-Divergenz, die Probleme mit verschwindenden Gradienten hat. WGAN verwendet die Wasserstein-Distanz, die stabiler ist:

Beispiel

# WGAN-Verlustfunktion (ersetzt BCE)
def wgan_d_loss(real_pred, fake_pred):
    """Diskriminator-Verlust: echte Beispiele werden hoch bewertet, generierte Beispiele niedrig bewertet"""
    return -(torch.mean(real_pred) - torch.mean(fake_pred))

def wgan_g_loss(fake_pred):
    """Generator-Verlust: generierte Beispiele sollen hoch bewertet werden"""
    return -torch.mean(fake_pred)

# Gradientenstrafe - WGAN-GP
def gradient_penalty(discriminator, real_images, fake_images, device):
    """WGAN-GP-Gradientenstrafterm"""
    batch_size = real_images.size(0)
    alpha = torch.rand(batch_size, 1, 1, 1).to(device)

    # Zwischen echten und generierten Bildern interpolieren
    interpolated = alpha * real_images + (1 - alpha) * fake_images
    interpolated.requires_grad = True

    # Berechne die Diskriminator-Ausgabe für interpolierte Bilder
    pred = discriminator(interpolated)

    # Berechne den Gradienten
    gradients = torch.autograd.grad(
        outputs=pred,
        inputs=interpolated,
        grad_outputs=torch.ones_like(pred),
        create_graph=True,
        retain_graph=True,
        only_inputs=True
    )[0]

    # Berechne die Gradientennorm
    gradients = gradients.view(batch_size, -1)
    gradient_norm = gradients.norm(2, dim=1)
    penalty = ((gradient_norm - 1) ** 2).mean()

    return penalty

4.3 Spektrale Normalisierung

Spektrale Normalisierung kann das GAN-Training stabilisieren, indem sie die Lipschitz-Konstante des Diskriminators steuert:

Beispiel

import torch.nn.utils.spectral_norm as spectral_norm

# Diskriminator mit spektraler Normalisierung
class SNDiscriminator(nn.Module):
    def __init__(self, channels=3, features_d=64):
        super().__init__()
        self.net = nn.Sequential(
            spectral_norm(nn.Conv2d(channels, features_d, 4, 2, 1)),
            nn.LeakyReLU(0.2, inplace=True),

            spectral_norm(nn.Conv2d(features_d, features_d * 2, 4, 2, 1)),
            nn.LeakyReLU(0.2, inplace=True),

            spectral_norm(nn.Conv2d(features_d * 2, features_d * 4, 4, 2, 1)),
            nn.LeakyReLU(0.2, inplace=True),

            spectral_norm(nn.Conv2d(features_d * 4, 1, 4, 1, 0)),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.net(x).view(x.size(0), -1)

5. Bedingtes GAN (cGAN)

Bedingtes GAN ermöglicht die Angabe von Klassenlabels für generierte Daten, was die bedingte Generierung ermöglicht.

5.1 cGAN-Architektur

Beispiel

import torch
import torch.nn as nn

class ConditionalGenerator(nn.Module):
    """Bedingter Generator: empfängt sowohl Rauschen als auch Klassenlabels"""
    def __init__(self, noise_dim, num_classes, embed_dim, img_channels, features_g=64):
        super().__init__()
        self.label_emb = nn.Embedding(num_classes, embed_dim)

        # Rauschen und Label-Einbettungen verketten
        self.net = nn.Sequential(
            nn.Linear(noise_dim + embed_dim, features_g * 8 * 4 * 4),
            nn.BatchNorm1d(features_g * 8 * 4 * 4),
            nn.ReLU(),
            # Dann transponierte Faltungen anwenden (ähnlich wie DCGAN)
            # ...
        )

    def forward(self, noise, labels):
        # Klassenlabels auf dieselbe Dimension wie das Rauschen einbetten
        label_embedding = self.label_emb(labels)
        # Rauschen und Label-Einbettungen verketten
        x = torch.cat([noise, label_embedding], dim=1)
        return self.net(x)


class ConditionalDiscriminator(nn.Module):
    """Bedingter Diskriminator: empfängt sowohl Bilder als auch Klassenlabels"""
    def __init__(self, img_channels, num_classes, embed_dim, features_d=64):
        super().__init__()
        self.label_emb = nn.Embedding(num_classes, embed_dim)

        # Bild- und Label-Embeddings verketten
        self.net = nn.Sequential(
            nn.Conv2d(img_channels + embed_dim, features_d, 4, 2, 1),
            nn.LeakyReLU(0.2),
            # ...
        )

    def forward(self, img, labels):
        # Label-Einbettungen auf dieselbe räumliche Größe wie Bilder umformen
        label_embedding = self.label_emb(labels)
        # Form für die Verkettung anpassen
        label_embedding = label_embedding.unsqueeze(2).unsqueeze(3)
        label_embedding = label_embedding.expand(-1, -1, img.size(2), img.size(3))
        # Bild und Label verketten
        x = torch.cat([img, label_embedding], dim=1)
        return self.net(x)

6. GAN-Evaluierungsmetriken

6.1 Gängige Evaluierungsmetriken

Metrik Beschreibung Vorteile Nachteile
Inception Score (IS) Inception v3 verwenden, um die Qualität und Vielfalt generierter Bilder zu bewerten Einfach zu berechnen, hat eine gewisse Korrelation mit menschlichem Urteilsvermögen Bewertet Überanpassung nicht und kann keinen Mode Collapse erkennen
Fréchet-Inception-Distanz (FID) Berechnet den Abstand zwischen echten und generierten Bildern im Merkmalsraum Empfindlicher gegenüber Rauschen und Mode Collapse Erfordert eine große Anzahl von Stichproben und ist langsam zu berechnen
Menschliche Bewertung Menschen beurteilen die Qualität generierter Bilder Spiegelt die menschliche Wahrnehmung am genauesten wider Subjektiv und zeitaufwändig

6.2 Implementierung der FID-Berechnung

Beispiel

import numpy as np
from scipy import linalg

def calculate_fid(real_activations, fake_activations):
    """
Fréchet-Inception-Distance berechnen
real_activations: Merkmalsvektoren von echten Bildern (N, dim)
fake_activations: Merkmalsvektoren von generierten Bildern (N, dim)
    """

    # Mittelwert und Kovarianz berechnen
    mu1, sigma1 = real_activations.mean(axis=0), np.cov(real_activations, rowvar=False)
    mu2, sigma2 = fake_activations.mean(axis=0), np.cov(fake_activations, rowvar=False)

    # FID berechnen
    diff = mu1 - mu2
    # Summe der Kovarianzmatrizen berechnen
    covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)

    # Komplexe Zahlen vermeiden
    if np.iscomplexobj(covmean):
        covmean = covmean.real

    fid = diff.dot(diff) + np.trace(sigma1 + sigma2 - 2 * covmean)
    return fid


# Vereinfachtes Beispiel: Zufallsdaten verwenden
np.random.seed(42)
real_acts = np.random.randn(1000, 2048)  # Ausgabedimension von Inception v3
fake_acts = np.random.randn(1000, 2048)

fid_score = calculate_fid(real_acts, fake_acts)
print(f"FID-Wert: {fid_score:.2f}")
# Ein niedrigerer FID-Wert ist besser; ein Wert unter 50 weist üblicherweise auf eine gute Generierungsqualität hin

7. Gängige GAN-Varianten

Seit seiner Entwicklung hat GAN viele Varianten hervorgebracht, die für verschiedene Anwendungsszenarien geeignet sind:

Modell Vollständiger Name Funktionen Geeignete Szenarien
DCGAN Deep Convolutional GAN Verwendet Faltungsnetzwerke, erzeugt hochwertige Bilder Bilderstellung
WGAN Wasserstein GAN Verwendet die Wasserstein-Distanz, stabileres Training Stabiles Training
WGAN-GP WGAN mit Gradient Penalty Gradient Penalty ersetzt Weight Clipping Stabiles Training
CGAN Conditional GAN Fügt bedingte Informationen hinzu, kontrollierbare Generierung Bedingte Generierung
CycleGAN Zykluskonsistentes GAN Unüberwachte Bild-zu-Bild-Übersetzung Stilübertragung
StyleGAN Stilbasiertes GAN Stilsteuerung, hochwertige Gesichtsgenerierung Gesichtserzeugung
BigGAN Big GAN Großformatige, hochwertige Bilderzeugung Hochauflösende Bilder
ProGAN Progressiv wachsende GAN Schrittweise Erhöhung der Auflösung Hochauflösende Generierung
Weitere Erweiterungen