Effiziente Hyperparameter-Optimierung mit Ray Tune und YOLO26

Die Hyperparameter-Optimierung ist entscheidend, um durch das Finden der optimalen Hyperparameter-Sets eine Spitzenleistung des Modells zu erzielen. Dies beinhaltet die Durchführung von Testläufen mit verschiedenen Hyperparametern und die anschließende Bewertung der Performance jedes einzelnen Laufs.

Beschleunige die Optimierung mit Ultralytics YOLO26 und Ray Tune

Ultralytics YOLO26 integriert Ray Tune zur Hyperparameter-Optimierung, was die Optimierung der YOLO26-Modell-Hyperparameter vereinfacht. Mit Ray Tune kannst du fortschrittliche Suchstrategien, Parallelisierung und frühzeitiges Stoppen nutzen, um den Optimierungsprozess zu beschleunigen.

Ray Tune

Ray Tune ist eine Bibliothek für Hyperparameter-Optimierung, die auf Effizienz und Flexibilität ausgelegt ist. Sie unterstützt verschiedene Suchstrategien, Parallelisierung sowie Strategien zum frühzeitigen Stoppen und lässt sich nahtlos in gängige Machine Learning-Frameworks integrieren, einschließlich Ultralytics YOLO26.

Integration mit Weights & Biases

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

Installation

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

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

# Optionally install W&B for logging
pip install wandb

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)

tune()-Methodenparameter

Die tune()-Methode in YOLO26 bietet eine einfach zu bedienende Schnittstelle für die Hyperparameter-Optimierung mit Ray Tune. Sie akzeptiert verschiedene Argumente, mit denen du den Optimierungsprozess anpassen kannst. Nachfolgend findest du eine detaillierte Erläuterung jedes Parameters:

Durch die Anpassung dieser Parameter kannst du den Hyperparameter-Optimierungsprozess so feinabstimmen, dass er deinen spezifischen Anforderungen und den verfügbaren Rechenressourcen entspricht.

Beschreibung des Standard-Suchraums

Die folgende Tabelle listet die Standard-Suchraumparameter für die Hyperparameter-Optimierung in YOLO26 mit Ray Tune auf. Jeder Parameter hat einen spezifischen 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 spezifische Hyperparameter von Interesse 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 Code-Snippet oben erstellen wir ein YOLO-Modell mit den vortrainierten Gewichten "yolo26n.pt". Dann rufen wir die tune()-Methode auf und spezifizieren die Dataset-Konfiguration mit "coco8.yaml". Wir stellen einen benutzerdefinierten Suchraum für die initiale Lernrate lr0 bereit, indem wir ein Dictionary mit dem Key "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 an die Tune-Methode mit epochs=50.

Beispiel für Suchalgorithmus

Du kannst eine Ray Tune-Suchstrategie nach Namen auswählen. Bei string-basierten Suchalgorithmen verwendet Ultralytics automatisch die Standard-Optimierungsmetrik des aktuellen Tasks und mode="max". Wenn search_alg nicht angegeben ist, 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-Sucher-Objekt 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. Optional kannst du den Verzeichnisnamen name übergeben, den Ray Tune unter runs/{task} verwendet hat. Andernfalls wird die zuletzt unterbrochene Sitzung fortgesetzt. Du musst iterations und space nicht erneut angeben, aber du musst die restlichen Trainingsargumente inklusive data und epochs erneut übermitteln.

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 von Ray Tune-Ergebnissen

Nach der Durchführung eines Hyperparameter-Optimierungsexperiments mit Ray Tune möchtest du möglicherweise verschiedene Analysen der erhaltenen Ergebnisse durchführen. Dieser Leitfaden führt dich durch gängige Workflows zur Verarbeitung und Analyse dieser Ergebnisse.

Laden von Tune-Experiment-Ergebnissen aus einem Verzeichnis

Nachdem das Optimierungsexperiment mit tuner.fit() ausgeführt wurde, kannst du die Ergebnisse aus einem Verzeichnis laden. Dies ist nützlich, insbesondere wenn du die Analyse durchführst, nachdem das ursprüngliche 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 Experiment-Ebene

Verschaffe dir einen Überblick darüber, wie die Testläufe abgeschnitten haben. Du kannst schnell überprüfen, ob während der Testläufe Fehler aufgetreten sind.

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

Grundlegende Analyse auf Trial-Ebene

