ರಾಸ್ಪ್ಬೆರಿ ಪೈನಲ್ಲಿ ಕ್ಲೌಡ್ ಆಬ್ಜೆಕ್ಟ್ ಡಿಟೆಕ್ಟರ್ನೊಂದಿಗೆ 🥇ವೀಡಿಯೋ

ಮುನ್ನುಡಿ

ಟೆಸ್ಲಾದ ಆಟೋಪೈಲಟ್ ರಸ್ತೆಯನ್ನು ಹೇಗೆ ನೋಡುತ್ತಾನೆ ಎಂಬುದನ್ನು ತೋರಿಸುವ ವೀಡಿಯೊ ಈಗ ಇಂಟರ್ನೆಟ್‌ನಲ್ಲಿ ಪ್ರಸಾರವಾಗುತ್ತಿದೆ.

ಡಿಟೆಕ್ಟರ್‌ನೊಂದಿಗೆ ಪುಷ್ಟೀಕರಿಸಿದ ವೀಡಿಯೊವನ್ನು ಮತ್ತು ನೈಜ ಸಮಯದಲ್ಲಿ ಪ್ರಸಾರ ಮಾಡಲು ನಾನು ಬಹಳ ಸಮಯದಿಂದ ತುರಿಕೆ ಮಾಡುತ್ತಿದ್ದೇನೆ.

ಸಮಸ್ಯೆಯೆಂದರೆ ನಾನು ರಾಸ್ಪ್ಬೆರಿಯಿಂದ ವೀಡಿಯೊವನ್ನು ಪ್ರಸಾರ ಮಾಡಲು ಬಯಸುತ್ತೇನೆ ಮತ್ತು ಅದರ ಮೇಲೆ ನರಗಳ ನೆಟ್ವರ್ಕ್ ಡಿಟೆಕ್ಟರ್ನ ಕಾರ್ಯಕ್ಷಮತೆಯು ಅಪೇಕ್ಷಿತವಾಗಿರುವುದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

ಇಂಟೆಲ್ ನ್ಯೂರಲ್ ಕಂಪ್ಯೂಟರ್ ಸ್ಟಿಕ್

ನಾನು ವಿಭಿನ್ನ ಪರಿಹಾರಗಳನ್ನು ಪರಿಗಣಿಸಿದೆ.

В ಕೊನೆಯ ಲೇಖನ ಇಂಟೆಲ್ ನ್ಯೂರಲ್ ಕಂಪ್ಯೂಟರ್ ಸ್ಟಿಕ್ ಅನ್ನು ಪ್ರಯೋಗಿಸಿದರು. ಹಾರ್ಡ್‌ವೇರ್ ಶಕ್ತಿಯುತವಾಗಿದೆ, ಆದರೆ ತನ್ನದೇ ಆದ ನೆಟ್‌ವರ್ಕ್ ಸ್ವರೂಪದ ಅಗತ್ಯವಿದೆ.

ಇಂಟೆಲ್ ಪ್ರಮುಖ ಚೌಕಟ್ಟುಗಳಿಗೆ ಪರಿವರ್ತಕಗಳನ್ನು ಒದಗಿಸಿದರೂ ಸಹ, ಹಲವಾರು ಅಪಾಯಗಳಿವೆ.

ಉದಾಹರಣೆಗೆ, ಅಗತ್ಯವಿರುವ ನೆಟ್‌ವರ್ಕ್‌ನ ಸ್ವರೂಪವು ಹೊಂದಿಕೆಯಾಗದಿರಬಹುದು, ಮತ್ತು ಅದು ಹೊಂದಾಣಿಕೆಯಾಗಿದ್ದರೆ, ಕೆಲವು ಲೇಯರ್‌ಗಳು ಸಾಧನದಲ್ಲಿ ಬೆಂಬಲಿತವಾಗಿಲ್ಲದಿರಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಬೆಂಬಲಿಸಿದರೆ, ಪರಿವರ್ತನೆ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ದೋಷಗಳು ಸಂಭವಿಸಬಹುದು, ಇದರ ಪರಿಣಾಮವಾಗಿ ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ನಾವು ಕೆಲವು ವಿಚಿತ್ರ ವಿಷಯಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ನೀವು ಕೆಲವು ರೀತಿಯ ಅನಿಯಂತ್ರಿತ ನರಮಂಡಲವನ್ನು ಬಯಸಿದರೆ, ಅದು NCS ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡದಿರಬಹುದು. ಆದ್ದರಿಂದ, ಹೆಚ್ಚು ವ್ಯಾಪಕವಾದ ಮತ್ತು ಪ್ರವೇಶಿಸಬಹುದಾದ ಸಾಧನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸಲು ನಾನು ನಿರ್ಧರಿಸಿದೆ.

