रीयल-टाइम फेस रिकग्निशन: एक एंड-टू-एंड प्रोजेक्ट: 8 चरण (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

OpenCV को एक्सप्लोर करने वाले मेरे पिछले ट्यूटोरियल में, हमने ऑटोमेटिक विजन ऑब्जेक्ट ट्रैकिंग सीखी। अब हम अपने PiCam का उपयोग वास्तविक समय में चेहरों को पहचानने के लिए करेंगे, जैसा कि आप नीचे देख सकते हैं:

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

फेस रिकग्निशन पर एक संपूर्ण प्रोजेक्ट बनाने के लिए, हमें 3 अलग-अलग चरणों पर काम करना चाहिए:

1. फेस डिटेक्शन एंड डेटा गैदरिंग
2. पहचानकर्ता को प्रशिक्षित करें
3. चेहरा पहचान

नीचे दिया गया ब्लॉक आरेख उन चरणों को फिर से शुरू करता है:

चरण 1: BoM - सामग्री का बिल

मुख्य भाग:

1. रास्पबेरी पाई V3 - यूएस$ 32.00
2. 5 मेगापिक्सेल 1080p सेंसर OV5647 मिनी कैमरा वीडियो मॉड्यूल - US$ 13.00

चरण 2: ओपनसीवी 3 पैकेज स्थापित करना

मैं रास्पबेरी पाई वी3 का उपयोग कर रहा हूं जो रास्पियन (स्ट्रेच) के अंतिम संस्करण में अपडेट किया गया है, इसलिए ओपनसीवी स्थापित करने का सबसे अच्छा तरीका एड्रियन रोजब्रॉक द्वारा विकसित उत्कृष्ट ट्यूटोरियल का पालन करना है: रास्पियन स्ट्रेच: अपने रास्पबेरी पाई पर ओपनसीवी 3 + पायथन स्थापित करें।.

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

एक बार जब आप एड्रियन का ट्यूटोरियल समाप्त कर लेते हैं, तो आपके पास अपने पाई पर हमारे प्रयोगों को चलाने के लिए एक OpenCV वर्चुअल वातावरण तैयार होना चाहिए।

आइए अपने आभासी वातावरण में जाएं और पुष्टि करें कि OpenCV 3 सही ढंग से स्थापित है।

एड्रियन हर बार जब आप एक नया टर्मिनल खोलते हैं तो "स्रोत" कमांड चलाने की सलाह देते हैं ताकि यह सुनिश्चित हो सके कि आपके सिस्टम वेरिएबल को सही तरीके से सेट किया गया है।

स्रोत ~/.प्रोफ़ाइल

अगला, आइए अपने आभासी वातावरण में प्रवेश करें:

काम सीवी

यदि आप अपने प्रॉम्प्ट से पहले टेक्स्ट (cv) देखते हैं, तो आप cv वर्चुअल वातावरण में हैं:

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

अब, अपने पायथन दुभाषिया में प्रवेश करें:

अजगर

और पुष्टि करें कि आप 3.5 (या ऊपर) संस्करण चला रहे हैं

दुभाषिया के अंदर (">>>" दिखाई देगा), OpenCV लाइब्रेरी आयात करें:

आयात cv2

यदि कोई त्रुटि संदेश प्रकट नहीं होता है, तो OpenCV आपके पायथन वर्चुअल एनवायरनमेंट पर सही ढंग से स्थापित है।

आप स्थापित ओपनसीवी संस्करण को भी देख सकते हैं:

cv2._संस्करण_

3.3.0 प्रकट होना चाहिए (या एक बेहतर संस्करण जिसे भविष्य में जारी किया जा सकता है)। उपरोक्त टर्मिनल प्रिंटस्क्रीन पिछले चरणों को दिखाता है।

चरण 3: अपने कैमरे का परीक्षण

एक बार जब आप अपने आरपीआई में ओपनसीवी स्थापित कर लेते हैं तो यह पुष्टि करने के लिए परीक्षण करें कि आपका कैमरा ठीक से काम कर रहा है।

मैं मान रहा हूं कि आपके रास्पबेरी पाई पर पहले से ही एक PiCam स्थापित है।

अपने आईडीई पर नीचे दिया गया पायथन कोड दर्ज करें:

np. के रूप में numpy आयात करें

आयात cv2 cap = cv2. VideoCapture(0) cap.set(3, 640) # set Width cap.set(4, 480) # set ऊंचाई जबकि(True): ret, फ्रेम = cap.read() फ्रेम = cv2. फ्लिप (फ्रेम, -1) # फ्लिप कैमरा लंबवत ग्रे = cv2.cvtColor (फ्रेम, cv2. COLOR_BGR2GRAY) cv2.imshow ('फ्रेम', फ्रेम) cv2.imshow ('ग्रे', ग्रे) k = cv2.waitKey(30) और 0xff अगर k == 27: # ब्रेक कैप छोड़ने के लिए 'ESC' दबाएं। रिलीज () cv2.destroyAllWindows ()

उपरोक्त कोड उस वीडियो स्ट्रीम को कैप्चर करेगा जो आपके PiCam द्वारा उत्पन्न किया जाएगा, दोनों को BGR रंग और ग्रे मोड में प्रदर्शित करेगा।

ध्यान दें कि जिस तरह से इसे इकट्ठा किया गया है, उसके कारण मैंने अपने कैमरे को लंबवत घुमाया। यदि यह आपका मामला नहीं है, तो टिप्पणी करें या "फ्लिप" कमांड लाइन को हटा दें।

आप वैकल्पिक रूप से मेरे GitHub से कोड डाउनलोड कर सकते हैं: simpleCamTest.py

निष्पादित करने के लिए, कमांड दर्ज करें:

अजगर simpleCamTest.py

कार्यक्रम को समाप्त करने के लिए, आपको अपने कीबोर्ड पर [ईएससी] कुंजी दबानी होगी।

[ईएससी] दबाने से पहले, वीडियो विंडो पर अपने माउस को क्लिक करें

उपरोक्त तस्वीर परिणाम दिखाती है।

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

sudo modprobe bcm2835-v4l2

आप /etc/modules फ़ाइल की अंतिम पंक्ति में bcm2835-v4l2 भी जोड़ सकते हैं ताकि ड्राइवर बूट पर लोड हो जाए।

ओपनसीवी के बारे में अधिक जानने के लिए, आप ट्यूटोरियल का अनुसरण कर सकते हैं: लोडिंग -वीडियो-पायथन-ओपनसीवी-ट्यूटोरियल

चरण 4: चेहरा पहचान

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

चेहरे (या किसी भी वस्तु) का पता लगाने का सबसे आम तरीका "हार कैस्केड क्लासिफायरियर" का उपयोग करना है

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

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

यदि आप अपना खुद का क्लासिफायरियर नहीं बनाना चाहते हैं, तो OpenCV में पहले से ही चेहरे, आंखों, मुस्कान आदि के लिए कई पूर्व-प्रशिक्षित क्लासिफायर शामिल हैं। उन XML फ़ाइलों को harcascades निर्देशिका से डाउनलोड किया जा सकता है।

पर्याप्त सिद्धांत, आइए OpenCV के साथ एक फेस डिटेक्टर बनाएं!

फ़ाइल डाउनलोड करें: मेरे GitHub से faceDetection.py।

np. के रूप में numpy आयात करें

आयात cv2 faceCascade = cv2. CascadeClassifier('Cascades/haarcascade_frontalface_default.xml') cap = cv2. VideoCapture(0) cap.set(3, 640) # set Width cap.set(4, 480) # set ऊंचाई जबकि सही: ret, img = cap.read() img = cv2.flip(img, -1) धूसर = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) चेहरे = faceCascade.detectMultiScale(ग्रे, स्केलफ़ैक्टर=1.2, minNeighbors=5, minSize=(20, 20)) के लिए (x, y, w, h) फलकों में: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = धूसर [y:y+h, x:x+w] roi_color = img[y:y+h, x:x+w] cv2.imshow('video', img) k = cv2.waitKey(30) & 0xff अगर k == 27: # ब्रेक कैप छोड़ने के लिए 'ESC' दबाएं। रिलीज () cv2.destroyAllWindows ()

मानो या न मानो, कोड की उपरोक्त कुछ पंक्तियाँ आपको केवल पायथन और ओपनसीवी का उपयोग करके एक चेहरे का पता लगाने की आवश्यकता है।

जब आप कैमरे का परीक्षण करने के लिए उपयोग किए गए अंतिम कोड से तुलना करते हैं, तो आप महसूस करेंगे कि इसमें कुछ हिस्से जोड़े गए थे। नीचे दी गई लाइन पर ध्यान दें:

faceCascade = cv2. CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')

यह वह रेखा है जो "वर्गीकारक" को लोड करती है (जो कि आपकी परियोजना निर्देशिका के अंतर्गत "Cascades/" नामक निर्देशिका में होनी चाहिए)।

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

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

चेहरे = faceCascade.detectMultiScale(ग्रे, स्केलफैक्टर = 1.2, न्यूनतम पड़ोसी = 5, न्यूनतम आकार = (20, 20))

कहा पे,

• ग्रे इनपुट ग्रेस्केल छवि है।
• स्केलफैक्टर यह निर्दिष्ट करने वाला पैरामीटर है कि प्रत्येक छवि पैमाने पर छवि का आकार कितना कम हो जाता है। इसका उपयोग स्केल पिरामिड बनाने के लिए किया जाता है।
• minNeighbors एक पैरामीटर है जो निर्दिष्ट करता है कि प्रत्येक उम्मीदवार आयत में कितने पड़ोसी होने चाहिए, इसे बनाए रखने के लिए। एक उच्च संख्या कम झूठी सकारात्मक देती है।
• minSize एक चेहरा माना जाने वाला न्यूनतम आयत आकार है।

फ़ंक्शन छवि पर चेहरों का पता लगाएगा। अगला, हमें छवि में चेहरों को "चिह्नित" करना चाहिए, उदाहरण के लिए, एक नीले आयत का उपयोग करना। यह कोड के इस हिस्से के साथ किया जाता है:

फलकों में (x, y, w, h) के लिए:

cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0)), 2) roi_gray = ग्रे [y:y+h, x:x+w] roi_color = img[y:y+h, x:x+w]

