Reconocimiento facial en tiempo real:un proyecto de principio a fin

Aprenderemos paso a paso, cómo usar una PiCam para reconocer caras en tiempo real. En mi último tutorial explorando OpenCV, aprendimos SEGUIMIENTO AUTOMÁTICO DE OBJETOS DE VISIÓN.

Ahora usaremos nuestra PiCam para reconocer caras en tiempo real, como puede ver a continuación:

Este proyecto se realizó con esta fantástica “Biblioteca de visión por computadora de código abierto”, el OpenCV. En este tutorial, nos centraremos en Raspberry Pi (es decir, Raspbian como sistema operativo) y Python, pero también probé el código en Mi Mac y también funciona bien. OpenCV fue diseñado para la eficiencia computacional y con un fuerte enfoque en aplicaciones en tiempo real. Por lo tanto, es perfecto para el reconocimiento facial en tiempo real con una cámara.

3 fases

Para crear un proyecto completo sobre reconocimiento facial, debemos trabajar en 3 fases muy distintas:

• Detección de rostros y recopilación de datos

• Entrene al reconocedor

• Reconocimiento facial

El siguiente diagrama de bloques reanuda esas fases:

Paso 1:BoM - Lista de materiales

Partes principales:

• Raspberry Pi V3:32,00 USD

• 5 megapíxeles 1080p Sensor OV5647 Mini módulo de video de cámara - US $ 13.00

Paso 2:Instalar el paquete OpenCV 3

Estoy usando una Raspberry Pi V3 actualizada a la última versión de Raspbian (Stretch), así que la mejor manera de tener OpenCV instalado es seguir el excelente tutorial desarrollado por Adrian Rosebrock:Raspbian Stretch:Install OpenCV 3 + Python en su Raspberry Pi.

Probé varias guías diferentes para instalar OpenCV en mi Pi. El tutorial de Adrian es el mejor. Te aconsejo que hagas lo mismo, siguiendo sus pautas paso a paso.

Una vez que haya terminado el tutorial de Adrian, debería tener un entorno virtual OpenCV listo para ejecutar nuestros experimentos en su Pi.

Vayamos a nuestro entorno virtual y confirmemos que OpenCV 3 está instalado correctamente.

Adrian recomienda ejecutar el comando "fuente" cada vez que abra una nueva terminal para asegurarse de que las variables de su sistema se hayan configurado correctamente.

fuente ~ / .profile

Luego, entremos en nuestro entorno virtual:

trabajar en cv

Si ve el texto (cv) que precede a su mensaje, entonces está en el cv virtual entorno:

(cv) pi @ frambuesa:~ $

Adrian llama la atención sobre el hecho de que el entorno virtual cv Python es completamente independiente y está aislado de la versión predeterminada de Python incluida en la descarga de Raspbian Stretch. Por lo tanto, cualquier paquete de Python en el directorio global site-packages no estará disponible para el entorno virtual cv. De manera similar, cualquier paquete de Python instalado en paquetes de sitio de cv no estará disponible para la instalación global de Python.

Ahora, ingrese su intérprete de Python:

pitón

y confirme que está ejecutando la versión 3.5 (o superior).

Dentro del intérprete (aparecerá el “>>>”), importe la biblioteca OpenCV:

importar cv2

Si no aparecen mensajes de error, el OpenCV está instalado correctamente EN SU ENTORNO VIRTUAL PYTHON.

También puede verificar la versión de OpenCV instalada:

cv2 .__ versión__

Debería aparecer la 3.3.0 (o una versión superior que se pueda lanzar en el futuro).

La pantalla de impresión de terminal anterior muestra los pasos anteriores.

Paso 3:prueba tu cámara

Una vez que haya instalado OpenCV en su RPi, hagamos una prueba para confirmar que su cámara funciona correctamente.

Supongo que ya tiene una PiCam instalada en su Raspberry Pi.

Debe tener la cámara habilitada cuando ejecutó el tutorial de Adrian; de lo contrario, los controladores no se instalarán correctamente.

En caso de que obtenga un error como: Error de OpenCV:Error de afirmación , puede intentar resolver el problema con el comando:

