RetinaNet-objectdetectie met PyTorch en torchvision

Introductie

Objectdetectie is een groot gebied in computervisie en een van de belangrijkste toepassingen van computervisie "in het wild". Aan de ene kant kan het worden gebruikt om autonome systemen te bouwen die agenten door omgevingen navigeren - of het nu robots zijn die taken uitvoeren of zelfrijdende auto's, maar dit vereist kruising met andere velden. Anomaliedetectie (zoals defecte producten op een lijn), het lokaliseren van objecten in afbeeldingen, gezichtsdetectie en verschillende andere toepassingen van objectdetectie kunnen echter worden uitgevoerd zonder andere velden te kruisen.

Objectdetectie is niet zo gestandaardiseerd als beeldclassificatie, vooral omdat de meeste nieuwe ontwikkelingen doorgaans worden gedaan door individuele onderzoekers, beheerders en ontwikkelaars, in plaats van door grote bibliotheken en frameworks. Het is moeilijk om de benodigde hulpprogrammascripts in een framework als TensorFlow of PyTorch te verpakken en de API-richtlijnen te handhaven die de ontwikkeling tot dusver hebben geleid.

Dit maakt objectdetectie iets complexer, doorgaans uitgebreider (maar niet altijd) en minder benaderbaar dan beeldclassificatie. Een van de belangrijkste voordelen van deel uitmaken van een ecosysteem is dat het je een manier biedt om niet te zoeken naar nuttige informatie over goede praktijken, tools en benaderingen om te gebruiken. Met objectdetectie moeten de meesten veel meer onderzoek doen naar het landschap van het veld om een ​​goede grip te krijgen.

Objectdetectie met RetinaNet van PyTorch/TorchVision

torchvision is het Computer Vision-project van PyTorch en heeft tot doel de ontwikkeling van op PyTorch gebaseerde CV-modellen gemakkelijker te maken door transformatie- en augmentatiescripts te bieden, een modeldierentuin met vooraf getrainde gewichten, datasets en hulpprogramma's die nuttig kunnen zijn voor een beoefenaar.

Hoewel nog in bèta en zeer experimenteel - torchvision biedt een relatief eenvoudige objectdetectie-API met een paar modellen om uit te kiezen:

• Snellere R-CNN
• Retina Net
• FCOS (Volledig convolutionele RetinaNet)
• SSD (VGG16-backbone ... yikes)
• SSDLite (MobileNetV3-backbone)

Hoewel de API niet zo gepolijst of eenvoudig is als sommige andere API's van derden, is het een zeer goed startpunt voor diegenen die nog steeds de voorkeur geven aan de veiligheid van een ecosysteem waarmee ze vertrouwd zijn. Voordat u verder gaat, moet u ervoor zorgen dat u PyTorch en Torchvision installeert:

$ pip install torch torchvision

