Ultralytics YOLO Hyperparameter-Tuning Handbuch

Einführung

Hyperparameter-Tuning ist nicht nur eine einmalige Einrichtung, sondern ein iterativer Prozess, der darauf abzielt, die Leistungskennzahlen des Machine Learning Modells zu optimieren, wie etwa Genauigkeit, Präzision und Recall. Im Kontext von Ultralytics YOLO können diese Hyperparameter von der Lernrate bis hin zu architektonischen Details reichen, wie der Anzahl der Schichten oder den verwendeten Arten von Aktivierungsfunktionen. Die Ultralytics Platform unterstützt zudem Cloud-Training mit konfigurierbaren Hyperparametern und Echtzeit-Metrik-Tracking.

Was sind Hyperparameter?

Hyperparameter sind übergeordnete, strukturelle Einstellungen für den Algorithmus. Sie werden vor der Trainingsphase festgelegt und bleiben währenddessen konstant. Hier sind einige häufig optimierte Hyperparameter in Ultralytics YOLO:

• Lernrate lr0: Bestimmt die Schrittweite bei jeder Iteration, während man sich in der Loss-Funktion auf ein Minimum zubewegt.
• Batch-Größe batch: Anzahl der Bilder, die gleichzeitig in einem Forward-Pass verarbeitet werden.
• Anzahl der Epochen epochs: Eine Epoche ist ein vollständiger Forward- und Backward-Pass aller Trainingsbeispiele.
• Architekturspezifikationen: Wie Kanalanzahlen, Anzahl der Schichten, Arten der Aktivierungsfunktionen usw.

Eine vollständige Liste der Augmentations-Hyperparameter, die in YOLO26 verwendet werden, findest du auf der Konfigurationsseite.

Genetische Evolution und Mutation

Ultralytics YOLO verwendet genetische Algorithmen, um Hyperparameter zu optimieren. Genetische Algorithmen sind vom Mechanismus der natürlichen Selektion und Genetik inspiriert.

• Crossover: Jede Iteration kombiniert Gene von bis zu neun der bisher besten Konfigurationen unter Verwendung eines BLX-α Crossovers mit fitness-gewichteter Elternauswahl.
• Mutation: Der rekombinierte Kandidat wird dann durch einen log-normalen multiplikativen Faktor gestört, der auf jeden Hyperparameter angewendet wird (mit einer Wahrscheinlichkeit von 0,5 pro Parameter). Die Mutationsstärke Sigma nimmt über die ersten 300 Iterationen linear von 0,2 auf 0,1 ab, sodass der Algorithmus früh breit erkundet und sich bei der Konvergenz verfeinert. Iteration 1 hat keine Eltern für das Crossover und verwendet die Standard-Trainings-Hyperparameter als Basis.

Vorbereitung auf das Hyperparameter-Tuning

Bevor du mit dem Tuning-Prozess beginnst, ist es wichtig:

1. Metriken identifizieren: Bestimme die Metriken, die du zur Bewertung der Modellleistung verwenden wirst. Dies könnten AP50, F1-Score oder andere sein.
2. Tuning-Budget festlegen: Definiere, wie viele Rechenressourcen du bereit bist zuzuweisen. Hyperparameter-Tuning kann rechenintensiv sein.

Schritte des Prozesses

Hyperparameter initialisieren

Starte mit einem vernünftigen Satz an initialen Hyperparametern. Dies können entweder die von Ultralytics YOLO festgelegten Standard-Hyperparameter sein oder etwas, das auf deinem Fachwissen oder früheren Experimenten basiert.

Hyperparameter mutieren

Verwende die _mutate-Methode, um basierend auf dem bestehenden Satz einen neuen Satz von Hyperparametern zu erstellen. Die Tuner-Klasse erledigt diesen Prozess automatisch.

Modell trainieren

Das Training wird mit dem mutierten Satz an Hyperparametern durchgeführt. Die Trainingsleistung wird dann anhand deiner gewählten Metriken bewertet.

Modell evaluieren

Verwende Metriken wie AP50, F1-Score oder benutzerdefinierte Metriken, um die Leistung des Modells zu bewerten. Der Evaluierungsprozess hilft festzustellen, ob die aktuellen Hyperparameter besser sind als die vorherigen.

Ergebnisse protokollieren

Es ist entscheidend, sowohl die Leistungskennzahlen als auch die entsprechenden Hyperparameter zur zukünftigen Referenz zu protokollieren. Ultralytics YOLO speichert diese Ergebnisse automatisch im NDJSON-Format.

