Catastrophic Forgetting

Einfach erklärt

Catastrophic Forgetting beschreibt, wie neuronale Netze beim Lernen neuer Aufgaben das Wissen über alte Aufgaben verlieren. Die Gewichte werden überschrieben – das alte Wissen ist weg.

Das Problem visualisiert:

Schritt 1: Training auf Task A
Modell: [████████████] Task A: 95% Accuracy

Schritt 2: Training auf Task B
Modell: [████████████] Task B: 90% Accuracy
                       Task A: 20% Accuracy ← Vergessen!

Warum passiert das?

Gewichte vor Task B:    [0.5, -0.3, 0.8, 0.2]  ← Optimal für A
                              ↓
Training auf Task B:    Gradient Updates
                              ↓
Gewichte nach Task B:   [0.1, 0.4, -0.2, 0.7]  ← Optimal für B
                                                  Schlecht für A

Die Gewichte, die für Task A wichtig waren, wurden für Task B überschrieben.

Technischer Deep Dive

Warum neuronale Netze vergessen

Shared Representations:

• Verschiedene Tasks nutzen dieselben Gewichte
• Optimierung für Task B verändert Gewichte
• Diese Änderungen sind schädlich für Task A

Keine Lokalisierung:

• Wissen ist über das gesamte Netz verteilt
• Kein “Speicherbereich” pro Task
• Jedes Update beeinflusst alles

Lösungsansätze

1. Replay (Experience Replay):

def train_with_replay(model, new_data, old_data_buffer, ratio=0.3):
    for batch in new_data:
        # Mix aus neuen und alten Daten
        replay_batch = sample(old_data_buffer, int(len(batch) * ratio))
        combined = concat(batch, replay_batch)
        
        loss = model(combined)
        loss.backward()
        optimizer.step()
        
        # Neue Daten zum Buffer hinzufügen
        old_data_buffer.add(batch)

2. Elastic Weight Consolidation (EWC):

def ewc_loss(model, task_loss, fisher_matrix, old_weights, lambda_ewc=1000):
    """
    Bestraft Änderungen an wichtigen Gewichten
    """
    ewc_penalty = 0
    for name, param in model.named_parameters():
        # Fisher Matrix zeigt Wichtigkeit der Gewichte
        importance = fisher_matrix[name]
        old_value = old_weights[name]
        
        # Penalty für Abweichung von alten Werten
        ewc_penalty += (importance * (param - old_value) ** 2).sum()
    
    return task_loss + lambda_ewc * ewc_penalty

3. Progressive Neural Networks:

Task A:  [Network A] ────────────────→ Output A
              │
              ↓ (frozen)
Task B:  [Network B] + lateral connections → Output B
              │
              ↓ (frozen)
Task C:  [Network C] + lateral connections → Output C

Neue Netzwerke für neue Tasks, alte bleiben eingefroren.

4. LoRA für LLMs:

# Statt alle Gewichte zu ändern
# Nur kleine Adapter trainieren
from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=16,  # Rank
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.1,
)

model = get_peft_model(base_model, config)
# Nur 0.1% der Parameter werden trainiert
# Basis-Modell bleibt unverändert

Messung von Forgetting

def measure_forgetting(model, tasks, initial_accuracies):
    """
    Backward Transfer: Wie viel wurde vergessen?
    """
    forgetting = {}
    
    for task_id, task_data in enumerate(tasks[:-1]):  # Alle außer letztem
        current_acc = evaluate(model, task_data)
        initial_acc = initial_accuracies[task_id]
        
        forgetting[task_id] = initial_acc - current_acc
    
    return forgetting

# Beispiel:
# Task A initial: 95%, nach Task B: 60%
# Forgetting = 35%

Continual Learning Metriken

Metrik	Beschreibung
Average Accuracy	Durchschnitt über alle Tasks
Forgetting	Accuracy-Verlust auf alten Tasks
Forward Transfer	Hilft altes Wissen bei neuen Tasks?
Backward Transfer	Hilft neues Wissen bei alten Tasks?

Praktische Tipps für Fine-Tuning

Strategie	Effekt auf Forgetting
Niedrige Learning Rate	⬇️ Weniger Vergessen
Wenige Epochen	⬇️ Weniger Vergessen
LoRA/Adapter	⬇️⬇️ Viel weniger Vergessen
Replay	⬇️⬇️ Aktiv dagegen
Full Fine-Tuning	⬆️ Hohes Risiko