💪🏽 🔙 👈🏾 वीडियो पर फेस डिटेक्शन: रास्पबेरी पाई और न्यूरल कम्प्यूट स्टिक 📛 🐇 👍🏿

लगभग एक साल पहले, Intel Movidius ने कंफ्यूज़नल न्यूरल नेटवर्क - Movidius Neural Compute Stick (NCS) के कुशल निष्कासन के लिए एक उपकरण जारी किया। यह उपकरण रोबोटिक कार्यों सहित सीमित बिजली की खपत की स्थितियों में वस्तुओं की मान्यता या पहचान के लिए तंत्रिका नेटवर्क के उपयोग की अनुमति देता है। NCS का USB इंटरफ़ेस है और 1 वाट से अधिक का उपभोग नहीं करता है। इस लेख में, मैं वीडियो में चेहरे का पता लगाने के लिए रास्पबेरी पाई के साथ एनसीएस का उपयोग करने के अनुभव के बारे में बात करूंगा, जिसमें मोबिलनेट-एसएसडी डिटेक्टर दोनों को प्रशिक्षित करना और इसे रास्पबेरी पर लॉन्च करना शामिल है।

सभी कोड मेरे दो रिपॉजिटरी में पाए जा सकते हैं: डिटेक्टर ट्रेनिंग और फेस डिटेक्शन डेमो ।

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

अंत में, मैंने अपने डिटेक्टर को प्रशिक्षित करने का निर्णय लिया। विकल्प मोबिलनेट एनकोडर के साथ एसएसडी डिटेक्टर पर गिर गया: मोबिलनेट का हल्का कनवल्शन आपको गुणवत्ता में किसी भी नुकसान के बिना उच्च गति प्राप्त करने की अनुमति देता है, और एसएसडी डिटेक्टर योलो से नीच नहीं है और बॉक्स से बाहर एनसीएस पर काम करता है।

कैसे Mobilenet-SSD डिटेक्टर काम करता है

चलिए शुरुआत मोबिलनेट से करते हैं। इसमें वास्तुकला पूर्ण है

ग ु न ा

$3 \ गुना 3$ दृढ़ संकल्प (सभी चैनलों पर) को दो हल्के संकल्पों द्वारा प्रतिस्थापित किया जाता है: पहला

ग ु न ा

$3 \ गुना 3$ प्रत्येक चैनल के लिए अलग से और फिर पूरा

ग ु न ा

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

SSD (सिंगल शॉट डिटेक्टर) इस तरह से काम करता है: कई कन्वेन्शन के आउटपुट पर एन्कोडर दो में लटका दिए जाते हैं

ग ु न ा

$1 \ गुना 1$ ऐंठन परत: एक वर्गों की संभावनाओं की भविष्यवाणी करता है, अन्य - बाउंडिंग बॉक्स के निर्देशांक। एक तीसरी परत है जो वर्तमान स्तर पर डिफ़ॉल्ट फ़्रेम के निर्देशांक और स्थिति प्रदान करती है। इसका अर्थ है: किसी भी परत का उत्पादन स्वाभाविक रूप से कोशिकाओं में विभाजित होता है; तंत्रिका नेटवर्क के अंत के करीब, वे छोटे होते जा रहे हैं (इस मामले में, stride=2 साथ stride=2 विश्वास के कारण), और प्रत्येक कोशिका के देखने के क्षेत्र में वृद्धि होती है। कई चयनित परतों में से प्रत्येक पर प्रत्येक सेल के लिए, हम अलग-अलग आकारों के कई डिफ़ॉल्ट फ्रेम और अलग-अलग पहलू अनुपातों के साथ सेट करते हैं, और प्रत्येक ऐसे फ्रेम के लिए निर्देशांक को सही करने और कक्षा की संभावनाओं की भविष्यवाणी करने के लिए अतिरिक्त प्रासंगिक परतों का उपयोग करते हैं। इसलिए, एक SSD डिटेक्टर (YOLO की तरह) हमेशा एक ही नंबर के फ्रेम पर विचार करता है। अलग-अलग परतों पर एक ही वस्तु का पता लगाया जा सकता है: प्रशिक्षण के दौरान, संकेत को सभी फ़्रेमों में भेजा जाता है जो ऑब्जेक्ट को बहुत दृढ़ता से प्रतिच्छेद करते हैं, और आवेदन के दौरान, गैर-अधिकतम दमन (एनएमएस) का उपयोग करते हुए डिटेक्टरों को जोड़ दिया जाता है। अंतिम परत सभी परतों से संयोजनों को जोड़ती है, उनके पूर्ण निर्देशांक पर विचार करती है, संभाव्यता की सीमा को काटती है और एनएमएस का उत्पादन करती है।

