Effiziente Hyperparameteroptimierung mit Ray Tune und YOLO26#

Die Optimierung von Hyperparametern ist entscheidend, um die bestmögliche Modellleistung zu erzielen, indem die optimale Kombination von Hyperparametern gefunden wird. Dazu werden Versuche mit unterschiedlichen Hyperparametern durchgeführt und die Leistung jedes einzelnen Versuchs bewertet.

Beschleunige die Optimierung mit Ultralytics YOLO26 und Ray Tune#

Ultralytics YOLO26 integriert Ray Tune zur Optimierung von Hyperparametern und vereinfacht so die Optimierung der YOLO26-Modellparameter. Mit Ray Tune kannst du fortschrittliche Suchstrategien, Parallelisierung und vorzeitigen Abbruch nutzen, um den Optimierungsprozess zu beschleunigen.

Ray Tune#

Ray Tune ist eine Bibliothek zur Optimierung von Hyperparametern, die auf Effizienz und Flexibilität ausgelegt ist. Sie unterstützt verschiedene Suchstrategien, Parallelisierung und Strategien zum vorzeitigen Abbruch und lässt sich nahtlos in beliebte Frameworks für maschinelles Lernen integrieren, darunter Ultralytics YOLO26.

Integration mit Weights & Biases#

YOLO26 unterstützt außerdem die optionale Integration mit Weights & Biases, um den Optimierungsprozess zu überwachen.

Installation#

Führe zum Installieren der erforderlichen Pakete Folgendes aus:

# Install and update Ultralytics and Ray Tune packages
pip install -U ultralytics "ray[tune]" optuna

# Optionally install and enable W&B for per-trial logging
pip install wandb
yolo settings wandb=True

Verwendung#

from ultralytics import YOLO

# Ein YOLO26n-Modell laden
model = YOLO("yolo26n.pt")

# Die Optimierung der Hyperparameter für das Training von YOLO26n mit dem COCO8-Datensatz starten
result_grid = model.tune(data="coco8.yaml", use_ray=True)

Parameter der Methode tune()#

Die Methode tune() in YOLO26 bietet eine benutzerfreundliche Schnittstelle zur Optimierung von Hyperparametern mit Ray Tune. Sie akzeptiert mehrere Argumente, mit denen du den Optimierungsprozess anpassen kannst. Im Folgenden findest du eine ausführliche Erklärung der einzelnen Parameter:

Wenn du diese Parameter anpasst, kannst du den Prozess der Hyperparameteroptimierung auf deine Anforderungen und verfügbaren Rechenressourcen abstimmen.

Beschreibung des Standardsuchraums#

Die folgende Tabelle enthält die Standardparameter des Suchraums für die Hyperparameteroptimierung mit YOLO26 und Ray Tune. Für jeden Parameter ist ein bestimmter Wertebereich festgelegt, der von tune.uniform() definiert wird. Eine Ausnahme ist close_mosaic, für das tune.randint() verwendet wird.

Beispiel für einen benutzerdefinierten Suchraum#

In diesem Beispiel zeigen wir, wie du mit einem benutzerdefinierten Suchraum die Hyperparameteroptimierung mit Ray Tune und YOLO26 durchführst. Mit einem benutzerdefinierten Suchraum kannst du die Optimierung auf bestimmte Hyperparameter konzentrieren, die dich interessieren.

from ray import tune

from ultralytics import YOLO

# YOLO-Modell definieren
model = YOLO("yolo26n.pt")

# Ray Tune für das Modell ausführen
result_grid = model.tune(
    data="coco8.yaml",
    space={"lr0": tune.uniform(1e-5, 1e-2)},
    epochs=50,
    use_ray=True,
)

Im obigen Codebeispiel erstellen wir ein YOLO-Modell mit den vortrainierten Gewichten "yolo26n.pt". Anschließend rufen wir die Methode tune() auf und geben mit "coco8.yaml" die Konfiguration des Datensatzes an. Für die anfängliche Lernrate lr0 legen wir mit einem Wörterbuch einen benutzerdefinierten Suchraum fest, dessen Schlüssel "lr0" und dessen Wert tune.uniform(1e-5, 1e-2) ist. Schließlich übergeben wir zusätzliche Trainingsargumente, beispielsweise die Anzahl der Epochen, direkt an die Tune-Methode als epochs=50.

Beispiel für einen Suchalgorithmus#

Du kannst eine Suchstrategie von Ray Tune anhand ihres Namens auswählen. Bei Suchalgorithmen, die über Zeichenfolgen angegeben werden, verwendet Ultralytics automatisch die Standardmetrik zur Optimierung für die aktuelle Aufgabe sowie mode="max". Wenn search_alg nicht angegeben ist, verwendet Ultralytics Optunas multivariates TPE mit parallelitätsbewussten Vorschlägen.