यदि चेहरे पाए जाते हैं, तो यह बाएं कोने (x, y) के साथ एक आयत के रूप में पहचाने गए चेहरों की स्थिति देता है और इसकी चौड़ाई के रूप में "w" और इसकी ऊंचाई के रूप में "h" होता है ==> (x, y, w, एच)। कृपया उपरोक्त चित्र देखें।

एक बार जब हम इन स्थानों को प्राप्त कर लेते हैं, तो हम चेहरे के लिए एक "आरओआई" (खींचा हुआ आयत) बना सकते हैं और परिणाम को imshow () फ़ंक्शन के साथ प्रस्तुत कर सकते हैं।

Rpi टर्मिनल का उपयोग करके अपने अजगर वातावरण पर उपरोक्त अजगर स्क्रिप्ट चलाएँ:

अजगर

परिणाम:

आप "आंखों का पता लगाने" या यहां तक कि "मुस्कान का पता लगाने" के लिए क्लासिफायर भी शामिल कर सकते हैं। उन मामलों में, आप फेस लूप के अंदर क्लासिफायर फंक्शन और रेक्टेंगल ड्रॉ को शामिल करेंगे, क्योंकि चेहरे के बाहर आंख या मुस्कान का पता लगाने का कोई मतलब नहीं होगा।

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

