🐯 🗃️ 🔱 रास्पबेरी पाई पर अपने तंत्रिका नेटवर्क डिटेक्टर को न्यूरल कम्प्यूट स्टिक और ओपनविनो का उपयोग करके लॉन्च करें 🕍 🚴🏾 🖕🏿

तंत्रिका नेटवर्क के प्रसार और विकास के साथ, उन्हें एम्बेडेड और कम-शक्ति वाले उपकरणों, रोबोट और ड्रोन पर उपयोग करने की बढ़ती आवश्यकता है। Intel OpenVino ढांचे के साथ संयोजन में न्यूरल कम्प्यूट स्टिक डिवाइस हमें तंत्रिका नेटवर्क की भारी गणनाओं के द्वारा इस समस्या को हल करने की अनुमति देता है। इसके लिए धन्यवाद, आप आसानी से लगभग वास्तविक समय में रास्पबेरी पाई जैसे कम-शक्ति डिवाइस पर एक न्यूरल नेटवर्क क्लासिफायर या डिटेक्टर लॉन्च कर सकते हैं, जबकि ऊर्जा की खपत में वृद्धि नहीं करते हैं। इस पोस्ट में, मैं आपको रास्पबेरी पाई पर एक साधारण चेहरा पहचान प्रणाली लॉन्च करने के लिए OpenVINO फ्रेमवर्क (C ++ में) और तंत्रिका कम्प्यूट स्टिक का उपयोग करने का तरीका दिखाऊंगा।

हमेशा की तरह, GitHub पर सभी कोड उपलब्ध हैं।

तंत्रिका कम्प्यूट स्टिक और OpenVINO के बारे में थोड़ा सा

2017 की गर्मियों में, इंटेल ने न्यूरल कम्प्यूट स्टिक (एनसीएस) डिवाइस को जारी किया, जिसे कम-शक्ति वाले उपकरणों पर तंत्रिका नेटवर्क चलाने के लिए डिज़ाइन किया गया था, और कुछ महीनों के बाद इसे खरीदा और परीक्षण किया जा सकता था, जो मैंने किया। एनसीएस एक छोटा कंप्यूटिंग मॉड्यूल है जिसमें एज़ुर रंग (यह भी एक रेडिएटर के रूप में कार्य करता है) का आवरण होता है, जो यूएसबी के माध्यम से मुख्य डिवाइस से जुड़ा होता है। अंदर, अन्य बातों के अलावा, इंटेल असंख्य VPU है , जो अनिवार्य रूप से 12-कोर समानांतर प्रोसेसर है, जो अक्सर तंत्रिका नेटवर्क में होने वाले संचालन के लिए तेज होता है। एनसीएस तंत्रिका नेटवर्क के प्रशिक्षण के लिए उपयुक्त नहीं है, लेकिन पहले से ही प्रशिक्षित तंत्रिका नेटवर्क में जीपीयू में इसकी गति के बराबर है। एनसीएस में सभी गणना 16-बिट फ्लोट संख्या पर की जाती हैं, जो आपको गति बढ़ाने की अनुमति देती है। NCS को संचालित करने के लिए केवल 1 वाट बिजली की आवश्यकता होती है, अर्थात 5 V पर, 200 mA तक की धारा USB कनेक्टर पर खपत होती है - यह रास्पबेरी पाई (250 mA) के लिए कैमरे से भी कम है।

पहले एनसीएस के साथ काम करने के लिए, तंत्रिका कम्प्यूट एसडीके (एनसीएसडीके) का उपयोग किया गया था: इसमें एनसीएस प्रारूप में कैफ और टेंसोरफ्लो प्रारूप में तंत्रिका नेटवर्क को संकलित करने के उपकरण शामिल हैं, उनके प्रदर्शन को मापने के लिए उपकरण, साथ ही पायथन और सी ++ एपीआई की शुरुआत के लिए।

फिर एनसीएस ढांचे का एक नया संस्करण जारी किया गया: एनसीएसडीके 2 । इसमें एपीआई काफी बदल गया है, और हालांकि कुछ परिवर्तन मुझे अजीब लग रहे थे, कुछ उपयोगी नवाचार थे। विशेष रूप से, फ्लोट 32 बिट से फ्लोट 16 बिट से सी ++ में स्वचालित रूप से जोड़ा गया था (पहले, बैसाखी को नेम्पी से कोड के रूप में डाला जाना था)। छवियों की कतारें और उनके प्रसंस्करण के परिणाम भी दिखाई दिए।

मई 2018 में, इंटेल ने ओपनविनो (जिसे पहले इंटेल कंप्यूटर विजन एसडीके कहा जाता था) जारी किया था। यह फ्रेमवर्क विभिन्न उपकरणों पर तंत्रिका नेटवर्क को कुशलतापूर्वक लॉन्च करने के लिए डिज़ाइन किया गया है: इंटेल प्रोसेसर और ग्राफिक्स कार्ड, एफपीजीए , साथ ही साथ न्यूरल कंपार्टमेंट स्टिक।

नवंबर 2018 में, त्वरक का एक नया संस्करण जारी किया गया था: तंत्रिका कम्प्यूट स्टिक 2 । डिवाइस की कंप्यूटिंग शक्ति बढ़ाई गई है: साइट पर विवरण में वे 8x तक त्वरण का वादा करते हैं, हालांकि, मैं डिवाइस के नए संस्करण का परीक्षण नहीं कर सका। त्वरण 12 से 16 तक कोर की संख्या बढ़ाने के साथ-साथ तंत्रिका नेटवर्क के लिए अनुकूलित नए कंप्यूटिंग उपकरणों को जोड़कर प्राप्त किया जाता है। सच है, मुझे जानकारी के बिजली की खपत के बारे में जानकारी नहीं मिली।

