Rilevamento di oggetti RetinaNet con PyTorch e torcia

Introduzione

Il rilevamento di oggetti è un ampio campo nella visione artificiale e una delle applicazioni più importanti della visione artificiale "in natura". Da un lato, può essere utilizzato per costruire sistemi autonomi che navigano gli agenti attraverso gli ambienti, che si tratti di robot che svolgono attività o di auto a guida autonoma, ma ciò richiede l'intersezione con altri campi. Tuttavia, il rilevamento di anomalie (come prodotti difettosi su una linea), l'individuazione di oggetti all'interno delle immagini, il rilevamento facciale e varie altre applicazioni di rilevamento di oggetti possono essere eseguiti senza intersecare altri campi.

Il rilevamento degli oggetti non è standardizzato come la classificazione delle immagini, principalmente perché la maggior parte dei nuovi sviluppi viene in genere eseguita da singoli ricercatori, manutentori e sviluppatori, piuttosto che da grandi librerie e framework. È difficile impacchettare gli script di utilità necessari in un framework come TensorFlow o PyTorch e mantenere le linee guida API che hanno guidato lo sviluppo finora.

Ciò rende il rilevamento degli oggetti un po' più complesso, in genere più dettagliato (ma non sempre) e meno accessibile rispetto alla classificazione delle immagini. Uno dei principali vantaggi dell'essere in un ecosistema è che fornisce un modo per non cercare informazioni utili su buone pratiche, strumenti e approcci da utilizzare. Con il rilevamento degli oggetti, la maggior parte deve fare molte più ricerche sul paesaggio del campo per avere una buona presa.

Rilevamento di oggetti con RetinaNet di PyTorch/TorchVision

torchvision è il progetto Computer Vision di PyTorch e mira a rendere più semplice lo sviluppo di modelli CV basati su PyTorch, fornendo script di trasformazione e aumento, uno zoo modello con pesi pre-addestrati, set di dati e utilità che possono essere utili per un professionista.

Mentre è ancora in versione beta e molto sperimentale - torchvision offre un'API Object Detection relativamente semplice con alcuni modelli tra cui scegliere:

• R-CNN più veloce
• Rete Retina
• FCOS (RetinaNet completamente convoluzionale)
• SSD (backbone VGG16... accidenti)
• SSDLite (backbone MobileNetV3)

Sebbene l'API non sia raffinata o semplice come alcune altre API di terze parti, è un punto di partenza molto decente per coloro che preferirebbero comunque la sicurezza di trovarsi in un ecosistema con cui hanno familiarità. Prima di andare avanti, assicurati di installare PyTorch e Torchvision:

$ pip install torch torchvision

Carichiamo alcune delle funzioni di utilità, come read_image(), draw_bounding_boxes() ed to_pil_image() per semplificare la lettura, il disegno e l'output di immagini, quindi importare RetinaNet e i suoi pesi pre-addestrati (MS COCO):

from torchvision.io.image import read_image
from torchvision.utils import draw_bounding_boxes
from torchvision.transforms.functional import to_pil_image
from torchvision.models.detection import retinanet_resnet50_fpn_v2, RetinaNet_ResNet50_FPN_V2_Weights

import matplotlib.pyplot as plt

RetinaNet utilizza un backbone ResNet50 e una Feature Pyramid Network (FPN) su di esso. Sebbene il nome della classe sia dettagliato, è indicativo dell'architettura. Recuperiamo un'immagine usando il requests libreria e salvarlo come file sul nostro disco locale:

import requests
response = requests.get('https://i.ytimg.com/vi/q71MCWAEfL8/maxresdefault.jpg')
open("obj_det.jpeg", "wb").write(response.content)

img = read_image("obj_det.jpeg")

Con un'immagine sul posto, possiamo istanziare il nostro modello e i nostri pesi:

weights = RetinaNet_ResNet50_FPN_V2_Weights.DEFAULT
model = retinanet_resnet50_fpn_v2(weights=weights, score_thresh=0.35)

model.eval()

preprocess = weights.transforms()

I score_thresh argomento definisce la soglia alla quale un oggetto viene rilevato come oggetto di una classe. Intuitivamente, è la soglia di confidenza e non classificheremo un oggetto come appartenente a una classe se il modello ha una sicurezza inferiore al 35% che appartenga a una classe.

Elaboriamo l'immagine utilizzando le trasformazioni dei nostri pesi, creiamo un batch ed eseguiamo l'inferenza:

batch = [preprocess(img)]
prediction = model(batch)[0]

Questo è tutto, il nostro prediction il dizionario contiene le classi e le posizioni degli oggetti dedotte! Ora, i risultati non sono molto utili per noi in questo modulo: vorremo estrarre le etichette rispetto ai metadati dai pesi e disegnare riquadri di delimitazione, cosa che può essere fatta tramite draw_bounding_boxes():

labels = [weights.meta["categories"][i] for i in prediction["labels"]]

box = draw_bounding_boxes(img, boxes=prediction["boxes"],
                          labels=labels,
                          colors="cyan",
                          width=2, 
                          font_size=30,
                          font='Arial')

im = to_pil_image(box.detach())

