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.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
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
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.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
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
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
# 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.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
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 |