Raspberry Pi හි Cloud Object Detector හි වීඩියෝව

පූර්විකාව

ටෙස්ලාගේ ස්වයංක්‍රීය නියමුවා මාර්ගය දකින ආකාරය දැක්වෙන වීඩියෝවක් දැන් අන්තර්ජාලයේ සංසරණය වෙමින් පවතී.

අනාවරකයකින් සහ තත්‍ය කාලීනව පොහොසත් වීඩියෝ විකාශනය කිරීමට මම දිගු කලක් තිස්සේ කැසීමෙන් සිටියෙමි.

ගැටළුව වන්නේ මට Raspberry වෙතින් වීඩියෝ විකාශනය කිරීමට අවශ්ය වන අතර, එය මත ස්නායු ජාල අනාවරකයේ ක්රියාකාරිත්වය අපේක්ෂා කිරීමට බොහෝ දේ ඉතිරි වේ.

Intel Neural Computer Stick

මම විවිධ විසඳුම් සලකා බැලුවෙමි.

В අවසාන ලිපියයි Intel Neural Computer Stick සමඟ අත්හදා බැලුවා. දෘඪාංග බලවත්, නමුත් එහිම ජාල ආකෘතියක් අවශ්ය වේ.

ඉන්ටෙල් විසින් ප්‍රධාන රාමු සඳහා පරිවර්තක ලබා දුන්නද, අන්තරායන් ගණනාවක් තිබේ.

උදාහරණයක් ලෙස, අවශ්‍ය ජාලයේ ආකෘතිය නොගැලපෙන විය හැකි අතර, එය අනුකූල නම්, සමහර ස්ථර උපාංගයට සහය නොදක්වයි, සහ ඒවාට සහය දක්වන්නේ නම්, පරිවර්තන ක්‍රියාවලියේදී දෝෂ ඇතිවිය හැක, එහි ප්‍රතිඵලයක් ලෙස output එකේදී අපිට අමුතු දේවල් ටිකක් ලැබෙනවා.

සාමාන්‍යයෙන්, ඔබට යම් ආකාරයක අත්තනෝමතික ස්නායු ජාලයක් අවශ්‍ය නම්, එය NCS සමඟ ක්‍රියා නොකරනු ඇත. එමනිසා, වඩාත් පුලුල්ව පැතිරුනු සහ ප්රවේශ විය හැකි මෙවලම් භාවිතයෙන් ගැටළුව විසඳීමට උත්සාහ කිරීමට මම තීරණය කළෙමි.

වලාකුළු

දේශීය දෘඩාංග විසඳුම සඳහා පැහැදිලි විකල්පය වන්නේ වලාකුළට යාමයි.

සූදානම් කළ විකල්ප - මගේ ඇස් කම්මැලියි.

සියලුම නායකයින්:

• Microsoft
• ගූගල්
• ඇමේසන්

... සහ අඩුවෙන් දන්නා දුසිම් ගනනක්.

මෙම ප්රභේදය තෝරා ගැනීම පහසු නැත.

මම තෝරා නොගැනීමට තීරණය කළෙමි, නමුත් ඩොකර්හි OpenCV මත හොඳ පැරණි වැඩ යෝජනා ක්රමය ඔතා එය වලාකුළෙහි ධාවනය කිරීමට.

මෙම ප්රවේශයේ වාසිය නම්යශීලීභාවය සහ පාලනයයි - ඔබට ස්නායුක ජාලය, සත්කාරකත්වය, සේවාදායකය වෙනස් කළ හැකිය - සාමාන්යයෙන්, ඕනෑම කැමැත්තක්.

සර්වර්

දේශීය මූලාකෘතියකින් පටන් ගනිමු.

සම්ප්‍රදායිකව මම REST API, OpenCV සහ MobileSSD ජාලය සඳහා Flask භාවිතා කරමි.

Docker හි වත්මන් අනුවාද ස්ථාපනය කිරීමෙන් පසුව, 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

තවදුරටත් මෙම මෙහෙයුම Flask හරහා අපනයනය කරන්න(ආදානය යනු පින්තූරයකි, ප්‍රතිදානය යනු json හි අනාවරකයේ ප්‍රතිඵල වේ).

විකල්ප විකල්පයක්, වැඩි කාර්යයක් සේවාදායකය වෙත මාරු කරනු ලැබේ: එයම සොයාගත් වස්තූන් රවුම් කර නිමි රූපය ආපසු ලබා දෙයි.

