Guide de détection des points de repère de visage pour Python

La tâche MediaPipe Face Markerer vous permet de détecter des repères de visage et des expressions faciales dans des images et des vidéos. Vous pouvez utiliser cette tâche pour identifier des expressions faciales et appliquer des filtres et des effets faciaux pour créer un avatar virtuel. Cette tâche utilise des modèles de machine learning (ML) capables de fonctionner avec des images uniques ou un pipeline d'images. La tâche génère des repères de visage en 3 dimensions, "Blendshape" (coefficients représentant l'expression faciale) pour déduire des expressions faciales détaillées surfaces en temps réel, et des matrices de transformation pour effectuer la et les transformations requises pour le rendu des effets.

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 section Présentation.

Exemple de code

L'exemple de code pour Face Markerer fournit une implémentation complète de cette dans Python à titre de référence. Ce code vous aide à tester cette tâche et à obtenir vous avez commencé à créer votre propre repère de visage. Vous pouvez afficher, exécuter et modifier les Exemple de repère de visage du code en utilisant uniquement votre navigateur Web.

Si vous implémentez Face Markerer pour Raspberry Pi, Exemple pour Raspberry Pi l'application Nest.

Configuration

Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement des projets de codage spécifiquement pour utiliser Face Markerer. Pour obtenir des informations générales sur configurer votre environnement de développement pour utiliser les tâches MediaPipe, y compris version de la plate-forme requise, consultez le guide de configuration Python.

Colis

La tâche MediaPipe Face Benchmarker nécessite le package Mediapipe PyPI. Vous pouvez installer Importez ces dépendances à l'aide de la commande suivante:

$ python -m pip install mediapipe

Importations

Importez les classes suivantes pour accéder aux fonctions des tâches Face Markerer:

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

Modèle

La tâche MediaPipe Face Markerer nécessite un modèle entraîné et compatible avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour Face Markerer, 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_landmarker.task'

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

Créer la tâche

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

Le code suivant montre comment compiler et configurer cette tâche.

Ces exemples montrent également les variantes de la construction de la tâche pour les images, des fichiers vidéo et des diffusions en direct.

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
FaceLandmarker = mp.tasks.vision.FaceLandmarker
FaceLandmarkerOptions = mp.tasks.vision.FaceLandmarkerOptions
VisionRunningMode = mp.tasks.vision.RunningMode

options = FaceLandmarkerOptions(
    base_options=BaseOptions(model_asset_path=model_path),
    running_mode=VisionRunningMode.IMAGE)

with FaceLandmarker.create_from_options(options) as landmarker:
  # The landmarker is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
FaceLandmarker = mp.tasks.vision.FaceLandmarker
FaceLandmarkerOptions = mp.tasks.vision.FaceLandmarkerOptions
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a face landmarker instance with the video mode:
options = FaceLandmarkerOptions(
    base_options=BaseOptions(model_asset_path=model_path),
    running_mode=VisionRunningMode.VIDEO)

with FaceLandmarker.create_from_options(options) as landmarker:
  # The landmarker is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
FaceLandmarker = mp.tasks.vision.FaceLandmarker
FaceLandmarkerOptions = mp.tasks.vision.FaceLandmarkerOptions
FaceLandmarkerResult = mp.tasks.vision.FaceLandmarkerResult
VisionRunningMode = mp.tasks.vision.RunningMode

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

options = FaceLandmarkerOptions(
    base_options=BaseOptions(model_asset_path=model_path),
    running_mode=VisionRunningMode.LIVE_STREAM,
    result_callback=print_result)

with FaceLandmarker.create_from_options(options) as landmarker:
  # The landmarker is initialized. Use it here.
  # ...
    

Pour obtenir un exemple complet de création d'un repère de visage à utiliser avec une image, consultez le code exemple.

Options de configuration

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

Préparer les données

Préparez votre entrée en tant que fichier image ou tableau Numpy, puis convertissez-la en mediapipe.Image. Si votre entrée est un fichier vidéo ou une diffusion en direct webcam, vous pouvez utiliser une bibliothèque externe comme OpenCV pour charger vos frames d'entrée au format Numpy ; tableaux.

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 repère de visage utilise detect, detect_for_video et detect_async. pour déclencher des inférences. Pour le point de repère des visages, cela implique prétraiter les données d'entrée et détecter les visages dans l'image.

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

# Perform face landmarking on the provided single image.
# The face landmarker must be created with the image mode.
face_landmarker_result = landmarker.detect(mp_image)
    

# Perform face landmarking on the provided single image.
# The face landmarker must be created with the video mode.
face_landmarker_result = landmarker.detect_for_video(mp_image, frame_timestamp_ms)
    

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

Veuillez noter les points suivants :

• En mode vidéo ou flux en direct, indiquez également le paramètre Tâche de reconnaissance faciale liée à l'horodatage de la trame d'entrée.
• Lors de l'exécution du modèle d'image ou de vidéo, la tâche Face Markerer bloque le thread actuel jusqu'à ce qu'il ait fini de traiter l'image ou le frame d'entrée.
• En mode diffusion en direct, la tâche Face Markerer renvoie immédiatement et ne bloque pas le thread actuel. Elle appellera le résultat avec le résultat de la détection chaque fois que le traitement d'une trame d'entrée. Si la fonction de détection est appelée lorsque la tâche Repères de visage est occupé à traiter une autre trame, la tâche ignore la nouvelle trame d'entrée.

Pour obtenir un exemple complet d'exécution d'un repère de visage sur une image, reportez-vous au code exemple pour en savoir plus.

Gérer et afficher les résultats

Le repère de visage renvoie un objet FaceLandmarkerResult pour chaque détection exécuter. L'objet du résultat contient une grille pour chaque visage détecté, avec les coordonnées géographiques de chaque repère de visage. L'objet de résultat peut aussi contiennent des mélanges de formes, qui représentent les expressions faciales et une pour appliquer des effets de visage aux points de repère détectés.

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

FaceLandmarkerResult:
  face_landmarks:
    NormalizedLandmark #0:
      x: 0.5971359014511108
      y: 0.485361784696579
      z: -0.038440968841314316
    NormalizedLandmark #1:
      x: 0.3302789330482483
      y: 0.29289937019348145
      z: -0.09489090740680695
    ... (478 landmarks for each face)
  face_blendshapes:
    browDownLeft: 0.8296722769737244
    browDownRight: 0.8096957206726074
    browInnerUp: 0.00035583582939580083
    browOuterUpLeft: 0.00035752105759456754
    ... (52 blendshapes for each face)
  facial_transformation_matrixes:
    [9.99158978e-01, -1.23036895e-02, 3.91213447e-02, -3.70770246e-01]
    [1.66496094e-02,  9.93480563e-01, -1.12779640e-01, 2.27719707e+01]
    ...

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

L'exemple de code Face Markerer montre comment afficher les résultats renvoyés. de la tâche, consultez le code exemple pour en savoir plus.