NCS का दूसरा संस्करण NCSDK या NCSDK2 के साथ पहले से ही असंगत है: OpenVino, जो NCS के दोनों संस्करणों के अलावा कई अन्य उपकरणों के साथ काम करने में सक्षम है, ने अपना अधिकार पारित कर दिया। OpenVINO में ही बड़ी कार्यक्षमता है और इसमें निम्नलिखित घटक शामिल हैं:

मॉडल ऑप्टिमाइज़र: पायथन लिपि जो आपको तंत्रिका नेटवर्क को लोकप्रिय डीप लर्निंग फ्रेमवर्क से यूनिवर्सल ओपनविनो प्रारूप में बदलने की अनुमति देती है। समर्थित फ्रेमवर्क की सूची: कैफ , टेन्सरफ्लो , एमएक्सनेट , कलड़ी (भाषण मान्यता फ्रेमवर्क), ओएनएनएक्स (तंत्रिका नेटवर्क का प्रतिनिधित्व करने के लिए खुला प्रारूप)।
इंजेक्शन इंजन: तंत्रिका नेटवर्क के इंजेक्शन के लिए C ++ और पायथन एपीआई, एक विशिष्ट इंजेक्शन डिवाइस से सार। API कोड CPU, GPU, FPGA और NCS के लिए लगभग समान होगा।
विभिन्न उपकरणों के लिए प्लगइन्स का एक सेट। प्लगइन्स गतिशील पुस्तकालय हैं जो मुख्य कार्यक्रम के कोड में स्पष्ट रूप से लोड किए गए हैं। हम एनसीएस के लिए प्लगइन में सबसे अधिक रुचि रखते हैं।
यूनिवर्सल ओपनविनो प्रारूप (पूर्ण सूची यहां है ) में पूर्व-प्रशिक्षित मॉडल का एक सेट। उच्च-गुणवत्ता वाले तंत्रिका नेटवर्क का एक प्रभावशाली संग्रह: चेहरे, पैदल यात्री, वस्तुओं के डिटेक्टर; चेहरे के उन्मुखीकरण की पहचान, चेहरे के विशेष बिंदु, मानव आसन; सुपर संकल्प; और अन्य। यह ध्यान देने योग्य है कि उनमें से सभी NCS / FPGA / GPU द्वारा समर्थित नहीं हैं।
मॉडल डाउनलोडर: एक अन्य स्क्रिप्ट जो नेटवर्क पर ओपनविनो प्रारूप में डाउनलोडिंग मॉडल को सरल बनाती है (हालांकि आप इसके बिना आसानी से कर सकते हैं)।
OpenCV कंप्यूटर दृष्टि पुस्तकालय इंटेल हार्डवेयर के लिए अनुकूलित।
लाइब्रेरी ऑफ़ कंप्यूटर विज़न OpenVX ।
डीप न्यूरल नेटवर्क्स के लिए इंटेल कंप्यूट लाइब्रेरी ।
डीप न्यूरल नेटवर्क्स के लिए इंटेल मैथ कर्नेल लाइब्रेरी ।
FPGA (वैकल्पिक) के लिए तंत्रिका नेटवर्क के अनुकूलन के लिए एक उपकरण।
प्रलेखन और नमूना कार्यक्रम।

अपने पिछले लेखों में, मैंने NCS (पहला लेख) पर YOLO फेस डिटेक्टर चलाने के बारे में बात की, साथ ही साथ अपने SSD फेस डिटेक्टर को कैसे प्रशिक्षित किया जाए और इसे रास्पबेरी पाई और NCS (दूसरा लेख) पर कैसे चलाया जाए। इन लेखों में, मैंने NCSDK और NCSDK2 का उपयोग किया। इस लेख में मैं आपको बताऊंगा कि कुछ समान कैसे किया जाता है, लेकिन OpenVINO का उपयोग करते हुए, मैं दोनों अलग-अलग फेस डिटेक्टरों और उन्हें लॉन्च करने के लिए दो रूपरेखाओं की एक छोटी तुलना करूंगा, और मैं कुछ नुकसानों के बारे में बताऊंगा। मैं सी ++ में लिखता हूं, क्योंकि मेरा मानना है कि इस तरह आप बेहतर प्रदर्शन हासिल कर सकते हैं, जो रास्पबेरी पाई के मामले में महत्वपूर्ण होगा।

OpenVINO स्थापित करें

सबसे मुश्किल काम नहीं है, हालांकि सूक्ष्मताएं हैं। इस लेखन के समय, OpenVINO केवल Ubuntu 16.04 LTS, CentOS 7.4 और Windows 10. का समर्थन करता है। मेरे पास Ubuntu 18 है, और मुझे इसे स्थापित करने के लिए छोटी बैसाखी की आवश्यकता है। मैं एनसीएसडीके 2 के साथ ओपनविनो की तुलना भी करना चाहता था, जिसकी स्थापना में भी समस्याएं हैं: विशेष रूप से, यह कैफ और टेन्सरफ्लो के अपने संस्करणों को मजबूत करता है और पर्यावरण सेटिंग्स को थोड़ा तोड़ सकता है। अंत में, मैंने एक सरल पथ का पालन करने का फैसला किया और उबंटू 16 (मैं वर्चुअलबॉक्स का उपयोग करता हूं) के साथ दोनों फ्रेमवर्क को एक वर्चुअल मशीन में स्थापित किया।