අපට opencv සේවාදායකයට ඇදීමට අවශ්‍ය නැති තැන මෙම විකල්පය හොඳයි.

ඩොකර්

අපි රූපය එකතු කරමු.

කේතය පීරා දමා පළ කර ඇත Github, docker එක කෙලින්ම එතනින් ගන්නවා.

වේදිකාවක් ලෙස, අපි Raspberry හි ඇති ආකාරයටම Debian Stretch ගන්නෙමු - අපි ඔප්පු කළ තාක්ෂණික තොගයෙන් අපගමනය නොවෙමු.

ඔබ ප්ලාස්ක්, ප්‍රොටොබෆ්, ඉල්ලීම්, විවෘත cv_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"]

සරලයි අනාවරක සේවාදායකයා ඉල්ලීම් මත පදනම්ව.

Docker Hub වෙත ප්‍රකාශනය කරමින්

ඩොකර් රෙජිස්ට්‍රි වලාකුළු අනාවරකවලට වඩා අඩු නොවන වේගයකින් ගුණ කරයි.

කරදර නොකිරීමට, අපි ගතානුගතිකව යන්නෙමු DockerHub.

1. ලියාපදිංචි වන්න
2. ඇතුල් වන්න:
   ඩොකර් පිවිසුම
3. අපි අර්ථවත් නමක් ඉදිරිපත් කරමු:
   ඩොකර් ටැගය opencv-detect tprlab/opencv-detect-ssd
4. පින්තූරය සේවාදායකයට උඩුගත කරන්න:
   docker push tprlab/opencv-detect-ssd

අපි වලාකුළු තුළ දියත් කරමු

කන්ටේනරය ධාවනය කළ යුතු ස්ථානය තෝරාගැනීම ද තරමක් පුළුල් ය.

සියලුම විශාල ක්‍රීඩකයින් (ගූගල්, මයික්‍රොසොෆ්ට්, ඇමේසන්) පළමු වසර සඳහා නොමිලේ ක්ෂුද්‍ර අවස්ථාවක් ලබා දෙයි.
මයික්‍රොසොෆ්ට් අසුර් සහ ගූගල් ක්ලවුඩ් සමඟ අත්හදා බැලීමෙන් පසු, එය වේගයෙන් ක්‍රියාත්මක වූ නිසා මම දෙවැන්න මත පදිංචි විය.

මෙම කොටස තෝරාගත් සැපයුම්කරුට ඉතා විශේෂිත බැවින් මම මෙහි උපදෙස් ලිව්වේ නැත.

මම විවිධ දෘඪාංග විකල්ප උත්සාහ කළා,
අඩු මට්ටම් (බෙදාගත් සහ කැපවූ) - තත්පර 0.4 - 0.5.
වඩා බලවත් මෝටර් රථ - 0.25 - 0.3.
හොඳයි, නරකම අවස්ථාවක පවා, ජයග්රහණ තුන් වතාවක්, ඔබට උත්සාහ කළ හැකිය.

Видео

අපි Google Cloud හරහා හඳුනා ගනිමින් Raspberry හි සරල OpenCV වීඩියෝ ප්‍රවාහයක් දියත් කරමු.
අත්හදා බැලීම සඳහා, වරක් අහඹු මංසන්ධියක රූගත කරන ලද වීඩියෝ ගොනුවක් භාවිතා කරන ලදී.

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 සමඟ වඩා ටිකක් අඩු වේගවත්, නමුත් එක් ප්‍රවාහයකට වඩා ප්‍රබලයි.

ලාභය, ඇත්ත වශයෙන්ම, රේඛීය නොවේ - opencv රූප සමමුහුර්ත කිරීම සහ ගැඹුරින් පිටපත් කිරීම සඳහා ආවරණ ඇත.

නිගමනය

සමස්තයක් වශයෙන්, ඔබ උත්සාහ කරන්නේ නම්, ඔබට සරල වලාකුළකින් ගැලවිය හැකි බව නිගමනය කිරීමට අත්හදා බැලීම අපට ඉඩ සලසයි.

නමුත් බලවත් ඩෙස්ක්ටොප් හෝ දේශීය දෘඪාංග ඔබට වඩා හොඳ ප්රතිඵල ලබා ගැනීමට ඉඩ සලසයි, සහ කිසිදු උපක්රමයකින් තොරව.

යොමු

• Github හි කේතය
• DockerHub හි ඩොකර් රූපය
• OpenCV සහ Python මත වීඩියෝ සේවාදායකය

මූලාශ්රය: www.habr.com