វីដេអូនៃ Cloud Object Detector នៅលើ Raspberry Pi

Prologue

វីដេអូមួយកំពុងចរាចរនៅលើអ៊ីនធឺណិត ដែលបង្ហាញពីរបៀបដែលអ្នកបើកបររថយន្ត Tesla មើលឃើញផ្លូវ។

ខ្ញុំ​បាន​រមាស់​ជា​យូរ​មក​ហើយ​ក្នុង​ការ​ចាក់​ផ្សាយ​វីដេអូ​ដែល​សំបូរ​ដោយ​ឧបករណ៍​ចាប់​សញ្ញា ហើយ​ក្នុង​ពេល​ជាក់ស្តែង។

បញ្ហាគឺថាខ្ញុំចង់ចាក់ផ្សាយវីដេអូពី Raspberry ហើយការសម្តែងរបស់ឧបករណ៍ចាប់បណ្តាញសរសៃប្រសាទនៅលើវាទុកឱ្យមានការចង់បានច្រើន។

Intel Neural Computer Stick

ខ្ញុំបានពិចារណាដំណោះស្រាយផ្សេងៗ។

В អត្ថបទចុងក្រោយ ពិសោធន៍ជាមួយ Intel Neural Computer Stick ។ ហាដវែរមានថាមពលខ្លាំង ប៉ុន្តែទាមទារទម្រង់បណ្តាញផ្ទាល់ខ្លួនរបស់វា។

ទោះបីជា Intel ផ្តល់ឧបករណ៍បំប្លែងសម្រាប់ក្របខ័ណ្ឌសំខាន់ៗក៏ដោយ វាមានឧបសគ្គមួយចំនួន។

ឧទាហរណ៍ ទ្រង់ទ្រាយនៃបណ្តាញដែលត្រូវការអាចមិនត្រូវគ្នា ហើយប្រសិនបើវាត្រូវគ្នា នោះស្រទាប់មួយចំនួនប្រហែលជាមិនត្រូវបានគាំទ្រនៅលើឧបករណ៍នោះទេ ហើយប្រសិនបើពួកវាត្រូវបានគាំទ្រ នោះកំហុសអាចកើតឡើងក្នុងអំឡុងពេលដំណើរការបំប្លែង ដែលជាលទ្ធផល យើងទទួលបានរបស់ចម្លែកខ្លះនៅឯទិន្នផល។

ជាទូទៅ ប្រសិនបើអ្នកចង់បានបណ្តាញសរសៃប្រសាទតាមអំពើចិត្តមួយចំនួន នោះវាប្រហែលជាមិនដំណើរការជាមួយ NCS ទេ។ ដូច្នេះហើយ ខ្ញុំបានសម្រេចចិត្តព្យាយាមដោះស្រាយបញ្ហាដោយប្រើឧបករណ៍ដែលរីករាលដាលបំផុត និងអាចចូលប្រើបាន។

ពពក

ជម្រើសជាក់ស្តែងចំពោះដំណោះស្រាយផ្នែករឹងក្នុងស្រុកគឺត្រូវចូលទៅកាន់ពពក។

ជម្រើសដែលត្រៀមរួចជាស្រេច - ភ្នែករបស់ខ្ញុំរត់ព្រៃ។

អ្នកដឹកនាំទាំងអស់៖

• ក្រុមហ៊ុន Microsoft
• Google
• អាម៉ាហ្សូន

... ហើយមនុស្សរាប់សិបនាក់ដែលមិនសូវស្គាល់។

ការជ្រើសរើសក្នុងចំណោមពូជនេះគឺមិនងាយស្រួលទាល់តែសោះ។

ហើយខ្ញុំបានសម្រេចចិត្តមិនជ្រើសរើស ប៉ុន្តែដើម្បីរុំគ្រោងការណ៍ការងារចាស់ដ៏ល្អនៅលើ OpenCV នៅក្នុង Docker ហើយដំណើរការវានៅក្នុងពពក។

អត្ថប្រយោជន៍នៃវិធីសាស្រ្តនេះគឺភាពបត់បែននិងការគ្រប់គ្រង - អ្នកអាចផ្លាស់ប្តូរបណ្តាញសរសៃប្រសាទ, បង្ហោះ, ម៉ាស៊ីនមេ - ជាទូទៅ, whim ណាមួយ។

ម៉ាស៊ីនមេ

ចូរចាប់ផ្តើមជាមួយនឹងគំរូក្នុងស្រុក។

ជាប្រពៃណីខ្ញុំប្រើ Flask សម្រាប់ REST API, OpenCV និងបណ្តាញ MobileSSD ។

