इंटेल न्यूरल कंप्यूटर स्टिक 2 के साथ रास्पबेरी पाई रोबोट टैंक

इसलिए रास्पबेरी-टैंक के विकास में एक नया चरण आया है।

पिछली श्रृंखला में, यह पता चला कि बॉक्स के बाहर सिमेंटिक विभाजन रास्पबेरी के लिए बहुत कठिन था।

बुद्धिशीलता और टिप्पणी ने हमें विकास के निम्नलिखित क्षेत्रों की पहचान करने की अनुमति दी:

• वांछित छवि आकार के लिए अपना खुद का ई-नेट नेटवर्क प्रशिक्षित करें
• रास्पबेरी से तंत्रिका नेटवर्क के लॉन्च को स्वयं हार्डवेयर के एक विशेष टुकड़े में स्थानांतरित करना, जिसमें से इंटेल Movidius (उर्फ न्यूरल कम्प्यूट स्टिक उर्फ ​​NCS) का सबसे अधिक बार उल्लेख किया गया था।

रोबोट को लोहे का एक नया टुकड़ा संलग्न करने के लिए रोबोटिक्स में सबसे दिलचस्प बात है, इसलिए तंत्रिका नेटवर्क को प्रशिक्षित करने के श्रमसाध्य काम को बेहतर समय तक स्थगित कर दिया गया है।

कुछ दिनों - और मेरे हाथों में लोहे का चमत्कारी टुकड़ा।

यह काफी बड़ा है, और आप इसे रास्पबेरी के निचले USB कनेक्टर में चिपका नहीं सकते। यह देखते हुए कि दाएं USB पोर्ट्स को कैमरा ट्राइपॉड द्वारा अस्पष्ट किया गया था, और ऊपरी बाईं ओर जीपीएस मॉड्यूल द्वारा कब्जा कर लिया गया था, इतने सारे विकल्प नहीं थे।

नतीजतन, जीपीएस को एक केबल पर रखा गया था, ठुकरा दिया गया था, और केबल को एक तिपाई के चारों ओर लपेटा गया था, और एनसीएस अपने स्थान पर चला गया।

इस पर हार्डवेयर भाग पूरा हो गया।

इंटेल एनसीएस

इंटेल ने हाल ही में एनसीएस के दूसरे संस्करण को जारी किया, और एपीआई पिछले संस्करण के साथ पूरी तरह से असंगत था, जिसे उपयोगकर्ताओं ने इंटरनेट पर बहुत दर्द डाला।

परिणामस्वरूप, पिछले संस्करण के बारे में संपूर्ण ज्ञान का आधार वर्तमान में केवल सूचनात्मक कचरा है।

नया संस्करण OpenVino फ्रेमवर्क प्रदान करता है, जिसमें OpenCV और बहुत कुछ शामिल है, जिसमें तंत्रिका नेटवर्क के साथ काम करने के लिए विभिन्न उपकरण शामिल हैं।

यहाँ NCS2 और OpenVino पर कुछ परिचयात्मक लेख दिए गए हैं:

• इंटेल से ही
• डेटा विज्ञान की ओर मैं
• डेटा साइंस II की ओर
• PyImageSearch

NCS के साथ शुरुआत करना काफी सुचारू रहा।

इंटेल ने शुरू में रास्पियन के लिए समर्थन किया था, इसलिए एक नखरे के साथ नृत्य करने की कोई आवश्यकता नहीं थी।
परिचयात्मक दस्तावेज भी बहुत स्पष्ट था और OpenVino ढांचे की स्थापना से कोई समस्या नहीं हुई।

यह एक अच्छा बोनस निकला कि OpenVino में OpenCV 4.1 शामिल है, जो समय बचाता है, क्योंकि मुझे रास्पबेरी पर OpenCV के पिछले संस्करणों का निर्माण करना था।

यहाँ NCS2 अपने आप कैसा दिखता है:



इसके अलावा यह अधिक दिलचस्प निकला।

एनसीएस केवल अपने स्वयं के तंत्रिका नेटवर्क प्रारूप का समर्थन करता है, जबकि इंटेल सबसे लोकप्रिय फ्रेमवर्क के ग्राफ को बदलने के लिए ओपनवीनो के हिस्से के रूप में मॉडल ऑप्टिमाइज़र टूल प्रदान करता है: टेंसोरफ्लो, कैफ, टॉर्च। इसके बारे में और आगे होगा।

इसके अलावा, इंटेल कई अवसरों के लिए तैयार किए गए मॉडल का एक सेट - मॉडल चिड़ियाघर भी प्रदान करता है।

उनमें सड़क विभाजन के दो मॉडल थे:

• एक सरल
• एक और छल किया

