Wie viele Epochen ohne Verbesserung toleriert werden, bevor gestoppt wird.

Effekt: Zu niedrig: stoppt zu früh (bei temporären Schwankungen). Zu hoch: Overfitting passiert trotzdem.

💡 patience=3 für kurze Trainings. patience=5 für lange Trainings mit Schwankungen.

Minimale Verbesserung des Validation Loss um als "besser" zu zählen.

Effekt: Verhindert Stoppen wenn nur minimales Rauschen die Metrik leicht verbessert.

💡 min_delta=0.001 ist ein guter Startwert.

Welche Metrik überwacht wird.

Effekt: val_loss ist stabiler und direkter. val_accuracy kann plateauen während val_loss noch sinkt.

💡 Immer val_loss monitoren, nicht val_accuracy.

Ob der beste Checkpoint automatisch geladen wird wenn gestoppt wird.

Effekt: Ohne: letzter Checkpoint (nach Overfitting). Mit: bester Checkpoint geladen.

💡 Immer True. Nur Ausnahme: wenn der letzte Checkpoint explizit gewünscht.

Jedes Modell gibt eine Klassen-Vorhersage. Die häufigste Klasse gewinnt (wie eine Wahl).

# 3 Modell-Vorhersagen kombinieren:
predictions = [model1.predict(x),  # "positiv"
               model2.predict(x),  # "positiv"  
               model3.predict(x)]  # "negativ"
from collections import Counter
final = Counter(predictions).most_common(1)[0][0]
# → "positiv" (2 von 3 Modellen)

Einsatz: Wenn Klassen-Label (nicht Wahrscheinlichkeit) verfügbar

Softmax-Wahrscheinlichkeiten aller Modelle werden gemittelt. Dann höchste Wahrscheinlichkeit als Klasse.

# Wahrscheinlichkeiten mitteln:
probs_1 = model1.predict_proba(x)  # [0.8, 0.2]
probs_2 = model2.predict_proba(x)  # [0.6, 0.4]
probs_3 = model3.predict_proba(x)  # [0.9, 0.1]

avg_probs = np.mean([probs_1, probs_2, probs_3], axis=0)
# → [0.77, 0.23]
final_class = np.argmax(avg_probs)  # Klasse 0 = "positiv"

Einsatz: Wenn Softmax-Wahrscheinlichkeiten verfügbar – fast immer besser als Majority Voting

Verschiedene Checkpoints desselben Trainings werden kombiniert. Kostengünstig – kein separates Training nötig.

# Letzte N Checkpoints aus einem Training:
checkpoints = [
    'model_epoch_8.pt',
    'model_epoch_9.pt', 
    'model_epoch_10.pt'
]
# Vorhersagen aller Checkpoints mitteln
ensemble_probs = np.mean([
    load_and_predict(ckpt, x) 
    for ckpt in checkpoints
], axis=0)

Einsatz: Wenn mehrmalige Training-Runs zu teuer sind – nutzt bereits vorhandene Checkpoints

Selbes Modell, aber verschiedene Random Seeds oder leicht verschiedene Hyperparameter. Mehr Diversität = besser.

# 5 Runs mit verschiedenen Seeds:
models = []
for seed in [42, 123, 456, 789, 1337]:
    model = train_with_seed(seed, lr=2e-5)
    models.append(model)

# Ensemble der 5 Modelle:
ensemble_pred = np.mean([
    m.predict_proba(x) for m in models
], axis=0)

Einsatz: Wettbewerbe, wenn maximale Performance nötig

Ein Meta-Modell lernt, die Outputs der Basis-Modelle optimal zu kombinieren. Komplexer aber mächtiger.

# Stacking Ablauf:
# 1. Basis-Modelle trainieren (cross-validation)
# 2. Basis-Modell-Predictions als Features verwenden
# 3. Meta-Modell auf diese Features trainieren

# Einfachster Meta-Learner: Logistische Regression
from sklearn.linear_model import LogisticRegression
meta_features = np.column_stack([
    model1.predict_proba(X_val),
    model2.predict_proba(X_val),
    model3.predict_proba(X_val)
])
meta_model = LogisticRegression().fit(meta_features, y_val)

Einsatz: Wenn Basis-Modelle sehr verschieden sind (unterschiedliche Architekturen)