Link to this sectionArchitettura di Ultralytics YOLOv5#

YOLOv5 (v6.0/6.1) è un potente algoritmo di object detection sviluppato da Ultralytics. Questo articolo analizza in profondità l'architettura di YOLOv5, le strategie di data augmentation, le metodologie di training e le tecniche di calcolo della loss. Questa comprensione completa ti aiuterà a migliorare la tua applicazione pratica dell'object detection in vari campi, inclusi sorveglianza, veicoli autonomi e image recognition.

Link to this sectionStruttura del Modello#

L'architettura di YOLOv5 consiste in tre parti principali:

• Backbone: Questo è il corpo principale della rete. Per YOLOv5, il backbone è progettato utilizzando la struttura CSPDarknet53, una modifica dell'architettura Darknet utilizzata nelle versioni precedenti.
• Neck: Questa parte connette il backbone e la head. In YOLOv5, vengono utilizzate le strutture SPPF (Spatial Pyramid Pooling - Fast) e PANet (Path Aggregation Network).
• Head: Questa parte è responsabile della generazione dell'output finale. YOLOv5 utilizza la YOLOv3 Head a questo scopo.

La struttura del modello è raffigurata nell'immagine sottostante. I dettagli della struttura del modello possono essere trovati in models/yolov5l.yaml.

YOLOv5 introduce alcuni miglioramenti degni di nota rispetto ai suoi predecessori:

1. La struttura Focus, presente nelle versioni precedenti, è sostituita con una struttura 6x6 Conv2d. Questa modifica incrementa l'efficienza #4825.
2. La struttura SPP è sostituita con SPPF. Questa alterazione più che raddoppia la velocità di elaborazione mantenendo lo stesso output.

Per testare la velocità di SPP e SPPF, è possibile utilizzare il seguente codice:

import time

import torch
import torch.nn as nn

class SPP(nn.Module):
    def __init__(self):
        """Initializes an SPP module with three different sizes of max pooling layers."""
        super().__init__()
        self.maxpool1 = nn.MaxPool2d(5, 1, padding=2)
        self.maxpool2 = nn.MaxPool2d(9, 1, padding=4)
        self.maxpool3 = nn.MaxPool2d(13, 1, padding=6)

    def forward(self, x):
        """Applies three max pooling layers on input `x` and concatenates results along channel dimension."""
        o1 = self.maxpool1(x)
        o2 = self.maxpool2(x)
        o3 = self.maxpool3(x)
        return torch.cat([x, o1, o2, o3], dim=1)

class SPPF(nn.Module):
    def __init__(self):
        """Initializes an SPPF module with a specific configuration of MaxPool2d layer."""
        super().__init__()
        self.maxpool = nn.MaxPool2d(5, 1, padding=2)

    def forward(self, x):
        """Applies sequential max pooling and concatenates results with input tensor."""
        o1 = self.maxpool(x)
        o2 = self.maxpool(o1)
        o3 = self.maxpool(o2)
        return torch.cat([x, o1, o2, o3], dim=1)

def main():
    """Compares outputs and performance of SPP and SPPF on a random tensor (8, 32, 16, 16)."""
    input_tensor = torch.rand(8, 32, 16, 16)
    spp = SPP()
    sppf = SPPF()
    output1 = spp(input_tensor)
    output2 = sppf(input_tensor)

    print(torch.equal(output1, output2))

    t_start = time.time()
    for _ in range(100):
        spp(input_tensor)
    print(f"SPP time: {time.time() - t_start}")

    t_start = time.time()
    for _ in range(100):
        sppf(input_tensor)
    print(f"SPPF time: {time.time() - t_start}")

if __name__ == "__main__":
    main()

True
SPP time: 0.5373051166534424
SPPF time: 0.20780706405639648

Link to this sectionTecniche di Data Augmentation#

YOLOv5 impiega varie tecniche di data augmentation per migliorare la capacità del modello di generalizzare e ridurre l'overfitting. Queste tecniche includono:

• Mosaic Augmentation: Una tecnica di elaborazione delle immagini che combina quattro immagini di training in una, in modi che incoraggiano i modelli di object detection a gestire meglio varie scale e traslazioni degli oggetti.

  

• Copy-Paste Augmentation: Un metodo innovativo di data augmentation che copia patch casuali da un'immagine e le incolla su un'altra immagine scelta casualmente, generando effettivamente un nuovo campione di training.

  

• Trasformazioni Affini Casuali: Questo include rotazione casuale, ridimensionamento, traslazione e inclinazione (shearing) delle immagini.

  

• MixUp Augmentation: Un metodo che crea immagini composite prendendo una combinazione lineare di due immagini e delle relative etichette.

  

• Albumentations: Una potente libreria di augmentation per immagini che supporta un'ampia varietà di tecniche di augmentation. Scopri di più su come utilizzare le augmentation di Albumentations.

• HSV Augmentation: Modifiche casuali a tonalità (Hue), saturazione (Saturation) e valore (Value) delle immagini.

  

• Random Horizontal Flip: Un metodo di augmentation che ribalta casualmente le immagini in orizzontale.

  

Link to this sectionStrategie di Training#

YOLOv5 applica diverse strategie di training sofisticate per migliorare le prestazioni del modello. Queste includono:

