Link to this sectionEffiziente 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.

Link to this sectionBeschleunige die Optimierung mit Ultralytics YOLO26 und Ray Tune#

Ultralytics YOLO26 integriert Ray Tune für die Hyperparameter-Optimierung, was die Abstimmung der YOLO26-Modell-Hyperparameter vereinfacht. Mit Ray Tune kannst du fortschrittliche Suchstrategien, Parallelisierung und Early Stopping nutzen, um den Optimierungsprozess zu beschleunigen.

Link to this sectionRay Tune#

Ray Tune ist eine Bibliothek zur Hyperparameter-Optimierung, die auf Effizienz und Flexibilität ausgelegt ist. Sie unterstützt verschiedene Suchstrategien, Parallelisierung und Early-Stopping-Verfahren und lässt sich nahtlos in gängige Machine Learning-Frameworks integrieren, einschließlich Ultralytics YOLO26.

Link to this sectionIntegration mit Weights & Biases#

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

Link to this sectionInstallation#

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 W&B for logging
pip install wandb

Link to this sectionVerwendung#

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)

Link to this sectionParameter der tune()-Methode#

Die tune()-Methode in YOLO26 bietet eine benutzerfreundliche Schnittstelle für die Hyperparameter-Optimierung mit Ray Tune. Sie akzeptiert mehrere 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 genau auf deine Bedürfnisse und verfügbaren Rechenressourcen abstimmen.

Link to this sectionBeschreibung des Standard-Suchraums#

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

Link to this sectionBeispiel 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-Schnipsel erstellen wir ein YOLO-Modell mit den vortrainierten "yolo26n.pt"-Gewichten. Dann rufen wir die tune()-Methode auf und spezifizieren die Datensatzkonfiguration mit "coco8.yaml". Wir stellen einen benutzerdefinierten Suchraum für die anfängliche Lernrate lr0 bereit, indem wir ein Dictionary mit dem Schlüssel "lr0" und dem Wert tune.uniform(1e-5, 1e-2) verwenden. Schließlich übergeben wir zusätzliche Trainingsargumente, wie die Anzahl der Epochen, direkt an die Tune-Methode als epochs=50.

Link to this sectionBeispiel für Suchalgorithmen#

Du kannst eine Ray Tune-Suchstrategie nach ihrem Namen auswählen. Bei String-basierten Suchalgorithmen verwendet Ultralytics automatisch die Standard-Optimierungsmetrik der aktuellen Aufgabe 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-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,
)

Link to this sectionWiederaufnahme einer unterbrochenen Hyperparameter-Optimierungssitzung mit Ray Tune#

Du kannst eine unterbrochene Ray Tune-Sitzung wieder aufnehmen, indem du resume=True übergibst. Optional kannst du den Verzeichnis-name angeben, den Ray Tune unter runs/{task} verwendet hat, um fortzufahren. Andernfalls wird die letzte unterbrochene Sitzung fortgesetzt. Du musst iterations und space nicht erneut angeben, aber du musst die restlichen 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)

Link to this sectionVerarbeitung 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.

Link to this sectionLaden 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 nützlich, 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()

Link to this sectionGrundlegende 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!")

Link to this sectionGrundlegende 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}")

Link to this sectionDarstellung 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()

Link to this sectionZusammenfassung#

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.

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

Link to this sectionFAQ#

Link to this sectionWie stimme ich die Hyperparameter meines YOLO26 Modells mit Ray Tune ab?#

Um die Hyperparameter deines Ultralytics YOLO26 Modells mit Ray Tune abzustimmen, 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 das Tuning:

   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.

Link to this sectionWas sind die Standard-Hyperparameter für das YOLO26 Tuning mit Ray Tune?#

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

Diese Hyperparameter können an deine spezifischen Bedürfnisse angepasst werden. Eine vollständige Liste und weitere Details findest du im Leitfaden Hyperparameter Tuning.

Link to this sectionWie kann ich Weights & Biases in mein YOLO26 Modell-Tuning integrieren?#

Um Weights & Biases (W&B) in deinen Ultralytics YOLO26 Tuning-Prozess zu integrieren:

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)

Diese Einrichtung ermöglicht es dir, den Tuning-Prozess zu überwachen, Hyperparameter-Konfigurationen zu verfolgen und Ergebnisse in W&B zu visualisieren.

Link to this sectionWarum sollte ich Ray Tune für die Hyperparameter-Optimierung mit YOLO26 verwenden?#

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

• Fortschrittliche 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.
• Vorzeitiges Abbrechen (Early Stopping): Setzt Strategien wie ASHA ein, um leistungsschwache Versuche frühzeitig zu beenden und Rechenressourcen zu sparen.

Ray Tune lässt sich nahtlos in Ultralytics YOLO26 integrieren und bietet eine benutzerfreundliche Schnittstelle zur effektiven Abstimmung von Hyperparametern. Um loszulegen, schau dir den Leitfaden Hyperparameter Tuning an.

Link to this sectionWie kann ich einen benutzerdefinierten Suchraum für das YOLO26 Hyperparameter-Tuning definieren?#

Um einen benutzerdefinierten Suchraum für dein YOLO26 Hyperparameter-Tuning mit Ray Tune zu definieren:

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 anfängliche Lernrate und das Momentum an, die während des Tuning-Prozesses untersucht werden sollen. Für fortgeschrittene Konfigurationen siehe den Abschnitt Custom Search Space Example.