यह ध्यान देने योग्य है कि एनसीएस को एक वर्चुअल मशीन से सफलतापूर्वक कनेक्ट करने के लिए, आपको वर्चुअलबॉक्स अतिथि ऐड-ऑन स्थापित करने और 3.0 3.0 समर्थन सक्षम करने की आवश्यकता है। मैंने USB उपकरणों के लिए एक सार्वभौमिक फ़िल्टर भी जोड़ा, जिसके परिणामस्वरूप NCS बिना किसी समस्या के जुड़ा (हालाँकि वेबकैम अभी भी वर्चुअल मशीन की सेटिंग में कनेक्ट होना है)। OpenVINO को स्थापित और संकलित करने के लिए आपके पास एक इंटेल खाता होना चाहिए, एक फ्रेमवर्क विकल्प चुनें (FPGA समर्थन के साथ या बिना) और निर्देशों का पालन करें । NCSDK और भी सरल है: यह GitHub से बूट होता है (फ्रेमवर्क के नए संस्करण के लिए ncsdk2 शाखा का चयन करना न भूलें), जिसके बाद आपको make install आवश्यकता होती है।

वर्चुअल मशीन में NCSDK2 को चलाने के दौरान मुझे जो एकमात्र समस्या आई, वह निम्नलिखित फ़ॉर्म की त्रुटि है:

 E: [ 0] dispatcherEventReceive:236 dispatcherEventReceive() Read failed -1 E: [ 0] eventReader:254 Failed to receive event, the device may have reset

यह कार्यक्रम के सही निष्पादन के अंत में होता है और (ऐसा लगता है) कुछ भी प्रभावित नहीं करता है। जाहिरा तौर पर, यह वीएम से संबंधित एक छोटा बग है (यह रास्पबेरी पर नहीं होना चाहिए)।

रास्पबेरी पाई पर स्थापना काफी अलग है। सबसे पहले, सुनिश्चित करें कि आपके पास रास्पियन खिंचाव स्थापित है: दोनों रूपरेखा आधिकारिक तौर पर केवल इस ओएस पर काम करती हैं। NCSDK2 को केवल-एपीआई मोड में संकलित करने की आवश्यकता है , अन्यथा यह कैफ और टेन्सरफ्लो स्थापित करने की कोशिश करेगा, जो आपके रास्पबेरी को खुश करने की संभावना नहीं है। OpenVINO के मामले में, रास्पबेरी के लिए पहले से ही इकट्ठे संस्करण है , जिसे आपको केवल पर्यावरण चर को अनपैक और कॉन्फ़िगर करने की आवश्यकता है। इस संस्करण में केवल C ++ और Python API है, साथ ही OpenCV लाइब्रेरी, अन्य सभी उपकरण उपलब्ध नहीं हैं। इसका मतलब है कि दोनों रूपरेखाओं के लिए, मॉडल को उबंटू के साथ एक मशीन पर अग्रिम रूप से परिवर्तित किया जाना चाहिए। मेरा चेहरा पहचानने वाला डेमो रास्पबेरी और डेस्कटॉप दोनों पर काम करता है, इसलिए मैंने सिर्फ रास्पबेरी के साथ सिंक करने में आसान बनाने के लिए अपने गिटहब रिपॉजिटरी में परिवर्तित तंत्रिका नेटवर्क फ़ाइलों को जोड़ा। मेरे पास रास्पबेरी पाई 2 मॉडल बी है, लेकिन इसे अन्य मॉडलों के साथ उतारना चाहिए।

रास्पबेरी पाई और न्यूरल कम्प्यूट स्टिक की बातचीत के बारे में एक और सूक्ष्मता है: यदि लैपटॉप के मामले में यह एनसीएस को केवल निकटतम यूएसबी 3.0 पोर्ट में प्रहार करने के लिए पर्याप्त है, तो रास्पबेरी के लिए आपको एक यूएसबी केबल ढूंढना होगा, अन्यथा एनएससी शेष तीन यूएसबी कनेक्टर को अपने शरीर के साथ ब्लॉक कर देगा। यह भी याद रखने योग्य है कि रास्पबेरी में सभी यूएसबी 2.0 संस्करण हैं, इसलिए संचार विलंब (बाद में एक विस्तृत तुलना होगी) के कारण अनुमान की दर कम होगी। लेकिन अगर आप रास्पबेरी से दो या अधिक एनसीएस कनेक्ट करना चाहते हैं, तो सबसे अधिक संभावना है कि आपको अतिरिक्त शक्ति के साथ एक यूएसबी हब ढूंढना होगा।

OpenVINO कोड कैसा दिखता है

बहुत सुंदर। बहुत सारी अलग-अलग क्रियाएं होती हैं, जो प्लग को लोड करने से शुरू होती हैं और अंतःक्षिप्तता के साथ समाप्त होती हैं - इसलिए मैंने डिटेक्टर के लिए एक आवरण वर्ग लिखा। पूरा कोड GitHub पर देखा जा सकता है, लेकिन यहां मैं सिर्फ मुख्य बिंदुओं को सूचीबद्ध करता हूं। चलिए शुरू करते हैं:

हमारे द्वारा आवश्यक सभी फ़ंक्शन की परिभाषाएँ InferenceEngine नाम स्थान में inference_engine.hpp फ़ाइल में हैं।

 #include <inference_engine.hpp> using namespace InferenceEngine;

