मास्क-आर CNN शुरुआत से पेशेवर तक

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

ठीक है, हम अपने कार्यों के बारे में अधिक विस्तार से वर्णन करेंगे:

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

ठीक है, मैंने सोचा, और एक मोटी सांप, अजगर को उठाया, इसका मतलब है। इसकी सरलता और आधुनिक सुविधाओं के संबंध में मास्क आर-एनएन न्यूरल नेटवर्क का उपयोग करने का निर्णय लिया गया। इसके अलावा, निश्चित रूप से, हम छवि हेरफेर के लिए OpenCV का उपयोग करेंगे।

पर्यावरण की स्थापना

हम विंडोज 10 का उपयोग करेंगे, क्योंकि आप इसका उपयोग करने की सबसे अधिक संभावना है।
यह समझा जाता है कि आपके पास पहले से ही 64 बिट पायथन है। यदि नहीं, तो आप पैकेज डाउनलोड कर सकते हैं, उदाहरण के लिए, यहाँ से

पैकेज स्थापना

git clone https://github.com/matterport/Mask_RCNN cd Mask_RCNN pip3 install -r requirements.txt python3 setup.py install 

यदि किसी कारण से स्रोत से संकलन करना संभव नहीं है, तो पाइप से एक संस्करण है:

 pip3 install mrcnn --user 

पैकेज, निश्चित रूप से, सभी निर्भरताओं के साथ आता है।

चरण 1. एक साधारण पहचानकर्ता बनाना।

हम आवश्यक आयात करेंगे

 import os import cv2 import mrcnn.config import mrcnn from mrcnn.model import MaskRCNN 

तंत्रिका नेटवर्क को ओवरराइड क्षेत्रों के साथ एक कॉन्फ़िगरेशन बनाने की आवश्यकता होती है

 class MaskRCNNConfig(mrcnn.config.Config): NAME = "coco_pretrained_model_config" GPU_COUNT = 1 IMAGES_PER_GPU = 1 DETECTION_MIN_CONFIDENCE = 0.8 #     NUM_CLASSES = 81 

तराजू के साथ फ़ाइल के स्थान को इंगित करें। इस उदाहरण में इस फाइल के साथ फ़ोल्डर में होगा। अगर यह नहीं है, तो यह डाउनलोड करेगा।

 import mrcnn.utils DATASET_FILE = "mask_rcnn_coco.h5" if not os.path.exists(DATASET_FILE): mrcnn.utils.download_trained_weights(DATASET_FILE) 

आइए ऊपर की सेटिंग्स के साथ अपना मॉडल बनाएं

 model = MaskRCNN(mode="inference", model_dir="logs", config=MaskRCNNConfig()) model.load_weights(DATASET_FILE, by_name=True) 

और शायद हम वर्तमान निर्देशिका में सभी छवियों को images निर्देशिका में संसाधित करना शुरू कर देंगे।

 IMAGE_DIR = os.path.join(os.getcwd(), "images") for filename in os.listdir(IMAGE_DIR): image = cv2.imread(os.path.join(IMAGE_DIR, filename)) rgb_image = image[:, :, ::-1] detections = model.detect([rgb_image], verbose=1)[0] 

हम निरोधों में क्या देखेंगे?

  print(detections) 

उदाहरण के लिए, कुछ इसी तरह:

 {'rois': array([[ 303, 649, 542, 1176],[ 405, 2, 701, 319]]), 'class_ids': array([3, 3]), 'scores': array([0.99896, 0.99770015], dtype=float32), 'masks': array()} 

इस मामले में, 2 ऑब्जेक्ट पाए गए थे।
rois - निचले बाएँ और ऊपरी दाएँ कोने के निर्देशांक के सरणियाँ
class_ids पाई गई वस्तुओं के संख्यात्मक पहचानकर्ता हैं, जबकि हमें यह जानना होगा कि 1 एक व्यक्ति है, 3 एक कार है, 8 एक ट्रक है।
scores - जहां तक ​​मॉडल समाधान में विश्वास है, इस पैरामीटर को सभी अनुचित विकल्पों को काटकर, विन्यास में DETECTION_MIN_CONFIDENCE माध्यम से DETECTION_MIN_CONFIDENCE जा सकता है।
masks - वस्तु का समोच्च। ऑब्जेक्ट मास्क का उपयोग करने के लिए डेटा का उपयोग किया जाता है। क्योंकि वे काफी समझदार हैं, और मानव समझ के लिए इरादा नहीं है; मैं उन्हें लेख में उद्धृत नहीं करूंगा।

