Reconnaissance faciale en temps réel :un projet de bout en bout

Nous allons apprendre, étape par étape, comment utiliser une PiCam pour reconnaître un visage en temps réel. Lors de mon dernier tutoriel explorant OpenCV, nous avons appris le SUIVI D'OBJETS DE VISION AUTOMATIQUE.

Nous allons maintenant utiliser notre PiCam pour reconnaître les visages en temps réel, comme vous pouvez le voir ci-dessous :

Ce projet a été réalisé avec cette fantastique "Open Source Computer Vision Library", l'OpenCV. Sur ce tutoriel, nous allons nous concentrer sur Raspberry Pi (donc, Raspbian comme OS) et Python, mais j'ai aussi testé le code sur My Mac et ça marche aussi très bien. OpenCV a été conçu pour l'efficacité de calcul et avec un fort accent sur les applications en temps réel. Il est donc parfait pour la reconnaissance faciale en temps réel à l'aide d'un appareil photo.

3 phases

Pour créer un projet complet sur la reconnaissance faciale, nous devons travailler sur 3 phases bien distinctes :

• Détection de visage et collecte de données

• Former l'outil de reconnaissance

• Reconnaissance des visages

Le schéma fonctionnel ci-dessous résume ces phases :

Étape 1 :BoM - Nomenclature

Parties principales :

• Raspberry Pi V3 – 32,00 USD

• Module vidéo pour mini caméra OV5647 avec capteur 1080p 5 mégapixels – 13,00 USD

Étape 2 :Installation du package OpenCV 3

J'utilise un Raspberry Pi V3 mis à jour vers la dernière version de Raspbian (Stretch), donc la meilleure façon d'installer OpenCV est de suivre l'excellent tutoriel développé par Adrian Rosebrock : Raspbian Stretch :Installer OpenCV 3 + Python sur votre Raspberry Pi.

J'ai essayé plusieurs guides différents pour installer OpenCV sur mon Pi. Le tutoriel d'Adrian est le meilleur. Je vous conseille de faire de même, en suivant pas à pas sa directive.

Une fois que vous avez terminé le tutoriel d'Adrian, vous devriez avoir un environnement virtuel OpenCV prêt à exécuter nos expériences sur votre Pi.

Allons dans notre environnement virtuel et vérifions qu'OpenCV 3 est correctement installé.

Adrian recommande d'exécuter la commande « source » à chaque fois que vous ouvrez un nouveau terminal pour vous assurer que vos variables système ont été correctement configurées.

source ~/.profile

Entrons ensuite dans notre environnement virtuel :

cv de travail

Si vous voyez le texte (cv) précédant votre invite, alors vous êtes dans le cv virtuel environnement :

(cv) pi@raspberry :~$

Adrian attire l'attention sur le fait que l'environnement virtuel cv Python est entièrement indépendant et séquestré de la version Python par défaut incluse dans le téléchargement de Raspbian Stretch. Ainsi, les packages Python du répertoire global site-packages ne seront pas disponibles pour l'environnement virtuel cv. De même, tous les packages Python installés dans les packages de site de cv ne seront pas disponibles pour l'installation globale de Python.

Maintenant, entrez dans votre interpréteur Python :

Python

et confirmez que vous utilisez la version 3.5 (ou supérieure).

Dans l'interpréteur (le « >>> » apparaîtra), importez la bibliothèque OpenCV :

importer cv2

Si aucun message d'erreur n'apparaît, l'OpenCV est correctement installé SUR VOTRE ENVIRONNEMENT VIRTUEL PYTHON.

Vous pouvez également vérifier la version d'OpenCV installée :

cv2.__version__

La 3.3.0 devrait apparaître (ou une version supérieure qui pourrait sortir dans le futur).

L'écran d'impression du terminal ci-dessus montre les étapes précédentes.

Étape 3 : tester votre appareil photo

Une fois OpenCV installé dans votre RPi, testons pour confirmer que votre appareil photo fonctionne correctement.

Je suppose que vous avez déjà installé une PiCam sur votre Raspberry Pi.

Vous devez avoir activé la caméra lorsque vous avez parcouru le didacticiel d'Adrian, sinon les pilotes ne seront pas installés correctement.

Au cas où vous auriez une erreur comme : Erreur OpenCV :Échec de l'assertion , vous pouvez essayer de résoudre le problème à l'aide de la commande :