ಮೇಘ

ಸ್ಥಳೀಯ ಹಾರ್ಡ್‌ವೇರ್ ಪರಿಹಾರಕ್ಕೆ ಸ್ಪಷ್ಟ ಪರ್ಯಾಯವೆಂದರೆ ಕ್ಲೌಡ್‌ಗೆ ಹೋಗುವುದು.

ರೆಡಿಮೇಡ್ ಆಯ್ಕೆಗಳು - ನನ್ನ ಕಣ್ಣುಗಳು ಕಾಡು ಓಡುತ್ತವೆ.

ಎಲ್ಲಾ ನಾಯಕರು:

... ಮತ್ತು ಕಡಿಮೆ ತಿಳಿದಿರುವ ಡಜನ್ಗಟ್ಟಲೆ.

ಈ ವಿಧದ ನಡುವೆ ಆಯ್ಕೆ ಮಾಡುವುದು ಸುಲಭವಲ್ಲ.

ಮತ್ತು ನಾನು ಆಯ್ಕೆ ಮಾಡದಿರಲು ನಿರ್ಧರಿಸಿದೆ, ಆದರೆ ಡಾಕರ್‌ನಲ್ಲಿ ಓಪನ್‌ಸಿವಿಯಲ್ಲಿ ಉತ್ತಮ ಹಳೆಯ ಕೆಲಸದ ಯೋಜನೆಯನ್ನು ಕಟ್ಟಲು ಮತ್ತು ಅದನ್ನು ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಲು.

ಈ ವಿಧಾನದ ಪ್ರಯೋಜನವೆಂದರೆ ನಮ್ಯತೆ ಮತ್ತು ನಿಯಂತ್ರಣ - ನೀವು ನರಗಳ ನೆಟ್ವರ್ಕ್, ಹೋಸ್ಟಿಂಗ್, ಸರ್ವರ್ ಅನ್ನು ಬದಲಾಯಿಸಬಹುದು - ಸಾಮಾನ್ಯವಾಗಿ, ಯಾವುದೇ ಹುಚ್ಚಾಟಿಕೆ.

ಸರ್ವರ್

ಸ್ಥಳೀಯ ಮೂಲಮಾದರಿಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ.

ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ ನಾನು 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 ಅನ್ನು ಎಳೆಯಲು ಬಯಸದಿರುವಲ್ಲಿ ಈ ಆಯ್ಕೆಯು ಉತ್ತಮವಾಗಿದೆ.

ಡಾಕರ್

ನಾವು ಚಿತ್ರವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ.

ಕೋಡ್ ಬಾಚಣಿಗೆ ಮತ್ತು ಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ ಗಿಥಬ್, ಡಾಕರ್ ಅದನ್ನು ಅಲ್ಲಿಂದ ನೇರವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತಾರೆ.

ವೇದಿಕೆಯಾಗಿ, ನಾವು ರಾಸ್ಪ್ಬೆರಿಯಲ್ಲಿರುವ ಅದೇ ಡೆಬಿಯನ್ ಸ್ಟ್ರೆಚ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ - ನಾವು ಸಾಬೀತಾಗಿರುವ ಟೆಕ್ ಸ್ಟಾಕ್ನಿಂದ ವಿಚಲನಗೊಳ್ಳುವುದಿಲ್ಲ.

