Guida alla ottimizzazione degli iperparametri di Ultralytics YOLO

Introduzione

L'ottimizzazione degli iperparametri non è solo un'impostazione una tantum, ma un processo iterativo volto a ottimizzare le metriche di prestazione del modello di machine learning, come accuratezza, precisione e richiamo. Nel contesto di Ultralytics YOLO, questi iperparametri possono variare dal tasso di apprendimento ai dettagli architetturali, come il numero di livelli o i tipi di funzioni di attivazione utilizzati. Ultralytics Platform supporta anche l'addestramento nel cloud con iperparametri configurabili e monitoraggio delle metriche in tempo reale.

Cosa sono gli iperparametri?

Gli iperparametri sono impostazioni strutturali di alto livello per l'algoritmo. Vengono definiti prima della fase di addestramento e rimangono costanti durante essa. Ecco alcuni iperparametri comunemente ottimizzati in Ultralytics YOLO:

• Tasso di apprendimento lr0: Determina la dimensione del passo a ogni iterazione mentre ci si muove verso un minimo nella funzione di perdita.
• Dimensione del batch batch: Numero di immagini elaborate simultaneamente in un passaggio in avanti.
• Numero di epoche epochs: Un'epoca è un passaggio completo in avanti e all'indietro di tutti gli esempi di addestramento.
• Specifiche dell'architettura: Come conteggi dei canali, numero di livelli, tipi di funzioni di attivazione, ecc.

Per un elenco completo degli iperparametri di aumento utilizzati in YOLO26, consulta la pagina delle configurazioni.

Evoluzione genetica e mutazione

Ultralytics YOLO utilizza algoritmi genetici per ottimizzare gli iperparametri. Gli algoritmi genetici sono ispirati al meccanismo della selezione naturale e della genetica.

• Crossover: Ogni iterazione combina geni provenienti da un massimo di nove delle configurazioni con la fitness più alta viste finora, utilizzando il crossover BLX-α con selezione dei genitori pesata per fitness.
• Mutazione: Il candidato ricombinato viene poi perturbato da un fattore moltiplicativo log-normale applicato a ciascun iperparametro (con probabilità 0,5 per parametro). La forza della mutazione sigma decade linearmente da 0,2 a 0,1 nelle prime 300 iterazioni, in modo che l'algoritmo esplori ampiamente all'inizio e rifinisca man mano che converge. L'iterazione 1 non ha genitori da cui eseguire il crossover e utilizza gli iperparametri di addestramento predefiniti come base.

Preparazione all'ottimizzazione degli iperparametri

Prima di iniziare il processo di ottimizzazione, è importante:

1. Identificare le metriche: Determina le metriche che utilizzerai per valutare le prestazioni del modello. Potrebbero essere AP50, F1-score o altre.
2. Impostare il budget di ottimizzazione: Definisci quante risorse computazionali sei disposto ad allocare. L'ottimizzazione degli iperparametri può essere computazionalmente intensiva.

Passaggi coinvolti

Inizializzare gli iperparametri

Inizia con un set ragionevole di iperparametri iniziali. Potrebbero essere gli iperparametri predefiniti impostati da Ultralytics YOLO o qualcosa basato sulla tua conoscenza del dominio o su esperimenti precedenti.

Mutare gli iperparametri

Utilizza il metodo _mutate per produrre un nuovo set di iperparametri basato su quello esistente. La classe Tuner gestisce questo processo automaticamente.

Addestrare il modello

L'addestramento viene eseguito utilizzando il set mutato di iperparametri. Le prestazioni dell'addestramento vengono quindi valutate utilizzando le metriche scelte.

Valutare il modello

Utilizza metriche come AP50, F1-score o metriche personalizzate per valutare le prestazioni del modello. Il processo di valutazione aiuta a determinare se gli iperparametri attuali sono migliori di quelli precedenti.

Registrare i risultati

È fondamentale registrare sia le metriche di prestazione che gli iperparametri corrispondenti per riferimento futuro. Ultralytics YOLO salva automaticamente questi risultati in formato NDJSON.

Ripetere

