Proyecto de Detección de Rostros en Python [En 5 Sencillos Pasos]

La identificación de objetos y la detección de rostros son probablemente las aplicaciones más populares de la visión artificial. Esta tecnología encuentra aplicaciones en diversas industrias, como la seguridad y las redes sociales. Así que estamos construyendo un proyecto de detección de rostros a través de Python.

Tenga en cuenta que debe estar familiarizado con la programación en Python, OpenCV y NumPy. Se asegurará de que no se confunda mientras trabaja en este proyecto. Empecemos.

Hemos compartido dos métodos para realizar el reconocimiento facial. El primero usa la biblioteca de reconocimiento facial de Python, mientras que el otro usa OpenCV y NumPy. Consulte nuestros programas de ciencia de datos para obtener más información.

Reconocimiento facial con 'Reconocimiento facial' de Python

Probablemente el método más fácil para detectar rostros es usar la biblioteca de reconocimiento de rostros en Python . Tenía una precisión del 99,38% en la base de datos LFW. Usarlo es bastante simple y no requiere mucho esfuerzo. Además, la biblioteca tiene un comando dedicado 'face_recognition' para identificar rostros en imágenes.

Cómo usar el reconocimiento facial

Puede distinguir caras en imágenes usando el comando 'face_locations':

importar reconocimiento facial

imagen = reconocimiento_rostro.cargar_archivo_de_imagen(“su_archivo.jpg”)

ubicaciones_caras = reconocimiento_caras.ubicaciones_caras(imagen)

También puede reconocer caras y asociarlas con sus nombres:

importar reconocimiento facial

imagen_conocida = reconocimiento_rostro.cargar_archivo_de_imagen(“modi.jpg”)

imagen_desconocida = reconocimiento_rostro.cargar_archivo_de_imagen(“desconocido.jpg”)

modi_encoding = face_recognition.face_encodings(imagen_conocida)[0]

codificación_desconocida = reconocimiento_rostro.codificación_rostro(imagen_desconocida)[0]

resultados = face_recognition.compare_faces([modi_encoding], unknown_encoding)

La imagen contiene "Narendra Modi"

Hay muchas otras cosas que puede realizar con esta biblioteca combinándola con otras. Ahora analizaremos la realización del reconocimiento facial con otras bibliotecas destacadas en Python, en particular OpenCV y NumPy.

Leer más: Tutorial de Python NumPy: aprenda Python Numpy con ejemplos

Proyecto de detección de rostros en Python

En este proyecto, hemos realizado detección y reconocimiento de rostros utilizando OpenCV y NumPy. Hemos usado Raspberry Pi, pero también puedes usarlo con otros sistemas. Solo tendrá que modificar ligeramente el código para usarlo en algún otro dispositivo (como una Mac o una PC con Windows).

Parte del crédito por este proyecto es para Marcelo Rovai .

Paso #1: Instalar Bibliotecas

Primero, debe instalar las bibliotecas requeridas, OpenCV y NumPy. Puedes instalarlo fácilmente a través de:

pip instalar opencv-python

pip instalar opencv-contrib-python

Para instalar NumPy en su sistema, use el mismo comando anterior y reemplace 'opencv-python' con 'numpy':

pip instalar numpy

Paso #2: Detectar rostros

Ahora, debe configurar su cámara y conectarla a su sistema. La cámara debería funcionar correctamente para evitar cualquier problema en la detección de rostros.

Antes de que nuestra cámara nos reconozca, primero tiene que detectar rostros. Usaremos el clasificador Haar Cascade para la detección de rostros. Es principalmente un método de detección de objetos en el que entrena una función en cascada a través de imágenes negativas y positivas, después de lo cual puede detectar objetos en otras fotos.

En nuestro caso, queremos que nuestro modelo detecte rostros. OpenCV viene con un entrenador y un detector, por lo que usar el clasificador Haar Cascade es relativamente más cómodo con esta biblioteca. Puede crear su clasificador para detectar otras imágenes también.