sudo modprobe bcm2835-v4l2

Une fois tous les pilotes correctement installés, entrez le code Python ci-dessous sur votre IDE :

importer numpy as np
import cv2
cap =cv2.VideoCapture(0)
cap.set(3,640) # définir la largeur
cap.set(4,480) # définir la hauteur
while(True) :
ret, frame =cap.read()
frame =cv2.flip(frame, -1) # Retourner la caméra verticalement
gray =cv2.cvtColor(frame , cv2.COLOR_BGR2GRAY)

cv2.imshow('cadre', cadre)
cv2.imshow('gris', gris)

k =cv2.waitKey(30) &0xff
if k ==27 :# appuyez sur 'ESC' pour quitter
break
cap.release()
cv2.destroyAllWindows()

Le code ci-dessus capturera le flux vidéo qui sera généré par votre PiCam, affichant les deux, en couleur BGR et en mode Gris.

Notez que j'ai fait pivoter mon appareil photo verticalement en raison de la façon dont il est assemblé. Si ce n'est pas votre cas, commentez ou supprimez la ligne de commande « flip ».

Vous pouvez également télécharger le code depuis mon GitHub : simpleCamTest.py

Pour exécuter, entrez la commande :

python simpleCamTest.py

Pour terminer le programme, vous devez appuyer sur la touche [ESC] de votre clavier. Cliquez avec votre souris sur la fenêtre vidéo, avant d'appuyer sur [ESC].

L'image ci-dessus montre le résultat.

Certains fabricants ont rencontré des problèmes en essayant d'ouvrir l'appareil photo (messages d'erreur « Échec de l'assertion »). Cela pourrait arriver si la caméra n'était pas activée lors de l'installation d'OpenCv et que les pilotes de la caméra ne s'installaient pas correctement. Pour corriger, utilisez la commande :

sudo modprobe bcm2835-v4l2

Vous pouvez également ajouter bcm2835-v4l2 à la dernière ligne du fichier /etc/modules afin que le pilote se charge au démarrage.

Pour en savoir plus sur OpenCV, vous pouvez suivre le tutoriel : loading -video-python-opencv-tutorial

Étape 4 :Détection des visages

La tâche la plus basique sur la reconnaissance faciale est bien sûr la « détection de visage ». Avant tout, vous devez « capturer » un visage (Phase 1) afin de le reconnaître, par rapport à un nouveau visage capturé dans le futur (Phase 3).

La façon la plus courante de détecter un visage (ou tout objet) est d'utiliser le « classificateur Haar Cascade »

La détection d'objets à l'aide des classificateurs en cascade Haar est une méthode efficace de détection d'objets proposée par Paul Viola et Michael Jones dans leur article intitulé "Rapid Object Detection using a Boosted Cascade of Simple Features" en 2001. Il est une approche basée sur l'apprentissage automatique où une fonction en cascade est formée à partir d'un grand nombre d'images positives et négatives. Il est ensuite utilisé pour détecter des objets dans d'autres images.

Ici, nous allons travailler avec la détection de visage. Initialement, l'algorithme a besoin de beaucoup d'images positives (images de visages) et négatives (images sans visages) pour entraîner le classificateur. Ensuite, nous devons en extraire des fonctionnalités. La bonne nouvelle est qu'OpenCV est livré avec un entraîneur ainsi qu'un détecteur. Si vous souhaitez former votre propre classificateur pour n'importe quel objet comme une voiture, des avions, etc., vous pouvez utiliser OpenCV pour en créer un. Ses détails complets sont donnés ici : Formation au classificateur en cascade.

Si vous ne souhaitez pas créer votre propre classificateur, OpenCV contient déjà de nombreux classificateurs pré-entraînés pour le visage, les yeux, le sourire, etc. Ces fichiers XML peuvent être téléchargés à partir du répertoire haarcascades.

Assez de théorie, créons un détecteur de visage avec OpenCV !

Téléchargez le fichier : faceDetection.py depuis mon GitHub.

