RetinaNet Objektdeteksjon med PyTorch og torchvision

Introduksjon

Objektdeteksjon er et stort felt innen datasyn, og en av de viktigste bruksområdene for datasyn "i naturen". I den ene enden kan den brukes til å bygge autonome systemer som navigerer agenter gjennom miljøer – det være seg roboter som utfører oppgaver eller selvkjørende biler, men dette krever skjæring med andre felt. Imidlertid kan avviksdeteksjon (som defekte produkter på en linje), lokalisering av objekter i bilder, ansiktsdeteksjon og forskjellige andre bruksområder for objektdeteksjon gjøres uten å krysse andre felt.

Objektdeteksjon er ikke like standardisert som bildeklassifisering, hovedsakelig fordi de fleste av de nye utviklingene vanligvis gjøres av individuelle forskere, vedlikeholdere og utviklere, i stedet for store biblioteker og rammeverk. Det er vanskelig å pakke de nødvendige verktøyskriptene i et rammeverk som TensorFlow eller PyTorch og opprettholde API-retningslinjene som har ledet utviklingen så langt.

Dette gjør gjenstandsgjenkjenning noe mer kompleks, vanligvis mer detaljert (men ikke alltid), og mindre tilgjengelig enn bildeklassifisering. En av de største fordelene med å være i et økosystem er at det gir deg en måte å ikke søke etter nyttig informasjon om god praksis, verktøy og tilnærminger til bruk. Med gjenstandsdeteksjon – de fleste må gjøre mye mer forskning på landskapet i feltet for å få et godt grep.

Objektdeteksjon med PyTorch/TorchVisions RetinaNet

torchvision er PyTorchs Computer Vision-prosjekt, og har som mål å gjøre utviklingen av PyTorch-baserte CV-modeller enklere, ved å tilby transformasjons- og utvidelsesskript, en modellzoo med forhåndstrente vekter, datasett og verktøy som kan være nyttige for en utøver.

Mens den fortsatt er i beta og veldig eksperimentell – torchvision tilbyr en relativt enkel Object Detection API med noen få modeller å velge mellom:

• Raskere R-CNN
• RetinaNet
• FCOS (Fullly convolutional RetinaNet)
• SSD (VGG16-ryggrad... yikes)
• SSDLite (MobileNetV3-ryggrad)

Selv om API-en ikke er så polert eller enkel som noen andre tredjeparts API-er, er det et veldig anstendig utgangspunkt for de som fortsatt foretrekker sikkerheten ved å være i et økosystem de er kjent med. Før du går videre, sørg for at du installerer PyTorch og Torchvision:

$ pip install torch torchvision

La oss laste inn noen av hjelpefunksjonene, som f.eks read_image(), draw_bounding_boxes() og to_pil_image() for å gjøre det enklere å lese, tegne på og skrive ut bilder, etterfulgt av import av RetinaNet og dets forhåndstrente vekter (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 bruker en ResNet50-ryggrad og et Feature Pyramid Network (FPN) på toppen av det. Mens navnet på klassen er detaljert, er det en indikasjon på arkitekturen. La oss hente et bilde ved å bruke requests bibliotek og lagre det som en fil på vår lokale stasjon:

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 bilde på plass – kan vi instansiere modellen og vektene våre:

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

model.eval()

preprocess = weights.transforms()

De score_thresh argument definerer terskelen der et objekt oppdages som et objekt i en klasse. Intuitivt er det konfidensgrensen, og vi vil ikke klassifisere et objekt til å tilhøre en klasse hvis modellen er mindre enn 35 % sikker på at den tilhører en klasse.

La oss forhåndsbehandle bildet ved å bruke transformasjonene fra vektene våre, lage en batch og kjøre slutning:

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

Det er det, vår prediction ordboken inneholder de utledede objektklassene og plasseringene! Nå er ikke resultatene veldig nyttige for oss i dette skjemaet – vi vil trekke ut etikettene med hensyn til metadataene fra vektene og tegne avgrensingsbokser, noe som kan gjø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 klassifiserte faktisk personen som tittet bak bilen! Det er en ganske vanskelig klassifisering.

Du kan bytte ut RetinaNet til et FCOS (fullt konvolusjonelt RetinaNet) ved å erstatte retinanet_resnet50_fpn_v2 med fcos_resnet50_fpn, og bruk FCOS_ResNet50_FPN_Weights vekter:

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 dyp læring for datasyn

Din nysgjerrige natur gjør at du ønsker å gå lenger? Vi anbefaler å sjekke ut vår Kurs: "Praktisk dyplæring for datasyn med Python".

Et annet datasynskurs?

Vi kommer ikke til å klassifisere MNIST-sifre eller MNIST-mote. De tjente sin del for lenge siden. For mange læringsressurser fokuserer på grunnleggende datasett og grunnleggende arkitekturer før de lar avanserte svartboksarkitekturer bære byrden av ytelse.

Vi ønsker å fokusere på avmystifisering, praktisk, forståelse, intuisjon og ekte prosjekter. Vil lære hvordan du kan gjøre en forskjell? Vi tar deg med på en tur fra måten hjernen vår behandler bilder på til å skrive en dyplæringsklassifiser for brystkreft til dyplæringsnettverk som "hallusinerer", lærer deg prinsippene og teorien gjennom praktisk arbeid, og utstyrer deg med kunnskap og verktøy for å bli en ekspert på å bruke dyp læring for å løse datasyn.

Hva er inni?

• De første prinsippene for visjon og hvordan datamaskiner kan læres å "se"
• Ulike oppgaver og anvendelser av datasyn
• Verktøyene i bransjen som vil gjøre arbeidet ditt enklere
• Finne, lage og bruke datasett for datasyn
• Teorien og anvendelsen av konvolusjonelle nevrale nettverk
• Håndtering av domeneskift, samtidig forekomst og andre skjevheter i datasett
• Overfør Læring og bruk av andres treningstid og beregningsressurser til din fordel
• Bygge og trene en toppmoderne brystkreftklassifiser
• Hvordan bruke en sunn dose skepsis til mainstream ideer og forstå implikasjonene av vidt vedtatte teknikker
• Visualisere et ConvNets "konseptrom" ved hjelp av t-SNE og PCA
• Kasusstudier av hvordan bedrifter bruker datasynsteknikker for å oppnå bedre resultater
• Riktig modellevaluering, latent romvisualisering og identifisering av modellens oppmerksomhet
• Utføre domeneforskning, behandle egne datasett og etablere modelltester
• Nyskapende arkitekturer, utviklingen av ideer, hva som gjør dem unike og hvordan de implementeres
• KerasCV – et WIP-bibliotek for å lage toppmoderne rørledninger og modeller
• Hvordan analysere og lese artikler og implementere dem selv
• Velge modeller avhengig av din applikasjon
• Opprette en ende-til-ende maskinlæringspipeline
• Landskap og intuisjon på objektdeteksjon med raskere R-CNN, RetinaNets, SSD og YOLO
• Forekomst og semantisk segmentering
• Objektgjenkjenning i sanntid med YOLOv5
• Trening av YOLOv5-objektdetektorer
• Arbeide med transformatorer ved å bruke KerasNLP (bransjesterkt WIP-bibliotek)
• Integrering av transformatorer med ConvNets for å generere bildetekster
• Deepdream

konklusjonen

Objektdeteksjon er et viktig felt innen datasyn, og et som dessverre er mindre tilgjengelig enn det burde være.

I denne korte veiledningen har vi tatt en titt på hvordan torchvision, PyTorchs Computer Vision-pakke, gjør det enklere å utføre objektdeteksjon på bilder, ved hjelp av RetinaNet.