Deep learning per l'object detection

1. Dal classificare al localizzare: il problema della detection

Il processo di object detection restituisce, per ogni oggetto di interesse presente nell'immagine di input: una bounding box, l'etichetta di una classe (scelta tra un insieme predefinito) e spesso una probabilità (o score). Dall'avvento di AlexNet diversi gruppi di ricerca hanno iniziato a studiare modelli di object detection basati su CNN. Le applicazioni sono molteplici: pedestrian detection, face detection, rilevamento di targhe, conteggio di oggetti (object counting), football detection e i sistemi per le auto a guida autonoma (self-driving).

2. Valutare le prestazioni: IoU, AP e mAP

I possibili errori di un sistema di detection sono di diverso tipo: oggetto non trovato, classe errata, bounding box sbagliata o imprecisa. Per quantificare il tutto con uno scalare si usano due misure. La Average Precision (AP) è calcolata come l'area sotto la curva precision-recall per gli oggetti di una singola classe su tutto il database; solitamente la curva viene prima corretta rimpiazzando la precision al livello di recall r con la massima precision misurata con recall ≥ r. La mean Average Precision (mAP) è la media dell'AP su tutte le classi. Ricordando le definizioni del capitolo 9: P = TP/(TP+FP), R = TP/(TP+FN). Si considera una prediction corretta quando la classe è giusta e la Intersection over Union (IoU) delle due bounding box (rilevata e vera) è maggiore di un valore dato (solitamente 0.5, per ovviare a inesattezze del ground truth):

IoU = area(A_t ∩ R_e) / area(A_t ∪ R_e)

L'esempio delle slide per la classe «cane»: 5 detection ordinate per score (0.99, 0.95, 0.9, 0.5, 0.1), di cui 3 con IoU > 0.5 (TP) e 2 no (FP). Con 3 oggetti nel ground truth: Recall = 3/3 = 1.0 e Precision = 3/5 = 0.6; la curva precision-recall corretta dà AP(cane) = 0.86. La mAP è la media sulle classi: mAP = (AP(cane) + AP(gatto) + AP(cavallo)) / 3.

3. Il framework generale e le sliding window

Tipicamente un sistema di object detection presenta tre componenti:

1. Region proposal — identifica le regioni di interesse (RoI) che potrebbero contenere un oggetto;
2. Object prediction — per ogni RoI determina se e quali oggetti sono presenti, restituendo per ognuno bounding box e classe;
3. Soppressione dei non-massimi — per ogni oggetto individuato analizza le bounding box associate, mantenendo quella con la confidenza più alta ed eliminando le altre.

Il primo tentativo «naïve»: prendere una rete addestrata per la classificazione e usarla per la detection con sliding windows + image pyramids. Dato un livello della piramide e una sliding window, la sotto-immagine corrispondente viene estratta e data in input alla rete, che restituisce una classe L e una probabilità; se la probabilità supera una soglia T la sotto-immagine è marcata come appartenente alla classe L. Ripetendo per ogni livello e ogni finestra si ottengono le sotto-immagini candidate; la soppressione dei non-massimi elimina le sotto-finestre con overlapping o bassa confidenza. Contributi: intuitivo, semplice, possibilità di usare diverse CNN pre-addestrate come backbone (AlexNet, VGGNet). Svantaggi: troppe finestre valutate (sistema estremamente lento) e ricalcolo dell'intera CNN per ogni finestra.

4. R-CNN: region proposal e classificazione per regione