डिटेक्टर प्रशिक्षण

आर्किटेक्चर

डिटेक्टर को प्रशिक्षित करने के लिए कोड यहाँ स्थित है ।

मैंने PASCAL VOC0712 पर प्रशिक्षित मोबिलनेट-एसएसडी डिटेक्टर का उपयोग करने का फैसला किया और इसे चेहरे का पता लगाने के लिए प्रशिक्षित किया। सबसे पहले, यह नेट को बहुत तेजी से प्रशिक्षित करने में मदद करता है, और दूसरी बात, आपको पहिया को फिर से लगाना नहीं है।

मूल परियोजना में gen.py स्क्रिप्ट शामिल थी, जिसने इनपुट मापदंडों को प्रतिस्थापित करते हुए, .prototxt मॉडल फ़ाइल को शाब्दिक रूप से एकत्र किया था। मैंने इसे अपनी परियोजना में स्थानांतरित कर दिया, कार्यक्षमता को थोड़ा बढ़ा दिया। यह स्क्रिप्ट आपको चार प्रकार की कॉन्फ़िगरेशन फ़ाइल जनरेट करने की अनुमति देती है:

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

मैंने बाद के विकल्प को जोड़ा, ताकि स्क्रिप्ट में आप LMDB डेटाबेस को छूने के बिना BatchNorm से ग्रिड को लोड और परिवर्तित कर सकें - अन्यथा, डेटाबेस की अनुपस्थिति में, कुछ भी काम नहीं करेगा। (सामान्य तौर पर, यह मुझे अजीब लगता है कि कैफ में डेटा स्रोत नेटवर्क आर्किटेक्चर में सेट है - यह कम से कम बहुत व्यावहारिक नहीं है)।

नेटवर्क आर्किटेक्चर कैसा दिखता है (लघु)

लॉग इन: $300 \ गुना 300 \ गुना 3$
पूर्ण सजा दी गई सजा : 32 चैनल, stride=2
Mobilenet convolution conv1 - conv11 : 64, 128, 128, 256, 256, 512 ... 512 चैनल, कुछ के पास है * stride=2
डिटेक्शन लेयर: $19 \ गुना 19 \ गुना 512$
Mobilenet convolution conv12, conv13 : 1024 चैनल, conv12 में stride=2
डिटेक्शन लेयर: $10 \ गुना 10 \ गुना 1024$
पूर्ण विक्षेप conv14_1, conv14_2 : 256, 512 चैनल, पहला kernel_size=1 , दूसरा stride=2
डिटेक्शन लेयर: $5 \ गुना 5 \ गुना 512$
पूर्ण विक्षेप conv15_1, conv15_2 : 128, 256 चैनल, पहला kernel_size=1 , दूसरा stride=2
डिटेक्शन लेयर: $3 \ गुना 3 \ गुना 256$
पूरा conv16_1, conv16_2 संकल्प : 128, 256 चैनल, पहला kernel_size=1 , दूसरा stride=2
डिटेक्शन लेयर: $2 \ टाइम्स 2 \ गुना 256$
पूर्ण विक्षेप conv17_1, conv17_2 : 64, 128 चैनल, पहला kernel_size=1 , दूसरा stride=2
डिटेक्शन लेयर: $1 \ गुना 1 \ गुना 128$
अंतिम परत डिटेक्शन आउटपुट

मैंने नेटवर्क आर्किटेक्चर को थोड़ा ठीक किया। परिवर्तनों की सूची:

जाहिर है, कक्षाओं की संख्या 1 में बदल गई (पृष्ठभूमि की गिनती नहीं)।
प्रशिक्षण के दौरान कट पैच के पहलू अनुपात पर सीमाएं: से बदल दी गईं $[0.5,2.0]$ पर $[0.7,1.4]$ (मैंने कार्य को थोड़ा सरल बनाने का फैसला किया और बहुत अधिक खींची गई तस्वीरों से नहीं सीखा)।
डिफ़ॉल्ट फ़्रेम में, केवल वर्ग वाले बने रहे, प्रत्येक सेल के लिए दो। मैंने उनके आकार को बहुत कम कर दिया है, क्योंकि चेहरे शास्त्रीय वस्तु का पता लगाने की समस्या में वस्तुओं की तुलना में काफी छोटा है।

कैफ़े डिफ़ॉल्ट फ्रेम आकार की गणना निम्नानुसार करता है: न्यूनतम फ्रेम आकार

$एस$ और अधिकतम

$एल$ , यह आयामों के साथ एक छोटा और बड़ा फ्रेम बनाता है

$एस$ और

$\ sqrt {sL}$ । चूंकि मैं यथासंभव छोटे चेहरों का पता लगाना चाहता था, इसलिए मैंने प्रत्येक पहचान परत के लिए पूर्ण stride गणना की और इसे न्यूनतम फ्रेम आकार के बराबर किया। इन मापदंडों के साथ, छोटे डिफ़ॉल्ट फ्रेम एक दूसरे के करीब स्थित होंगे और प्रतिच्छेद नहीं करेंगे। तो हम कम से कम एक गारंटी है कि वस्तु के साथ प्रतिच्छेदन किसी तरह के ढांचे के लिए मौजूद होगा। मैंने अधिकतम आकार दो बार जितना निर्धारित किया है। Conv16_2, conv17_2 की परतों के लिए , मैंने आंखों पर समान होने के लिए आयाम निर्धारित किए हैं। इस तरह से

$एस, एल$ सभी परतों के लिए थे:

$(16.32), (32.64), (64,128), (128,214), (214,300), (214,300)$

कुछ डिफ़ॉल्ट फ़्रेम कैसे दिखते हैं (स्पष्टता के लिए शोर)

डेटा

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

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

प्रशिक्षण और परीक्षण के लिए उनका उपयोग करने के लिए, आपको उनसे LMDB आधार को इकट्ठा करने की आवश्यकता है। यह कैसे करें:

प्रत्येक छवि के लिए, मार्कअप को .xml प्रारूप में बनाया जाता है।
एक train.txt फाइल "path/to/image.png path/to/labels.xml" लाइनों के साथ बनाई गई है, परीक्षण के लिए बनाई गई है।
एक test_name_size.txt फ़ाइल "test_image_name height width" फ़ॉर्म की पंक्तियों के साथ test_name_size.txt
संख्यात्मक labelmap.prototxt मैचों के साथ एक labelmap.prototxt फ़ाइल बनाता है

ssd-caffe/scripts/create_annoset.py (Makefile से उदाहरण):

 python3 /opt/movidius/ssd-caffe/scripts/create_annoset.py --anno-type=detection \ --label-map-file=$(wider_dir)/labelmap.prototxt --min-dim=0 --max-dim=0 \ --resize-width=0 --resize-height=0 --check-label --encode-type=jpg --encoded \ --redo $(wider_dir) \ $(wider_dir)/trainval.txt $(wider_dir)/WIDER_train/lmdb/wider_train_lmdb ./data

labelmap.prototxt

 item { name: "none_of_the_above" label: 0 display_name: "background" } item { name: "face" label: 1 display_name: "face" }

उदाहरण .xml मार्कअप

 <?xml version="1.0" ?> <annotation> <size> <width>348</width> <height>450</height> <depth>3</depth> </size> <object> <name>face</name> <bndbox> <xmin>161</xmin> <ymin>43</ymin> <xmax>241</xmax> <ymax>123</ymax> </bndbox> </object> </annotation>

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

उसके बाद, आप प्रशिक्षण शुरू कर सकते हैं।

ट्रेनिंग

मॉडल प्रशिक्षण के लिए कोड मेरे कोलाब नोटबुक में पाया जा सकता है।

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

कोलैबोरेटरी में एक और विशेषता है: 12 घंटों के बाद, कार मर जाती है, स्थायी रूप से सभी डेटा मिटा देती है। डेटा हानि से बचने का सबसे अच्छा तरीका है कि आप सिस्टम में अपनी Google डिस्क को माउंट करें और हर 500-1000 प्रशिक्षण पुनरावृत्तियों में नेटवर्क भार को बचाएं।

