RetinaNet-objektdetektion med PyTorch og torchvision

Introduktion

Objektdetektion er et stort felt inden for computersyn og en af ​​de mere vigtige anvendelser af computersyn "i naturen". I den ene ende kan det bruges til at bygge autonome systemer, der navigerer agenter gennem miljøer - det være sig robotter, der udfører opgaver eller selvkørende biler, men det kræver krydsning med andre felter. Anomalidetektion (såsom defekte produkter på en linje), lokalisering af objekter i billeder, ansigtsdetektion og forskellige andre anvendelser af objektdetektion kan dog udføres uden at krydse andre felter.

Objektdetektion er ikke så standardiseret som billedklassificering, hovedsagelig fordi de fleste af de nye udviklinger typisk udføres af individuelle forskere, vedligeholdere og udviklere i stedet for store biblioteker og rammer. Det er svært at pakke de nødvendige hjælpescripts i en ramme som TensorFlow eller PyTorch og vedligeholde API-retningslinjerne, der har været styret af udviklingen indtil videre.

Dette gør genkendelse af objekter noget mere kompleks, typisk mere omfattende (men ikke altid) og mindre tilgængelig end billedklassificering. En af de største fordele ved at være i et økosystem er, at det giver dig mulighed for ikke at søge efter nyttig information om god praksis, værktøjer og tilgange til brug. Med genstandsdetektering – de fleste er nødt til at forske meget mere i markens landskab for at få et godt greb.

Objektdetektion med PyTorch/TorchVision's RetinaNet

torchvision er PyTorchs Computer Vision-projekt, og har til formål at gøre udviklingen af ​​PyTorch-baserede CV-modeller lettere, ved at levere transformations- og augmentationsscripts, en modelzoo med præ-trænede vægte, datasæt og hjælpeprogrammer, der kan være nyttige for en praktiserende læge.

Mens den stadig er i beta og meget eksperimenterende – torchvision tilbyder et relativt simpelt objektdetektions-API med nogle få modeller at vælge imellem:

• Hurtigere R-CNN
• RetinaNet
• FCOS (Fuldt indviklet RetinaNet)
• SSD (VGG16 backbone... yikes)
• SSDLite (MobileNetV3-rygrad)

Selvom API'et ikke er så poleret eller simpelt som nogle andre tredjeparts API'er, er det et meget anstændigt udgangspunkt for dem, der stadig foretrækker sikkerheden ved at være i et økosystem, de er bekendt med. Før du går videre, skal du sørge for at installere PyTorch og Torchvision:

$ pip install torch torchvision

Lad os indlæse nogle af hjælpefunktionerne, som f.eks read_image(), draw_bounding_boxes() , to_pil_image() for at gøre det nemmere at læse, tegne på og udskrive billeder, efterfulgt af import af RetinaNet og dets præ-trænede vægte (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 bruger et ResNet50-backbone og et Feature Pyramid Network (FPN) ovenpå. Mens navnet på klassen er udførligt, er det vejledende for arkitekturen. Lad os hente et billede ved hjælp af requests bibliotek og gem det som en fil på vores lokale drev:

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

Med et billede på plads – kan vi instantiere vores model og vægte:

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

model.eval()

preprocess = weights.transforms()

score_thresh argument definerer den tærskel, ved hvilken et objekt detekteres som et objekt i en klasse. Intuitivt er det konfidensgrænsen, og vi klassificerer ikke et objekt til at tilhøre en klasse, hvis modellen er mindre end 35 % sikker på, at den tilhører en klasse.

Lad os forbehandle billedet ved hjælp af transformationerne fra vores vægte, oprette en batch og køre konklusioner:

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

Det er det, vores prediction ordbogen indeholder de udledte objektklasser og placeringer! Nu er resultaterne ikke særlig brugbare for os i denne form – vi vil gerne udtrække etiketterne med hensyn til metadata fra vægtene og tegne afgrænsningsfelter, hvilket kan gøres via 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()

Dette resulterer i:

RetinaNet klassificerede faktisk den person, der kiggede bag bilen! Det er en ret svær klassificering.

Du kan skifte RetinaNet ud til et FCOS (fuldt indviklet RetinaNet) ved at udskifte retinanet_resnet50_fpn_v2 med fcos_resnet50_fpn, og brug FCOS_ResNet50_FPN_Weights vægte:

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

Gå videre – Praktisk dyb læring til computersyn

Din nysgerrige natur giver dig lyst til at gå længere? Vi anbefaler at tjekke vores Kursus: "Praktisk dyb læring til computersyn med Python".

Endnu et kursus i computersyn?

Vi laver ikke klassificering af MNIST-cifre eller MNIST-mode. De tjente deres del for længe siden. For mange læringsressourcer fokuserer på grundlæggende datasæt og grundlæggende arkitekturer, før de lader avancerede black-box-arkitekturer bære byrden af ​​ydeevne.

Vi ønsker at fokusere på afmystificering, praktisk, forståelse, intuition , rigtige projekter. Vil gerne lære hvordan kan du gøre en forskel? Vi tager dig med på en tur fra den måde, vores hjerner behandler billeder på, til at skrive en deep learning-klassificerer for brystkræft i forskningsklasse til deep learning-netværk, der "hallucinerer", lærer dig principperne og teorien gennem praktisk arbejde, og udstyrer dig med knowhow og værktøjer til at blive ekspert i at anvende dyb læring til at løse computervision.

Hvad er der indenfor?

• De første principper for vision og hvordan computere kan læres at "se"
• Forskellige opgaver og anvendelser af computersyn
• Branchens værktøjer, der vil gøre dit arbejde lettere
• Finde, skabe og bruge datasæt til computervision
• Teorien og anvendelsen af ​​​​konvolutionelle neurale netværk
• Håndtering af domæneskift, samtidige forekomster og andre skævheder i datasæt
• Overfør Læring og udnyttelse af andres træningstid og beregningsressourcer til din fordel
• Opbygning og træning af en avanceret brystkræftklassificering
• Hvordan man anvender en sund dosis skepsis til mainstream ideer og forstår implikationerne af vidt anvendte teknikker
• Visualisering af et ConvNets "konceptrum" ved hjælp af t-SNE og PCA
• Casestudier af, hvordan virksomheder bruger computervisionsteknikker til at opnå bedre resultater
• Korrekt modelevaluering, latent rumvisualisering og identifikation af modellens opmærksomhed
• Udførelse af domæneforskning, bearbejdning af dine egne datasæt og etablering af modeltest
• Banebrydende arkitekturer, udviklingen af ​​ideer, hvad der gør dem unikke, og hvordan man implementerer dem
• KerasCV – et WIP-bibliotek til at skabe state of the art pipelines og modeller
• Hvordan man analyserer og læser papirer og implementerer dem selv
• Valg af modeller afhængigt af din applikation
• Oprettelse af en end-to-end machine learning pipeline
• Landskab og intuition på objektdetektion med hurtigere R-CNN'er, RetinaNets, SSD'er og YOLO
• Forekomst og semantisk segmentering
• Objektgenkendelse i realtid med YOLOv5
• Træning af YOLOv5 objektdetektorer
• Arbejde med transformere ved hjælp af KerasNLP (industristærkt WIP-bibliotek)
• Integrering af transformere med ConvNets for at generere billedtekster
• Deepdream

Konklusion

Objektgenkendelse er et vigtigt område inden for computersyn, og et område, der desværre er mindre tilgængeligt, end det burde være.

I denne korte guide har vi taget et kig på hvordan torchvision, PyTorchs Computer Vision-pakke, gør det nemmere at udføre objektdetektering på billeder ved hjælp af RetinaNet.