ನೀವು ಫ್ಲಾಸ್ಕ್, ಪ್ರೋಟೋಬಫ್, ವಿನಂತಿಗಳು, ಓಪನ್‌ಸಿವಿ_ಪೈಥಾನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕು, ಗಿಥಬ್‌ನಿಂದ ಮೊಬೈಲ್ ಎಸ್‌ಎಸ್‌ಡಿ, ಸರ್ವರ್ ಕೋಡ್ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು.

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"]

ಪ್ರಾಯೋಗಿಕ ಡಿಟೆಕ್ಟರ್ ಕ್ಲೈಂಟ್ ವಿನಂತಿಗಳನ್ನು ಆಧರಿಸಿ.

ಡಾಕರ್ ಹಬ್‌ಗೆ ಪ್ರಕಟಿಸಲಾಗುತ್ತಿದೆ

ಡಾಕರ್ ರಿಜಿಸ್ಟ್ರಿಗಳು ಕ್ಲೌಡ್ ಡಿಟೆಕ್ಟರ್‌ಗಳಿಗಿಂತ ಕಡಿಮೆಯಿಲ್ಲದ ವೇಗದಲ್ಲಿ ಗುಣಿಸುತ್ತಿವೆ.

ತೊಂದರೆಯಾಗದಿರಲು, ನಾವು ಸಂಪ್ರದಾಯಬದ್ಧವಾಗಿ ಹಾದು ಹೋಗುತ್ತೇವೆ ಡಾಕರ್‌ಹಬ್.

ನೋಂದಣಿ
ಲಾಗ್ ಇನ್:
ಡಾಕರ್ ಲಾಗಿನ್
ಅರ್ಥಪೂರ್ಣ ಹೆಸರಿನೊಂದಿಗೆ ಬರೋಣ:
ಡಾಕರ್ ಟ್ಯಾಗ್ opencv-ಡಿಟೆಕ್ಟ್ tprlab/opencv-detect-ssd
ಚಿತ್ರವನ್ನು ಸರ್ವರ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಿ:
ಡಾಕರ್ ಪುಶ್ tprlab/opencv-detect-ssd

ನಾವು ಮೋಡದಲ್ಲಿ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ

ಧಾರಕವನ್ನು ಎಲ್ಲಿ ಓಡಿಸಬೇಕೆಂಬುದರ ಆಯ್ಕೆಯು ಸಾಕಷ್ಟು ವಿಸ್ತಾರವಾಗಿದೆ.

ಎಲ್ಲಾ ದೊಡ್ಡ ಆಟಗಾರರು (ಗೂಗಲ್, ಮೈಕ್ರೋಸಾಫ್ಟ್, ಅಮೆಜಾನ್) ಮೊದಲ ವರ್ಷಕ್ಕೆ ಮೈಕ್ರೋ-ಉದಾಹರಣೆಯನ್ನು ಉಚಿತವಾಗಿ ನೀಡುತ್ತಾರೆ.
ಮೈಕ್ರೋಸಾಫ್ಟ್ ಅಜೂರ್ ಮತ್ತು ಗೂಗಲ್ ಕ್ಲೌಡ್‌ನೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಿದ ನಂತರ, ನಾನು ಎರಡನೆಯದರಲ್ಲಿ ನೆಲೆಸಿದ್ದೇನೆ ಏಕೆಂದರೆ ಅದು ವೇಗವಾಗಿ ಹೊರಟುಹೋಯಿತು.

ಆಯ್ದ ಪೂರೈಕೆದಾರರಿಗೆ ಈ ಭಾಗವು ತುಂಬಾ ನಿರ್ದಿಷ್ಟವಾದ ಕಾರಣ ನಾನು ಇಲ್ಲಿ ಸೂಚನೆಗಳನ್ನು ಬರೆಯಲಿಲ್ಲ.

