Link to this sectionArchitettura 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.

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 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

Link to this sectionTecniche 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.

  

Link to this sectionStrategie 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.

Link to this sectionFunzionalità aggiuntive#

Link to this section4.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:

Link to this section4.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.

Link to this section4.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.

Link to this section4.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.

Link to this sectionConclusione#

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.