Contents
Van het tellen van voertuigen en slimme parkeersystemen tot Autonomous Driving Assistant-systemen, de vraag naar het detecteren van auto's, bussen en motorfietsen neemt toe en zal binnenkort net zo gewoon zijn voor een toepassing als gezichtsdetectie.
En natuurlijk, ze moeten realtime worden uitgevoerd om bruikbaar te zijn in de meeste toepassingen in de echte wereld, want wie zal vertrouwen op een Autonomous Driving Assistant-systeem als het geen auto's voor ons kan detecteren tijdens het rijden.
In dit bericht laat ik je zien hoe je je eigen autodetector kunt implementeren met behulp van vooraf getrainde modellen die beschikbaar zijn om te downloaden: MobileNet SSD en Xailient Car Detector.
Voordat we diep in de implementatie duiken, laten we beginnen een beetje bekend en kennen deze modellen. Maar ga gerust naar de code en resultaten als je dat wilt.
MobileNet SSD
MobileNet is een lichtgewicht diepe neurale netwerkarchitectuur ontworpen voor mobiele telefoons en embedded vision-applicaties.
MobileNet-architectuur [1]
In veel toepassingen in de echte wereld, zoals een zelfrijdende auto, moeten de herkenningstaken tijdig worden uitgevoerd op een rekenkundig beperkt apparaat. Om aan deze eis te voldoen, werd MobileNet in 2017 ontwikkeld.
De kernlagen van MobileNet zijn gebouwd op in de diepte scheidbare filters. De eerste laag, die een volledige convolutie is, is een uitzondering.
Raadpleeg de paper voor meer informatie over MobileNet.
Rond dezelfde tijd (2016), SSD: Single Shot-detector is ook ontwikkeld door het Google Research-team om tegemoet te komen aan de behoefte aan modellen die realtime kunnen worden uitgevoerd op embedded apparaten zonder een significante compromis in nauwkeurigheid.
SSD-architectuur [2]
Single Shot-objectdetectie of SSD maakt één enkele opname om meerdere objecten in het beeld te detecteren. De SSD-benadering is gebaseerd op een feed-forward convolutienetwerk dat een verzameling begrenzingsvakken met een vaste grootte produceert en scores voor de aanwezigheid van objectklasse-instanties in die vakken.
Het bestaat uit twee delen:
Het bestaat uit twee delen:
- Extract feature maps, en
- Pas convolutiefilter toe om objecten te detecteren
SSD is ontworpen om onafhankelijk te zijn van het basisnetwerk en kan dus bovenop alle basisnetwerken zoals VGG, YOLO, MobileNet draaien.
In het oorspronkelijke artikel gebruikten Wei Liu en het team het VGG-16-netwerk als basis om functiekaarten te extraheren.
Raadpleeg het artikel voor meer informatie over SSD.
Om de praktische beperkingen van het uitvoeren van neurale netwerken met veel bronnen en energie op low-end apparaten in realtime toepassingen verder aan te pakken, werd MobileNet geïntegreerd in het SSD-framework. Dus toen MobileNet werd gebruikt als het basisnetwerk in de SSD, werd het MobileNet SSD.
MobileNet SSD-overzicht [7]
De MobileNet SSD-methode werd eerst getraind op de COCO-dataset en werd vervolgens verfijnd op PASCAL VOC en bereikte 72,7% mAP (gemiddelde gemiddelde precisie).
MobileSSD voor realtime autodetectie
Stap 1: Download een vooraf getraind MobileNetSSD Caffe-model en prototxt.
We gebruiken een vooraf getrainde MobileNet die is gedownload van https://github.com/chuanqi305/MobileNet -SSD/ die is getraind in Caffe-SSD-framework.
Download hier het vooraf getrainde MobileNet SSD-model en prototxt.
MobileNetSSD_deploy.caffemodel
MobileNetSSD_deploy.prototxt
Stap 2: Implementeer code om MobileNet SSD te gebruiken
import tijd import cv2 als cv import numpy als np import math # laad ons geserialiseerde model van schijf print(“Load MobileNetSSD model”) prototxt_path = “MobileNetSSD_deploy.prototxt” model_path = “MobileNetSSD_deploy.caffemodel” # initialiseer de lijst met klasselabels MobileNet SSD is getraind om CLASSES = [“achtergrond”, “vliegtuig”, “fiets”, “vogel”, “boot”, “fles”, “bus”, “auto”, “kat”, “stoel”, “koe” te detecteren , “eettafel”, “hond”, “paard”, “motor”, “persoon”, “potplant”, “schapen”, “bank”, “trein”, “tvmonitor”] net = cv.dnn.readNetFromCaffe(prototxt_path , model_path) def process_frame_MobileNetSSD(next_frame): rgb = cv.cvtColor(next_frame, cv.COLOR_BGR2RGB) (H, W) = next_frame.shape[:2] # converteer het frame naar een blob en geef de blob door het # netwerk en de detecties verkrijgen blob = cv.dnn.blobFromImage(next_frame, size=(300, 300), ddepth=cv.CV_8U) net.setInput(blob, scalefactor=1,0/127,5, mean=[127,5, 127,5, 127,5]) detecties = net.forward() # loop over de detecties voor i in np.arange(0, detecties.shape[2]): # extraheer het vertrouwen (d.w.z. waarschijnlijkheid) geassocieerd # met het voorspellingsvertrouwen = detecties[0, 0, i, 2] # filter zwakke detecties uit door de `betrouwbaarheid ` # is groter dan de minimale betrouwbaarheid als betrouwbaarheid > 0.7: # extraheer de index van het klasselabel uit de # detectielijst idx = int(detections[0, 0, i, 1]) # als het klasselabel geen auto is, negeer het dan if CLASSES[idx] != ” car”: ga verder # bereken de (x, y)-coördinaten van het selectiekader # voor het objectkader = detecties[0, 0, i, 3:7] * np.array([W, H, W, H] ) (startX, startY, endX, endY) = box.astype(“int”) cv.rectangle(next_frame, (startX, startY), (endX, endY), (0, 255, 0), 3) return next_frame def VehicheDetection_UsingMobileNetSSD(bestandsnaam): cap = cv.VideoCapture(bestandsnaam) # Schrijf uitvoerbestand frame_width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH)) frame_height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)) # Definieer de codec en creëer VideoWriter object fps = 20 size = (int(frame_width),int(frame_height)) fourcc = cv.VideoWriter_fourcc('m','p','4','v') out = cv.VideoWriter() success = out. open('output_mobilenetssd.mov', fourcc, fps, size, True) frame_count = 0 # start timer t1 = time.time() while True: ret, next_frame = cap.read() # Leest t het volgende videoframe in het geheugen if ret == False: frame_count breken += 1 next_frame = process_frame_MobileNetSSD(next_frame) # write frame out.write(next_frame) key = cv.waitKey(50) if key == 27: # Hit ESC-toets om pauze te stoppen # eindtimer t2 = time.time() # bereken FPS fps = str( float(frame_count/float(t2 – t1))) + 'FPS' print(“/MobileNetSSD Car Detector”) print(“Frames verwerkt : {}”.format(frame_count)) print(“Verstreken tijd: {:.2f}”.format(float(t2 – t1))) print(“FPS: {}”.format(fps)) cap.release () cv.destroyAllWindows() uit.release()
Omdat we het willen gebruiken voor realtime toepassingen, laten we ook de frames berekenen die het per seconde verwerkt.
(Delen van deze code zijn geïnspireerd op de PyImageSearch-blog.)
<Experimenten:
Ik heb de bovenstaande code op twee verschillende apparaten uitgevoerd:
- Op mijn ontwikkelmachine, dat is Lenovo Yoga 920 met Ubuntu18.04 in werking systeem.
- Op een goedkoop apparaat met beperkte middelen, namelijk de Raspberry Pi 3B+ met het Raspbian Buster-besturingssysteem.
Resultaten:
MobileNet SSD-resultaten.
Op mijn ontwikkelmachine, Lenovo Yoga, met MobileNet SSD, kreeg ik een inferentiesnelheid van 23,3 FPS en toen ik RaspberryPi 3B+ draaide, was de inferentiesnelheid 0,9 FPS, met alle 4 de kernen.
Behoorlijk dramatisch. Dit experiment laat zien dat als je een krachtig apparaat hebt om de MobileNetSSD uit te voeren, het goed presteert en voldoet aan de realtime-vereiste. Maar als uw toepassing is bedoeld om te worden geïmplementeerd op een rekenkundig beperkt IoT/embedded apparaat zoals de Raspberry Pi, lijkt dit niet geschikt voor een realtime toepassing.
Xailient
Xailient-model gebruikt selectieve aandachtsbenadering om detectie uit te voeren. Het is geïnspireerd op het werkingsmechanisme van het menselijk oog.
Xailient-modellen zijn geoptimaliseerd om te werken op apparaten met een laag stroomverbruik, die weinig geheugen en bronnen hebben.
Laten we nu eens kijken hoe Xailient Pre -getrainde autodetector presteert.
Xailient Car Detector voor realtime autodetectie
Stap-1: Download het vooraf getrainde autodetectormodel.
We gebruiken een vooraf getraind autodetectormodel van Xailient dat is gedownload van console.xailient.com.
Stap 2: Implementeer de code om de Xailient-autodetectormodus te gebruiken
import tijd import cv2 als cv import numpy als np import wiskunde van xailient import dnn # initialize Xailient model print(“Initialize Xailient model”) THRESHOLD = 0.6 # Waarde tussen 0 en 1 voor betrouwbaarheidsscore detectum = dnn.Detector() def process_frame_xailient( next_frame): _, bboxes = detectum.process_frame(next_frame, THRESHOLD) # Extract bbox-coördinaten # Loop door lijst (indien leeg wordt deze overgeslagen) en overlay groene bboxes # Formaat van bboxes is: xmin, ymin (linksboven), xmax , ymax (rechtsonder) voor i in bboxes: cv.rectangle(next_frame, (i[0], i[1]), (i[2], i[3]), (0, 255, 0), 3 ) return next_frame def VehicheDetection_UsingXailient(bestandsnaam): cap = cv.VideoCapture(bestandsnaam) # Schrijf uitvoerbestand frame_width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH)) frame_height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)) # Definieer de codec en maak een VideoWriter-object fps = 20 size = (int(frame_width),int(frame_height)) fourcc = cv.VideoWriter_fourcc('m','p','4','v') out = cv.VideoWriter() succes = uit.o pen('output_xailient.mov', fourcc, fps, size, True) frame_count = 0 # start timer t1 = time.time() while True: ret, next_frame = cap.read() # Leest het volgende videoframe in het geheugen als ret == False: break frame_count += 1 next_frame = process_frame_xailient(next_frame) # write frame out.write(next_frame) key = cv.waitKey(50) if key == 27: # Hit ESC-toets om pauze te stoppen # end timer t2 = time.time() # bereken FPS fps = str( float(frame_count/float(t2 – t1))) + 'FPS' print(“/nXailient Car Detector”) print(“Frames verwerkt: {}”.format( frame_count)) print(“Verstreken tijd: {:.2f}”.format(float(t2 – t1))) print(“FPS: {}”.format(fps)) cap.release() cv.destroyAllWindows() out.release()
Experimenten:
Ik heb de bovenstaande code op dezelfde twee sets apparaten uitgevoerd:
- Op mijn ontwikkelmachine, dat is Lenovo Yoga 920 met Ubuntu18.04-besturingssysteem.
- Op een goedkoop apparaat met beperkte middelen, namelijk Raspberry Pi 3B+ met Raspbian Buster-besturingssysteem.
Resultaten:
<Xailient Car Detection Results.
Op de dev-machine is er een lichte verbetering in de inferentiesnelheid bij gebruik van Xailient Car Detector, zelfs als er slechts één kern wordt gebruikt. Op Raspberry Pi verwerkt Xailient echter 8x meer frames per seconde met een enkele kern.
De resultaten van beide modellen samenvattend:
MobileNetSSD vs Xailient
De video die ik heb gebruikt voor dit experiment is gedownload van Pexels.com
In dit bericht hebben we gekeken naar de behoefte aan realtime detectiemodellen, kort geïntroduceerd MobileNet, SSD, MobileNetSSD en Xailient, die allemaal zijn ontwikkeld om dezelfde uitdaging op te lossen: detectiemodellen draaien op low-powered, resource-beperkte IoT/embedded apparaten met een juiste balans tussen snelheid en nauwkeurigheid. We gebruikten vooraf getrainde MobileNetSSD- en Xailient-autodetectormodellen en voerden experimenten uit op twee afzonderlijke apparaten: dev-machine en een goedkoop IoT-apparaat. Resultaten laten een lichte verbetering zien in snelheid van Xailient Car-detector ten opzichte van MobileNetSSD, in de ontwikkelmachine en een significante verbetering in het goedkope IoT-apparaat, zelfs wanneer slechts 1 core werd gebruikt.
Als u uw autodetectietoepassing wilt uitbreiden naar het volgen van auto's en snelheidsschattingen, is hier een zeer goede blog van PyImageSearch.
Referenties
- Howard , Andrew G., et al. “Mobilenets: efficiënte convolutionele neurale netwerken voor mobiele vision-toepassingen.” arXiv preprint arXiv:1704.04861 (2017).
- Liu, Wei, et al. "Ssd: Single shot multibox-detector." Europese conferentie over computervisie. Springer, Cham, 2016.
- https://www.pyimagesearch.com/2019/12/02/opencv-vehicle-detection-tracking-and-speed-estimation/
- https://honingds.com/blog/ssd-single-shot-object-detection-mobilenet-opencv/
- https://github.com/chuanqi305/MobileNet-SSD
- https://mc.ai/object-detection-with-ssd-and-mobilenet/
- https://machinethink.net/blog/mobilenet-v2/#:~:text=SSD% 20is%20designed%20to%20be,detectie%20portion%20of%20the%20network.
Sabina Pokhrel
AI-ingenieur voor klantsucces, Xailient
