Effiziente Hyperparameterabstimmung mit Ray Tune und YOLO26#

Die Hyperparameterabstimmung ist entscheidend, um die maximale Modellleistung zu erreichen, indem die optimale Kombination von Hyperparametern ermittelt wird. Dazu werden Durchläufe mit unterschiedlichen Hyperparametern ausgeführt und deren Leistung bewertet.

Beschleunigte Abstimmung mit Ultralytics YOLO26 und Ray Tune#

Ultralytics YOLO26 nutzt Ray Tune zur Hyperparameterabstimmung und vereinfacht dadurch die Optimierung der YOLO26-Modellhyperparameter. Mit Ray Tune kannst du fortschrittliche Suchstrategien, Parallelisierung und frühzeitiges Beenden nutzen, um den Abstimmungsprozess zu beschleunigen.

Ray Tune#

Ray Tune ist eine auf Effizienz und Flexibilität ausgelegte Bibliothek zur Hyperparameterabstimmung. Sie unterstützt verschiedene Suchstrategien, Parallelisierung und Strategien zum frühzeitigen Beenden und lässt sich nahtlos in gängige Frameworks für maschinelles Lernen integrieren, darunter Ultralytics YOLO26.

Integration mit Weights & Biases#

YOLO26 ermöglicht außerdem die optionale Integration mit Weights & Biases zur Überwachung des Abstimmungsprozesses.

Installation#

Führe zur Installation 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

# Load a YOLO26n model
model = YOLO("yolo26n.pt")

# Start tuning hyperparameters for YOLO26n training on the COCO8 dataset
result_grid = model.tune(data="coco8.yaml", use_ray=True)

Parameter der Methode tune()#

Die Methode tune() in YOLO26 bietet eine benutzerfreundliche Schnittstelle zur Hyperparameterabstimmung mit Ray Tune. Sie akzeptiert mehrere Argumente, mit denen du den Abstimmungsprozess anpassen kannst. Im Folgenden werden die einzelnen Parameter ausführlich erläutert:

Durch die Anpassung dieser Parameter kannst du den Hyperparameter-Optimierungsprozess auf deine spezifischen Anforderungen und die verfügbaren Rechenressourcen abstimmen.

Beschreibung des Standardsuchraums#

Die folgende Tabelle enthält die Standardsuchraumparameter für die Hyperparameterabstimmung von YOLO26 mit Ray Tune. Für jeden Parameter ist durch tune.uniform() ein bestimmter Wertebereich definiert.

Beispiel für einen benutzerdefinierten Suchraum#

In diesem Beispiel zeigen wir, wie du einen benutzerdefinierten Suchraum für die Hyperparameterabstimmung mit Ray Tune und YOLO26 verwendest. Mit einem benutzerdefinierten Suchraum kannst du den Abstimmungsprozess auf bestimmte interessante Hyperparameter konzentrieren.

from ray import tune

from ultralytics import YOLO

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

# Run Ray Tune on the model
result_grid = model.tune(
    data="coco8.yaml",
    space={"lr0": tune.uniform(1e-5, 1e-2)},
    epochs=50,
    use_ray=True,
)

Im obigen Codeausschnitt erstellen wir ein YOLO-Modell mit den vortrainierten Gewichten „yolo26n.pt“. Anschließend rufen wir die Methode tune() auf und geben die Dataset-Konfiguration mit „coco8.yaml“ an. Für die anfängliche Lernrate lr0 übergeben wir einen benutzerdefinierten Suchraum als Dictionary mit dem Schlüssel „lr0“ und dem Wert tune.uniform(1e-5, 1e-2). Schließlich übergeben wir zusätzliche Trainingsargumente, beispielsweise die Anzahl der Epochen, direkt als epochs=50 an die Tune-Methode.

Beispiel für einen Suchalgorithmus#

Du kannst eine Suchstrategie von Ray Tune anhand ihres Namens auswählen. Bei Suchalgorithmen auf Zeichenfolgenbasis verwendet Ultralytics automatisch die standardmäßige Optimierungsmetrik der aktuellen Aufgabe und mode="max". Wenn search_alg nicht angegeben wird, verwendet Ultralytics multivariates TPE von Optuna mit parallelisierungsbewussten Vorschlägen.

from ultralytics import YOLO

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

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

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

from ray.tune.search.optuna import OptunaSearch

from ultralytics import YOLO

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

# Define a searcher
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 Hyperparameterabstimmungssitzung mit Ray Tune fortsetzen#

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

from ultralytics import YOLO

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

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

# Resume Ray Tune run with name 'tune_exp_2'
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, name="tune_exp_2", resume=True)

Ray-Tune-Ergebnisse verarbeiten#

Nach einem Hyperparameterabstimmungsexperiment mit Ray Tune 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.

Tune-Experimentergebnisse aus einem Verzeichnis laden#

model.tune(use_ray=True) gibt einen Ray ResultGrid zurück und speichert das Experiment unter runs/{task}/tune oder unter dem von dir übergebenen name. Um diese Ergebnisse nach dem Beenden des ursprünglichen Skripts zu laden, nimm die Sitzung wieder auf, wodurch die gespeicherten Versuche wiederhergestellt werden und denselben ResultGrid zurückgibt:

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 Durchläufe. Du kannst schnell prüfen, ob während der Durchläufe Fehler aufgetreten sind.

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

Grundlegende Analyse auf Durchlaufebene#

Greife auf die Hyperparameterkonfigurationen einzelner Durchläufe und die zuletzt gemeldeten Metriken zu.

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

Den vollständigen Verlauf der gemeldeten Metriken eines Durchlaufs darstellen#

Du kannst den Verlauf der gemeldeten Metriken für jeden Durchlauf 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 Experimenten mit Ray Tune und Ultralytics behandelt. Zu den wichtigsten Schritten gehören das Laden der Experimentergebnisse aus einem Verzeichnis, die grundlegende Analyse auf Experiment- und Durchlaufebene sowie die Darstellung der Metriken.

Weitere Informationen findest du auf der Ray-Tune-Dokumentationsseite „Ergebnisse analysieren“, um das Beste aus deinen Hyperparameterabstimmungsexperimenten herauszuholen.

FAQ#