निम्नलिखित चर को हर समय की आवश्यकता होगी। तंत्रिका नेटवर्क के इनपुट और आउटपुट को संबोधित करने के लिए हमें inputName और outputName की आवश्यकता है। आमतौर पर, एक तंत्रिका नेटवर्क में कई इनपुट और आउटपुट हो सकते हैं, लेकिन हमारे डिटेक्टरों में एक समय में एक होगा। वैरिएबल net ही नेटवर्क है, request लास्ट inputBlob का पॉइंटर है, inputBlob न्यूरल नेटवर्क के इनपुट डेटा ऐरे का पॉइंटर है। शेष चर अपने लिए बोलते हैं।

 string inputName; string outputName; ExecutableNetwork net; InferRequest::Ptr request; Blob::Ptr inputBlob; //input shape int netInputWidth; int netInputHeight; int netInputChannels; //output shape int maxNumDetectedFaces; //return code StatusCode ncsCode;

अब आवश्यक प्लगइन डाउनलोड करें - हमें एनसीएस और एनसीएस 2 के लिए जिम्मेदार एक की आवश्यकता है, इसे "MYRII" नाम से प्राप्त किया जा सकता है। आपको याद दिला दूं कि OpenVino के संदर्भ में, एक प्लगइन सिर्फ एक गतिशील पुस्तकालय है जो स्पष्ट अनुरोध द्वारा जोड़ता है। PluginDispatcher फ़ंक्शन का पैरामीटर उन निर्देशिकाओं की एक सूची है जिसमें प्लगइन्स की तलाश है। यदि आप निर्देशों के अनुसार पर्यावरण चर सेट करते हैं, तो एक खाली रेखा पर्याप्त होगी। संदर्भ के लिए, प्लगइन्स [OpenVINO_install_dir]/deployment_tools/inference_engine/lib/ubuntu_16.04/intel64/

 InferencePlugin plugin = PluginDispatcher({""}).getPluginByDevice("MYRIAD");

अब तंत्रिका नेटवर्क को लोड करने के लिए एक वस्तु बनाएं, इसके विवरण पर विचार करें और बैच का आकार (एक साथ संसाधित छवियों की संख्या) सेट करें। OpenVINO प्रारूप में एक तंत्रिका नेटवर्क को दो फ़ाइलों द्वारा परिभाषित किया गया है: संरचना के विवरण के साथ .xml और वजन के साथ एक .bin। जबकि हम OpenVINO से तैयार किए गए डिटेक्टरों का उपयोग करेंगे, हम बाद में अपना स्वयं का निर्माण करेंगे। यहाँ std::string filename एक्सटेंशन के बिना फाइल का नाम है। आपको यह भी ध्यान रखना होगा कि NCS केवल 1 के बैच आकार का समर्थन करता है।

 CNNNetReader netReader; netReader.ReadNetwork(filename+".xml"); netReader.ReadWeights(filename+".bin"); netReader.getNetwork().setBatchSize(1);

तब निम्न होता है:

तंत्रिका नेटवर्क में प्रवेश करने के लिए, डेटा टाइप को अहस्ताक्षरित चार 8 बिट पर सेट करें। इसका मतलब यह है कि हम उस प्रारूप में छवि को इनपुट कर सकते हैं जिसमें यह कैमरे से आता है, और InferenceEngine रूपांतरण का ख्याल रखेगा (NCS 16 बिट फ्लोट प्रारूप में गणना करता है)। यह रास्पबेरी पाई पर थोड़ी गति देगा - जैसा कि मैं इसे समझता हूं, रूपांतरण एनसीएस पर किया जाता है, इसलिए यूएसबी के माध्यम से डेटा स्थानांतरित करने में कम देरी होती है।
हमें इनपुट और आउटपुट नाम मिलते हैं, ताकि बाद में हम उन्हें एक्सेस कर सकें।
हम आउटपुट का विवरण प्राप्त करते हैं (यह आउटपुट के नाम से एक पॉइंटर से डेटा ब्लॉक तक का नक्शा है)। हमें पहले (एकल) आउटपुट के डेटा ब्लॉक के लिए एक पॉइंटर मिलता है।
हम इसका आकार प्राप्त करते हैं: 1 एक्स 1 एक्स अधिकतम संख्या में पता लगाने के विवरण (7) का पता लगाने की लंबाई एक्स। विवरणों के विवरण के प्रारूप के बारे में - बाद में।
32 बिट फ्लोट करने के लिए आउटपुट स्वरूप सेट करें। फिर से, फ्लोट 16 बिट से रूपांतरण InferenceEngine का ख्याल रखता है।

 //we can set input type to unsigned char: conversion will be performed on device netReader.getNetwork().getInputsInfo().begin()->second->setPrecision(Precision::U8); //get input and output names and their info structures inputName = netReader.getNetwork().getInputsInfo().begin()->first; outputName = netReader.getNetwork().getOutputsInfo().begin()->first; OutputsDataMap outputInfo(netReader.getNetwork().getOutputsInfo()); InputsDataMap inputInfo(netReader.getNetwork().getInputsInfo()); DataPtr &outputData = (outputInfo.begin()->second); //get output shape: (1 x 1 x maxNumDetectedFaces x faceDescriptionLength(7)) const SizeVector outputDims = outputData->getTensorDesc().getDims(); maxNumDetectedFaces = outputDims[2]; //set input type to float32: calculations are all in float16, conversion is performed on device outputData->setPrecision(Precision::FP32);

अब सबसे महत्वपूर्ण बिंदु: हम तंत्रिका नेटवर्क को प्लगइन में लोड करते हैं (अर्थात, एनसीएस में)। जाहिर है, वांछित प्रारूप पर संकलन मक्खी पर है। यदि प्रोग्राम इस फ़ंक्शन पर क्रैश होता है, तो तंत्रिका नेटवर्क शायद इस डिवाइस के लिए उपयुक्त नहीं है।

 net = plugin.LoadNetwork(netReader.getNetwork(), {});

