Effiziente Hyperparameter-Optimierung mit Ray Tune und YOLO26#

Die Hyperparameter-Optimierung ist entscheidend, um die maximale Modellleistung durch das Finden der optimalen Hyperparameter-Sets zu erreichen. Dies umfasst das Durchführen von Testläufen mit verschiedenen Hyperparametern und die Bewertung der Leistung jedes Durchlaufs.

Beschleunige die Optimierung mit Ultralytics YOLO26 und Ray Tune#

Ultralytics YOLO26 integriert Ray Tune für das Hyperparameter-Tuning und optimiert so die Hyperparameter des YOLO26-Modells. Mit Ray Tune kannst du fortschrittliche Suchstrategien, Parallelisierung und Early Stopping nutzen, um den Tuning-Prozess zu beschleunigen.

Ray Tune#

Ray Tune ist eine auf Effizienz und Flexibilität ausgelegte Bibliothek für Hyperparameter-Tuning. Sie unterstützt verschiedene Suchstrategien, Parallelisierung sowie Early-Stopping-Strategien und lässt sich nahtlos in gängige Machine-Learning-Frameworks, einschließlich Ultralytics YOLO26, integrieren.

Integration mit Weights & Biases#

YOLO26 ermöglicht zudem eine optionale Integration mit Weights & Biases zur Überwachung des Tuning-Prozesses.

Installation#

Um die erforderlichen Pakete zu installieren, führe aus:

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

# 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)

Methodenparameter für tune()#

Die Methode tune() in YOLO26 bietet eine benutzerfreundliche Schnittstelle für das Hyperparameter-Tuning mit Ray Tune. Sie akzeptiert mehrere Argumente, mit denen du den Tuning-Prozess anpassen kannst. Unten findest du eine detaillierte Erklärung der einzelnen Parameter:

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

Beschreibung des Standard-Suchraums#

Die folgende Tabelle listet die Standardparameter des Suchraums für das Hyperparameter-Tuning in YOLO26 mit Ray Tune auf. Jeder Parameter hat einen bestimmten Wertebereich, der durch tune.uniform() definiert ist.

Beispiel für einen benutzerdefinierten Suchraum#

In diesem Beispiel zeigen wir, wie man einen benutzerdefinierten Suchraum für die Hyperparameter-Optimierung mit Ray Tune und YOLO26 verwendet. Durch die Bereitstellung eines benutzerdefinierten Suchraums kannst du den Optimierungsprozess auf bestimmte Hyperparameter von Interesse fokussieren.

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 Code-Snippet erstellen wir ein YOLO-Modell mit den vortrainierten Gewichten "yolo26n.pt". Dann rufen wir die Methode tune() auf und geben die Dataset-Konfiguration mit "coco8.yaml" an. Wir stellen einen benutzerdefinierten Suchraum für die initiale Lernrate lr0 bereit, indem wir ein Wörterbuch mit dem Schlüssel "lr0" und dem Wert tune.uniform(1e-5, 1e-2) verwenden. Schließlich übergeben wir zusätzliche Trainingsargumente, wie etwa die Anzahl der Epochen, direkt als epochs=50 an die Tune-Methode.

Beispiel für Suchalgorithmen#

Du kannst eine Ray-Tune-Suchstrategie nach Namen auswählen. Bei string-basierten Suchalgorithmen verwendet Ultralytics automatisch die Standard-Optimierungsmetrik der aktuellen Aufgabe und mode="max". Wenn search_alg nicht angegeben wird, verwendet Ray Tune seine Standard-Zufallssuchstrategie BasicVariantGenerator.

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 Suchers anpassen oder dessen Metrik und Optimierungsmodus überschreiben musst, übergib stattdessen ein instanziiertes Ray Tune-Suchobjekt anstelle eines Strings.

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,
)

Wiederaufnahme einer unterbrochenen Hyperparameter-Optimierungssitzung mit Ray Tune#

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

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)

Verarbeitung der Ray Tune-Ergebnisse#

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

Laden von Tune-Experimentergebnissen aus einem Verzeichnis#

Nachdem du das Tuning-Experiment mit tuner.fit() ausgeführt hast, kannst du die Ergebnisse aus einem Verzeichnis laden. Dies ist besonders dann nützlich, wenn du die Analyse durchführst, nachdem das initiale Trainingsskript beendet wurde.

experiment_path = f"{storage_path}/{exp_name}"
print(f"Loading results from {experiment_path}...")

restored_tuner = tune.Tuner.restore(experiment_path, trainable=train_mnist)
result_grid = restored_tuner.get_results()

Grundlegende Analyse auf Experimentebene#

Erhalte einen Überblick darüber, wie die Versuche abgeschnitten haben. 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#

Greife auf einzelne Hyperparameter-Konfigurationen der Versuche 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}")

Darstellung des gesamten Verlaufs der gemeldeten Metriken für einen Versuch#

Du kannst den Verlauf der gemeldeten Metriken für jeden Versuch grafisch 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["mean_accuracy"],
        label=f"Trial {i}",
    )

plt.xlabel("Training Iterations")
plt.ylabel("Mean Accuracy")
plt.legend()
plt.show()

Zusammenfassung#

In diesem Leitfaden haben wir gängige Arbeitsabläufe zur Analyse der Ergebnisse von Experimenten behandelt, die mit Ray Tune unter Verwendung von Ultralytics durchgeführt wurden. Die wichtigsten Schritte umfassen das Laden der Experimentergebnisse aus einem Verzeichnis, die Durchführung grundlegender Analysen auf Experiment- und Versuchsebene sowie die grafische Darstellung der Metriken.

Erfahre mehr, indem du in der Analyze Results-Dokumentationsseite von Ray Tune nachliest, um das Beste aus deinen Hyperparameter-Tuning-Experimenten herauszuholen.

FAQ#