👰 👨‍❤️‍👨 🏹 YOLOv3 का उपयोग करके iOS पर रियल-टाइम ऑब्जेक्ट मान्यता 🌛 ✌🏻 🌰

सभी को नमस्कार!

इस लेख में हम वास्तविक समय में वस्तु पहचान और मान्यता (ऑब्जेक्ट डिटेक्शन) की समस्या को हल करने के लिए एक छोटा सा कार्यक्रम लिखेंगे। कार्यक्रम आईओएस प्लेटफॉर्म के लिए स्विफ्ट प्रोग्रामिंग भाषा में लिखा जाएगा। वस्तुओं का पता लगाने के लिए, हम YOLOv3 नामक एक वास्तुकला के साथ एक दृढ़ तंत्रिका नेटवर्क का उपयोग करेंगे। इस लेख में, हम सीखेंगे कि CoreML फ्रेमवर्क का उपयोग करके तंत्रिका नेटवर्क के साथ iOS में कैसे काम करें, YOLOv3 नेटवर्क क्या है और इस नेटवर्क के आउटपुट का उपयोग और संसाधित करने की थोड़ी समझ है। हम कार्यक्रम के संचालन की भी जाँच करेंगे और YOLOv3 के कई रूपों की तुलना करेंगे: YOLOv3- छोटे और YOLOv3-416।

लेख के अंत में स्रोत उपलब्ध होंगे, इसलिए हर कोई अपने डिवाइस पर तंत्रिका नेटवर्क के संचालन का परीक्षण करने में सक्षम होगा।

वस्तु का पता लगाना

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

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

ऑब्जेक्ट मान्यता के लिए लोकप्रिय सीएनएन आर्किटेक्चर:

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

इस लेख में, हम योलो वास्तुकला का उपयोग करेंगे, अर्थात् इसका नवीनतम संशोधन, योलोव ३।

क्यों YOLO?

YOLO या यू ओनली लुक वन्स एक बार CNN की बहुत लोकप्रिय वास्तुकला है, जिसका उपयोग किसी चित्र में कई वस्तुओं को पहचानने के लिए किया जाता है। इसके बारे में अधिक पूरी जानकारी आधिकारिक वेबसाइट पर प्राप्त की जा सकती है, उसी स्थान पर आप प्रकाशन पा सकते हैं जिसमें इस नेटवर्क के सिद्धांत और गणितीय घटक के बारे में विस्तार से बताया गया है, साथ ही इसके प्रशिक्षण की प्रक्रिया का वर्णन किया गया है।

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

इस दृष्टिकोण का लाभ यह है कि नेटवर्क एक बार में पूरी छवि को देखता है और किसी वस्तु का पता लगाने और पहचानने के दौरान संदर्भ को ध्यान में रखता है। YOLO भी R-CNN से 1000 गुना तेज़ है और Fast R-CNN से लगभग 100 गुना तेज़ है। इस लेख में, हम ऑनलाइन प्रसंस्करण के लिए एक मोबाइल डिवाइस पर एक नेटवर्क लॉन्च करेंगे, इसलिए यह हमारे लिए सबसे महत्वपूर्ण गुण है।

आर्किटेक्चर की तुलना करने के बारे में अधिक विस्तृत जानकारी यहां पाई जा सकती है ।

YOLOv3

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

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

हम वस्तु मान्यता के लिए एक कार्यक्रम लिख रहे हैं

मज़ा हिस्सा शुरू होता है!

आइए एक एप्लिकेशन बनाएं जो फोन के कैमरे का उपयोग करके वास्तविक समय में छवि में विभिन्न वस्तुओं को पहचान लेगा। सभी कोड स्विफ्ट 4.2 प्रोग्रामिंग भाषा में लिखे जाएंगे और एक आईओएस डिवाइस पर चलेंगे।

इस ट्यूटोरियल में हम एक तैयार नेटवर्क तैयार करेंगे जिसमें तराजू को एक COCO डेटासेट पर पहले से प्रशिक्षित किया गया है। यह 80 विभिन्न वर्गों को प्रस्तुत करता है। इसलिए, हमारे न्यूरॉन 80 विभिन्न वस्तुओं को पहचानने में सक्षम होंगे।

