Raspberry Pi 'ਤੇ ਕਲਾਉਡ ਆਬਜੈਕਟ ਡਿਟੈਕਟਰ ਦਾ ਵੀਡੀਓ

ਪ੍ਰੋਲੋਗ

ਇੱਕ ਵੀਡੀਓ ਹੁਣ ਇੰਟਰਨੈੱਟ 'ਤੇ ਘੁੰਮ ਰਿਹਾ ਹੈ ਜਿਸ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ ਕਿ ਟੇਸਲਾ ਦਾ ਆਟੋਪਾਇਲਟ ਸੜਕ ਨੂੰ ਕਿਵੇਂ ਦੇਖਦਾ ਹੈ।

ਮੈਨੂੰ ਇੱਕ ਡਿਟੈਕਟਰ ਨਾਲ ਭਰਪੂਰ ਵੀਡੀਓ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਲਈ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਖੁਜਲੀ ਹੋ ਰਹੀ ਹੈ, ਅਤੇ ਅਸਲ ਸਮੇਂ ਵਿੱਚ।

ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਮੈਂ ਰਾਸਬੇਰੀ ਤੋਂ ਵੀਡੀਓ ਪ੍ਰਸਾਰਿਤ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ, ਅਤੇ ਇਸ 'ਤੇ ਨਿਊਰਲ ਨੈਟਵਰਕ ਡਿਟੈਕਟਰ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਲੋੜੀਂਦੇ ਹੋਣ ਲਈ ਬਹੁਤ ਕੁਝ ਛੱਡਦੀ ਹੈ।

ਇੰਟੇਲ ਨਿਊਰਲ ਕੰਪਿਊਟਰ ਸਟਿਕ

ਮੈਂ ਵੱਖ-ਵੱਖ ਹੱਲਾਂ 'ਤੇ ਵਿਚਾਰ ਕੀਤਾ।

В ਆਖਰੀ ਲੇਖ Intel Neural Computer Stick ਨਾਲ ਪ੍ਰਯੋਗ ਕੀਤਾ। ਹਾਰਡਵੇਅਰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ, ਪਰ ਇਸਦੇ ਆਪਣੇ ਨੈੱਟਵਰਕ ਫਾਰਮੈਟ ਦੀ ਲੋੜ ਹੈ।

ਹਾਲਾਂਕਿ ਇੰਟੇਲ ਵੱਡੇ ਫਰੇਮਵਰਕ ਲਈ ਕਨਵਰਟਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਇੱਥੇ ਬਹੁਤ ਸਾਰੀਆਂ ਕਮੀਆਂ ਹਨ।

ਉਦਾਹਰਨ ਲਈ, ਲੋੜੀਂਦੇ ਨੈੱਟਵਰਕ ਦਾ ਫਾਰਮੈਟ ਅਸੰਗਤ ਹੋ ਸਕਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਇਹ ਅਨੁਕੂਲ ਹੈ, ਤਾਂ ਕੁਝ ਲੇਅਰਾਂ ਡਿਵਾਈਸ 'ਤੇ ਸਮਰਥਿਤ ਨਹੀਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਅਤੇ ਜੇਕਰ ਉਹ ਸਮਰਥਿਤ ਹਨ, ਤਾਂ ਪਰਿਵਰਤਨ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਗਲਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਸਾਨੂੰ ਆਉਟਪੁੱਟ 'ਤੇ ਕੁਝ ਅਜੀਬ ਚੀਜ਼ਾਂ ਮਿਲਦੀਆਂ ਹਨ।

ਆਮ ਤੌਰ 'ਤੇ, ਜੇਕਰ ਤੁਸੀਂ ਕਿਸੇ ਕਿਸਮ ਦਾ ਆਰਬਿਟਰਰੀ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਹ 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 ਨੂੰ ਖਿੱਚਣਾ ਨਹੀਂ ਚਾਹੁੰਦੇ ਹਾਂ।

ਡੌਕਰ

ਅਸੀਂ ਚਿੱਤਰ ਨੂੰ ਇਕੱਠਾ ਕਰਦੇ ਹਾਂ.

ਕੋਡ ਨੂੰ ਕੰਬਡ ਅਤੇ ਪੋਸਟ ਕੀਤਾ ਗਿਆ ਹੈ Github, docker ਇਸ ਨੂੰ ਉੱਥੋਂ ਸਿੱਧਾ ਲੈ ਜਾਵੇਗਾ।

ਇੱਕ ਪਲੇਟਫਾਰਮ ਦੇ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਰਾਸਬੇਰੀ ਵਾਂਗ ਹੀ ਡੇਬੀਅਨ ਸਟ੍ਰੈਚ ਲਵਾਂਗੇ - ਅਸੀਂ ਪ੍ਰਮਾਣਿਤ ਤਕਨੀਕੀ ਸਟੈਕ ਤੋਂ ਭਟਕਣ ਨਹੀਂ ਜਾਵਾਂਗੇ।

ਤੁਹਾਨੂੰ flask, protobuf, ਬੇਨਤੀਆਂ, 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"]

ਸਧਾਰਨ ਡਿਟੈਕਟਰ ਕਲਾਇੰਟ ਬੇਨਤੀਆਂ ਦੇ ਆਧਾਰ 'ਤੇ।

ਡੌਕਰ ਹੱਬ 'ਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਡੌਕਰ ਰਜਿਸਟਰੀਆਂ ਕਲਾਉਡ ਡਿਟੈਕਟਰਾਂ ਤੋਂ ਘੱਟ ਨਹੀਂ ਗਤੀ ਨਾਲ ਗੁਣਾ ਕਰ ਰਹੀਆਂ ਹਨ.