Nel 2013 Girshick, Donahue, Darrell e Malik proposero R-CNN, un modello in due fasi composto da quattro moduli: region proposal (individua un insieme di regioni di interesse), estrattore di feature (estrae le feature da ogni regione con una CNN — il backbone), classificatore (per ogni regione restituisce l'etichetta della classe più probabile) e regressore (ottimizza la bounding box restituita).

• Per individuare le regioni di interesse viene usato il metodo selective search, che restituisce circa 2000 regioni;
• ogni regione viene ridimensionata a una dimensione fissa di 227 × 227 pixel (eventualmente modificandone l'aspect ratio);
• la regione ridimensionata è data in input alla rete AlexNet (pre-addestrata) ottenendo un vettore di 4096 feature (livello fc6 o fc7);
• per ogni classe è addestrato un SVM lineare che valuta le feature di ogni regione;
• per ogni classe è addestrato un regressore che raffina la posizione della bounding box;
• la soppressione dei non-massimi (separatamente per classe) rimuove le regioni con elevato overlapping rispetto a regioni con score più alto.

Contributo: un algoritmo per la selezione preventiva delle regioni invece della ricerca esaustiva. Svantaggi: la modifica dell'aspect ratio può causare un calo di accuratezza; ricalcolo dell'intera CNN per ogni regione; addestramento lento (fine-tuning della CNN + SVM + regressori); selective search richiede ~2 secondi per immagine e restituisce regioni ridondanti; troppo lenta per il real-time.

5. Selective search: la gerarchia di regioni

L'algoritmo selective search, presa un'immagine in input, produce una gerarchia di regioni:

1. generazione di una segmentazione iniziale sulla base di colore e tessitura;
2. fusione di regioni simili: si selezionano le due regioni più simili (in termini di colore, tessitura, dimensione e posizione reciproca), le si fonde, e si ripete finché non rimane un'unica regione.

Il risultato è un insieme di regioni candidate (circa 2000) che verranno processate dalla CNN di R-CNN.

6. Fast R-CNN: RoI pooling e multi-task loss

Nel 2015 Girshick (Microsoft Research) propose Fast R-CNN per risolvere i problemi di R-CNN: i tre componenti fondamentali (CNN, classificatore, regressore) vengono inglobati nella stessa architettura. Fast R-CNN è composta da:

• una CNN pre-addestrata (es. VGG-16);
• l'ultimo livello di max pooling della CNN sostituito con un Region of Interest (RoI) pooling layer;
• l'ultimo livello fully-connected sostituito da due sibling layer di output;
• la CNN modificata per prendere in input un'immagine e un insieme di regioni di interesse.

Le regioni di interesse sono selezionate con selective search; l'immagine è ridimensionata (lato corto 600 px, lato lungo ≤ 1000 px) e attraversa tutta la CNN fino alle feature map dell'ultimo convolutional layer. Il RoI pooling layer riceve le feature map e le regioni di interesse e restituisce, per ogni regione, feature map di dimensione prefissata passate ai livelli fully-connected; le feature risultanti alimentano i due sibling layer: il primo è il livello di classificazione (classe di ogni RoI), il secondo è il regressore (coordinate delle bounding box). Una multi-task loss addestra contemporaneamente la rete a predire classe e bounding box. Contributi: addestramento end-to-end, introduzione del RoI pooling, migliori prestazioni di R-CNN, multi-task loss. Svantaggi: metodo esterno per le regioni (~2s per immagine), ancora troppo lenta per il real-time.

7. Il layer RoI pooling

Uno dei principali ostacoli nell'uso di CNN progettate per la classificazione nei problemi di detection è la necessità di input a dimensioni prefissate (a causa dei livelli fully-connected), mentre il numero di oggetti e le loro dimensioni sono variabili e non noti a priori. Il RoI pooling layer restituisce più volumi di output di dimensione prefissata partendo da: una serie di feature map (volume di input) e N regioni di interesse. Per ogni regione, la porzione corrispondente delle feature map viene convertita in un insieme di feature map a dimensione prefissata tramite max pooling. Il numero di canali di output corrisponde a quello di input; le dimensioni spaziali dipendono solo dagli iperparametri del layer: le dimensioni del volume di output (W_P, H_P) e il fattore di scala P_S.

Le regioni di interesse sono individuate sull'immagine di input e devono essere riscalate sulle dimensioni del volume di input del RoI pooling: PS = WM/WI = HM/HI. Ogni regione viene riscalata e la corrispondente porzione di feature map suddivisa in W_P × H_P blocchi; in ogni blocco viene selezionato il massimo di ogni canale e copiato nel volume di output. Per tutte le N regioni l'output ha sempre dimensione W_P × H_P × C_M. Esempio delle slide: input 224 × 224, feature map 8 × 8 (C_M = 3), W_P = H_P = 2 → P_S = 8/224 = 1/28; ogni RoI è divisa in 2 × 2 blocchi e in ciascuno si prende il massimo per canale.

8. La multi-task loss

Fast R-CNN è un'architettura end-to-end che apprende simultaneamente classe e bounding box tramite una multi-task loss. Il layer di classificazione restituisce una probabilità p = (p₀, …, p_K) per ogni classe (p₀ = probabilità della classe background). Dato il vettore p e la classe vera u, la loss di classificazione è:

L_cls(p, u) = −log(p_u)

Data una classe u (con u ≥ 1: il background non ha bounding box), il livello di regressione produce una tupla t^u = (t_x, t_y, t_w, t_h) con le coordinate del corner superiore sinistro, la larghezza e l'altezza della bounding box. Indicando con v = (v_x, v_y, v_w, v_h) la bounding box vera della classe u, la loss di regressione è una L1 loss smoothed:

L_loc(t^u, v) = Σ_{i∈{x,y,w,h}} smoothL1(t^u_i − v_i)
smoothL1(x) = 0.5·x²  se |x| < 1
smoothL1(x) = |x| − 0.5  altrimenti

La multi-task loss combina le due:

L(p, u, t^u, v) = L_cls(p, u) + λ·[u ≥ 1]·L_loc(t^u, v)

La funzione [u ≥ 1] (1 se u ≥ 1, 0 altrimenti) annulla il contributo della regressione se la classe vera è il background; l'iperparametro λ controlla il bilanciamento tra le due loss.

9. Faster R-CNN e la Region Proposal Network

Sempre nel 2015, Ren, He, Girshick e Sun proposero Faster R-CNN che, a differenza di R-CNN e Fast R-CNN, non usa nessun metodo esterno per individuare le regioni di interesse: è composta da una Fast R-CNN e da una Region Proposal Network (RPN). L'immagine (lato corto 600, lato lungo ≤ 1000) attraversa la CNN fino alle feature map dell'ultimo convolutional layer; la RPN riceve le feature map e restituisce un insieme di regioni di interesse; l'esecuzione prosegue come una normale Fast R-CNN che usa le regioni della RPN invece di selective search.

La RPN, dato il volume W_F × H_F × C_F, è composta da: un convolutional layer con d kernel 3 × 3 (che simula una sliding window 3 × 3 da cui vengono estratte d feature per ogni posizione) e due sibling convolutional layer con 4k e 2k kernel 1 × 1:

• il layer reg restituisce un volume W_F × H_F × 4k: per ogni posizione, i 4 coefficienti di regressione (centro, larghezza, altezza) per ognuna delle k regioni (ancore);
• il layer cls restituisce un volume W_F × H_F × 2k: la probabilità che vi sia o meno un oggetto di interesse in ognuna delle k regioni.

Ad ogni posizione della sliding window la RPN valuta k possibili proposte di regione (ancore). La trasformazione dalle ancore alle proposte: px = ax + aw·tx, py = ay + ah·ty, pw = aw·exp(tw), ph = ah·exp(th), dove (a_x, a_y) è il centro dell'ancora (dipendente dalla box 3 × 3) e (a_w, a_h) le dimensioni prefissate.

10. Le ancore nella RPN

Il parametro d è 256 con AlexNet come backbone o 512 con VGG-16. Sono usate 9 ancore per ogni posizione, corrispondenti a 3 diverse scale (128 × 128, 256 × 256, 512 × 512) e 3 diversi aspect ratio (1:1, 2:1, 1:2). Con immagini di input 1000 × 600, le feature map di input della RPN hanno dimensione 60 × 40: 60 × 40 × 9 = 21.600 ancore.

Durante il training: tutte le ancore che si intersecano con il bordo dell'immagine sono scartate (il numero scende a circa 6000 per immagine); un'ancora è etichettata come contenente un oggetto se i) presenta il più alto valore di IoU con una regione del ground truth, oppure ii) presenta IoU ≥ 0.7 con qualsiasi regione del ground truth; un'ancora è etichettata come background se presenta IoU < 0.3 con tutte le regioni del ground truth; tutte le altre ancore non contribuiscono all'addestramento.

