Architettura di Ultralytics YOLOv5

YOLOv5 (v6.0/6.1) è un potente algoritmo di object detection sviluppato da Ultralytics. Questo articolo approfondisce l'architettura di YOLOv5, le strategie di data augmentation, le metodologie di addestramento e le tecniche di calcolo della loss. Questa comprensione completa ti aiuterà a migliorare la tua applicazione pratica dell'object detection in vari settori, inclusi la sorveglianza, i veicoli autonomi e il riconoscimento delle immagini.

Struttura 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 collega 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 è rappresentata nell'immagine sottostante. I dettagli della struttura del modello si possono trovare in models/yolov5l.yaml.

YOLOv5 introduce alcuni miglioramenti notevoli rispetto ai suoi predecessori:

1. La struttura Focus, presente nelle versioni precedenti, è sostituita con una struttura 6x6 Conv2d. Questo cambiamento aumenta l'efficienza #4825.
2. La struttura SPP è sostituita con SPPF. Questa modifica 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

Tecniche di data augmentation

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

• Mosaic Augmentation: una tecnica di elaborazione delle immagini che combina quattro immagini di addestramento in una sola, in modi che incoraggiano i modelli di object detection a gestire meglio diverse 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 efficacemente un nuovo campione di addestramento.

  

• Random Affine Transformations: questo include rotazione casuale, ridimensionamento, traslazione e inclinazione delle immagini.

  

• MixUp Augmentation: un metodo che crea immagini composite prendendo una combinazione lineare di due immagini e delle loro etichette associate.

  

• Albumentations: una potente libreria di augmentation delle immagini che supporta un'ampia varietà di tecniche. Scopri di più sull'utilizzo delle augmentation di Albumentations.

• HSV Augmentation: cambiamenti 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.

  

Strategie di addestramento

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

• Multiscale Training: le immagini di input vengono ridimensionate casualmente all'interno di un intervallo da 0,5 a 1,5 volte la loro dimensione originale durante il processo di addestramento.
• AutoAnchor: questa strategia ottimizza le anchor box prior per adattarsi alle caratteristiche statistiche delle ground truth box nei tuoi dati personalizzati.
• Warmup e Cosine LR Scheduler: un metodo per regolare il learning rate per migliorare le prestazioni del modello.
• Exponential Moving Average (EMA): una strategia che utilizza la media dei parametri nei passaggi precedenti per stabilizzare il processo di addestramento e ridurre l'errore di generalizzazione.
• Addestramento a precisione mista: un metodo per eseguire operazioni in formato a mezza precisione, riducendo l'utilizzo della memoria e migliorando la velocità computazionale.
• Hyperparameter Evolution: una strategia per ottimizzare automaticamente gli iperparametri per ottenere le massime prestazioni. Scopri di più sull'ottimizzazione degli iperparametri.

Funzionalità aggiuntive

4.1 Calcolo delle loss

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

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

La funzione di loss complessiva è rappresentata da:

4.2 Bilanciamento delle loss

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

4.3 Eliminazione della sensibilità alla griglia

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

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

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

Confronta l'offset del punto centrale prima e dopo il ridimensionamento. L'intervallo dell'offset del punto centrale viene regolato da (0, 1) a (-0,5, 1,5). Pertanto, l'offset può facilmente ottenere 0 o 1.

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

4.4 Build Targets

Il processo di build target in YOLOv5 è fondamentale per l'efficienza dell'addestramento e l'accuratezza 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 è entro la soglia, abbina la ground truth box con l'anchor corrispondente.

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

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

Conclusione

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

I miglioramenti principali in YOLOv5 includono l'uso di un'architettura dinamica, un'ampia gamma di tecniche di data augmentation, strategie di addestramento innovative, nonché importanti aggiustamenti nel calcolo delle loss e nel processo di build 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.