Cómo hacer un proyecto de reconocimiento facial Raspberry Pi

Raspberry Pi es una mini computadora de bajo costo que ha facilitado mucho la informática y la programación para la mayoría de las personas, incluidos los estudiantes y aficionados. Esta mini computadora puede hacer todo lo que puede hacer una computadora de escritorio, desde navegar por Internet hasta crear proyectos y programas interesantes. Y uno de estos increíbles proyectos es hacer un reconocimiento facial Raspberry Pi. Si bien este proyecto puede ser muy interesante, no es muy fácil de realizar. Entonces, te recomiendo que sigas el artículo paso a paso.

Reconocimiento facial Raspberry Pi

Hacer un programa de reconocimiento facial podría haber sido algo muy difícil y avanzado alguna vez. Pero con , ¡nada es demasiado difícil! En este artículo, he utilizado la biblioteca de visión por computadora de código abierto (OpenCV) para hacer el proyecto.

Este repositorio fue diseñado para funcionar con eficiencia computacional y aplicaciones en tiempo real. Por lo tanto, es ideal para nuestro programa de reconocimiento facial en tiempo real. Este artículo lo guiará paso a paso a través de todo el proyecto. ¡Por lo tanto, quédese hasta el final para tener su propio reconocimiento facial Raspberry Pi!

Requisitos

Necesitará lo siguiente para hacer un sistema de reconocimiento facial Raspberry Pi:

  1. Raspberry Pi V4
  2. Cámara Noir
  3. OpenCV

Conexiones Raspberry Pi

Asegúrese de crear las siguientes conexiones antes de comenzar a codificar:

  1. Realice las conexiones entre la Raspberry Pi y el cable plano desde la pantalla
  2. Conecte el SDA al pin SDA de su Pi
  3. Coloque el SCL de la pantalla en el pin SCL
  4. Conecte el cable plano de la cámara a la Raspberry Pi
  5. Ponga el GND de la pantalla en el Pi GND
  6. Conecte la Raspberry Pi 5V y la pantalla 5V

Reconocimiento facial Raspberry Pi - Conexiones

Paso 1: Instale OpenCV en Raspberry Pi

El primer paso es instalar OpenCV en su dispositivo Pi. Para hacer eso, inicie su Raspberry Pi y abra una conexión SSH. Para incluir todo el espacio disponible en la tarjeta micro-SD, expanda su sistema de archivos.

$ sudo raspi-config

Luego seleccione las “Opciones avanzadas” en el menú y luego “Expandir sistema de archivos”:

Instalar OpenCV 4 - Opciones avanzadas

Instalar OpenCV 4 - Expandir el sistema de archivos

Después de eso, presione el botón “<Finish>” y reinicie su Raspberry Pi.

$ sudo reboot

Paso 2: Confirme la instalación de OpenCV

Una vez que haya terminado de reiniciar, debería haber un entorno virtual OpenCV listo en su Pi. Ahora, debe confirmar si OpenCV está instalado correctamente en su Pi. Ejecute el comando “fuente” cada vez que abra una nueva terminal para que las variables del sistema estén configuradas correctamente.

source ~/.profile

Ahora, ingrese a su entorno virtual:

workon cv

El texto (cv) significa que se encuentra en el entorno virtual cv.

(cv) [email protected]:~$

Para ingresar a su intérprete de Python:

python

Verá aparecer un “>>>” en el intérprete. Para importar la biblioteca OpenCV:

import cv2

Si no hay mensajes de error, puede estar seguro de que OpenCV está instalado correctamente.

Paso 3: Descarga OpenCV

Ahora, descargue su OpenCV instalado. Tendrá que descargar OpenCV y OpenCV contrib. El contrib viene con módulos y funciones que necesitará en este experimento.

$ cd ~
$ wget -O opencv.zip https://github.com/opencv/opencv/archive/4.0.0.zip
$ wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.0.0.zip

Ahora, descomprime los archivos:

$ unzip opencv.zip
$ unzip opencv_contrib.zip

Paso 4: instalar dependencias

Ahora, instale las dependencias OpenCV necesarias en su Raspberry Pi para que funcione correctamente:

$ sudo apt-get update && sudo apt-get upgrade
$ sudo apt-get install build-essential cmake pkg-config
$ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng-dev
$ sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
$ sudo apt-get install libxvidcore-dev libx264-dev
$ sudo apt-get install libgtk2.0-dev libgtk-3-dev
$ sudo apt-get install libfontconfig1-dev libcairo2-dev
$ sudo apt-get install libgdk-pixbuf2.0-dev libpango1.0-dev
$ sudo apt-get install libhdf5-dev libhdf5-serial-dev libhdf5-103
$ sudo apt-get install libqtgui4 libqtwebkit4 libqt4-test python3-pyqt5
$ sudo apt-get install libatlas-base-dev gfortran
$ sudo apt-get install python2.7-dev python3-dev
$ sudo apt-get install python3-pil.imagetk

Paso 5: instalar pip

En este paso, deberá instalar un administrador de paquetes para Python llamado “pip”.

$ wget https://bootstrap.pypa.io/get-pip.py
$ sudo python3 get-pip.py

Paso 6: instala Numpy

Después de eso, instale una biblioteca de Python llamada “Numpy”.

$ pip3 install numpy

Paso 7: prueba la cámara

Ahora que ha instalado todas las cosas necesarias, incluido OpenCV, es hora de comprobar si su cámara funciona correctamente. Ya debería tener un Picam instalado en su Raspberry Pi. Ingrese el siguiente código en su Python 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) # Flip camera vertically
gray= cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
cv2.imshow('frame', frame)
cv2.imshow('gray', gray)
k= cv2.waitKey(30) & 0xff
if k== 27: # press 'ESC' to quit
break
cap.release()
cv2.destroyAllWindows()

Este código funciona capturando el flujo de video generado por su PiCam que muestra tanto el modo gris como el modo de color BGR. Luego ejecute el código con el siguiente comando:

python simpleCamTest.py

Ahora, presione la tecla [ESC] para finalizar el programa. Asegúrese de hacer clic en la ventana del video antes de terminarlo. Ahora debería ver que su cámara funciona correctamente y muestra resultados. Si su cámara muestra mensajes de error “Afirmación fallida”, utilice el siguiente comando para solucionarlo:

sudo modprobe bcm2835-v4l2

Reconocimiento facial Raspberry Pi - Prueba de cámara

Paso 8: Detección de rostro

Debe saber que el primer paso para completar nuestro proyecto de reconocimiento facial es hacer que la PiCam capture una cara. Seguramente, primero tiene que detectar un rostro para poder reconocerlo en el futuro.