Laten we enkele van de hulpprogramma-functies inladen, zoals: read_image(), draw_bounding_boxes() en to_pil_image() om het lezen, tekenen en uitvoeren van afbeeldingen gemakkelijker te maken, gevolgd door het importeren van RetinaNet en zijn vooraf getrainde gewichten (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 gebruikt een ResNet50-backbone en daarbovenop een Feature Pyramid Network (FPN). Hoewel de naam van de klasse uitgebreid is, is het een indicatie van de architectuur. Laten we een afbeelding ophalen met de requests bibliotheek en sla het op als een bestand op onze lokale schijf:

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

Met een afbeelding op zijn plaats kunnen we ons model en gewichten instantiëren:

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 definieert de drempel waarbij een object wordt gedetecteerd als een object van een klasse. Intuïtief is dit de betrouwbaarheidsdrempel en we zullen een object niet classificeren om tot een klasse te behoren als het model minder dan 35% zeker is dat het tot een klasse behoort.

Laten we de afbeelding voorbewerken met behulp van de transformaties van onze gewichten, een batch maken en gevolgtrekking uitvoeren:

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

Dat is het, onze prediction woordenboek bevat de afgeleide objectklassen en locaties! Nu zijn de resultaten in deze vorm niet erg nuttig voor ons - we willen de labels met betrekking tot de metadata uit de gewichten extraheren en begrenzingsvakken tekenen, wat kan worden gedaan 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()

Dit resulteert in:

RetinaNet classificeerde zelfs de persoon die achter de auto gluurde! Dat is een vrij moeilijke classificatie.

U kunt RetinaNet overschakelen naar een FCOS (volledig convolutionele RetinaNet) door te vervangen retinanet_resnet50_fpn_v2 Met fcos_resnet50_fpn, en gebruik de FCOS_ResNet50_FPN_Weights gewichten:

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

Verder gaan - Praktisch diep leren voor computervisie

Je leergierige karakter maakt dat je verder wilt gaan? We raden aan om onze Type cursus: "Praktisch diep leren voor computervisie met Python".

Nog een cursus computervisie?

We zullen geen classificatie van MNIST-cijfers of MNIST-mode doen. Ze hebben lang geleden hun deel gediend. Te veel leermiddelen zijn gericht op basisgegevenssets en basisarchitecturen voordat geavanceerde black-box-architecturen de last van de prestaties op zich nemen.

We willen ons concentreren op demystificatie, uitvoerbaarheid, begrip, intuïtie en echte projecten. Willen leren hoe je kan een verschil maken? We nemen je mee op een reis van de manier waarop onze hersenen afbeeldingen verwerken tot het schrijven van een onderzoeksclassificatie voor diep leren voor borstkanker tot diepgaande leernetwerken die 'hallucineren', je de principes en theorie leren door middel van praktisch werk, en je uitrusten met de knowhow en tools om een ​​expert te worden in het toepassen van deep learning om computervisie op te lossen.

Wat zit erin?

• De eerste principes van visie en hoe computers kunnen worden geleerd om te "zien"
• Verschillende taken en toepassingen van computervisie
• De tools van het vak die uw werk gemakkelijker maken
• Datasets zoeken, maken en gebruiken voor computervisie
• De theorie en toepassing van convolutionele neurale netwerken
• Omgaan met domeinverschuiving, gelijktijdig voorkomen en andere vooroordelen in datasets
• Overdragen Leren en de trainingstijd en computerbronnen van anderen gebruiken in uw voordeel
• Het bouwen en trainen van een state-of-the-art classifier voor borstkanker
• Hoe je een gezonde dosis scepsis toepast op mainstream ideeën en de implicaties begrijpt van algemeen aanvaarde technieken?
• De "conceptruimte" van een ConvNet visualiseren met t-SNE en PCA
• Casestudy's van hoe bedrijven computervisietechnieken gebruiken om betere resultaten te behalen
• Correcte modelevaluatie, visualisatie van de latente ruimte en het identificeren van de aandacht van het model
• Domeinonderzoek doen, eigen datasets verwerken en modeltesten opzetten
• Geavanceerde architecturen, de voortgang van ideeën, wat ze uniek maakt en hoe ze te implementeren
• KerasCV – een WIP-bibliotheek voor het maken van ultramoderne pijplijnen en modellen
• Hoe papers te ontleden en te lezen en ze zelf te implementeren?
• Modellen selecteren afhankelijk van uw toepassing
• Een end-to-end machine learning-pijplijn maken
• Landschap en intuïtie bij objectdetectie met snellere R-CNN's, RetinaNets, SSD's en YOLO
• Instantie en semantische segmentatie
• Realtime objectherkenning met YOLOv5
• YOLOv5-objectdetectoren trainen
• Werken met Transformers met KerasNLP (industriële WIP-bibliotheek)
• Transformers integreren met ConvNets om bijschriften van afbeeldingen te genereren
• DeepDream

Conclusie

Objectdetectie is een belangrijk gebied van Computer Vision en helaas minder benaderbaar dan het zou moeten zijn.

In deze korte handleiding hebben we bekeken hoe: torchvision, het Computer Vision-pakket van PyTorch, maakt het eenvoudiger om objectdetectie op afbeeldingen uit te voeren met behulp van RetinaNet.