Reconocimiento Facial e Identificación en Visión por Computadora

El rápido avance en el aprendizaje automático y las tecnologías de IA ha logrado importantes progresos en visión por computadora para la detección y reconocimiento de objetos. Sin embargo, crear un sistema capaz de reconocer el humor y la diversión en las personas sigue siendo un desafío para los programadores, ya que la comedia y el entretenimiento son subjetivos y se basan en gustos personales y contexto cultural. Por lo tanto, es complicado diseñar un sistema que pueda determinar con precisión lo que las personas encuentran divertido o agradable.

A pesar de ello, la visión por computadora en el reconocimiento facial e identificación ha alcanzado progresos significativos, y se emplea ampliamente en diversas aplicaciones como seguridad, vigilancia y biometría. La tecnología de reconocimiento facial identifica a las personas analizando y comparando sus rasgos faciales con una base de datos de caras conocidas. La identificación facial implica emparejar la cara de una persona con su identidad. Utiliza algoritmos para extraer características faciales como la distancia entre los ojos, las curvas de la nariz y el ángulo de la mandíbula para generar una firma facial única.

Técnicas de Reconocimiento y Identificación Facial

Existen varios métodos para reconocer e identificar caras, pero este tutorial se centrará en tres técnicas y describirá sus ventajas y desventajas.

1. Enfoque Basado en Plantillas

Primero, el enfoque basado en plantillas compara las características faciales de una cara objetivo con las de una imagen plantilla o de referencia. La imagen plantilla incluye varias características faciales, como la posición de los ojos, nariz, boca y las distancias entre ellos. La técnica compara entonces la cara objetivo con la imagen plantilla para determinar si hay una coincidencia. Las eigenfaces son uno de los métodos basados en plantillas más comunes que utilizan el análisis de componentes principales (PCA) para reducir la dimensionalidad de las imágenes faciales y extraer las características más relevantes.

Ventajas

• Son muy precisos con plantillas de alta calidad
• Maneja variaciones en la iluminación y expresiones faciales

Desventajas

• Requiere plantillas de alta calidad para resultados precisos
• Puede ser computacionalmente costoso

2. Enfoque Basado en Características

En segundo lugar, la técnica basada en características extrae características de la cara, como la forma de los ojos, la distancia entre las cejas y la curvatura de los labios. El enfoque luego compara estas características con las de una base de datos de caras conocidas para identificar la cara objetivo. Ejemplos de técnicas típicas basadas en características incluyen el Patrón Binario Local (LBP) y la Transformada de Características Invariantes a Escala (SIFT).

Ventajas

• Relativamente rápido y eficiente
• Funciona con imágenes de baja resolución

Desventajas

• Puede no funcionar bien con condiciones de iluminación variables
• Puede no ser robusto a cambios en expresiones faciales o poses

3. Enfoque Basado en Aprendizaje Profundo

Por último, un enfoque basado en el aprendizaje profundo utiliza redes neuronales profundas para aprender características directamente de imágenes faciales. Las redes se entrenan en grandes conjuntos de datos de imágenes faciales para identificar patrones y características relevantes para el reconocimiento facial. Ejemplos de métodos típicos basados en aprendizaje profundo incluyen Redes Neuronales Convolucionales (CNN) y Redes Siamesas.

Ventajas

• Alcanza una alta precisión con grandes conjuntos de datos
• Maneja variaciones en las expresiones faciales y poses

Desventajas

• Requiere una gran cantidad de datos de entrenamiento
• Computacionalmente costoso

NOTA: Existen varias técnicas para el reconocimiento y la identificación facial.

Reconocimiento y Identificación Facial Usando Python y OpenCV

Con la disponibilidad de potentes bibliotecas como OpenCV y los avances en algoritmos de aprendizaje automático, ha sido más fácil que nunca desarrollar sistemas de reconocimiento y identificación facial usando Python. OpenCV proporciona un rico conjunto de funciones y herramientas para el procesamiento de imágenes, particularmente útiles en tareas de reconocimiento facial como detección de rostros, extracción de características y emparejamiento. También cuenta con modelos preelaborados como el clasificador de cascadas Haar para la detección de rostros y VGG o ResNet para etiquetar los rostros detectados.

OpenCV proporciona varios modelos para etiquetar caras, como Eigenfaces, Fisherfaces y Histogramas de Patrones Binarios Locales (LBPH). Entrenamos estos modelos para identificar a individuos específicos presentándoles imágenes de las personas que queremos reconocer. Eigenfaces utiliza el Análisis de Componentes Principales (PCA) para construir una imagen de la cara a partir de partes más pequeñas, mientras que Fisherfaces emplea el Análisis Discriminante Lineal (LDA) para distinguir entre caras. LBPH compara la textura de las caras con caras conocidas.

Identificación Facial

Importar Dependencias

Importe las bibliotecas necesarias.

import numpy as np
import cv2
import matplotlib.pyplot as plt
from IPython.display import Image

from google.colab import drive
drive.mount('/content/drive')

Cargar Modelos Pre-entrenados e Imagen

OpenCV proporciona un conjunto de clasificadores `Haar Cascade` pre-entrenados para detectar varios objetos, incluidas las caras. `cv2.CascadeClassifier` es una clase que representa el clasificador Haar Cascade. cv2.data.haarcascades es una ruta al directorio que contiene los modelos pre-entrenados. `haarcascade_frontalface_default.xml` es el archivo que contiene el modelo pre-entrenado de detección de caras. El modelo está disponible para descarga gratuita en GitHub.

