Incipit prologus
Video nunc in interrete circumfertur, quo modo Teslae gubernator automaticus viam videt, demonstrans.
Iam diu cupio imagines moventes detectore locupletatas, et in tempore reali, transmittere.
Problema est quod video ex Raspberry Pi transmittere volo, et effectus detectoris retium neuralium in eo multum desiderandum relinquit.
Intel Neural Computer Stick
Varias solutiones consideravi.
В Experimentum feci cum Intel Neural Computer Stick. Apparatus potens est, sed proprium formatum retiale requirit.
Quamquam Intel conversores pro maioribus structuris computatralibus praebet, nonnullae sunt insidiae.
Exempli gratia, forma reti requisita fortasse incompatibilis est, et si compatibilis est, nonnullae laminae in instrumento fortasse non sustinebuntur, et si sustinentur, errores in conversione oriri possunt, quod ad res insolitas in exitu ducit.
Breviter, si reticulum neurale proprium quaeris, NCS fortasse non est optio. Itaque, statui problema solvere conari instrumentis latissime praesto utens.
nubes
Alternativa manifesta solutioni apparatuum in situ est ad nubem ire.
Tot sunt optiones praeparatae ut oculi tui attoniti fluant.
Omnes duces:
...Et plurima minus nota.
Ex hac varietate eligere omnino non facile est.
Itaque statui non eligere, sed bonum vetus schema operandi in OpenCV in Docker involvere et in nube currere.
Huius consilii commodum est flexibilitas et potestas—rete neurale, hospitium, servitorem—fere, quodvis libidinem mutare potes.
servo
Incipiamus cum prototypo locali.
Traditio mea est ut Flask pro REST API, OpenCV et retibus MobileSSD utar.
Versionibus hodiernis in Docker institutis, comperi OpenCV 4.1.2 cum Mobile SSD v1_coco_2018_01_28 non operari, et ad comprobatam versionem 11_06_2017 redire debui.
In initio servitii, nomina classium et rete oneramus:
def init():
tf_labels.initLabels(dnn_conf.DNN_LABELS_PATH)
return cv.dnn.readNetFromTensorflow(dnn_conf.DNN_PATH, dnn_conf.DNN_TXT_PATH)
In docker locali (in computatro portatili vetustiore) hoc 0.3 secunda, in Raspberry - 3.5 sumit.
Incipiamus calculum:
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()
Docker - 0.2 sec, Rubus idaeus - 1.7.
Convertendo exitum tensoris in JSON legibilem:
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
Ulterior (input est imago, output est detector quae resultat in json).
Alia optio, quae plus laboris ad servitorem transfert, est ut ille automatice res inventas delineet et imaginem perfectam reddat.
Haec optio bona est cum OpenCV ad servitorem trahere nolumus.
Docker
Imaginem colligimus.
Codex pectitus et publicatus est in , docker id directe inde capiet.
Eandem suggestum sumamus ac Debian Extende, sicut in Rubo Idaeo, a probata technologiae structura non aberrabimus.
Necesse est tibi `flask`, `protobuf`, `requests`, `opencv_python` instituere, `Mobile SSD`, codicem servi ex GitHub depromere et servitorem currere.
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"]
simplex secundum petitiones.
Publicatio ad Docker Hub
Registra Docker non minore celeritate quam detectores nubium proliferant.
Ne omnis confusio fiat, caute progrediemur per .
- Register
- Intramus:
Docker initium sessionis - Nomen significans inveniamus:
`docker tag` `opencv-detect` `tprlab/opencv-detect-ssd` - Imaginem ad servitorem impone:
Docker impulsum tprlab/opencv-detect-ssd
In nube incipiens
Electio ubi receptaculum immittere etiam satis lata est.
Omnes magni actores (Google, Microsoft, Amazon) instantiam micro gratis primo anno offerunt.
Post experimenta cum Microsoft Azure et Google Cloud, in posterum elegi quod celerius crescebat.
Instructiones hic non scripsi, cum haec pars ad provisorem electum valde specifica sit.
Varia genera ferramentae expertus sum,
Gradus humiles (communicati et dedicati) - 0.4 - 0.5 secunda.
Machinae potentiores - 0.25 - 0.3.
Bene, etiam in pessimo casu, victoria ter est, experiri potes.
Video
Simplicem programmatis OpenCV pro imaginum transmissionem in Raspberry Pi immittimus, per Google Cloud detegens.
Fasciculus video, qui olim in intersectione fortuita captus est, ad experimentum adhibitus est.
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")
Cum detectore non plus quam tria imaginum per secundum accipis, omnia lente progrediuntur.
Si machina potenti in GCloud uteris, quattuor vel quinque imagines per secundum deprehendere potes, sed differentia oculo nudo paene imperceptibilis est, tamen lenta est.
Nubes et sumptus translationis nihil ad rem pertinent; detector hac celeritate in apparatu communi operatur.
Baculus Computatralis Neuronalis
Resistere non potui et experimentum in NCS cucurri.
Celeritas detectoris paulo tardior erat quam 0.1 secunda, quoquo modo bis vel ter velocior quam nubes in machina debili, id est octo vel novem imagines per secundum.
Discrepantia in eventibus explicatur eo quod versio Mobile SSD 2018_01_28 in NCS emissa est.
PS Praeterea, experimenta demonstraverunt machinam satis potentem computatralem cum processore I7 paulo meliora eventus ostendere et decem imagines per secundum in ea exprimendas esse possibile.
botrum portassent
Experimentum ulterius processit et detectorem in quinque nodis in Google Kubernetes institui.
Ipsae capsulae erant infirmae et singulae plus quam duas imagines per secundum tractare non poterant.
Sed si gregem in N nodis curris et imagines in N rivos retractes, tum cum sufficienti numero nodorum (5) desideratas decem imagines per secundum consequi potes.
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
Quid hic:
Non tam celeris quam cum NCS, sed energicior quam cum uno flumine.
Lucrum, scilicet, non est lineare – sunt quaedam superpositiones de synchronizatione et copiatione profunda imaginum OpenCV.
conclusio,
Summa summarum, experimentum suggerit, si satis coneris, te nubem simplicem impune evadere posse.
Sed computatrum validum vel apparatus localis te meliora consequi sinit, sine ullis artificiis.
References
Source: www.habr.com
