cours
Détection de visages avec Python en utilisant OpenCV
Qu'est-ce que la vision par ordinateur ?
Nous vivons actuellement une ère de révolution de l'IA, marquée par des avancées impressionnantes dans le domaine de l'apprentissage profond. Au cours des derniers mois, nous avons été témoins d'applications de l'intelligence artificielle qui ont stupéfié le monde en générant des œuvres d'art réalistes, en réussissant l'examen du barreau et en écrivant du code Python pour créer des sites web.
La vision par ordinateur est une application d'apprentissage profond qui se trouve au cœur de cette révolution. Elle permet aux ordinateurs de tirer des conclusions à partir de données visuelles telles que des images et des fichiers vidéo. Les exemples de vision par ordinateur comprennent la détection de visages, la reconnaissance faciale, l'estimation de la pose humaine et la détection d'obstacles. Dans ce tutoriel, nous allons explorer comment effectuer la détection de visages avec OpenCV, en examinant à la fois des images fixes et des images en temps réel.
Applications de la vision par ordinateur
Pourquoi avons-nous besoin de la vision par ordinateur alors que la vision humaine est une tâche relativement triviale pour la plupart des humains ?
S'il est vrai que les humains peuvent effectuer des tâches visuelles avec facilité et n'ont besoin que de quelques échantillons de données, l'IA est hautement évolutive. Les modèles de vision par ordinateur peuvent traiter des millions de points de données lorsqu'ils sont déployés dans des véhicules de surveillance et des véhicules autonomes. Il s'agit d'une échelle que la vision humaine ne peut tout simplement pas atteindre.
En outre, les applications de vision par ordinateur peuvent être intégrées dans des capteurs, des caméras et des dispositifs intelligents pour le traitement d'images en temps réel, 24 heures sur 24 et 7 jours sur 7. Là encore, il s'agit d'un exploit incroyablement difficile à réaliser pour les humains.
Enfin, l'IA n'est pas sensible aux biais, à la fatigue et à l'inattention. Alors que les humains peuvent se fatiguer et négliger une faille de sécurité, une application de vision par ordinateur ne faiblira jamais, réduisant ainsi le risque d'incidents manqués.
Examinons quelques applications réelles de la vision par ordinateur dans notre vie quotidienne :
Surveillance
Les applications de vision artificielle telles que la reconnaissance d'objets et l'estimation de la pose sont souvent déployées dans les dispositifs de sécurité afin d'automatiser la surveillance humaine. Un modèle d'estimation de la pose, par exemple, peut suivre le langage corporel d'une personne pour déterminer si elle incite à la violence, si elle subit une urgence médicale ou si elle est sur le point de voler quelque chose. Ces systèmes peuvent alors déclencher une notification qui alerte les autorités compétentes pour obtenir de l'aide, ce qui réduit les délais d'intervention et améliore la sécurité publique.
Vente au détail
Des modèles de vision par ordinateur peuvent être déployés dans les points de vente pour suivre la position des yeux des clients, leur langage corporel et leurs déplacements dans le magasin.
Ces algorithmes peuvent fournir aux détaillants les informations suivantes sur le comportement des utilisateurs :
- Y a-t-il des promotions ou des produits spécifiques qui attirent l'attention des gens et les incitent à entrer dans le magasin ?
- Quel chemin les clients empruntent-ils généralement lorsqu'ils entrent dans le magasin ?
- Quel type de placement de produit suscite le plus d'attention ?
- À quelle fréquence les clients s'intéressent-ils au matériel promotionnel tel que les bannières et la signalisation ?
Les détaillants peuvent ensuite utiliser ces informations pour améliorer la stratégie marketing du magasin et personnaliser l'emplacement des produits afin de stimuler les ventes.
Véhicules autonomes
Le domaine de la conduite autonome a énormément bénéficié des technologies de vision par ordinateur.
Les modèles de détection d'objets sont déployés dans les véhicules pour identifier les piétons, les autres véhicules et les animaux sur la route.
Les applications de vision par ordinateur peuvent interpréter les panneaux d'arrêt et les feux de circulation, estimer avec précision la distance entre le véhicule et d'autres objets et éviter des obstacles tels que les nids-de-poule, afin de garantir une conduite sûre.
Introduction à OpenCV
Maintenant que nous comprenons à quel point les applications de vision par ordinateur sont utiles, examinons un outil populaire utilisé pour les mettre en œuvre. OpenCV est une bibliothèque de vision par ordinateur qui prend en charge des langages de programmation tels que Python, C++ et Java.
Le paquet a été initialement créé par Intel en 1999 et a ensuite été rendu open-source et mis à la disposition du public.
OpenCV permet aux développeurs et aux non-mathématiciens de créer facilement des applications de vision par ordinateur sans avoir à les coder à partir de zéro. La bibliothèque compte plus de 2 500 algorithmes qui permettent aux utilisateurs d'effectuer des tâches telles que la reconnaissance de visages et la détection d'objets.
Les développeurs et les spécialistes des données d'organisations bien établies telles que Google, Microsoft, IBM et Intel utilisent largement la bibliothèque OpenCV, dont l'utilisation commerciale est actuellement gratuite.
Dans cet article, nous utiliserons OpenCV pour effectuer la détection de visages en Python.
À la fin de ce tutoriel, vous saurez comment :
- Détecter des visages humains dans des images avec OpenCV en Python
- Détection des visages en temps réel dans un flux en direct provenant d'une webcam
- Reconnaître et étiqueter des visages de célébrités dans des images
Qu'est-ce que la détection des visages ?
La détection des visages consiste à identifier le visage d'une personne dans une image ou une vidéo. Pour ce faire, les données visuelles sont analysées afin de déterminer si les traits du visage d'une personne sont présents.
Les visages humains étant très diversifiés, les modèles de détection des visages doivent généralement être entraînés sur de grandes quantités de données d'entrée pour être précis. L'ensemble de données de formation doit contenir une représentation suffisante de personnes issues de milieux, de sexes et de cultures différents.
Ces algorithmes doivent également être alimentés par de nombreux échantillons d'entraînement comprenant différents éclairages, angles et orientations afin de faire des prédictions correctes dans des scénarios réels.
Ces nuances font de la détection des visages une tâche non triviale et fastidieuse qui nécessite des heures d'apprentissage du modèle et des millions d'échantillons de données.
Heureusement, le paquet OpenCV est livré avec des modèles pré-entraînés pour la détection des visages, ce qui signifie que nous n'avons pas besoin d'entraîner un algorithme à partir de zéro. Plus précisément, la bibliothèque utilise une approche d'apprentissage automatique appelée cascade de Haar pour identifier les objets dans les données visuelles.
Tutoriel OpenCV pour la détection des visages
Dans cette section, nous allons apprendre à appliquer une approche populaire de détection des visages appelée Haar Cascade pour la détection des visages à l'aide d'OpenCV et de Python.
Exécutez et modifiez le code de ce tutoriel en ligne
Exécuter le codeIntroduction aux classificateurs Haar Cascade
Cette méthode a été présentée pour la première fois dans l'article Rapid Object Detection Using a Boosted Cascade of Simple Features (Détection rapide d'objets à l'aide d'une cascade de caractéristiques simples), rédigé par Paul Viola et Michael Jones.
Cette technique repose sur l'utilisation d'une cascade de classificateurs pour détecter les différentes caractéristiques d'une image. Ces classificateurs sont ensuite combinés en un classificateur puissant capable de distinguer avec précision les échantillons contenant un visage humain de ceux qui n'en contiennent pas.
Le classificateur Haar Cascade intégré à OpenCV a déjà été entraîné sur un vaste ensemble de données de visages humains, de sorte qu'aucun entraînement supplémentaire n'est nécessaire. Il suffit de charger le classificateur à partir de la bibliothèque et de l'utiliser pour détecter les visages sur une image d'entrée.
Installation d'OpenCV pour Python
Pour installer la bibliothèque OpenCV, ouvrez simplement votre invite de commande ou votre fenêtre de terminal et exécutez la commande suivante :
pip install opencv-python
Cette commande ne fonctionnera que si pip est déjà installé sur votre appareil. Si vous souhaitez en savoir plus sur le gestionnaire de paquets pip, vous pouvez lire notre tutoriel PIP Python.
OpenCV pour la détection des visages dans les images
Nous allons construire un détecteur pour identifier le visage humain dans une photo provenant d'Unsplash. Veillez à enregistrer l'image dans votre répertoire de travail et à la renommer input_image
avant de commencer à coder.
Étape 1 : Importer le paquet OpenCV
Maintenant, importons OpenCV et entrons le chemin de l'image d'entrée avec les lignes de code suivantes :
import cv2
imagePath = 'input_image.jpg'
Étape 2 : Lire l'image
Ensuite, nous devons lire l'image avec la fonction imread() d'OpenCV :
img = cv2.imread(imagePath)
Cette commande charge l'image à partir du chemin d'accès spécifié et la renvoie sous la forme d'un tableau Numpy.
Imprimons les dimensions de ce tableau :
img.shape
(4000, 2667, 3)
Notez qu'il s'agit d'un tableau à trois dimensions. Les valeurs du tableau représentent respectivement la hauteur, la largeur et les canaux de l'image. Comme il s'agit d'une image couleur, trois canaux sont utilisés pour la représenter : le bleu, le vert et le rouge (BGR).
Notez que si la séquence conventionnelle utilisée pour représenter les images est RVB (rouge, bleu, vert), la bibliothèque OpenCV utilise la séquence opposée (bleu, vert, rouge).
Étape 3 : Convertir l'image en niveaux de gris
Pour améliorer l'efficacité des calculs, nous devons d'abord convertir cette image en niveaux de gris avant de procéder à la détection des visages :
gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
Examinons maintenant les dimensions de cette image en niveaux de gris :
gray_image.shape
(4000, 2667)
Remarquez que ce tableau ne contient que deux valeurs puisque l'image est en niveaux de gris et n'a plus de troisième canal de couleur.
Étape 4 : Charger le classificateur
Chargeons le classificateur Haar Cascade pré-entraîné qui est intégré à OpenCV :
face_classifier = cv2.CascadeClassifier(
cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)
Remarquez que nous utilisons un fichier appelé haarcascade_frontalface_default.xml
. Ce classificateur est conçu spécifiquement pour détecter les visages frontaux dans les données visuelles.
OpenCV propose également d'autres modèles pré-entraînés pour détecter différents objets dans une image, tels que les yeux, le sourire, le haut du corps et même la plaque d'immatriculation d'un véhicule. Vous pouvez en savoir plus sur les différents classificateurs intégrés à OpenCV en consultant le dépôt GitHub de la bibliothèque.
Étape 5 : Effectuer la détection des visages
Nous pouvons maintenant procéder à la détection des visages sur l'image en niveaux de gris à l'aide du classificateur que nous venons de charger :
face = face_classifier.detectMultiScale(
gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40)
)
Décortiquons les méthodes et les paramètres spécifiés dans le code ci-dessus :
- detectMultiScale() :
La méthode detectMultiScale() est utilisée pour identifier les visages de différentes tailles dans l'image d'entrée.
grey_image
:
Le premier paramètre de cette méthode est appelé grey_image
, qui est l'image en niveaux de gris que nous avons créée précédemment.
scaleFactor
:
Ce paramètre est utilisé pour réduire la taille de l'image d'entrée afin de permettre à l'algorithme de détecter plus facilement des visages plus grands. Dans ce cas, nous avons spécifié un facteur d'échelle de 1,1, ce qui indique que nous voulons réduire la taille de l'image de 10 %.
minNeighbors
:
Le classificateur en cascade applique une fenêtre coulissante à l'image pour y détecter les visages. Vous pouvez considérer ces fenêtres comme des rectangles.
Dans un premier temps, le classificateur enregistre un grand nombre de faux positifs. Ces derniers sont éliminés à l'aide du paramètre minNeighbors
, qui spécifie le nombre de rectangles voisins qui doivent être identifiés pour qu'un objet soit considéré comme une détection valide.
En résumé, l'attribution d'une petite valeur (0 ou 1) à ce paramètre entraînerait un nombre élevé de faux positifs, tandis qu'une valeur élevée pourrait entraîner la perte de nombreux vrais positifs.
L'astuce consiste à trouver un compromis qui nous permette d'éliminer les faux positifs tout en identifiant avec précision les vrais positifs.
minSize
:
Enfin, le paramètre minSize
définit la taille minimale de l'objet à détecter. Le modèle ignore les faces dont la taille est inférieure à la taille minimale spécifiée.
Étape 6 : Dessiner une boîte de délimitation
Maintenant que le modèle a détecté les visages dans l'image, exécutons les lignes de code suivantes pour créer une boîte englobante autour de ces visages :
for (x, y, w, h) in face:
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 4)
La variable face
est un tableau à quatre valeurs : les axes x et y sur lesquels les visages ont été détectés, ainsi que leur largeur et leur hauteur. Le code ci-dessus itère sur les faces identifiées et crée une boîte englobante qui s'étend sur ces mesures.
Le paramètre 0,255,0
représente la couleur de la boîte englobante, qui est verte, et 4
indique son épaisseur.
Étape 7 : Affichage de l'image
Pour afficher l'image avec les visages détectés, nous devons d'abord convertir l'image du format BGR au format RGB :
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
Utilisons maintenant la bibliothèque Matplotlib pour afficher l'image :
import matplotlib.pyplot as plt
plt.figure(figsize=(20,10))
plt.imshow(img_rgb)
plt.axis('off')
Le code ci-dessus devrait générer la sortie suivante :
Excellent !
Le modèle a détecté avec succès le visage humain dans cette image et a créé une boîte englobante autour de lui.
Détection de visages en temps réel avec OpenCV
Maintenant que nous avons réussi à détecter des visages sur une image statique avec OpenCV, voyons comment faire de même sur un flux vidéo en direct.
Étape 1 : Pré-requis
Tout d'abord, importons la bibliothèque OpenCV et chargeons le modèle Haar Cascade comme nous l'avons fait dans la section précédente. Vous pouvez ignorer ce bloc de code si vous l'avez déjà exécuté auparavant :
import cv2
face_classifier = cv2.CascadeClassifier(
cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)
Étape 2 : Accéder à la webcam
Nous devons maintenant accéder à la caméra de notre appareil pour lire un flux de données vidéo en direct. Pour ce faire, vous pouvez utiliser le code suivant :
video_capture = cv2.VideoCapture(0)
Remarquez que nous avons passé le paramètre 0
à la fonction VideoCapture(). Cela indique à OpenCV d'utiliser la caméra par défaut de notre appareil. Si plusieurs caméras sont connectées à votre appareil, vous pouvez modifier la valeur de ce paramètre en conséquence.
Étape 3 : Identification des visages dans le flux vidéo
Maintenant, créons une fonction pour détecter les visages dans le flux vidéo et dessiner un cadre autour d'eux :
def detect_bounding_box(vid):
gray_image = cv2.cvtColor(vid, cv2.COLOR_BGR2GRAY)
faces = face_classifier.detectMultiScale(gray_image, 1.1, 5, minSize=(40, 40))
for (x, y, w, h) in faces:
cv2.rectangle(vid, (x, y), (x + w, y + h), (0, 255, 0), 4)
return faces
La fonction detect_bounding_box
prend l'image vidéo en entrée.
Dans cette fonction, nous utilisons les mêmes codes que précédemment pour convertir l'image en niveaux de gris avant de procéder à la détection des visages.
Ensuite, nous détectons également le visage dans cette image en utilisant les mêmes valeurs de paramètres pour scaleFactor
, minNeighbors
et minSize
que précédemment.
Enfin, nous dessinons un cadre vert d'une épaisseur de 4
autour du cadre.
Étape 4 : Création d'une boucle pour la détection des visages en temps réel
Nous devons maintenant créer une boucle while indéfinie qui capturera l'image vidéo de notre webcam et lui appliquera la fonction de détection des visages :
while True:
result, video_frame = video_capture.read() # read frames from the video
if result is False:
break # terminate the loop if the frame is not read successfully
faces = detect_bounding_box(
video_frame
) # apply the function we created to the video frame
cv2.imshow(
"My Face Detection Project", video_frame
) # display the processed frame in a window named "My Face Detection Project"
if cv2.waitKey(1) & 0xFF == ord("q"):
break
video_capture.release()
cv2.destroyAllWindows()
Après avoir exécuté le code ci-dessus, vous devriez voir apparaître à l'écran une fenêtre appelée My Face Detection Project
:
L'algorithme doit suivre votre visage et créer un cadre vert autour de lui, quel que soit l'endroit où vous vous déplacez dans le cadre.
Dans l'image ci-dessus, le mannequin reconnaît mon visage et ma photo sur le permis de conduire que je lui présente.
Vous pouvez également tester l'efficacité de ce modèle en présentant plusieurs photos ou en demandant à différentes personnes de se placer à différents angles derrière l'appareil photo. Le modèle doit être capable d'identifier tous les visages humains dans différents arrière-plans ou éclairages.
Si vous souhaitez quitter le programme, vous pouvez appuyer sur la touche "q" de votre clavier pour sortir de la boucle.
Détection de visages avec OpenCV - Prochaines étapes
Maintenant que vous avez appris à détecter avec succès des visages humains dans des images et des vidéos en temps réel à l'aide de la bibliothèque OpenCV, voici quelques étapes qui vous permettront d'approfondir vos connaissances :
Créez votre propre projet
Vous pouvez utiliser le code fourni dans ce tutoriel comme point de départ pour votre propre projet de détection des visages.
L'un des moyens d'étendre ce projet est d'identifier les visages humains dans différents types de données d'entrée, tels que les fichiers PDF ou les images de surveillance. Vous pouvez même installer votre propre caméra de sécurité et effectuer une détection des visages sur les données qu'elle capture en temps réel.
Vous pouvez également créer un modèle de détection des visages sur de grands ensembles de données ou aller plus loin et effectuer des tâches telles que détecter si une personne porte des masques dans des ensembles de données d'images.
Les ensembles de données de détection de vis ages dans les images et de détection de masques de visages sur Kaggle sont de bons points de départ pour un projet de portefeuille dans ce domaine.
Construire un modèle de reconnaissance faciale
Alors que la détection des visages est utilisée pour détecter un visage humain dans une entrée visuelle, la reconnaissance faciale va plus loin. Cette technologie est utilisée pour vérifier l'identité d'une personne en comparant son visage à une base de données existante.
Vous pouvez essayer de construire un modèle de reconnaissance faciale qui identifie un visage spécifique (peut-être même le vôtre) parmi une foule d'autres personnes.
Cette tâche sera légèrement plus difficile que la détection des visages car le modèle doit être entraîné sur de nombreux échantillons de données avant de pouvoir faire la distinction entre les personnes.
Avant d'élaborer un modèle de reconnaissance faciale, vous devrez peut-être aussi appliquer des techniques de prétraitement telles que la réduction du bruit et la transformation de l'image.
Si ces concepts vous semblent étrangers, ne vous inquiétez pas ! Vous pouvez apprendre tout ce qu'il faut savoir sur le traitement d'images en suivant notre cours Traitement d'images en Python.
Acquérir une expertise dans le domaine
Le traitement de l'image et de la vidéo a des applications dans un large éventail de secteurs, notamment la sécurité, la vente au détail, les soins de santé et la fabrication.
Si vous souhaitez obtenir un emploi en tant que spécialiste de la vision par ordinateur, vous devez d'abord comprendre les types de données utilisés dans ces secteurs. L'expertise du domaine vous permettra d'étiqueter, de transformer et de former plus facilement des ensembles de données dans des scénarios réels.
Pour commencer, vous pouvez suivre notre cours Biomedical Image Analysis in Python (Analyse d'images biomédicales en Python ). Ce programme vous apprendra à traiter des images de tomodensitométrie, à segmenter une série temporelle d'IRM cardiaque et à déterminer si la maladie d'Alzheimer modifie la structure du cerveau.
Ces concepts vous permettront d'acquérir les compétences nécessaires pour entrer dans le domaine de l'imagerie biomédicale.
Obtenez une certification dans le rôle de Data Scientist de vos rêves
Nos programmes de certification vous aident à vous démarquer et à prouver aux employeurs potentiels que vos compétences sont adaptées à l'emploi.

Cours Python
cours
Python intermédiaire
cours
Introduction à la visualisation de données avec Matplotlib
blog
Les 32 meilleures questions d'entretien sur AWS et leurs réponses pour 2024
blog
Les 20 meilleures questions d'entretien pour les flocons de neige, à tous les niveaux

Nisha Arya Ahmed
20 min