sudo modprobe bcm2835-v4l2

Una vez que tenga todos los controladores instalados correctamente, ingrese el siguiente código Python en su IDE:

import numpy as np
import cv2
cap =cv2.VideoCapture (0)
cap.set (3,640) # set Width
cap.set (4,480) # set Height
while (True):
ret, frame =cap.read ()
frame =cv2.flip (frame, -1) # Voltear la cámara verticalmente
gray =cv2.cvtColor (frame , cv2.COLOR_BGR2GRAY)

cv2.imshow ('marco', marco)
cv2.imshow ('gris', gris)

k =cv2.waitKey (30) &0xff
if k ==27:# presione 'ESC' para salir
romper
cap.release ()
cv2.destroyAllWindows ()

El código anterior capturará el flujo de video que generará su PiCam, mostrando ambos, en color BGR y en modo gris.

Tenga en cuenta que giré mi cámara verticalmente debido a la forma en que está ensamblada. Si no es su caso, comente o elimine la línea de comando "flip".

Alternativamente, puede descargar el código de mi GitHub:simpleCamTest.py

Para ejecutar, ingrese el comando:

python simpleCamTest.py

Para finalizar el programa, debes presionar la tecla [ESC] en tu teclado. Haga clic con el mouse en la ventana de video, antes de presionar [ESC].

La imagen de arriba muestra el resultado.

Algunos fabricantes encontraron problemas al intentar abrir la cámara (mensajes de error "Afirmación fallida"). Eso podría suceder si la cámara no se habilitó durante la instalación de OpenCv y, por lo tanto, los controladores de la cámara no se instalaron correctamente. Para corregir, use el comando:

sudo modprobe bcm2835-v4l2

También puede agregar bcm2835-v4l2 a la última línea del archivo / etc / modules para que el controlador se cargue al arrancar.

Para saber más sobre OpenCV, puede seguir el tutorial:loading -video-python-opencv-tutorial

Paso 4:Detección de rostro

La tarea más básica del reconocimiento facial es, por supuesto, la "detección de rostros". Antes que nada, debes "capturar" un rostro (Fase 1) para poder reconocerlo, en comparación con un nuevo rostro capturado en el futuro (Fase 3).

La forma más común de detectar una cara (o cualquier objeto) es usando el “clasificador Haar Cascade“

La detección de objetos usando clasificadores en cascada basados ​​en características de Haar es un método efectivo de detección de objetos propuesto por Paul Viola y Michael Jones en su artículo, “Detección rápida de objetos usando una cascada mejorada de características simples” en 2001. es un enfoque basado en el aprendizaje automático en el que se entrena una función en cascada a partir de una gran cantidad de imágenes positivas y negativas. Luego se usa para detectar objetos en otras imágenes.

Aquí trabajaremos con detección de rostros. Inicialmente, el algoritmo necesita muchas imágenes positivas (imágenes de rostros) e imágenes negativas (imágenes sin rostros) para entrenar al clasificador. Entonces necesitamos extraer características de él. La buena noticia es que OpenCV viene con un entrenador y un detector. Si desea entrenar su propio clasificador para cualquier objeto como automóvil, aviones, etc., puede usar OpenCV para crear uno. Todos los detalles se dan aquí:Entrenamiento de clasificador en cascada.

Si no desea crear su propio clasificador, OpenCV ya contiene muchos clasificadores previamente entrenados para rostro, ojos, sonrisa, etc. Esos archivos XML se pueden descargar desde el directorio haarcascades.

¡Suficiente teoría, creemos un detector facial con OpenCV!

Descarga el archivo:faceDetection.py desde mi GitHub.

import numpy as np
import cv2
faceCascade =cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml')
cap =cv2.VideoCapture (0)
cap.set (3,640) # set Width
cap.set (4,480) # set Height
while True:
ret, img =cap.read ()
img =cv2.flip (img, –1 )
gris =cv2.cvtColor (img, cv2.COLOR_BGR2GRAY)
caras =faceCascade.detectMultiScale (
gris,
scaleFactor =1.2,
minNeighbors =5,
minSize =(20, 20)
)
para (x, y, w, h) en caras:
cv2.rectangle (img, (x, y), (x + w, y + h), (255,0,0), 2)
roi_gray =gris [y:y + h, x:x + w]
roi_color =img [y:y + h, x:x + w]
cv2.imshow ('video', img)
k =cv2.waitKey (30) &0xff
if k ==27:# presione 'ESC 'para salir
romper
cap.release ()
cv2.destroyAllWindows ()

