Raspberry Pi ရှိ Cloud Object Detector ၏ ဗီဒီယို

စကားချီး

Tesla ၏ အလိုအလျောက် မောင်းနှင်သူသည် လမ်းကို မည်သို့မြင်ကြောင်း ပြသသည့် ဗီဒီယိုသည် ယခုအခါ အင်တာနက်ပေါ်တွင် ပျံ့နှံ့နေပါသည်။

ထောက်လှမ်းကိရိယာဖြင့် ကြွယ်ဝသော ဗီဒီယိုကို အချိန်နှင့်တပြေးညီထုတ်လွှင့်ရန် အချိန်အတော်ကြာ ယားယံနေပါသည်။

ပြဿနာမှာ Raspberry မှ ဗီဒီယိုကို ထုတ်လွှင့်လိုခြင်းဖြစ်ပြီး ၎င်းတွင် neural network detector ၏ စွမ်းဆောင်ရည်သည် လိုချင်စရာများစွာ ကျန်ရစ်ခဲ့သည်။

Intel Neural Computer Stick

မတူညီတဲ့ ဖြေရှင်းနည်းတွေကို စဉ်းစားခဲ့တယ်။

В ပြီးခဲ့သည့်ဆောင်းပါး Intel Neural Computer Stick ဖြင့် စမ်းသပ်ခဲ့သည်။ ဟာ့ဒ်ဝဲသည် အစွမ်းထက်သော်လည်း ၎င်း၏ကိုယ်ပိုင်ကွန်ရက်ဖော်မတ်လိုအပ်သည်။

Intel သည် အဓိက မူဘောင်များအတွက် converters များကို ပံ့ပိုးပေးသော်လည်း ချို့ယွင်းချက်များစွာရှိသည်။

ဥပမာအားဖြင့်၊ လိုအပ်သောကွန်ရက်၏ဖော်မတ်သည် သဟဇာတမဖြစ်နိုင်သော်လည်း ၎င်းသည် လိုက်ဖက်ပါက၊ အချို့သောအလွှာများကို စက်ပေါ်တွင် ပံ့ပိုးပေးနိုင်မည်မဟုတ်သည့်အပြင် ၎င်းတို့ကို ပံ့ပိုးပေးပါက၊ ထိုရလဒ်ကြောင့် ပြောင်းလဲခြင်းလုပ်ငန်းစဉ်အတွင်း အမှားအယွင်းများ ဖြစ်ပေါ်လာနိုင်သည်။ ထွက်ပေါက်မှာ ထူးဆန်းတဲ့အရာတချို့ကို ကျွန်တော်တို့ ရရှိပါတယ်။

ယေဘူယျအားဖြင့်၊ သင်သည် ထင်သလိုမဟုတ်သော အာရုံကြောကွန်ရက်တစ်မျိုးမျိုးကို လိုချင်ပါက၊ ၎င်းသည် NCS နှင့် အလုပ်မဖြစ်နိုင်ပါ။ ထို့ကြောင့်၊ အကျယ်ပြန့်ဆုံးနှင့် လက်လှမ်းမီနိုင်သော ကိရိယာများကို အသုံးပြု၍ ပြဿနာကို ဖြေရှင်းရန် ကြိုးစားရန် ဆုံးဖြတ်ခဲ့သည်။

မိုဃ်းတိမ်ကို

ဒေသတွင်း ဟာ့ဒ်ဝဲဖြေရှင်းချက်အတွက် သိသာထင်ရှားသော အစားထိုးနည်းလမ်းမှာ တိမ်တိုက်သို့သွားခြင်း ဖြစ်သည်။

အဆင်သင့်လုပ်ထားသော ရွေးချယ်မှုများ - ကျွန်ုပ်မျက်လုံးများ ရိုင်းသွားပါသည်။

ခေါင်းဆောင်များအားလုံး-

• မိုက်ခရိုဆော့ဖ်
• Google က
• အမေဇုံ

... နောက်ပြီး လူသိနည်းတဲ့ ဒါဇင်ပေါင်းများစွာ။

ဤအမျိုးအစားများထဲမှ ရွေးချယ်ခြင်းသည် လွယ်ကူသည်မဟုတ်။

