Epoch

Eine Epoche ist ein vollständiger Durchlauf eines Modells für maschinelles Lernen durch den gesamten Trainingsdatensatz. Während einer Epoche trägt jedes Trainingsbeispiel genau einmal zur Aktualisierung der Modellgewichte bei. Deep-Learning-Modelle lernen selten genug in einem einzigen Durchlauf. Daher wird das Training über viele Epochen ausgeführt, wobei der Fehler auf den Trainingsdaten typischerweise mit jeder Epoche sinkt, während das Netz seine Vorhersagen verfeinert.

Epoche, Batch und Iteration im Vergleich#

Drei Begriffe beschreiben den Aufbau eines Trainingslaufs. Jeder Begriff ist in den vorhergehenden eingebettet:

• Epoche: Ein vollständiger Durchlauf durch den Trainingsdatensatz.
• Batch: Eine Gruppe von Beispielen, die gemeinsam in einem Schritt verarbeitet werden. Datensätze passen selten vollständig in den GPU-Speicher. Daher wird jede Epoche in Batches aufgeteilt, üblicherweise nachdem die Daten gemischt wurden.
• Iteration: Eine Aktualisierung der Gewichte, die erfolgt, nachdem die Verlustfunktion für einen Batch berechnet wurde und ihre Gradienten durch Backpropagation zurückfließen. „Schritt“ ist ein Synonym.

Die Anzahl der Iterationen pro Epoche entspricht der Datensatzgröße geteilt durch die Batchgröße, aufgerundet. Ein Datensatz mit 1.000 Bildern und einer Batchgröße von 100 erfordert 10 Iterationen pro Epoche. Bei 50 Epochen werden also 500 Gewichtsaktualisierungen vorgenommen. In PyTorch wird dieser Aufbau durch zwei verschachtelte Schleifen umgesetzt: eine äußere Schleife über die Epochen und eine innere Schleife über die Batches, die von DataLoader bereitgestellt werden.

import torch
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(0)

# 1,000 noisy samples of the line y = 3x + 2, served in shuffled batches of 100
x = torch.rand(1000, 1)
y = 3 * x + 2 + 0.1 * torch.randn(1000, 1)
loader = DataLoader(TensorDataset(x, y), batch_size=100, shuffle=True)

model = torch.nn.Linear(1, 1)
optimizer = torch.optim.SGD(model.parameters(), lr=0.5)

for epoch in range(5):  # one epoch = one full pass over all 1,000 samples
    for xb, yb in loader:  # 1,000 / 100 = 10 iterations per epoch
        loss = torch.nn.functional.mse_loss(model(xb), yb)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch + 1}: {len(loader)} iterations, last batch loss {loss.item():.4f}")

Jede Epoche umfasst 10 Iterationen. Der Verlust auf dem letzten Batch sinkt von 0,1096 nach der ersten Epoche auf 0,0088 nach der fünften, während das Modell sich an die tatsächliche Gerade annähert. Bei Verwendung von Datenerweiterung sieht das Modell in jeder Epoche eine frisch veränderte Version jedes Bildes. Spätere Epochen bringen dadurch Abwechslung statt exakter Wiederholungen.

Die Anzahl der Epochen wählen#

Die Anzahl der Epochen ist eine der wichtigsten Einstellungen bei der Hyperparameteroptimierung. Zu wenige Epochen führen zu Unteranpassung, bei der sowohl der Fehler auf den Trainingsdaten als auch auf den Validierungsdaten hoch bleibt. Zu viele Epochen begünstigen Überanpassung: Der Trainingsverlust sinkt weiter, während der Wert auf den Validierungsdaten stagniert oder fällt, weil das Modell begonnen hat, sich die Trainingsbeispiele einzuprägen. Die richtige Anzahl hängt von der Datensatzgröße, der Modellgröße, dem Zeitplan für die Lernrate und davon ab, ob das Training mit vortrainierten Gewichten per Transferlernen beginnt. Auch der Maßstab spielt eine Rolle: Kleine Bilddatensätze werden häufig über Hunderte von Epochen trainiert, während große Sprachmodelle einen Großteil ihrer Daten weniger als einmal sehen. GPT-3 absolvierte 0,44 Epochen mit seinen gefilterten Common-Crawl-Daten.

Frühzeitiger Trainingsabbruch automatisiert die Auswahl. Das Modell wird nach jeder Epoche anhand der Validierungsdaten bewertet, der beste Prüfpunkt wird gespeichert und das Training endet, wenn sich der Wert auf den Validierungsdaten für eine festgelegte Anzahl von Epochen, die sogenannte Geduld, nicht verbessert hat.

Trainingszeitpläne auf Grundlage von Epochen#

Über den Abbruchzeitpunkt hinaus ändern sich viele Trainingseinstellungen nach einem Zeitplan für Epochen, etwa das Aufwärmen und Absenken der Lernrate oder die Stärke der Datenerweiterung. Beim Training mit Ultralytics YOLO ist sowohl für epochs als auch für patience standardmäßig der Wert 100 festgelegt. Die Lernrate wird während der ersten 3 Epochen aufgewärmt, und die Mosaikerweiterung wird in den letzten 10 Epochen deaktiviert (close_mosaic=10), damit das Modell zum Abschluss mit Bildern trainiert wird, die realen Eingaben ähneln. Das Trainingsrezept für YOLO26 zeigt, wie stark die Anzahl je nach Modellgröße variiert: Auf 150 Epochen Vortraining mit Objects365 folgte das Feintuning mit COCO, das für YOLO26n 245 Epochen und für YOLO26x 40 Epochen dauerte.

from ultralytics import YOLO

# Lade ein vortrainiertes YOLO26n-Modell
model = YOLO("yolo26n.pt")

# Mit 50 Epochen trainieren: 50 vollständige Durchläufe durch die COCO8-Trainingsbilder
results = model.train(data="coco8.yaml", epochs=50, imgsz=640)

Während dieses Laufs validiert der Trainer das Modell YOLO26 nach jeder Epoche, überschreibt jedes Mal last.pt und speichert best.pt, sobald die Validierungsleistung, die bei der Erkennung anhand von mAP_50-95 gemessen wird, einen neuen Höchstwert erreicht.