एनसीएस में तंत्रिका नेटवर्क

एक डिवाइस पर एक तंत्रिका नेटवर्क को चलाने के लिए, आपको कई कदम उठाने की आवश्यकता है।

आरंभिक उपकरण

MYRIAD नाम, प्लग-इन का विचार और इसका गतिशील लोडिंग, जिस पथ को प्रोग्राम में निर्दिष्ट किया जाना चाहिए - स्पष्ट रूप से अंधेरे अतीत से खिंचाव।

from openvino.inference_engine import IENetwork, IEPlugin ncs_plugin = IEPlugin(device="MYRIAD", plugin_dirs="/opt/intel/openvino/inference_engine/lib/armv7l") 

मॉडल डाउनलोड करें

अगला, आपको मॉडल को डिवाइस पर अपलोड करने की आवश्यकता है।

यह एक कठिन ऑपरेशन है। वह छोटा मॉडल जिसे मैंने विभाजन के लिए इस्तेमाल किया था, उसे लोड करने में लगभग 15 सेकंड लगते हैं।

अच्छी खबर यह है कि आपको केवल एक बार मॉडल डाउनलोड करने की आवश्यकता है और आप कई मॉडल डाउनलोड कर सकते हैं।

  model = IENetwork(model=xml_path, weights=bin_path) net = ncs_plugin.load(network=model) 

गणना चलाएँ

अब मॉडल का उपयोग किया जा सकता है।

  input_blob = next(iter(model.inputs)) out_blob = next(iter(model.outputs)) n, c, h, w = model.inputs[input_blob].shape images = np.ndarray(shape=(n, c, h, w)) images[0] = image res = net.infer(inputs={input_blob: images}) res = res[out_blob] 

एकल प्रक्रिया

यह अचानक पता चला कि आप एक ही समय में दो अलग-अलग प्रक्रियाओं से एनसीएस का उपयोग नहीं कर सकते।
जो कोई भी देर से है वह मॉडल लोड नहीं कर सकता है:

 E: [ncAPI] [ 684447] resetAll:348 Failed to connect to stalled device, rc: X_LINK_ERROR E: [ncAPI] [ 691700] ncDeviceOpen:672 Failed to find suitable device, rc: X_LINK_DEVICE_NOT_FOUND Traceback (most recent call last): net = ncs_plugin.load(network=model) File "ie_api.pyx", line 395, in openvino.inference_engine.ie_api.IEPlugin.load File "ie_api.pyx", line 406, in openvino.inference_engine.ie_api.IEPlugin.load RuntimeError: Can not init USB device: NC_ERROR 

न तो Google और न ही इंटेल सपोर्ट फोरम ने यह समझना संभव किया कि क्या मामला था - या तो डिवाइस वास्तव में अनन्य है या मैं इसे खाना बनाना नहीं जानता।

OpenVino विभाजन

जैसा कि पहले ही उल्लेख किया गया है, बॉक्स से बाहर, OpenVino एक सड़क विभाजन मॉडल और उदाहरण प्रदान करता है।

परीक्षण के परिणाम कुछ विरोधाभासी हैं। यह कभी-कभी कुटिलता से पहचाना जाता है, लेकिन बहुमत में यह सामान्य है।

Enet ने बेहतर काम किया, लेकिन हमें अभी भी एनसीएस के तहत Enet की कोशिश करनी है, तो चलिए हमारे पास जो है, उसके साथ प्रयास करें।



दिलचस्प है, OpenVino से मॉडल के बारे में अधिक जानने के लिए और इसे फिर से सिखाना इतना आसान नहीं है।

उपयोगकर्ता रुचि रखते हैं , लेकिन इंटेल के व्यक्ति ने सख्ती से कहा कि मॉडल का कोड और डेटा बंद हो गया है, और जो लोग चाहते हैं वे PyTorch पर एक समान तंत्रिका नेटवर्क ले सकते हैं, ट्रेन कर सकते हैं, कन्वर्ट कर सकते हैं और इसका उपयोग कर सकते हैं।

गति लाभ बहुत महत्वपूर्ण है:
यदि Enet विभाजन में 6 सेकंड लगते हैं, तो इस मॉडल को एक छवि को संसाधित करने में 0.8 सेकंड का समय लगा (जबकि डिवाइस पर मॉडल को लोड करने में 14 सेकंड का समय लगा, लेकिन यह उसी समय किया जाता है)।

दिशाओं का वर्गीकरण

आंदोलन की दिशा के बारे में निर्णय लेने के लिए, टैंक एक सरल तंत्रिका नेटवर्क का उपयोग करता है, जैसा कि संबंधित लेख में वर्णित है।