ដោយបានដំឡើងកំណែបច្ចុប្បន្ននៅលើ 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)

នៅលើ docker ក្នុងស្រុក (នៅលើកុំព្យូទ័រយួរដៃដែលមិនក្មេងខ្លាំង) វាចំណាយពេល 0.3 វិនាទីនៅលើ Raspberry - 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 exhaust ទៅជា 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 ទៅកាន់ម៉ាស៊ីនមេ។

Docker

យើងប្រមូលរូបភាព។

កូដ​ត្រូវ​បាន​សិត​ហើយ​បង្ហោះ Github, docker នឹងយកវាដោយផ្ទាល់ពីទីនោះ។

ជាវេទិកាមួយ យើងនឹងយក Debian Stretch ដូចនៅលើ Raspberry - យើងនឹងមិនងាកចេញពីជង់បច្ចេកវិទ្យាដែលបានបញ្ជាក់នោះទេ។

អ្នកត្រូវដំឡើង flask, protobuf, សំណើ, opencv_python, ទាញយក Mobile SSD, server code ពី Github ហើយចាប់ផ្តើម server។

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

ការចុះឈ្មោះ Docker កំពុងកើនឡើងក្នុងល្បឿនមិនតិចជាងឧបករណ៍រាវរកពពកទេ។

ដើម្បីកុំឱ្យរំខានយើងនឹងអភិរក្ស 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 ។
ជាការប្រសើរណាស់ សូម្បីតែនៅក្នុងសេណារីយ៉ូដ៏អាក្រក់បំផុត ការឈ្នះគឺបីដង អ្នកអាចសាកល្បងបាន។

Видео

យើងបើកដំណើរការកម្មវិធីផ្សាយវីដេអូ OpenCV សាមញ្ញនៅលើ Raspberry ដោយរកឃើញតាមរយៈ 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 ហ្វ្រេមក្នុងមួយវិនាទី ប៉ុន្តែភាពខុសគ្នាគឺស្ទើរតែមើលមិនឃើញដោយភ្នែក វានៅតែយឺត។

ពពក និងថ្លៃដឹកជញ្ជូនមិនមានជាប់ពាក់ព័ន្ធជាមួយវាទេ ឧបករណ៍ចាប់ដំណើរការលើផ្នែករឹងធម្មតា ហើយដំណើរការក្នុងល្បឿននោះ។

Neural Computer Stick

ខ្ញុំ​មិន​អាច​ទប់ទល់​និង​បាន​ដំណើរការ​គោល​ដៅ​លើ NCS ទេ។

ល្បឿនរបស់ឧបករណ៍ចាប់គឺយឺតជាង 0.1 វិនាទី ក្នុងករណីណាក៏ដោយ 2-3 ដងលឿនជាងពពកនៅលើម៉ាស៊ីនខ្សោយ ពោលគឺ 8-9 ហ្វ្រេមក្នុងមួយវិនាទី។

ភាពខុសគ្នានៃលទ្ធផលត្រូវបានពន្យល់ដោយការពិតដែលថា NCS កំពុងដំណើរការ Mobile SSD កំណែ 2018_01_28។

P.S. លើសពីនេះទៀតការពិសោធន៍បានបង្ហាញថាម៉ាស៊ីនកុំព្យូទ័រលើតុដែលមានថាមពលខ្លាំងជាមួយប្រព័ន្ធដំណើរការ I7 បង្ហាញលទ្ធផលប្រសើរជាងមុនបន្តិចហើយវាបានប្រែទៅជាអាចធ្វើទៅបានដើម្បីច្របាច់ចេញ 10 ហ្វ្រេមក្នុងមួយវិនាទី។

ចង្កោម

ការពិសោធន៍បានបន្តទៅមុខទៀត ហើយខ្ញុំបានដំឡើងឧបករណ៍ចាប់នៅលើថ្នាំងចំនួនប្រាំនៅក្នុង Google Kubernetes ។
ផើងខ្លួនឯងខ្សោយ ហើយពួកវានីមួយៗមិនអាចដំណើរការលើសពី 2 ហ្វ្រេមក្នុងមួយវិនាទីបានទេ។
ប៉ុន្តែប្រសិនបើអ្នកដំណើរការចង្កោមជាមួយ N nodes និង parse frames ក្នុង N threads បន្ទាប់មកជាមួយនឹងចំនួន nodes គ្រប់គ្រាន់ (5) អ្នកអាចសម្រេចបាន 10 frames ដែលចង់បានក្នុងមួយវិនាទី។

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
• រូបភាព Docker នៅលើ DockerHub
• ម៉ាស៊ីនមេវីដេអូនៅលើ OpenCV & Python

ប្រភព: www.habr.com