importer numpy en tant que np
importer cv2
faceCascade =cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
cap =cv2.VideoCapture(0)
cap.set(3,640) # définir la largeur
cap.set(4,480) # définir la hauteur
tandis que True :
ret, img =cap.read()
img =cv2.flip(img, –1 )
gris =cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces =faceCascade.detectMultiScale(
gris,
scaleFactor=1,2,
minNeighbors=5,
minSize=(20, 20)
)
pour (x,y,w,h) dans les faces :
cv2.rectangle(img,(x,y),(x +w,y+h),(255,0,0),2)
roi_gray =gray[y:y+h, x:x+w]
roi_color =img[y:y+ h, x:x+w]
cv2.imshow('video',img)
k =cv2.waitKey(30) &0xff
if k ==27 :# appuyez sur 'ESC ' pour quitter
break
cap.release()
cv2.destroyAllWindows()

Croyez-le ou non, les quelques lignes de code ci-dessus sont tout ce dont vous avez besoin pour détecter un visage, en utilisant Python et OpenCV.

Lorsque vous comparez avec le dernier code utilisé pour tester la caméra, vous vous rendrez compte que peu de pièces y ont été ajoutées. Notez la ligne ci-dessous :

faceCascade =cv2.CascadeClassifier(‘Cascades/haarcascade_frontalface_default.xml’)

C'est la ligne qui charge le "classifier" (qui doit être dans un répertoire nommé "Cascades/", sous le répertoire de votre projet).

Ensuite, nous allons régler notre caméra et à l'intérieur de la boucle, charger notre vidéo d'entrée en mode niveaux de gris (le même que nous avons vu auparavant).

Maintenant, nous devons appeler notre fonction de classificateur, en lui passant des paramètres très importants, comme le facteur d'échelle, le nombre de voisins et la taille minimale du visage détecté.

faces =faceCascade.detectMultiScale(
gris,
scaleFactor=1.2,
minNeighbors=5,
minSize=(20, 20)
)

Où,

• gris est l'image en niveaux de gris d'entrée.

• facteur d'échelle est le paramètre spécifiant de combien la taille de l'image est réduite à chaque échelle d'image. Il est utilisé pour créer la pyramide à l'échelle.

• minVoisins est un paramètre spécifiant le nombre de voisins que chaque rectangle candidat doit avoir pour le conserver. Un nombre plus élevé donne moins de faux positifs.

• minSize est la taille minimale du rectangle pour être considéré comme un visage.

La fonction détectera les visages sur l'image. Ensuite, il faut « marquer » les visages dans l'image, à l'aide, par exemple, d'un rectangle bleu. Ceci est fait avec cette partie du code :

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

Si des visages sont trouvés, il renvoie les positions des visages détectés sous la forme d'un rectangle avec le coin supérieur gauche (x,y) et ayant "w" comme largeur et "h" comme hauteur ==> (x,y,w,h). Veuillez voir l'image.

Une fois ces emplacements obtenus, nous pouvons créer un « ROI » (rectangle dessiné) pour le visage et présenter le résultat avec imshow()  fonction.

Exécutez le script python ci-dessus sur votre environnement python, à l'aide du terminal Rpi :

python faceDetection.py

Le résultat :

Vous pouvez également inclure des classificateurs pour la « détection des yeux » ou encore la « détection du sourire ». Dans ces cas, vous incluez la fonction de classificateur et le dessin du rectangle à l'intérieur de la boucle du visage, car il n'aurait aucun sens de détecter un œil ou un sourire à l'extérieur d'un visage.

A noter que sur un Pi, avoir plusieurs classifieurs dans un même code va ralentir le traitement, une fois que cette méthode de détection (HaarCascades) utilise une grande puissance de calcul. Sur un ordinateur de bureau, il est plus facile de l'exécuter.

Exemples

Sur mon GitHub vous trouverez d'autres exemples :

• faceEyeDetection.py

• faceSmileDetection.py

• faceSmileEyeDetection.py

Et sur la photo, vous pouvez voir le résultat.

Vous pouvez également suivre le tutoriel ci-dessous pour mieux comprendre la détection de visage :

Tutoriel Python OpenCV sur la détection d'objets en cascade Haar pour le visage et les yeux

Étape 5 :Collecte de données

Tout d'abord, je dois remercier Ramiz Raja pour son excellent travail sur la reconnaissance faciale sur les photos :

RECONNAISSANCE DU VISAGE À L'AIDE D'OPENCV ET DE PYTHON :GUIDE DU DÉBUTANT

et aussi Anirban Kar, qui a développé un tutoriel très complet en vidéo :

