Cómo hacer un proyecto de reconocimiento facial Raspberry Pi

Raspberry Pi es una mini computadora de bajo costo que ha hecho que la computación y la programación sean mucho más fáciles para la mayoría de las personas, incluidos los estudiantes y aficionados. Esta mini computadora puede hacer todo lo que una computadora de escritorio puede hacer, 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 una vez. Pero con Raspberry Pi, 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

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":

Después de eso, presiona el "" y reinicia tu Raspberry Pi.

$ sudo reiniciar

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.

fuente ~ /.perfil

Ahora, ingrese a su entorno virtual:

trabajar en cv

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

(cv) pi @ frambuesa: ~ $

Para ingresar a su intérprete de Python:

pitón

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

importar 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.Código Postal

Ahora, descomprime los archivos:

$ descomprimir opencv.zip $ unzip opencv_contrib.Código Postal

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- obtener instalar 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: // arranque.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 instalar 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.Límite de VideoCapture (0).set (3,640) # set Cap de ancho.set (4,480) # set Height while (True): ret, frame = cap.read () frame = cv2.flip (frame, -1) # Voltear la cámara verticalmente gris = cv2.cvtColor (marco, cv2.COLOR_BGR2GRAY) cv2.imshow ('marco', marco) cv2.imshow ('gris', gris) k = cv2.waitKey (30) & 0xff si k == 27: # presione 'ESC' para salir del límite de ruptura.lanzamiento () cv2.destroyAllWindows ()

Este código funciona capturando la transmisión de video generada 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úrate 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

Paso 8: Detección de rostro

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

El algoritmo de detección de rostros requiere imágenes con el rostro y sin él para entrenar al clasificador y salvar estructuras de esos. 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:

importar numpy como np importar cv2 faceCascade = cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml ') cap = cv2.Límite de VideoCapture (0).set (3,640) # set Cap de ancho.set (4,480) # set Height while True: ret, img = cap.leer () img = cv2.voltear (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.rectángulo (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 si k == 27: # presione 'ESC' para salir del límite de ruptura.lanzamiento () 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 (gris, 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:

para (x, y, w, h) en caras: cv2.rectángulo (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]

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:

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

reconocimiento facial mkdir

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

conjunto de datos mkdir

Luego, usa el siguiente código:

importar cv2 importar os cam = cv2.VideoCapture (0) cámara.set (3, 640) # set cámara de ancho de video.set (4, 480) # set video height face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ') # Para cada persona, ingrese un ID de rostro numérico face_id = input (' \ n ingrese el ID de usuario y presione  ==> ') print ("\ n [INFO] Inicializando captura facial. Mire la cámara y espere… ") # Inicialice el recuento de rostros de muestreo individual = 0 while (True): ret, img = cam.leer () img = cv2.flip (img, -1) # voltear imagen de video verticalmente gris = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) caras = face_detector.detectMultiScale (gris, 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 (recuento) + ".jpg ", gris [y: y + h, x: x + w]) cv2.imshow ('imagen', img) k = cv2.waitKey (100) & 0xff # Presione 'ESC' para salir del video si k == 27: break elif count> = 10: # Tome 10 muestras de caras y detenga el video # Realice un poco de limpieza print ("\ n [INFO] Saliendo del programa y cosas de limpieza ") cam.lanzamiento () 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 ("conjunto de datos / usuario."+ str (face_id) + '.'+ str (recuento) + ".jpg ", gris [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:

Usuario.face_id.contar.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. Comience creando un subdirectorio para almacenar los datos entrenados.

entrenador mkdir

Luego ejecuta 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.cara.LBPHFaceRecognizer_create () detector = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml "); # función para obtener las imágenes y los datos de la etiqueta def getImagesAndLabels (ruta): imagePaths = [os.camino.unirse (ruta, f) para f en el sistema operativo.listdir (ruta)] faceSamples = [] ids = [] para imagePath en imagePaths: PIL_img = Image.abrir (imagePath).convert ('L') # convertirlo a escala de grises img_numpy = np.matriz (PIL_img, 'uint8') id = int (os.camino.dividir (imagePath) [- 1].separar(".") [1]) caras = detector.detectMultiScale (img_numpy) para (x, y, w, h) en caras: faceSamples.añadir (img_numpy [y: y + h, x: x + w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Caras de entrenamiento. Tardará unos segundos. Espera ... ") caras, ids = reconocedor de getImagesAndLabels (ruta).tren (caras, np.array (ids)) # Guarde el modelo en entrenador / entrenador.reconocedor de yml.escribir ('entrenador / entrenador.yml ') # reconocedor.save () funcionó en Mac, pero no en Pi # Imprime el número de caras entrenadas y finaliza el programa print ("\ n [INFO] 0 caras entrenadas. Saliendo del programa ".formato (len (np.único (ids))))

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

pip instalar almohada

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

reconocedor = cv2.cara.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.

reconocedor.tren (caras, ids)

Ahora, verá el "entrenador.yml ”archivo con nombre 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 que regresa si la cara fue capturada antes. Entonces, escribamos nuestro código final:

import cv2 import numpy as np import os Recognizer = cv2.cara.LBPHFaceRecognizer_create () reconocedor.read ('entrenador / entrenador.yml ') cascadePath = "haarcascade_frontalface_default.xml "faceCascade = cv2.CascadeClassifier (cascadePath); font = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # nombres relacionados con los identificadores: ejemplo ==> Marcelo: id = 1, etc names = ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Inicializar e iniciar la captura de video en tiempo real cam = cv2.VideoCapture (0) cámara.set (3, 640) # set video widht cam.set (4, 480) # set video height # Definir el tamaño mínimo de la ventana para que se reconozca como una cara minW = 0.1 * cámara.obtener (3) minH = 0.1 * cámara.get (4) while True: ret, img = cam.leer () img = cv2.flip (img, -1) # Voltear verticalmente gris = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) caras = faceCascade.detectMultiScale (gris, scaleFactor = 1.2, minNeighbors = 5, minSize = (int (minW), int (minH)),) para (x, y, w, h) en caras: cv2.rectángulo (img, (x, y), (x + w, y + h), (0,255,0), 2) id, confianza = reconocedor.predecir (gris [y: y + h, x: x + w]) # Comprueba si la confianza es menor que ellos 100 ==> "0" es una coincidencia perfecta si (confianza < 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 diferentes parámetros y regresa al propietario guardado mientras muestra la identificación.
Si no reconoce la cara, mostrará "desconocido" en la imagen.

Entonces, Voila!

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 sea exitoso para ti. No olvide mencionar sus pensamientos en la sección de comentarios!