पायथन के साथ मुफ्त पार्किंग स्थान की तलाश में

मैं एक अच्छे शहर में रहता हूँ। लेकिन, कई अन्य लोगों की तरह, पार्किंग स्पेस की तलाश हमेशा एक परीक्षा में बदल जाती है। मुफ्त स्थान जल्दी से कब्जा कर लेते हैं, और यहां तक ​​कि अगर आपके पास अपना है, तो दोस्तों को आपको कॉल करना मुश्किल होगा, क्योंकि वे पार्क करने के लिए कहीं नहीं होंगे।

इसलिए मैंने खिड़की से कैमरे को इंगित करने और गहरी सीखने का उपयोग करने का फैसला किया ताकि अंतरिक्ष उपलब्ध होने पर मेरा कंप्यूटर मुझसे कहे:



यह जटिल लग सकता है, लेकिन वास्तव में गहरी सीखने के साथ एक कामकाजी प्रोटोटाइप लिखना त्वरित और आसान है। सभी आवश्यक घटक पहले से ही मौजूद हैं - आपको बस यह जानना होगा कि उन्हें कहां खोजना है और उन्हें एक साथ कैसे रखना है।

तो चलिए कुछ मज़ा लेते हैं और पाइथन और गहरी शिक्षा का उपयोग करके एक सटीक मुफ्त पार्किंग अधिसूचना प्रणाली लिखते हैं

कार्य का विघटन

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

यहाँ बताया गया है कि मैंने अपना कार्य कैसे किया:



विंडो से निर्देशित वेबकैम से वीडियो स्ट्रीम कन्वेयर इनपुट में प्रवेश करती है:



पाइपलाइन के माध्यम से, हम एक बार में, वीडियो के प्रत्येक फ्रेम को प्रसारित करेंगे।

पहला कदम फ्रेम में सभी संभावित पार्किंग स्थानों को पहचानना है। जाहिर है, इससे पहले कि हम निर्जन स्थानों की खोज कर सकें, हमें यह समझने की आवश्यकता है कि छवि के किन हिस्सों में पार्किंग है।

फिर प्रत्येक फ्रेम पर आपको सभी कारों को खोजने की आवश्यकता है। यह हमें फ्रेम से फ्रेम तक प्रत्येक मशीन के आंदोलन को ट्रैक करने की अनुमति देगा।

तीसरा चरण यह निर्धारित करना है कि कौन सी जगहों पर मशीनों का कब्जा है और कौन सी नहीं हैं। ऐसा करने के लिए, पहले दो चरणों के परिणामों को मिलाएं।

अंत में, पार्किंग स्थान खाली होने पर कार्यक्रम को अलर्ट भेजना चाहिए। यह वीडियो के फ्रेम के बीच मशीनों के स्थान में परिवर्तन द्वारा निर्धारित किया जाएगा।

इनमें से प्रत्येक चरण को विभिन्न तकनीकों का उपयोग करके विभिन्न तरीकों से पूरा किया जा सकता है। इस कन्वेयर की रचना करने का कोई सही या गलत तरीका नहीं है; विभिन्न तरीकों के अपने फायदे और नुकसान होंगे। आइए प्रत्येक चरण के साथ अधिक विस्तार से व्यवहार करें।

हम पार्किंग स्थलों को पहचानते हैं

यहाँ हमारा कैमरा क्या देखता है:



हमें किसी तरह इस छवि को स्कैन करने और पार्क करने के लिए स्थानों की एक सूची प्राप्त करने की आवश्यकता है:



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

वैकल्पिक रूप से, आप छवि में पार्किंग मीटर की खोज कर सकते हैं और मान सकते हैं कि उनमें से प्रत्येक के बगल में एक पार्किंग स्थान है:



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

एक अन्य विचार यह है कि एक वस्तु मान्यता मॉडल बनाया जाए जो सड़क पर पार्किंग स्थल के निशान को देखता हो:



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

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

दूसरे शब्दों में, पार्किंग स्थान स्थित हैं जहां कारें लंबे समय तक खड़ी रहती हैं:



इस प्रकार, यदि हम कारों को पहचान सकते हैं और यह पता लगा सकते हैं कि उनमें से कौन सी फ्रेम के बीच नहीं चलती है, तो हम अनुमान लगा सकते हैं कि पार्किंग स्थान कहाँ हैं। उस के रूप में सरल - मशीन मान्यता के लिए जाओ!

कारों को पहचानो

एक वीडियो फ्रेम पर कारों को पहचानना एक क्लासिक वस्तु मान्यता कार्य है। कई मशीन लर्निंग दृष्टिकोण हैं जिन्हें हम मान्यता के लिए उपयोग कर सकते हैं। यहाँ "पुराने स्कूल" से "नए स्कूल" के क्रम में उनमें से कुछ हैं:

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

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

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

इसके अलावा, मास्क आर-सीएनएन प्रत्येक मान्यता प्राप्त वस्तु के बारे में बहुत सारी जानकारी प्रदान करता है। अधिकांश मान्यता एल्गोरिदम प्रत्येक ऑब्जेक्ट के लिए केवल एक बाउंडिंग बॉक्स लौटाते हैं। हालांकि, मास्क आर-सीएनएन न केवल हमें प्रत्येक वस्तु का स्थान देगा, बल्कि इसकी रूपरेखा (मुखौटा) भी:



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

उनमें से एक लोकप्रिय SOCO डेटासेट (कॉन्टेक्ट ऑब्जेक्ट्स इन कॉनटेक्स्ट के लिए छोटा) है, जिसमें ऑब्जेक्ट मास्क के साथ छवियों को एनोटेट किया गया है। इस डेटासेट में पहले से ही लेबल मशीनों के साथ 12,000 से अधिक चित्र हैं। यहां डेटासेट से एक उदाहरण छवि है:



मास्क आर-सीएनएन पर आधारित मॉडल के प्रशिक्षण के लिए ऐसा डेटा उत्कृष्ट है।

लेकिन घोड़ों को पकड़ो, वहाँ भी बेहतर खबर है! हम पहले नहीं हैं जो COCO डेटासेट का उपयोग करके अपने मॉडल को प्रशिक्षित करना चाहते थे - बहुत से लोग हमारे सामने यह कर चुके हैं और अपने परिणाम साझा कर चुके हैं। इसलिए, अपने मॉडल को प्रशिक्षित करने के बजाय, हम एक ऐसा तैयार कर सकते हैं जो पहले से ही कारों को पहचान सके। हमारी परियोजना के लिए, हम मैटरपोर्ट से ओपन-सोर्स मॉडल का उपयोग करेंगे ।

यदि हम कैमरे से इस मॉडल के इनपुट के लिए एक छवि देते हैं, तो यह हमें पहले से ही "बॉक्स से बाहर" मिलता है:



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

प्रत्येक मान्यता प्राप्त वस्तु के लिए, मास्क आर-सीएनएन मॉडल 4 चीजें लौटाता है:

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

नीचे पूर्व-प्रशिक्षित मास्क R-CNN और OpenVV नेटवर्क का उपयोग करते हुए मशीनों के लिए बाउंडिंग बॉक्स का पता लगाने के लिए पायथन कोड है:

import numpy as np import cv2 import mrcnn.config import mrcnn.utils from mrcnn.model import MaskRCNN from pathlib import Path # ,     Mask-RCNN. class MaskRCNNConfig(mrcnn.config.Config): NAME = "coco_pretrained_model_config" IMAGES_PER_GPU = 1 GPU_COUNT = 1 NUM_CLASSES = 1 + 80 #   COCO  80  + 1  . DETECTION_MIN_CONFIDENCE = 0.6 #    ,    . def get_car_boxes(boxes, class_ids): car_boxes = [] for i, box in enumerate(boxes): #     ,   . if class_ids[i] in [3, 8, 6]: car_boxes.append(box) return np.array(car_boxes) #   . ROOT_DIR = Path(".") #       . MODEL_DIR = ROOT_DIR / "logs" #       . COCO_MODEL_PATH = ROOT_DIR / "mask_rcnn_coco.h5" #   COCO  . if not COCO_MODEL_PATH.exists(): mrcnn.utils.download_trained_weights(COCO_MODEL_PATH) #     . IMAGE_DIR = ROOT_DIR / "images" #      —   0,    ,   . VIDEO_SOURCE = "test_images/parking.mp4" #   Mask-RCNN   . model = MaskRCNN(mode="inference", model_dir=MODEL_DIR, config=MaskRCNNConfig()) #   . model.load_weights(COCO_MODEL_PATH, by_name=True) #   . parked_car_boxes = None #  ,     . video_capture = cv2.VideoCapture(VIDEO_SOURCE) #      . while video_capture.isOpened(): success, frame = video_capture.read() if not success: break #      BGR ( OpenCV)  RGB. rgb_image = frame[:, :, ::-1] #    Mask R-CNN   . results = model.detect([rgb_image], verbose=0) # Mask R-CNN ,       . #     ,     . r = results[0] #  r    : # - r['rois'] —      ; # - r['class_ids'] —  () ; # - r['scores'] —  ; # - r['masks'] —   (    ). #      . car_boxes = get_car_boxes(r['rois'], r['class_ids']) print("Cars found in frame of video:") #     . for box in car_boxes: print("Car:", box) y1, x1, y2, x2 = box #  . cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 1) #    . cv2.imshow('Video', frame) #  'q',  . if cv2.waitKey(1) & 0xFF == ord('q'): break #    . video_capture.release() cv2.destroyAllWindows() 

इस स्क्रिप्ट को चलाने के बाद, स्क्रीन पर प्रत्येक ज्ञात मशीन के चारों ओर एक फ्रेम दिखाई देगा।



इसके अलावा, प्रत्येक मशीन के निर्देशांक कंसोल में प्रदर्शित किए जाएंगे:

 Cars found in frame of video: Car: [492 871 551 961] Car: [450 819 509 913] Car: [411 774 470 856] 

इसलिए हमने इमेज में कारों को पहचानना सीखा।

हम खाली पार्किंग स्थानों को पहचानते हैं

हम प्रत्येक मशीन के पिक्सेल निर्देशांक जानते हैं। कई लगातार फ़्रेमों के माध्यम से देखते हुए, हम आसानी से यह निर्धारित कर सकते हैं कि कौन सी कार नहीं चली, और मान लें कि पार्किंग स्थान हैं। लेकिन यह कैसे समझें कि कार ने पार्किंग को छोड़ दिया?

समस्या यह है कि मशीनों के फ्रेम आंशिक रूप से एक दूसरे को ओवरलैप करते हैं:



इसलिए, यदि आप कल्पना करते हैं कि प्रत्येक फ्रेम एक पार्किंग स्थान का प्रतिनिधित्व करता है, तो यह पता चल सकता है कि यह मशीन द्वारा आंशिक रूप से कब्जा कर लिया गया है, जब वास्तव में यह खाली है। हमें केवल "सबसे खाली" फ्रेम की खोज करने के लिए दो वस्तुओं के प्रतिच्छेदन की डिग्री को मापने का एक तरीका खोजने की आवश्यकता है।

हम Intersection Over Union (कुल क्षेत्र के प्रतिच्छेदन क्षेत्र का अनुपात) या IoU नामक एक उपाय का उपयोग करेंगे। आईओयू को उन पिक्सेल्स की संख्या की गणना करके पाया जा सकता है जहां दो ऑब्जेक्ट्स प्रतिच्छेद करते हैं, और इन ऑब्जेक्ट्स द्वारा कब्जा किए गए पिक्सल की संख्या से विभाजित करते हैं:



तो हम समझ सकते हैं कि पार्किंग स्पेस के फ्रेम के साथ कार का बहुत बाउंडिंग फ्रेम कैसे इंटरसेक्ट करता है। इससे यह निर्धारित करना आसान हो जाएगा कि पार्किंग मुफ्त है या नहीं। यदि IoU मान कम है, जैसे 0.15, तो कार पार्किंग स्थान के एक छोटे से हिस्से पर कब्जा कर लेती है। और अगर यह उच्च है, तो 0.6 की तरह, तो इसका मतलब है कि कार अधिकांश जगह ले जाती है और आप वहां पार्क नहीं कर सकते।