मेरे GitHub पर आपको अन्य उदाहरण मिलेंगे:

faceEyeDetection.py

FaceSmileDetection.py

faceSmileEyeDetection.py

और ऊपर की तस्वीर में आप परिणाम देख सकते हैं।

फेस डिटेक्शन को बेहतर ढंग से समझने के लिए आप नीचे दिए गए ट्यूटोरियल को भी फॉलो कर सकते हैं:

हार कैस्केड ऑब्जेक्ट डिटेक्शन फेस एंड आई ओपनसीवी पायथन ट्यूटोरियल

चरण 5: डेटा एकत्र करना

सबसे पहले, मुझे रमिज़ राजा को तस्वीरों पर फेस रिकग्निशन पर उनके महान काम के लिए धन्यवाद देना चाहिए:

OPENCV और Python का उपयोग करके चेहरा पहचानना: एक शुरुआती मार्गदर्शिका

और अनिर्बान कर, जिसने वीडियो का उपयोग करके एक बहुत व्यापक ट्यूटोरियल विकसित किया:

चेहरा पहचान - 3 भाग

मैं वास्तव में अनुशंसा करता हूं कि आप दोनों ट्यूटोरियल पर एक नज़र डालें।

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

सबसे पहले, एक निर्देशिका बनाएं जहां आप अपनी परियोजना विकसित करते हैं, उदाहरण के लिए, चेहरे की पहचान परियोजना:

