Video objekti tuvastamise kohta Raspberry Pi-l

Proloog

Praegu levib internetis video, kuidas Tesla autopiloot näeb teed.

Olen juba ammu tahtnud edastada videot, mida täiustatakse detektoriga, ja seda reaalses ajas.

Probleem on selles, et tahan videot edastada Raspberry-lt, kuid närvivõrgu detektori jõudlus on kehv.

Intel Neural Computer Stick

Olen kaalunud erinevaid lahendusi.

V eelmisel artiklil Eksperimenteerin Intel Neural Computer Stickiga. Seade on võimas, kuid vajab oma võrgu formaati.

Kuigi Intel pakub konvertereid peamiste raamistike jaoks, on siin mitmeid peidetud probleeme.

Näiteks vajalik võrgu formaat võib olla ühilduv, ja isegi kui see on ühilduv, võivad mõned kihid seadmes ei ole toetatud, aga kui need on toetatud, võivad konversiooni käigus tekkida vead, mille tulemuseks on mõned kummalised asjad.

Ühesõnaga, kui soovite mõnda suvalist närvivõrku, siis ei pruugi see NCS-iga õnnestuda. Seetõttu otsustasin proovida probleemi lahendada kõige massilisemate ja kergesti juurdepääsetavate tööriistade kaudu.

Pilv

Ilmselt on kohalikule riistvaralahendusele alternatiiviks üleminek pilve.

Valikuvõimalusi on tohutult.

Kõik liidrid:

• Microsoft
• Google
• Amazon

… ja kümneid vähem tuntud.

Selle mitmekesisuse seast valimine pole just lihtne.

Otsustasin mitte valida, vaid tõsta vana hea tööprotsessi OpenCV Dockerisse ja käivitada see pilves.

Selle lähenemise eeliseks on paindlikkus ja kontroll — saab vahetada närvivõrku, hostimist, serverit — üldiselt kõike, mida soovid.

Server

Alustame kohalikust prototüübist.

Tavaliselt kasutan REST API jaoks Flaski, OpenCV-d ja MobileSSD võrku.

Paigaldades Dockerisse uusimad versioonid, avastasin, et OpenCV 4.1.2 ei tööta koos Mobile SSD v1_coco_2018_01_28-ga ning pidin tagasi minema tõestatud 11_06_2017 versiooni.

Teenuse käivitamisel laadime klasside nimed ja võrgu:

def init():
    tf_labels.initLabels(dnn_conf.DNN_LABELS_PATH)
    return cv.dnn.readNetFromTensorflow(dnn_conf.DNN_PATH, dnn_conf.DNN_TXT_PATH)

Kohalikus Dockeris (mitte kõige uuemas sülearvutis) võtab see 0,3 sekundit, Raspberry-l aga 3,5.

Käivitame arvutuse:

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, Raspberry — 1,7.

Muutame tensori väljundi loetavaks json-iks:

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

Edasi me eksportime selle operatsiooni läbi Flaski(sisendiks on pilt, väljundiks — detektori tulemused json-formaadis).

Alternatiivne variant, kus rohkem tööd kantakse serveri õlule: see joonistab leitud objektid ise ümber ja tagastab valmis pildi.

See variant sobib hästi, kui me ei soovi opencv-d serverisse tuua.

Docker

Kogume pildi.

Kood on korrastatud ja postitatud Github, docker võtab selle otse sealt.

Platvormiks võtame sama Debian Stretchi, mis on Raspberry peal — ei lähe usaldusväärsest tehnoloogiapakist kaugemale.

Peame installima flaski, protobufi, requests'i, opencv_python'i, alla laadima Mobile SSD, serverikoodi GitHubist ja serveri käivitama.

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

Lihtne klient detektori jaoks põhinev requestsil.

Avaldamine Docker Hubis

Docker registrid tõukuvad sama kiiresti, kui pilvedetektorid.

Et mitte keeruliseks minna, võtame konservatiivse lähenemise läbi DockerHubi.

1. Registreerume
2. Logime sisse:
   docker login
3. Mõtleme välja sisuka nime:
   docker tag opencv-detect tprlab/opencv-detect-ssd
4. Laeme pildi serverisse:
   docker push tprlab/opencv-detect-ssd

Käivitame pilves

Valik, kus konteinerit käivitada, on samuti üsna lai.

Kõik suured tegijad (Google, Microsoft, Amazon) pakuvad esimese aasta jooksul tasuta mikroinstantsi.
Katsusin Microsoft Azure’i ja Google Cloudi, kuid peatusin viimase juures — sest see tõusis kiiremini.

Ei hakanud siia juhendit kirjutama, kuna see osa on väga spetsiifiline valitud teenusepakkuja jaoks.

Proovisin erinevaid rauavariante,
Madala taseme (jagatud ja pühendatud) — 0,4 — 0,5 sekundit.
Tugevamad masinad — 0,25 — 0,3.
Noh, isegi halvemal juhul on võit kolme korda, proovi ära.

Video

Käivitame lihtsa OpenCV videostreami Raspberryl, tuvastades läbi Google Cloud.
Eksperimendi jaoks kasutati videofaili, mis on kunagi filmitud juhuslikul ristmikul.

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

Detektoriga ei saa rohkem kui kolm kaadrit sekundis, kõik toimub väga aeglaselt.
Kui GCloudis võtta võimas masin, võib tuvastada 4-5 kaadrit sekundis, kuid silmaga on erinevus praktiliselt märkamatud, ikkagi aeglane.

Pilv ja transpordikulud siin ei mängi rolli, tavalisel riistvaral töötab detektor sellise kiirus.

Neural Computer Stick

Ei suutnud end tagasi hoida ja jooksin NCS-il benchmark'i.

Detektori kiirus oli natuke aeglasem kui 0.1 sekundit, igal juhul 2-3 korda kiiremini kui pilves nõrkal masinal, s.t 8-9 kaadrit sekundis.

Tulemustes on erinevus seletatav sellega, et NCS-il käivitati Mobile SSD versioon 2018_01_28.

P.S. Lisaks on katsetused näidanud, et piisavalt võimas lauaarvuti, millel on I7 protsessor, näitab veidi paremaid tulemusi ja sellel õnnestub saavutada 10 kaadrit sekundis.

Klaster

Eksperiment läks kaugemale ja paigaldasin detektori viiele sõlmele Google Kuberneteses.
Isegi konteinerid olid nõrgad ja igaühel neist ei õnnestunud töödelda rohkem kui 2 kaadrit sekundis.
Kuid kui käivitada klaster N sõlmel ja jagada kaadreid N voogu — siis piisava arvu sõlmade (5) korral on võimalik saavutada soovitud 10 kaadrit sekundis.

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

Siin on tulemused:

Veidi mitte nii kiiresti nagu NCS-iga, kuid kiiremini kui ühes voos.

Kasum ei ole loomulikult lineaarne — tekivad sünkroniseerimise ja sügava kopeerimise probleemid opencv piltide puhul.

Kokkuvõte

Üldiselt võimaldab eksperiment järeldada, et kui pingutada, on lihtsa pilve toestamine võimalik.

Kuid võimas töölaua arvuti või kohalik server annab paremaid tulemusi, ilma igasuguste trikkideta.

Lingid

• Kood GitHubis
• Docker image DockerHubis
• Videoteenus OpenCV ja Pythoniga

Allikas: habr.com