prologen
En video sirkulerer nå på Internett som viser hvordan Teslas autopilot ser veien.
Jeg har lenge kløt etter å kringkaste video beriket med en detektor, og i sanntid.
Problemet er at jeg ønsker å kringkaste video fra Raspberry, og ytelsen til den nevrale nettverksdetektoren på den etterlater mye å være ønsket.
Intel Neural Computer Stick
Jeg vurderte forskjellige løsninger.
В eksperimenterte med Intel Neural Computer Stick. Maskinvaren er kraftig, men krever sitt eget nettverksformat.
Selv om Intel leverer omformere for store rammeverk, er det en rekke fallgruver.
For eksempel kan formatet til det nødvendige nettverket være inkompatibelt, og hvis det er kompatibelt, kan det hende at noen lag ikke støttes på enheten, og hvis de støttes, kan det oppstå feil under konverteringsprosessen, som et resultat av at vi får noen merkelige ting ved utgangen.
Generelt, hvis du vil ha en slags vilkårlig nevrale nettverk, kan det hende at det ikke fungerer med NCS. Derfor bestemte jeg meg for å prøve å løse problemet ved å bruke de mest utbredte og tilgjengelige verktøyene.
sky
Det åpenbare alternativet til en lokal maskinvareløsning er å gå til skyen.
Ferdige alternativer - øynene mine løper løpsk.
Alle ledere:
... Og dusinvis av mindre kjente.
Å velge blant denne varianten er ikke i det hele tatt lett.
Og jeg bestemte meg for ikke å velge, men å pakke inn den gode gamle arbeidsordningen på OpenCV i Docker og kjøre den i skyen.
Fordelen med denne tilnærmingen er fleksibilitet og kontroll - du kan endre det nevrale nettverket, hosting, server - generelt, ethvert innfall.
Сервер
La oss starte med en lokal prototype.
Tradisjonelt bruker jeg Flask for REST API, OpenCV og MobileSSD-nettverk.
Etter å ha installert de nåværende versjonene på Docker, oppdaget jeg at OpenCV 4.1.2 ikke fungerer med Mobile SSD v1_coco_2018_01_28, og jeg måtte rulle tilbake til den velprøvde 11/06_2017.
Ved starten av tjenesten laster vi klassenavnene og nettverket:
def init():
tf_labels.initLabels(dnn_conf.DNN_LABELS_PATH)
return cv.dnn.readNetFromTensorflow(dnn_conf.DNN_PATH, dnn_conf.DNN_TXT_PATH)
På en lokal docker (på en ikke veldig ung bærbar datamaskin) tar det 0.3 sekunder, på Raspberry - 3.5.
La oss starte beregningen:
def inference(img):
net.setInput(cv.dnn.blobFromImage(img, 1.0/127.5, (300, 300), (127.5, 127.5, 127.5), swapRB=True, crop=False))
return net.forward()
Docker - 0.2 sek, bringebær - 1.7.
Gjør om tensoreksos til lesbar json:
def build_detection(data, thr, rows, cols):
ret = []
for detection in data[0,0,:,:]:
score = float(detection[2])
if score > thr:
cls = int(detection[1])
a = {"class" : cls, "name" : tf_labels.getLabel(cls), "score" : score}
a["x"] = int(detection[3] * cols)
a["y"] = int(detection[4] * rows)
a["w"] = int(detection[5] * cols ) - a["x"]
a["h"] = int(detection[6] * rows) - a["y"]
ret.append(a)
return ret
videre (inngang er et bilde, utgang er resultatene av detektoren i json).
Et alternativt alternativ, der mer arbeid flyttes til serveren: den sirkler selv de funnet objektene og returnerer det ferdige bildet.
Dette alternativet er bra der vi ikke ønsker å dra opencv til serveren.
Docker
Vi samler bildet.
Koden kjemmes og legges på , vil docker ta det direkte derfra.
Som plattform tar vi samme Debian Stretch som på Raspberry - vi vil ikke avvike fra den velprøvde teknologistabelen.
Du må installere flask, protobuf, requests, opencv_python, laste ned Mobile SSD, serverkode fra Github og starte serveren.
FROM python:3.7-stretch
RUN pip3 install flask
RUN pip3 install protobuf
RUN pip3 install requests
RUN pip3 install opencv_python
ADD http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_coco_11_06_2017.tar.gz /
RUN tar -xvf /ssd_mobilenet_v1_coco_11_06_2017.tar.gz
ADD https://github.com/tprlab/docker-detect/archive/master.zip /
RUN unzip /master.zip
EXPOSE 80
CMD ["python3", "/docker-detect-master/detect-app/app.py"]
enkel basert på forespørsler.
Publiserer til Docker Hub
Docker-registre formerer seg med en hastighet som ikke er mindre enn skydetektorer.
For ikke å bry oss, skal vi konservativt gå gjennom .
- Registrere
- Logg Inn:
docker-pålogging - La oss finne et meningsfylt navn:
docker-tag opencv-detect tprlab/opencv-detect-ssd - Last opp bildet til serveren:
docker push tprlab/opencv-detect-ssd
Vi lanserer i skyen
Valget av hvor beholderen skal kjøres er også ganske bredt.
Alle de store aktørene (Google, Microsoft, Amazon) tilbyr en mikroforekomst gratis det første året.
Etter å ha eksperimentert med Microsoft Azure og Google Cloud bestemte jeg meg for sistnevnte fordi det tok fart raskere.
Jeg skrev ikke instruksjoner her, siden denne delen er veldig spesifikk for den valgte leverandøren.
Jeg prøvde forskjellige maskinvarealternativer,
Lave nivåer (delt og dedikert) - 0.4 - 0.5 sekunder.
Kraftigere biler - 0.25 - 0.3.
Vel, selv i verste fall er gevinsten tre ganger, du kan prøve.
Video
Vi lanserer en enkel OpenCV-videostreamer på Raspberry, som oppdager gjennom Google Cloud.
Til eksperimentet ble det brukt en videofil som en gang ble filmet i et tilfeldig kryss.
def handle_frame(frame):
return detect.detect_draw_img(frame)
def generate():
while True:
rc, frame = vs.read()
outFrame = handle_frame(frame)
if outFrame is None:
(rc, outFrame) = cv.imencode(".jpg", frame)
yield(b'--framern' b'Content-Type: image/jpegrnrn' + bytearray(outFrame) + b'rn')
@app.route("/stream")
def video_feed():
return Response(generate(), mimetype = "multipart/x-mixed-replace; boundary=frame")
Med detektoren får vi ikke mer enn tre bilder per sekund, alt går veldig sakte.
Hvis du tar en kraftig maskin inn i GCloud, kan du oppdage 4-5 bilder per sekund, men forskjellen er nesten usynlig for øyet, den er fortsatt treg.
Skyen og transportkostnadene har ingenting med det å gjøre; detektoren kjører på vanlig maskinvare og jobber med en slik hastighet.
Nevral Computer Stick
Jeg kunne ikke motstå og kjørte benchmark på norsk sokkel.
Hastigheten på detektoren var litt lavere enn 0.1 sekunder, i alle fall 2-3 ganger raskere enn skyen på en svak maskin, det vil si 8-9 bilder per sekund.
Forskjellen i resultater forklares av at NCS kjørte Mobile SSD versjon 2018_01_28.
PS I tillegg har eksperimenter vist at en ganske kraftig stasjonær maskin med I7-prosessor viser litt bedre resultater og det viste seg å være mulig å presse 10 bilder per sekund på den.
Klynge
Eksperimentet gikk videre og jeg installerte detektoren på fem noder i Google Kubernetes.
Selve podene var svake og hver av dem kunne ikke behandle mer enn 2 bilder per sekund.
Men hvis du kjører en klynge med N noder og analyserer rammer i N tråder, kan du med et tilstrekkelig antall noder (5) oppnå de ønskede 10 bilder per sekund.
def generate():
while True:
rc, frame = vs.read()
if frame is not None:
future = executor.submit(handle_frame, (frame.copy()))
Q.append(future)
keep_polling = len(Q) > 0
while(keep_polling):
top = Q[0]
if top.done():
outFrame = top.result()
Q.popleft()
if outFrame:
yield(b'--framern' b'Content-Type: image/jpegrnrn' + bytearray(outFrame) + b'rn')
keep_polling = len(Q) > 0
else:
keep_polling = len(Q) >= M
Her er det som skjedde:
Litt mindre rask enn med norsk sokkel, men kraftigere enn i én bekk.
Forsterkningen er selvfølgelig ikke lineær - det finnes overlegg for synkronisering og dypkopiering av opencv-bilder.
Konklusjon
Totalt sett lar eksperimentet oss konkludere med at hvis du prøver, kan du komme unna med en enkel sky.
Men en kraftig stasjonær eller lokal maskinvare lar deg oppnå bedre resultater, og uten noen triks.
referanser
Kilde: www.habr.com