ပြီးတော့ ကျွန်တော် Docker မှာ OpenCV မှာ ကောင်းမွန်တဲ့ အလုပ်အစီအစဥ်ဟောင်းကို ခြုံပြီး cloud မှာ run ဖို့ ကျွန်တော် မရွေးချယ်ဖို့ ဆုံးဖြတ်လိုက်တယ်။

ဤချဉ်းကပ်မှု၏အားသာချက်မှာ ပြောင်းလွယ်ပြင်လွယ်နှင့် ထိန်းချုပ်ခြင်းဖြစ်သည် - သင်သည် အာရုံကြောကွန်ရက်၊ hosting၊ ဆာဗာကို ပြောင်းလဲနိုင်သည်။

ဆာဗာက

ဒေသဆိုင်ရာ နမူနာပုံစံဖြင့် စကြပါစို့။

အစဉ်အလာအားဖြင့် ကျွန်ုပ်သည် REST API၊ OpenCV နှင့် MobileSSD ကွန်ရက်အတွက် Flask ကို အသုံးပြုသည်။

Docker တွင် လက်ရှိဗားရှင်းများကို ထည့်သွင်းပြီးနောက်၊ OpenCV 4.1.2 သည် Mobile 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)

Local docker (သိပ်မငယ်တဲ့ laptop မှာ) Raspberry - 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()

Docker - 0.2 စက္ကန့်၊ Raspberry - 1.7 ။

tensor အိတ်ဇောကို ဖတ်နိုင်သော 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 မှတစ်ဆင့် တင်ပို့ပါ။(input သည် ပုံတစ်ပုံဖြစ်ပြီး output သည် json ရှိ detector ၏ရလဒ်ဖြစ်သည်)။

ဆာဗာသို့ အလုပ်ပိုမိုရွှေ့နိုင်သည့် အစားထိုးရွေးချယ်မှုတစ်ခု- ၎င်းသည် တွေ့ရှိသည့်အရာဝတ္ထုများကို စက်ဝိုင်းနှင့် ပြီးသွားသည့်ပုံကို ပြန်ပေးသည်။

ကျွန်ုပ်တို့သည် opencv ကို ဆာဗာသို့ မဆွဲယူလိုသော ဤရွေးချယ်မှုသည် ကောင်းမွန်ပါသည်။

Docker

ပုံကို စုစည်းထားပါတယ်။

ကုဒ်ကို ကုတ်ခြစ်ပြီး တင်ထားသည်။ Github၊ docker သည် ၎င်းကို ထိုနေရာမှ တိုက်ရိုက်ယူပါမည်။

ပလပ်ဖောင်းတစ်ခုအနေနှင့်၊ Raspberry တွင်ကဲ့သို့ Debian Stretch ကို ကျွန်ုပ်တို့ယူပါမည် - သက်သေပြထားသောနည်းပညာအစုအဝေးမှ သွေဖည်မည်မဟုတ်ပါ။

သင်သည် flask၊ protobuf၊ တောင်းဆိုမှုများ၊ opencv_python၊ Mobile 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"]

ရိုးရိုး detector client တောင်းဆိုချက်များအပေါ်အခြေခံသည်။

Docker Hub သို့ ထုတ်ဝေခြင်း။

Docker မှတ်ပုံတင်ခြင်းများသည် cloud detectors များထက်မနည်းသော အမြန်နှုန်းဖြင့် များပြားနေသည်။

အနှောက်အယှက်မဖြစ်စေရန် ရှေးရိုးစွဲအတိုင်း ဖြတ်သန်းသွားပါမည်။ DockerHub.

1. မှတ်ပုံတင်ပါ။
2. လော့ဂ်အင်:
   docker အကောင့်ဝင်ပါ။
3. အဓိပ္ပါယ်ရှိတဲ့ နာမည်တစ်ခုနဲ့ ကြည့်လိုက်ရအောင်။
   docker တဂ် opencv-detect tprlab/opencv-detect-ssd
4. ပုံကို ဆာဗာသို့ အပ်လုဒ်လုပ်ပါ။
   docker က tprlab/opencv-detect-ssd ကို တွန်းပါ။

ကျွန်ုပ်တို့သည် တိမ်တိုက်တွင် လွှင့်တင်သည်။

