Implémentation de la détection de visage à l'aide de Python et OpenCV

source: https://www.ariadnext.com/facial-recognition-new-era-for-on-online-identification/

La vision par ordinateur fait fureur dans la communauté d'apprentissage en machine et d'apprentissage en profondeur de nos jours. Et l'une des applications les plus populaires de ce domaine est la détection de visage.

C'est ce que nous allons apprendre à construire dans cet article détaillé. Mais avant de commencer, examinons deux cas d’utilisation réels:

1. Rendre les voitures plus sûres
Les constructeurs automobiles du monde entier tels que Mercedes, Tesla, BMW, etc. cherchent de plus en plus à rendre les voitures plus personnelles et plus sûres pour le conducteur. Dans leur tentative de créer des fonctionnalités de voiture plus intelligentes, il est logique que les fabricants utilisent AI / ML pour les aider à mieux comprendre les émotions humaines. En utilisant la détection faciale, les voitures intelligentes peuvent alerter le conducteur lorsqu'il se sent somnolent ou léthargique.

Le département américain des Transports a indiqué que les erreurs de conduite sont à l'origine d'environ 95% des accidents de la route mortels. La détection des émotions faciales peut détecter des changements subtils dans les micro-expressions faciales qui précèdent la somnolence et envoyer des alertes personnalisées au conducteur lui demandant d'arrêter la voiture et de prendre une pause-café, de changer de musique ou de température, etc.

2. Détection des émotions du visage dans les entretiens
L'interaction entre le candidat et l'intervieweur est influencée par trop de catégories de jugement et par une sorte d'interprétation erronée. Un tel jugement rend difficile de déterminer si le candidat est réellement apte à occuper le poste. Identifier ce que le candidat tente de transmettre est hors de portée de l’intervieweur en raison des multiples niveaux d’interprétation du langage, des biais cognitifs et du contexte qui les sépare. C'est là qu'intervient l'IA, qui peut mesurer les expressions faciales du candidat pour saisir son humeur et mieux évaluer ses traits de personnalité.

Le moral des employés peut également être perçu à l'aide de cette technologie en organisant et en enregistrant des interactions au travail. En tant qu’outil RH, il peut vous aider non seulement à élaborer des stratégies de recrutement, mais également à élaborer des politiques en matière de ressources humaines qui optimisent les performances des employés.

Comme nous avons vu comment la technologie de détection faciale peut efficacement aider à prendre de meilleures décisions, laissez-nous creuser plus profondément et comprendre ce qu'est exactement la détection de visage et comment créer un modèle simple capable de détecter notre visage.

Qu'est-ce que la détection de visage?

La détection des visages est la capacité de la technologie informatique à identifier les visages des personnes dans des images numériques. Les applications de détection de visage utilisent des algorithmes axés sur la détection de visage humain dans des images plus grandes pouvant contenir des paysages, des objets, etc.

Afin de fonctionner, les applications de détection de visage utilisent des algorithmes d'apprentissage automatique pour détecter les visages humains au sein d'images de toutes tailles. Les images plus grandes peuvent contenir de nombreux objets sans vis-à-vis tels que des paysages, des objets, des animaux, des bâtiments et d’autres parties de l’être humain (jambes, épaules, bras, par exemple).

La technologie de détection / reconnaissance faciale était jusqu'alors associée au seul secteur de la sécurité, mais on constate actuellement une expansion active dans d'autres secteurs, notamment la vente au détail, le marketing, les soins de santé, etc.

Comment fonctionne la détection de visage?

Bien que le processus soit quelque peu complexe, les algorithmes de détection de visage commencent souvent par rechercher des yeux humains. Les yeux constituent ce qu’on appelle une vallée et sont l’un des éléments les plus faciles à détecter. Une fois que les yeux sont détectés, l'algorithme peut alors tenter de détecter les régions du visage, notamment les sourcils, la bouche, le nez, les narines et l'iris. Une fois que l'algorithme suppose qu'il a détecté une région faciale, il peut ensuite appliquer des tests supplémentaires pour valider s'il a effectivement détecté un visage. - https://www.facefirst.com/blog/face-detection-vs-face-recognition/

OpenCV

source: https://medium.com/@gsari/digit-recognition-with-opencv-and-python-cbf962f7e2d0

OpenCV (bibliothèque Open Source Computer Vision), qui est une bibliothèque de traitement d'images et de vidéos avec des liaisons en C ++, C, Python et Java. OpenCV est utilisé pour toutes sortes d'analyses d'images et de vidéos, telles que la reconnaissance et la détection faciales, la lecture de plaques d'immatriculation, l'édition de photos, la vision robotique avancée, la reconnaissance optique de caractères, et bien plus encore.

