Le développement rapide des technologies d’apprentissage automatique et d’intelligence artificielle a fait des progrès significatifs dans la vision par ordinateur pour la détection et la reconnaissance d’objets. Pourtant, créer un système capable de reconnaître l’humour et l’amusement chez les gens reste un défi pour les programmeurs, car la comédie et le divertissement sont subjectifs et basés sur les goûts personnels et le contexte culturel. Il est donc difficile de créer un système capable de déterminer avec précision ce que les individus trouvent amusant ou agréable.
Cependant, la vision par ordinateur dans la reconnaissance et l’identification faciales a fait des progrès significatifs, largement utilisée dans diverses applications telles que la sécurité, la surveillance et la biométrie. La technologie de reconnaissance faciale identifie principalement les individus en analysant et en comparant leurs traits faciaux à une base de données de visages connus. L’identification faciale consiste à faire correspondre le visage d’une personne à son identité. Il utilise des algorithmes pour extraire les caractéristiques du visage comme la distance entre les yeux, les courbes du nez et l’angle de la mâchoire pour générer une signature faciale distinctive.
Techniques de reconnaissance faciale et d’identification
Il existe différentes méthodes pour reconnaître et identifier les visages, mais ce didacticiel se concentrera sur trois techniques et décrira leurs avantages et leurs inconvénients.
1. Approche basée sur un modèle
Premièrement, l’approche basée sur un modèle compare les traits du visage d’un visage cible avec ceux d’un modèle ou d’une image de référence. L’image modèle comprend plusieurs caractéristiques faciales, telles que la position des yeux, du nez, de la bouche et les distances entre eux. La technique compare ensuite le visage cible avec l’image modèle pour déterminer s’il y a une correspondance. Eigenfaces est l’une des méthodes basées sur des modèles les plus courantes qui utilise l’analyse en composantes principales (ACP) pour réduire la dimensionnalité des images faciales et extraire les caractéristiques les plus pertinentes.
Avantages
- Ils sont très précis avec des modèles de haute qualité
- Gère les variations d’éclairage et d’expressions faciales
Désavantages
- Nécessite des modèles de haute qualité pour des résultats précis
- Peut être coûteux en calcul
2. Approche basée sur les fonctionnalités
Deuxièmement, la technique basée sur les caractéristiques extrait les caractéristiques du visage, telles que la forme des yeux, la distance entre les sourcils et la courbure des lèvres. L’approche compare ensuite ces caractéristiques avec celles d’une base de données de visages connus pour identifier le visage cible. Des exemples de techniques typiques basées sur les caractéristiques comprennent le modèle binaire local (LBP) et la transformation de caractéristiques invariantes à l’échelle (SIFT).
Avantages
- Relativement rapide et efficace
- Fonctionne avec des images basse résolution
Désavantages
- Peut ne pas bien fonctionner avec des conditions d’éclairage variables
- Peut ne pas être robuste aux changements d’expressions faciales ou de poses
3. Approche basée sur l’apprentissage en profondeur
Enfin, une approche basée sur l’apprentissage en profondeur utilise des réseaux de neurones profonds pour apprendre des caractéristiques directement à partir d’images faciales. Les réseaux sont formés sur de grands ensembles de données d’images faciales pour identifier les modèles et les caractéristiques pertinentes pour la reconnaissance faciale. Des exemples de méthodes typiques basées sur l’apprentissage en profondeur comprennent les réseaux de neurones convolutifs (CNN) et les réseaux siamois.
Avantages
- Atteint une grande précision avec de grands ensembles de données
- Gère les variations dans les expressions faciales et les poses
Désavantages
- Nécessite une grande quantité de données d’entraînement
- Coûteux en termes de calcul
NOTE: Il existe plusieurs techniques de reconnaissance faciale et d’identification.
Reconnaissance faciale et identification à l’aide de Python et OpenCV
Avec la disponibilité de bibliothèques puissantes comme OpenCV et les progrès des algorithmes d’apprentissage automatique, il est devenu plus facile que jamais de développer des systèmes de reconnaissance faciale et d’identification à l’aide de Python. OpenCV fournit un riche ensemble de fonctions et d’outils pour le traitement d’image, particulièrement utile dans les tâches de reconnaissance faciale telles que la détection de visage, l’extraction de caractéristiques et la correspondance. Il dispose également de modèles prédéfinis tels que le classificateur Haar Cascades pour la détection des visages et VGG ou ResNet pour étiqueter les visages détectés.
OpenCV fournit divers modèles pour les étiquetages de visage, tels que Eigenfaces, Fisherfaces et Local Binary Patterns Histograms (LBPH). Nous formons ces modèles pour identifier des individus spécifiques en leur présentant des images des individus que nous voulons reconnaître. Eigenfaces utilise l’analyse en composantes principales (PCA) pour construire une image de visage à partir de parties plus petites, tandis que Fisherfaces utilise l’analyse discriminante linéaire (LDA) pour distinguer les visages. LBPH compare la texture des visages à des visages connus.
Identification faciale
Dépendances d’importation
Importez les bibliothèques nécessaires.
import numpy as np
import cv2
import matplotlib.pyplot as plt
from IPython.display import Image
from google.colab import drive
drive.mount('/content/drive')Charger des modèles et une image pré-formés
OpenCV fournit un ensemble de « classificateurs Haar Cascade » pré-formés pour détecter divers objets, y compris les visages. `cv2.CascadeClassifier` est une classe qui représente le classificateur Haar Cascade. Le cv2.data.haarcascades est un chemin vers le répertoire contenant les modèles pré-formés. `haarcascade_frontalface_default.xml` est le fichier contenant le modèle de détection de visage pré-formé. Le modèle est disponible en téléchargement gratuit sur GitHub.
# Load the pre-trained face detection model
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')Charger l’image d’entrée `image1.jpg` peut être une image de votre choix en utilisant la fonction `imread()` d’OpenCV. Il convertit ensuite l’image en niveaux de gris à l’aide de la fonction `cvtColor()` d’OpenCV. L’image en niveaux de gris est requise pour l’algorithme de détection de visage.
# Load the image and convert it to grayscale
img = cv2.imread('/content/drive/MyDrive/Face Detection/image1.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#show the image
plt.imshow(gray)La ligne ci-dessous détecte les visages dans l’image en niveaux de gris à l’aide de la méthode detectMultiScale() de la classe CascadeClassifier. La méthode detectMultiScale() prend les arguments suivants :
`gray` : l’image en niveaux de gris
`scaleFactor` : est un paramètre spécifiant de combien la taille de l’image est minimisée à chaque échelle d’image. Une valeur de 1,3 signifie que l’image est réduite de 30 % à chaque échelle.
`minNeighbors` : est un paramètre spécifiant le nombre de voisins que chaque rectangle candidat doit avoir pour le conserver, une valeur plus élevée entraîne moins de détections mais avec une plus grande confiance.
`La méthode detectMultiScale()` renvoie une liste de rectangles où les visages sont détectés. Chaque rectangle représente un tuple de quatre entiers `(x,y,w,h)` représentant les coordonnées du coin supérieur gauche `(x,y)` du rectangle et sa largeur `w` et sa hauteur `h`.
# Detect faces in the grayscale image
faces = face_cascade.detectMultiScale(gray, 1.3, 5)Dessiner un rectangle dans la région de la face
Créons une boucle qui dessine des rectangles autour des visages détectés dans l’image d’origine. La fonction cv2.rectangle() prend les arguments suivants :
`img` : l’image d’origine.
`(x,y)` : les coordonnées du coin supérieur gauche du rectangle.
`(x+w,y+h)` : les coordonnées du coin inférieur droit du rectangle.
`(255,0,0)` : représente la couleur binaire du rectangle dessiné au format RVB. (255,0,0) représente le bleu.
`5` : l’épaisseur de la bordure du rectangle en pixels.
# Draw rectangles around the detected faces
for (x,y,w,h) in faces:
cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),5)
#Show the image after building the rectangle.
# Display the image with the detected faces
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.show()
# Save the detected image by name
cv2.imwrite('detected_image.jpg', img)
#Confirm if saved image exists.
detected_image=cv2.imread("detected_image.jpg", 1)
gray_channels_reversed = detected_image[:, :, ::-1]
plt.imshow(gray_channels_reversed)La reconnaissance faciale
Nous n’entrerons pas dans une explication comme celle ci-dessus, mais utiliserons l’image détectée enregistrée ci-dessus pour confirmer si le modèle fonctionne pour l’identification en donnant différentes images pour la détection.
Dépendances d’importation
import numpy as np
import cv2
import matplotlib.pyplot as plt
import dlib
from imutils import face_utils
from scipy.spatial.distance import cosine
from sklearn.metrics.pairwise import cosine_similarityCharger le modèle de détection de visage et le détecteur de repère facial
La fonction `dlib.get_frontal_face_detector()` renvoie un modèle de détection de visage pré-entraîné capable de détecter des visages humains dans des images. Pour plus d’informations, consultez les fonctions de dlib.net. Téléchargez également le détecteur de points de repère.
# Load the face detection model and the facial landmark detector
face_detector = dlib.get_frontal_face_detector()
landmark_detector = dlib.shape_predictor('/content/drive/MyDrive/Face Detection/shape_predictor_68_face_landmarks_GTX.dat')
# Load the detected image of
img1 = cv2.imread('/content/drive/MyDrive/Face Detection/detected_image.jpg')
gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
# Detect the face and facial landmarks of the image
rects1 = face_detector(gray1, 1)
landmarks1 = landmark_detector(gray1, rects1[0])
landmarks1 = face_utils.shape_to_np(landmarks1)
# Load another image to compare with the image loaded previously
img2 = cv2.imread('/content/drive/MyDrive/Face Detection/001_d3323f3c.jpg')
gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)### Set model parameter
# Detect the face and facial landmarks of the second image
rects2 = face_detector(gray2, 1)
landmarks2 = landmark_detector(gray2, rects2[0])
landmarks2 = face_utils.shape_to_np(landmarks2)
# Extract the features of the two images by computing the Euclidean distances between facial landmarks
features1 = np.zeros(68)
features2 = np.zeros(68)
for i in range(68):
features1[i] = np.linalg.norm(landmarks1[i] - landmarks1[0])
features2[i] = np.linalg.norm(landmarks2[i] - landmarks2[0])
#### Train on similarities
# Compute the cosine similarity between the two feature vectors
score = cosine(features1, features2)
# Check if the score is below a certain threshold (e.g. 0.5) to determine if the two faces match
if...