Reconnaissance faciale avec OpenCV

La complexité des machines a augmenté au fil des ans et les ordinateurs ne font pas exception. Les ordinateurs ont aidé l'humanité à résoudre de nombreux problèmes et à accomplir de nombreuses tâches difficiles. Fini le temps où tous les ordinateurs ne faisaient que de simples opérations arithmétiques, les ordinateurs dirigent maintenant le monde.

Les ordinateurs sont devenus si complexes qu'ils sont entraînés à penser comme les humains.
Oui!

Nous allons faire quelque chose de cette nature dans cet article. En tant qu'êtres humains, reconnaître le visage des autres est une tâche simple et malgré les capacités des ordinateurs d'aujourd'hui, ce n'est pas aussi facile pour l'ordinateur, nous devons donc l'entraîner pour qu'il soit capable de faire la même chose.

Beaucoup d'articles que vous verriez là-bas s'arrêteraient à la simple détection des visages, mais cet article couvrirait non seulement la détection des visages, mais également la reconnaissance des visages.

Cela signifie que si l'ordinateur est présenté avec deux photos de moi, il reconnaîtra non seulement quelle partie de l'image est mon visage, il reconnaîtra également que je suis celui sur les deux images également.

Pour commencer, il faudrait d'abord installer opencv sur nos machines, ce qui ne peut être fait que si Python est installé. L'installation de Python n'est pas l'objectif de cet article, donc si vous ne l'avez pas déjà sur votre machine, vous pouvez installer Python à partir du site Web de Python.

Pour installer Open CV, nous pouvons le faire en utilisant la commande pip.

pip installer opencv-python

Nous utiliserons également le package numpy dans cet article, qui doit être installé avec OpenCV à l'aide de la commande ci-dessus.

Si numpy ne s'est pas installé, vous pouvez facilement le faire en utilisant la commande ci-dessous :

pip installer numpy

Pour confirmer que votre OpenCV est installé, lorsque vous activez l'environnement interactif de Python, essayez de l'importer en utilisant :

importer cv2

Si vous n'obtenez pas d'erreur, vous pouvez continuer.

Pour effectuer la reconnaissance faciale, nous écririons trois scripts. Un pour créer un ensemble de données d'images, un autre pour entraîner ces images, puis le dernier pour reconnaître les visages en fonction des résultats de l'entraînement suivi par l'ordinateur.

Nous aurions besoin de la cascade Haar fournie par Open CV. Ce fichier peut être obtenu à partir du répertoire opencv qui est cv2/data/haarcascade_frontalface_default.xml sur ma machine, cela devrait être le même sur votre machine aussi. Copiez le fichier dans le dossier où vous souhaitez faire la reconnaissance faciale.

Maintenant entrons dans le vif du sujet.
Nous essaierions d'obtenir notre webcam pour obtenir les images, nécessaires pour l'ensemble de données.

importer cv2
vid_cam = cv2.Capture vidéo(0)
face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
face_id = 1
compte = 0
tandis que (vid_cam.est ouvert()):
ret, image_frame = vid_cam.lis()
gris = cv2.cvtColor(image_frame, cv2.COULEUR_BGR2GRAY)
faces = face_detector.detectMultiScale(gris, 1.3, 5)
pour (x,y,w,h) dans les faces :
cv2.rectangle(image_frame, (x,y), (x+w,y+h), (255,0,0), 2)
compte += 1
cv2.imwrite("ensemble de données/utilisateur." + str(face_id) + '.' + str(nombre) + ".jpg", gris[y:y+h,x:x+w])
cv2.imshow('frame', image_frame)
si cv2.waitKey(100) & 0xFF == ord('q'):
Pause
compte elif>100 :
Pause
vid_cam.Libération()
cv2.détruireToutesFenêtres()

Donc pour expliquer ce que fait chaque ligne de code :

importer cv2

Voici la commande qui indique à python d'inclure une bibliothèque externe à utiliser dans ce code, dans ce cas il s'agit d'Open CV.

vid_cam = cv2.Capture vidéo(0)

Ce code appelle la bibliothèque Open CV importée pour commencer la capture et la webcam est lancée à ce stade. Si Open CV ne prend pas en charge votre webcam, le code échouera ici.

face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

Pour que nous puissions effectuer la détection d'images, ce code est nécessaire. Open CV utilise le 'haarcascade_frontalface_default.xml' pour la classification en cascade. L'objet résultant est ensuite stocké dans la variable face_detector.

