Guía de detección de rostro para Python

La tarea del detector de rostros de MediaPipe te permite detectar rostros en una imagen o un video. Puedes usar esta tarea para ubicar rostros y rasgos faciales dentro de un marco. Esta tarea usa un modelo de aprendizaje automático (AA) que funciona con imágenes individuales o un flujo contínuo de imágenes. La tarea genera ubicaciones de rostros, junto con los siguientes puntos clave faciales: ojo izquierdo, ojo derecho, punta de la nariz, boca, tragión del ojo izquierdo y tragión del ojo derecho.

La muestra de código que se describe en estas instrucciones está disponible en GitHub. Para obtener más información sobre las funciones, los modelos y las opciones de configuración de esta tarea, consulta la descripción general.

Ejemplo de código

El código de ejemplo del detector de rostros proporciona una implementación completa de esta tarea en Python como referencia. Este código te ayuda a probar esta tarea y comenzar a compilar tu propio detector de rostros. Puedes ver, ejecutar y editar el código de ejemplo del detector de rostros solo con tu navegador web.

Si implementas el detector de rostros para Raspberry Pi, consulta la app de ejemplo de Raspberry Pi.

Configuración

En esta sección, se describen los pasos clave para configurar tu entorno de desarrollo y codificar proyectos específicamente para usar el detector de rostros. Para obtener información general sobre cómo configurar tu entorno de desarrollo para usar tareas de MediaPipe, incluidos los requisitos de la versión de la plataforma, consulta la Guía de configuración para Python.

Paquetes

La tarea del detector de rostros de MediaPipe requiere el paquete mediapipe de PyPI. Puedes instalar y importar estas dependencias con lo siguiente:

$ python -m pip install mediapipe

Importaciones

Importa las siguientes clases para acceder a las funciones de tareas del detector de rostros:

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

Modelo

La tarea del detector de rostros de MediaPipe requiere un modelo entrenado que sea compatible con esta tarea. Para obtener más información sobre los modelos entrenados disponibles para el detector de rostros, consulta la sección Modelos de la descripción general de la tarea.

Selecciona y descarga el modelo, y guárdalo en un directorio local:

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

Usa el parámetro model_asset_path del objeto BaseOptions para especificar la ruta del modelo que se usará. Para ver un ejemplo de código, consulta la siguiente sección.

Crea la tarea

La tarea del detector de rostros de MediaPipe usa la función create_from_options para configurarla. La función create_from_options acepta valores para que las opciones de configuración los controlen. Para obtener más información sobre las opciones de configuración, consulta Opciones de configuración.

En el siguiente código, se muestra cómo compilar y configurar esta tarea.

En estos ejemplos, también se muestran las variaciones de la construcción de tareas para imágenes, archivos de video y transmisiones en vivo.

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.
  # ...
    

Para ver un ejemplo completo de cómo crear un detector de rostros para usarlo con una imagen, consulta el ejemplo de código.

Opciones de configuración

Esta tarea tiene las siguientes opciones de configuración para aplicaciones de Python:

Preparar los datos

Prepara tu entrada como un archivo de imagen o un array de numpy y, luego, conviértela en un objeto mediapipe.Image. Si tu entrada es un archivo de video o una transmisión en vivo desde una cámara web, puedes usar una biblioteca externa, como OpenCV, para cargar tus fotogramas de entrada como arrays de 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)
    

Ejecuta la tarea

El detector de rostros usa las funciones detect, detect_for_video y detect_async para activar inferencias. En el caso de la detección de rostros, esto implica preprocesar los datos de entrada y detectar rostros en la imagen.

En el siguiente código, se muestra cómo ejecutar el procesamiento con el modelo de tareas.

# 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)
    

Ten en cuenta lo siguiente:

• Cuando se ejecuta en el modo de video o en el modo de transmisión en vivo, también proporciona a la tarea del detector de rostros la marca de tiempo del fotograma de entrada.
• Cuando se ejecuta en la imagen o el modelo de video, la tarea del detector de rostros bloquea el subproceso actual hasta que termina de procesar la imagen o el fotograma de entrada.
• Cuando se ejecuta en el modo de transmisión en vivo, la tarea del detector de rostros se muestra de inmediato y no bloquea el subproceso actual. Invocará al objeto de escucha de resultados con el resultado de la detección cada vez que termine de procesar un fotograma de entrada. Si se llama a la función de detección cuando la tarea del detector de rostros está ocupada procesando otro fotograma, la tarea ignorará el nuevo fotograma de entrada.

Para ver un ejemplo completo de cómo ejecutar un detector de rostros en una imagen, consulta el ejemplo de código y obtén más información.

Cómo controlar y mostrar los resultados

El detector de rostros muestra un objeto FaceDetectorResult para cada ejecución de detección. El objeto de resultado contiene cuadros de límite para los rostros detectados y una puntuación de confianza para cada rostro detectado.

A continuación, se muestra un ejemplo de los datos de resultado de esta tarea:

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)

En la siguiente imagen, se muestra una visualización del resultado de la tarea:

Para ver la imagen sin cuadros de límite, consulta la imagen original.

En el código de ejemplo del detector de rostros, se muestra cómo mostrar los resultados que se devuelven de la tarea. Consulta el ejemplo de código para obtener más información.