और अंत में - हम परीक्षण निष्कर्ष निकालेंगे और इनपुट आकार प्राप्त करेंगे (शायद यह अधिक सुरुचिपूर्ण ढंग से किया जा सकता है)। सबसे पहले, हम प्रवेश के लिए एक अनुरोध खोलते हैं, फिर उससे हमें इनपुट डेटा ब्लॉक का लिंक मिलता है, और हम पहले से ही इसके आकार का अनुरोध करते हैं।

 //perform single inference to get input shape (a hack) request = net.CreateInferRequestPtr(); //open inference request //we need the blob size: (batch(1) x channels(3) x H x W) inputBlob = request->GetBlob(inputName); SizeVector blobSize = inputBlob->getTensorDesc().getDims(); netInputWidth = blobSize[3]; netInputHeight = blobSize[2]; netInputChannels = blobSize[1]; request->Infer(); //close request

आइए NCS को एक चित्र अपलोड करने का प्रयास करें। उसी तरह, हम अनुमान के लिए एक अनुरोध बनाते हैं, इसके लिए एक डेटा ब्लॉक को एक पॉइंटर प्राप्त करें, और वहां से हम सरणी के लिए एक पॉइंटर प्राप्त करें। अगला, बस हमारी छवि से डेटा कॉपी करें (यहां यह पहले से ही वांछित आकार में कम हो गया है)। यह ध्यान देने योग्य है कि cv::Mat और inputBlob माप अलग-अलग क्रम में (OpenCV में, चैनल इंडेक्स सभी की तुलना में तेज़ी से बदलता है, OpenVINO में यह सभी की तुलना में धीमा है), इसलिए मेम्ची पर्याप्त नहीं है। फिर हम अतुल्यकालिक आक्रमण शुरू करते हैं।

अतुल्यकालिक क्यों? यह संसाधनों के आवंटन का अनुकूलन करेगा। जबकि एनसीएस तंत्रिका नेटवर्क पर विचार करता है, तो आप अगले फ्रेम को संसाधित कर सकते हैं - इससे रास्पबेरी पाई पर ध्यान देने योग्य त्वरण होगा।

 cv::Mat data; ... //get image somehow //create request, get data blob request = net.CreateInferRequestPtr(); inputBlob = request->GetBlob(inputName); unsigned char* blobData = inputBlob->buffer().as<unsigned char*>(); //copy from resized frame to network input int wh = netInputHeight*netInputWidth; for (int c = 0; c < netInputChannels; c++) for (int h = 0; h < wh; h++) blobData[c * wh + h] = data.data[netInputChannels*h + c]; //start asynchronous inference request->StartAsync();

यदि आप तंत्रिका नेटवर्क से अच्छी तरह से परिचित हैं, तो आपके पास एक सवाल हो सकता है कि हम तंत्रिका नेटवर्क के इनपुट पिक्सल के मूल्यों को किस बिंदु पर मापते हैं (उदाहरण के लिए, हम सीमा पर लाते हैं।

$[0,1]$ )। तथ्य यह है कि OpenVINO मॉडल में यह परिवर्तन पहले से ही तंत्रिका नेटवर्क के विवरण में शामिल है, और हमारे डिटेक्टर का उपयोग करते समय हम कुछ ऐसा ही करेंगे। और चूंकि फ्लोटिंग और स्केलिंग के दोनों रूपांतरण OpenVINO द्वारा किए जाते हैं, हमें केवल छवि का आकार बदलने की आवश्यकता है।

अब (कुछ उपयोगी काम करने के बाद) हम अनुमान के लिए अनुरोध पूरा करेंगे। निष्पादन परिणाम आने तक कार्यक्रम अवरुद्ध है। हमें परिणाम के लिए एक संकेतक मिलता है।

 float * output; ncsCode = request->Wait(IInferRequest::WaitMode::RESULT_READY); output = request->GetBlob(outputName)->buffer().as<float*>();

अब यह सोचने का समय है कि एनसीएस डिटेक्टर के परिणाम को किस प्रारूप में लौटाता है। यह ध्यान देने योग्य है कि यह NCSDK का उपयोग करते समय प्रारूप से थोड़ा अलग है। सामान्यतया, डिटेक्टर आउटपुट चार-आयामी होता है और इसका एक आयाम (1 x 1 x अधिकतम संख्या में एक्स x 7) होता है, हम मान सकते हैं कि यह आकार का एक सरणी है ( maxNumDetectedFaces x 7)।

maxNumDetectedFaces पैरामीटर तंत्रिका नेटवर्क के विवरण में सेट किया गया है, और इसे बदलना आसान है, उदाहरण के लिए, Caffe प्रारूप में नेटवर्क के .prototxt विवरण में। इससे पहले हमने इसे डिटेक्टर का प्रतिनिधित्व करने वाली वस्तु से प्राप्त किया था। यह पैरामीटर SSD डिटेक्टरों (सिंगल शॉट डिटेक्टर) के वर्ग की बारीकियों से संबंधित है, जिसमें सभी समर्थित NCS डिटेक्टर शामिल हैं। एक SSD हमेशा प्रत्येक छवि के लिए बाउंडिंग बॉक्स की समान (और बहुत बड़ी) संख्या पर विचार करता है, और कम आत्मविश्वास रेटिंग के साथ डिटेक्शन को फ़िल्टर करने और नॉन-मैक्सिमम सप्रेशन का उपयोग करके ओवरलैपिंग फ्रेम को हटाने के बाद, वे आमतौर पर 100-200 सर्वश्रेष्ठ छोड़ते हैं। यह वही है जो पैरामीटर के लिए जिम्मेदार है।

