Guide de détection de visages pour Python

La tâche MediaPipe de détection de visages vous permet de détecter les visages dans une image ou une vidéo. Vous pouvez utiliser cette tâche pour localiser des visages et des traits de visage dans un cadre. Cette tâche utilise un modèle de machine learning (ML) fonctionnant avec des images uniques ou un flux continu d'images. La tâche génère la position des visages, ainsi que les points clés du visage suivants: œil gauche, œil droit, embout du nez, bouche, tragion œil gauche et tragion œil droit.

L'exemple de code décrit dans ces instructions est disponible sur GitHub. Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la présentation.

Exemple de code

L'exemple de code pour la détection de visages fournit une implémentation complète de cette tâche en Python à titre de référence. Ce code vous aide à tester cette tâche et à créer votre propre détecteur de visages. Vous pouvez afficher, exécuter et modifier l'exemple de code pour la détection de visages à l'aide de votre navigateur Web.

Si vous mettez en œuvre le détecteur de visages pour Raspberry Pi, consultez l'exemple d'application pour Raspberry Pi.

Préparation

Cette section décrit les étapes clés de la configuration de votre environnement de développement et de vos projets de code spécifiquement pour l'utilisation du détecteur de visages. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour l'utilisation des tâches MediaPipe, y compris sur les exigences de version de la plate-forme, consultez le guide de configuration pour Python.

Colis

La tâche MediaPipe Face Detector nécessite le package PyPI Mediapipe. Vous pouvez installer et importer ces dépendances avec la commande suivante:

$ python -m pip install mediapipe

Importations

Importez les classes suivantes pour accéder aux fonctions des tâches de détection de visages:

import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision

Modèle

La tâche MediaPipe de détection de visages nécessite un modèle entraîné compatible avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour les détecteurs de visages, consultez la section Modèles de la présentation des tâches.

Sélectionnez et téléchargez le modèle, puis stockez-le dans un répertoire local:

model_path = '/absolute/path/to/face_detector.task'

Utilisez le paramètre model_asset_path de l'objet BaseOptions pour spécifier le chemin d'accès du modèle à utiliser. Pour obtenir un exemple de code, consultez la section suivante.

Créer la tâche

La tâche MediaPipe de détection de visages utilise la fonction create_from_options pour configurer la tâche. La fonction create_from_options accepte des valeurs pour les options de configuration à gérer. Pour en savoir plus sur les options de configuration, consultez la section Options de configuration.

Le code suivant montre comment créer et configurer cette tâche.

Ces exemples montrent également les variantes de construction des tâches pour les images, les fichiers vidéo et le flux en direct.

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
FaceDetector = mp.tasks.vision.FaceDetector
FaceDetectorOptions = mp.tasks.vision.FaceDetectorOptions
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a face detector instance with the image mode:
options = FaceDetectorOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.IMAGE)
with FaceDetector.create_from_options(options) as detector:
  # The detector is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
FaceDetector = mp.tasks.vision.FaceDetector
FaceDetectorOptions = mp.tasks.vision.FaceDetectorOptions
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a face detector instance with the video mode:
options = FaceDetectorOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.VIDEO)
with FaceDetector.create_from_options(options) as detector:
  # The detector is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
FaceDetector = mp.tasks.vision.FaceDetector
FaceDetectorOptions = mp.tasks.vision.FaceDetectorOptions
FaceDetectorResult = mp.tasks.vision.FaceDetectorResult
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a face detector instance with the live stream mode:
def print_result(result: FaceDetectorResult, output_image: mp.Image, timestamp_ms: int):
    print('face detector result: {}'.format(result))

options = FaceDetectorOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.LIVE_STREAM,
    result_callback=print_result)
with FaceDetector.create_from_options(options) as detector:
  # The detector is initialized. Use it here.
  # ...
    

Pour obtenir un exemple complet de création d'un détecteur de visages à utiliser avec une image, consultez l'exemple de code.

Options de configuration

Cette tâche dispose des options de configuration suivantes pour les applications Python:

Préparation des données

Préparez votre entrée en tant que fichier image ou tableau Numpy, puis convertissez-la en objet mediapipe.Image. Si votre entrée est un fichier vidéo ou un flux vidéo en direct à partir d'une webcam, vous pouvez utiliser une bibliothèque externe telle que OpenCV pour charger vos images d'entrée sous forme de tableaux Numpy.