OpenCV possède trois systèmes de reconnaissance de visage intégrés et, grâce à son code propre, vous pouvez les utiliser simplement en modifiant une seule ligne de code. Voici les noms de ces identificateurs de visage et leurs appels OpenCV:

EigenFaces - cv2.face.createEigenFaceRecognizer ()
FisherFaces - cv2.face.createFisherFaceRecognizer ()
Histogrammes de modèles binaires locaux (LBPH) - cv2.face.createLBPHFaceRecognizer ()

Comment trouver des visages avec OpenCV?

Il existe essentiellement deux méthodes principales pour rechercher des visages à l'aide d'OpenCV:

Classificateur de Haar
Classificateur LBP Cascade

La plupart des développeurs utilisent Haar parce que c'est plus précis, mais c'est aussi beaucoup plus lent que LBP. Je vais aussi avec Haar Classifier pour ce tutoriel. Le paquet OpenCV contient en fait toutes les données dont vous avez besoin pour utiliser Haar efficacement. Fondamentalement, vous avez simplement besoin d’un fichier XML contenant les données de visage correctes. Vous pouvez également créer le vôtre si vous saviez ce que vous faisiez ou simplement utiliser ce qui vient avec OpenCV. Pour en savoir plus sur Haar Classifier et LBP Cascade Classifier, cliquez sur ceci et ceci.

Nous allons donc écrire un programme python simple qui prendra des échantillons d’images en entrée et tentera de détecter les visages et les yeux à l’aide d’OpenCV. Vous pouvez télécharger le fichier XML Haar Classifier pour la détection des visages et des yeux à partir d’ici et ici et conserver les fichiers XML dans votre répertoire de travail.

Les dépendances:

pip installer numpy
pip installer matplotlib
pip installer opencv-python

Images d'entrée:

Code source:

importer cv2
importer numpy en tant que np
de pyplot d'importation matplotlib en tant que plt
importation globale
txtfiles = []
pour le fichier glob.glob ("* .jpg"):
    txtfiles.append (fichier)
    
pour ix dans les fichiers txt:
    img = cv2.imread (ix, cv2.IMREAD_COLOR)
    imgtest1 = img.copy ()
    imgtest = cv2.cvtColor (imgtest1, cv2.COLOR_BGR2GRAY)
    facecascade = cv2.CascadeClassifier ('D: \\ KJ \\ Nagesh \\ Téléchargements \\ face_recognition \\ haarcascade_frontalface_default.xml')
    eye_cascade = cv2.CascadeClassifier ('D: \\ KJ \\ Nagesh \\ Téléchargements \\ face_recognition \\ haarcascade_eye.xml')
   
    faces = facecascade.detectMultiScale (imgtest, scaleFactor = 1.2, minNeothers = 5)
 
    print (’Nombre total de faces trouvées’, len (faces))
    
    pour (x, y, w, h) dans les faces:
        face_detect = cv2.rectangle (imgtest, (x, y), (x + w, y + h), (255, 0, 255), 2)
        roi_gray = imgtest [y: y + h, x: x + w]
        roi_color = imgtest [y: y + h, x: x + w] plt.imshow (face_detect)
        eyes = eye_cascade.detectMultiScale (roi_gray)
        pour (ex, ey, ew, hein) dans les yeux:
            eye_detect = cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,0,255), 2)
            plt.imshow (eye_detect)

Maintenant, comprenons ce programme simple:

Étape 1: Importez numpy, matplotlib, open-cv et glob

importer numpy en tant que np
de pyplot d'importation matplotlib en tant que plt
importer cv2
importation globale

Étape 2: Parcourez chacun des fichiers .jpg présents dans votre répertoire de travail actuel en boucle globale et stockez-les dans une liste «fichiers txt». Pour savoir comment lire des fichiers avec glob, cliquez ici.

txtfiles = []
pour le fichier glob.glob ("* .jpg"):
    txtfiles.append (fichier)

Étape 3: Lisez chacun des fichiers .jpg à l’aide de cv2.imread (). La fonction cv2.imread () nécessite deux arguments: le premier est le chemin d'accès à l'image elle-même et le second spécifie le mode de lecture de l'image. Nous pouvons utiliser n'importe lequel des trois ci-dessous comme deuxième argument.

cv2.IMREAD_COLOR - utilisé pour charger une image en couleur. Il néglige la transparence de l'image et constitue le drapeau par défaut. C’est pour les images 8 bits qui n’ont pas le canal alpha.
cv2.IMREAD_GRAYSCALE - responsable du chargement de nos images en niveaux de gris.
cv2.IMREAD_UNCHANGED - Charge une image en utilisant le canal alpha (RGBA).

Lorsque vous chargez une image à l'aide d'OpenCV, celle-ci est chargée dans l'espace colorimétrique BGR par défaut.