RECONNAISSANCE DU VISAGE – 3 parties

Je vous recommande vraiment de jeter un œil aux deux tutoriels.

En disant cela, commençons la première phase de notre projet. Ce que nous allons faire ici, c'est à partir de la dernière étape (Détection de visage), nous allons simplement créer un ensemble de données, où nous stockerons pour chaque identifiant, un groupe de photos en gris avec la partie qui a été utilisée pour la détection de visage.

Tout d'abord, créez un répertoire dans lequel vous développez votre projet, par exemple, FacialRecognitionProject :

mkdir Projet de reconnaissance faciale

Dans ce répertoire, outre les 3 scripts python que nous allons créer pour notre projet, nous devons y avoir enregistré le Facial Classifier. Vous pouvez le télécharger depuis mon GitHub : haarcascade_frontalface_default.xml

Ensuite, créez un sous-répertoire dans lequel nous stockerons nos échantillons de visage et nommez-le « ensemble de données » :

ensemble de données mkdir

Et téléchargez le code depuis mon GitHub : 01_face_dataset.py

import cv2
import os
cam =cv2.VideoCapture(0)
cam.set(3, 640) # définir la largeur de la vidéo
cam.set(4, 480) # définir hauteur de la vidéo
face_detector =cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
# Pour chaque personne, entrez un identifiant de visage numérique
face_id =input('\n entrez l'identifiant de l'utilisateur et appuyez sur ==> ')
print("\n [INFO] Initialisation de la capture de visage. Regardez la caméra et attendez …")
# Initialisez le nombre de visages d'échantillonnage individuel
count =0
while(True) :
ret, img =cam.read()
img =cv2.flip(img, -1) # retourne l'image vidéo verticalement
gray =cv2.cvtColor(img , cv2.COLOR_BGR2GRAY)
faces =face_detector.detectMultiScale(gray, 1.3, 5)
pour (x,y,w,h) dans les faces :
cv2.rectangle(img, (x ,y), (x+w,y+h), (255,0,0), 2)
count +=1
# Enregistrer l'image capturée dans le dossier des jeux de données
cv2 .imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y+h,x:x+w])
cv2. imshow('image', img)
k =cv2.waitKey(100) &0x ff # Appuyez sur 'ESC' pour quitter la vidéo
if k ==27 :
break
elif count>=30 :# Prenez 30 échantillons de visage et arrêtez la vidéo
break
# Faites un peu de nettoyage
print("\n [INFO] Quitter le programme et nettoyer les choses")
cam.release()
cv2.destroyAllWindows()

Le code est très similaire au code que nous avons vu pour la détection de visage. Ce que nous avons ajouté, c'était une "commande d'entrée" pour capturer un identifiant utilisateur, qui devrait être un nombre entier (1, 2, 3, etc.)

face_id =input(‘\n entrez l'identifiant de l'utilisateur et appuyez sur ==> ‘)

Et pour chacune des images capturées, nous devons l'enregistrer sous forme de fichier dans un répertoire « dataset » :

cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y+h,x:x+w])

Notez que pour enregistrer le fichier ci-dessus, vous devez avoir importé la bibliothèque « os ». Le nom de chaque fichier suivra la structure :

User.face_id.count.jpg

Par exemple, pour un utilisateur avec un face_id =1, le 4ème exemple de fichier sur le répertoire dataset/ sera quelque chose comme :

Utilisateur.1.4.jpg

comme indiqué sur la photo de mon Pi :

Sur mon code, je capture 30 échantillons de chaque identifiant. Vous pouvez le changer sur le dernier « elif ». Le nombre d'échantillons est utilisé pour rompre la boucle où les échantillons de visage sont capturés.

Exécutez le script Python et capturez quelques identifiants. Vous devez exécuter le script chaque fois que vous souhaitez agréger un nouvel utilisateur (ou modifier les photos d'un utilisateur déjà existant).

Étape 6 :Formateur

Sur cette deuxième phase, nous devons prendre toutes les données utilisateur de notre ensemble de données et « former » l'OpenCV Recognizer. Cela se fait directement par une fonction OpenCV spécifique. Le résultat sera un fichier .yml qui sera enregistré dans un répertoire « trainer/ ».

Lire plus de détails : Reconnaissance faciale en temps réel :un projet de bout en bout