Lo crea o no, las pocas líneas de código anteriores son todo lo que necesita para detectar una cara, usando Python y OpenCV.

Cuando compare con el último código utilizado para probar la cámara, se dará cuenta de que se le agregaron pocas partes. Tenga en cuenta la línea a continuación:

faceCascade =cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml')

Esta es la línea que carga el "clasificador" (que debe estar en un directorio llamado "Cascades /", bajo el directorio de su proyecto).

Luego, configuraremos nuestra cámara y dentro del bucle, cargaremos nuestro video de entrada en modo de escala de grises (lo mismo que vimos antes).

Ahora debemos llamar a nuestra función clasificadora, pasándole algunos parámetros muy importantes, como factor de escala, número de vecinos y tamaño mínimo del rostro detectado.

faces =faceCascade.detectMultiScale (
gris,
scaleFactor =1.2,
minNeighbors =5,
minSize =(20, 20)
)

Dónde,

• gris es la imagen de entrada en escala de grises.

• scaleFactor es el parámetro que especifica cuánto se reduce el tamaño de la imagen en cada escala de imagen. Se utiliza para crear la pirámide de escala.

• minNeighbors es un parámetro que especifica cuántos vecinos debe tener cada rectángulo candidato para retenerlo. Un número más alto da menos falsos positivos.

• minSize es el tamaño mínimo del rectángulo para que se considere una cara.

La función detectará rostros en la imagen. A continuación, debemos “marcar” las caras en la imagen, utilizando, por ejemplo, un rectángulo azul. Esto se hace con esta parte del código:

para (x, y, w, h) en caras:
cv2.rectangle (img, (x, y), (x + w, y + h), (255,0,0), 2)
roi_gray =gris [y:y + h, x:x + w]
roi_color =img [y:y + h, x:x + w]

Si se encuentran caras, devuelve las posiciones de las caras detectadas como un rectángulo con la esquina superior izquierda (x, y) y teniendo "w" como su Ancho y "h" como su Alto ==> (x, y, w, h). Por favor, vea la imagen.

Una vez que obtenemos estas ubicaciones, podemos crear un "ROI" (rectángulo dibujado) para la cara y presentar el resultado con imshow () función.

Ejecute el script de Python anterior en su entorno de Python, usando la Terminal Rpi:

python faceDetection.py

El resultado:

También puede incluir clasificadores para "detección de ojos" o incluso "detección de sonrisas". En esos casos, incluirá la función de clasificador y el dibujo del rectángulo dentro del bucle de la cara, porque no tendría sentido detectar un ojo o una sonrisa fuera de una cara.

Tenga en cuenta que en un Pi, tener varios clasificadores en el mismo código ralentizará el procesamiento, una vez que este método de detección (HaarCascades) utiliza una gran cantidad de poder computacional. En un escritorio, es más fácil ejecutarlo.

Ejemplos

En mi GitHub encontrarás otros ejemplos:

• faceEyeDetection.py

• faceSmileDetection.py

• faceSmileEyeDetection.py

Y en la imagen, puedes ver el resultado.

También puede seguir el siguiente tutorial para comprender mejor la detección de rostros:

Haar Cascade Object Detection Face &Eye OpenCV Python Tutorial

Paso 5:recopilación de datos

En primer lugar, debo agradecer a Ramiz Raja por su gran trabajo sobre el reconocimiento facial en fotografías:

RECONOCIMIENTO DE CARA UTILIZANDO OPENCV Y PYTHON:UNA GUÍA PARA PRINCIPIANTES

y también Anirban Kar, que desarrolló un tutorial muy completo usando video:

RECONOCIMIENTO DE CARA - 3 partes

Realmente te recomiendo que eches un vistazo a ambos tutoriales.