face_id = 1

Voici un cas de définition du numéro d'identification du visage, de sorte que le premier visage obtient un identifiant de 1.

compte = 0

Nous allons prendre quelques images car Open CV doit former des images pour pouvoir reconnaître les visages, la variable count sert de décompte d'images.

tandis que (vid_cam.est ouvert()):

Cela permet aux opérations suivantes de continuer à condition que la caméra vidéo soit ouverte. La méthode isOpened() renvoie True ou False.

ret, image_frame = vid_cam.lis()

Ici, la vid_cam.read() examine la capture vidéo puis capture l'image qui est stockée dans la variable image_frame, si l'opération réussit, le booléen True est renvoyé et stocké dans la variable ret

gris = cv2.cvtColor(image_frame, cv2.COULEUR_BGR2GRAY)

La méthode cvtColor() est utilisée pour convertir le cadre de l'image dans le type de couleur souhaité. Dans ce cas, nous l'avons converti en niveaux de gris.

faces = face_detector.detectMultiScale(gris, 1.3, 5)

Ceci vérifie les trames de différentes tailles et essaie de les mettre à l'échelle, ceci est appliqué sur la variable à laquelle la cascade Haar a été appliquée.

pour (x,y,w,h) dans les faces :

Ici, nous parcourons les faces et ses dimensions, où x et y représentent les coordonnées et w et h représentent respectivement la largeur et la hauteur.

cv2.rectangle(image_frame, (x,y), (x+w,y+h), (255,0,0), 2)

N'oubliez pas que nous travaillons toujours avec la caméra vidéo, la caméra vidéo recadre alors la partie nécessaire de l'image selon les dimensions ci-dessus.

compte += 1

Immédiatement cela est fait, la variable de comptage qui tient lieu de compteur puis incrémente.

cv2.imwrite("ensemble de données/utilisateur." + str(face_id) + '.' + str(nombre) + ".jpg", gris[y:y+h,x:x+w])

L'image recadrée est enregistrée avec le nom User(face_id).(compter).jpg et mis dans un dossier appelé dataset.

cv2.imshow('frame', image_frame)

Après l'enregistrement, ce code garantit que l'image est l'image vidéo est affichée avec un rectangle sur le visage de l'individu une fois la détection du visage effectuée.

si cv2.waitKey(100) & 0xFF == ord('q'):
Pause

Après chaque photo, l'utilisateur est autorisé à arrêter le programme de prendre plus de photos, ce qui peut être fait en appuyant sur le « q » du clavier pendant au moins 100 ms.

compte elif>100 :
Pause

Ce que fait ce code est d'arrêter la vidéo de fonctionner au moment où 100 photos ont été prises, peu importe si l'utilisateur veut en prendre plus ou non.

vid_cam.Libération()

Ici, la webcam est fermée et pas seulement arrêtée de prendre des photos.

cv2.détruireToutesFenêtres()

Ensuite, toutes les fenêtres ouvertes par OpenCV ont été détruites et le code s'exécute jusqu'à la fin.

Maintenant que nous avons terminé avec cela, nous pouvons ensuite entraîner l'ensemble de données d'image :

importer cv2, os
importer numpy en tant que np
de l'image d'importation PIL
reconnaissance = cv2.visage.createLBPHFaceRecognizer()
détecteur = cv2.CascadeClassifier("haarcascade_frontalface_default.xml");
def getImagesAndLabels(chemin):
imagePaths = [os.chemin.join(chemin,f) pour f dans os.listdir(chemin)]
faceSamples=[]
identifiants = []
pour imagePath dans imagePaths :
PIL_img = Image.open(imagePath).convertir('L')
img_numpy = np.tableau(PIL_img,'uint8')
id = int(os.chemin.split(imagePath)[-1].diviser(".")[1])
visages = détecteur.détecterMultiScale(img_numpy)
pour (x,y,w,h) dans les faces :
visageÉchantillons.ajouter(img_numpy[y:y+h,x:x+w])
identifiants.ajouter(id)
retourner faceSamples, ids
faces, ids = getImagesAndLabels('dataset')
reconnaissance.train(visages, np.tableau (identifiants))
reconnaissance.save('formateur/formateur.yml')

Allons de l'avant et expliquons également ce code :

importer cv2, os

Tout comme l'autre code, nous importons ici OpenCV et os dont nous aurions besoin pour le chemin du fichier.

importer numpy en tant que np

