OpenCV के साथ Python में फेस डिटेक्शन

Haar कैस्केड क्लासिफ़ायर्स का परिचय

यह विधि पहली बार Paul Viola और Michael Jones द्वारा लिखे गए पेपर Rapid Object Detection Using a Boosted Cascade of Simple Features में प्रस्तुत की गई थी।

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

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

Python के लिए OpenCV इंस्टॉल करना

OpenCV लाइब्रेरी इंस्टॉल करने के लिए, अपने कमांड प्रॉम्प्ट या टर्मिनल विंडो को खोलें और निम्न कमांड चलाएं:

pip install opencv-pythonसंचालित द्वारा

यह कमांड तभी काम करेगा जब आपके डिवाइस पर पहले से pip इंस्टॉल हो। यदि आप pip पैकेज मैनेजर के बारे में अधिक जानना चाहते हैं, तो हमारा PIP Python Tutorial पढ़ सकते हैं।

इमेज में फेस डिटेक्शन के लिए OpenCV

हम Unsplash से एक फोटो में मानव चेहरे की पहचान करने के लिए एक डिटेक्टर बनाएंगे। कोड के साथ चलते समय सुनिश्चित करें कि तस्वीर को अपनी वर्किंग डायरेक्टरी में सेव करें और उसका नाम input_image कर दें।

चरण 1: OpenCV पैकेज इम्पोर्ट करें

अब, OpenCV इम्पोर्ट करते हैं और निम्न पंक्तियों के साथ इनपुट इमेज पाथ दर्ज करते हैं:

import cv2

imagePath = 'input_image.jpg'संचालित द्वारा

चरण 2: इमेज पढ़ें

इसके बाद, हमें OpenCV की imread() फ़ंक्शन से इमेज पढ़नी होगी:

img = cv2.imread(imagePath)संचालित द्वारा

यह निर्दिष्ट फ़ाइल पाथ से इमेज लोड करेगा और उसे Numpy array के रूप में लौटाएगा। 

आइए इस array के आयाम प्रिंट करें:

img.shapeसंचालित द्वारा

(4000, 2667, 3)संचालित द्वारा

ध्यान दें कि यह एक 3-आयामी array है। array के मान क्रमशः चित्र की ऊँचाई, चौड़ाई और चैनल्स का प्रतिनिधित्व करते हैं। चूंकि यह एक रंगीन इमेज है, इसलिए इसे दर्शाने के लिए तीन चैनल्स प्रयोग होते हैं - ब्लू, ग्रीन और रेड (BGR)। 

ध्यान दें कि जहाँ इमेज का पारंपरिक अनुक्रम RGB (Red, Green, Blue) होता है, वहीं OpenCV लाइब्रेरी उल्टा लेआउट (Blue, Green, Red) उपयोग करती है।

चरण 3: इमेज को ग्रेस्केल में बदलें

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

gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)संचालित द्वारा

अब इस ग्रेस्केल इमेज के आयाम देखते हैं:

gray_image.shapeसंचालित द्वारा

(4000, 2667)संचालित द्वारा

ध्यान दें कि यह array केवल दो मान रखता है क्योंकि इमेज अब ग्रेस्केल है और तीसरा कलर चैनल नहीं है।

चरण 4: क्लासिफ़ायर लोड करें

आइए OpenCV में बिल्ट-इन प्री-ट्रेंड Haar कैस्केड क्लासिफ़ायर लोड करें:

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)संचालित द्वारा

ध्यान दें कि हम haarcascade_frontalface_default.xml नामक फ़ाइल का उपयोग कर रहे हैं। यह क्लासिफ़ायर विशेष रूप से फ्रंटल फेसेज़ का पता लगाने के लिए डिज़ाइन किया गया है। 

OpenCV इमेज में अलग-अलग ऑब्जेक्ट्स का पता लगाने के लिए अन्य प्री-ट्रेंड मॉडल भी प्रदान करता है - जैसे किसी व्यक्ति की आँखें, मुस्कान, ऊपरी शरीर, यहाँ तक कि वाहन की नंबर प्लेट। आप OpenCV में बिल्ट-इन अलग-अलग क्लासिफ़ायर के बारे में लाइब्रेरी के GitHub रिपॉज़िटरी में अधिक जान सकते हैं।