एमकेडीआईआर फेशियल रिकॉग्निशनप्रोजेक्ट

इस निर्देशिका में, 3 पायथन लिपियों के अलावा, जो हम अपने प्रोजेक्ट के लिए बनाएंगे, हमने उस पर फेशियल क्लासिफायर को सहेजा होगा। आप इसे मेरे GitHub से डाउनलोड कर सकते हैं: haarcascade_frontalface_default.xml

इसके बाद, एक उपनिर्देशिका बनाएं जहां हम अपने चेहरे के नमूने संग्रहीत करेंगे और इसे "डेटासेट" नाम देंगे:

एमकेडीआईआर डेटासेट

और मेरे GitHub से कोड डाउनलोड करें: 01_face_dataset.py

आयात cv2

आयात ओएस कैम = cv2. VideoCapture(0) cam.set(3, 640) # वीडियो चौड़ाई सेट करें cam.set(4, 480) # वीडियो ऊंचाई सेट करें face_detector = cv2. CascadeClassifier('haarcascade_frontalface_default.xml') # प्रत्येक व्यक्ति के लिए, एक संख्यात्मक चेहरा आईडी दर्ज करें face_id = इनपुट ('\ n उपयोगकर्ता आईडी दर्ज करें अंत प्रेस ==> ') प्रिंट ("\ n [जानकारी] चेहरा कैप्चर शुरू करना। कैमरा देखें और प्रतीक्षा करें …") # व्यक्तिगत नमूना चेहरा गिनती गिनती शुरू करें = 0 जबकि (ट्रू): रिट, img = cam.read() img = cv2.flip (img, -1) # फ्लिप वीडियो इमेज वर्टिकली ग्रे = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) फेस = face_detector.detectMultiScale(ग्रे, 1.3, 5) (x, y, w, h) के लिए चेहरे में: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) गिनती += 1 # कैप्चर की गई छवि को डेटासेट फ़ोल्डर cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", धूसर[y:y+ में सहेजें h, x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # वीडियो से बाहर निकलने के लिए 'ESC' दबाएं यदि k == 27: ब्रेक एलिफ काउंट>= 30: # 30 फेस सैंपल लें और वीडियो ब्रेक रोकें # अब करें यह क्लीनअप प्रिंट ("\ n [सूचना] से बाहर निकलने का कार्यक्रम और सफाई सामग्री") cam.release () cv2.destroyAllWindows ()