ਪਰੇਸ਼ਾਨ ਨਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਰੂੜ੍ਹੀਵਾਦੀ ਤੌਰ 'ਤੇ ਲੰਘਾਂਗੇ DockerHub.

1. ਰਜਿਸਟਰ
2. ਲਾਗਿਨ:
   ਡੌਕਰ ਲੌਗਇਨ
3. ਆਓ ਇੱਕ ਅਰਥਪੂਰਨ ਨਾਮ ਦੇ ਨਾਲ ਆਓ:
   ਡੌਕਰ ਟੈਗ opencv-detect tprlab/opencv-detect-ssd
4. ਸਰਵਰ ਤੇ ਚਿੱਤਰ ਅੱਪਲੋਡ ਕਰੋ:
   ਡੌਕਰ ਪੁਸ਼ tprlab/opencv-detect-ssd

ਅਸੀਂ ਕਲਾਉਡ ਵਿੱਚ ਲਾਂਚ ਕਰਦੇ ਹਾਂ

ਕੰਟੇਨਰ ਕਿੱਥੇ ਚਲਾਉਣਾ ਹੈ ਦੀ ਚੋਣ ਵੀ ਕਾਫ਼ੀ ਚੌੜੀ ਹੈ।

ਸਾਰੇ ਵੱਡੇ ਖਿਡਾਰੀ (ਗੂਗਲ, ​​ਮਾਈਕਰੋਸਾਫਟ, ਐਮਾਜ਼ਾਨ) ਪਹਿਲੇ ਸਾਲ ਲਈ ਇੱਕ ਮਾਈਕਰੋ-ਇੰਸਟੈਂਸ ਮੁਫ਼ਤ ਵਿੱਚ ਪੇਸ਼ ਕਰਦੇ ਹਨ।
ਮਾਈਕ੍ਰੋਸਾਫਟ ਅਜ਼ੁਰ ਅਤੇ ਗੂਗਲ ਕਲਾਉਡ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਬਾਅਦ ਵਿੱਚ ਸੈਟਲ ਹੋ ਗਿਆ ਕਿਉਂਕਿ ਇਹ ਤੇਜ਼ੀ ਨਾਲ ਬੰਦ ਹੋ ਗਿਆ ਸੀ।

ਮੈਂ ਇੱਥੇ ਹਦਾਇਤਾਂ ਨਹੀਂ ਲਿਖੀਆਂ, ਕਿਉਂਕਿ ਇਹ ਹਿੱਸਾ ਚੁਣੇ ਹੋਏ ਪ੍ਰਦਾਤਾ ਲਈ ਬਹੁਤ ਖਾਸ ਹੈ।

ਮੈਂ ਵੱਖ-ਵੱਖ ਹਾਰਡਵੇਅਰ ਵਿਕਲਪਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ,
ਘੱਟ ਪੱਧਰ (ਸਾਂਝਾ ਅਤੇ ਸਮਰਪਿਤ) - 0.4 - 0.5 ਸਕਿੰਟ।
ਵਧੇਰੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਕਾਰਾਂ - 0.25 - 0.3.
ਖੈਰ, ਸਭ ਤੋਂ ਮਾੜੇ ਹਾਲਾਤ ਵਿੱਚ ਵੀ, ਜਿੱਤਾਂ ਤਿੰਨ ਵਾਰ ਹਨ, ਤੁਸੀਂ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ।

ਵੀਡੀਓ

ਅਸੀਂ Raspberry 'ਤੇ ਇੱਕ ਸਧਾਰਨ 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 ਫਰੇਮ ਪ੍ਰਤੀ ਸਕਿੰਟ।

ਨਤੀਜਿਆਂ ਵਿੱਚ ਅੰਤਰ ਇਸ ਤੱਥ ਦੁਆਰਾ ਸਮਝਾਇਆ ਗਿਆ ਹੈ ਕਿ ਮੋਬਾਈਲ SSD ਸੰਸਕਰਣ 2018_01_28 NCS 'ਤੇ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਸੀ।

ਪੀ.ਐੱਸ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪ੍ਰਯੋਗਾਂ ਨੇ ਦਿਖਾਇਆ ਹੈ ਕਿ ਇੱਕ I7 ਪ੍ਰੋਸੈਸਰ ਵਾਲੀ ਇੱਕ ਕਾਫ਼ੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਡੈਸਕਟੌਪ ਮਸ਼ੀਨ ਥੋੜੇ ਵਧੀਆ ਨਤੀਜੇ ਦਿਖਾਉਂਦੀ ਹੈ ਅਤੇ ਇਹ ਪ੍ਰਤੀ ਸਕਿੰਟ 10 ਫਰੇਮਾਂ ਨੂੰ ਨਿਚੋੜਨਾ ਸੰਭਵ ਸਾਬਤ ਹੋਇਆ ਹੈ।

ਕਲੱਸਟਰ

ਪ੍ਰਯੋਗ ਹੋਰ ਅੱਗੇ ਗਿਆ ਅਤੇ ਮੈਂ ਗੂਗਲ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਪੰਜ ਨੋਡਾਂ 'ਤੇ ਡਿਟੈਕਟਰ ਸਥਾਪਤ ਕੀਤਾ।
ਪੌਡ ਆਪਣੇ ਆਪ ਵਿੱਚ ਕਮਜ਼ੋਰ ਸਨ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ 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