fig, ax = plt.subplots(figsize=(16, 12))
ax.imshow(im)
plt.show()

Questo risulta in:

RetinaNet ha effettivamente classificato la persona che sbirciava dietro l'auto! Questa è una classificazione piuttosto difficile.

È possibile passare da RetinaNet a un FCOS (RetinaNet completamente convoluzionale) sostituendo retinanet_resnet50_fpn_v2 con fcos_resnet50_fpne usa il FCOS_ResNet50_FPN_Weights pesi:

from torchvision.io.image import read_image
from torchvision.utils import draw_bounding_boxes
from torchvision.transforms.functional import to_pil_image
from torchvision.models.detection import fcos_resnet50_fpn, FCOS_ResNet50_FPN_Weights

import matplotlib.pyplot as plt
import requests
response = requests.get('https://i.ytimg.com/vi/q71MCWAEfL8/maxresdefault.jpg')
open("obj_det.jpeg", "wb").write(response.content)

img = read_image("obj_det.jpeg")
weights = FCOS_ResNet50_FPN_Weights.DEFAULT
model = fcos_resnet50_fpn(weights=weights, score_thresh=0.35)
model.eval()

preprocess = weights.transforms()
batch = [preprocess(img)]
prediction = model(batch)[0]

labels = [weights.meta["categories"][i] for i in prediction["labels"]]

box = draw_bounding_boxes(img, boxes=prediction["boxes"],
                          labels=labels,
                          colors="cyan",
                          width=2, 
                          font_size=30,
                          font='Arial')

im = to_pil_image(box.detach())

fig, ax = plt.subplots(figsize=(16, 12))
ax.imshow(im)
plt.show()

Andare oltre - Apprendimento profondo pratico per la visione artificiale

La tua natura curiosa ti fa venire voglia di andare oltre? Ti consigliamo di dare un'occhiata al nostro Portata: "Apprendimento profondo pratico per la visione artificiale con Python".

Un altro corso di visione artificiale?

Non faremo la classificazione delle cifre MNIST o della moda MNIST. Hanno servito la loro parte molto tempo fa. Troppe risorse di apprendimento si stanno concentrando su set di dati di base e architetture di base prima di lasciare che le architetture black-box avanzate si assumano il peso delle prestazioni.

Vogliamo concentrarci demistificazione, praticità, e una comprensione reciproca, intuizione ed progetti reali. Vuoi imparare come Puoi fare la differenza? Ti porteremo in un viaggio dal modo in cui il nostro cervello elabora le immagini alla scrittura di un classificatore di apprendimento profondo per la ricerca per il cancro al seno alle reti di apprendimento profondo che "allucinano", insegnandoti i principi e la teoria attraverso il lavoro pratico, fornendoti il know-how e strumenti per diventare un esperto nell'applicazione del deep learning per risolvere la visione artificiale.

Cosa c'è dentro?

• I primi principi della visione e come si può insegnare ai computer a "vedere"
• Diversi compiti e applicazioni della visione artificiale
• Gli strumenti del mestiere che ti semplificheranno il lavoro
• Trovare, creare e utilizzare set di dati per la visione artificiale
• La teoria e l'applicazione delle reti neurali convoluzionali
• Gestione del cambio di dominio, della co-occorrenza e di altri pregiudizi nei set di dati
• Trasferisci l'apprendimento e utilizza il tempo di formazione e le risorse di calcolo degli altri a tuo vantaggio
• Costruire e formare un classificatore di cancro al seno all'avanguardia
• Come applicare una sana dose di scetticismo alle idee tradizionali e comprendere le implicazioni delle tecniche ampiamente adottate
• Visualizzazione dello "spazio concettuale" di una ConvNet utilizzando t-SNE e PCA
• Casi di studio su come le aziende utilizzano le tecniche di visione artificiale per ottenere risultati migliori
• Valutazione corretta del modello, visualizzazione dello spazio latente e identificazione dell'attenzione del modello
• Esecuzione di ricerche di dominio, elaborazione dei propri set di dati e creazione di test di modello
• Architetture all'avanguardia, la progressione delle idee, cosa le rende uniche e come realizzarle
• KerasCV – una libreria WIP per la creazione di pipeline e modelli all'avanguardia
• Come analizzare e leggere documenti e implementarli da soli
• Selezione dei modelli in base all'applicazione
• Creazione di una pipeline di machine learning end-to-end
• Paesaggio e intuizione sul rilevamento di oggetti con R-CNN, RetinaNet, SSD e YOLO più veloci
• Istanza e segmentazione semantica
• Riconoscimento di oggetti in tempo reale con YOLOv5
• Formazione dei rilevatori di oggetti YOLOv5
• Utilizzo di Transformers tramite KerasNLP (libreria WIP di livello industriale)
• Integrazione di Transformers con ConvNets per generare didascalie di immagini
• Deepdream

Conclusione

Il rilevamento degli oggetti è un campo importante della visione artificiale e sfortunatamente meno accessibile di quanto dovrebbe essere.

In questa breve guida, abbiamo dato un'occhiata a come torchvision, il pacchetto Computer Vision di PyTorch, semplifica il rilevamento di oggetti sulle immagini, utilizzando RetinaNet.