कोड बहुत हद तक उस कोड से मिलता-जुलता है जिसे हमने फेस डिटेक्शन के लिए देखा था। हमने जो जोड़ा, वह एक यूजर आईडी कैप्चर करने के लिए एक "इनपुट कमांड" था, जो एक पूर्णांक संख्या (1, 2, 3, आदि) होनी चाहिए।

face_id = इनपुट ('\ n यूजर आईडी दर्ज करें एंड प्रेस ==>')

और कैप्चर किए गए फ़्रेमों में से प्रत्येक के लिए, हमें इसे "डेटासेट" निर्देशिका पर फ़ाइल के रूप में सहेजना चाहिए:

cv2.imwrite("डेटासेट/उपयोगकर्ता।" + str(face_id) + '।' + str(गिनती) + ".jpg", ग्रे [y:y+h, x:x+w])

ध्यान दें कि उपरोक्त फ़ाइल को सहेजने के लिए, आपने पुस्तकालय "ओएस" को आयात किया होगा। प्रत्येक फ़ाइल का नाम संरचना का पालन करेगा:

User.face_id.count.jpg

उदाहरण के लिए, फेस_आईडी = 1 वाले उपयोगकर्ता के लिए, डेटासेट/निर्देशिका पर चौथी नमूना फ़ाइल कुछ इस तरह होगी:

उपयोगकर्ता.1.4.jpg

जैसा कि उपरोक्त फोटो में my Pi से दिखाया गया है। मेरे कोड पर, मैं प्रत्येक आईडी से 30 नमूने कैप्चर कर रहा हूं। आप इसे अंतिम "एलिफ" पर बदल सकते हैं। नमूनों की संख्या का उपयोग उस लूप को तोड़ने के लिए किया जाता है जहां चेहरे के नमूने लिए जाते हैं।

पायथन स्क्रिप्ट चलाएँ और कुछ आईडी कैप्चर करें। हर बार जब आप किसी नए उपयोगकर्ता को एकत्रित करना चाहते हैं (या पहले से मौजूद किसी के लिए फ़ोटो बदलने के लिए) तो आपको स्क्रिप्ट चलानी होगी।

चरण 6: ट्रेनर

इस दूसरे चरण में, हमें अपने डेटासेट से सभी उपयोगकर्ता डेटा और OpenCV पहचानकर्ता को "ट्रेनर" लेना होगा। यह सीधे एक विशिष्ट OpenCV फ़ंक्शन द्वारा किया जाता है। परिणाम एक.yml फ़ाइल होगी जिसे "ट्रेनर/" निर्देशिका में सहेजा जाएगा।

तो, चलिए एक उपनिर्देशिका बनाना शुरू करते हैं जहाँ हम प्रशिक्षित डेटा संग्रहीत करेंगे:

एमकेडीआईआर ट्रेनर

मेरे GitHub से दूसरी पायथन लिपि डाउनलोड करें: 02_face_training.py

आयात cv2

पीआईएल आयात से एनपी के रूप में numpy आयात करें छवि आयात ओएस # चेहरा छवि डेटाबेस पथ के लिए पथ = 'डेटासेट' पहचानकर्ता = cv2.face. LBHFaceRecognizer_create() डिटेक्टर = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # छवियों और लेबल डेटा प्राप्त करने के लिए फ़ंक्शन getImagesAndLabels (पथ): imagePaths = [os.path.join(path, f) f के लिए os.listdir(path)] faceSamples= ids = imagePath में imagePath के लिए: PIL_img = Image.open(imagePath).convert('L') # इसे ग्रेस्केल में बदलें img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1]. स्प्लिट ("।") [1]) चेहरे = डिटेक्टर। मल्टीस्केल (img_numpy) के लिए (x, y, w, h) चेहरों में: faceSamples.append(img_numpy[y:y+h, x:x+w]) ids.append(id) रिटर्न फेसनमूने, आईडी प्रिंट ("\ n [सूचना] प्रशिक्षण चेहरे। इसमें कुछ सेकंड लगेंगे। प्रतीक्षा करें …") चेहरे, आईडी = getImagesAndLabels (पथ) पहचानकर्ता। ट्रेन (चेहरे, np.array(ids)) # मॉडल को ट्रेनर/ट्रेनर में सेव करें। ("\n [जानकारी] {0} प्रशिक्षित चेहरे। प्रोग्राम से बाहर निकलें।format(len(np.unique(ids))))