Après cela, effectuez une copie de l'image transmise de manière à ce que l'image transmise ne soit pas modifiée.

img = cv2.imread (ix, cv2.IMREAD_COLOR)
    imgtest1 = img.copy ()

Étape 4: convertissez l'image en image grise, car le détecteur de visage OpenCV attend des images en gris.

imgtest = cv2.cvtColor (imgtest1, cv2.COLOR_BGR2GRAY)

Étape 5: Nous devons maintenant charger nos classificateurs Haar (fichiers XML téléchargés) pour la détection des visages et des yeux, qui prend en entrée le fichier de formation du classificateur Haar.

facecascade = cv2.CascadeClassifier ('D: \\ KJ \\ Nagesh \\ Téléchargements \\ face_recognition \\ haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier ('D: \\ KJ \\ Nagesh \\ Téléchargements \\ face_recognition \\ haarcascade_eye.xml')

Étape 6: Comment détecter un visage à partir d'une image à l'aide de CascadeClassifier?

Eh bien, encore une fois, CascadedClassifier d’OpenCV nous a simplifié les choses grâce à detectMultiScale (), qui détecte exactement ce dont vous avez besoin.

detectMultiScale (image, scaleFactor, minNeothers)

Ci-dessous se trouvent des arguments qui devraient passer à detectMultiScale ().

C’est une fonction générale de détection d’objets. Dans ce cas, il détectera les visages depuis notre appel en cascade. S'il trouve une face, il renvoie une liste de positions de cette face sous la forme «Rect (x, y, w, h).». Sinon, renvoie «Aucune».

  • Image: La première entrée est l'image en niveaux de gris.
  • scaleFactor: Cette fonction compense une fausse perception de la taille qui se produit lorsqu'un visage semble être plus grand que l'autre simplement parce qu'il est plus proche de la caméra.
  • minNeothers: algorithme de détection qui utilise une fenêtre mobile pour détecter les objets, il le fait en définissant le nombre d'objets trouvés près de celui en cours avant de pouvoir déclarer le visage trouvé.
faces = facecascade.detectMultiScale (imgtest, scaleFactor = 1.2, minNeothers = 5)

Étape 7: Imprimez maintenant le nombre de faces de chaque image:

print ('Nombre total de faces trouvées', len (faces))

Étape 8: Parcourez la liste des visages et tracez des rectangles sur les images. Ici, fondamentalement, nous trouvons des visages, brisons les visages, leurs tailles et dessinons des rectangles

pour (x, y, w, h) dans les faces:
face_detect = cv2.rectangle (imgtest, (x, y), (x + w, y + h), (255, 0, 255), 2)
roi_gray = imgtest [y: y + h, x: x + w]
roi_color = imgtest [y: y + h, x: x + w]
plt.imshow (face_detect)

Étape 9: Nous effectuerons ensuite la détection des yeux et la partie intéressante est qu’il ne trouverait probablement pas un globe oculaire pour détecter un œil. La plupart des algorithmes de détection des yeux utilisent la peau environnante, les paupières, les cils et les sourcils pour effectuer la détection.

eyes = eye_cascade.detectMultiScale (roi_gray)
pour (ex, ey, ew, hein) dans les yeux:
eye_detect = cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,0,255), 2)
plt.imshow (eye_detect)

Enfin notre sortie:

Fichier de sortie: friends.pngFichier de sortie: Leonardo.PNGFichier de sortie: Nagesh.PNGFichier de sortie: Rahul.PNGFichier de sortie: Amar.PNGFichier de sortie: Sachin.PNGFichier de sortie: Vishak.PNGFichier de sortie: Shahrukh.PNGFichier de sortie: Dog.PNGFichier de sortie: download1.png

Cool !!! N'est-ce pas?

Vous remarquerez une chose ici: dans les deux dernières sorties que nous avons obtenues, aucune détection de visage n’est effectuée, ce qui est évidemment dû au fait que ces deux images n’ont pas de visage pouvant être détecté. L'un est une image d'un chien et l'autre est une rose bleue.

Conclusion:

Nous pouvons donc constater que, avec seulement quelques lignes de code, nous avons démarré avec la détection de visage. À partir de là, nous pouvons créer un modèle de reconnaissance de visage à l'aide d'openCV, qui permettra de prédire le nom et d'autres informations relatives à cette personne. Ce blog est destiné aux débutants qui souhaitent construire quelque chose de cool en utilisant cet incroyable langage de programmation Python.

Il existe de nombreux classificateurs Haar disponibles pour détecter diverses parties du corps humain. Vérifiez le ici.

Eh bien, c'est tout dans ce blog. Merci d'avoir lu :)

Bonne apprentissage !!!

Vous pouvez me joindre sur LinkedIn.