Guida di Ultralytics YOLO all'ottimizzazione degli iperparametri#

L'ottimizzazione degli iperparametri in Ultralytics YOLO è una ricerca automatizzata e iterativa che ottimizza impostazioni — come il tasso di apprendimento, i pesi delle funzioni di perdita e l'intensità dell'aumento dei dati — per massimizzare le metriche di prestazione di un modello di machine learning, come accuratezza, precisione e richiamo. Invece di testare questi valori manualmente, Ultralytics YOLO esplora lo spazio degli iperparametri con un algoritmo genetico che modifica e valuta configurazioni candidate attraverso numerose sessioni di addestramento brevi.

Cosa sono gli iperparametri?#

Gli iperparametri sono impostazioni strutturali di alto livello dell'algoritmo. Vengono definiti prima della fase di addestramento e rimangono costanti durante questa fase. Ecco alcuni degli iperparametri più comunemente ottimizzati in Ultralytics YOLO:

• Tasso di apprendimento lr0: determina l'ampiezza del passo a ogni iterazione mentre ci si avvicina a un minimo della funzione di perdita.
• Dimensione del batch batch: numero di immagini elaborate contemporaneamente in un passaggio in avanti.
• Numero di epoche epochs: un'epoca corrisponde a un passaggio completo in avanti e all'indietro su tutti gli esempi di addestramento.
• Dettagli dell'architettura: ad esempio, numero di canali, numero di livelli, tipi di funzioni di attivazione e così via. Questi elementi si trovano nella configurazione YAML del modello, non negli argomenti di addestramento.

Tra questi quattro, solo il tasso di apprendimento rientra nello spazio di ricerca predefinito: batch, epochs e l'architettura rimangono fissi. L'ottimizzatore modifica anche la pianificazione, i coefficienti delle funzioni di perdita e gli aumenti dei dati elencati di seguito.

Per l'elenco completo degli iperparametri di aumento dei dati usati in YOLO26, consulta la pagina delle configurazioni.

Evoluzione genetica e mutazione#

Ultralytics YOLO usa algoritmi genetici per ottimizzare gli iperparametri. Gli algoritmi genetici si ispirano ai meccanismi della selezione naturale e della genetica.

• Selezione: a ogni iterazione viene selezionata una delle configurazioni con il punteggio di fitness più alto, fino a un massimo di nove, con probabilità proporzionale al punteggio di fitness. Dopo 30 risultati, anche il 20% dei risultati migliori (fino a un massimo di 30) contribuisce a stimare la covarianza dei parametri, con un'influenza che aumenta man mano che si accumulano evidenze sulle configurazioni d'élite.
• Mutazione: a ogni iterazione viene modificata circa la metà dei parametri usando passi gaussiani normalizzati in base ai rispettivi intervalli di ricerca. Quando la covarianza è attiva, una quota ponderata in base al livello di confidenza, fino a un massimo del 40%, usa passi correlati; il ripiegamento riporta questi passi entro i limiti senza accumulare valori troncati. Man mano che si accumulano prove senza miglioramenti, le dimensioni dei passi si riducono linearmente fino al 20% nell'arco di 25 prove e vengono ripristinate quando si trova un nuovo risultato migliore. L'iterazione 1 non ha un elemento genitore e usa gli iperparametri di addestramento predefiniti come riferimento.

Preparazione all'ottimizzazione degli iperparametri#

Prima di iniziare il processo di ottimizzazione, è importante:

1. Identificare le metriche: l'ottimizzatore integrato (use_ray=False) classifica le prove in base al punteggio fitness dell'attività, mentre use_ray=True usa la metrica dell'attività. Decidi quali metriche secondarie esaminare, come AP50 o il punteggio F1.
2. Definire il budget di ottimizzazione: stabilisci quante risorse di calcolo vuoi allocare. L'ottimizzazione degli iperparametri può richiedere molte risorse di calcolo.

Come funziona il ciclo di ottimizzazione#

A ogni iterazione, l'ottimizzatore integrato ripete il ciclo seguente:

1. Inizializzare gli iperparametri — partire da un riferimento ragionevole: gli iperparametri predefiniti impostati da Ultralytics YOLO oppure valori basati sulle tue conoscenze del dominio o su esperimenti precedenti.
2. Modificare gli iperparametri — la classe Tuner genera automaticamente un nuovo insieme di iperparametri a partire da quello esistente usando il metodo _mutate.
3. Addestrare il modello — addestrare il modello usando gli iperparametri modificati, quindi valutare le prestazioni di addestramento con le metriche scelte.
4. Valutare il modello — il processo di valutazione produce il punteggio di fitness dell'iterazione, che viene confrontato con quelli delle iterazioni precedenti per determinare se gli iperparametri correnti rappresentano un miglioramento.
5. Registrare i risultati — annotare le metriche di prestazione e i relativi iperparametri per consultarli in futuro. Ultralytics YOLO salva automaticamente questi risultati in formato NDJSON.
6. Ripetere — continuare fino a raggiungere il numero di iterazioni stabilito; ogni iterazione si basa sulle conoscenze acquisite nelle esecuzioni precedenti. L'ottimizzatore integrato esegue tutti i iterations; Ray Tune restituisce le metriche dopo ogni epoca di fit, consentendo ad ASHA di interrompere le prove poco promettenti una volta trascorso il periodo di tolleranza.

Numero di iterazioni e dimensione della popolazione#

Con l'ottimizzatore genetico integrato (use_ray=False), iterations controlla il numero totale di prove sequenziali e il valore predefinito è 300. Ogni prova addestra un modello con una configurazione di iperparametri: ad esempio, iterations=40 con epochs=50 pianifica 40 esecuzioni di addestramento indipendenti di 50 epoche ciascuna, non un'unica esecuzione di 50 epoche con una popolazione separata di 40 candidati.

L'algoritmo genetico integrato non ha un parametro esplicito per la dimensione della popolazione. Quando sono disponibili prove precedenti, seleziona fino a nove configurazioni con i punteggi di fitness più alti e modifica un candidato per iterazione.

Per eseguire prove in parallelo o usare strategie di ricerca più avanzate, imposta use_ray=True per usare Ray Tune, che adotta lo stesso valore predefinito di 300 prove e riceve iterations come num_samples. Per i dettagli, consulta la guida all'integrazione di Ray Tune.

Spazio di ricerca predefinito#

La tabella seguente 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 usare il metodo model.tune() per utilizzare la classe Tuner e ottimizzare gli iperparametri di YOLO26n su COCO8 per 30 epoche con un ottimizzatore AdamW, saltando la generazione dei grafici, il salvataggio dei checkpoint e la convalida, tranne che nell'epoca finale, per velocizzare l'ottimizzazione.

from ultralytics import YOLO

# Inizializza il modello YOLO
model = YOLO("yolo26n.pt")

# Definisci lo spazio di ricerca
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

# Ottimizza gli iperparametri su COCO8 per 30 epoche
model.tune(
    data="coco8.yaml",
    epochs=30,
    iterations=300,
    optimizer="AdamW",
    space=search_space,
    plots=False,
    save=False,
    val=False,
)

Riprendere una sessione di ottimizzazione degli iperparametri interrotta#

Puoi riprendere una sessione di ottimizzazione degli iperparametri interrotta passando resume=True. Facoltativamente, puoi passare la directory name usata da runs/{task} per riprendere la sessione. Se non specifichi name, la ripresa avviene dalla directory chiamata letteralmente tune, che è il nome predefinito e non quello della sessione eseguita più di recente; quindi, passa name per qualsiasi esecuzione avviata con un nome personalizzato. Devi anche fornire tutti gli argomenti di addestramento precedenti, inclusi data, epochs, iterations e space.

from ultralytics import YOLO

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

# Definisci lo spazio di ricerca
search_space = {
    "lr0": (1e-5, 1e-2),
    "degrees": (0.0, 45.0),
}

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

# Riprendi l'esecuzione di ottimizzazione con il nome 'tune_exp'
results = model.tune(data="coco8.yaml", epochs=50, iterations=300, space=search_space, name="tune_exp", resume=True)

Risultati#

Al termine dell'ottimizzazione degli iperparametri, otterrai diversi file e directory che raccolgono i risultati dell'ottimizzazione. Di seguito è descritta ciascuna voce:

Struttura dei file#

Ecco come apparirà la struttura delle directory dei risultati. Le directory delle sessioni di ricerca, come multitrain/ e multitrain-2/, contengono le singole iterazioni di ottimizzazione: una per ogni modello addestrato su ciascun dataset con un insieme di iperparametri, in una sottodirectory denominata in base al dataset. Per risparmiare spazio, l'ottimizzatore elimina le directory delle esecuzioni per dataset delle iterazioni che non sono le migliori correnti. La directory tune/ contiene i risultati dell'ottimizzazione di tutti i singoli addestramenti dei modelli:

runs/
└── detect/
    ├── multitrain/
    │   └── coco8/
    ├── multitrain-2/
    ├── ...
    └── tune/
        ├── best_hyperparameters.yaml
        ├── tune_fitness.png
        ├── tune_results.ndjson
        ├── tune_scatter_plots.png
        └── weights/
            ├── last.pt
            └── best.pt

Descrizione dei file#

best_hyperparameters.yaml#

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

• Formato: YAML

• Uso: 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/l1_loss': 0.68503, 'fitness': 0.64297}
  # Best fitness model is /usr/src/ultralytics/runs/detect/tune/weights
  # 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 grafico mostra il punteggio di fitness in funzione del numero di iterazioni. Ti aiuta a visualizzare l'andamento dell'algoritmo genetico nel tempo.

• Formato: PNG
• Uso: visualizzazione delle prestazioni

Il grafico contiene:

• Un indicatore per ogni iterazione e per ogni dataset: un'esecuzione con un solo dataset mostra un punto per iterazione, mentre un'esecuzione con più dataset mostra un punto per ciascun dataset a ogni iterazione.
• Una linea tratteggiata della "media smussata", calcolata applicando uno smoothing gaussiano (sigma=3) ai valori di fitness di primo livello per ogni iterazione.

tune_results.ndjson#

Un file NDJSON che contiene i risultati dettagliati di ogni iterazione di ottimizzazione. Ogni riga è un oggetto JSON con il punteggio di fitness aggregato, gli iperparametri ottimizzati e le metriche per ciascun dataset. L'ottimizzazione con un singolo dataset e quella con più dataset usano lo stesso formato di file.

• Formato: NDJSON
• Uso: monitoraggio dei risultati per iterazione.
• Esempio:

Di seguito è riportato un esempio formattato per facilitarne la lettura; nel file .ndjson effettivo, 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/l1_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/l1_loss": 1.70226,
            "fitness": 0.33152
        }
    },
    "save_dirs": {
        "coco8": "runs/detect/multitrain/coco8",
        "coco8-grayscale": "runs/detect/multitrain/coco8-grayscale"
    }
}

Il valore di primo livello fitness è la media aritmetica dei valori fitness di ciascun dataset. Nell'ottimizzazione con un solo dataset, il dizionario datasets contiene una voce, il cui valore fitness corrisponde al valore fitness di primo livello. Viene registrato un oggetto JSON per ogni iterazione completata. I percorsi save_dirs effettivi sono assoluti; qui sono abbreviati per facilitarne la lettura.

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 le metriche di prestazione. La mutazione usa l'intervallo configurato per ogni iperparametro, quindi i valori possono evolvere anche da impostazioni predefinite pari a zero come degrees e shear.

• Formato: PNG
• Uso: analisi esplorativa dei dati

weights/#

Questa directory contiene i modelli PyTorch salvati dall'iterazione con il punteggio di fitness migliore dell'esecuzione di ottimizzazione. Entrambi i file provengono dalla stessa iterazione:

• last.pt: last.pt contiene i pesi dell'ultima epoca di addestramento.
• best.pt: i pesi best.pt appartengono all'iterazione che ha ottenuto il punteggio di fitness migliore.

Usando questi risultati, puoi prendere decisioni più consapevoli per i futuri addestramenti e le analisi dei modelli.

Conclusione#

L'ottimizzazione degli iperparametri in Ultralytics YOLO è semplice da avviare e potente al suo interno: utilizza una selezione ponderata in base alla fitness e una mutazione normalizzata rispetto all'intervallo in un algoritmo genetico. Seguendo il ciclo descritto in questa guida, puoi ottimizzare sistematicamente il tuo modello per ottenere prestazioni migliori e poi riutilizzare il risultato best_hyperparameters.yaml per inizializzare i futuri cicli di addestramento. Per estendere l'ottimizzazione a prove parallele e ad algoritmi di ricerca più avanzati, continua con la guida all'integrazione di Ray Tune, oppure esegui job gestiti con iperparametri configurabili e monitoraggio delle metriche in tempo reale su Ultralytics Platform tramite l'addestramento nel cloud.

Per le impostazioni non esposte da alcun argomento, come i tassi di apprendimento per livello o una metrica di fitness personalizzata, crea una sottoclasse del trainer. Per approfondire, esplora il codice sorgente della classe Tuner. Se hai domande o richieste di funzionalità, contattaci su GitHub o Discord.

Domande frequenti#