तंत्रिका नेटवर्क केर पर प्रशिक्षित किया जाता है और टेन्सरफ्लो के माध्यम से रास्पबेरी पर चलता है, जिसमें इस प्रारूप के लिए एक अंतर्निहित एडाप्टर है।

मॉडल बहुत सरल है और रास्पबेरी पर भी स्वीकार्य गति परिणाम दिखाता है।
(प्रति चित्र 0.35 सेकंड)।

फिर भी, इंटेल ग्रंथि होने से, आप बेहतर परिणाम प्राप्त करने की उम्मीद कर सकते हैं।
इंटेल के मॉडल ऑप्टिमाइज़र रूपांतरण के लिए जिन प्रारूपों को स्वीकार करता है, उनमें टेन्सरफ़्लो है, लेकिन कोई केरेस नहीं है।

केरस को टीएफ में बदलना एक काफी लोकप्रिय चीज है, इस विषय पर पर्याप्त सामग्री है, मुझे इस लेख द्वारा निर्देशित किया गया था।

उसी लेखक के पास एक अधिक व्यापक लेख है , बस इस विषय पर कि कैसे OpenVino पर केरस मॉडल को चलाया जाए।

आप इंटेल से मार्गदर्शन का उपयोग भी कर सकते हैं।

सामान्य तौर पर, स्रोतों को संकलित करते हुए, मुझे केरस मॉडल को TF में परिवर्तित करने के लिए एक स्क्रिप्ट मिली:

 import tensorflow as tf from tensorflow.python.framework.graph_util import convert_variables_to_constants from keras import backend as K from keras.models import load_model from keras.models import model_from_json def load_keras_model(json_file, model_file): jf = open(json_file, 'r') loaded_model_json = jf.read() jf.close() loaded_model = model_from_json(loaded_model_json) loaded_model.load_weights(model_file) return loaded_model def freeze_session(session, keep_var_names=None, output_names=None, clear_devices=True): graph = session.graph with graph.as_default(): freeze_var_names = list(set(v.op.name for v in tf.global_variables()).difference(keep_var_names or [])) output_names = output_names or [] output_names += [v.op.name for v in tf.global_variables()] # Graph -> GraphDef ProtoBuf input_graph_def = graph.as_graph_def() if clear_devices: for node in input_graph_def.node: node.device = "" frozen_graph = convert_variables_to_constants(session, input_graph_def, output_names, freeze_var_names) return frozen_graph model = load_keras_model('./model.json', './model.h5') frozen_graph = freeze_session(K.get_session(), output_names=[out.op.name for out in model.outputs]) tf.train.write_graph(frozen_graph, ".", "ktf_model.pb", as_text=False) 

समान कोड गितुब पर है ।

परिणामस्वरूप TF मॉडल आगे OpenVino प्रारूप में आसुत है:

 python mo_tf.py --input_model "model/ktf_model.pb" --log_level=DEBUG -b1 --data_type FP16 

परीक्षणों से पता चला कि तस्वीर के वर्गीकरण में 0.007 सेकंड लगते हैं।
यह परिणाम बहुत सुखदायक है।

सभी प्रशिक्षित मॉडल (केरस, टीएफ, ओपनविनो) भी जीथब पर अपलोड किए गए हैं।

वस्तु मान्यता

विभाजन कार्य केवल एक ही नहीं है जिसे रोबोट को अपने कठिन जीवन में हल करना है।

शुरुआत में एक बिल्ली डिटेक्टर था, जो बाद में MobileSSD और OpenCV-DNN पर आधारित एक सार्वभौमिक डिटेक्टर में विकसित हुआ।

अब एनसीएस पर उसी कार्य को चालू करने का समय आ गया है।

इंटेल के मॉडल_ज़ू में , मोबाइलएसएसडी पर आधारित एक संकीर्ण विशिष्टता के डिटेक्टर पर्याप्त हैं, लेकिन कोई सटीक एनालॉग नहीं है।

हालाँकि, यह नेटवर्क समर्थित TF मॉडल की सूची में संगत के रूप में सूचीबद्ध है।

दिलचस्प है, लेखन के समय, MobileSSD 2018_01_28 के संस्करण को यहां इंगित किया गया है।

हालाँकि, OpenCV ने इस मॉडल को पढ़ने से इनकार कर दिया है:

 cv2.error: OpenCV(4.1.0-openvino) /home/jenkins/workspace/OpenCV/OpenVINO/build/opencv/modules/dnn/src/tensorflow/tf_importer.cpp:530: error: (-2:Unspecified error) Const input blob for weights not found in function 'getConstBlob' 

(लेकिन हमें पता चला कि वे जेनकिंस का उपयोग करते हैं)।

वहीं, OpenVino का रूपांतरण सफल है।