चूंकि IoU का उपयोग कंप्यूटर विज़न में काफी बार किया जाता है, इसलिए यह बहुत संभावना है कि संबंधित लाइब्रेरी इस उपाय को लागू करें। हमारी लाइब्रेरी मास्क आर-सीएनएन में, इसे एक फ़ंक्शन mrcnn.utils.compute_overlaps () के रूप में लागू किया गया है।

यदि हमारे पास पार्किंग स्थलों के लिए बाउंडिंग बॉक्स की सूची है, तो आप इस रूपरेखा में कारों की उपस्थिति के लिए एक पूरी लाइन या दो कोड जोड़कर चेक जोड़ सकते हैं:

  #      . car_boxes = get_car_boxes(r['rois'], r['class_ids']) # ,        . overlaps = mrcnn.utils.compute_overlaps(car_boxes, parking_areas) print(overlaps) 

परिणाम कुछ इस तरह दिखना चाहिए:

 [ [1. 0.07040032 0. 0.] [0.07040032 1. 0.07673165 0.] [0. 0. 0.02332112 0.] ] 

इस दो-आयामी सरणी में, प्रत्येक पंक्ति पार्किंग स्थान के एक फ्रेम को दर्शाती है। और प्रत्येक स्तंभ इंगित करता है कि प्रत्येक स्थान कितनी दृढ़ता से पता लगाने वाली मशीनों में से एक के साथ अंतर करता है। 1.0 के परिणाम का अर्थ है कि पूरी जगह कार पर पूरी तरह से कब्जा कर चुकी है, और 0.02 जैसी कम कीमत इंगित करती है कि कार थोड़ी जगह पर चढ़ गई है, लेकिन आप अभी भी उस पर पार्क कर सकते हैं।

निर्जन स्थानों को खोजने के लिए, आपको बस इस सरणी में प्रत्येक पंक्ति की जांच करने की आवश्यकता है। यदि सभी संख्याएं शून्य के करीब हैं, तो सबसे अधिक संभावना है कि स्थान मुफ़्त है!

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

एसएमएस भेजें

मुफ्त पार्किंग स्थान दिखाई देने पर हमारे कन्वेयर का अंतिम भाग एसएमएस सूचनाएं भेज रहा है।

यदि आप ट्विलियो का उपयोग करते हैं तो पायथन से संदेश भेजना बहुत आसान है। ट्विलियो एक लोकप्रिय एपीआई है जो आपको कोड की कुछ लाइनों के साथ लगभग किसी भी प्रोग्रामिंग भाषा से एसएमएस भेजने की अनुमति देता है। बेशक, यदि आप एक अलग सेवा पसंद करते हैं, तो आप इसका उपयोग कर सकते हैं। मुझे ट्विलियो से कोई लेना-देना नहीं है, यह सिर्फ पहली बात है जो दिमाग में आती है।

Twilio का उपयोग करने के लिए, एक परीक्षण खाते के लिए साइन अप करें, एक Twilio फ़ोन नंबर बनाएं, और अपने खाते की प्रमाणीकरण जानकारी प्राप्त करें। फिर क्लाइंट लाइब्रेरी स्थापित करें:

 $ pip3 install twilio 

उसके बाद, संदेश भेजने के लिए निम्न कोड का उपयोग करें:

 from twilio.rest import Client #   Twilio. twilio_account_sid = ' Twilio SID' twilio_auth_token = '   Twilio' twilio_source_phone_number = '   Twilio' #    Twilio. client = Client(twilio_account_sid, twilio_auth_token) #  SMS. message = client.messages.create( body=" ", from_=twilio_source_phone_number, to=" ,   " ) 

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

