Ottimizzazione efficiente degli iperparametri con Ray Tune e YOLO26

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

Accelera l'ottimizzazione con Ultralytics YOLO26 e Ray Tune

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

Ray Tune

Ray Tune è una libreria per l'ottimizzazione degli iperparametri progettata per efficienza e flessibilità. Supporta varie strategie di ricerca, parallelismo e strategie di arresto anticipato, e si integra perfettamente con popolari framework di machine learning, incluso Ultralytics YOLO26.

Integrazione con Weights & Biases

YOLO26 consente anche un'integrazione opzionale 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]"

# 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 facile da usare per l'ottimizzazione degli iperparametri con Ray Tune. Accetta diversi argomenti che ti permettono di personalizzare il processo di ottimizzazione. Di seguito è riportata una spiegazione dettagliata di ogni 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 predefiniti dello spazio di ricerca per l'ottimizzazione degli iperparametri in YOLO26 con Ray Tune. Ogni parametro ha uno specifico intervallo di valori 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,
)

Nello snippet di codice sopra, creiamo un modello YOLO con i pesi pre-addestrati "yolo26n.pt". Quindi, richiamiamo 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 è 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 campionatore del searcher o sovrascrivere la sua metrica e modalità di ottimizzazione, passa un oggetto searcher 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 di Ray Tune interrotta passando resume=True. Puoi opzionalmente passare la directory name utilizzata da Ray Tune in runs/{task} per riprendere. Altrimenti, 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 accompagnerà 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 ottimizzazione con tuner.fit(), puoi caricare i risultati da una directory. Questo è utile, specialmente 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 hanno funzionato 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 configurazioni degli iperparametri delle singole prove e alle ultime metriche riportate.

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 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 coperto 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 analisi di base a livello di esperimento e di prova, e il tracciamento delle metriche.

Esplora ulteriormente consultando la pagina della documentazione Analisi dei risultati di Ray Tune per ottenere il massimo dai tuoi esperimenti di ottimizzazione degli iperparametri.

FAQ

Come posso ottimizzare gli iperparametri del mio modello YOLO26 utilizzando Ray Tune?

Per ottimizzare gli iperparametri del tuo modello Ultralytics YOLO26 utilizzando Ray Tune, segui questi passaggi:

1. Installa i pacchetti richiesti:

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

2. Carica il tuo modello YOLO26 e avvia l'ottimizzazione:

   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)

Ciò utilizza le strategie di ricerca avanzate e il parallelismo di Ray Tune per ottimizzare in modo efficiente gli iperparametri del tuo modello. Per ulteriori informazioni, consulta la documentazione di Ray Tune.

Quali sono gli iperparametri predefiniti per l'ottimizzazione di YOLO26 con Ray Tune?

Ultralytics YOLO26 utilizza i seguenti iperparametri predefiniti per l'ottimizzazione con Ray Tune:

Puoi personalizzare questi iperparametri per soddisfare le tue esigenze specifiche. Per un elenco completo e maggiori dettagli, consulta la guida Hyperparameter Tuning.

Come posso integrare Weights & Biases con il tuning del mio modello YOLO26?

Per integrare Weights & Biases (W&B) con il tuo processo di tuning di Ultralytics YOLO26:

1. Installa W&B:

   pip install wandb

2. Modifica il tuo script di tuning:

   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)

Questa configurazione ti consentirà di monitorare il processo di tuning, tenere traccia delle configurazioni degli iperparametri e visualizzare i risultati su W&B.

Perché dovrei usare Ray Tune per l'ottimizzazione degli iperparametri con YOLO26?

Ray Tune offre numerosi vantaggi per l'ottimizzazione degli iperparametri:

• Strategie di ricerca avanzate: Utilizza algoritmi come la Bayesian Optimization e HyperOpt per una ricerca efficiente dei parametri.
• Parallelismo: Supporta l'esecuzione parallela di più prove, velocizzando significativamente il processo di tuning.
• Early Stopping: Impiega strategie come ASHA per terminare in anticipo le prove con prestazioni inferiori, risparmiando risorse computazionali.

Ray Tune si integra perfettamente con Ultralytics YOLO26, fornendo un'interfaccia facile da usare per ottimizzare gli iperparametri in modo efficace. Per iniziare, consulta la guida Hyperparameter Tuning.

Come posso definire uno spazio di ricerca personalizzato per il tuning degli iperparametri di YOLO26?

Per definire uno spazio di ricerca personalizzato per il tuning degli iperparametri di YOLO26 con 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)

Questo personalizza l'intervallo degli iperparametri, come il learning rate iniziale e il momentum, da esplorare durante il processo di tuning. Per configurazioni avanzate, consulta la sezione Custom Search Space Example.