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, um Stabilität und Gradientenfluss zu verbessern:

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 (in der Regel 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 Geschwindigkeitsvorhersage (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: $\beta_1=0.5,\ \beta_2=0.999$ verwenden;
• 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: Wird auf die Diskriminatorschichten in GANs angewendet, um Lipschitz-Bedingungen durchzusetzen;

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

• Label Smoothing: Weicht harte Labels auf (z. B. real = 0,9 statt 1,0), um Überkonfidenz zu reduzieren;
• Two-Time-Scale Update Rule (TTUR): Verwendet unterschiedliche Lernraten für Generator und Diskriminator, um die Konvergenz zu verbessern;
• Mixed-Precision Training: Nutzt 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, anschließend werden ausgewählte Schichten schrittweise für eine bessere Feinabstimmung freigegeben. 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 ermöglicht, 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 Referenzdatensätzen.

Zusammenfassung

• Verwendung von modellspezifischen Verlustfunktionen, die den Trainingszielen und der Modellstruktur entsprechen;
• 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.