Aquí está el código:

importar numpy como np

importar cv2

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

tapa = cv2.VideoCapture(0)

cap.set(3,640) # establecer Ancho

cap.set(4,480) # establecer altura

mientras que es cierto:

ret, img = cap.read()

imagen = cv2.flip(imagen, -1)

gris = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

caras = faceCascade.detectMultiScale(

gris,

factor de escala = 1.2,

minVecinos=5,

minTamaño=(20, 20)

)

para (x,y,w,h) en caras:

cv2.rectangle(img,(x,y),(x+an,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.esperaClave(30) & 0xff

si k == 27: # presione 'ESC' para salir

descanso

cap.liberar()

cv2.destroyAllWindows()

Paso n.º 3: recopilar datos

Ahora que su modelo puede identificar rostros, puede entrenarlo para que comience a reconocer de quién es el rostro en la imagen. Para hacer eso, debes proporcionarle varias fotos de las caras que quieres que recuerde.

Es por eso que comenzaremos con la creación de nuestro conjunto de datos recopilando fotos. Después de recopilar las imágenes necesarias, agregue identificaciones para cada persona, de modo que el modelo sepa qué cara asociar con qué identificación. Comience con las imágenes de una persona y agregue al menos 10-20. Use diferentes expresiones para obtener los resultados más efectivos.

Cree un script para agregar ID de usuario a las imágenes, para que no tenga que hacerlo manualmente cada vez. El guión es vital en caso de que quieras usar tu modelo para varias caras.

Aprenda cursos de aprendizaje automático de las mejores universidades del mundo. Obtenga programas de maestría, PGP ejecutivo o certificado avanzado para acelerar su carrera.

Paso #4: Entrena

Después de crear el conjunto de datos de las imágenes de la persona, tendría que entrenar el modelo. Enviaría las imágenes a su reconocedor OpenCV, y al final creará un archivo llamado 'trainer.yml'.

En esta etapa, solo tiene que proporcionarle al modelo imágenes y sus ID para que el modelo pueda familiarizarse con el ID de cada imagen. Después de que terminemos de entrenar el modelo, podemos probarlo.

Aquí está el código:

importar cv2

importar numpy como np

de imagen de importación PIL

importar sistema operativo

# Ruta para la base de datos de imágenes de rostros

ruta = 'conjunto de datos'

reconocedor = cv2.face.LBPHFaceRecognizer_create()

detector = cv2.CascadeClassifier(“haarcascade_frontalface_default.xml”);

# función para obtener las imágenes y los datos de las etiquetas

def getImagesAndLabels(ruta):

imagePaths = [os.path.join(ruta,f) para f en os.listdir(ruta)]

muestras de caras=[]

identificadores = []

para imagePath en imagePaths:

PIL_img = Image.open(imagePath).convert('L') # escala de grises

img_numpy = np.array(PIL_img,'uint8′)

id = int(os.path.split(imagePath)[-1].split(“.”)[1])

caras = detector.detectMultiScale(img_numpy)

para (x,y,w,h) en caras:

faceSamples.append(img_numpy[y:y+h,x:x+w])

ids.append(id)

volver faceSamples,ids

print ("\n [INFO] Caras de entrenamiento. Tardará unos segundos. Espera...")

caras,ids = getImagesAndLabels(ruta)

reconocedor.tren(caras, np.array(ids))

# Guarda el modelo en trainer/trainer.yml

reconocedor.write('entrenador/entrenador.yml')

# Imprime el número de caras entrenadas y finaliza el programa

print(“\n [INFO] {0} caras entrenadas. Saliendo del programa”.format(len(np.unique(ids))))

Aprenda: Aplicación de MATLAB en reconocimiento facial: código, descripción y sintaxis

Paso #5: Iniciar reconocimiento

Ahora que ha entrenado el modelo, podemos comenzar a probarlo. En esta sección, hemos agregado nombres a las ID para que el modelo pueda mostrar los nombres de los respectivos usuarios que reconoce.

El modelo no reconoce a una persona. Predice si el rostro que detecta coincide con el rostro presente en su base de datos. Nuestro modelo muestra un porcentaje de cuánto coincide el rostro con el rostro presente en su base de datos. Su precisión dependerá en gran medida de la imagen que esté probando y de las imágenes que haya agregado a su base de datos (las imágenes con las que entrenó al modelo).

Aquí está el código:

importar cv2

importar numpy como np

importar sistema operativo

reconocedor = cv2.face.LBPHFaceRecognizer_create()

reconocedor.read('entrenador/entrenador.yml')

cascadePath = "haarcascade_frontalface_default.xml"

faceCascade = cv2.CascadeClassifier(cascadePath);

fuente = cv2.FONT_HERSHEY_SIMPLEX

#iniciar contador de identificación

identificación = 0

# nombres relacionados con ids: ejemplo ==> upGrad: id=1, etc.

nombres = ['Ninguno', UpGrad', Yo', 'Amigo', 'Y', 'X']

# Inicialice e inicie la captura de video en tiempo real

cámara = cv2.VideoCapture(0)

cam.set(3, 640) # establece el ancho del video

cam.set(4, 480) # establece la altura del video

# Defina el tamaño mínimo de la ventana para ser reconocido como una cara

minW = 0.1*cam.get(3)

minH = 0.1*cam.get(4)

mientras que es cierto:

ret, img = cámara.leer()

img = cv2.flip(img, -1) # Voltear verticalmente

gris = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

caras = faceCascade.detectMultiScale(

gris,

factor de escala = 1.2,

minVecinos = 5,

minSize = (int(minW), int(minH)),

)

for(x,y,w,h) en caras:

cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)

id, confianza = reconocedor.predecir(gris[y:y+h,x:x+w])

# Si la confianza es inferior a 100 ==> “0”: coincidencia perfecta

si (confianza < 100):

id = nombres[id]

confianza = ” {0}%”. formato (redondo (100 – confianza))

demás:

id = "desconocido"

confianza = ” {0}%”. formato (redondo (100 – confianza))

cv2.putText(

imagen,

cadena (id),

(x+5,y-5),

fuente,

1,

(255,255,255),

2

)

cv2.putText(

imagen,

str(confianza),

(x+5,y+h-5),

fuente,

1,

(255,255,0),

1

)

cv2.imshow('cámara',img)

k = cv2.waitKey(10) & 0xff # Presione 'ESC' para salir del video

si k == 27:

descanso

# Haz una limpieza

print(“\n [INFO] Saliendo del programa y limpiando”)

cam.release()

cv2.destroyAllWindows()

Hemos llegado al final de nuestro proyecto de detección de rostros en Python. Ahora sabe cómo crear un modelo de aprendizaje automático que detecta y reconoce rostros. ¡Asegúrate de compartir tus resultados con nosotros!

Aprender: tutorial de detección de objetos de TensorFlow para principiantes

Obtenga más información sobre el aprendizaje automático

Esperamos que te haya gustado este proyecto de detección de rostros. Si desea que sea más desafiante, puede agregar varias caras en su conjunto de datos y entrenar su modelo en consecuencia. ¡También puede combinarlo con otras bibliotecas y extender el proyecto a otra cosa, como un sistema de seguridad de detección de rostros para un programa!

Si está interesado en obtener más información sobre el aprendizaje automático, consulte el Programa PG Ejecutivo en Aprendizaje Automático e IA de IIIT-B y upGrad, que está diseñado para profesionales que trabajan y ofrece más de 450 horas de capacitación rigurosa, más de 30 estudios de casos y asignaciones, IIIT -Estado de exalumno B, más de 5 proyectos prácticos finales prácticos y asistencia laboral con las mejores empresas.