मेरे डिटेक्टर के रूप में, एक सत्र में कोलैबोरेटरी में वह 4,500 पुनरावृत्तियों को अनसुना करने में कामयाब रहे, और दो सत्रों में पूरी तरह से प्रशिक्षित थे।

परीक्षण डेटा पर भविष्यवाणियों (औसत औसत परिशुद्धता) की गुणवत्ता जो मैंने ऊपर सूचीबद्ध प्रतिबंधों के साथ उजागर की (विलय और एफडीडीबी विलय) सबसे अच्छे मॉडल के लिए लगभग 0.87 थी। प्रशिक्षण के दौरान सहेजे गए तराजू पर एमएपी मापने के लिए, एक स्क्रिप्ट scripts/plot_map.py ।

डिटेक्टर एक डाटासेट से (बहुत अजीब) उदाहरण पर काम करता है:

एनसीएस पर लॉन्च

एक फेस डिटेक्शन डेमो यहां है ।

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

डिटेक्टर को प्रशिक्षित करने के बाद, तंत्रिका नेटवर्क को गति देने के लिए आसन्न संकल्प के साथ बैचमॉर्म परतों को विलय करने के लायक है। merge_bn.py स्क्रिप्ट यहां से होती है , जिसे मैंने मोबिलनेट-एसएसडी प्रोजेक्ट से भी उधार लिया था।

फिर आपको उदाहरण के लिए mvNCCompile उपयोगिता को कॉल करने की आवश्यकता है:

 mvNCCompile -s 12 -o graph_ssd -w ssd-face.caffemodel ssd-face.prototxt

प्रोजेक्ट के graph_ssd लिए एक graph_ssd लक्ष्य है। परिणामस्वरूप graph_ssd फ़ाइल एनसीएस द्वारा समझे गए प्रारूप में एक तंत्रिका नेटवर्क विवरण है।

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

सीरियल नंबर द्वारा डिवाइस डिस्क्रिप्टर प्राप्त करें
डिवाइस खोलें
बफर में संकलित तंत्रिका नेटवर्क फ़ाइल पढ़ें (बाइनरी फ़ाइल के रूप में)
NCS के लिए एक खाली गणना ग्राफ़ बनाएँ
फ़ाइल से डेटा का उपयोग करके डिवाइस पर ग्राफ रखें और इनपुट / आउटपुट पर इसके लिए फीफो का चयन करें; फ़ाइल सामग्री के साथ बफर को अब मुक्त किया जा सकता है
डिटेक्टर शुरू:
- कैमरे से छवि प्राप्त करें (या किसी अन्य स्रोत से)
- इसे संसाधित करें: वांछित आकार के पैमाने, फ्लोट 32 में बदलें और रेंज में ले जाएँ [-1,1]
- डिवाइस और अनुरोध के लिए छवि अपलोड करें
- परिणाम का अनुरोध करें (परिणाम प्राप्त होने तक कार्यक्रम अवरुद्ध हो जाएगा)
- परिणाम को पार्स करें, ऑब्जेक्ट के फ्रेम का चयन करें (प्रारूप के बारे में - आगे)
- पूर्वानुमान प्रदर्शित करें
सभी संसाधन मुक्त करें: फीफो और गणना ग्राफ को हटा दें, डिवाइस को बंद करें और इसके हैंडल को हटा दें

एनसीएस के साथ लगभग हर क्रिया का अपना अलग कार्य होता है, और सी ++ में यह बहुत बोझिल लगता है, और आपको सभी संसाधनों की रिहाई की सावधानीपूर्वक निगरानी करनी होगी। कोड को अधिभार नहीं देने के लिए, मैंने NCS के साथ काम करने के लिए एक आवरण वर्ग बनाया। इसमें, निर्माण और load_file फ़ंक्शन में, और संसाधनों की रिहाई पर सभी प्रारंभिककरण कार्य छिपा हुआ है - विध्वंसक में, और एनसीएस के साथ काम करना 2-3 क्लास विधियों को कॉल करने के लिए कम हो जाता है। इसके अलावा, हुई त्रुटियों को समझाने के लिए एक सुविधाजनक कार्य है।

