Guida Ultralytics YOLO alla regolazione degli iperparametri#

La regolazione degli iperparametri in Ultralytics YOLO è una ricerca automatizzata e iterativa che ottimizza impostazioni — come il learning rate, i pesi della loss e l'intensità dell'augmentation — per massimizzare metriche delle prestazioni del modello di machine learning come accuratezza, precisione e recall. Invece di testare manualmente questi valori, Ultralytics YOLO esplora lo spazio degli iperparametri con un algoritmo genetico che modifica e valuta configurazioni candidate attraverso numerose brevi esecuzioni di training.

Cosa sono gli iperparametri?#

Gli iperparametri sono impostazioni strutturali di alto livello dell'algoritmo. Vengono impostati prima della fase di training e rimangono costanti durante quest'ultima. Ecco alcuni degli iperparametri comunemente regolati in Ultralytics YOLO:

• Learning rate lr0: determina la dimensione del passo a ogni iterazione mentre ci si avvicina a un minimo nella funzione di loss.
• Dimensione del batch batch: numero di immagini elaborate simultaneamente in un forward pass.
• Numero di epoche epochs: un'epoca è un forward pass e backward pass completi di tutti gli esempi di training.
• Dettagli dell'architettura: ad esempio numero di canali, numero di layer, tipi di funzioni di attivazione, ecc. Questi elementi si trovano nella configurazione YAML del modello, non negli argomenti di training.

Di questi quattro, solo il learning rate fa parte dello spazio di ricerca predefinito: batch, epochs e l'architettura rimangono fissi. Il tuner modifica anche lo schedule, i coefficienti della loss e le augmentation elencate di seguito.

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

Evoluzione e mutazione genetica#

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

• Selezione: a ogni iterazione viene selezionata una delle configurazioni con fitness più elevata, fino a un massimo di nove, con ponderazione basata sulla fitness. Dopo 30 risultati, il 20% migliore di tutti i risultati (fino a 30) stima anche la covarianza dei parametri, con un'influenza che cresce man mano che si accumulano evidenze sulle configurazioni d'élite.
• Mutazione: a ogni iterazione viene modificata circa la metà dei parametri utilizzando passi gaussiani normalizzati in base ai rispettivi intervalli di ricerca. Quando la covarianza è attiva, una quota ponderata per la confidenza, pari al massimo al 40%, utilizza passi correlati, mentre la riflessione riporta tali passi entro i limiti senza accumulare valori troncati. Man mano che si accumulano trial senza miglioramenti, le dimensioni dei passi si restringono linearmente fino al 20% nell'arco di 25 trial e vengono reimpostate quando viene trovato un nuovo risultato migliore. L'iterazione 1 non ha un genitore e utilizza gli iperparametri di training predefiniti come baseline.

Preparazione alla regolazione degli iperparametri#

Prima di iniziare il processo di regolazione, è importante:

1. Identificare le metriche: il tuner integrato (use_ray=False) classifica i trial in base al punteggio fitness dell'attività, mentre use_ray=True utilizza la metrica dell'attività. Decidi quali metriche secondarie esaminare, come AP50 o F1-score.
2. Impostare il budget di regolazione: definisci quante risorse computazionali sei disposto ad allocare. La regolazione degli iperparametri può richiedere molte risorse computazionali.

Come funziona il ciclo di regolazione#

A ogni iterazione, il tuner integrato ripete il ciclo seguente:

1. Inizializzare gli iperparametri — parti da una baseline ragionevole, costituita dagli iperparametri predefiniti impostati da Ultralytics YOLO oppure da valori basati sulle tue conoscenze del dominio o su esperimenti precedenti.
2. Modificare gli iperparametri — la classe Tuner produce automaticamente un nuovo insieme di iperparametri a partire da quello esistente tramite il metodo _mutate.
3. Eseguire il training del modello — esegui il training utilizzando gli iperparametri modificati, quindi valuta le prestazioni del training con le metriche scelte.
4. Valutare il modello — il processo di valutazione produce il punteggio di fitness dell'iterazione, che viene confrontato con quello delle iterazioni precedenti per determinare se gli iperparametri correnti rappresentano un miglioramento.
5. Registrare i risultati — registra sia le metriche delle prestazioni sia gli iperparametri corrispondenti per riferimento futuro. Ultralytics YOLO salva automaticamente questi risultati in formato NDJSON.
6. Ripetere — continua fino al raggiungimento del numero di iterazioni impostato, facendo sì che ogni iterazione si basi sulle conoscenze acquisite nelle esecuzioni precedenti. Il tuner integrato esegue tutti i iterations; Ray Tune riporta le metriche dopo ogni epoca di fit, consentendo ad ASHA di interrompere i trial deboli al termine del relativo periodo di tolleranza.

Iterazioni e dimensione della popolazione#