Darknet से CoreML तक

मूल YOLOv3 आर्किटेक्चर डार्कनेट फ्रेमवर्क का उपयोग करके कार्यान्वित किया गया है।

IOS पर, संस्करण 11.0 से शुरू होकर, एक अद्भुत CoreML लाइब्रेरी है जो आपको मशीन लर्निंग मॉडल को सीधे डिवाइस पर चलाने की अनुमति देती है। लेकिन एक सीमा है: कार्यक्रम केवल iOS 11 और इसके बाद के संस्करण पर चलने वाले डिवाइस पर चलाया जा सकता है।

समस्या यह है कि CoreML केवल .coreml मॉडल के विशिष्ट प्रारूप को समझता है। अधिकांश लोकप्रिय पुस्तकालयों, जैसे कि टेनसफ़्लो, केरस या एक्सजीबोस्ट के लिए, सीधे कोरएमएल प्रारूप में परिवर्तित करना संभव है। लेकिन डार्कनेट के लिए ऐसी कोई संभावना नहीं है। Darknet से CoreML में सहेजे गए और प्रशिक्षित मॉडल को परिवर्तित करने के लिए, आप विभिन्न विकल्पों का उपयोग कर सकते हैं, उदाहरण के लिए, Darknet को ONNX पर सहेजें , और फिर इसे ONNX से CoreML में परिवर्तित करें।

हम एक सरल तरीके का उपयोग करेंगे और हम YOLOv3 के Keras कार्यान्वयन का उपयोग करेंगे। एक्शन का एल्गोरिदम यह है: डार्कनेट वेट्स को केरस मॉडल में लोड करें, इसे केरस फॉर्मेट में सेव करें और सीधे इसे कोरएमएल से इसे कन्वर्ट करें।

डाउनलोड करें डार्कनेट। यहां से प्रशिक्षित Darknet-YOLOv3 मॉडल की फाइलें डाउनलोड करें । इस लेख में, मैं दो आर्किटेक्चर का उपयोग करूंगा: YOLOv3-416 और YOLOv3- छोटे। हम दोनों cfg और वजन फ़ाइलों की आवश्यकता होगी।
डार्कनेट से लेकर केरेस तक। सबसे पहले, रिपॉजिटरी को क्लोन करें, रेपो फ़ोल्डर में जाएं और कमांड चलाएँ:
```
python convert.py yolov3.cfg yolov3.weights yolo.h5 
```
जहां yolov3.cfg और yolov3.weights ने Darknet फाइलें डाउनलोड की हैं। नतीजतन, हमारे पास एक्सटेंशन के साथ एक फ़ाइल होनी चाहिए। 5 - यह केआरएएस प्रारूप में सहेजी गई YOLOv3 मॉडल है।
करेस से कोरमल तक। आखिरी चरण बना रहा। मॉडल को CoreML में बदलने के लिए, आपको पायथन स्क्रिप्ट को चलाने की आवश्यकता है (आपको पहले अजगर के लिए कॉरम्स्टूल लाइब्रेरी स्थापित करना होगा):
```
 import coremltools coreml_model = coremltools.converters.keras.convert( 'yolo.h5', input_names='image', image_input_names='image', input_name_shape_dict={'image': [None, 416, 416, 3]}, #      image_scale=1/255.) coreml_model.input_description['image'] = 'Input image' coreml_model.save('yolo.mlmodel') 
```

ऊपर वर्णित चरणों को दो मॉडल YOLOv3-416 और YOLOv3- छोटे के लिए किया जाना चाहिए।
जब हमने यह सब किया, तो हमारे पास दो फाइलें हैं: yolo.mlmodel और yolo-small.mlmodel। अब आप आवेदन का कोड लिखना शुरू कर सकते हैं।

IOS ऐप बनाना

