నాంది
టెస్లా ఆటోపైలట్ రోడ్డును ఎలా చూస్తుందో చూపించే వీడియో ఇప్పుడు ఇంటర్నెట్‌లో చక్కర్లు కొడుతోంది.
డిటెక్టర్తో సమృద్ధిగా ఉన్న వీడియోను మరియు నిజ సమయంలో ప్రసారం చేయడానికి నేను చాలా కాలంగా దురద చేస్తున్నాను.
సమస్య ఏమిటంటే నేను రాస్ప్బెర్రీ నుండి వీడియోను ప్రసారం చేయాలనుకుంటున్నాను మరియు దానిపై న్యూరల్ నెట్‌వర్క్ డిటెక్టర్ యొక్క పనితీరు చాలా కావలసినది.
ఇంటెల్ న్యూరల్ కంప్యూటర్ స్టిక్
నేను విభిన్న పరిష్కారాలను పరిగణించాను.
В ఇంటెల్ న్యూరల్ కంప్యూటర్ స్టిక్‌తో ప్రయోగాలు చేశారు. హార్డ్‌వేర్ శక్తివంతమైనది, కానీ దాని స్వంత నెట్‌వర్క్ ఫార్మాట్ అవసరం.
ఇంటెల్ ప్రధాన ఫ్రేమ్‌వర్క్‌ల కోసం కన్వర్టర్‌లను అందించినప్పటికీ, అనేక ఆపదలు ఉన్నాయి.
ఉదాహరణకు, అవసరమైన నెట్‌వర్క్ ఫార్మాట్ అననుకూలంగా ఉండవచ్చు మరియు అది అనుకూలంగా ఉంటే, పరికరంలో కొన్ని లేయర్‌లకు మద్దతు ఉండకపోవచ్చు మరియు వాటికి మద్దతు ఉంటే, మార్పిడి ప్రక్రియలో లోపాలు సంభవించవచ్చు, దీని ఫలితంగా అవుట్‌పుట్‌లో మనకు కొన్ని వింత విషయాలు లభిస్తాయి.
సాధారణంగా, మీరు కొన్ని రకాల ఏకపక్ష న్యూరల్ నెట్‌వర్క్‌ని కోరుకుంటే, అది NCSతో పని చేయకపోవచ్చు. అందువల్ల, నేను అత్యంత విస్తృతమైన మరియు అందుబాటులో ఉన్న సాధనాలను ఉపయోగించి సమస్యను పరిష్కరించడానికి ప్రయత్నించాలని నిర్ణయించుకున్నాను.
క్లౌడ్
స్థానిక హార్డ్‌వేర్ పరిష్కారానికి స్పష్టమైన ప్రత్యామ్నాయం క్లౌడ్‌కి వెళ్లడం.
రెడీమేడ్ ఎంపికలు - నా కళ్ళు క్రూరంగా నడుస్తాయి.
నాయకులందరూ:
... మరియు డజన్ల కొద్దీ తక్కువగా తెలిసినవి.
ఈ రకాన్ని ఎంచుకోవడం అంత సులభం కాదు.
మరియు నేను ఎంచుకోకూడదని నిర్ణయించుకున్నాను, కానీ డాకర్‌లో ఓపెన్‌సివిలో మంచి పాత పని పథకాన్ని చుట్టి, దానిని క్లౌడ్‌లో అమలు చేయాలని నిర్ణయించుకున్నాను.
ఈ విధానం యొక్క ప్రయోజనం వశ్యత మరియు నియంత్రణ - మీరు న్యూరల్ నెట్‌వర్క్, హోస్టింగ్, సర్వర్‌ను మార్చవచ్చు - సాధారణంగా, ఏదైనా ఇష్టానుసారం.
సర్వర్
స్థానిక నమూనాతో ప్రారంభిద్దాం.
సాంప్రదాయకంగా నేను REST API, OpenCV మరియు MobileSSD నెట్‌వర్క్ కోసం Flaskని ఉపయోగిస్తాను.
డాకర్‌లో ప్రస్తుత సంస్కరణలను ఇన్‌స్టాల్ చేసిన తర్వాత, 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_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"]
సాధారణ అభ్యర్థనల ఆధారంగా.
డాకర్ హబ్‌కి ప్రచురిస్తోంది
డాకర్ రిజిస్ట్రీలు క్లౌడ్ డిటెక్టర్‌ల కంటే తక్కువ వేగంతో గుణించబడుతున్నాయి.
ఇబ్బంది పడకుండా ఉండటానికి, మేము సంప్రదాయబద్ధంగా వెళ్తాము .
- నమోదు చేసుకోండి
- ప్రవేశించండి:
డాకర్ లాగిన్ - అర్ధవంతమైన పేరుతో రండి:
డాకర్ ట్యాగ్ opencv-detect tprlab/opencv-detect-ssd - చిత్రాన్ని సర్వర్‌కు అప్‌లోడ్ చేయండి:
డాకర్ పుష్ tprlab/opencv-detect-ssd
మేము క్లౌడ్‌లో ప్రారంభించాము
కంటైనర్‌ను ఎక్కడ నడపాలనే ఎంపిక కూడా చాలా విస్తృతమైనది.
అన్ని పెద్ద ప్లేయర్‌లు (గూగుల్, మైక్రోసాఫ్ట్, అమెజాన్) మొదటి సంవత్సరం ఉచితంగా మైక్రో-ఇన్‌స్టాన్స్‌ను అందిస్తాయి.
మైక్రోసాఫ్ట్ అజూర్ మరియు గూగుల్ క్లౌడ్‌తో ప్రయోగాలు చేసిన తర్వాత, నేను రెండోదానిపై స్థిరపడ్డాను ఎందుకంటే ఇది వేగంగా బయలుదేరింది.
ఎంచుకున్న ప్రొవైడర్‌కు ఈ భాగం చాలా నిర్దిష్టంగా ఉన్నందున నేను ఇక్కడ సూచనలను వ్రాయలేదు.
నేను విభిన్న హార్డ్‌వేర్ ఎంపికలను ప్రయత్నించాను,
తక్కువ స్థాయిలు (భాగస్వామ్యం మరియు అంకితం) - 0.4 - 0.5 సెకన్లు.
మరింత శక్తివంతమైన కార్లు - 0.25 - 0.3.
బాగా, చెత్త దృష్టాంతంలో కూడా, విజయాలు మూడు సార్లు ఉంటాయి, మీరు ప్రయత్నించవచ్చు.
వీడియో
మేము Google క్లౌడ్ ద్వారా గుర్తించే ఒక సాధారణ OpenCV వీడియో స్ట్రీమర్‌ని Raspberryలో ప్రారంభించాము.
ప్రయోగం కోసం, ఒకప్పుడు యాదృచ్ఛిక ఖండన వద్ద చిత్రీకరించబడిన వీడియో ఫైల్ ఉపయోగించబడింది.
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 ఫ్రేమ్‌లను గుర్తించవచ్చు, కానీ వ్యత్యాసం కంటికి దాదాపు కనిపించదు, ఇది ఇప్పటికీ నెమ్మదిగా ఉంటుంది.
క్లౌడ్ మరియు రవాణా ఖర్చులకు దానితో సంబంధం లేదు; డిటెక్టర్ సాధారణ హార్డ్‌వేర్‌పై నడుస్తుంది మరియు అంత వేగంతో పనిచేస్తుంది.
న్యూరల్ కంప్యూటర్ స్టిక్
నేను ఎన్‌సిఎస్‌లో బెంచ్‌మార్క్‌ను ఎదిరించలేకపోయాను.
డిటెక్టర్ యొక్క వేగం 0.1 సెకన్ల కంటే కొంచెం నెమ్మదిగా ఉంది, ఏ సందర్భంలోనైనా బలహీనమైన మెషీన్‌లో క్లౌడ్ కంటే 2-3 రెట్లు వేగంగా ఉంటుంది, అంటే సెకనుకు 8-9 ఫ్రేమ్‌లు.
NCS మొబైల్ 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 కంటే కొంచెం తక్కువ వేగవంతమైనది, కానీ ఒక స్ట్రీమ్‌లో కంటే మరింత శక్తివంతమైనది.
లాభం, వాస్తవానికి, సరళమైనది కాదు - ఓపెన్‌సివి చిత్రాల సమకాలీకరణ మరియు లోతైన కాపీ కోసం అతివ్యాప్తులు ఉన్నాయి.
తీర్మానం
మొత్తంమీద, మీరు ప్రయత్నిస్తే, మీరు ఒక సాధారణ క్లౌడ్‌తో తప్పించుకోవచ్చని నిర్ధారించడానికి ప్రయోగం మాకు అనుమతిస్తుంది.
కానీ శక్తివంతమైన డెస్క్‌టాప్ లేదా లోకల్ హార్డ్‌వేర్ మెరుగైన ఫలితాలను సాధించడానికి మరియు ఎలాంటి ఉపాయాలు లేకుండా మిమ్మల్ని అనుమతిస్తుంది.
సూచనలు
మూలం: www.habr.com