रास्पबेरी पाईवरील क्लाउड ऑब्जेक्ट डिटेक्टरचा व्हिडिओ

प्रस्तावना

टेस्लाचा ऑटोपायलट रस्ता कसा पाहतो हे दाखवणारा व्हिडिओ आता इंटरनेटवर फिरत आहे.

डिटेक्टरसह समृद्ध केलेला व्हिडिओ प्रसारित करण्यासाठी आणि रिअल टाइममध्ये मला बर्याच काळापासून खाज सुटली आहे.

समस्या अशी आहे की मला रास्पबेरी वरून व्हिडिओ प्रसारित करायचा आहे आणि त्यावरील न्यूरल नेटवर्क डिटेक्टरचे कार्यप्रदर्शन खूप हवे आहे.

इंटेल न्यूरल कॉम्प्युटर स्टिक

मी वेगवेगळ्या उपायांचा विचार केला.

В शेवटचा लेख इंटेल न्यूरल कॉम्प्युटर स्टिकचा प्रयोग केला. हार्डवेअर शक्तिशाली आहे, परंतु त्याचे स्वतःचे नेटवर्क स्वरूप आवश्यक आहे.

जरी इंटेल प्रमुख फ्रेमवर्कसाठी कन्व्हर्टर प्रदान करते, तरीही अनेक तोटे आहेत.

उदाहरणार्थ, आवश्यक नेटवर्कचे स्वरूप विसंगत असू शकते आणि ते सुसंगत असल्यास, काही स्तर डिव्हाइसवर समर्थित नसतील आणि जर ते समर्थित असतील, तर रूपांतरण प्रक्रियेदरम्यान त्रुटी उद्भवू शकतात, परिणामी आऊटपुटवर काही विचित्र गोष्टी मिळतात.

सर्वसाधारणपणे, तुम्हाला काही प्रकारचे अनियंत्रित न्यूरल नेटवर्क हवे असल्यास, ते NCS सह कार्य करू शकत नाही. म्हणून, मी सर्वात व्यापक आणि प्रवेशयोग्य साधने वापरून समस्येचे निराकरण करण्याचा प्रयत्न करण्याचा निर्णय घेतला.

ढग

स्थानिक हार्डवेअर सोल्यूशनचा स्पष्ट पर्याय म्हणजे क्लाउडवर जाणे.

तयार पर्याय - माझे डोळे जंगली चालतात.

सर्व नेते:

• मायक्रोसॉफ्ट
• Google
• .मेझॉन

... आणि डझनभर कमी ज्ञात.

या विविधतेपैकी निवडणे अजिबात सोपे नाही.

आणि मी निवडायचे नाही, परंतु डॉकरमधील OpenCV वर चांगली जुनी कार्य योजना गुंडाळण्याचा आणि क्लाउडमध्ये चालवण्याचा निर्णय घेतला.

या दृष्टिकोनाचा फायदा म्हणजे लवचिकता आणि नियंत्रण - आपण न्यूरल नेटवर्क, होस्टिंग, सर्व्हर - सर्वसाधारणपणे, कोणत्याही लहरी बदलू शकता.

Сервер

चला स्थानिक प्रोटोटाइपसह प्रारंभ करूया.

पारंपारिकपणे मी REST API, OpenCV आणि MobileSSD नेटवर्कसाठी फ्लास्क वापरतो.

डॉकरवर वर्तमान आवृत्त्या स्थापित केल्यावर, मला आढळले की OpenCV 4.1.2 मोबाइल SSD v1_coco_2018_01_28 सह कार्य करत नाही आणि मला सिद्ध 11/06_2017 वर परत जावे लागले.

सेवेच्या सुरूवातीस, आम्ही वर्गांची नावे आणि नेटवर्क लोड करतो:

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

स्थानिक डॉकरवर (खूप तरुण नसलेल्या लॅपटॉपवर) यास 0.3 सेकंद लागतात, रास्पबेरीवर - 3.5.

चला गणना सुरू करूया:

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

डॉकर - 0.2 सेकंद, रास्पबेरी - 1.7.

टेन्सर एक्झॉस्टला वाचनीय 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

पुढे फ्लास्क द्वारे हे ऑपरेशन निर्यात करा(इनपुट एक चित्र आहे, आउटपुट हे जेसनमधील डिटेक्टरचे परिणाम आहे).

एक पर्यायी पर्याय, ज्यामध्ये अधिक काम सर्व्हरवर हलविले जाते: ते स्वतः सापडलेल्या वस्तूंवर वर्तुळ करते आणि तयार केलेली प्रतिमा परत करते.

हा पर्याय चांगला आहे जेथे आम्ही सर्व्हरवर opencv ड्रॅग करू इच्छित नाही.

डॉकर

आम्ही प्रतिमा गोळा करतो.

कोड combed आणि वर पोस्ट आहे गिथुब, डॉकर तेथून थेट घेईल.

प्लॅटफॉर्म म्हणून, आम्ही रास्पबेरी प्रमाणेच डेबियन स्ट्रेच घेऊ - आम्ही सिद्ध तंत्रज्ञान स्टॅकपासून विचलित होणार नाही.

तुम्हाला फ्लास्क, प्रोटोबफ, रिक्वेस्ट, opencv_python, मोबाईल SSD, Github वरून सर्व्हर कोड डाउनलोड करून सर्व्हर सुरू करण्याची आवश्यकता आहे.

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

सोपा डिटेक्टर क्लायंट विनंत्यांवर आधारित.

डॉकर हबवर प्रकाशित करत आहे