ठीक है, हम वहां रुक सकते हैं, लेकिन हम उस छवि को देखना चाहते हैं जो आमतौर पर खूबसूरती से चयनित वस्तुओं के साथ तंत्रिका नेटवर्क का उपयोग करने पर मार्गदर्शन करती है?

फ़ंक्शन को mrcnn.visualize.display_instances आसान होगा, लेकिन हम ऐसा नहीं करेंगे, हम अपना खुद का लिखेंगे।

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

 def visualize_detections(image, masks, boxes, class_ids, scores): import numpy as np bgr_image = image[:, :, ::-1] CLASS_NAMES = ['BG',"person", "bicycle", "car", "motorcycle", "bus", "truck"] COLORS = mrcnn.visualize.random_colors(len(CLASS_NAMES)) for i in range(boxes.shape[0]): y1, x1, y2, x2 = boxes[i] classID = class_ids[i] label = CLASS_NAMES[classID] font = cv2.FONT_HERSHEY_DUPLEX color = [int(c) for c in np.array(COLORS[classID]) * 255] text = "{}: {:.3f}".format(label, scores[i]) size = 0.8 width = 2 cv2.rectangle(bgr_image, (x1, y1), (x2, y2), color, width) cv2.putText(bgr_image, text, (x1, y1-20), font, size, color, width) 

हालांकि इस तंत्रिका नेटवर्क का एक मुख्य लाभ इंस्टेंस सेगमेंट की समस्याओं का समाधान है - वस्तुओं के आकृति प्राप्त करना, हमने अभी तक इसका उपयोग नहीं किया है, हम इसका विश्लेषण करेंगे।

मुखौटे को लागू करने के लिए, प्रत्येक वस्तु के लिए एक आयत बनाने से पहले कुछ पंक्तियों को जोड़ें।

 mask = masks[:, :, i] #   image = mrcnn.visualize.apply_mask(image, mask, color, alpha=0.6) #   

परिणाम:

स्टेज II। पहली सफलता। कारों की संख्या की मान्यता।

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

यह यूक्रेनी निर्माता नॉमरॉफ़-नेट (विज्ञापन नहीं) से एक तैयार किए गए परिवाद का उपयोग करने का निर्णय लिया गया था। क्योंकि लगभग सभी कोड मॉडल के उदाहरणों में पाए जा सकते हैं, फिर मैंने पूर्ण विवरण नहीं दिया।

मैं केवल यह कह सकता हूं कि यह फ़ंक्शन मूल छवि के साथ शुरू किया जा सकता है या मान्यता प्राप्त मशीन को फ्रेम से बाहर काटा जा सकता है और इस फ़ंक्शन को पास किया जा सकता है।

 import sys import matplotlib.image as mpimg import os sys.path.append(cfg.NOMEROFF_NET_DIR) from NomeroffNet import filters, RectDetector, TextDetector, OptionsDetector, Detector, textPostprocessing nnet = Detector(cfg.MASK_RCNN_DIR, cfg.MASK_RCNN_LOG_DIR) nnet.loadModel("latest") rectDetector = RectDetector() optionsDetector = OptionsDetector() optionsDetector.load("latest") textDetector = TextDetector.get_static_module("ru")() textDetector.load("latest") def detectCarNumber(imgPath: str) -> str: img = mpimg.imread(imgPath) NP = nnet.detect([img]) cvImgMasks = filters.cv_img_mask(NP) arrPoints = rectDetector.detect(cvImgMasks) zones = rectDetector.get_cv_zonesBGR(img, arrPoints) regionIds, stateIds, _c = optionsDetector.predict(zones) regionNames = optionsDetector.getRegionLabels(regionIds) # find text with postprocessing by standart textArr = textDetector.predict(zones) textArr = textPostprocessing(textArr, regionNames) return textArr 

आउटपुट textArr फ्रेम पर पाए जाने वाले मशीनों की संख्या के साथ तार की एक सरणी का प्रतिनिधित्व करेगा, उदाहरण के लिए:
["293163"] , या [""] , [] - यदि कोई मिलान संख्या नहीं मिली।

स्टेज III। समानता से वस्तुओं को पहचानें।

