🥇וידאו עם גלאי אובייקטים בענן ב-Raspberry Pi

פרולוג

סרטון מסתובב כעת באינטרנט המראה כיצד הטייס האוטומטי של טסלה רואה את הכביש.

כבר הרבה זמן שאני מגרד לשדר וידאו מועשר בגלאי, ובזמן אמת.

הבעיה היא שאני רוצה לשדר וידאו מ-Raspberry, והביצועים של גלאי הרשת העצבית עליו משאירים הרבה מה לרצות.

Intel Neural Computer Stick

שקלתי פתרונות שונים.

В המאמר האחרון התנסה עם Intel Neural Computer Stick. החומרה חזקה, אך דורשת פורמט רשת משלה.

למרות שאינטל מספקת ממירים למסגרות עיקריות, ישנן מספר מלכודות.

לדוגמה, הפורמט של הרשת הנדרשת עשוי להיות לא תואם, ואם הוא תואם, ייתכן שחלק מהשכבות לא יהיו נתמכות במכשיר, ואם הן נתמכות, עלולות להתרחש שגיאות במהלך תהליך ההמרה, וכתוצאה מכך אנחנו מקבלים כמה דברים מוזרים בפלט.

באופן כללי, אם אתה רוצה איזושהי רשת עצבית שרירותית, ייתכן שהיא לא תעבוד עם NCS. לכן, החלטתי לנסות לפתור את הבעיה באמצעות הכלים הנפוצים והנגישים ביותר.

ענן

האלטרנטיבה הברורה לפתרון חומרה מקומי היא ללכת לענן.

אפשרויות מוכנות - העיניים שלי משתוללות.

כל המנהיגים:

... ועשרות פחות מוכרים.

הבחירה בין מגוון זה אינה קלה כלל.

והחלטתי לא לבחור, אלא לעטוף את סכימת העבודה הישנה והטובה ב-OpenCV ב-Docker ולהפעיל אותה בענן.

היתרון של גישה זו הוא גמישות ושליטה - אתה יכול לשנות את הרשת העצבית, אירוח, שרת - באופן כללי, כל גחמה.

שרת

נתחיל עם אב טיפוס מקומי.

באופן מסורתי אני משתמש ב-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)

בדוקר מקומי (במחשב נייד לא צעיר במיוחד) זה לוקח 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()

דוקר - 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 ייקח אותו ישירות משם.

כפלטפורמה, ניקח את אותה Debian Stretch כמו ב-Raspberry - לא נחרוג מחסנית הטכנולוגיה המוכחת.

אתה צריך להתקין flask, protobuf, requests, 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"]

פשוט לקוח גלאי מבוסס על בקשות.

פרסום ל- Docker Hub

רישומי Docker מתרבים במהירות לא פחות מגלאי ענן.

כדי לא לטרוח, נעבור באופן שמרני DockerHub.

הירשם
התחברות:
כניסה למעגן
בואו נמציא שם בעל משמעות:
docker tag opencv-detect tprlab/opencv-detect-ssd
העלה את התמונה לשרת:
docker push tprlab/opencv-detect-ssd

אנחנו משיקים בענן

גם הבחירה היכן להפעיל את המכולה היא רחבה למדי.

כל השחקנים הגדולים (גוגל, מיקרוסופט, אמזון) מציעים מיקרו-מופע בחינם בשנה הראשונה.
לאחר התנסות עם 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 פריימים בשנייה, אבל ההבדל כמעט בלתי נראה לעין, הוא עדיין איטי.

אין שום קשר לענן ולעלויות התחבורה; הגלאי פועל על חומרה רגילה ועובד במהירות כזו.

מקל מחשב עצבי

לא יכולתי להתאפק והרצתי את המדד ב-NCS.

מהירות הגלאי הייתה מעט יותר איטית מ-0.1 שניות, בכל מקרה מהירה פי 2-3 מהענן במכונה חלשה, כלומר 8-9 פריימים לשנייה.

ההבדל בתוצאות מוסבר על ידי העובדה ש-NCS הריצה Mobile SSD גרסת 2018_01_28.

נ.ב בנוסף, ניסויים הראו שמכונה שולחנית חזקה למדי עם מעבד 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.

מסקנה

בסך הכל, הניסוי מאפשר לנו להסיק שאם תנסה, תוכל לברוח עם ענן פשוט.

אבל שולחן עבודה חזק או חומרה מקומית מאפשר לך להשיג תוצאות טובות יותר, וללא כל טריקים.

תזכור

מקור: www.habr.com

סרטון של גלאי אובייקטים בענן ב-Raspberry Pi