चरण 5: फेस डिटेक्शन करें

अब हम ग्रेस्केल इमेज पर अभी लोड किए गए क्लासिफ़ायर का उपयोग करके फेस डिटेक्शन कर सकते हैं:

face = face_classifier.detectMultiScale(
    gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40)
)संचालित द्वारा

आइए ऊपर दिए गए कोड में प्रयुक्त मेथड्स और पैरामीटर्स को समझें:

1. detectMultiScale():

detectMultiScale() मेथड इनपुट इमेज में अलग-अलग आकार के चेहरों की पहचान करने के लिए उपयोग होता है।

1. grey_image:

इस मेथड का पहला पैरामीटर grey_image है, जो वह ग्रेस्केल इमेज है जिसे हमने पहले बनाया था।

1. scaleFactor:

यह पैरामीटर इनपुट इमेज के आकार को स्केल-डाउन करने के लिए उपयोग होता है, ताकि एल्गोरिदम के लिए बड़े चेहरों का पता लगाना आसान हो सके। यहाँ हमने 1.1 का स्केल फ़ैक्टर निर्धारित किया है, जो बताता है कि हम इमेज का आकार 10% कम करना चाहते हैं।

1. minNeighbors:

कैस्केड क्लासिफ़ायर इमेज में चेहरों का पता लगाने के लिए उस पर एक स्लाइडिंग विंडो लागू करता है। आप इन विंडोज़ को आयतों के रूप में सोच सकते हैं। 

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

सारांशतः, इस पैरामीटर को 0 या 1 जैसा छोटा मान देने पर फ़ॉल्स पॉज़िटिव्स की संख्या अधिक होगी, जबकि बहुत बड़ा मान देने पर कई ट्रू पॉज़िटिव्स छूट सकते हैं।

यहाँ तरकीब यह है कि ऐसा संतुलन खोजें जो फ़ॉल्स पॉज़िटिव्स को कम करे और साथ ही ट्रू पॉज़िटिव्स की सटीक पहचान भी कर सके।

1. minSize:

अंत में, minSize पैरामीटर उस ऑब्जेक्ट के न्यूनतम आकार को सेट करता है जिसका पता लगाना है। मॉडल निर्दिष्ट न्यूनतम आकार से छोटे चेहरों को नज़रअंदाज़ कर देगा।

चरण 6: बॉन्डिंग बॉक्स बनाना

अब जब मॉडल ने इमेज के अंदर चेहरों का पता लगा लिया है, तो इन चेहरों के चारों ओर बॉन्डिंग बॉक्स बनाने के लिए निम्न कोड चलाते हैं:

for (x, y, w, h) in face:
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 4)संचालित द्वारा

face वेरिएबल चार मानों वाला एक array है: जिन अक्षों (x और y) पर चेहरे पाए गए, और उनकी चौड़ाई तथा ऊँचाई। ऊपर का कोड पहचाने गए चेहरों पर इटररेट करता है और इन मापों के अनुसार बॉन्डिंग बॉक्स बनाता है।

0,255,0 पैरामीटर बॉन्डिंग बॉक्स का रंग दर्शाता है, जो हरा है, और 4 उसकी मोटाई को दर्शाता है।

चरण 7: इमेज प्रदर्शित करना

डिटेक्ट किए गए चेहरों वाली इमेज को दिखाने के लिए, हमें पहले इमेज को BGR फॉर्मैट से RGB में बदलना होगा:

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)संचालित द्वारा

अब, इमेज प्रदर्शित करने के लिए Matplotlib लाइब्रेरी का उपयोग करते हैं:

import matplotlib.pyplot as plt



plt.figure(figsize=(20,10))
plt.imshow(img_rgb)
plt.axis('off')संचालित द्वारा

ऊपर का कोड निम्न आउटपुट उत्पन्न करना चाहिए: 

बहुत बढ़िया!

मॉडल ने इस इमेज में मानव चेहरे का सफलतापूर्वक पता लगाया है और उसके चारों ओर एक बॉन्डिंग बॉक्स बनाया है। 

OpenCV के साथ रियल-टाइम फेस डिटेक्शन