Nous importons également la bibliothèque numpy qui serait utilisée pour le calcul matriciel (une matrice est juste un arrangement de tableaux).

de l'image d'importation PIL

Nous importons la bibliothèque d'images Python, puis nous obtenons également la bibliothèque d'images de ce package.

reconnaissance = cv2.visage.createLBPHFaceRecognizer()

Ce que cela fait est d'appliquer la méthode createLBPHFaceRecognizer() au cv2.objet visage, cela faciliterait la reconnaissance des visages car nous n'avons pas à créer notre propre ensemble d'algorithmes.

détecteur = cv2.CascadeClassifier("haarcascade_frontalface_default.xml");

Si vous avez suivi le tutoriel, vous l'auriez déjà rencontré. Il aide à la détection des visages à l'aide du "haarcascade_frontalface_default.xml" pour la classification en cascade.

def getImagesAndLabels(chemin):

Maintenant, nous sommes sur le point de commencer l'apprentissage de l'image proprement dit, nous créons donc une fonction.

imagePaths = [os.chemin.join(chemin,f) pour f dans os.listdir(chemin)]

Ce code vérifie dans le répertoire actuel du fichier et recherche les fichiers image puis les ajoute à cette liste.

faceSamples=[]

Cela initialise une liste d'échantillons, elle est vide à ce stade mais des visages seraient ajoutés au fur et à mesure de l'exécution du code.

identifiants = []

Initialiser une liste d'identifiants, qui est initialement vide.

pour imagePath dans imagePaths :

Rappelez-vous le code qui a vérifié les fichiers image dans le répertoire? Oui? Maintenant, nous allons parcourir chacun de ces fichiers et effectuer des opérations sur eux.

PIL_img = Image.open(imagePath).convertir('L')

Maintenant, la première chose que nous faisons à l'image est de la convertir en niveaux de gris, et ce code fait cela.

img_numpy = np.tableau(PIL_img,'uint8')

L'image en niveaux de gris n'est qu'une série de nombres au même endroit, nous créons donc un tableau numpy à partir d'eux et l'attribuons à une variable.

id = int(os.chemin.split(imagePath)[-1].diviser(".")[1])

Si vous vous souvenez du fichier qui obtient les images, vous vous souviendrez que nous avons nommé les fichiers User(face_id).compter.jpg. Donc ici, nous séparons les noms avec le ".” puis nous extrayons le face_id et affectons à une variable ici. Nous aurions besoin de l'identifiant pour la reconnaissance.

visages = détecteur.détecterMultiScale(img_numpy)

À partir du tableau numpy, la méthode detectMultiScale() va essayer de détecter les visages à partir du motif qu'elle trouve dans le tableau numpy. Ensuite, il attribue les valeurs dans la variable faces.

pour (x,y,w,h) dans les faces :

Ici, nous parcourons les valeurs affectées à la variable. Les valeurs ici sont les coordonnées x et y que nous pourrions prendre comme origine, puis w et h représentant respectivement la largeur et la hauteur.

visageÉchantillons.ajouter(img_numpy[y:y+h,x:x+w])

Auparavant, nous avons créé une liste d'échantillons de visage, mais elle était vide. Ici, nous ajoutons des visages à cette liste, et nous ajoutons le y à h afin d'obtenir les deux valeurs des coordonnées y et la même chose est faite pour x.

identifiants.ajouter(id)

Nous avons maintenant un visage dans la liste d'échantillons de visages, nous obtenons donc son identifiant et l'ajoutons également à la liste des identifiants.

retourner faceSamples, ids

Puis après tout, nous retournons la liste des échantillons de visage et la liste des identifiants.

faces, ids = getImagesAndLabels('dataset')

N'oubliez pas que getImagesAndLabels() n'est qu'une fonction. Nous appelons donc la fonction ici, et les valeurs de retour sont enregistrées dans les variables faces et ids.

reconnaissance.train(visages, np.tableau (identifiants))

C'est ici que se déroule la vraie formation. Nous avons appliqué la méthode createLBPHFaceRecognizer() un peu plus tôt et affecté à une variable de reconnaissance. C'est l'heure de l'entraînement!

reconnaissance.save('formateur/formateur.yml')

Après la formation, nous enregistrons les résultats de la formation.
Après avoir exécuté le code, il crée un fichier appelé trainer.yml qui serait ensuite utilisé par le code de reconnaissance faciale.

Voici le code de reconnaissance faciale :

