રાસ્પબેરી પી પર ક્લાઉડ ઑબ્જેક્ટ ડિટેક્ટરનો વિડિઓ

પ્રસ્તાવના

ટેસ્લાના ઓટોપાયલટ રસ્તાને કેવી રીતે જુએ છે તે દર્શાવતો એક વીડિયો હવે ઇન્ટરનેટ પર ફરતો થઈ રહ્યો છે.

મને ડિટેક્ટર સાથે સમૃદ્ધ વિડિઓ પ્રસારિત કરવા માટે લાંબા સમયથી ખંજવાળ આવે છે, અને વાસ્તવિક સમયમાં.

સમસ્યા એ છે કે હું રાસ્પબેરીમાંથી વિડિઓ પ્રસારિત કરવા માંગુ છું, અને તેના પર ન્યુરલ નેટવર્ક ડિટેક્ટરનું પ્રદર્શન ઇચ્છિત થવા માટે ઘણું છોડી દે છે.

ઇન્ટેલ ન્યુરલ કમ્પ્યુટર સ્ટિક

મેં વિવિધ ઉકેલો ધ્યાનમાં લીધા.

В છેલ્લા લેખ ઇન્ટેલ ન્યુરલ કમ્પ્યુટર સ્ટિક સાથે પ્રયોગ કર્યો. હાર્ડવેર શક્તિશાળી છે, પરંતુ તેના પોતાના નેટવર્ક ફોર્મેટની જરૂર છે.

ભલે ઇન્ટેલ મુખ્ય ફ્રેમવર્ક માટે કન્વર્ટર પ્રદાન કરે છે, ત્યાં ઘણી બધી મુશ્કેલીઓ છે.

ઉદાહરણ તરીકે, જરૂરી નેટવર્કનું ફોર્મેટ અસંગત હોઈ શકે છે, અને જો તે સુસંગત હોય, તો કેટલાક સ્તરો ઉપકરણ પર સમર્થિત ન હોઈ શકે, અને જો તે સમર્થિત હોય, તો પછી રૂપાંતરણ પ્રક્રિયા દરમિયાન ભૂલો આવી શકે છે, જેના પરિણામે અમને આઉટપુટ પર કેટલીક વિચિત્ર વસ્તુઓ મળે છે.

સામાન્ય રીતે, જો તમને કોઈ પ્રકારનું મનસ્વી ન્યુરલ નેટવર્ક જોઈએ છે, તો તે NCS સાથે કામ કરી શકશે નહીં. તેથી, મેં સૌથી વધુ વ્યાપક અને સુલભ સાધનોનો ઉપયોગ કરીને સમસ્યાને હલ કરવાનો પ્રયાસ કરવાનું નક્કી કર્યું.

વાદળ

સ્થાનિક હાર્ડવેર સોલ્યુશનનો સ્પષ્ટ વિકલ્પ ક્લાઉડ પર જવાનું છે.

તૈયાર વિકલ્પો - મારી આંખો જંગલી ચાલે છે.

બધા નેતાઓ:

• માઈક્રોસોફ્ટ
• Google
• એમેઝોન

... અને ડઝનેક ઓછા જાણીતા.

આ વિવિધતાઓમાંથી પસંદ કરવાનું બિલકુલ સરળ નથી.

અને મેં પસંદ ન કરવાનું નક્કી કર્યું, પરંતુ ડોકરમાં ઓપનસીવી પર સારી જૂની કાર્યકારી યોજનાને લપેટી અને તેને ક્લાઉડમાં ચલાવવાનું નક્કી કર્યું.

આ અભિગમનો ફાયદો લવચીકતા અને નિયંત્રણ છે - તમે ન્યુરલ નેટવર્ક, હોસ્ટિંગ, સર્વર - સામાન્ય રીતે, કોઈપણ ધૂન બદલી શકો છો.

સર્વર

ચાલો સ્થાનિક પ્રોટોટાઇપથી શરૂઆત કરીએ.

પરંપરાગત રીતે હું 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

આગળ ફ્લાસ્ક દ્વારા આ કામગીરીની નિકાસ કરો(ઇનપુટ એક ચિત્ર છે, આઉટપુટ એ json માં ડિટેક્ટરના પરિણામો છે).

એક વૈકલ્પિક વિકલ્પ, જેમાં વધુ કાર્ય સર્વર પર સ્થાનાંતરિત થાય છે: તે પોતે મળેલી વસ્તુઓને વર્તુળ કરે છે અને તૈયાર કરેલી છબી પરત કરે છે.

આ વિકલ્પ સારો છે જ્યાં આપણે opencv ને સર્વર પર ખેંચવા માંગતા નથી.

ડોકર

અમે છબી એકત્રિત કરીએ છીએ.

કોડ કોમ્બેડ અને પર પોસ્ટ કરવામાં આવે છે ગીથબ, ડોકર તેને ત્યાંથી સીધું લઈ જશે.

પ્લેટફોર્મ તરીકે, અમે રાસ્પબેરીની જેમ જ ડેબિયન સ્ટ્રેચ લઈશું - અમે સાબિત ટેક સ્ટેકથી વિચલિત થઈશું નહીં.

તમારે ફ્લાસ્ક, પ્રોટોબફ, વિનંતીઓ, 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) પ્રથમ વર્ષ માટે મફતમાં માઇક્રો-ઇન્સ્ટન્સ ઓફર કરે છે.
માઈક્રોસોફ્ટ એઝ્યુર અને ગૂગલ ક્લાઉડ સાથે પ્રયોગ કર્યા પછી, મેં બાદમાં સેટલ કર્યું કારણ કે તે ઝડપથી ઉપડ્યું.

મેં અહીં સૂચનાઓ લખી નથી, કારણ કે આ ભાગ પસંદ કરેલ પ્રદાતા માટે ખૂબ જ વિશિષ્ટ છે.

મેં વિવિધ હાર્ડવેર વિકલ્પો અજમાવ્યા,
નીચા સ્તરો (શેર કરેલ અને સમર્પિત) - 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 પર કોડ
• DockerHub પર ડોકર છબી
• OpenCV અને Python પર વિડિઓ સર્વર

સોર્સ: www.habr.com