पुष्टि करें कि क्या आपने अपने आरपीआई पर जनहित याचिका पुस्तकालय स्थापित किया है। यदि नहीं, तो टर्मिनल में निम्न कमांड चलाएँ:

पिप स्थापित तकिया

हम OpenCV पैकेज में शामिल LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) फेस रिकॉग्नाइज़र, एक पहचानकर्ता के रूप में उपयोग करेंगे। हम इसे निम्नलिखित पंक्ति में करते हैं:

पहचानकर्ता = cv2.face. LBHFaceRecognizer_create ()

फ़ंक्शन "getImagesAndLabels (पथ)", निर्देशिका पर सभी फ़ोटो लेगा: "डेटासेट /", 2 सरणियाँ लौटाता है: "Ids" और "चेहरे"। इनपुट के रूप में उन सरणियों के साथ, हम "अपने पहचानकर्ता को प्रशिक्षित करेंगे":

पहचानकर्ता.ट्रेन (चेहरे, आईडी)

परिणामस्वरूप, "trainer.yml" नाम की एक फ़ाइल उस ट्रेनर निर्देशिका में सहेजी जाएगी जो पहले हमारे द्वारा बनाई गई थी।

इतना ही! मैंने पिछले प्रिंट स्टेटमेंट को शामिल किया जहां मैंने पुष्टि के लिए प्रदर्शित किया, उपयोगकर्ता के चेहरों की संख्या जिसे हमने प्रशिक्षित किया है।

हर बार जब आप चरण 1 करते हैं, तो चरण 2 भी चलाया जाना चाहिए

चरण 7: पहचानकर्ता

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

आइए मेरे गिटहब से तीसरे चरण की पायथन लिपि डाउनलोड करें: 03_face_recognition.py।

आयात cv2

