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 ciascuna prova.

Accelera l'ottimizzazione con Ultralytics YOLO26 e Ray Tune#

Ultralytics YOLO26 integra Ray Tune per ottimizzare gli iperparametri, semplificando l'ottimizzazione degli iperparametri dei modelli YOLO26. Con Ray Tune puoi sfruttare 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 necessari, 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

# Carica un modello YOLO26n
model = YOLO("yolo26n.pt")

# Avvia l'ottimizzazione degli iperparametri per l'addestramento di YOLO26n sul dataset COCO8
result_grid = model.tune(data="coco8.yaml", use_ray=True)

Parametri del metodo tune()#

Il metodo tune() di YOLO26 offre un'interfaccia intuitiva 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 ciascun parametro:

Personalizzando questi parametri, puoi adattare il processo di ottimizzazione degli iperparametri 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(), ad eccezione di close_mosaic, che usa tune.randint().

Esempio di spazio di ricerca personalizzato#

In questo esempio mostriamo come usare uno spazio di ricerca personalizzato per ottimizzare gli iperparametri con Ray Tune e YOLO26. Specificando uno spazio di ricerca personalizzato, puoi concentrare l'ottimizzazione sugli iperparametri che ti interessano.

from ray import tune

from ultralytics import YOLO

# Definisci un modello YOLO
model = YOLO("yolo26n.pt")

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

Nel frammento di codice qui sopra creiamo un modello YOLO con i pesi preaddestrati "yolo26n.pt". Poi chiamiamo il metodo tune(), specificando la configurazione del dataset con "coco8.yaml". Definiamo uno spazio di ricerca personalizzato per il tasso di apprendimento iniziale lr0 usando un dizionario con la chiave "lr0" e il valore tune.uniform(1e-5, 1e-2). Infine, passiamo al metodo tune altri argomenti di addestramento, come il numero di epoche, tramite epochs=50.

Esempio di algoritmo di ricerca#

Puoi selezionare una strategia di ricerca di Ray Tune specificandone il nome. Per gli algoritmi di ricerca specificati come stringhe, Ultralytics usa automaticamente la metrica di ottimizzazione predefinita dell'attività corrente e mode="max". Se search_alg non viene specificato, Ultralytics usa TPE multivariato di Optuna con suggerimenti che tengono conto del parallelismo.

from ultralytics import YOLO

# Definisci un modello YOLO
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 sovrascriverne la metrica e la modalità di ottimizzazione, passa un oggetto searcher di Ray Tune già istanziato invece di una stringa.

from ray.tune.search.optuna import OptunaSearch

from ultralytics import YOLO

# Definisci un modello YOLO
model = YOLO("yolo26n.pt")

# Definisci un 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,
)

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

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

from ultralytics import YOLO

# Definisci un modello YOLO
model = YOLO("yolo26n.pt")

# Riprendi l'esecuzione precedente
results = model.tune(use_ray=True, data="coco8.yaml", epochs=50, resume=True)

# Riprendi l'esecuzione di Ray Tune con il nome '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 analizzare i risultati ottenuti in vari modi. Questa guida illustra i flussi di lavoro più 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 oppure nella directory name che hai specificato. Per caricare i risultati dopo la chiusura dello script originale, riprendi la sessione: così verranno ripristinate le prove salvate e verrà restituito 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 dei risultati 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ù di recente.

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

Creazione di un grafico dell'intera cronologia delle metriche riportate per una prova#

Puoi tracciare la cronologia delle metriche riportate per ciascuna prova e osservare come sono cambiate 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 più comuni per analizzare i risultati degli esperimenti eseguiti con Ray Tune tramite Ultralytics. I passaggi principali consistono nel caricare i risultati dell'esperimento da una directory, eseguire analisi di base a livello di esperimento e di prova e tracciare le metriche.

Per approfondire, consulta la pagina della documentazione di Ray Tune Analizzare i risultati e sfrutta al meglio i tuoi esperimenti di ottimizzazione degli iperparametri.

Domande frequenti#