importer cv2
importer numpy en tant que np
reconnaissance = cv2.visage.createLBPHFaceRecognizer()
reconnaissance.load('formateur/formateur.yml')
cascadePath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)
police = cv2.FONT_HERSHEY_SIMPLEX
came = cv2.Capture vidéo(0)
tant que vrai :
ret, je suis = cam.lis()
gris = cv2.cvtCouleur(im,cv2.COULEUR_BGR2GRAY)
faces = faceCascade.detectMultiScale(gris, 1.2,5)
for(x,y,w,h) dans les faces :
cv2.rectangle(im, (x-20,y-20), (x+w+20,y+h+20), (0,255,0), 4)
Id = reconnaissance.prévoir(gris[y:y+h,x:x+w])
si(Id == 1) :
Id = "Nazmi"
autre:
Id = "Inconnu"
cv2.rectangle(im, (x-22,y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.putText(im, str(Id), (x,y-40), font, 2, (255,255,255), 3)
cv2.imshow('je', je)
si cv2.waitKey(10) & 0xFF == ord('q'):
Pause
came.Libération()
cv2.détruireToutesFenêtres()

Si vous suivez l'article depuis le début, nous l'avons déjà fait. Si vous n'avez pas la gentillesse de faire.

reconnaissance.load('formateur/formateur.yml')

N'oubliez pas que nous avons formé le module de reconnaissance et enregistré un fichier? Oui? Nous chargeons ce fichier maintenant.

cascadePath = "haarcascade_frontalface_default.xml"

Nous travaillerions avec le fichier haarcascade, et ici nous avons attribué le nom de fichier à une variable.

# Créer un classificateur à partir d'un modèle prédéfini
faceCascade = cv2.CascadeClassifier(cascadePath)

Ici, nous arrivons à effectuer une classification en cascade sur le fichier haarcascade.

police = cv2.FONT_HERSHEY_SIMPLEX

Nous définissons le type de police qui serait utilisé lorsque le code reconnaît le visage dans une image et affiche le nom.

came = cv2.Capture vidéo(0)

Nous sommes déjà venus ici, mais cette fois, il est temps de reconnaître les visages. Si vous ne savez pas à quoi sert ce code, il lance la webcam.

tant que vrai :
ret, je suis = cam.lis()
gris = cv2.cvtCouleur(im,cv2.COULEUR_BGR2GRAY)
faces = faceCascade.detectMultiScale(gris, 1.2,5)
for(x,y,w,h) dans les faces :

Tout cela a été fait auparavant, veuillez vérifier le code qui a été utilisé pour enregistrer les images si vous ne savez pas ce que fait le code.

cv2.rectangle(im, (x-20,y-20), (x+w+20,y+h+20), (0,255,0), 4)

Cela aide donc la webcam à détecter où se trouvent les visages et place un rectangle pour indiquer un visage.

Id = reconnaissance.prévoir(gris[y:y+h,x:x+w])

Nous avons déjà chargé le fichier de train dans le module de reconnaissance, il est donc capable de reconnaître le visage maintenant.

si(Id == 1) :
Id = "Moi-même"
autre:
Id = "Inconnu"

Après avoir essayé de reconnaître de quel visage il s'agit, il vérifie l'identifiant et voit s'il existe. Ici, la valeur de l'identifiant serait le nom de la personne qui appartenait à un tel identifiant lors de la création de l'ensemble de données d'image.

cv2.rectangle(im, (x-22,y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.putText(im, str(Id), (x,y-40), font, 2, (255,255,255), 3)

Le code après avoir trouvé le propriétaire de l'Id, dessine un rectangle autour du visage et place le nom du propriétaire du visage. Visage reconnu!

cv2.imshow('je', je)

Ici, l'image vidéo est affichée avec le rectangle délimité.

si cv2.waitKey(10) & 0xFF == ord('q'):
Pause
came.Libération()
cv2.détruireToutesFenêtres()

Donc, une fois terminé, vous pouvez arrêter le programme en appuyant sur la touche 'q', et cela arrête la webcam et la ferme.

Voilà, votre webcam peut maintenant reconnaître les visages et vous pouvez l'utiliser quand vous le souhaitez. En plus d'utiliser la webcam, vous pouvez également charger une image, mais cela nécessite d'autres étapes que celles prises dans cet article.

Vous pouvez trouver le code source utilisé sur son repo github. Tweetez-nous également si vous avez des commentaires ou souhaitez discuter de @linuxhint