एक पहचान के विवरण में सात मान इस प्रकार हैं:

बैच में छवि संख्या जिस पर वस्तु का पता चला है (हमारे मामले में, यह शून्य होना चाहिए);
ऑब्जेक्ट क्लास (0 - पृष्ठभूमि, 1 से शुरू - अन्य कक्षाएं, केवल एक सकारात्मक वर्ग के साथ हिरासत वापस कर दी जाती हैं);
पहचान की उपस्थिति में विश्वास (सीमा में) $[0,1]$ );
बाउंडिंग बॉक्स के ऊपरी बाएँ कोने में सामान्यीकृत x- समन्वय $[0,1]$ );
इसी तरह - y- समन्वय;
सामान्यीकृत बाउंडिंग बॉक्स चौड़ाई (सीमा में) $[0,1]$ );
इसी तरह - ऊंचाई;

डिटेक्टर आउटपुट से बाउंडिंग बॉक्स निकालने के लिए कोड

 void get_detection_boxes(const float* predictions, int numPred, int w, int h, float thresh, std::vector<float>& probs, std::vector<cv::Rect>& boxes) { float score = 0; float cls = 0; float id = 0; //predictions holds numPred*7 values //data format: image_id, detection_class, detection_confidence, //box_normed_x, box_normed_y, box_normed_w, box_normed_h for (int i=0; i<numPred; i++) { score = predictions[i*7+2]; cls = predictions[i*7+1]; id = predictions[i*7 ]; if (id>=0 && score>thresh && cls<=1) { probs.push_back(score); boxes.push_back(Rect(predictions[i*7+3]*w, predictions[i*7+4]*h, (predictions[i*7+5]-predictions[i*7+3])*w, (predictions[i*7+6]-predictions[i*7+4])*h)); } } }

हम डिटेक्टर से खुद को numPred , और w,h - विज़ुअलाइज़ेशन के लिए छवि आकार।

अब इस बारे में कि वास्तविक समय में अनुमान की सामान्य योजना कैसी है। सबसे पहले हम तंत्रिका नेटवर्क और कैमरे को इनिशियलाइज़ करते हैं, cv::Mat शुरू करते हैं cv::Mat कच्चे फ्रेम के लिए cv::Mat और वांछित आकार में कम किए गए फ्रेम के लिए एक और। हम अपने फ्रेम को शून्य से भरते हैं - इससे आत्मविश्वास बढ़ जाएगा कि एक ही शुरुआत में तंत्रिका नेटवर्क को कुछ भी नहीं मिलेगा। फिर हम एक अनुमान चक्र शुरू करते हैं:

हम एक अतुल्यकालिक अनुरोध का उपयोग करके तंत्रिका नेटवर्क में वर्तमान फ्रेम को लोड करते हैं - एनसीएस ने पहले ही काम करना शुरू कर दिया है, और इस समय हमारे पास उपयोगी कार्य को मुख्य प्रोसेसर बनाने का अवसर है।
हम पिछले फ्रेम पर सभी पिछले डिटेक्टरों को प्रदर्शित करते हैं, एक फ्रेम खींचते हैं (यदि आवश्यक हो)।
हमें कैमरे से एक नया फ्रेम मिलता है, इसे वांछित आकार में संपीड़ित करें। रास्पबेरी के लिए, मैं सरलतम आकार के एल्गोरिथ्म का उपयोग करने की सलाह देता हूं - ओपनसीवी में, यह निकटतम पड़ोसी प्रक्षेप है। यह डिटेक्टर के प्रदर्शन की गुणवत्ता को प्रभावित नहीं करेगा, लेकिन यह थोड़ा गति जोड़ सकता है। मैं आसान विज़ुअलाइज़ेशन (वैकल्पिक) के लिए फ़्रेम को दर्पण भी करता हूं।
अब समय आ गया है कि एनसीएस के साथ निष्कर्ष निकालने का अनुरोध पूरा करके परिणाम प्राप्त किया जाए। परिणाम प्राप्त होने तक कार्यक्रम अवरुद्ध रहेगा।
हम नए डिटेक्शन प्रोसेस करते हैं, फ्रेम का चयन करते हैं।
बाकी: कीस्ट्रोक्स, काउंटिंग फ्रेम आदि का काम करना।

इसका संकलन कैसे करें

InferenceEngine उदाहरणों में, मुझे भारी CMake फाइलें पसंद नहीं थीं, और मैंने अपने Makefile में सब कुछ फिर से लिखने का फैसला किया:

 g++ $(RPI_ARCH) \ -I/usr/include -I. \ -I$(OPENVINO_PATH)/deployment_tools/inference_engine/include \ -I$(OPENVINO_PATH_RPI)/deployment_tools/inference_engine/include \ -L/usr/lib/x86_64-linux-gnu \ -L/usr/local/lib \ -L$(OPENVINO_PATH)/deployment_tools/inference_engine/lib/ubuntu_16.04/intel64 \ -L$(OPENVINO_PATH_RPI)/deployment_tools/inference_engine/lib/raspbian_9/armv7l \ vino.cpp wrapper/vino_wrapper.cpp \ -o demo -std=c++11 \ `pkg-config opencv --cflags --libs` \ -ldl -linference_engine $(RPI_LIBS)

यह टीम उबंटू और रास्पियन दोनों पर काम करेगी, एक-दो तरकीबों की बदौलत। हेडर और गतिशील पुस्तकालयों की खोज के लिए पथ मैंने रास्पबेरी और उबंटू मशीन दोनों के लिए संकेत दिया है। पुस्तकालयों में से, OpenCV के अलावा, आपको libinference_engine और libdl को भी जोड़ना होगा - गतिशील रूप से अन्य पुस्तकालयों को जोड़ने के लिए एक पुस्तकालय, यह प्लग-इन कार्य के लिए आवश्यक है। उसी समय, libmyriadPlugin स्वयं निर्दिष्ट करने की आवश्यकता नहीं है। अन्य बातों के अलावा, रास्पबेरी के लिए मैं कैमरे के साथ काम करने के लिए रास्पिकैम पुस्तकालय को भी जोड़ता हूं (यह $(RPI_LIBS) )। मुझे भी C ++ 11 मानक का उपयोग करना पड़ा।

अलग-अलग, यह ध्यान देने योग्य है कि रास्पबेरी पर संकलन करते समय, -march=armv7-a ध्वज की आवश्यकता होती है (यह $(RPI_ARCH) )। यदि आप इसे निर्दिष्ट नहीं करते हैं, तो प्रोग्राम संकलन करेगा, लेकिन एक मूक segfault के साथ दुर्घटनाग्रस्त हो जाएगा। -O3 का उपयोग करके आप अनुकूलन भी जोड़ सकते हैं, इससे गति बढ़ेगी।

डिटेक्टर क्या हैं

NCS बॉक्स से केवल Caffe SSD डिटेक्टरों का समर्थन करता है, हालांकि कुछ गंदी चाल के साथ मैं इस पर Darknet प्रारूप से YOLO चलाने में कामयाब रहा। सिंगल शॉट डिटेक्टर (एसएसडी) हल्के तंत्रिका नेटवर्क के बीच एक लोकप्रिय वास्तुकला है, और विभिन्न एन्कोडर (या बैकबोन नेटवर्क) की मदद से आप गति और गुणवत्ता के अनुपात को काफी भिन्न कर सकते हैं।

मैं अलग-अलग फेस डिटेक्टरों के साथ प्रयोग करूंगा:

यहाँ से लिया गया YOLO, पहले Caffe प्रारूप में, फिर NCS प्रारूप में (केवल NCSDK के साथ) परिवर्तित किया गया। छवि 448 x 448।
मेरा मोबिलनेट + एसएसडी डिटेक्टर, जिसके प्रशिक्षण के बारे में मैंने पिछले प्रकाशन में बात की थी। मेरे पास अभी भी इस डिटेक्टर का एक फसली संस्करण है, जो केवल छोटे चेहरे देखता है, और एक ही समय में थोड़ा तेज है। मैं NCSDK और OpenVINO दोनों पर अपने डिटेक्टर के पूर्ण संस्करण की जांच करूंगा। चित्र 300 x 300
OpenVINO से डिटेक्टर फेस-डिटेक्शन-एडस-0001: मोबाइलनेट + एसएसडी। छवि 384 x 672
OpenVINO फेस-डिटेक्शन-रिटेल -0004 डिटेक्टर: लाइटवेट स्क्वीज़नेट + एसएसडी। चित्र 300 x 300

OpenVINO से डिटेक्टरों के लिए, कैफ प्रारूप या NCSDK प्रारूप में कोई पैमाना नहीं है, इसलिए मैं केवल उन्हें OpenVINO में लॉन्च कर सकता हूं।

OpenVino प्रारूप में अपने डिटेक्टर को बदलना

मेरे पास कैफ़ प्रारूप में दो फाइलें हैं: नेटवर्क के विवरण के साथ .protxt और वजन के साथ .caffemodel। मुझे OpenVino प्रारूप में उनसे दो फाइलें प्राप्त करने की आवश्यकता है: .xml और .bin एक विवरण और भार के साथ, क्रमशः। ऐसा करने के लिए, OpenVINO (उर्फ मॉडल ऑप्टिमाइज़र) से mo.py स्क्रिप्ट का उपयोग करें:

 mo.py \ --framework caffe \ --input_proto models/face/ssd-face.prototxt \ --input_model models/face/ssd-face.caffemodel \ --output_dir models/face \ --model_name ssd-vino-custom \ --mean_values [127.5,127.5,127.5] \ --scale_values [127.5,127.5,127.5] \ --data_type FP16

output_dir उस निर्देशिका को निर्दिष्ट करता है जिसमें नई फाइलें बनाई model_name , model_name एक एक्सटेंशन के बिना नई फ़ाइलों का नाम है, data_type (FP16/FP32) तंत्रिका नेटवर्क में संतुलन का प्रकार है (NCS केवल FP16 का समर्थन करता है)। mean_values, scale_values तंत्रिका नेटवर्क में लॉन्च होने से पहले छवियों को प्रीप्रोसेस करने के लिए औसत और स्केल सेट करते हैं। विशिष्ट रूपांतरण इस तरह दिखता है:

$(पिक्सेल \ _values - माध्य \ _values) / स्केल \ _values $

इस स्थिति में, मान श्रेणी से कनवर्ट किए जाते हैं

$[0.255]$ सीमा में

$[0,1]$ । सामान्य तौर पर, इस स्क्रिप्ट में बहुत सारे पैरामीटर होते हैं, जिनमें से कुछ व्यक्तिगत रूपरेखाओं के लिए विशिष्ट होते हैं, मेरा सुझाव है कि आप स्क्रिप्ट के लिए मैनुअल देखें।

रास्पबेरी के लिए OpenVINO वितरण में तैयार मॉडल नहीं हैं, लेकिन वे डाउनलोड करने के लिए काफी सरल हैं।

उदाहरण के लिए, इस तरह।

  wget --no-check-certificate \ https://download.01.org/openvinotoolkit/2018_R4/open_model_zoo/face-detection-retail-0004/FP16/face-detection-retail-0004.xml \ -O ./models/face/vino.xml; \ wget --no-check-certificate \ https://download.01.org/openvinotoolkit/2018_R4/open_model_zoo/face-detection-retail-0004/FP16/face-detection-retail-0004.bin \ -O ./models/face/vino.bin

डिटेक्टर और चौखटे की तुलना

मैंने तीन तुलना विकल्पों का उपयोग किया: 1) उबंटू 16.04, कोर आई 7 प्रोसेसर, यूएसबी 3.0 कनेक्टर के साथ एनसीएस + वर्चुअल मशीन; 2) एनसीएस + एक ही मशीन, यूएसबी 3.0 कनेक्टर + यूएसबी 2.0 केबल (डिवाइस के साथ आदान-प्रदान में अधिक देरी होगी); 3) एनसीएस + रास्पबेरी पाई 2 मॉडल बी, रास्पियन खिंचाव, यूएसबी 2.0 कनेक्टर + यूएसबी 2.0 केबल।