मैंने सभी एप्लिकेशन कोड का वर्णन नहीं किया है, आप इसे रिपॉजिटरी में देख सकते हैं, एक लिंक जिसे लेख के अंत में दिया जाएगा। मुझे केवल यह कहने दें कि हमारे पास तीन UIViewController-a: OnlineViewController, PhotoViewController और SettingsViewController हैं। पहला कैमरा का आउटपुट है और प्रत्येक फ्रेम के लिए ऑब्जेक्ट का ऑनलाइन पता लगाना है। दूसरे में, आप एक तस्वीर ले सकते हैं या गैलरी से एक तस्वीर का चयन कर सकते हैं और इन चित्रों पर नेटवर्क का परीक्षण कर सकते हैं। तीसरे में सेटिंग्स हैं, आप YOLOv3-416 या YOLOv3- छोटे मॉडल का चयन कर सकते हैं, साथ ही थ्रेसहोल्ड IoU (यूनियन पर चौराहा) और ऑब्जेक्ट कॉन्फिडेंस (वर्तमान छवि अनुभाग में ऑब्जेक्ट होने की संभावना) का चयन कर सकते हैं।

CoreML में लोड हो रहे मॉडल

हमने डार्कनेट प्रारूप से प्रशिक्षित मॉडल को CoreML में बदलने के बाद, हमारे पास एक्सटेंशन .mlmodel के साथ एक फ़ाइल है। मेरे मामले में, मैंने क्रमशः YOLOv3-416 और YOLOv3- छोटे मॉडल के लिए दो फाइलें बनाईं : yolo.mlmodel और yolo-small.mlmodel । अब आप इन फ़ाइलों को Xcode में एक प्रोजेक्ट में लोड कर सकते हैं।

हम मॉडलप्रॉइडर वर्ग बनाते हैं, यह वर्तमान मॉडल और विधियों को अतुल्यकालिक रूप से निष्पादन के लिए तंत्रिका नेटवर्क को संचित करेगा। मॉडल को इस तरह से लोड किया गया है:

  private func loadModel(type: YOLOType) { do { self.model = try YOLO(type: type) } catch { assertionFailure("error creating model") } }

YOLO वर्ग सीधे .mlmodel फ़ाइलों को लोड करने और मॉडल आउटपुट को संभालने के लिए जिम्मेदार है। डाउनलोड मॉडल फ़ाइलें:

  var url: URL? = nil self.type = type switch type { case .v3_Tiny: url = Bundle.main.url(forResource: "yolo-tiny", withExtension:"mlmodelc") self.anchors = tiny_anchors case .v3_416: url = Bundle.main.url(forResource: "yolo", withExtension:"mlmodelc") self.anchors = anchors_416 } guard let modelURL = url else { throw YOLOError.modelFileNotFound } do { model = try MLModel(contentsOf: modelURL) } catch let error { print(error) throw YOLOError.modelCreationError }

पूर्ण ModelProvider कोड।

 import UIKit import CoreML protocol ModelProviderDelegate: class { func show(predictions: [YOLO.Prediction]?, stat: ModelProvider.Statistics, error: YOLOError?) } @available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *) class ModelProvider { struct Statistics { var timeForFrame: Float var fps: Float } static let shared = ModelProvider(modelType: Settings.shared.modelType) var model: YOLO! weak var delegate: ModelProviderDelegate? var predicted = 0 var timeOfFirstFrameInSecond = CACurrentMediaTime() init(modelType type: YOLOType) { loadModel(type: type) } func reloadModel(type: YOLOType) { loadModel(type: type) } private func loadModel(type: YOLOType) { do { self.model = try YOLO(type: type) } catch { assertionFailure("error creating model") } } func predict(frame: UIImage) { DispatchQueue.global().async { do { let startTime = CACurrentMediaTime() let predictions = try self.model.predict(frame: frame) let elapsed = CACurrentMediaTime() - startTime self.showResultOnMain(predictions: predictions, elapsed: Float(elapsed), error: nil) } catch let error as YOLOError { self.showResultOnMain(predictions: nil, elapsed: -1, error: error) } catch { self.showResultOnMain(predictions: nil, elapsed: -1, error: YOLOError.unknownError) } } } private func showResultOnMain(predictions: [YOLO.Prediction]?, elapsed: Float, error: YOLOError?) { if let delegate = self.delegate { DispatchQueue.main.async { let fps = self.measureFPS() delegate.show(predictions: predictions, stat: ModelProvider.Statistics(timeForFrame: elapsed, fps: fps), error: error) } } } private func measureFPS() -> Float { predicted += 1 let elapsed = CACurrentMediaTime() - timeOfFirstFrameInSecond let currentFPSDelivered = Double(predicted) / elapsed if elapsed > 1 { predicted = 0 timeOfFirstFrameInSecond = CACurrentMediaTime() } return Float(currentFPSDelivered) } }