Wiederholen

Der Prozess wird wiederholt, bis entweder die festgelegte Anzahl an Iterationen erreicht ist oder die Leistungskennzahl zufriedenstellend ist. Jede Iteration baut auf dem Wissen aus früheren Durchläufen auf.

Beschreibung des Standard-Suchraums

Die folgende Tabelle listet die Standard-Suchraumparameter für das Hyperparameter-Tuning in YOLO26 auf. Jeder Parameter hat einen spezifischen Wertebereich, der durch ein Tupel (min, max) definiert ist.

Beispiel für einen benutzerdefinierten Suchraum

So definierst du einen Suchraum und nutzt die model.tune()-Methode, um die Tuner-Klasse für das Hyperparameter-Tuning von YOLO26n auf COCO8 für 30 Epochen mit einem AdamW-Optimizer zu verwenden, wobei Plotten, Checkpointing und Validierung außerhalb der letzten Epoche für ein schnelleres Tuning übersprungen werden.

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(
    data="coco8.yaml",
    epochs=30,
    iterations=300,
    optimizer="AdamW",
    space=search_space,
    plots=False,
    save=False,
    val=False,
)

Fortsetzen einer unterbrochenen Hyperparameter-Tuning-Sitzung

You can resume an interrupted hyperparameter tuning session by passing resume=True. You can optionally pass the directory name used under runs/{task} to resume. Otherwise, it would resume the last interrupted session. You also need to provide all the previous training arguments including data, epochs, iterations and space.

from ultralytics import YOLO

# Define a YOLO model
model = YOLO("yolo26n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Resume previous run
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, resume=True)

# Resume tuning run with name 'tune_exp'
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, name="tune_exp", resume=True)

Results

Nachdem du den Hyperparameter-Tuning-Prozess erfolgreich abgeschlossen hast, erhältst du mehrere Dateien und Verzeichnisse, die die Ergebnisse des Tunings zusammenfassen. Im Folgenden wird jede davon beschrieben:

Dateistruktur

So sieht die Verzeichnisstruktur der Ergebnisse aus. Trainingsverzeichnisse wie train1/ enthalten individuelle Tuning-Iterationen, d. h. ein Modell, das mit einem Satz an Hyperparametern trainiert wurde. Das tune/-Verzeichnis enthält Tuning-Ergebnisse aller individuellen Modelltrainings:

runs/
└── detect/
    ├── train1/
    ├── train2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── tune_fitness.png
        ├── tune_results.ndjson
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

Dateibeschreibungen

best_hyperparameters.yaml

Diese YAML-Datei enthält die leistungsstärksten Hyperparameter, die während des Tuning-Prozesses gefunden wurden. Du kannst diese Datei verwenden, um zukünftige Trainings mit diesen optimierten Einstellungen zu initialisieren.

• Format: YAML

• Verwendung: Hyperparameter-Ergebnisse

• Beispiel:

  # 558/900 iterations complete ✅ (45536.81s)
  # Results saved to /usr/src/ultralytics/runs/detect/tune
  # Best fitness=0.64297 observed at iteration 498
  # Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/dfl_loss': 0.68503, 'fitness': 0.64297}
  # Best fitness model is /usr/src/ultralytics/runs/detect/train498
  # Best fitness hyperparameters are printed below.
  
  lr0: 0.00269
  lrf: 0.00288
  momentum: 0.73375
  weight_decay: 0.00015
  warmup_epochs: 1.22935
  warmup_momentum: 0.1525
  box: 18.27875
  cls: 1.32899
  dfl: 0.56016
  hsv_h: 0.01148
  hsv_s: 0.53554
  hsv_v: 0.13636
  degrees: 0.0
  translate: 0.12431
  scale: 0.07643
  shear: 0.0
  perspective: 0.0
  flipud: 0.0
  fliplr: 0.08631
  mosaic: 0.42551
  mixup: 0.0
  copy_paste: 0.0

tune_fitness.png

Dies ist ein Diagramm, das die Fitness im Verhältnis zur Anzahl der Iterationen anzeigt. Es hilft dir zu visualisieren, wie der genetische Algorithmus über die Zeit hinweg gearbeitet hat.

• Format: PNG
• Verwendung: Leistungsvisualisierung

Das Diagramm enthält:

