Ottimizzazione efficiente degli iperparametri con Ray Tune e YOLO26#

L'ottimizzazione degli iperparametri è fondamentale per raggiungere le massime prestazioni del modello scoprendo il set ottimale di iperparametri. Ciò comporta l'esecuzione di prove con iperparametri diversi e la valutazione delle prestazioni di ciascuna prova.

Accelera l'ottimizzazione con Ultralytics YOLO26 e Ray Tune#

Ultralytics YOLO26 incorpora Ray Tune per la sintonizzazione degli iperparametri, ottimizzando il processo di ottimizzazione degli iperparametri del modello YOLO26. Con Ray Tune, puoi utilizzare strategie di ricerca avanzate, parallelismo e arresto anticipato per velocizzare il processo di sintonizzazione.

Ray Tune#

Ray Tune è una libreria di sintonizzazione degli iperparametri progettata per efficienza e flessibilità. Supporta varie strategie di ricerca, parallelismo e strategie di arresto anticipato, e si integra perfettamente con i famosi framework di machine learning, tra cui Ultralytics YOLO26.

Integrazione con Weights & Biases#

YOLO26 consente inoltre un'integrazione opzionale con Weights & Biases per il monitoraggio del processo di sintonizzazione.

Installazione#

Per installare i pacchetti richiesti, esegui:

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

# Optionally install W&B for logging
pip install wandb

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 fornisce un'interfaccia semplice da usare per la sintonizzazione degli iperparametri con Ray Tune. Accetta diversi argomenti che ti permettono di personalizzare il processo di sintonizzazione. Di seguito è riportata una spiegazione dettagliata di ciascun parametro:

Personalizzando questi parametri, puoi perfezionare il processo di ottimizzazione degli iperparametri per soddisfare le tue esigenze specifiche e le risorse computazionali disponibili.

Descrizione dello spazio di ricerca predefinito#

La seguente tabella elenca i parametri dello spazio di ricerca predefiniti per la sintonizzazione degli iperparametri in YOLO26 con Ray Tune. Ciascun parametro ha un intervallo di valori specifico definito da tune.uniform().

Esempio di spazio di ricerca personalizzato#

In questo esempio, dimostriamo 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 sopra, creiamo un modello YOLO con i pesi preaddestrati "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 di addestramento aggiuntivi, come il numero di epoche direttamente al metodo tune come epochs=50.

Esempio di algoritmo di ricerca#

Puoi selezionare una strategia di ricerca Ray Tune per nome. Per gli algoritmi di ricerca basati su stringhe, Ultralytics utilizzerà automaticamente la metrica di ottimizzazione predefinita del task corrente e mode="max". Se search_alg non viene fornito, Ray Tune utilizza la sua strategia di ricerca casuale predefinita, 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,
)

Se hai bisogno di personalizzare il sampler del cercatore o sovrascrivere la sua metrica e modalità di ottimizzazione, passa un oggetto cercatore 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 di ottimizzazione degli iperparametri interrotta con Ray Tune#

Puoi riprendere una sessione Ray Tune interrotta passando resume=True. Puoi opzionalmente passare la directory name utilizzata da Ray Tune sotto runs/{task} per riprendere. In caso contrario, riprenderà l'ultima sessione interrotta. Non è necessario fornire nuovamente iterations e space, ma devi fornire nuovamente 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 eseguire varie analisi sui risultati ottenuti. Questa guida ti condurrà attraverso i flussi di lavoro comuni per l'elaborazione e l'analisi di questi risultati.

Caricamento dei risultati dell'esperimento di ottimizzazione da una directory#

Dopo aver eseguito l'esperimento di sintonizzazione con tuner.fit(), puoi caricare i risultati da una directory. Questo è utile, soprattutto se stai eseguendo l'analisi dopo che lo script di addestramento iniziale è terminato.

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

Analisi di base a livello di esperimento#

Ottieni una panoramica di come sono state eseguite le prove. Puoi controllare rapidamente se ci sono stati 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 singole configurazioni degli iperparametri della prova e alle ultime metriche riportate.

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

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

Puoi tracciare la cronologia delle metriche riportate per ogni prova per vedere come le metriche 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["mean_accuracy"],
        label=f"Trial {i}",
    )

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

Riepilogo#

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

Esplora ulteriormente consultando la pagina di documentazione di Ray Tune Analyze Results per ottenere il massimo dai tuoi esperimenti di sintonizzazione degli iperparametri.

FAQ#