तंत्रिका नेटवर्क आउटपुट प्रसंस्करण

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

प्रवेश करें और YOLOv3- छोटे से बाहर निकलें।

प्रवेश और YOLOv3-416 से बाहर निकलें।

जैसा कि आप ऊपर की छवि में देख सकते हैं, हमारे पास YOLOv3-416 के लिए तीन और YOLOv3- छोटे आउटपुट परतों के लिए दो हैं, जिनमें से प्रत्येक में विभिन्न वस्तुओं के लिए बाउंडिंग बॉक्स की भविष्यवाणी की गई है।
इस मामले में, यह संख्याओं का एक नियमित सरणी है, आइए जानें कि इसे पार्स कैसे किया जाए।

YOLOv3 मॉडल एक अलग ग्रिड में छवि को विभाजित करने के लिए आउटपुट के रूप में तीन परतों का उपयोग करता है, इन ग्रिडों के सेल आकार में निम्नलिखित मान हैं: 8, 16 और 32. मान लीजिए कि हमारे पास आकार में 416x416 पिक्सेल की छवि है, तो आउटपुट मैट्रिक्स (ग्रिड) का आकार 52x5252 होगा , 26x26 और 13x13 (416/8 = 52, 416/16 = 26 और 416/32 = 13)। YOLOv3- छोटे के मामले में, सब कुछ समान है, लेकिन तीन ग्रिडों के बजाय, हमारे पास दो: 16 और 32 हैं, अर्थात, 26x26 और 13x13 आयामों के मैट्रेस हैं।

लोड किए गए CoreML मॉडल को शुरू करने के बाद, हमें आउटपुट पर MLMultiArray वर्ग की दो (या तीन) वस्तुएं मिलती हैं। और यदि आप इन वस्तुओं के आकार की संपत्ति को देखते हैं, तो हम निम्नलिखित चित्र देखेंगे (YOLOv3- छोटे के लिए):

$[1, 1, 255, 26, 26] \\ [1, 1, 255, 13, 13]$

जैसा कि अपेक्षित था, मेट्रिक्स का आयाम 26x26 और 13x13 होगा। लेकिन संख्या 255 का क्या अर्थ होगा? जैसा कि पहले उल्लेख किया गया है, आउटपुट लेयर 52x52, 26x26 और 13x13 मैट्रिसेस हैं। तथ्य यह है कि इस मैट्रिक्स का प्रत्येक तत्व एक संख्या नहीं है, यह एक वेक्टर है। यही है, आउटपुट परत एक तीन-आयामी मैट्रिक्स है। इस वेक्टर में आयाम B x (5 + C) है, जहां B सेल में बाउंडिंग बॉक्स की संख्या है, C कक्षाओं की संख्या है। 5 नंबर कहां से आता है? इसका कारण यह है: प्रत्येक बॉक्स-ए के लिए, संभावना है कि एक वस्तु (ऑब्जेक्ट कॉन्फिडेंस) की भविष्यवाणी की गई है एक संख्या है, और शेष चार अनुमानित बॉक्स-ए के लिए x, y, चौड़ाई और ऊंचाई हैं। नीचे दिया गया आंकड़ा इस वेक्टर का एक योजनाबद्ध प्रतिनिधित्व दर्शाता है:

आउटपुट लेयर (फीचर मैप) का योजनाबद्ध प्रतिनिधित्व।

80 वर्गों में प्रशिक्षित हमारे नेटवर्क के लिए, 3 बाउंडिंग बॉक्स-ए में विभाजन ग्रिड के प्रत्येक सेल के लिए भविष्यवाणी की गई है, उनमें से प्रत्येक के लिए - 80 वर्ग संभावनाएं + ऑब्जेक्ट आत्मविश्वास + इस बॉक्स-ए की स्थिति और आकार के लिए जिम्मेदार 4 नंबर। कुल: 3 x (5 + 80) = 255