Greife auf die Hyperparameter-Konfigurationen einzelner Testlä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}")

Darstellung der gesamten Historie gemeldeter Metriken für einen Testlauf

Du kannst die Historie der für jeden Testlauf gemeldeten Metriken plotten, 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 Workflows behandelt, um die Ergebnisse von Experimenten zu analysieren, 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 Trial-Ebene sowie das Plotten von Metriken.

Erkunde weiter, indem du dir die Analyze Results-Dokumentationsseite von Ray Tune ansiehst, um das Beste aus deinen Hyperparameter-Optimierungsexperimenten herauszuholen.

FAQ

Wie optimiere ich die Hyperparameter meines YOLO26-Modells mit Ray Tune?

Um die Hyperparameter deines Ultralytics YOLO26-Modells mit Ray Tune zu optimieren, befolge diese Schritte:

1. Installiere die erforderlichen Pakete:

   pip install -U ultralytics "ray[tune]"
   pip install wandb # optional for logging

2. Lade dein YOLO26-Modell und starte die Optimierung:

   from ultralytics import YOLO
   
   # Load a YOLO26 model
   model = YOLO("yolo26n.pt")
   
   # Start tuning with the COCO8 dataset
   result_grid = model.tune(data="coco8.yaml", use_ray=True)

Dies nutzt die fortschrittlichen Suchstrategien und die Parallelisierung von Ray Tune, um die Hyperparameter deines Modells effizient zu optimieren. Weitere Informationen findest du in der Ray Tune-Dokumentation.

Was sind die Standard-Hyperparameter für die YOLO26-Optimierung mit Ray Tune?

Ultralytics YOLO26 verwendet die folgenden Standard-Hyperparameter für die Optimierung mit Ray Tune:

Diese Hyperparameter können an deine spezifischen Anforderungen angepasst werden. Eine vollständige Liste und weitere Details findest du im Leitfaden zur Hyperparameter-Optimierung.

Wie kann ich Weights & Biases in mein YOLO26-Modell-Tuning integrieren?

So integrierst du Weights & Biases (W&B) in deinen Ultralytics YOLO26-Tuning-Prozess:

1. Installiere W&B:

   pip install wandb

2. Passe dein Tuning-Skript an:

   import wandb
   
   from ultralytics import YOLO
   
   wandb.init(project="YOLO-Tuning", entity="your-entity")
   
   # Load YOLO model
   model = YOLO("yolo26n.pt")
   
   # Tune hyperparameters
   result_grid = model.tune(data="coco8.yaml", use_ray=True)

Dieses Setup ermöglicht es dir, den Tuning-Prozess zu überwachen, Hyperparameter-Konfigurationen nachzuverfolgen und Ergebnisse in W&B zu visualisieren.

Warum sollte ich Ray Tune für die Hyperparameter-Optimierung mit YOLO26 verwenden?

Ray Tune bietet zahlreiche Vorteile für die Hyperparameter-Optimierung:

• Fortgeschrittene Suchstrategien: Nutzt Algorithmen wie Bayesian Optimization und HyperOpt für eine effiziente Parametersuche.
• Parallelisierung: Unterstützt die parallele Ausführung mehrerer Versuche, was den Tuning-Prozess erheblich beschleunigt.
• Early Stopping: Verwendet Strategien wie ASHA, um leistungsschwache Versuche frühzeitig zu beenden und Rechenressourcen zu sparen.

Ray Tune lässt sich nahtlos in Ultralytics YOLO26 integrieren und bietet eine einfach zu bedienende Schnittstelle für eine effektive Hyperparameter-Optimierung. Um loszulegen, schau dir den Leitfaden zur Hyperparameter-Optimierung an.

Wie kann ich einen benutzerdefinierten Suchraum für das YOLO26-Hyperparameter-Tuning definieren?

So definierst du einen benutzerdefinierten Suchraum für dein YOLO26-Hyperparameter-Tuning mit Ray Tune:

from ray import tune

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
search_space = {"lr0": tune.uniform(1e-5, 1e-2), "momentum": tune.uniform(0.7, 0.98)}
result_grid = model.tune(data="coco8.yaml", space=search_space, use_ray=True)

Dies passt den Bereich der Hyperparameter wie die initiale Lernrate und das Momentum an, die während des Tuning-Prozesses untersucht werden sollen. Für fortgeschrittene Konfigurationen siehe den Abschnitt Beispiel für einen benutzerdefinierten Suchraum.