La multi-task loss della RPN è:

L({p_i},{t_i}) = (1/N_cls)·Σ_i L_cls(p_i, p*_i) + (λ/N_reg)·Σ_i p*_i·L_reg(t_i, t*_i)

dove p*_i e t*_i sono il ground truth dell'ancora i (p* = 1 se contiene un oggetto); L_cls e L_reg sono le stesse di Fast R-CNN; i due termini sono normalizzati con N_cls (dimensione dei mini-batch = 256) e N_reg (numero di ancore ~ 2400), pesati con λ = 10. In fase di detection, le regioni della RPN possono avere elevata sovrapposizione: si applica una soppressione dei non-massimi basata sullo score di classificazione.

11. Single-stage: YOLO

Tutti i modelli visti finora sono multi-stage: prima si identificano le regioni di interesse, poi solo le regioni candidate vengono processate. I modelli single-stage effettuano la detection su una serie di posizioni predefinite evitando di individuare preventivamente le regioni: YOLO, SSD, RetinaNet. Generalmente i single-stage sono meno accurati ma più veloci dei multi-stage.

YOLO (You Only Look Once, 2015 — Redmon, Divvala, Girshick e Farhadi) è una rete single-stage per scenari real-time, composta da 24 convolutional layer, quattro max pooling e due fully-connected. L'immagine di input viene riscalata a 448 × 448 e suddivisa con una griglia di S × S celle (S = 7). La cella responsabile dell'individuazione di un oggetto è quella in cui ricade il centro di tale oggetto. Ogni cella restituisce, per B bounding box (B = 2), una tupla (c, x, y, w, h): un valore di confidenza c (quanto il modello è certo che la box contenga un oggetto), le coordinate del centro (x, y) e le dimensioni (w, h). Inoltre ogni cella restituisce un vettore pj (1 ≤ j ≤ C) con la probabilità che un oggetto di classe j sia presente nella cella. La probabilità che la bounding box i contenga un oggetto di classe j è ci·pj; le predizioni sono restituite come un volume di output S × S × (5·B + C). Infine una soppressione dei non-massimi riduce le regioni usando una soglia sulla confidenza.

