Ottimizzazione efficiente degli iperparametri con Ray Tune e YOLO26#

L'ottimizzazione degli iperparametri è fondamentale per ottenere le massime prestazioni del modello, individuando l'insieme ottimale di iperparametri. Questo processo consiste nell'eseguire prove con iperparametri diversi e nel valutare le prestazioni di ogni prova.

Accelera l'ottimizzazione con Ultralytics YOLO26 e Ray Tune#

Ultralytics YOLO26 integra Ray Tune per l'ottimizzazione degli iperparametri, semplificando l'ottimizzazione degli iperparametri del modello YOLO26. Con Ray Tune puoi utilizzare strategie di ricerca avanzate, il parallelismo e l'arresto anticipato per accelerare il processo di ottimizzazione.

Ray Tune#

Ray Tune è una libreria per l'ottimizzazione degli iperparametri progettata per garantire efficienza e flessibilità. Supporta diverse strategie di ricerca, il parallelismo e strategie di arresto anticipato e si integra perfettamente con i più diffusi framework di machine learning, tra cui Ultralytics YOLO26.

Integrazione con Weights & Biases#

YOLO26 consente anche l'integrazione facoltativa con Weights & Biases per monitorare il processo di ottimizzazione.

Installazione#

Per installare i pacchetti richiesti, esegui:

# 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

Utilizzo#

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)

Parametri del metodo tune()#

Il metodo tune() in YOLO26 offre un'interfaccia semplice da usare per l'ottimizzazione degli iperparametri con Ray Tune. Accetta diversi argomenti che ti consentono di personalizzare il processo di ottimizzazione. Di seguito trovi una spiegazione dettagliata di ogni parametro:

Personalizzando questi parametri, puoi perfezionare il processo di ottimizzazione degli iperparametri in base alle tue esigenze specifiche e alle risorse di calcolo disponibili.

Descrizione dello spazio di ricerca predefinito#

La tabella seguente elenca i parametri dello spazio di ricerca predefinito per l'ottimizzazione degli iperparametri in YOLO26 con Ray Tune. Ogni parametro ha un intervallo di valori specifico definito da tune.uniform().

Esempio di spazio di ricerca personalizzato#

In questo esempio mostriamo come utilizzare uno spazio di ricerca personalizzato per l'ottimizzazione degli iperparametri con Ray Tune e YOLO26. Fornendo uno spazio di ricerca personalizzato, puoi concentrare il processo di ottimizzazione su specifici iperparametri di interesse.

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

Nel frammento di codice precedente, creiamo un modello YOLO con i pesi pretrained "yolo26n.pt". Quindi chiamiamo il metodo tune(), specificando la configurazione del dataset con "coco8.yaml". Forniamo uno spazio di ricerca personalizzato per il tasso di apprendimento iniziale lr0 utilizzando un dizionario con la chiave "lr0" e il valore tune.uniform(1e-5, 1e-2). Infine, passiamo argomenti aggiuntivi per l'addestramento, come il numero di epoche, direttamente al metodo tune come epochs=50.

Esempio di algoritmo di ricerca#

Puoi selezionare una strategia di ricerca di Ray Tune tramite il nome. Per gli algoritmi di ricerca basati su stringhe, Ultralytics utilizzerà automaticamente la metrica di ottimizzazione predefinita dell'attività corrente e mode="max". Se search_alg non viene fornito, Ultralytics utilizza TPE multivariato di Optuna con suggerimenti consapevoli del parallelismo.

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

Se devi personalizzare il sampler del searcher o sovrascrivere la relativa metrica e modalità di ottimizzazione, passa un oggetto searcher di Ray Tune istanziato invece di una stringa.

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

Ripresa di una sessione interrotta di ottimizzazione degli iperparametri con Ray Tune#

Puoi riprendere una sessione di Ray Tune interrotta passando resume=True. Facoltativamente, puoi passare la directory name utilizzata da Ray Tune in runs/{task} per riprendere la sessione. In caso contrario, verrà ripresa l'ultima sessione interrotta. Non è necessario fornire nuovamente iterations e space, ma devi fornire di nuovo il resto degli argomenti di addestramento, inclusi data e epochs.

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)

Elaborazione dei risultati di Ray Tune#

Dopo aver eseguito un esperimento di ottimizzazione degli iperparametri con Ray Tune, potresti voler effettuare diverse analisi sui risultati ottenuti. Questa guida illustra i flussi di lavoro comuni per elaborare e analizzare questi risultati.

Caricamento dei risultati dell'esperimento Tune da una directory#

model.tune(use_ray=True) restituisce un ResultGrid di Ray e salva l'esperimento in runs/{task}/tune o in name che hai passato. Per caricare quei risultati dopo che lo script originale è uscito, riprendi la sessione, la quale ripristina le prove salvate e restituisce lo stesso ResultGrid:

from ultralytics import YOLO

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

Analisi di base a livello di esperimento#

Ottieni una panoramica delle prestazioni delle prove. Puoi verificare rapidamente se si sono verificati errori durante le prove.

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

Analisi di base a livello di prova#

Accedi alle configurazioni degli iperparametri delle singole prove e alle metriche riportate più recentemente.

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

Tracciamento dell'intera cronologia delle metriche riportate per una prova#

Puoi tracciare la cronologia delle metriche riportate per ogni prova per vedere come si sono evolute nel tempo.

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

Riepilogo#

In questa guida abbiamo illustrato i flussi di lavoro comuni per analizzare i risultati degli esperimenti eseguiti con Ray Tune utilizzando Ultralytics. I passaggi principali includono il caricamento dei risultati dell'esperimento da una directory, l'esecuzione di analisi di base a livello di esperimento e di prova e la rappresentazione grafica delle metriche.

Per approfondire, consulta la pagina della documentazione di Ray Tune Analyze Results per ottenere il massimo dai tuoi esperimenti di ottimizzazione degli iperparametri.

FAQ#