Con il tuner integrato (use_ray=False), iterations controlla il numero totale di trial sequenziali e ha come valore predefinito 300. Ogni trial esegue il training di un modello con una configurazione di iperparametri — ad esempio, iterations=40 con epochs=50 pianifica 40 esecuzioni indipendenti di training da 50 epoche, non un'unica esecuzione da 50 epoche con una popolazione separata di 40 candidati.

L'algoritmo genetico integrato non dispone di un parametro esplicito per la dimensione della popolazione. Quando esistono trial precedenti, seleziona fino a nove configurazioni con la fitness più elevata e modifica un candidato per iterazione.

Per trial paralleli o strategie di ricerca più avanzate, imposta use_ray=True per utilizzare Ray Tune, che usa lo stesso valore predefinito di 300 trial e riceve iterations come num_samples. Per maggiori 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 la regolazione 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 usare la classe Tuner per la regolazione degli iperparametri di YOLO26n su COCO8 per 30 epoche con un ottimizzatore AdamW, saltando plotting, checkpoint e validation, tranne che nell'epoca finale, per velocizzare la regolazione.

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 regolazione degli iperparametri interrotta#

Puoi riprendere una sessione di regolazione degli iperparametri interrotta passando resume=True. Facoltativamente, puoi passare la directory name utilizzata in runs/{task} per riprendere la sessione. Senza un name, la sessione riprende la directory denominata letteralmente tune, che è il nome predefinito e non quello della sessione eseguita più di recente; passa quindi name per qualsiasi esecuzione avviata con un nome personalizzato. Devi inoltre fornire tutti gli argomenti di training 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)

Risultati#

Dopo aver completato correttamente il processo di regolazione degli iperparametri, otterrai diversi file e directory che raccolgono i risultati della regolazione. Di seguito viene descritto ciascuno di essi:

Struttura dei file#

Ecco come apparirà la struttura delle directory dei risultati. Le directory di training come train/ e train-2/ contengono singole iterazioni di regolazione, ovvero un modello addestrato con un insieme di iperparametri. La directory tune/ contiene i risultati della regolazione di tutti i singoli training dei modelli:

runs/
└── detect/
    ├── train/
    ├── train-2/
    ├── ...
    └── 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 migliori prestazioni trovati durante il processo di regolazione. Puoi utilizzare questo file per inizializzare training 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/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 è un grafico che mostra la fitness rispetto al numero di iterazioni. Ti aiuta a visualizzare le prestazioni dell'algoritmo genetico nel tempo.

• Formato: PNG
• Utilizzo: visualizzazione delle prestazioni

Il grafico contiene:

• Un indicatore per ogni iterazione per dataset, quindi un'esecuzione su un singolo dataset mostra un punto per iterazione, mentre un'esecuzione su più dataset mostra un punto per dataset per iterazione.
• Una linea puntinata della "media livellata" calcolata come smoothing gaussiano (sigma=3) sui valori di fitness di primo livello per iterazione.

tune_results.ndjson#

Un file NDJSON contenente i risultati dettagliati di ogni iterazione di regolazione. Ogni riga è un oggetto JSON con la fitness aggregata, gli iperparametri regolati e le metriche per dataset. La regolazione su un singolo dataset e quella su più dataset utilizzano lo stesso formato di file.

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

Segue 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/coco8",
        "coco8-grayscale": "runs/detect/coco8-grayscale"
    }
}

L'elemento di primo livello fitness è la media aritmetica dei valori fitness per dataset. Nella regolazione su un singolo dataset, il dizionario datasets contiene una voce il cui fitness è uguale a fitness di primo livello. Viene registrato un oggetto JSON per ogni iterazione completata. I percorsi effettivi save_dirs sono assoluti; qui sono abbreviati per facilitare 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 delle prestazioni. La mutazione utilizza l'intervallo configurato di ciascun iperparametro, quindi i valori possono evolvere da valori predefiniti pari a zero come degrees e shear.

• Formato: PNG
• Utilizzo: analisi esplorativa dei dati

weights/#

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

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

Utilizzando questi risultati, puoi prendere decisioni più consapevoli per i futuri training e le future analisi dei modelli.

Conclusioni#

La regolazione degli iperparametri in Ultralytics YOLO è semplice da avviare e potente a livello interno, grazie alla selezione ponderata per fitness e alla mutazione normalizzata rispetto agli intervalli in un algoritmo genetico. Seguendo il ciclo descritto in questa guida puoi regolare sistematicamente il modello per ottenere prestazioni migliori, quindi riutilizzare il best_hyperparameters.yaml risultante per inizializzare futuri training. Per scalare la regolazione su trial paralleli e 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 il training sul cloud.

Per le impostazioni che nessun argomento espone, come learning rate per layer o una metrica di fitness personalizzata, crea una sottoclasse del trainer. Per approfondimenti, esplora il codice sorgente della classe Tuner. Se hai domande o richieste di funzionalità, contattaci su GitHub o Discord.

FAQ#