Learning Rate (vertieft)
Der wichtigste Hyperparameter vollständig verstehen
Die Learning Rate (LR) bestimmt die Schrittgröße beim Gradient Descent. Sie ist der einflussreichste Hyperparameter: kein anderer Parameter kann das Training so stark positiv oder negativ beeinflussen.
Auswirkungen auf den Trainingsverlauf
⚡ Chaos
LR zu groß (z.B. 1e-2)
• Loss oszilliert extrem
• Kein Konvergieren
• Mögliche Gradient-Explosion (NaN)
✓ Optimal
LR ideal (z.B. 2e-5)
• Loss sinkt gleichmäßig
• Stabile Konvergenz
• Erreicht niedriges Minimum
🐌 Zu langsam
LR zu klein (z.B. 1e-8)
• Kaum Fortschritt pro Epoche
• Sehr langsames Training
• Praktisch kein Lernen
LR-Empfehlungen nach Modelltyp und Aufgabe
2e-5 bis 5e-51e-5 bis 3e-55e-5 bis 1e-41e-4 bis 3e-45e-5 bis 1e-42e-4 bis 3e-41e-5 bis 5e-51e-3 bis 3e-3Der LR Range Test – systematische Findung
LR Range Test (implementierung):
1. Initialisiere Modell frisch
2. Trainiere 1 Epoche mit LR Schedule: 1e-8 → 1e-1
(exponentiell steigend über alle Steps)
3. Plotte Loss vs. LR (log-Skala)
4. Identifiziere:
- Punkt wo Loss am steilsten sinkt → LR_steep
- Punkt wo Loss beginnt zu steigen → LR_max
5. Gute LR = LR_steep / 10 bis LR_steep
Beispiel-Ergebnis:
LR_steep = 5e-4
LR_max = 2e-3
→ Gute LR = 5e-5 (sicher unter steep)
oder 1e-4 (aggressiver)Linear Scaling Rule & Batch-LR-Beziehung
Linear Scaling Rule: LR_neu = LR_basis × (Batch_Size_neu / Batch_Size_basis) Beispiel: Basis: BS=8, LR=2e-5 Neu: BS=32 → LR = 2e-5 × (32/8) = 8e-5 Für Batch Size < 512: Linear Scaling gut Für Batch Size > 512: Square Root Scaling besser: LR_neu = LR_basis × sqrt(BS_neu / BS_basis) Hinweis: Bei kleinen Änderungen (8→16) oft optional.
Praktischer Ansatz für FrameTrain
LR Scheduler Strategien
Die Learning Rate intelligent über das Training steuern
Ein LR Scheduler passt die LR während des Trainings automatisch an. Statt einer konstanten LR ermöglicht er schnelles Lernen am Anfang und präzises Fine-Tuning am Ende.
Learning Rate Scheduler: Warmup + Cosine Decay
Die 5 wichtigsten Scheduler im Detail
Warmup + Cosine Decay ⭐ (Goldstandard)
⭐ EmpfohlenLR steigt linear von 0 auf Ziel-LR (Warmup), danach sanfte Cosinus-Kurve bis fast 0.
warmup_steps = 5–10% total; scheduler_type = "cosine"✓ Vorteile:
Sanftes Abkühlen am Ende. Sehr stabile, reproduzierbare Ergebnisse. Weit verbreitet und gut erprobt.
✗ Nachteile:
Warmup-Schritte müssen vorab festgelegt werden.
Warmup + Linear Decay
LR steigt linear (Warmup), dann linearer Abfall bis 0.
warmup_ratio = 0.06; scheduler_type = "linear"✓ Vorteile:
Einfach, gut dokumentiert, BERT-Standard.
✗ Nachteile:
Cosine Decay minimal besser bei LLMs.
Warmup + Constant
LR steigt linear auf Ziel-LR, bleibt dann konstant.
warmup_steps = 100; scheduler_type = "constant_with_warmup"✓ Vorteile:
Einfachste Konfiguration.
✗ Nachteile:
Kein automatisches Abkühlen – kann am Ende zu instabil sein.
Cosine Annealing with Warm Restarts (SGDR)
Wiederholt Cosine-Decay-Zyklen mit Restarts. Nach jedem Zyklus: neue Exploration.
T_0 = 100 (erste Zykluslänge), T_mult = 2 (Verlängerung)✓ Vorteile:
Diverse Checkpoints aus verschiedenen Minima. Hilfreich für Ensembles.
✗ Nachteile:
Komplexer. Loss-Kurve sieht zyklisch aus – kann verwirrend sein.
ReduceLROnPlateau
LR wird automatisch reduziert, wenn Validation Loss für N Epochen nicht sinkt.
factor = 0.5 (LR × 0.5 wenn Plateau); patience = 2✓ Vorteile:
Völlig adaptiv, kein manuelles Tuning.
✗ Nachteile:
Kann zu früh oder zu spät reagieren. Braucht Validation Loss nach jeder Epoche.
Warmup berechnen – praktische Formel
Warmup-Schritte berechnen:
warmup_steps = total_steps × warmup_ratio (z.B. 0.06)
total_steps = (dataset_size / batch_size) × num_epochs
Beispiele:
1.000 Beispiele, BS=8, 3 Epochen:
total_steps = 125 × 3 = 375
warmup_steps = 375 × 0.06 = ~23 Steps
5.000 Beispiele, BS=16, 2 Epochen:
total_steps = 313 × 2 = 625
warmup_steps = 625 × 0.06 = ~38 Steps
Faustregel: 50–200 Warmup-Steps für die meisten JobsBatch Size & Gradient Accumulation
Effizienz, Speicher und Qualität ausbalancieren
Die Batch Size bestimmt, wie viele Trainingsbeispiele gleichzeitig verarbeitet werden, bevor Gewichte aktualisiert werden. Sie beeinflusst direkt Speicherbedarf, Trainingsgeschwindigkeit und oft auch die Generalisierungsqualität.
Kleine vs. Große Batch Size
Kleine Batch Size (1–8)
- ✓ Wenig GPU-Speicher
- ✓ Stochastisches Rauschen → manchmal bessere Generalisierung
- ✓ Häufigere Gewichts-Updates
- ✗ Noisige Gradienten (weniger Samples)
- ✗ Langsamer (weniger Parallelismus)
- ✗ Braucht niedrigere LR
Große Batch Size (32–256)
- ✓ Schnelleres Training (besserer GPU-Auslastung)
- ✓ Stabilere Gradienten
- ✓ Erlaubt höhere LR (Linear Scaling)
- ✗ Viel mehr VRAM
- ✗ Kann schlechtere Generalisierung bei sehr großen BS
- ✗ Braucht LR-Anpassung
Sweet Spot für LLM Fine-Tuning
Gradient Accumulation – der VRAM-Trick
Gradient Accumulation löst das Dilemma zwischen kleinem VRAM und großer effektiver Batch Size: Du verarbeitest kleine Batches, akkumulierst die Gradienten über mehrere Steps, und führst erst dann ein Gewichts-Update durch.
Gradient Accumulation Beispiel:
Ziel: Effektive Batch Size = 32, aber nur 6 GB VRAM
Batch Size: 4 (passt in VRAM)
Gradient Accumulation: 8 (akkumuliere 8 Steps)
Effektive Batch Size: 4×8 = 32 ✓
Ablauf:
Step 1: Forward(Batch1) → Gradient ÷8 akkumulieren
Step 2: Forward(Batch2) → Gradient ÷8 akkumulieren
...
Step 8: Forward(Batch8) → Gradient ÷8 akkumulieren
→ optimizer.step() (1 Update aus 32 Samples)
→ optimizer.zero_grad()
Wichtig: Gradienten durch accumulation_steps dividieren!
Sonst: zu große UpdatesVRAM-Empfehlungen nach GPU
Effektive Batch Size berechnen
Effektive Batch Size = batch_size × gradient_accumulation_steps
× num_gpus (bei Multi-GPU)
Beispiel (1 GPU):
batch_size = 4, accumulation = 8, gpus = 1
→ effektiv = 4 × 8 = 32
Empfehlung: Effektive BS von 16–32 anstreben
Wenn BS 32 nicht in VRAM passt:
→ BS=4, accumulation=8 ist gleichwertigOptimizer Vergleich
Welcher Optimizer für welche Situation?
Der Optimizer bestimmt, wie Gradienten in Gewichts-Updates umgewandelt werden. Neben der LR ist er der wichtigste Einflussfaktor auf Trainingsgeschwindigkeit, Stabilität und finale Performance.
Die wichtigsten Optimizer im Detail
AdamW ⭐ (Standard)
lr=2e-5, betas=(0.9, 0.999), eps=1e-8, weight_decay=0.01Kombiniert adaptives Lernen (Adam) mit korrekt entkoppeltem Weight Decay. Der Unterschied zu Adam: Weight Decay wird direkt auf Gewichte angewendet, nicht in den Gradienten integriert. Ergebnis: bessere Regularisierung.
✓ Vorteile:
Stabil, schnell, robust. Funktioniert out-of-the-box für fast alle LLM Fine-Tuning-Jobs.
✗ Nachteile:
Benötigt ~3× den Speicher der Modellgewichte (Moment-Statistiken). Bei 7B = ~14 GB extra.
💡 ⭐ Nutze immer AdamW als ersten Versuch
AdamW 8-bit (bitsandbytes)
bnb.optim.AdamW8bit(...)Quantisiert die Adam-Moment-Statistiken auf 8-bit. Spart ~75% Optimizer-Speicher bei minimalem Qualitätsverlust. Essentiell für Full Fine-Tuning auf 24GB GPUs.
✓ Vorteile:
Drittelt den Optimizer-Speicher. Qualität nahezu identisch zu fp32 AdamW.
✗ Nachteile:
Benötigt bitsandbytes-Library. Minimal langsamer durch Dequantisierung.
💡 Verwende wenn GPU-Speicher knapp bei Full Fine-Tuning
SGD mit Momentum
lr=0.01–0.1, momentum=0.9, weight_decay=1e-4Einfachster Optimizer mit Momentum. Gut verstanden und theoretisch fundiert. Oft besser für Vision-Modelle (ResNet, etc.), aber selten besser als AdamW für NLP/LLMs.
✓ Vorteile:
Einfach, weniger Speicher als Adam (keine Moment-Statistiken). Theoretisch gut verstanden.
✗ Nachteile:
Sehr sensitiv auf LR. Braucht sorgfältiges LR-Tuning. Für LLMs fast immer schlechter als AdamW.
💡 Für NLP/LLMs: immer AdamW bevorzugen
Adafactor
relative_step=True (auto-LR) oder feste LRSpart Speicher durch faktorisierte statt vollständige Moment-Statistiken. Für sehr große Modelle wo AdamW zu viel Speicher braucht. Standard bei Google-Modellen (T5, PaLM).
✓ Vorteile:
Dramatisch weniger Speicher als AdamW. Skaliert zu sehr großen Modellen.
✗ Nachteile:
Erfordert sorgfältigeres LR-Tuning. Konvergenz manchmal schlechter als AdamW.
💡 Fallback wenn AdamW OOM verursacht
Optimizer Memory Budget
Speicher-Übersicht (für 7B Modell, bf16):
Modell-Gewichte (bf16): ~14 GB
Aktivierungen (BS=4): ~4 GB
Gradients: ~14 GB (wie Gewichte)
Optimizer States:
AdamW (fp32): ~28 GB (2× Gewichte für Momente)
AdamW 8bit: ~7 GB (1/4 von AdamW fp32)
SGD: ~14 GB (nur 1× Moment)
Adafactor: ~2 GB (faktorisiert)
Total (AdamW): 14+4+14+28 = ~60 GB → braucht A100!
Total (AdamW8b): 14+4+14+7 = ~39 GB → RTX 3090×2 oder A100
Mit LoRA (kein Gradient für frozen layers):
Total (AdamW LoRA): ~14+1+1+2 = ~18 GB → RTX 3090!Regularisierung
Techniken für bessere Generalisierung und stabiles Training
Regularisierung umfasst Techniken, die das Modell daran hindern, die Trainingsdaten zu "memorieren", und stattdessen bessere Generalisierung fördern.
Die wichtigsten Regularisierungstechniken
L2 Regularisierung (Weight Decay)
L_total = L_task + λ · Σ w²weight_decay = 0.01 (Standard), 0.1 (stark)Fügt dem Loss einen Term hinzu, der proportional zum Quadrat der Gewichte ist. Bestraft große Gewichte und hält das Modell "bescheiden". In AdamW korrekt entkoppelt implementiert.
Effekt: Verhindert extreme Gewichtswerte. Implizite "Occams Razor" – einfachere Lösungen werden bevorzugt.
💡 Erhöhe weight_decay auf 0.05–0.1 bei starkem Overfitting.
Dropout
während Training: h_i = 0 mit Wahrscheinlichkeit pdropout = 0.1 (Standard), 0.3–0.5 (stark)Deaktiviert zufällig Neuronen während des Trainings. Das Netz kann sich nicht auf einzelne Neuronen verlassen und lernt redundante Repräsentationen.
Effekt: Stärkstes Regularisierungs-Werkzeug. Verhindert Co-Adaptation von Neuronen.
💡 Immer nur im Training aktiv! Bei Inferenz: alle Neuronen aktiv (skaliert).
Label Smoothing
y_smooth = y × (1-ε) + ε/Klabel_smoothing = 0.1 (Standard)Statt harter 0/1-Labels werden weiche Targets genutzt (z.B. 0.9 für Positiv, 0.1/(K-1) für alle anderen). Verhindert "überself-sicheres" Modell.
Effekt: Verbessert Kalibrierung (Confindence = echte Wahrscheinlichkeit). Leichte Overfitting-Reduktion.
💡 Besonders hilfreich bei NLP-Aufgaben mit viel Label-Rauschen.
Gradient Clipping
if ||g|| > max_norm: g = g × (max_norm / ||g||)max_grad_norm = 1.0 (Standard)Begrenzt die maximale Gradient-Norm. Kein eigentlicher Regularisierer, aber stabilisiert das Training und verhindert Explosionen.
Effekt: Verhindert Gradient-Explosion und NaN-Loss. Essenziell bei großen Modellen.
💡 Standard in FrameTrain: immer aktiviert. Bei sehr stabilen Trainings: 0.5 für strengeres Clipping.
Early Stopping
Stoppe wenn val_loss >= best_val_loss für patience Epochenpatience = 3 (Standard), monitor = "val_loss"Beendet das Training, wenn Validation Loss aufhört sich zu verbessern. Verhindert Overfitting durch zu langes Training implizit.
Effekt: Verhindert die Overfitting-Phase durch rechtzeitigen Stopp. Lädt besten Checkpoint.
💡 Kombiniere immer mit save_best_only=True für automatisches Best-Checkpoint-Speichern.
Regularisierung kombinieren
Empfohlene Kombination für FrameTrain Fine-Tuning: # Standard (wenig Overfitting): weight_decay = 0.01 dropout = 0.05 (LoRA dropout) early_stopping patience = 3 # Moderat (mittleres Overfitting): weight_decay = 0.05 dropout = 0.1 label_smoothing = 0.05 early_stopping patience = 2 # Stark (starkes Overfitting, wenig Daten): weight_decay = 0.1 dropout = 0.2 label_smoothing = 0.1 early_stopping patience = 2 lora_rank = 4 (weniger trainierbare Parameter)