Catastrophic Forgetting

Catastrophic Forgetting im Überblick

Catastrophic Forgetting beschreibt, wie neuronale Netze beim Lernen neuer Aufgaben Leistung auf alten Aufgaben verlieren können. Gewichtsänderungen für neue Daten können frühere Repräsentationen stören.

Das Problem visualisiert:

Schritt 1: Training auf Task A
Modell: [████████████] Task A: hohe Leistung

Schritt 2: Training auf Task B
Modell: [████████████] Task B: hohe Leistung
                       Task A: deutlich niedrigere Leistung ← Forgetting

Warum passiert das?

Gewichte vor Task B:    Muster sind gut für Task A angepasst
                              ↓
Training auf Task B:    Gradient Updates
                              ↓
Gewichte nach Task B:   Muster sind stärker für Task B angepasst
                         und können für Task A schlechter funktionieren

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

Technisch betrachtet

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, replay_ratio):
    for batch in new_data:
        # Mix aus neuen und alten Daten
        replay_batch = sample(old_data_buffer, int(len(batch) * replay_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):
    """
    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=adapter_rank,
    lora_alpha=adapter_scale,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=dropout_rate,
)

model = get_peft_model(base_model, config)
# Nur Adapter-Parameter werden trainiert
# Basis-Modell bleibt weitgehend 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:
# Forgetting = initiale Leistung auf Task A - aktuelle Leistung auf Task A
# Je größer der Abstand, desto stärker das Vergessen

Continual Learning Metriken

Praktische Tipps für Fine-Tuning