निर्माणकर्ता को इनपुट आकार और आउटपुट आकार (तत्वों की संख्या) पास करके एक आवरण बनाएँ:

 NCSWrapper NCS(NETWORK_INPUT_SIZE*NETWORK_INPUT_SIZE*3, NETWORK_OUTPUT_SIZE);

हम तंत्रिका नेटवर्क के साथ संकलित फ़ाइल को लोड करते हैं, साथ ही साथ उस सब कुछ को आरंभ करते हैं जो हमें चाहिए:

 if (!NCS.load_file("./models/face/graph_ssd")) { NCS.print_error_code(); return 0; }

हम इमेज को फ्लोट 32 में बदलते हैं ( image cv::Mat प्रारूप CV_32FC3 में cv::Mat है) और इसे डिवाइस पर डाउनलोड करें:

 if(!NCS.load_tensor_nowait((float*)image.data)) { NCS.print_error_code(); break; }

हम परिणाम प्राप्त करते हैं ( result एक मुक्त float सूचक है, परिणाम बफर आवरण द्वारा समर्थित है); गणना के अंत तक, कार्यक्रम अवरुद्ध है:

 if(!NCS.get_result(result)) { NCS.print_error_code(); break; }

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

परिणामस्वरूप डिटेक्टर 7*(keep_top_k+1) आकार का फ्लोट सरणी देता है 7*(keep_top_k+1) । यहां, keep_top_k मॉडल की .prototxt फ़ाइल में निर्दिष्ट पैरामीटर है और यह दिखा रहा है कि कितने डिटेक्शन (घटते आत्मविश्वास के क्रम में) को वापस किया जाना चाहिए। यह पैरामीटर, साथ ही न्यूनतम आत्मविश्वास मान द्वारा फ़िल्टरिंग फ़िल्टर के लिए जिम्मेदार पैरामीटर, और गैर-अधिकतम दमन मापदंडों को मॉडल की .prototxt फ़ाइल में बहुत अंतिम परत में कॉन्फ़िगर किया जा सकता है। यह ध्यान देने योग्य है कि यदि कैफ छवि में पाया गया था, तो एनसीएस हमेशा के लिए लौटता है, तो एनसीएस हमेशा keep_top_k पता keep_top_k ताकि सरणी आकार स्थिर हो।

परिणाम सरणी स्वयं ही निम्न प्रकार से keep_top_k+1 है: यदि हम इसे keep_top_k+1 पंक्तियों और 7 स्तंभों के साथ एक मैट्रिक्स के रूप में मानते हैं, तो पहली पंक्ति में, पहली तत्व में डिटेक्टरों की संख्या होगी, और दूसरी पंक्ति से शुरू होने वाले प्रारूप "garbage, class_index, class_probability, x_min, y_min, x_max, y_max" में खुद को बंद कर दिया जाएगा। "garbage, class_index, class_probability, x_min, y_min, x_max, y_max" । निर्देशांक सीमा [0,1] में निर्दिष्ट हैं, इसलिए उन्हें छवि की ऊंचाई / चौड़ाई से गुणा करने की आवश्यकता होगी। सरणी के शेष तत्व कचरा होंगे। इस मामले में, परिणाम प्राप्त होने से पहले ही गैर-अधिकतम दमन स्वचालित रूप से किया जाता है (ऐसा लगता है, एनसीएस पर सही है)।

पता लगानेवाला

 void get_detection_boxes(float* predictions, int w, int h, float thresh, std::vector<float>& probs, std::vector<cv::Rect>& boxes) { int num = predictions[0]; float score = 0; float cls = 0; for (int i=1; i<num+1; i++) { score = predictions[i*7+2]; cls = predictions[i*7+1]; if (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)); } } }

रास्पबेरी पाई लॉन्च सुविधाएँ