MLMultiArray वर्ग से इन मानों को प्राप्त करने के लिए, एक कच्चे सूचक को डेटा सरणी और पते के अंकगणित का उपयोग करना बेहतर है:

  let pointer = UnsafeMutablePointer<Double>(OpaquePointer(out.dataPointer)) //    if out.strides.count < 3 { throw YOLOError.strideOutOfBounds } let channelStride = out.strides[out.strides.count-3].intValue let yStride = out.strides[out.strides.count-2].intValue let xStride = out.strides[out.strides.count-1].intValue func offset(ch: Int, x: Int, y: Int) -> Int { //     return ch * channelStride + y * yStride + x * xStride }

अब आपको 255 तत्वों के वेक्टर को संसाधित करने की आवश्यकता है। प्रत्येक बॉक्स के लिए, आपको 80 वर्गों के लिए संभाव्यता वितरण प्राप्त करने की आवश्यकता है, आप सॉफ्टमैक्स फ़ंक्शन का उपयोग करके ऐसा कर सकते हैं।

सॉफ्टमैक्स क्या है

फ़ंक्शन एक वेक्टर को रूपांतरित करता है

$\ mathbb x$ आयाम K, एक ही आयाम के एक सदिश में, जहां प्रत्येक समन्वय करते हैं

$\ mathbb x_i$ परिणामी वेक्टर को अंतराल में एक वास्तविक संख्या [0,1] द्वारा दर्शाया गया है और निर्देशांक का योग 1 है।

स ि ग ् म ा

$\ _ सिग्मा (\ mathbb {x}) _ i = \ frac {e ^ {x_i}} {\ sum_ {k = 1} ^ {K} {e ^ {x_k}}}$

जहां K वेक्टर का आयाम है।

स्विफ्ट पर सॉफ्टमैक्स फ़ंक्शन:

  private func softmax(_ x: inout [Float]) { let len = vDSP_Length(x.count) var count = Int32(x.count) vvexpf(&x, x, &count) var sum: Float = 0 vDSP_sve(x, 1, &sum, len) vDSP_vsdiv(x, 1, &sum, &x, 1, len) }

बाउंडिंग-ए के निर्देशांक और आकार प्राप्त करने के लिए, आपको सूत्रों का उपयोग करने की आवश्यकता है:

$x = \ sigma (\ hat x) + c_x \\ y = \ sigma (\ hat y) + c_y \\ w = p_we ^ {\ hat w} \\ h = p_he ^ {hat h h}$

जहाँ

ह ह य ट ह व ॉ ट ह ै ट ह

$\ ह x, \ ह यट, \ ह वॉट, \ हैट ह$ - अनुमानित x, y निर्देशांक, चौड़ाई और ऊंचाई क्रमशः,

स ि ग ् म ा

$\ _ सिग्मा (x)$ सिग्मॉइड फ़ंक्शन है, और

$p_w, p_h$ - तीन बक्सों के लिए लंगर (लंगर) का मान। ये मान प्रशिक्षण के दौरान निर्धारित किए जाते हैं और Helpers.swift फ़ाइल में सेट किए जाते हैं:

 let anchors1: [Float] = [116,90, 156,198, 373,326] //     let anchors2: [Float] = [30,61, 62,45, 59,119] //     let anchors3: [Float] = [10,13, 16,30, 33,23] //

एक बाउंडिंग बॉक्स की स्थिति की गणना का योजनाबद्ध प्रतिनिधित्व।