• Einen Marker pro Iteration pro Datensatz, sodass ein Lauf mit einem einzelnen Datensatz einen Punkt pro Iteration und ein Lauf mit mehreren Datensätzen einen Punkt pro Datensatz pro Iteration zeigt.
• Eine gepunktete "geglättete Mittelwert"-Linie, berechnet als Gaußsche Glättung (sigma=3) über die Fitnesswerte der obersten Ebene pro Iteration.

tune_results.ndjson

Eine NDJSON-Datei mit detaillierten Ergebnissen jeder Tuning-Iteration. Jede Zeile ist ein JSON-Objekt mit der aggregierten Fitness, den getunten Hyperparametern und den Metriken pro Datensatz. Das Tuning für einzelne und mehrere Datensätze verwendet dasselbe Dateiformat.

• Format: NDJSON
• Verwendung: Nachverfolgung der Ergebnisse pro Iteration.
• Beispiel:

Ein übersichtlich formatiertes Beispiel wird unten zur besseren Lesbarkeit gezeigt. In der tatsächlichen .ndjson-Datei wird jedes Objekt in einer einzelnen Zeile gespeichert.

{
    "iteration": 1,
    "fitness": 0.48628,
    "hyperparameters": {
        "lr0": 0.01,
        "lrf": 0.01,
        "momentum": 0.937,
        "weight_decay": 0.0005
    },
    "datasets": {
        "coco8": {
            "metrics/precision(B)": 0.65666,
            "metrics/recall(B)": 0.85,
            "metrics/mAP50(B)": 0.85086,
            "metrics/mAP50-95(B)": 0.64104,
            "val/box_loss": 1.57958,
            "val/cls_loss": 1.04986,
            "val/dfl_loss": 1.32641,
            "fitness": 0.64104
        },
        "coco8-grayscale": {
            "metrics/precision(B)": 0.6582,
            "metrics/recall(B)": 0.51667,
            "metrics/mAP50(B)": 0.59106,
            "metrics/mAP50-95(B)": 0.33152,
            "val/box_loss": 1.95424,
            "val/cls_loss": 1.64059,
            "val/dfl_loss": 1.70226,
            "fitness": 0.33152
        }
    },
    "save_dirs": {
        "coco8": "runs/detect/coco8",
        "coco8-grayscale": "runs/detect/coco8-grayscale"
    }
}

Die fitness der obersten Ebene ist das arithmetische Mittel der fitness-Werte pro Datensatz. Beim Tuning für einen einzelnen Datensatz hat das datasets-Dictionary einen Eintrag, dessen fitness der fitness der obersten Ebene entspricht. Pro abgeschlossener Iteration wird ein JSON-Objekt aufgezeichnet. Die tatsächlichen save_dirs-Pfade sind absolut; sie wurden oben zur besseren Lesbarkeit abgekürzt.

tune_scatter_plots.png

Diese Datei enthält Streudiagramme, die aus tune_results.ndjson generiert wurden, um dir zu helfen, die Beziehungen zwischen verschiedenen Hyperparametern und Leistungsmetriken zu visualisieren. Hyperparameter, deren Standardwert 0 ist (zum Beispiel degrees und shear unten), entwickeln sich möglicherweise nur langsam von ihrem anfänglichen Startwert, da der multiplikative Mutationsfaktor kaum Spielraum hat, um von einem Wert nahe null zu expandieren.

• Format: PNG
• Verwendung: Explorative Datenanalyse

weights/

Dieses Verzeichnis enthält die gespeicherten PyTorch-Modelle für die letzte und die beste Iteration während des Hyperparameter-Tuning-Prozesses.

• last.pt: Die last.pt sind die Gewichte aus der letzten Epoche des Trainings.
• best.pt: Die best.pt Gewichte für die Iteration, die den besten Fitness-Score erreicht hat.

Mit diesen Ergebnissen kannst du fundiertere Entscheidungen für deine zukünftigen Modelltrainings und Analysen treffen. Zögere nicht, diese Artefakte heranzuziehen, um zu verstehen, wie gut dein Modell abgeschnitten hat und wie du es weiter verbessern kannst.

Fazit

Der Hyperparameter-Tuning-Prozess in Ultralytics YOLO ist einfach und dennoch leistungsstark, dank seines auf genetischen Algorithmen basierenden Ansatzes, der BLX-α-Crossover mit log-normaler Mutation kombiniert. Das Befolgen der in diesem Leitfaden beschriebenen Schritte hilft dir dabei, dein Modell systematisch abzustimmen, um eine bessere Leistung zu erzielen.

Weiterführende Literatur

1. Hyperparameter-Optimierung bei Wikipedia
2. Leitfaden zur YOLOv5 Hyperparameter-Evolution
3. Effizientes Hyperparameter-Tuning mit Ray Tune und YOLO26