Il processo viene ripetuto fino a quando non viene raggiunto il numero stabilito di iterazioni o la metrica di prestazione è soddisfacente. Ogni iterazione si basa sulla conoscenza acquisita dalle esecuzioni precedenti.

Descrizione dello spazio di ricerca predefinito

La seguente tabella elenca i parametri dello spazio di ricerca predefinito per l'ottimizzazione degli iperparametri in YOLO26. Ogni parametro ha un intervallo di valori specifico definito da una tupla (min, max).

Esempio di spazio di ricerca personalizzato

Ecco come definire uno spazio di ricerca e utilizzare il metodo model.tune() per sfruttare la classe Tuner per l'ottimizzazione degli iperparametri di YOLO26n su COCO8 per 30 epoche con un ottimizzatore AdamW, saltando la creazione di grafici, il salvataggio dei checkpoint e la validazione eccetto che nell'epoca finale per un'ottimizzazione più rapida.

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(
    data="coco8.yaml",
    epochs=30,
    iterations=300,
    optimizer="AdamW",
    space=search_space,
    plots=False,
    save=False,
    val=False,
)

Ripresa di una sessione di ottimizzazione degli iperparametri interrotta

Puoi riprendere una sessione di ottimizzazione degli iperparametri interrotta passando resume=True. Puoi facoltativamente passare la directory name utilizzata sotto runs/{task} per riprendere. Altrimenti, riprenderà l'ultima sessione interrotta. Devi anche fornire tutti gli argomenti di addestramento precedenti, inclusi data, epochs, iterations e space.

from ultralytics import YOLO

# Define a YOLO model
model = YOLO("yolo26n.pt")

# Define search space
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Resume previous run
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, resume=True)

# Resume tuning run with name 'tune_exp'
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, name="tune_exp", resume=True)

Results

Dopo aver completato con successo il processo di ottimizzazione degli iperparametri, otterrai diversi file e directory che racchiudono i risultati dell'ottimizzazione. Di seguito viene descritto ciascuno:

Struttura dei file

Ecco come apparirà la struttura delle directory dei risultati. Le directory di addestramento come train1/ contengono singole iterazioni di ottimizzazione, ovvero un modello addestrato con un set di iperparametri. La directory tune/ contiene i risultati di ottimizzazione da tutti i singoli addestramenti del modello:

runs/
└── detect/
    ├── train1/
    ├── train2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── tune_fitness.png
        ├── tune_results.ndjson
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

Descrizioni dei file

best_hyperparameters.yaml

Questo file YAML contiene gli iperparametri con le prestazioni migliori riscontrati durante il processo di ottimizzazione. Puoi usare questo file per inizializzare addestramenti futuri con queste impostazioni ottimizzate.

• Formato: YAML

• Utilizzo: Risultati degli iperparametri

• Esempio:

  # 558/900 iterations complete ✅ (45536.81s)
  # Results saved to /usr/src/ultralytics/runs/detect/tune
  # Best fitness=0.64297 observed at iteration 498
  # Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/dfl_loss': 0.68503, 'fitness': 0.64297}
  # Best fitness model is /usr/src/ultralytics/runs/detect/train498
  # Best fitness hyperparameters are printed below.
  
  lr0: 0.00269
  lrf: 0.00288
  momentum: 0.73375
  weight_decay: 0.00015
  warmup_epochs: 1.22935
  warmup_momentum: 0.1525
  box: 18.27875
  cls: 1.32899
  dfl: 0.56016
  hsv_h: 0.01148
  hsv_s: 0.53554
  hsv_v: 0.13636
  degrees: 0.0
  translate: 0.12431
  scale: 0.07643
  shear: 0.0
  perspective: 0.0
  flipud: 0.0
  fliplr: 0.08631
  mosaic: 0.42551
  mixup: 0.0
  copy_paste: 0.0

tune_fitness.png

Questo è un grafico che mostra l'adattamento (fitness) rispetto al numero di iterazioni. Ti aiuta a visualizzare come l'algoritmo genetico ha performato nel tempo.

• Formato: PNG
• Utilizzo: Visualizzazione delle prestazioni

Il grafico contiene:

• Un marcatore per iterazione per dataset, quindi un'esecuzione su singolo dataset mostra un punto per iterazione, mentre un'esecuzione su dataset multipli mostra un punto per dataset per iterazione.
• Una linea tratteggiata di "media livellata" calcolata come una levigatura Gaussiana (sigma=3) sui valori di fitness di alto livello per iterazione.

tune_results.ndjson

Un file NDJSON contenente risultati dettagliati di ogni iterazione di ottimizzazione. Ogni riga è un oggetto JSON con la fitness aggregata, gli iperparametri ottimizzati e le metriche per dataset. L'ottimizzazione su singolo dataset e su dataset multipli utilizzano lo stesso formato di file.

• Formato: NDJSON
• Utilizzo: Tracciamento dei risultati per iterazione.
• Esempio:

Un esempio formattato in modo leggibile (pretty-printed) è mostrato di seguito. Nel file .ndjson reale, ogni oggetto è memorizzato su una singola riga.

{
    "iteration": 1,
    "fitness": 0.48628,
    "hyperparameters": {
        "lr0": 0.01,
        "lrf": 0.01,
        "momentum": 0.937,
        "weight_decay": 0.0005
    },
    "datasets": {
        "coco8": {
            "metrics/precision(B)": 0.65666,
            "metrics/recall(B)": 0.85,
            "metrics/mAP50(B)": 0.85086,
            "metrics/mAP50-95(B)": 0.64104,
            "val/box_loss": 1.57958,
            "val/cls_loss": 1.04986,
            "val/dfl_loss": 1.32641,
            "fitness": 0.64104
        },
        "coco8-grayscale": {
            "metrics/precision(B)": 0.6582,
            "metrics/recall(B)": 0.51667,
            "metrics/mAP50(B)": 0.59106,
            "metrics/mAP50-95(B)": 0.33152,
            "val/box_loss": 1.95424,
            "val/cls_loss": 1.64059,
            "val/dfl_loss": 1.70226,
            "fitness": 0.33152
        }
    },
    "save_dirs": {
        "coco8": "runs/detect/coco8",
        "coco8-grayscale": "runs/detect/coco8-grayscale"
    }
}

La fitness di alto livello è la media aritmetica dei valori di fitness per dataset. Per l'ottimizzazione su singolo dataset, il dizionario datasets ha una voce la cui fitness equivale alla fitness di alto livello. Un oggetto JSON viene registrato per ogni iterazione completata. I percorsi reali di save_dirs sono assoluti; sono abbreviati sopra per leggibilità.

tune_scatter_plots.png

Questo file contiene grafici a dispersione generati da tune_results.ndjson, che ti aiutano a visualizzare le relazioni tra diversi iperparametri e metriche di prestazione. Gli iperparametri il cui valore predefinito è 0 (per esempio, degrees e shear qui sotto) potrebbero evolvere solo lentamente dal loro seme iniziale perché il fattore di mutazione moltiplicativo ha pochissimo da espandere da un valore prossimo allo zero.

• Formato: PNG
• Utilizzo: Analisi esplorativa dei dati

weights/

Questa directory contiene i modelli PyTorch salvati per le ultime iterazioni e per quelle migliori durante il processo di ottimizzazione degli iperparametri.

• last.pt: Il file last.pt contiene i pesi dell'ultima epoca di addestramento.
• best.pt: I pesi best.pt per l'iterazione che ha raggiunto il miglior punteggio di fitness.

Usando questi risultati, puoi prendere decisioni più informate per i tuoi futuri addestramenti e analisi dei modelli. Sentiti libero di consultare questi artefatti per capire quanto bene ha performato il tuo modello e come potresti migliorarlo ulteriormente.

Conclusione

Il processo di ottimizzazione degli iperparametri in Ultralytics YOLO è semplificato ma potente, grazie al suo approccio basato su algoritmi genetici che combina il crossover BLX-α con la mutazione log-normale. Seguire i passaggi delineati in questa guida ti aiuterà a ottimizzare sistematicamente il tuo modello per ottenere prestazioni migliori.

Ulteriori letture

1. Ottimizzazione degli iperparametri su Wikipedia
2. Guida all'evoluzione degli iperparametri YOLOv5
3. Ottimizzazione efficiente degli iperparametri con Ray Tune e YOLO26