import mediapipe as mp

# Load the input image from an image file.
mp_image = mp.Image.create_from_file('/path/to/image')

# Load the input image from a numpy array.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_image)
    

import mediapipe as mp

# Use OpenCV’s VideoCapture to load the input video.

# Load the frame rate of the video using OpenCV’s CV_CAP_PROP_FPS
# You’ll need it to calculate the timestamp for each frame.

# Loop through each frame in the video using VideoCapture#read()

# Convert the frame received from OpenCV to a MediaPipe’s Image object.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_frame_from_opencv)
    

import mediapipe as mp

# Use OpenCV’s VideoCapture to start capturing from the webcam.

# Create a loop to read the latest frame from the camera using VideoCapture#read()

# Convert the frame received from OpenCV to a MediaPipe’s Image object.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_frame_from_opencv)
    

Exécuter la tâche

Le détecteur de visages utilise les fonctions detect, detect_for_video et detect_async pour déclencher des inférences. Pour la détection de visages, cela implique le prétraitement des données d'entrée et la détection des visages dans l'image.

Le code suivant montre comment exécuter le traitement avec le modèle de tâche.

# Perform face detection on the provided single image.
# The face detector must be created with the image mode.
face_detector_result = detector.detect(mp_image)
    

# Perform face detection on the provided single image.
# The face detector must be created with the video mode.
face_detector_result = detector.detect_for_video(mp_image, frame_timestamp_ms)
    

# Send live image data to perform face detection.
# The results are accessible via the `result_callback` provided in
# the `FaceDetectorOptions` object.
# The face detector must be created with the live stream mode.
detector.detect_async(mp_image, frame_timestamp_ms)
    

Veuillez noter les points suivants :

• Lorsque vous exécutez le mode vidéo ou le mode de diffusion en direct, fournissez également à la tâche de détection de visages l'horodatage de l'image d'entrée.
• Lors de l'exécution dans l'image ou le modèle vidéo, la tâche de détection de visages bloque le thread actuel jusqu'à ce qu'elle ait fini de traiter l'image ou le cadre d'entrée.
• En mode diffusion en direct, la tâche de détection de visages est renvoyée immédiatement et ne bloque pas le thread actuel. Il appelle l'écouteur de résultat avec le résultat de la détection chaque fois qu'il termine le traitement d'une trame d'entrée. Si la fonction de détection est appelée lorsque la tâche de détection de visages est occupée à traiter une autre image, la tâche ignore la nouvelle trame d'entrée.

Pour obtenir un exemple complet d'exécution d'un détecteur de visages sur une image, consultez l'exemple de code.

Gérer et afficher les résultats

Le détecteur de visages renvoie un objet FaceDetectorResult pour chaque exécution de détection. L'objet de résultat contient des cadres de délimitation pour les visages détectés et un score de confiance pour chacun d'eux.

Voici un exemple des données de sortie de cette tâche:

FaceDetectionResult:
  Detections:
    Detection #0:
      BoundingBox:
        origin_x: 126
        origin_y: 100
        width: 463
        height: 463
      Categories:
        Category #0:
          index: 0
          score: 0.9729152917861938
      NormalizedKeypoints:
        NormalizedKeypoint #0:
          x: 0.18298381567001343
          y: 0.2961040139198303
        NormalizedKeypoint #1:
          x: 0.3302789330482483
          y: 0.29289937019348145
        ... (6 keypoints for each face)
    Detection #1:
      BoundingBox:
        origin_x: 616
        origin_y: 193
        width: 430
        height: 430
      Categories:
        Category #0:
          index: 0
          score: 0.9251380562782288
      NormalizedKeypoints:
        NormalizedKeypoint #0:
          x: 0.6151331663131714
          y: 0.3713381886482239
        NormalizedKeypoint #1:
          x: 0.7460576295852661
          y: 0.38825345039367676
        ... (6 keypoints for each face)

L'image suivante montre une visualisation du résultat de la tâche:

Pour l'image sans cadre de délimitation, consultez l'image d'origine.

L'exemple de code de détection de visages montre comment afficher les résultats renvoyés par la tâche. Pour en savoir plus, consultez cet exemple de code.