ကွန်တိန်နာကို လည်ပတ်မည့်နေရာ ရွေးချယ်မှုမှာလည်း အလွန်ကျယ်ပြန့်သည်။

ကစားသမားကြီးများအားလုံး (Google၊ Microsoft၊ Amazon) သည် ပထမနှစ်အတွက် micro-instance ကို အခမဲ့ပေးဆောင်သည်။
Microsoft Azure နှင့် Google Cloud တို့ကို စမ်းသပ်ပြီးနောက်၊ ပိုမြန်လာသောကြောင့် နောက်ပိုင်းတွင် ကျွန်တော် အခြေချခဲ့သည်။

ဤအပိုင်းသည် ရွေးချယ်ထားသောဝန်ဆောင်မှုပေးသူအတွက် အလွန်တိကျသောကြောင့် ဤနေရာတွင် ညွှန်ကြားချက်များကို ကျွန်ုပ်မရေးခဲ့ပါ။

ဟာ့ဒ်ဝဲရွေးချယ်စရာအမျိုးမျိုးကို ငါကြိုးစားခဲ့တယ်၊
အဆင့်နိမ့် (မျှဝေပြီး သီးသန့်) - 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 frames နှုန်းကို သင်ထောက်လှမ်းနိုင်သော်လည်း ခြားနားချက်ကို မျက်စိမှမမြင်နိုင်သောကြောင့် နှေးနေသေးသည်။

cloud နှင့် သယ်ယူပို့ဆောင်ရေးစရိတ်များသည် ၎င်းနှင့်မသက်ဆိုင်ပါ ၊ detector သည် သာမန် hardware ပေါ်တွင်အလုပ်လုပ်ပြီး ထိုကဲ့သို့အမြန်နှုန်းဖြင့်အလုပ်လုပ်ပါသည်။

Neural Computer Stick

ကျွန်ုပ်သည် သည်းမခံနိုင်ဘဲ NCS ၏ စံနှုန်းကို အကောင်အထည်ဖော်ခဲ့သည်။

detector ၏အမြန်နှုန်းသည် 0.1 စက္ကန့်ထက် အနည်းငယ်နှေးကွေးနေသော်လည်း မည်သည့်အခြေအနေတွင်မဆို အားနည်းသောစက်ရှိ cloud ထက် 2-3 ဆ ပိုမြန်သည်၊ ဆိုလိုသည်မှာ တစ်စက္ကန့်လျှင် 8-9 frames ဖြစ်သည်။

NCS သည် Mobile SSD ဗားရှင်း 2018_01_28 ကို အသုံးပြုနေခြင်းကြောင့် ရလဒ်များ၏ ကွာခြားချက်ကို ရှင်းပြပါသည်။

PS ထို့အပြင်၊ စမ်းသပ်ချက်များအရ I7 ပရိုဆက်ဆာပါသော အစွမ်းထက်သော desktop စက်သည် အနည်းငယ်ပိုမိုကောင်းမွန်သော ရလဒ်များကိုပြသပြီး ၎င်းတွင် တစ်စက္ကန့်လျှင် 10 frames ညှစ်ရန် ဖြစ်နိုင်ကြောင်းပြသခဲ့သည်။

စပျစ်သီးပြွတ်

စမ်းသပ်မှုသည် ပိုမိုများပြားလာပြီး Google Kubernetes ရှိ node ငါးခုတွင် detector ကို တပ်ဆင်ခဲ့သည်။
အစေ့များသည် ၎င်းတို့ကိုယ်တိုင် အားနည်းနေပြီး ၎င်းတို့တစ်ခုစီသည် တစ်စက္ကန့်လျှင် 2 frames ထက်ပို၍ မလုပ်ဆောင်နိုင်ပါ။
သို့သော် အကယ်၍ သင်သည် N node များနှင့် N thread များတွင် ခွဲခြမ်းစိတ်ဖြာမှုဘောင်များပါရှိသော အစုအဝေးတစ်ခုကို လုပ်ဆောင်ပါက၊ လုံလောက်သော node အရေအတွက် (5) ဖြင့် သင်လိုချင်သော 10 frames per second ကို ရရှိနိုင်သည်။

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 ရှိ Docker ပုံ
• OpenCV & Python ရှိ ဗီဒီယိုဆာဗာ

source: www.habr.com