• Multiscale Training: Le immagini in input vengono ridimensionate casualmente all'interno di un intervallo da 0,5 a 1,5 volte la loro dimensione originale durante il processo di training.
• AutoAnchor: Questa strategia ottimizza le anchor box predefinite per adattarle alle caratteristiche statistiche delle ground truth box nei tuoi dati personalizzati.
• Warmup e Cosine LR Scheduler: Un metodo per regolare il learning rate al fine di migliorare le prestazioni del modello.
• Exponential Moving Average (EMA): Una strategia che utilizza la media dei parametri calcolata sui passi precedenti per stabilizzare il processo di training e ridurre l'errore di generalizzazione.
• Training in Mixed Precision: Un metodo per eseguire operazioni in formato a mezza precision, riducendo l'utilizzo della memoria e migliorando la velocità computazionale.
• Hyperparameter Evolution: Una strategia per regolare automaticamente gli iperparametri al fine di ottenere prestazioni ottimali. Scopri di più sul tuning degli iperparametri.

Link to this sectionFunzionalità Aggiuntive#

Link to this section4.1 Calcolo delle Losses#

La loss in YOLOv5 è calcolata come una combinazione di tre componenti individuali:

• Classes Loss (BCE Loss): Loss di Binary Cross-Entropy, misura l'errore per il task di classificazione.
• Objectness Loss (BCE Loss): Un'altra loss di Binary Cross-Entropy, calcola l'errore nel rilevare se un oggetto è presente o meno in una specifica cella della griglia.
• Location Loss (CIoU Loss): Complete IoU loss, misura l'errore nella localizzazione dell'oggetto all'interno della cella della griglia.

La loss function complessiva è rappresentata da:

Link to this section4.2 Bilanciamento delle Losses#

Le objectness loss dei tre layer di predizione (P3, P4, P5) sono pesate in modo differente. I pesi di bilanciamento sono rispettivamente [4.0, 1.0, 0.4]. Questo approccio assicura che le predizioni a scale diverse contribuiscano in modo appropriato alla loss totale.

Link to this section4.3 Eliminazione della sensibilità alla griglia#

L'architettura di YOLOv5 apporta alcune modifiche importanti alla strategia di predizione del box rispetto alle versioni precedenti di YOLO. In YOLOv2 e YOLOv3, le coordinate del box venivano predette direttamente utilizzando l'attivazione dell'ultimo layer.

Tuttavia, in YOLOv5, la formula per predire le coordinate del box è stata aggiornata per ridurre la sensibilità alla griglia e impedire al modello di predire dimensioni del box non vincolate.

Le formule riviste per calcolare il bounding box predetto sono le seguenti:

Confronta l'offset del punto centrale prima e dopo lo scalamento. L'intervallo dell'offset del punto centrale è regolato da (0, 1) a (-0.5, 1.5). Pertanto, l'offset può facilmente ottenere 0 o 1.

Confronta il rapporto di scalamento di altezza e larghezza (rispetto all'anchor) prima e dopo la regolazione. Le equazioni originali del box in yolo/darknet presentano un difetto grave. La larghezza e l'altezza sono completamente illimitate poiché sono semplicemente out=exp(in), il che è pericoloso, poiché può portare a gradienti incontrollati, instabilità, loss NaN e infine a una perdita completa del training. Consulta questo issue per maggiori dettagli.

Link to this section4.4 Build Targets#

Il processo di build target in YOLOv5 è critico per l'efficienza del training e l'accuracy del modello. Comporta l'assegnazione delle ground truth box alle celle della griglia appropriate nella mappa di output e l'abbinamento con le anchor box appropriate.

Questo processo segue questi passaggi:

• Calcola il rapporto tra le dimensioni della ground truth box e le dimensioni di ciascun template di anchor.

• Se il rapporto calcolato rientra nella soglia, abbina la ground truth box con l'anchor corrispondente.

• Assegna l'anchor abbinata alle celle appropriate, tenendo presente che, a causa dell'offset rivisto del punto centrale, una ground truth box può essere assegnata a più di un'anchor poiché l'intervallo dell'offset del punto centrale è regolato da (0, 1) a (-0.5, 1.5), rendendo possibili corrispondenze aggiuntive.

In questo modo, il processo di build targets assicura che ogni oggetto ground truth sia correttamente assegnato e abbinato durante il processo di training, consentendo a YOLOv5 di apprendere il task di object detection in modo più efficace.

Link to this sectionConclusione#

YOLOv5 rappresenta un passo significativo nell'evoluzione dell'object detection in tempo reale. Le sue scelte architetturali, le strategie di training e i perfezionamenti ingegneristici offrono prestazioni ed efficienza elevate rispetto alle versioni precedenti di YOLO.

I miglioramenti primari in YOLOv5 includono l'uso di un'architettura dinamica, un'ampia gamma di tecniche di data augmentation, strategie di training innovative, nonché importanti regolazioni nel calcolo delle loss e nel processo di costruzione dei target. Tutte queste innovazioni migliorano significativamente l'accuratezza e l'efficienza dell'object detection pur mantenendo un alto grado di velocità, che è il marchio di fabbrica dei modelli YOLO.