डेमो प्रोग्राम को नियमित कंप्यूटर या लैपटॉप पर उबंटू के साथ या रास्पबेरी स्ट्रेच के साथ रास्पबेरी पाई पर चलाया जा सकता है। मैं एक रास्पबेरी पाई 2 मॉडल बी का उपयोग कर रहा हूं, लेकिन डेमो को अन्य मॉडलों पर भी काम करना चाहिए। प्रोजेक्ट के मेकफाइल में स्विचिंग मोड के लिए दो लक्ष्य होते हैं: कंप्यूटर / लैपटॉप के लिए make switch_desk make switch_rpi और रास्पबेरी पाई के लिए make switch_rpi । प्रोग्राम कोड में मूलभूत अंतर यह है कि पहले मामले में, OpenCV का उपयोग कैमरे से डेटा पढ़ने के लिए किया जाता है, और दूसरे मामले में, RaspiCam लाइब्रेरी। रास्पबेरी पर डेमो चलाने के लिए, आपको इसे संकलित और स्थापित करना होगा।

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

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

यह भी ध्यान में रखने योग्य है कि निष्पादन की गति यूएसबी के विभिन्न संस्करणों के लिए अलग-अलग होगी (इस विशेष तंत्रिका नेटवर्क के लिए: यूएसबी 3.0 के लिए 102 एमएस, यूएसबी 2.0 के लिए 92 एमएस)।

अब NCS की शक्ति के बारे में। प्रलेखन के अनुसार, यह 1 वाट तक खपत करता है (यूएसबी कनेक्टर पर 5 वोल्ट पर यह 200 एमए तक होगा; तुलना के लिए: रास्पबेरी कैमरा 250 एमए तक की खपत करता है)। जब एक नियमित 5 वोल्ट चार्जर, 2 एम्पीयर द्वारा संचालित किया जाता है, तो सब कुछ बहुत अच्छा काम करता है। हालांकि, रास्पबेरी के लिए दो या अधिक एनसीएस को जोड़ने की कोशिश करने से समस्याएं हो सकती हैं। इस मामले में, बाहरी शक्ति की संभावना के साथ एक यूएसबी फाड़नेवाला का उपयोग करने की सिफारिश की जाती है।

रास्पबेरी पर, डेमो कंप्यूटर / लैपटॉप की तुलना में धीमा है: 7.2 एफपीएस बनाम 10.4 एफपीएस। यह कई कारकों के कारण है: सबसे पहले, सीपीयू पर गणना से छुटकारा पाना असंभव है, लेकिन उन्हें बहुत अधिक धीरे-धीरे प्रदर्शन किया जाता है; दूसरी बात, डेटा ट्रांसफर स्पीड प्रभावित होती है (USB 2.0 के लिए)।

इसके अलावा, तुलना के लिए, मैंने अपने पहले लेख से रास्पबेरी YOLOv2 पर एक फेस डिटेक्टर चलाने की कोशिश की, लेकिन इसने बहुत खराब तरीके से काम किया: 3.6 एफपीएस की गति से, यह साधारण फ्रेम पर भी बहुत सारे चेहरे याद करता है। जाहिरा तौर पर, यह इनपुट छवि के मापदंडों के प्रति बहुत संवेदनशील है, जिसकी गुणवत्ता रास्पबेरी कैमरे के मामले में आदर्श से बहुत दूर है। SSD अधिक स्थिर रूप से काम करता है, हालाँकि मुझे वीडियो सेटिंग्स को रॅपिकैम सेटिंग्स में थोड़ा मोड़ना था। वह भी कभी-कभी फ्रेम में चेहरों को याद करता है, लेकिन ऐसा बहुत कम ही होता है। वास्तविक अनुप्रयोगों में स्थिरता बढ़ाने के लिए, आप एक साधारण सेंट्रो ट्रैकर जोड़ सकते हैं।

वैसे: पायथन में एक ही चीज़ को पुन: पेश किया जा सकता है, PyImageSearch पर एक ट्यूटोरियल है (Mobilenet-SSD का उपयोग ऑब्जेक्ट डिटेक्शन कार्य के लिए किया जाता है)।

अन्य विचार

मैंने स्वयं तंत्रिका नेटवर्क को गति देने के लिए कुछ विचारों का परीक्षण किया:

पहला विचार: आप केवल परतों का पता लगा सकते हैं conv11 और conv13 , और सभी अतिरिक्त परतों को हटा सकते हैं। आपको एक डिटेक्टर मिलेगा जो केवल छोटे चेहरे का पता लगाता है और थोड़ी तेजी से काम करता है। सब सब में, इसके लायक नहीं।

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

निष्कर्ष

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

वीडियो पर फेस डिटेक्शन: रास्पबेरी पाई और न्यूरल कम्प्यूट स्टिक