अब हमें यह समझने की आवश्यकता है कि किसी वस्तु को एक बार कैसे ठीक किया जाए, यह समझने के लिए कि वह अगले फ्रेम में है। इस स्तर पर, हम मान लेंगे कि हमारे पास केवल एक कैमरा है और हम केवल इससे अलग फ्रेम के बीच अंतर करेंगे।

ऐसा करने के लिए, आपको यह पता लगाना होगा कि हम दो वस्तुओं की तुलना कैसे करेंगे।

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

 pip3 install opencv-contrib-python --user 

~~ ऑपरेटर को अधिभारित करें == ~~ हम एक फ़ंक्शन लिखते हैं जो मैट्रिसेस के रूप में 2 तुलनात्मक वस्तुओं को लेता है। उदाहरण के लिए, हम फ़ंक्शन cv2.open(path) कॉल करने के बाद उन्हें प्राप्त करते हैं

हम अपने एल्गोरिथ्म के कार्यान्वयन को लिखेंगे।

 def compareImages(img1, img2) -> bool: sift = cv2.xfeatures2d.SIFT_create() 

SIFT का उपयोग करके मुख्य बिंदुओं और विवरणों का पता लगाएं। शायद मैं इन कार्यों के लिए सहायता प्रदान नहीं करूंगा, क्योंकि आप इसे हमेशा help(somefunc) रूप में इंटरैक्टिव शेल में कह सकते help(somefunc)

  kp1, des1 = sift.detectAndCompute(img1, None) kp2, des2 = sift.detectAndCompute(img2, None) 

हमारे एल्गोरिथ्म को सेट करें।

  FLANN_INDEX_KDTREE = 0 indexParams = dict(algorithm=FLANN_INDEX_KDTREE, trees=5) searchParams = dict(checks=50) flann = cv2.FlannBasedMatcher(indexParams, searchParams) 

अब इसे चलाएं।

  matches = flann.knnMatch(des1, des2, k=2) 

छवियों के बीच समानताएं गिनें।

  matchesCount = 0 for m, n in matches: if m.distance < cfg.cencitivity*n.distance: matchesCount += 1 return matchesCount > cfg.MIN_MATCH_COUNT 

अब, इसका उपयोग करने का प्रयास करें
ऐसा करने के लिए, वस्तुओं का पता लगाने के बाद, हमें उन्हें मूल छवि से काटने की आवश्यकता है

मैं इसे धीमी मेमोरी के लिए सहेजने से बेहतर कुछ नहीं लिख सकता था, और फिर वहां से पढ़ा।

  def extractObjects(objects, binaryImage, outputImageDirectory, filename=None): for item in objects: y1, x1, y2, x2 = item.coordinates #       cropped = binaryImage[y1:y2, x1:x2] beforePoint, afterPoint = filename.split(".") outputDirPath = os.path.join(os.path.split(outputImageDirectory)[0], "objectsOn" + beforePoint) if not os.path.exists(outputDirPath): os.mkdir(outputDirPath) coordinates = str(item).replace(" ", ",") pathToObjectImage = "{}{}.jpg".format(item.type, coordinates) cv2.imwrite(os.path.join(outputDirPath, str(pathToObjectImage)), cropped) 

अब हमारे पास <outputImageDirectory>/objectsOn<imageFilename> में ऑब्जेक्ट्स हैं

अब, यदि हमारे पास कम से कम 2 ऐसी निर्देशिकाएं हैं, तो हम उनमें वस्तुओं की तुलना कर सकते हैं। पहले लिखे गए फंक्शन को रन करें

 if compareImages(previousObjects, currentObjects): print(“  !”) 

या हम एक और कार्रवाई कर सकते हैं, जैसे कि इन वस्तुओं को समान पहचानकर्ता के साथ चिह्नित करना।

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

सामान्य तौर पर, हमने शुरुआत में निर्धारित 3 कार्यों को पूरा किया है, इसलिए हम इसे समाप्त कर देंगे। मुझे संदेह है कि इस लेख ने उन लोगों की आँखें खोलीं जिन्होंने कम से कम एक कार्यक्रम लिखा है जो छवि मान्यता / छवि विभाजन की समस्याओं को हल करता है, लेकिन मुझे उम्मीद है कि मैंने कम से कम एक नौसिखिया डेवलपर की मदद की)।

परियोजना का पूर्ण स्रोत कोड यहां पाया जा सकता है ।