मैंने अपने डिटेक्टर को OpenVINO और NCSDK2 दोनों के साथ शुरू किया, OpenVINO से डिटेक्टरों ने केवल अपने मूल ढांचे के साथ, YOLO केवल NCSDK2 के साथ (सबसे अधिक संभावना है, यह OpenVINO पर भी चलाया जा सकता है)।

विभिन्न डिटेक्टरों के लिए एफपीएस तालिका इस तरह दिखती है (संख्या लगभग है):

आदर्श	यूएसबी 3.0	USB 2.0	रास्पबेरी पाई
NCSDK2 के साथ कस्टम SSD	10.8	9.3	7.2
NCSDK2 के साथ कस्टम longrange SSD	11.8	10.0	7.3
NCSDK2 के साथ YOLO v2	5.3	4.6	3.6
OpenVINO के साथ कस्टम SSD	10.6	9.9	7.9
ओपनविनो फेस-डिटेक्शन-रिटेल-0004	15.6	14.2	9.3
ओपनविनो फेस-डिटेक्शन-एडस-0001	5.8	5.5	3.9

नोट: प्रदर्शन को पूरे डेमो प्रोग्राम के लिए मापा गया था, जिसमें फ्रेम की प्रोसेसिंग और विज़ुअलाइज़ेशन शामिल है।