यह सब एक साथ रखना

 import numpy as np import cv2 import mrcnn.config import mrcnn.utils from mrcnn.model import MaskRCNN from pathlib import Path from twilio.rest import Client # ,     Mask-RCNN. class MaskRCNNConfig(mrcnn.config.Config): NAME = "coco_pretrained_model_config" IMAGES_PER_GPU = 1 GPU_COUNT = 1 NUM_CLASSES = 1 + 80 #   COCO  80  + 1  . DETECTION_MIN_CONFIDENCE = 0.6 #    ,    . def get_car_boxes(boxes, class_ids): car_boxes = [] for i, box in enumerate(boxes): #     ,   . if class_ids[i] in [3, 8, 6]: car_boxes.append(box) return np.array(car_boxes) #  Twilio. twilio_account_sid = ' Twilio SID' twilio_auth_token = '   Twilio' twilio_phone_number = '   Twilio' destination_phone_number = ',   ' client = Client(twilio_account_sid, twilio_auth_token) #   . ROOT_DIR = Path(".") #       . MODEL_DIR = ROOT_DIR / "logs" #       . COCO_MODEL_PATH = ROOT_DIR / "mask_rcnn_coco.h5" #   COCO  . if not COCO_MODEL_PATH.exists(): mrcnn.utils.download_trained_weights(COCO_MODEL_PATH) #     . IMAGE_DIR = ROOT_DIR / "images" #      —   0,   ,   . VIDEO_SOURCE = "test_images/parking.mp4" #   Mask-RCNN   . model = MaskRCNN(mode="inference", model_dir=MODEL_DIR, config=MaskRCNNConfig()) #   . model.load_weights(COCO_MODEL_PATH, by_name=True) #   . parked_car_boxes = None #  ,     . video_capture = cv2.VideoCapture(VIDEO_SOURCE) #         . free_space_frames = 0 #    SMS? sms_sent = False #      . while video_capture.isOpened(): success, frame = video_capture.read() if not success: break #      BGR  RGB. rgb_image = frame[:, :, ::-1] #    Mask R-CNN   . results = model.detect([rgb_image], verbose=0) # Mask R-CNN ,       . #     ,     . r = results[0] #  r    : # - r['rois'] —      ; # - r['class_ids'] —  () ; # - r['scores'] —  ; # - r['masks'] —   (    ). if parked_car_boxes is None: #     — ,       . #            . parked_car_boxes = get_car_boxes(r['rois'], r['class_ids']) else: #   ,  . ,   . #     . car_boxes = get_car_boxes(r['rois'], r['class_ids']) # ,         . overlaps = mrcnn.utils.compute_overlaps(parked_car_boxes, car_boxes) # ,    ,      . free_space = False #        . for parking_area, overlap_areas in zip(parked_car_boxes, overlaps): #        #    (, ). max_IoU_overlap = np.max(overlap_areas) #         . y1, x1, y2, x2 = parking_area # ,   ,   IoU. if max_IoU_overlap < 0.15: #  !     . cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 3) # ,        . free_space = True else: #     —   . cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 0, 255), 1) #   IoU  . font = cv2.FONT_HERSHEY_DUPLEX cv2.putText(frame, f"{max_IoU_overlap:0.2}", (x1 + 6, y2 - 6), font, 0.3, (255, 255, 255)) #       ,   . #   ,  ,     #      . if free_space: free_space_frames += 1 else: #   ,  . free_space_frames = 0 #       ,  ,   . if free_space_frames > 10: #   SPACE AVAILABLE!!  . font = cv2.FONT_HERSHEY_DUPLEX cv2.putText(frame, f"SPACE AVAILABLE!", (10, 150), font, 3.0, (0, 255, 0), 2, cv2.FILLED) #  ,     . if not sms_sent: print("SENDING SMS!!!") message = client.messages.create( body="Parking space open - go go go!", from_=twilio_phone_number, to=destination_phone_number ) sms_sent = True #    . cv2.imshow('Video', frame) #  'q',  . if cv2.waitKey(1) & 0xFF == ord('q'): break #  'q',  . video_capture.release() cv2.destroyAllWindows() 

उस कोड को चलाने के लिए, आपको सबसे पहले Python 3.6+, Matterport Mask R-CNN और OpenCV को इंस्टॉल करना होगा।

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

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

इस तरह के अधिक लेख टेलीग्राम चैनल न्यूरॉन (@neurondata) में पढ़े जा सकते हैं

वैकल्पिक अनुवाद लिंक: tproger.ru/translations/parking-searching/

सारा ज्ञान। प्रयोग!