El algoritmo de detección de rostros requiere imágenes con la cara y sin la cara para entrenar al clasificador y salvar estructuras de esas. Afortunadamente, el OpenCV que descargó de antemano viene con un detector y un entrenador. Además, ya cuenta con algunos clasificadores previamente entrenados como rostro, ojos, manos, etc. Para crear un detector facial con OpenCV, use los siguientes códigos:

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)
gray= cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces= faceCascade.detectMultiScale(
gray,
scaleFactor=1.2,
minNeighbors=5,
minSize=(20, 20)
)
for (x,y,w,h) in faces:
cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray= gray[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: # press 'ESC' to quit
break
cap.release()
cv2.destroyAllWindows()

Ahora, tendrá que llamar a la función de clasificador con algunos factores de escala, parámetros y un tamaño mínimo de la cara que detectará.

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

Este código funciona detectando rostros en una imagen. Ahora, es posible que desee marcar las caras usando una forma como un rectángulo. Use el siguiente código para hacer eso:

for (x,y,w,h) in faces:
cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray= gray[y:y+h, x:x+w]
roi_color= img[y:y+h, x:x+w]

Entonces, así es como funciona:

Si el clasificador encuentra caras en la imagen, muestra las posiciones de la cara como un rectángulo como se ordenó, donde usa “h” como su altura y “w” como el ancho y las esquinas hacia arriba a la izquierda (x, y). Eso resume bastante bien nuestro rectángulo (x, y, w, h).

Ahora que ha terminado con las ubicaciones, cree un “ROI” para la cara y muestre el resultado con la función imshow (). Ejecútelo en el entorno de Python usando la Terminal Raspberry Pi:

python faceDetection.py

Y el resultado:

Reconocimiento facial Raspberry-Pi

Paso 9: guardar datos

En esta parte, debe crear un conjunto de datos donde su programa guardará los datos recopilados sobre las identificaciones de la cara que ha detectado. Para hacer eso, cree un directorio (estoy usando FacialRecognition):

mkdir FacialRecognition

Ahora, cree un subdirectorio con el nombre “conjunto de datos”.

mkdir dataset

Luego, use el siguiente código:

import cv2
import os
cam= cv2.VideoCapture(0)
cam.set(3, 640) # set video width
cam.set(4, 480) # set video height
face_detector= cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
# For each person, enter one numeric face id
face_id= input('\n enter user id end press <return>==>  ')
print("\n [INFO] Initializing face capture. Look the camera and wait ...")
# Initialize individual sampling face count
count= 0
while(True):
ret, img= cam.read()
img= cv2.flip(img, -1) # flip video image vertically
gray= cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces= face_detector.detectMultiScale(gray, 1.3, 5)
for (x,y,w,h) in faces:
cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 2)
count += 1
# Save the captured image into the datasets folder
cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y+h,x:x+w])
cv2.imshow('image', img)
k= cv2.waitKey(100) & 0xff # Press 'ESC' for exiting video
if k== 27:
break
elif count >= 10: # Take 10 face sample and stop video
break
# Do a bit of cleanup
print("\n [INFO] Exiting Program and cleanup stuff")
cam.release()
cv2.destroyAllWindows()

Tenga en cuenta que vamos a guardar cada uno de los fotogramas capturados como un archivo en el subdirectorio “conjunto de datos”:

cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y+h,x:x+w])

Después de eso, debe importar la biblioteca “os” para guardar el archivo anterior. El nombre de los archivos seguirá una estructura como esta:

User.face_id.count.jpg,/pre>

El código mencionado anteriormente capturará solo 10 imágenes por cada identificación. Seguramente puedes cambiar eso si quieres.
Ahora, intente ejecutar el programa y capture algunos identificadores. Asegúrese de ejecutar el código cada vez que cambie el usuario o la foto existente.

Paso 10: Entrenador

En este paso, tendrá que usar una función OpenCV para entrenar el reconocedor OpenCV con los datos de su conjunto de datos. Empiece por crear un subdirectorio para almacenar los datos entrenados.

mkdir trainer

Luego ejecute el siguiente código:

import cv2
import numpy as np
from PIL import Image
import os
# Path for face image database
path= 'dataset'
recognizer= cv2.face.LBPHFaceRecognizer_create()
detector= cv2.CascadeClassifier("haarcascade_frontalface_default.xml");
# function to get the images and label data
def getImagesAndLabels(path):
 imagePaths= [os.path.join(path,f) for f in os.listdir(path)]
 faceSamples=[]
 ids= []
 for imagePath in imagePaths:
  PIL_img= Image.open(imagePath).convert('L') # convert it to grayscale
  img_numpy= np.array(PIL_img,'uint8')
  id= int(os.path.split(imagePath)[-1].split(".")[1])
  faces= detector.detectMultiScale(img_numpy)
  for (x,y,w,h) in faces:
            faceSamples.append(img_numpy[y:y+h,x:x+w])
            ids.append(id)
 return faceSamples,ids