Für tiefere Einblicke kannst du den Quellcode der Tuner-Klasse und die begleitende Dokumentation erkunden. Solltest du Fragen oder Feature-Wünsche haben oder weitere Unterstützung benötigen, wende dich gerne an uns auf GitHub oder Discord.

FAQ

Wie optimiere ich die Lernrate für Ultralytics YOLO während des Hyperparameter-Tunings?

Um die Lernrate für Ultralytics YOLO zu optimieren, beginne damit, eine anfängliche Lernrate mithilfe des lr0-Parameters festzulegen. Häufige Werte liegen im Bereich von 0.001 bis 0.01. Während des Hyperparameter-Tuning-Prozesses wird dieser Wert mutiert, um die optimale Einstellung zu finden. Du kannst die model.tune()-Methode verwenden, um diesen Prozess zu automatisieren. Zum Beispiel:

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)

Weitere Details findest du auf der Konfigurationsseite von Ultralytics YOLO.

Welche Vorteile bietet die Verwendung genetischer Algorithmen für das Hyperparameter-Tuning in YOLO26?

Genetische Algorithmen in Ultralytics YOLO26 bieten eine robuste Methode zur Erforschung des Hyperparameter-Raums, was zu einer hochgradig optimierten Modellleistung führt. Zu den Hauptvorteilen gehören:

• Effiziente Suche: BLX-α-Crossover kombiniert Gene der Eltern mit der höchsten Fitness, während eine log-normale Mutation das Ergebnis stört, um neue Kandidaten zu entdecken.
• Vermeidung lokaler Minima: Durch das Einbringen von Zufall helfen sie dabei, lokale Minima zu vermeiden und eine bessere globale Optimierung sicherzustellen.
• Leistungsmetriken: Sie passen sich basierend auf einem aufgaben-spezifischen Fitness-Score an (mAP50-95 für die Detektion).

Um zu sehen, wie genetische Algorithmen Hyperparameter optimieren können, sieh dir den Leitfaden zur Hyperparameter-Evolution an.

Wie lange dauert der Hyperparameter-Tuning-Prozess für Ultralytics YOLO?

Die für das Hyperparameter-Tuning mit Ultralytics YOLO benötigte Zeit hängt stark von mehreren Faktoren ab, wie der Größe des Datensatzes, der Komplexität der Modellarchitektur, der Anzahl der Iterationen und den verfügbaren Rechenressourcen. Zum Beispiel kann das Tunen von YOLO26n auf einem Datensatz wie COCO8 für 30 Epochen je nach Hardware mehrere Stunden bis Tage dauern.

Um die Tuning-Zeit effektiv zu verwalten, lege vorab ein klares Tuning-Budget fest (interner Abschnitts-Link). Dies hilft dabei, die Ressourcenzuweisung und die Optimierungsziele in Einklang zu bringen.

Welche Metriken sollte ich verwenden, um die Modellleistung während des Hyperparameter-Tunings in YOLO zu bewerten?

Bei der Bewertung der Modellleistung während des Hyperparameter-Tunings in YOLO kannst du mehrere wichtige Metriken verwenden:

• AP50: Die durchschnittliche Präzision (Average Precision) bei einem IoU-Schwellenwert von 0,50.
• F1-Score: Das harmonische Mittel aus Präzision und Recall.
• Präzision und Recall: Individuelle Metriken, die die Genauigkeit des Modells bei der Identifizierung von True Positives im Vergleich zu False Positives und False Negatives angeben.

Diese Metriken helfen dir, verschiedene Aspekte der Leistung deines Modells zu verstehen. Siehe dir den Leitfaden zu Ultralytics YOLO Leistungsmetriken für einen umfassenden Überblick an.

Kann ich Ray Tune für die fortgeschrittene Hyperparameter-Optimierung mit YOLO26 verwenden?

Ja, Ultralytics YOLO26 lässt sich für eine fortgeschrittene Hyperparameter-Optimierung mit Ray Tune integrieren. Ray Tune bietet hochentwickelte Suchalgorithmen wie Bayesian Optimization und Hyperband sowie Möglichkeiten zur parallelen Ausführung, um den Tuning-Prozess zu beschleunigen.

Um Ray Tune mit YOLO26 zu verwenden, setze einfach den Parameter use_ray=True in deinem model.tune()-Methodenaufruf. Weitere Details und Beispiele findest du im Ray Tune Integrationsleitfaden.