आउटपुट लेयर्स की प्रोसेसिंग के लिए पूरा कोड।

  private func process(output out: MLMultiArray, name: String) throws -> [Prediction] { var predictions = [Prediction]() let grid = out.shape[out.shape.count-1].intValue let gridSize = YOLO.inputSize / Float(grid) let classesCount = labels.count print(out.shape) let pointer = UnsafeMutablePointer<Double>(OpaquePointer(out.dataPointer)) if out.strides.count < 3 { throw YOLOError.strideOutOfBounds } let channelStride = out.strides[out.strides.count-3].intValue let yStride = out.strides[out.strides.count-2].intValue let xStride = out.strides[out.strides.count-1].intValue func offset(ch: Int, x: Int, y: Int) -> Int { return ch * channelStride + y * yStride + x * xStride } for x in 0 ..< grid { for y in 0 ..< grid { for box_i in 0 ..< YOLO.boxesPerCell { let boxOffset = box_i * (classesCount + 5) let bbx = Float(pointer[offset(ch: boxOffset, x: x, y: y)]) let bby = Float(pointer[offset(ch: boxOffset + 1, x: x, y: y)]) let bbw = Float(pointer[offset(ch: boxOffset + 2, x: x, y: y)]) let bbh = Float(pointer[offset(ch: boxOffset + 3, x: x, y: y)]) let confidence = sigmoid(Float(pointer[offset(ch: boxOffset + 4, x: x, y: y)])) if confidence < confidenceThreshold { continue } let x_pos = (sigmoid(bbx) + Float(x)) * gridSize let y_pos = (sigmoid(bby) + Float(y)) * gridSize let width = exp(bbw) * self.anchors[name]![2 * box_i] let height = exp(bbh) * self.anchors[name]![2 * box_i + 1] for c in 0 ..< 80 { classes[c] = Float(pointer[offset(ch: boxOffset + 5 + c, x: x, y: y)]) } softmax(&classes) let (detectedClass, bestClassScore) = argmax(classes) let confidenceInClass = bestClassScore * confidence if confidenceInClass < confidenceThreshold { continue } predictions.append(Prediction(classIndex: detectedClass, score: confidenceInClass, rect: CGRect(x: CGFloat(x_pos - width / 2), y: CGFloat(y_pos - height / 2), width: CGFloat(width), height: CGFloat(height)))) } } } return predictions }

गैर अधिकतम दमन

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

एल्गोरिथ्म इस प्रकार है:

हम ऑब्जेक्ट से संबंधित उच्चतम संभावना वाले बाउंडिंग बॉक्स की तलाश कर रहे हैं।
हम सभी बाउंडिंग बॉक्स के माध्यम से चलते हैं जो इस वस्तु से संबंधित हैं।
हम उन्हें हटा देते हैं यदि पहले बाउंडिंग बॉक्स के साथ संघ (IoU) पर अंतर निर्दिष्ट सीमा से अधिक है।

IoU की गणना एक सरल सूत्र का उपयोग करके की जाती है:

अ ं त ः क ् ष े त ् र क ् ष े त ् र ए स ो स ि ए श न क ् ष े त ् र

$\ text {IoU} = \ frac {\ text {अंतःक्षेत्र क्षेत्र}} {\ text {एसोसिएशन क्षेत्र}}$

IoU की गणना।

  static func IOU(a: CGRect, b: CGRect) -> Float { let areaA = a.width * a.height if areaA <= 0 { return 0 } let areaB = b.width * b.height if areaB <= 0 { return 0 } let intersection = a.intersection(b) let intersectionArea = intersection.width * intersection.height return Float(intersectionArea / (areaA + areaB - intersectionArea)) }

गैर अधिकतम दमन।

  private func nonMaxSuppression(boxes: inout [Prediction], threshold: Float) { var i = 0 while i < boxes.count { var j = i + 1 while j < boxes.count { let iou = YOLO.IOU(a: boxes[i].rect, b: boxes[j].rect) if iou > threshold { if boxes[i].score > boxes[j].score { if boxes[i].classIndex == boxes[j].classIndex { boxes.remove(at: j) } else { j += 1 } } else { if boxes[i].classIndex == boxes[j].classIndex { boxes.remove(at: i) j = i + 1 } else { j += 1 } } } else { j += 1 } } i += 1 } }

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

यह भी ध्यान देने योग्य है कि मैंने ऑनलाइन छवियों को संसाधित करते समय बाउंडिंग बॉक्स का थोड़ा चौरसाई किया, इस मामले में यह पिछले 30 फ़्रेमों में अनुमानित वर्ग की स्थिति और आकार का सामान्य औसत है।

कार्यक्रम का परीक्षण

अब हम एप्लिकेशन का परीक्षण करते हैं।