यदि हम OpenCV-DNN (11_06_2017) के साथ संगत मोबाइल SSD के संस्करण को बदलने का प्रयास करते हैं, तो हम यह करते हैं:

 [E0919 main.py:317] Unexpected exception happened during extracting attributes for node FeatureExtractor/MobilenetV1/Conv2d_13_pointwise_1_Conv2d_2_1x1_256/Relu6. Original exception message: operands could not be broadcast together with remapped shapes [original->remapped]: (0,) and requested shape (1,0,10,256) 

कुछ इस तरह, तकनीकी रूप से OpenVino और OpenCV-DNN एक ही पैकेज में हैं, लेकिन उपयोग किए गए तंत्रिका नेटवर्क के संस्करणों के साथ असंगत हैं।

यही है, यदि आप दोनों दृष्टिकोणों का एक साथ उपयोग करना चाहते हैं, तो आपको MobileSSD के दो संस्करणों को खींचने की आवश्यकता है।

गति के संदर्भ में, तुलना निश्चित रूप से एनसीएस के पक्ष में है: 0.1 सेकंड बनाम 1.7।

गुणवत्ता के संदर्भ में ... (हालांकि यह एनसीएस का सवाल नहीं है, लेकिन मोबाइल एसएसडी के विकास का है)।

छवि वर्गीकरण

टैंक Imagenet पर इंसेप्शन का उपयोग करके, Tensorflow के माध्यम से छवियों को वर्गीकृत करने में सक्षम है।
और मैंने 2015-12-05 में इंसेप्शन का इस्तेमाल किया, जब यह एक और था।

यह पता चला कि मैं जीवन से बहुत पीछे था, क्योंकि Google के लोग अपनी रोटी खाने के लिए नहीं हैं और पहले से ही 4 संस्करण तैयार कर चुके हैं!

लेकिन इंटेल के लोग उनके पीछे नहीं हैं और सभी 4 संस्करणों को ओपनविनो में समर्थन दिया गया था।

यहाँ एक लेख है जिसमें विभिन्न प्रकार के इंसेप्शन का वर्णन किया गया है।
लेकिन हम ट्रिफ़ल नहीं करेंगे, हम तुरंत अंतिम, चौथे डाउनलोड करते हैं।

हम मेज पर बिल्ली और लैपटॉप के साथ तस्वीर को वर्गीकृत करते हैं।

हमें वर्तमान संस्करण के परिणाम याद हैं:

• लैपटॉप, लैपटॉप कंप्यूटर 62%
• नोटबुक, नोटबुक कंप्यूटर 11%
• 13 सेकंड
• बिल्ली कहाँ है

अब हम इनविटेशन को ओपनवीनो में परिवर्तित करने के निर्देशों को पढ़ते हैं।

रूपांतरण सफल होता है, हम एनसीएस पर क्लासिफायर शुरू करते हैं:

• लैपटॉप, लैपटॉप कंप्यूटर 85%
• नोटबुक, नोटबुक कंप्यूटर 8%
• 0.2 सेकंड
• फिर कोई बिल्ली नहीं है

निष्कर्ष

इस प्रकार, सभी परिदृश्यों की आवश्यकता है जो Tensorflow NCS का उपयोग करके पुन: पेश किए गए थे, और इसका मतलब है कि आप Tensorflow का उपयोग कर बाहर निकल सकते हैं।

सभी समान, रास्पबेरी के लिए यह रूपरेखा भारी है।

जिस गति से एनसीएस तंत्रिका नेटवर्क को पचाता है, वह अपने क्षितिज का विस्तार करने की अनुमति देता है।

ऐसे कार्य हैं जो रोबोट पहले से ही करता है, उदाहरण के लिए, सिमेंटिक सेगमेंटेशन और वर्गीकरण, लेकिन ऑब्जेक्ट सेगमेंटेशन या वास्तविक समय में ज्ञात वस्तुओं के साथ वीडियो के प्रसारण जैसे अन्य हैं। (जो नग्न रास्पबेरी पर नहीं सोचा जा सकता था)।

मल्टीप्रोसेसिंग के साथ समस्याएं कुछ हद तक भ्रामक हैं, लेकिन अगर उन्हें हल नहीं किया जा सकता है, तो एनसीएस को एक अलग सेवा के रूप में लपेटने के रूप में हमेशा एक विकल्प होता है।

संदर्भ

• इंटेल ओपनविनो इंट्रो
• रास्पियन इंस्टॉलेशन गाइड
• ओपनविनो मॉडल चिड़ियाघर - विवरण के साथ तैयार मॉडल की एक सूची
• संसाधन जहां आप OpenVino मॉडल डाउनलोड कर सकते हैं
• गिथब पर OpenVino के लिए टैंक फर्मवेयर रेपो