YOLO सभी में सबसे धीमा और सबसे अस्थिर था। यह बहुत बार पता लगाता है और प्रबुद्ध फ्रेम के साथ काम नहीं कर सकता है।

जिस डिटेक्टर को मैंने दो बार तेजी से काम किया, वह फ्रेम में विरूपण के लिए अधिक प्रतिरोधी है, और यहां तक कि छोटे चेहरे का भी पता लगाता है। हालाँकि, यह अभी भी कभी-कभी पता लगाता है और कभी-कभी झूठे लोगों का पता लगाता है। यदि आप इसमें से पिछली कुछ परतों को काट देते हैं, तो यह थोड़ा तेज़ हो जाएगा, लेकिन यह बड़े चेहरे को देखना बंद कर देगा। OpenVino के माध्यम से लॉन्च किया गया समान डिटेक्टर USB 2.0 का उपयोग करते समय थोड़ा तेज हो जाता है, गुणवत्ता नेत्रहीन रूप से नहीं बदलती है।

OpenVINO डिटेक्टर, निश्चित रूप से, YOLO और मेरे डिटेक्टर दोनों से बेहतर हैं। (यदि ओपनविनो उस समय अपने वर्तमान रूप में मौजूद था, तो मैं अपने डिटेक्टर को प्रशिक्षित करना भी शुरू नहीं करूंगा)। खुदरा-0004 मॉडल काफी तेज है और एक ही समय में व्यावहारिक रूप से चेहरे को याद नहीं करता है, लेकिन मैं इसे थोड़ा बेवकूफ बनाने में कामयाब रहा (हालांकि इन निशानों में विश्वास कम है):

कृत्रिम पर प्राकृतिक बुद्धि का प्रतिस्पर्धी हमला

Adas-0001 डिटेक्टर बहुत धीमा है, लेकिन यह बड़ी छवियों के साथ काम करता है और अधिक सटीक होना चाहिए। मुझे अंतर नज़र नहीं आया, लेकिन मैंने काफी सरल फ्रेम पर जाँच की।

निष्कर्ष

सामान्य तौर पर, यह बहुत अच्छा है कि रास्पबेरी पाई जैसी कम-शक्ति डिवाइस पर आप तंत्रिका नेटवर्क का उपयोग कर सकते हैं, और यहां तक कि लगभग वास्तविक समय में भी। OpenVINO कई अलग-अलग उपकरणों पर तंत्रिका नेटवर्क की शुरूआत के लिए बहुत व्यापक कार्यक्षमता प्रदान करता है - लेख में वर्णित की तुलना में बहुत व्यापक। मुझे लगता है कि मेरे रोबोट अनुसंधान में न्यूरल कम्प्यूट स्टिक और ओपनविनो बहुत उपयोगी होंगे।

रास्पबेरी पाई पर अपने तंत्रिका नेटवर्क डिटेक्टर को न्यूरल कम्प्यूट स्टिक और ओपनविनो का उपयोग करके लॉन्च करें