Per approfondimenti, puoi esplorare il codice sorgente della classe Tuner e la relativa documentazione. Se hai domande, richieste di nuove funzionalità o hai bisogno di ulteriore assistenza, non esitare a contattarci su GitHub o Discord.

FAQ

Come posso ottimizzare il learning rate per Ultralytics YOLO durante l'ottimizzazione degli iperparametri?

Per ottimizzare il learning rate per Ultralytics YOLO, inizia impostando un learning rate iniziale usando il parametro lr0. I valori comuni vanno da 0.001 a 0.01. Durante il processo di ottimizzazione degli iperparametri, questo valore verrà mutato per trovare l'impostazione ottimale. Puoi utilizzare il metodo model.tune() per automatizzare questo processo. Ad esempio:

from ultralytics import YOLO

# Initialize the YOLO model
model = YOLO("yolo26n.pt")

# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)

Per ulteriori dettagli, consulta la pagina di configurazione di Ultralytics YOLO.

Quali sono i vantaggi dell'utilizzo degli algoritmi genetici per l'ottimizzazione degli iperparametri in YOLO26?

Gli algoritmi genetici in Ultralytics YOLO26 forniscono un metodo robusto per esplorare lo spazio degli iperparametri, portando a prestazioni del modello altamente ottimizzate. I vantaggi principali includono:

• Ricerca efficiente: Il crossover BLX-α combina i geni dei genitori con la fitness più alta, mentre la mutazione log-normale perturba il risultato per scoprire nuovi candidati.
• Evitare i minimi locali: Introducendo casualità, aiutano a evitare i minimi locali, garantendo una migliore ottimizzazione globale.
• Metriche di prestazione: Si adattano in base a un punteggio di fitness specifico per il compito (mAP50-95 per il rilevamento).

Per vedere come gli algoritmi genetici possono ottimizzare gli iperparametri, dai un'occhiata alla guida all'evoluzione degli iperparametri.

Quanto tempo richiede il processo di ottimizzazione degli iperparametri per Ultralytics YOLO?

Il tempo richiesto per l'ottimizzazione degli iperparametri con Ultralytics YOLO dipende in gran parte da diversi fattori come la dimensione del dataset, la complessità dell'architettura del modello, il numero di iterazioni e le risorse computazionali disponibili. Ad esempio, ottimizzare YOLO26n su un dataset come COCO8 per 30 epoche potrebbe richiedere da diverse ore a giorni, a seconda dell'hardware.

Per gestire efficacemente il tempo di ottimizzazione, definisci in anticipo un budget chiaro per l'ottimizzazione (collegamento alla sezione interna). Questo aiuta a bilanciare l'allocazione delle risorse e gli obiettivi di ottimizzazione.

Quali metriche dovrei usare per valutare le prestazioni del modello durante l'ottimizzazione degli iperparametri in YOLO?

Quando valuti le prestazioni del modello durante l'ottimizzazione degli iperparametri in YOLO, puoi utilizzare diverse metriche chiave:

• AP50: La precisione media (Average Precision) alla soglia IoU di 0.50.
• F1-Score: La media armonica tra precisione e recall.
• Precisione e Recall: Metriche individuali che indicano l'accuratezza del modello nell'identificare veri positivi rispetto a falsi positivi e falsi negativi.

Queste metriche ti aiutano a comprendere diversi aspetti delle prestazioni del tuo modello. Fai riferimento alla guida sulle metriche di prestazione di Ultralytics YOLO per una panoramica completa.

Posso usare Ray Tune per l'ottimizzazione avanzata degli iperparametri con YOLO26?

Sì, Ultralytics YOLO26 si integra con Ray Tune per un'ottimizzazione avanzata degli iperparametri. Ray Tune offre algoritmi di ricerca sofisticati come l'Ottimizzazione Bayesiana e Hyperband, insieme a capacità di esecuzione parallela per velocizzare il processo di ottimizzazione.

Per utilizzare Ray Tune con YOLO26, imposta semplicemente il parametro use_ray=True nella chiamata al tuo metodo model.tune(). Per maggiori dettagli ed esempi, consulta la guida all'integrazione di Ray Tune.