ನಾನು ವಿಭಿನ್ನ ಹಾರ್ಡ್‌ವೇರ್ ಆಯ್ಕೆಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿದೆ,
ಕಡಿಮೆ ಮಟ್ಟಗಳು (ಹಂಚಿಕೆ ಮತ್ತು ಮೀಸಲಿಡಲಾಗಿದೆ) - 0.4 - 0.5 ಸೆಕೆಂಡುಗಳು.
ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ಕಾರುಗಳು - 0.25 - 0.3.
ಒಳ್ಳೆಯದು, ಕೆಟ್ಟ ಸನ್ನಿವೇಶದಲ್ಲಿಯೂ ಸಹ, ಗೆಲುವುಗಳು ಮೂರು ಬಾರಿ, ನೀವು ಪ್ರಯತ್ನಿಸಬಹುದು.

ವೀಡಿಯೊ

ನಾವು ರಾಸ್ಪ್ಬೆರಿಯಲ್ಲಿ ಸರಳವಾದ OpenCV ವೀಡಿಯೊ ಸ್ಟ್ರೀಮರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, Google ಕ್ಲೌಡ್ ಮೂಲಕ ಪತ್ತೆಹಚ್ಚುತ್ತೇವೆ.
ಪ್ರಯೋಗಕ್ಕಾಗಿ, ಒಮ್ಮೆ ಯಾದೃಚ್ಛಿಕ ಛೇದಕದಲ್ಲಿ ಚಿತ್ರೀಕರಿಸಲಾದ ವೀಡಿಯೊ ಫೈಲ್ ಅನ್ನು ಬಳಸಲಾಯಿತು.


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 ಚೌಕಟ್ಟುಗಳು.

ಫಲಿತಾಂಶಗಳಲ್ಲಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಮೊಬೈಲ್ SSD ಆವೃತ್ತಿ 2018_01_28 ಅನ್ನು NCS ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂಬ ಅಂಶದಿಂದ ವಿವರಿಸಲಾಗಿದೆ.

ಪಿ.ಎಸ್. ಹೆಚ್ಚುವರಿಯಾಗಿ, I7 ಪ್ರೊಸೆಸರ್ ಹೊಂದಿರುವ ಸಾಕಷ್ಟು ಶಕ್ತಿಯುತ ಡೆಸ್ಕ್‌ಟಾಪ್ ಯಂತ್ರವು ಸ್ವಲ್ಪ ಉತ್ತಮ ಫಲಿತಾಂಶಗಳನ್ನು ತೋರಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ 10 ಫ್ರೇಮ್‌ಗಳನ್ನು ಹಿಂಡುವ ಸಾಧ್ಯತೆಯಿದೆ ಎಂದು ಪ್ರಯೋಗಗಳು ತೋರಿಸಿವೆ.

РљР »Р °

ಪ್ರಯೋಗವು ಮತ್ತಷ್ಟು ಹೋಯಿತು ಮತ್ತು ನಾನು ಗೂಗಲ್ ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಐದು ನೋಡ್‌ಗಳಲ್ಲಿ ಡಿಟೆಕ್ಟರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದೆ.
ಬೀಜಕೋಶಗಳು ಸ್ವತಃ ದುರ್ಬಲವಾಗಿದ್ದವು ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ 2 ಚೌಕಟ್ಟುಗಳಿಗಿಂತ ಹೆಚ್ಚು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.
ಆದರೆ ನೀವು ಎನ್ ನೋಡ್‌ಗಳೊಂದಿಗೆ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರನ್ ಮಾಡಿದರೆ ಮತ್ತು ಎನ್ ಥ್ರೆಡ್‌ಗಳಲ್ಲಿ ಫ್ರೇಮ್‌ಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡಿದರೆ, ಸಾಕಷ್ಟು ಸಂಖ್ಯೆಯ ನೋಡ್‌ಗಳೊಂದಿಗೆ (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

ರಾಸ್ಪ್ಬೆರಿ ಪೈನಲ್ಲಿ ಕ್ಲೌಡ್ ಆಬ್ಜೆಕ್ಟ್ ಡಿಟೆಕ್ಟರ್ನ ವೀಡಿಯೊ