from ultralytics import YOLO

# YOLO-Modell definieren
model = YOLO("yolo26n.pt")

result_grid = model.tune(
    data="coco8.yaml",
    epochs=50,
    search_alg="optuna",
    use_ray=True,
)

Wenn du den Sampler des Suchers anpassen oder dessen Metrik und Optimierungsmodus überschreiben möchtest, übergib statt einer Zeichenfolge ein instanziiertes Ray-Tune-Sucherobjekt.

from ray.tune.search.optuna import OptunaSearch

from ultralytics import YOLO

# YOLO-Modell definieren
model = YOLO("yolo26n.pt")

# Einen Sucher definieren
searcher = OptunaSearch(
    metric="metrics/mAP50-95(B)",
    mode="max",
)

result_grid = model.tune(
    data="coco8.yaml",
    epochs=50,
    search_alg=searcher,
    use_ray=True,
)

Eine unterbrochene Hyperparameteroptimierungssitzung mit Ray Tune fortsetzen#

Du kannst eine unterbrochene Ray-Tune-Sitzung fortsetzen, indem du resume=True übergibst. Optional kannst du das Verzeichnis name übergeben, das Ray Tune unter runs/{task} verwendet, um die Sitzung fortzusetzen. Andernfalls wird die zuletzt unterbrochene Sitzung fortgesetzt. iterations und space musst du nicht erneut angeben, aber die übrigen Trainingsargumente musst du erneut übergeben, einschließlich data und epochs.

from ultralytics import YOLO

# YOLO-Modell definieren
model = YOLO("yolo26n.pt")

# Vorherigen Lauf fortsetzen
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, resume=True)

# Ray-Tune-Lauf mit dem Namen 'tune_exp_2' fortsetzen
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, name="tune_exp_2", resume=True)

Ray-Tune-Ergebnisse verarbeiten#

Nachdem du ein Hyperparameteroptimierungsexperiment mit Ray Tune ausgeführt hast, möchtest du möglicherweise verschiedene Analysen der erzielten Ergebnisse durchführen. Dieser Leitfaden führt dich durch gängige Arbeitsabläufe zur Verarbeitung und Analyse dieser Ergebnisse.

Ergebnisse eines Tune-Experiments aus einem Verzeichnis laden#

model.tune(use_ray=True) gibt ein Ray-ResultGrid zurück und speichert das Experiment unter runs/{task}/tune oder unter dem von dir angegebenen name. Um diese Ergebnisse nach Beendigung des ursprünglichen Skripts zu laden, setze die Sitzung fort. Dadurch werden die gespeicherten Versuche wiederhergestellt und dasselbe ResultGrid zurückgegeben:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
result_grid = model.tune(data="coco8.yaml", epochs=50, use_ray=True, resume=True)

Grundlegende Analyse auf Experimenteebene#

Verschaffe dir einen Überblick über die Leistung der Versuche. Du kannst schnell prüfen, ob während der Versuche Fehler aufgetreten sind.

if result_grid.errors:
    print("One or more trials failed!")
else:
    print("No errors!")

Grundlegende Analyse auf Versuchsebene#

Rufe die Hyperparameterkonfigurationen einzelner Versuche und die zuletzt gemeldeten Metriken ab.

for i, result in enumerate(result_grid):
    print(f"Trial #{i}: Configuration: {result.config}, Last Reported Metrics: {result.metrics}")

Den gesamten Verlauf der für einen Versuch gemeldeten Metriken darstellen#

Du kannst den Verlauf der für jeden Versuch gemeldeten Metriken darstellen, um zu sehen, wie sich die Metriken im Laufe der Zeit entwickelt haben.

import matplotlib.pyplot as plt

for i, result in enumerate(result_grid):
    plt.plot(
        result.metrics_dataframe["training_iteration"],
        result.metrics_dataframe["metrics/mAP50-95(B)"],
        label=f"Trial {i}",
    )

plt.xlabel("Training Iterations")
plt.ylabel("mAP50-95")
plt.legend()
plt.show()

Zusammenfassung#

In diesem Leitfaden haben wir gängige Arbeitsabläufe zur Analyse der Ergebnisse von mit Ultralytics ausgeführten Ray-Tune-Experimenten behandelt. Zu den wichtigsten Schritten gehören das Laden der Versuchsergebnisse aus einem Verzeichnis, grundlegende Analysen auf Experimente- und Versuchsebene sowie das Darstellen der Metriken.

Weitere Informationen findest du in der Ray-Tune-Dokumentation unter Ergebnisse analysieren, damit du das Beste aus deinen Hyperparameteroptimierungsexperimenten herausholst.

Häufig gestellte Fragen#