# Cargar el modelo pre-entrenado de detección de caras
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

Cargar la imagen de entrada `image1.jpg` que puede ser una imagen de su elección utilizando la función `imread()` de OpenCV. Luego convierte la imagen a escala de grises utilizando la función `cvtColor()` de OpenCV. La imagen en escala de grises es necesaria para el algoritmo de detección de caras.

# Cargar la imagen y convertirla a escala de grises
img = cv2.imread('/content/drive/MyDrive/Face Detection/image1.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#mostrar la imagen 
plt.imshow(gray)

La línea siguiente detecta caras en la imagen en escala de grises utilizando el método detectMultiScale() de la clase CascadeClassifier. El método detectMultiScale() toma los siguientes argumentos:

`gray`: la imagen en escala de grises

`scaleFactor`: es un parámetro que especifica cuánto se minimiza el tamaño de la imagen en cada escala de la imagen. Un valor de 1.3 significa que la imagen se reduce en un 30% en cada escala.

`minNeighbors`: es un parámetro que especifica cuántos vecinos debería tener cada rectángulo candidato para retenerlo, un valor más alto resulta en menos detecciones pero con mayor confianza.

`El método detectMultiScale()` devuelve una lista de rectángulos donde se detectan caras. Cada rectángulo representa una tupla de cuatro enteros `(x,y,w,h)` que representan las coordenadas del vértice superior izquierdo `(x,y)` del rectángulo y su ancho `w` y altura `h`.

# Detectar caras en la imagen en escala de grises
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

Dibujar Rectángulo en Región de la Cara

Creemos un bucle que dibuje rectángulos alrededor de las caras detectadas en la imagen original. La función cv2.rectangle() toma los siguientes argumentos:

`img`: la imagen original.    

`(x,y)`: las coordenadas del vértice superior izquierdo del rectángulo.    

`(x+w,y+h)`: las coordenadas del vértice inferior derecho del rectángulo.    

`(255,0,0)`: representa el color binario del rectángulo dibujado en formato RGB. (255,0,0) representa azul.

`5`: el grosor del borde del rectángulo en píxeles.

# Dibujar rectángulos alrededor de las caras detectadas
for (x,y,w,h) in faces:

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

#Mostrar la imagen después de construir el rectángulo.


# Mostrar la imagen con las caras detectadas

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))

plt.show()

# Guardar la imagen detectada con un nombre
cv2.imwrite('detected_image.jpg', img)

# Confirmar si la imagen guardada existe.
detected_image=cv2.imread("detected_image.jpg", 1)
gray_channels_reversed = detected_image[:, :, ::-1]
plt.imshow(gray_channels_reversed)

Reconocimiento Facial

No entraremos en una explicación como la mencionada anteriormente, sino que utilizaremos la imagen detectada guardada para confirmar si el modelo funciona para la identificación al proporcionar diferentes imágenes para la detección.

Importar Dependencias

import numpy as np
import cv2
import matplotlib.pyplot as plt
import dlib
from imutils import face_utils
from scipy.spatial.distance import cosine
from sklearn.metrics.pairwise import cosine_similarity

Cargar el Modelo de Detección de Rostros y el Detector de Punto de Referencia Facial

La función `dlib.get_frontal_face_detector()` devuelve un modelo de detección de rostros pre-entrenado capaz de detectar rostros humanos en imágenes. Para más información, consulta las funciones de dlib.net. Además, descarga el detector de puntos de referencia.

# Cargar el modelo de detección de rostros y el detector de puntos de referencia facial
face_detector = dlib.get_frontal_face_detector()
landmark_detector = dlib.shape_predictor('/content/drive/MyDrive/Face Detection/shape_predictor_68_face_landmarks_GTX.dat')

# Cargar la imagen detectada de 

img1 = cv2.imread('/content/drive/MyDrive/Face Detection/detected_image.jpg')
gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)


# Detectar el rostro y los puntos de referencia faciales de la imagen
rects1 = face_detector(gray1, 1)
landmarks1 = landmark_detector(gray1, rects1[0])
landmarks1 = face_utils.shape_to_np(landmarks1)

# Cargar otra imagen para comparar con la imagen cargada previamente
img2 = cv2.imread('/content/drive/MyDrive/Face Detection/001_d3323f3c.jpg')
gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)

### Establecer parámetros del modelo

# Detectar la cara y los puntos de referencia faciales de la segunda imagen

rects2 = face_detector(gray2, 1)

landmarks2 = landmark_detector(gray2, rects2[0])

landmarks2 = face_utils.shape_to_np(landmarks2)

# Extraer las características de las dos imágenes calculando las distancias euclidianas entre los puntos de referencia faciales

features1 = np.zeros(68)

features2 = np.zeros(68)

for i in range(68):

    features1[i] = np.linalg.norm(landmarks1[i] - landmarks1[0])

    features2[i] = np.linalg.norm(landmarks2[i] - landmarks2[0])

#### Entrenar con similitudes

# Calcular la similitud del coseno entre los dos vectores de características

score = cosine(features1, features2)

# Verificar si el puntaje está por debajo de un cierto umbral (por ejemplo, 0.5) para determinar si las dos caras coinciden

if score < 0.5:

    print("The model did not recognize Joseph in one or both of the images..")

else:

    print("The model recognized Joseph in both images.")

Conclusión

En este tutorial, has aprendido el reconocimiento y la identificación facial utilizando Python OpenCV, cómo funciona, sus usos y cómo puede ser implementado. El código de este proyecto puede ser accedido desde el Repositorio de GitHub.