Training und Optimierung

Das Training generativer Modelle umfasst die Optimierung oft instabiler und komplexer Verlustlandschaften. Dieser Abschnitt stellt Verlustfunktionen vor, die auf jeden Modelltyp zugeschnitten sind, Optimierungsstrategien zur Stabilisierung des Trainings sowie Methoden zur Feinabstimmung vortrainierter Modelle für individuelle Anwendungsfälle.

Zentrale Verlustfunktionen

Verschiedene Familien generativer Modelle verwenden unterschiedliche Verlustformulierungen, abhängig davon, wie sie Datenverteilungen modellieren.

GAN-Verluste

Minimax-Verlust (ursprüngliches GAN)

Adversariales Setup zwischen Generator $G$ und Diskriminator $D$ (Beispiel mit der pythorch-Bibliothek):

loss_D = -torch.mean(torch.log(D(real_data)) + torch.log(1. - D(fake_data)))
loss_G = -torch.mean(torch.log(D(fake_data)))

Least Squares GAN (LSGAN)

Verwendet L2-Verlust anstelle von Log-Verlust zur Verbesserung der Stabilität und des Gradientenflusses:

loss_D = 0.5 * torch.mean((D(real_data) - 1) ** 2 + D(fake_data) ** 2)
loss_G = 0.5 * torch.mean((D(fake_data) - 1) ** 2)

Wasserstein GAN (WGAN)

Minimiert die Earth Mover (EM) Distanz; ersetzt den Diskriminator durch einen "Kritiker" und verwendet Weight Clipping oder Gradientenstrafe für Lipschitz-Stetigkeit:

loss = torch.mean(D(fake_data)) - torch.mean(D(real_data)) + gradient_penalty

VAE-Verlust

Evidence Lower Bound (ELBO)

Kombiniert Rekonstruktions- und Regularisierungsterm. Der KL-Divergenz-Term sorgt dafür, dass der latente Posterior nahe an der Prior-Verteilung (meist Standardnormalverteilung) bleibt:

recon_loss = F.binary_cross_entropy(recon_x, x, reduction='sum')
kl_div = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
loss = recon_loss + kl_div

Diffusionsmodell-Verluste

Rauschvorhersage-Verlust

Modelle lernen, hinzugefügtes Gaußsches Rauschen über einen Diffusionszeitplan zu entfernen. Varianten verwenden Geschwindigkeitsschätzung (z. B. v-prediction in Stable Diffusion v2) oder hybride Zielsetzungen:

noise = torch.randn_like(x)
x_t = q_sample(x, t, noise)
pred_noise = model(x_t, t)
loss = F.mse_loss(pred_noise, noise)

Optimierungstechniken

Das Training generativer Modelle ist oft instabil und empfindlich gegenüber Hyperparametern. Verschiedene Techniken werden eingesetzt, um Konvergenz und Qualität sicherzustellen.

Optimierer und Scheduler

• Adam / AdamW: Adaptive Gradientenoptimierer sind der De-facto-Standard. Für GANs werden $\beta_1=0.5,\ \beta_2=0.999$ verwendet;
• RMSprop: Wird manchmal in WGAN-Varianten eingesetzt;
• Lernraten-Scheduling:
  • Aufwärmphasen für Transformer und Diffusionsmodelle;
  • Kosinus-Abfall oder ReduceLROnPlateau für stabile Konvergenz.

optimizer = torch.optim.Adam(model.parameters(), lr=2e-4, betas=(0.5, 0.999))
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)

Stabilisierungsverfahren

• Gradient Clipping: Vermeidung explodierender Gradienten in RNNs oder tiefen UNets;

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

• Spektrale Normalisierung: Anwendung auf Diskriminatorschichten in GANs zur Durchsetzung von Lipschitz-Bedingungen;

from torch.nn.utils import spectral_norm
layer = spectral_norm(nn.Linear(100, 100))

• Label Smoothing: Abschwächung harter Labels (z. B. real = 0,9 statt 1,0) zur Reduzierung von Überkonfidenz;
• Two-Time-Scale Update Rule (TTUR): Verwendung unterschiedlicher Lernraten für Generator und Diskriminator zur Verbesserung der Konvergenz;
• Mixed-Precision Training: Nutzung von FP16 (über NVIDIA Apex oder PyTorch AMP) für schnelleres Training auf modernen GPUs.

scaler = torch.cuda.amp.GradScaler()
with torch.cuda.amp.autocast():
    output = model(input)
    loss = loss_fn(output, target)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

Feinabstimmung vortrainierter generativer Modelle

Vortrainierte generative Modelle (z. B. Stable Diffusion, LLaMA, StyleGAN2) können für domänenspezifische Aufgaben mit leichteren Trainingsstrategien feinabgestimmt werden.

Transfer-Learning-Techniken

• Vollständige Feinabstimmung: Alle Modellgewichte werden erneut trainiert. Hoher Rechenaufwand, aber maximale Flexibilität;

model = AutoModel.from_pretrained('model-name')
model.train()
optimizer = torch.optim.Adam(model.parameters(), lr=5e-5)

• Schichtweises Einfrieren / schrittweises Auftauen: Zunächst werden die meisten Schichten eingefroren, dann werden ausgewählte Schichten schrittweise freigegeben, um eine bessere Feinabstimmung zu ermöglichen. Dies verhindert katastrophales Vergessen. Das Einfrieren früher Schichten bewahrt allgemeine Merkmale aus dem Pretraining (wie Kanten oder Wortmuster), während das Auftauen späterer Schichten dem Modell erlaubt, aufgabenspezifische Merkmale zu erlernen;

for param in model.parameters():
    param.requires_grad = False
# Unfreeze final transformer block or decoder
for param in model.transformer.block[-1].parameters():
    param.requires_grad = True

• LoRA- / Adapter-Schichten: Einfügen von trainierbaren Low-Rank-Schichten, ohne die Basismodell-Parameter zu aktualisieren;

from peft import get_peft_model, LoraConfig, TaskType

config = LoraConfig(task_type=TaskType.SEQ_2_SEQ_LM, r=8, lora_alpha=16, lora_dropout=0.1)
model = get_peft_model(base_model, config)

• DreamBooth / Textuelle Inversion (Diffusionsmodelle):
  • Feintuning mit wenigen objektspezifischen Bildern.
  • Verwendung der diffusers-Pipeline:

from diffusers import StableDiffusionPipeline
pipeline = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4")
pipeline.train(texts, images)  # pseudo-call: use DreamBooth training scripts in practice

• Prompt Tuning / P-Tuning:

from peft import PromptTuningConfig, get_peft_model
config = PromptTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=20)
model = get_peft_model(base_model, config)

Häufige Anwendungsfälle

• Stilanpassung: Feinabstimmung auf Anime-, Comic- oder künstlerischen Datensätzen;
• Branchenspezifische Anpassung: Anpassung von LLMs an juristische, medizinische oder unternehmensspezifische Bereiche;
• Personalisierung: Individuelle Identitäts- oder Sprachkonditionierung mit kleinen Referenzmengen.

Zusammenfassung

• Verwendung von modellspezifischen Verlustfunktionen, die zu Trainingszielen und Modellstruktur passen;
• Optimierung mit adaptiven Methoden, Stabilisierungsverfahren und effizientem Scheduling;
• Feinabstimmung vortrainierter Modelle mit modernen Low-Rank- oder Prompt-basierten Transferstrategien zur Kostensenkung und Steigerung der Domänenanpassungsfähigkeit.