print ("\n [INFO] Training faces. It will take a few seconds. Wait ...")
faces,ids= getImagesAndLabels(path)
recognizer.train(faces, np.array(ids))
# Save the model into trainer/trainer.yml
recognizer.write('trainer/trainer.yml') # recognizer.save() worked on Mac, but not on Pi
# Print the numer of faces trained and end program
print("\n [INFO] {0} faces trained. Exiting Program".format(len(np.unique(ids))))

Asegúrese de haber instalado la biblioteca PIL en su Raspberry Pi. Si no lo tiene, ejecute el siguiente comando:

pip install pillow

Aquí, estoy usando el reconocedor facial LBPH que viene incluido con el paquete OpenCV. Ahora, sigue esta línea:

recognizer= cv2.face.LBPHFaceRecognizer_create()

Todas sus fotos se llevarán al directorio “conjunto de datos” mediante la función “getImagesAndLabels”. Devolverá 2 matrices llamadas “ID” y “caras”. Ahora es el momento de entrenar al reconocedor.

recognizer.train(faces, ids)

Ahora, verá el archivo denominado “trainer.yml” guardado en el directorio del entrenador.

Paso 11: Reconocimiento facial

Es hora de la acción final. Después de este paso, su reconocedor puede adivinar una identificación de retorno si la cara fue capturada antes. Entonces, escribamos nuestro código final:

import cv2
import numpy as np
import os 
recognizer= cv2.face.LBPHFaceRecognizer_create()
recognizer.read('trainer/trainer.yml')
cascadePath= "haarcascade_frontalface_default.xml"
faceCascade= cv2.CascadeClassifier(cascadePath);
font= cv2.FONT_HERSHEY_SIMPLEX
#iniciate id counter
id= 0
# names related to ids: example==> Marcelo: id=1,  etc
names= ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z'] 
# Initialize and start realtime video capture
cam= cv2.VideoCapture(0)
cam.set(3, 640) # set video widht
cam.set(4, 480) # set video height
# Define min window size to be recognized as a face
minW= 0.1*cam.get(3)
minH= 0.1*cam.get(4)
while True:
    ret, img=cam.read()
    img= cv2.flip(img, -1) # Flip vertically
    gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    
    faces= faceCascade.detectMultiScale( 
        gray,
        scaleFactor= 1.2,
        minNeighbors= 5,
        minSize= (int(minW), int(minH)),
       )
    for(x,y,w,h) in faces:
        cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)
        id, confidence= recognizer.predict(gray[y:y+h,x:x+w])
        # Check if confidence is less them 100==> "0" is perfect match 
        if (confidence < 100):
            id= names[id]
            confidence= "  {0}%".format(round(100 - confidence))
        else:
            id= "unknown"
            confidence= "  {0}%".format(round(100 - confidence))
        
        cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2)
        cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1)  
    
    cv2.imshow('camera',img) 
    k= cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video
    if k== 27:
        break
# Do a bit of cleanup
print("\n [INFO] Exiting Program and cleanup stuff")
cam.release()
cv2.destroyAllWindows()

El programa funciona como reconocedor. La función predecir () toma diferentes partes de la cara capturada como parámetros diferentes y regresa al propietario guardado mientras muestra la identificación.
Si no reconoce la cara, mostrará “desconocido” en la imagen.

Entonces, ¡voila!

Reconocimiento facial en tiempo real

Finalmente, Insights

Entonces, así es como se hace un reconocimiento facial de Raspberry Pi. ¡Asegúrese de seguir este artículo paso a paso para obtener el mejor resultado! Ahora, además de este clasificador de reconocimiento facial, también puedes realizar reconocimiento ocular o reconocimiento de sonrisas utilizando diferentes clasificadores y funciones. Investigué todos los artículos relacionados en Internet y se me ocurrió este. Entonces, realmente espero que esta guía te haya ayudado con los proyectos. Y espero que tenga éxito. ¡No olvide mencionar sus pensamientos en la sección de comentarios!

Leave a Comment

Your email address will not be published. Required fields are marked *