Dicho esto, comencemos la primera fase de nuestro proyecto. Lo que haremos aquí es comenzar desde el último paso (Detección de rostros), simplemente crearemos un conjunto de datos, donde almacenaremos para cada identificación, un grupo de fotos en gris con la parte que se utilizó para la detección de rostros.

Primero, cree un directorio donde desarrolle su proyecto, por ejemplo, FacialRecognitionProject:

mkdir FacialRecognitionProject

En este directorio, además de los 3 scripts en python que crearemos para nuestro proyecto, debemos tener guardado en él el Clasificador Facial. Puedes descargarlo de mi GitHub:haarcascade_frontalface_default.xml

Luego, cree un subdirectorio donde almacenaremos nuestras muestras faciales y lo nombraremos "conjunto de datos":

conjunto de datos mkdir

Y descargue el código de mi GitHub:01_face_dataset.py

import cv2
import os
cam =cv2.VideoCapture (0)
cam.set (3, 640) # set video width
cam.set (4, 480) # set altura del video
face_detector =cv2.CascadeClassifier ('haarcascade_frontalface_default.xml')
# Para cada persona, ingrese una identificación numérica de rostro
face_id =input ('\ n ingrese la identificación de usuario y presione ==> ')
print (“\ n [INFO] Inicializando la captura de rostros. Mira la cámara y espera…”)
# Inicializa el conteo de rostros de muestreo individual
count =0
while (Verdadero):
ret, img =cam.read ()
img =cv2.flip (img, -1) # voltear imagen de video verticalmente
gris =cv2.cvtColor (img , cv2.COLOR_BGR2GRAY)
faces =face_detector.detectMultiScale (gray, 1.3, 5)
para (x, y, w, h) en caras:
cv2.rectangle (img, (x , y), (x + w, y + h), (255,0,0), 2)
count + =1
# Guarde la imagen capturada en la carpeta de conjuntos de datos
cv2 .imwrite (“conjunto de datos / Usuario.” + str (face_id) + '.' + str (cuenta) + “.jpg”, gris [y:y + h, x:x + w])
cv2. imshow ('imagen', img)
k =cv2.waitKey (100) &0x ff # Presione 'ESC' para salir del video
if k ==27:
break
elif count> =30:# Tome 30 muestras de caras y detenga el video
break
# Haga un poco de limpieza
print (“\ n [INFO] Saliendo del programa y cosas de limpieza”)
cam.release ()
cv2.destroyAllWindows ()

El código es muy similar al código que vimos para la detección de rostros. Lo que agregamos fue un "comando de entrada" para capturar una identificación de usuario, que debería ser un número entero (1, 2, 3, etc.)

face_id =input (‘\ n ingrese la identificación del usuario y presione ==>‘)

Y para cada uno de los fotogramas capturados, debemos guardarlo como un archivo en un directorio de "conjunto de datos":

cv2.imwrite ("conjunto de datos / Usuario". + str (face_id) + "." + str (recuento) + ".jpg", gris [y:y + h, x:x + w])

Tenga en cuenta que para guardar el archivo anterior, debe haber importado la biblioteca “os”. El nombre de cada archivo seguirá la estructura:

User.face_id.count.jpg

Por ejemplo, para un usuario con face_id =1, el cuarto archivo de muestra en el directorio / conjunto de datos será algo como:

User.1.4.jpg

como se muestra en la foto de mi Pi:

En mi código, estoy capturando 30 muestras de cada id. Puede cambiarlo en el último "elif". La cantidad de muestras se usa para romper el ciclo donde se capturan las muestras faciales.

Ejecute la secuencia de comandos de Python y capture algunos ID. Debe ejecutar el script cada vez que desee agregar un nuevo usuario (o cambiar las fotos por uno que ya existe).

Paso 6:entrenador

En esta segunda fase, debemos tomar todos los datos del usuario de nuestro conjunto de datos y "entrenar" el OpenCV Recognizer. Esto se realiza directamente mediante una función OpenCV específica. El resultado será un archivo .yml que se guardará en un directorio "trainer /".

Leer más detalles:Reconocimiento facial en tiempo real:un proyecto de principio a fin