एक बार फिर से आपको याद दिला दूं: एप्लिकेशन में तीन व्यूकंट्रोलर हैं, एक फोटो या स्नैपशॉट के प्रसंस्करण के लिए, एक ऑनलाइन वीडियो स्ट्रीम को संसाधित करने के लिए, और तीसरा नेटवर्क स्थापित करने के लिए।

तीसरे के साथ शुरू करते हैं। इसमें आप दो में से एक मॉडल YOLOv3- स्माल या YOLOv3-416 चुन सकते हैं, कॉन्फिडेंस थ्रेशोल्ड और IoU थ्रेशोल्ड चुन सकते हैं, आप ऑनलाइन एंटी-अलियासिंग को इनेबल या डिसेबल भी कर सकते हैं।

अब देखते हैं कि प्रशिक्षित न्यूरॉन वास्तविक छवियों के साथ कैसे काम करता है, इसके लिए हम गैलरी से एक तस्वीर लेते हैं और इसे नेटवर्क से गुजरते हैं। नीचे दी गई तस्वीर अलग सेटिंग्स के साथ YOLOv3- छोटे के परिणामों को दिखाती है।

YOLOv3- छोटे के विभिन्न ऑपरेटिंग मोड। बाईं तस्वीर ऑपरेशन के सामान्य मोड को दिखाती है। बीच पर - दहलीज IoU = 1 यानी। मानो गैर-अधिकतम दमन गायब है। दाईं ओर वस्तु आत्मविश्वास की कम सीमा है, अर्थात्। सभी संभव बाउंडिंग बॉक्स प्रदर्शित किए जाते हैं।

निम्नलिखित YOLOv3-416 का परिणाम है। आप देख सकते हैं कि, YOLOv3- छोटे की तुलना में, परिणामस्वरूप फ़्रेम अधिक सही हैं, साथ ही छवि में छोटी वस्तुओं को मान्यता दी जाती है, जो तीसरी आउटपुट परत के काम से मेल खाती है।

YOLOv3-416 का उपयोग करके छवि संसाधित की गई।

जब ऑनलाइन ऑपरेशन मोड चालू किया गया था, तो प्रत्येक फ्रेम को संसाधित किया गया था और इसके लिए एक भविष्यवाणी की गई थी, iPhone XS पर परीक्षण किए गए थे, इसलिए परिणाम दोनों नेटवर्क विकल्पों के लिए काफी स्वीकार्य था। YOLOv3- छोटे 23 - 25 एफपीएस से 30 - 32 एफपीएस, YOLOv3-416 - का औसत पैदा करता है। जिस डिवाइस पर यह परीक्षण किया गया था वह काफी उत्पादक है, इसलिए पहले के मॉडल पर परिणाम भिन्न हो सकते हैं, जिसमें निश्चित रूप से यह योलोव 3-छोटे का उपयोग करना बेहतर होता है। एक और महत्वपूर्ण बिंदु: yolo-छोटे.mlmodel (YOLOv3- छोटे) में लगभग 35 एमबी लगते हैं, जबकि yolo.mlmodel (YOLOv3 -16) का वजन लगभग 250 एमबी है, जो एक बहुत महत्वपूर्ण अंतर है।

निष्कर्ष

नतीजतन, एक iOS एप्लिकेशन को लिखा गया था कि तंत्रिका नेटवर्क की मदद से छवि में वस्तुओं को पहचान सकते हैं। हमने देखा कि कोरएमएल लाइब्रेरी के साथ कैसे काम करना है और विभिन्न पूर्व-प्रशिक्षित मॉडलों को निष्पादित करने के लिए इसका उपयोग कैसे करें (वैसे, आप इसके साथ प्रशिक्षित भी कर सकते हैं)। ऑब्जेक्ट मान्यता समस्या YOLOv3 नेटवर्क का उपयोग करके हल की गई थी। IPhone XS पर, यह नेटवर्क (YOLOv3-small) ~ 30 फ्रेम प्रति सेकंड की आवृत्ति पर छवियों को संसाधित करने में सक्षम है, जो वास्तविक समय के संचालन के लिए काफी पर्याप्त है।

पूरा आवेदन कोड GitHub पर देखा जा सकता है ।

YOLOv3 का उपयोग करके iOS पर रियल-टाइम ऑब्जेक्ट मान्यता