डॉकर रेजिस्ट्री क्लाउड डिटेक्टरपेक्षा कमी वेगाने गुणाकार करत आहेत.

त्रास होऊ नये म्हणून, आम्ही पुराणमतवादीपणे पुढे जाऊ डॉकरहब.

1. नोंदणी करा
2. लॉग इन करा:
   डॉकर लॉगिन
3. चला एक अर्थपूर्ण नाव घेऊन येऊ:
   डॉकर टॅग opencv-detect tprlab/opencv-detect-ssd
4. सर्व्हरवर प्रतिमा अपलोड करा:
   डॉकर पुश tprlab/opencv-detect-ssd

आम्ही क्लाउडमध्ये लॉन्च करतो

कंटेनर कुठे चालवायचा याची निवड देखील खूप विस्तृत आहे.

सर्व मोठे खेळाडू (Google, Microsoft, Amazon) पहिल्या वर्षासाठी मायक्रो-इंस्टन्स मोफत देतात.
Microsoft Azure आणि Google Cloud सह प्रयोग केल्यानंतर, मी नंतरच्या गोष्टींवर स्थिर झालो कारण ते अधिक वेगाने टेक ऑफ झाले.

मी येथे सूचना लिहिल्या नाहीत, कारण हा भाग निवडलेल्या प्रदात्यासाठी अतिशय विशिष्ट आहे.

मी वेगवेगळ्या हार्डवेअर पर्यायांचा प्रयत्न केला,
कमी पातळी (सामायिक आणि समर्पित) - 0.4 - 0.5 सेकंद.
अधिक शक्तिशाली कार - 0.25 - 0.3.
बरं, अगदी वाईट परिस्थितीतही, विजय तीन वेळा आहेत, तुम्ही प्रयत्न करू शकता.

व्हिडिओ

आम्ही रास्पबेरीवर एक साधा OpenCV व्हिडिओ स्ट्रीमर लाँच करतो, Google Cloud द्वारे शोधून.
प्रयोगासाठी, एक व्हिडिओ फाइल वापरली गेली जी एकदा यादृच्छिक छेदनबिंदूवर चित्रित केली गेली होती.

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

डिटेक्टरसह आम्हाला प्रति सेकंद तीन फ्रेम्सपेक्षा जास्त मिळत नाही, सर्वकाही खूप हळू होते.
तुम्ही GCloud मध्ये शक्तिशाली मशीन घेतल्यास, तुम्ही 4-5 फ्रेम्स प्रति सेकंद शोधू शकता, परंतु फरक डोळ्यांना जवळजवळ अदृश्य आहे, तो अजूनही मंद आहे.

क्लाउड आणि वाहतूक खर्चाचा काहीही संबंध नाही; डिटेक्टर सामान्य हार्डवेअरवर चालतो आणि इतक्या वेगाने काम करतो.

न्यूरल कॉम्प्युटर स्टिक

मी प्रतिकार करू शकलो नाही आणि NCS वर बेंचमार्क चालवला.

डिटेक्टरचा वेग 0.1 सेकंदांपेक्षा थोडा कमी होता, कोणत्याही परिस्थितीत कमकुवत मशीनवरील ढगापेक्षा 2-3 पट वेगवान, म्हणजे 8-9 फ्रेम्स प्रति सेकंद.

NCS मोबाईल SSD आवृत्ती 2018_01_28 चालवत होते या वस्तुस्थितीवरून परिणामांमधील फरक स्पष्ट केला आहे.

PS याव्यतिरिक्त, प्रयोगांनी दर्शविले आहे की I7 प्रोसेसरसह बर्‍यापैकी शक्तिशाली डेस्कटॉप मशीन थोडे चांगले परिणाम दर्शवते आणि त्यावर प्रति सेकंद 10 फ्रेम्स पिळून काढणे शक्य झाले आहे.

क्लस्टर

प्रयोग पुढे गेला आणि मी Google Kubernetes मध्ये पाच नोड्सवर डिटेक्टर स्थापित केले.
शेंगा स्वत: कमकुवत होत्या आणि प्रत्येक सेकंदाला 2 फ्रेम्सपेक्षा जास्त प्रक्रिया करू शकत नव्हते.
परंतु जर तुम्ही N नोड्ससह क्लस्टर चालवला आणि N थ्रेड्समध्ये फ्रेम्स पार्स केले, तर पुरेशा संख्येने नोड्स (5) सह तुम्ही इच्छित 10 फ्रेम्स प्रति सेकंद साध्य करू शकता.

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

काय झाले ते येथे आहे:

NCS पेक्षा थोडे कमी वेगवान, परंतु एका प्रवाहापेक्षा अधिक जोमदार.

फायदा, अर्थातच, रेखीय नाही - ओपनसीव्ही प्रतिमा समक्रमित करण्यासाठी आणि खोल कॉपी करण्यासाठी आच्छादन आहेत.

निष्कर्ष

एकंदरीत, प्रयोग आम्हाला असा निष्कर्ष काढण्याची परवानगी देतो की तुम्ही प्रयत्न केल्यास, तुम्ही एका साध्या ढगापासून दूर जाऊ शकता.

परंतु एक शक्तिशाली डेस्कटॉप किंवा स्थानिक हार्डवेअर आपल्याला कोणत्याही युक्त्याशिवाय आणि चांगले परिणाम प्राप्त करण्यास अनुमती देते.

संदर्भ

• Github वर कोड
• डॉकरहबवर डॉकर प्रतिमा
• OpenCV आणि Python वर व्हिडिओ सर्व्हर

स्त्रोत: www.habr.com