अब जब हमने OpenCV के साथ एक स्थिर इमेज पर सफलतापूर्वक फेस डिटेक्शन कर लिया है, तो देखते हैं कि लाइव वीडियो स्ट्रीम पर यही काम कैसे करें। 

चरण 1: पूर्व-आवश्यकताएँ

सबसे पहले, पिछले खंड की तरह OpenCV लाइब्रेरी इम्पोर्ट करते हैं और Haar कैस्केड मॉडल लोड करते हैं। यदि आपने पहले ही यह ब्लॉक चला लिया है, तो इसे छोड़ सकते हैं:

import cv2

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)संचालित द्वारा

चरण 2: वेबकैम एक्सेस करें

अब हमें अपने डिवाइस के कैमरे तक पहुंचना होगा ताकि वीडियो डेटा की लाइव स्ट्रीम पढ़ी जा सके। यह निम्न कोड से किया जा सकता है:

video_capture = cv2.VideoCapture(0)संचालित द्वारा

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

चरण 3: वीडियो स्ट्रीम में चेहरों की पहचान

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

def detect_bounding_box(vid):
    gray_image = cv2.cvtColor(vid, cv2.COLOR_BGR2GRAY)
    faces = face_classifier.detectMultiScale(gray_image, 1.1, 5, minSize=(40, 40))
    for (x, y, w, h) in faces:
        cv2.rectangle(vid, (x, y), (x + w, y + h), (0, 255, 0), 4)
    return facesसंचालित द्वारा

detect_bounding_box फ़ंक्शन वीडियो फ्रेम को इनपुट लेता है।

इस फ़ंक्शन में, हम फेस डिटेक्शन करने से पहले फ्रेम को ग्रेस्केल में बदलने के लिए पहले जैसे ही कोड का उपयोग कर रहे हैं।

फिर, हम scaleFactor, minNeighbors, और minSize के पहले जैसे ही मानों का उपयोग करके इस इमेज में चेहरे का पता लगा रहे हैं।

अंत में, हम फ्रेम के चारों ओर मोटाई 4 का हरा बॉन्डिंग बॉक्स बनाते हैं।

चरण 4: रियल-टाइम फेस डिटेक्शन के लिए लूप बनाना

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

while True:

    result, video_frame = video_capture.read()  # read frames from the video
    if result is False:
        break  # terminate the loop if the frame is not read successfully

    faces = detect_bounding_box(
        video_frame
    )  # apply the function we created to the video frame

    cv2.imshow(
        "My Face Detection Project", video_frame
    )  # display the processed frame in a window named "My Face Detection Project"

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

video_capture.release()
cv2.destroyAllWindows()संचालित द्वारा

उपरोक्त कोड चलाने के बाद, आपको स्क्रीन पर My Face Detection Project नामक एक विंडो दिखाई देनी चाहिए:

एल्गोरिदम को आपके चेहरे को ट्रैक करना चाहिए और फ्रेम में आपकी स्थिति चाहे जो भी हो, उसके चारों ओर एक हरा बॉन्डिंग बॉक्स बनाना चाहिए।

ऊपर के फ्रेम में, मॉडल मेरा चेहरा और मेरे द्वारा पकड़कर रखे गए ड्राइविंग लाइसेंस पर मेरी तस्वीर को पहचानता है।

आप इस मॉडल की प्रभावशीलता का परीक्षण कई तस्वीरें पकड़कर या अलग-अलग लोगों को कैमरे के पीछे विभिन्न कोणों पर खड़ा करके भी कर सकते हैं। मॉडल को अलग-अलग बैकग्राउंड या लाइटिंग सेटिंग्स में सभी मानव चेहरों की पहचान करने में सक्षम होना चाहिए।

यदि आप प्रोग्राम से बाहर निकलना चाहते हैं, तो कीबोर्ड पर “q” कुंजी दबाकर लूप से बाहर निकल सकते हैं।

निष्कर्ष

संक्षेप में, OpenCV कंप्यूटर विज़न एप्लिकेशन बनाने के लिए एक शक्तिशाली और बहुमुखी लाइब्रेरी है, जो फेस डिटेक्शन जैसे जटिल कार्यों को सरल बनाने के लिए प्री-ट्रेंड मॉडल्स और टूल्स की एक विस्तृत श्रृंखला प्रदान करती है।

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

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