Contributi: real-time. Svantaggi: meno accurata di Faster R-CNN; non individua oggetti multipli nella stessa cella; lo stesso oggetto può essere individuato più volte in celle adiacenti.

12. SSD: default box e predittori convoluzionali

Nel 2015 fu proposto il modello single-stage SSD (Single-Shot multibox Detector), composto da tre componenti: VGG-16 come backbone, quattro extra feature layer (ognuno con due convolutional layer) e 6 convolutional predictor layer. L'immagine è riscalata a 300 × 300. SSD usa i livelli superficiali (receptive field piccolo) per rilevare piccoli oggetti e i livelli profondi (receptive field maggiore) per gli oggetti grandi. Una serie di 8732 default box con dimensioni, aspect ratio e posizioni differenti viene valutata dalla rete, restituendo per ognuna quattro offset e un valore di confidenza per ogni classe, calcolati tramite convolutional predictor applicati a diverse feature map. Infine la soppressione dei non-massimi restituisce al massimo 200 regioni, eliminando quelle con IoU > 0.45 con altre regioni della stessa classe.

Default box

Le default box sono bounding box predefinite sulla base di dimensioni, aspect ratio e posizione; l'obiettivo del modello è decidere quali usare per una data immagine e predire gli offset da applicare per ottenere la regione finale. Le feature map di livelli diversi hanno dimensioni e receptive field diversi: le default box sono ridimensionate opportunamente. Usando feature map da m livelli, il fattore di scala per ogni livello è:

s_k = s_min + (s_max − s_min)/(m−1) · (k−1)

Con s_min = 0.2, s_max = 0.9 e aspect ratio a_r ∈ {1, 2, 3, 1/2, 1/3}: wkr = sk·√ar e hkr = sk/√ar. Le positive box sono default box con IoU > 0.5 con almeno una regione del ground truth.

Convolutional predictor

Dato un volume W_F × H_F × C_F, k default box e c classi, applicando k·4 + c kernel 3 × 3 × C_F si ottiene un volume W_F × H_F × (k·4 + c): in ogni posizione spaziale, per ognuna delle k default box vi sono 4 offset e c confidenze (una per classe).

Contributi: accuratezza confrontabile con Faster R-CNN, real-time, più veloce e più accurata di YOLO, introduzione di default box e localizzazione multi-scala. Svantaggi: funziona male su oggetti piccoli (i livelli superficiali non generano feature di alto livello); richiede una grande quantità di dati.

13. RetinaNet: Feature Pyramid Network e focal loss

Nel 2017 fu proposto il modello single-stage RetinaNet, composto da: una ResNet come backbone, una Feature Pyramid Network (FPN) e una Detection head con due sottoreti (Classification subnet e Regression subnet). Usa anchor box di varie dimensioni e aspect ratio su ogni cella delle feature map (niente region proposal) e la Focal loss per bilanciare il peso di pochi oggetti (esempi difficili) rispetto allo sfondo (esempi facili). Contributi: accuratezza confrontabile con Faster R-CNN, FPN, focal loss. Svantaggio: più pesante di YOLO per il real-time.

Feature Pyramid Network

La FPN genera feature map a diverse risoluzioni (P2–P5) combinando informazioni provenienti da più livelli della rete, migliorando la localizzazione grazie a connessioni laterali tra i livelli ricostruiti e le corrispondenti feature map della ResNet. Nel percorso top-down esegue un upsampling di fattore 2 del livello precedente (nearest neighbor) e riduce l'effetto di aliasing della fusione con una convoluzione 3 × 3.

14. Dataset e modelli a confronto

I dataset di riferimento per la detection:

• COCO (Common Objects in Context): ~330K immagini, 80 categorie; oggetti in contesti realistici; benchmark principale per lo stato dell'arte;
• PASCAL VOC: ~20K immagini, 20 categorie; dataset storico e semplice, ideale per introdurre i concetti base e per training rapidi;
• Open Images: >9M immagini, 600+ categorie; scene complesse con molti oggetti per immagine; applicazioni su larga scala.

La tabella confronta i modelli sulla PASCAL Visual Object Classes Challenge 2012 (20 classi, 11530 immagini di training+validation con 27450 oggetti, 10991 di test):

Oggi sono disponibili online numerosi modelli all'avanguardia già addestrati: YOLO (Ultralytics), Faster R-CNN e Mask R-CNN (Detectron2), DETR, RetinaNet, SSD (MMDetection), Vision Transformer (Hugging Face).

Verifica le tue conoscenze