Projet de détection de visage en Python [en 5 étapes faciles]

L'identification d'objets et la détection de visages sont probablement les applications les plus populaires de la vision par ordinateur. Cette technologie trouve des applications dans diverses industries, telles que la sécurité et les médias sociaux. Nous construisons donc un projet de détection de visage via Python.

Notez que vous devez être familiarisé avec la programmation en Python, OpenCV et NumPy. Cela garantira que vous ne serez pas confus lorsque vous travaillerez sur ce projet. Commençons.

Nous avons partagé deux méthodes pour effectuer la reconnaissance faciale. Le premier utilise la bibliothèque de reconnaissance faciale de Python, tandis que l'autre utilise OpenCV et NumPy. Consultez nos programmes de science des données pour en savoir plus.

Reconnaissance faciale avec la "reconnaissance faciale" de Python

La méthode la plus simple pour détecter les visages consiste probablement à utiliser la bibliothèque de reconnaissance faciale de Python . Il avait une précision de 99,38% dans la base de données LFW. Son utilisation est assez simple et ne demande pas beaucoup d'efforts. De plus, la bibliothèque dispose d'une commande dédiée "face_recognition" pour identifier les visages dans les images.

Comment utiliser la reconnaissance faciale

Vous pouvez distinguer les visages dans les images en utilisant la commande 'face_locations' :

importer la reconnaissance faciale

image = face_recognition.load_image_file("votre_fichier.jpg")

face_locations = face_recognition.face_locations(image)

Il peut également reconnaître les visages et les associer à leurs noms :

importer la reconnaissance faciale

image_connue = reconnaissance_visage.load_image_file("modi.jpg")

image_inconnue = reconnaissance_visage.load_image_file("inconnu.jpg")

modi_encoding = face_recognition.face_encodings(known_image)[0]

codage_inconnu = reconnaissance_visage.codages_face(image_inconnue)[0]

résultats = face_recognition.compare_faces([modi_encoding], unknown_encoding)

L'image contient "Narendra Modi"

Il y a beaucoup d'autres choses que vous pouvez effectuer avec cette bibliothèque en la combinant avec d'autres. Nous allons maintenant discuter de l'exécution de la reconnaissance faciale avec d'autres bibliothèques de premier plan en Python, en particulier OpenCV et NumPy.

Lire la suite : Tutoriel Python NumPy : Apprendre Python Numpy avec des exemples

Projet de détection de visage en Python

Dans ce projet, nous avons effectué la détection et la reconnaissance des visages en utilisant OpenCV et NumPy. Nous avons utilisé Raspberry Pi, mais vous pouvez également l'utiliser avec d'autres systèmes. Vous n'aurez qu'à modifier légèrement le code pour l'utiliser sur un autre appareil (comme un Mac ou un PC Windows).

Un certain crédit pour ce projet revient à Marcelo Rovai .

Étape 1 : Installer les bibliothèques

Tout d'abord, vous devez installer les bibliothèques requises, OpenCV et NumPy. Vous pouvez l'installer facilement via:

pip installer opencv-python

pip installer opencv-contrib-python

Pour installer NumPy sur votre système, utilisez la même commande que ci-dessus et remplacez 'opencv-python' par 'numpy' :

pip installer numpy

Étape 2 : Détecter les visages

Maintenant, vous devez configurer votre caméra et la connecter à votre système. La caméra doit fonctionner correctement pour éviter tout problème de détection de visage.

Avant que notre caméra ne nous reconnaisse, elle doit d'abord détecter les visages. Nous utiliserons le classificateur Haar Cascade pour la détection des visages. Il s'agit principalement d'une méthode de détection d'objets dans laquelle vous entraînez une fonction en cascade à travers des images négatives et positives, après quoi il devient capable de détecter des objets dans d'autres photos.

Dans notre cas, nous voulons que notre modèle détecte les visages. OpenCV est livré avec un entraîneur et un détecteur, donc l'utilisation du classificateur Haar Cascade est relativement plus confortable avec cette bibliothèque. Vous pouvez créer votre classificateur pour détecter également d'autres images.

Voici le code :

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 Vrai :

ret, img = cap.read()

img = cv2.flip(img, -1)

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

