Cloud Object Detector-ის ვიდეო Raspberry Pi-ზე

პროლოგი

ინტერნეტში ახლა ვრცელდება ვიდეო, სადაც ნაჩვენებია, თუ როგორ ხედავს ტესლას ავტოპილოტი გზას.

დიდი ხანია მაწუხებს დეტექტორით გამდიდრებული ვიდეოს გადაცემა და რეალურ დროში.

პრობლემა ის არის, რომ მე მინდა ვიდეოს გადაცემა Raspberry-დან და მასზე ნერვული ქსელის დეტექტორის შესრულება სასურველს ტოვებს.

Intel Neural Computer Stick

განვიხილე სხვადასხვა გადაწყვეტილებები.

В ბოლო სტატია ჩაატარა ექსპერიმენტი Intel Neural Computer Stick-ით. აპარატურა მძლავრია, მაგრამ მოითხოვს საკუთარ ქსელურ ფორმატს.

მიუხედავად იმისა, რომ Intel უზრუნველყოფს კონვერტორებს ძირითადი ჩარჩოებისთვის, არსებობს მთელი რიგი ხარვეზები.

მაგალითად, საჭირო ქსელის ფორმატი შეიძლება შეუთავსებელი იყოს და თუ ის თავსებადია, მაშინ ზოგიერთი ფენა შეიძლება არ იყოს მხარდაჭერილი მოწყობილობაზე, ხოლო თუ ისინი მხარდაჭერილია, მაშინ შეიძლება მოხდეს შეცდომები კონვერტაციის პროცესში, რის შედეგადაც ჩვენ ვიღებთ უცნაურ ნივთებს გამოსავალზე.

ზოგადად, თუ გსურთ რაიმე სახის თვითნებური ნერვული ქსელი, მაშინ ის შეიძლება არ იმუშაოს NCS-თან. ამიტომ, გადავწყვიტე პრობლემის გადაჭრა ყველაზე გავრცელებული და ხელმისაწვდომი ინსტრუმენტების გამოყენებით.

ღრუბელი

ლოკალური ტექნიკის გადაწყვეტის აშკარა ალტერნატივა ღრუბელზე გადასვლაა.

მზა ვარიანტები - თვალები მიშტერება.

ყველა ლიდერი:

• მაიკროსოფტი
• Google
• ამაზონი

... და ათობით ნაკლებად ცნობილი.

ამ ჯიშს შორის არჩევა სულაც არ არის ადვილი.

და მე გადავწყვიტე, რომ არ ავირჩიო, არამედ შემეკრა ძველი კარგი სამუშაო სქემა OpenCV-ზე Docker-ში და გაშვება ღრუბელში.

ამ მიდგომის უპირატესობა არის მოქნილობა და კონტროლი - შეგიძლიათ შეცვალოთ ნერვული ქსელი, ჰოსტინგი, სერვერი - ზოგადად, ნებისმიერი ახირება.

სერვერი

დავიწყოთ ადგილობრივი პროტოტიპით.

მე ტრადიციულად ვიყენებ Flask-ს REST API, OpenCV და MobileSSD ქსელისთვის.

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 წამი, 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 სერვერზე გადატანა.

დოკერი

ჩვენ ვაგროვებთ სურათს.

კოდი კომბინირებულია და გამოქვეყნებულია გითჰუბი, დოკერი პირდაპირ იქიდან წაიღებს.

როგორც პლატფორმა, ჩვენ ავიღებთ იგივე Debian Stretch-ს, როგორც Raspberry-ზე - ჩვენ არ გადაუხვევთ დადასტურებულ ტექნიკურ დასტას.

თქვენ უნდა დააინსტალიროთ ფლაკონი, პროტობუფი, მოთხოვნები, 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"]

მარტივი დეტექტორის კლიენტი მოთხოვნების საფუძველზე.

გამოქვეყნება Docker Hub-ში

დოკერის რეესტრები მრავლდება ღრუბლის დეტექტორებზე არანაკლებ სიჩქარით.

იმისათვის, რომ არ შევაწუხოთ, ჩვენ კონსერვატიულად გავივლით DockerHub.

1. რეგისტრაცია
2. Შესვლა:
   დოკერის შესვლა
3. მოდით მოვიფიქროთ მნიშვნელოვანი სახელი:
   docker tag opencv-detect tprlab/opencv-detect-ssd
4. ატვირთეთ სურათი სერვერზე:
   docker push tprlab/opencv-detect-ssd

ჩვენ ვიწყებთ ღრუბელში

კონტეინერის გაშვების არჩევანი ასევე საკმაოდ ფართოა.

ყველა მსხვილი მოთამაშე (Google, Microsoft, Amazon) გთავაზობთ მიკრო ინსტანციას უფასოდ პირველი წლის განმავლობაში.
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 მუშაობდა მობილური SSD ვერსია 2018_01_28.

P.S. გარდა ამისა, ექსპერიმენტებმა აჩვენა, რომ საკმაოდ მძლავრი დესკტოპის აპარატი 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