La reconnaissance faciale est un processus d'identification des personnes par les caractéristiques uniques de leurs visages. C'est un processus très complexe et fascinant qui a une large gamme d'applications, notamment la sécurité, l'identification et le comptage des personnes, surtout en temps de coronavirus. OpenCV, une bibliothèque open-source qui comprend plusieurs centaines d'algorithmes de vision par ordinateur, est parfait pour cela.

Voici un guide étape par étape sur comment construire un système de reconnaissance faciale en utilisant Python et OpenCV :

Étape 1 : Installer les bibliothèques nécessaires

Tout d'abord, vous devez avoir Python et OpenCV installés sur votre système. Vous pouvez télécharger et installer ces modules en utilisant pip.

pip install opencv-python
pip install opencv-python-headless

Cette commande installera le package OpenCV pour Python.

Étape 2 : Importer les modules nécessaires

Vous devrez importer plusieurs modules intégrés :

import cv2
import os
import numpy as np

Étape 3 : Préparer les données d'entraînement

Vous devez préparer un ensemble de données de visages que le système doit reconnaître. Vous pouvez collecter manuellement ces données ou les obtenir à partir de ressources en ligne.

Placez l'ensemble de données dans un répertoire. Les sous-répertoires de ce répertoire seront les étiquettes des visages.

Par exemple :

/images
/person1
person1_image1.jpg
person1_image2.jpg
...
/person2
person2_image1.jpg
person2_image2.jpg
...
/person3
person3_image1.jpg
person3_image2.jpg
...
...

Vous écrirez ensuite une fonction Python pour charger les images de votre ensemble de données et les convertir en niveaux de gris. Le nom de chaque sous-répertoire sera l'étiquette de chaque image.

fonction pour détecter le visage en utilisant OpenCV

def detect_face(img):

convertir l'image de test en image grise

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

charger le détecteur de visages OpenCV

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

faces = face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5);

si aucun visage n'est détecté alors retourner l'image

if (len(faces) == 0):
return None, None

extraire le visage

(x, y, w, h) = faces[0]

retourner uniquement la partie du visage

return gray[y: y+w, x: x+h], faces[0]

Étape 4 : Entraîner le Modèle

Ensuite, vous devez extraire les visages dans les sous-répertoires, en attribuant des étiquettes à chacun d'eux. Assurez-vous que vous traitez les images dans le même ordre que les étiquettes.

Vous effectuerez ensuite la reconnaissance faciale. Cela créera un objet de reconnaissance. L'objet de reconnaissance peut être formé en utilisant les visages et les étiquettes.

def prepare_training_data(data_folder_path):

Fonction pour préparer les données d'entraînement

Etape - 1 : obtenir les répertoires (un répertoire pour chaque sujet) dans le dossier de données

dirs = os.listdir(data_folder_path)

Etape - 2 : pour chaque répertoire, extraire l'étiquette et les images

faces = []
labels = []

for dir_name in dirs:
label = int(dir_name)

   subject_dir_path = data_folder_path + "/" + dir\_name
   
   subject_images_names = os.listdir(subject_dir_path)
   
   for image_name in subject_images\_names:
       if image\_name.startswith("."):
           continue;
        
       # charger l'image
       image_path = subject_dir_path + "/" + image_name
       image = cv2.imread(image\_path)
        
       # détecter le visage
       face, rect = detect\_face(image)
        
       if face is not None:
           # ajouter le visage à la liste des visages
           faces.append(face)
           # ajouter l'étiquette pour ce visage
           labels.append(label)
            

return faces, labels

Testons notre fonction

préparons d'abord nos données d'entraînement

faces, labels = prepare_training_data("training-data")

créer notre reconnaisseur de visages LBPH

face_recognizer = cv2.face.LBPHFaceRecognizer_create()

entraîner notre reconnaisseur de visages sur nos visages d'entraînement

face_recognizer.train(faces, np.array(labels))

Étape 5 : Faire une Prédiction

Pour faire une prédiction, l'image de test est donnée en entrée à la fonction predict(). Celle-ci retournera l'étiquette et le score de confiance.

fonction pour dessiner un rectangle sur l'image

def draw_rectangle(img, rect):
(x, y, w, h) = rect
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)

function pour dessiner du texte sur l'image donnée

def draw_text(img, text, x, y):
cv2.putText(img, text, (x, y), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 255, 0), 2)

Fonction pour reconnaître la personne dans l'image passée

def predict(test_img):

détecter le visage à partir de l'image

face, rect = detect_face(test_img)
label= face_recognizer.predict(face)

obtenir le nom pour l'étiquette respective retournée par le reconnaîseur de visages

label_text = subjects[label[0]]

dessiner un rectangle autour du visage détecté

draw_rectangle(test_img, rect)

dessiner le nom de la personne prédite

draw_text(test_img, label_text, rect[0], rect[1]-5)
return test_img

Testez la fonction sur une image

test_img1 = cv2.imread("test-data/test1.jpg")
predicted_img1 = predict(test_img1)
cv2.imshow(predicted_img1)
cv2.waitKey(0)
cv2.destroyAllWindows()

Et c'est ainsi que vous construisez un système de reconnaissance faciale en utilisant Python et OpenCV.

Cependant, pour les systèmes qui nécessitent une grande précision et robustesse, il est recommandé d'utiliser des cadres d'apprentissage profond comme Dlib ou FaceNet.