faces = faceCascade.detectMultiScale(

grise,

facteur d'échelle=1.2,

minVoisins=5,

Taille min=(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('vidéo',img)

k = cv2.waitKey(30) & 0xff

si k == 27 : # appuyez sur 'ESC' pour quitter

Pause

cap.release()

cv2.destroyAllWindows()

Étape 3 : Recueillir des données

Maintenant que votre modèle peut identifier les visages, vous pouvez l'entraîner pour qu'il commence à reconnaître le visage sur l'image. Pour ce faire, vous devez lui fournir plusieurs photos des visages dont vous souhaitez qu'il se souvienne.

C'est pourquoi nous allons commencer par créer notre jeu de données en rassemblant des photos. Après avoir collecté les images nécessaires, ajoutez des identifiants pour chaque personne, afin que le modèle sache quel visage associer à quel identifiant. Commencez avec les images d'une personne et ajoutez-en au moins 10-20. Utilisez différentes expressions pour obtenir les résultats les plus efficaces.

Créez un script pour ajouter des identifiants d'utilisateur aux images, afin que vous n'ayez pas à le faire manuellement à chaque fois. Le script est essentiel si vous souhaitez utiliser votre modèle pour plusieurs visages.

Apprenez des cours d'apprentissage automatique des meilleures universités du monde. Gagnez des programmes de maîtrise, Executive PGP ou Advanced Certificate pour accélérer votre carrière.

Étape #4 : Entraînez-vous

Après avoir créé le jeu de données des images de la personne, vous devez entraîner le modèle. Vous insérez les images dans votre module de reconnaissance OpenCV, et il créera un fichier nommé 'trainer.yml' à la fin.

À ce stade, il vous suffit de fournir au modèle des images et leurs ID afin que le modèle puisse se familiariser avec l'ID de chaque image. Après avoir terminé la formation du modèle, nous pouvons le tester.

Voici le code :

importer cv2

importer numpy en tant que np

à partir de l'image d'importation PIL

importer le système d'exploitation

# Chemin pour la base de données d'images de visage

chemin = 'ensemble de données'

reconnaisseur = cv2.face.LBPHFaceRecognizer_create()

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

# fonction pour obtenir les images et les données d'étiquette

def getImagesAndLabels(path):

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

faceSamples=[]

identifiants = []

pour imagePath dans imagePaths :

PIL_img = Image.open(imagePath).convert('L') # niveaux de gris

img_numpy = np.array(PIL_img,'uint8′)

id = int(os.path.split(imagePath)[-1].split(“.”)[1])

visages = détecteur.detectMultiScale(img_numpy)

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

faceSamples.append(img_numpy[y:y+h,x:x+w])

ids.append(id)

retourner faceSamples,ids

print ("\n [INFO] Visages d'entraînement. Cela prendra quelques secondes. Attendez...")

faces,ids = getImagesAndLabels(chemin)

Reconnaître.train(visages, np.array(ids))

# Enregistrez le modèle dans trainer/trainer.yml

Reconnaître.write('trainer/trainer.yml')

# Imprimez le nombre de visages formés et terminez le programme

print("\n [INFO] {0} visages formés. Sortie du programme".format(len(np.unique(ids))))

Apprendre : Application MATLAB dans la reconnaissance faciale : code, description et syntaxe

Étape n ° 5 : Démarrer la reconnaissance

Maintenant que vous avez formé le modèle, nous pouvons commencer à tester le modèle. Dans cette section, nous avons ajouté des noms aux identifiants afin que le modèle puisse afficher les noms des utilisateurs respectifs qu'il reconnaît.

Le modèle ne reconnaît pas une personne. Il prédit si le visage qu'il détecte correspond au visage présent dans sa base de données. Notre modèle affiche un pourcentage de la correspondance entre le visage et le visage présent dans sa base de données. Sa précision dépendra fortement de l'image que vous testez et des images que vous avez ajoutées à votre base de données (les images avec lesquelles vous avez formé le modèle).

Voici le code :

importer cv2

importer numpy en tant que np

importer le système d'exploitation

reconnaisseur = cv2.face.LBPHFaceRecognizer_create()

Reconnaître.lire('trainer/trainer.yml')

cascadePath = "haarcascade_frontalface_default.xml"

faceCascade = cv2.CascadeClassifier(cascadePath);

police = cv2.FONT_HERSHEY_SIMPLEX

#initier le compteur d'identifiants

identifiant = 0

# noms liés aux ids : example ==> upGrad : id=1, etc

noms = ['Aucun', upGrad', Moi', 'Ami', 'Y', 'X']

# Initialiser et démarrer la capture vidéo en temps réel

cam = cv2.VideoCapture(0)

cam.set(3, 640) # définir la largeur de la vidéo

cam.set(4, 480) # définir la hauteur de la vidéo

# Définir la taille minimale de la fenêtre pour être reconnu comme un visage

minW = 0.1*cam.get(3)

minH = 0.1*cam.get(4)

tandis que Vrai :

ret, img =cam.read()

img = cv2.flip(img, -1) # Retourner verticalement

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

faces = faceCascade.detectMultiScale(

grise,

facteur d'échelle = 1,2,

minVoisins = 5,

minTaille = (int(minW), int(minH)),

)

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

cv2.rectangle(img, (x,y), (x+l,y+h), (0,255,0), 2)

id, confiance = identifier.predict(gray[y:y+h,x:x+w])

# Si la confiance est inférieure à 100 ==> "0" : correspondance parfaite

si (confiance < 100) :

id = noms[id]

confiance = ” {0}%”.format(round(100 – confiance))

autre:

identifiant = "inconnu"

confiance = ” {0}%”.format(round(100 – confiance))

cv2.putText(

img,

chaîne(id),

(x+5,y-5),

Police de caractère,

1,

(255,255,255),

2

)

cv2.putText(

img,

str(confiance),

(x+5,y+h-5),

Police de caractère,

1,

(255,255,0),

1

)

cv2.imshow('caméra',img)

k = cv2.waitKey(10) & 0xff # Appuyez sur 'ESC' pour quitter la vidéo

si k == 27 :

Pause

# Faites un nettoyage

print("\n [INFO] Quitter le programme et effectuer le nettoyage")

cam.release()

cv2.destroyAllWindows()

Nous avons atteint la fin de notre projet de détection de visage en Python. Vous savez maintenant comment créer un modèle d'apprentissage automatique qui détecte et reconnaît les visages. Assurez-vous de partager vos résultats avec nous!

Apprendre : Tutoriel de détection d'objets TensorFlow pour les débutants

En savoir plus sur l'apprentissage automatique

Nous espérons que vous avez aimé ce projet de détection de visage. Si vous souhaitez le rendre plus difficile, vous pouvez ajouter plusieurs visages dans votre jeu de données et entraîner votre modèle en conséquence. Vous pouvez également le combiner avec d'autres bibliothèques et étendre le projet à autre chose, comme un système de sécurité par détection de visage pour un programme !

Si vous souhaitez en savoir plus sur l'apprentissage automatique, consultez le programme Executive PG d'IIIT-B & upGrad en apprentissage automatique et IA, conçu pour les professionnels en activité et offrant plus de 450 heures de formation rigoureuse, plus de 30 études de cas et missions, IIIT -B Statut d'anciens élèves, 5+ projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.