एनपी आयात ओएस पहचानकर्ता = cv2.face. LBPHFaceRecognizer_create() पहचानकर्ता के रूप में numpy आयात करें। पढ़ें ('ट्रेनर/ट्रेनर.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier(cascadePath); फ़ॉन्ट = cv2. FONT_HERSHEY_SIMPLEX #iniciate आईडी काउंटर आईडी = 0 # आईडी से संबंधित नाम: उदाहरण ==> मार्सेलो: आईडी = 1, आदि नाम = ['कोई नहीं', 'मार्सेलो', 'पाउला', 'इल्ज़ा', 'जेड ', 'डब्ल्यू'] # रीयलटाइम वीडियो कैप्चर कैम शुरू करें और शुरू करें = cv2. VideoCapture(0) cam.set(3, 640) # सेट वीडियो चौड़ाई cam.set(4, 480) # वीडियो ऊंचाई सेट करें # न्यूनतम विंडो आकार परिभाषित करें चेहरे के रूप में पहचाने जाने के लिए minW = 0.1*cam.get(3) minH = 0.1*cam.get(4) जबकि True: ret, img =cam.read() img = cv2.flip(img, -1) # लंबवत धूसर फ़्लिप करें = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) चेहरे = faceCascade.detectMultiScale(ग्रे, स्केलफ़ैक्टर = 1.2, minNeighbors = 5, minSize = (int(minW), int(minH)),) for(x, y), डब्ल्यू, एच) चेहरों में: cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2) आईडी, कॉन्फिडेंस = पहचानकर्ता। भविष्यवाणी (ग्रे[y:y+h, x:x+w]) # चेक करें कि उनमें कॉन्फिडेंस कम है या नहीं 100 ==> "0" परफेक्ट मैच है अगर (कॉन्फिडेंस <100): आईडी = नाम [आईडी] कॉन्फिडेंस = " {0}% ".format(राउंड(100 - कॉन्फिडेंस)) और: आईडी = "अज्ञात" कॉन्फिडेंस = " {0}%"।फॉर्मेट (राउंड (100 - कॉन्फिडेंस) पहचान)) cv2.putText (img, str (id), (x+5, y-5), फ़ॉन्ट, 1, (255, 255, 255), 2) cv2.putText (img, str (आत्मविश्वास), (x+5, y+h-5), फ़ॉन्ट, 1, (255, 255, 0), 1) cv2.imshow('camera', img) k = cv2.waitKey(10) और 0xff # 'ESC' दबाएं वीडियो से बाहर निकलने के लिए अगर k == 27: ब्रेक # कुछ सफाई प्रिंट करें ("\ n [सूचना] प्रोग्राम और सफाई सामग्री से बाहर निकलना") cam.release() cv2.destroyAllWindows()

हम यहां एक नई सरणी शामिल कर रहे हैं, इसलिए हम क्रमांकित आईडी के बजाय "नाम" प्रदर्शित करेंगे:

नाम = ['कोई नहीं', 'मार्सेलो', 'पाउला', 'इल्ज़ा', 'जेड', 'डब्ल्यू']

तो, उदाहरण के लिए: मार्सेलो उपयोगकर्ता आईडी = 1 के साथ होगा; पाउला: आईडी = 2, आदि।

अगला, हम एक चेहरे का पता लगाएंगे, जैसा कि हमने पहले हासकास्केड क्लासिफायर के साथ किया था। एक पहचाने गए चेहरे के साथ, हम उपरोक्त कोड में सबसे महत्वपूर्ण फ़ंक्शन को कॉल कर सकते हैं:

आईडी, आत्मविश्वास = पहचानकर्ता। भविष्यवाणी (चेहरे का धूसर भाग)

पहचानकर्ता। भविष्यवाणी (), विश्लेषण के लिए चेहरे के एक कैप्चर किए गए हिस्से को एक पैरामीटर के रूप में लेगा और इसके संभावित मालिक को वापस कर देगा, इसकी आईडी और पहचानकर्ता को इस मैच के संबंध में कितना विश्वास है।

ध्यान दें कि विश्वास सूचकांक "शून्य" लौटाएगा यदि इसे एक आदर्श मिलान माना जाएगा

और अंत में, यदि पहचानकर्ता एक चेहरे की भविष्यवाणी कर सकता है, तो हम संभावित आईडी के साथ छवि पर एक टेक्स्ट डालते हैं और% में "संभावना" कितनी है कि मैच सही है ("संभावना" = 100 - आत्मविश्वास सूचकांक)। यदि नहीं, तो चेहरे पर "अनजान" का लेबल लगा दिया जाता है।

परिणाम के साथ एक-g.webp

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

चरण 8: निष्कर्ष

हमेशा की तरह, मुझे आशा है कि यह परियोजना दूसरों को इलेक्ट्रॉनिक्स की रोमांचक दुनिया में अपना रास्ता खोजने में मदद कर सकती है!

विवरण और अंतिम कोड के लिए, कृपया मेरे GitHub डिपॉजिटरी पर जाएँ: OpenCV-Face-Recognition

अधिक परियोजनाओं के लिए, कृपया मेरे ब्लॉग पर जाएँ: MJRoBot.org

भविष्य के ट्यूटोरियल की एक झलक के नीचे, जहां हम "स्वचालित फेस ट्रैक और फेस डिटेक्शन के अन्य तरीकों" का पता लगाएंगे:

दुनिया के दक्षिण से Saludos!

मेरे अगले निर्देश में मिलते हैं!

शुक्रिया, मार्सेलो