Reconocedor de expresiones faciales con FER: uso de Deep Neural Net

En nuestra vida diaria, a sabiendas o sin saberlo, llevamos a cabo diferentes tipos de Expresiones Faciales. Estos movimientos transmiten el estado emocional de los humanos.

Podemos juzgar el estado de ánimo y mental de la siguiente persona por su expresión facial. A principios del siglo XX, Ekman y Friesen definieron «seis» emociones básicas.

Esta expresión no cambia con las culturas, son universales. Seis expresiones faciales son: –

• Felicidad
• Tristeza
• Miedo
• Enfado
• Sorpresa
• Asco

En este artículo, compartiré cómo construir un reconocedor de expresiones faciales utilizando la biblioteca `FER` de Python.

Biblioteca FER: 

La biblioteca de reconocimiento de expresiones faciales está desarrollada por Justin Shenk . Esta biblioteca requiere las dependencias OpenCV>=3.2 y Tensorflow>=1.7.0 instaladas en el sistema. Las caras se detectan utilizando el clasificador Haar Cascade de OpenCV. Para obtener más información y el código fuente de la biblioteca FER, puede visitar la página GitHub de FER aquí.

 ¡Configurando nuestro código!

Para este artículo, puede usar un editor de código en línea llamado Repl.it , o puede usar su editor de código favorito. Se puede instalar a través  

pip:`$ pip install fer`

1. Edite su nuevo archivo `main.py` con el siguiente código:

import cv2
 
from fer import FER
 
import matplotlib.pyplot as plt
 
import matplotlib.image as mpimg

El código de arriba dice que:

• Importe ` cv2 ` completo, comúnmente conocido como biblioteca Open CV. Nos proporciona diversas soluciones de visión artificial. Usaremos esta biblioteca principalmente para leer y manipular imágenes. Puede leer más sobre la `Biblioteca Open Cv` en OpenCV Docs 
• Importe la función ‘FER’ de la biblioteca ‘ fer ‘. Esta es la biblioteca principal que usaremos en este taller.
• Agregue el módulo ` matplotlib.pyplot ` como ` plt `. Nos ayudará a trazar gráficas.
• Incluya el módulo `matplotlib.image` como ` mpimg `. Matplotlib.image  de la biblioteca matplotlib se utiliza para trazar imágenes en el gráfico con los ejes `x` e `y`.

 2. A continuación, predeciremos las emociones de las imágenes fijas al proporcionar la imagen de entrada:

# Input Image
input_image = cv2.imread("smile.jpg")
emotion_detector = FER()
# Output image's information
print(emotion_detector.detect_emotions(input_image))

Imagen de entrada

 Intente comprender lo que el código anterior está tratando de decir. Aquí está la explicación del código anterior:

• Nuestra variable ` imagen` carga una imagen del archivo especificado en nuestro caso ` abc.jpg` utilizando el método ` cv2.imread(“abc.jpg”) `.
• A continuación, asignaremos ` FER() ` que se importó anteriormente a la variable ** detector **.
• La sintaxis de impresión con ` detector.detect_emotions(image) ` como parámetro devolverá el diccionario de notaciones de cuadro delimitador.

A continuación se muestra la salida de muestra:

[{'box': [277, 90, 48, 63], 'emotions': {
  'angry': 0.02, 'disgust': 0.0, 'fear': 0.05,
  'happy': 0.16, 'neutral': 0.09, 'sad': 0.27, 'surprise': 0.41}]

¿Qué está pasando debajo del capó?

El `detector` es la parte principal de nuestro código. Veamos qué hace el detector:

Un detector es un objeto creado para almacenar ` FER() `. Detector devuelve un diccionario ordenado de notaciones de cuadro delimitador. Observa y detecta dónde se encuentra la cara y la clasifica en valores decimales de `0` a `1` con una probabilidad de las 6 emociones respectivamente. FER exhibe el modelo Keras construido con CNN o bien conocido como Redes Neuronales Convolucionales. Almacena los valores en el modelo `HDF5`. FER por defecto detecta rostros utilizando Haar Cascade Classifier de OpenCV. Alternativamente, podemos usar una red convolucional de múltiples cascadas más avanzada en abreviatura `MTCNN`. Utilizará la API de Peltarion en el backend en lugar del modelo Keras. Por defecto, FER usa CNN, pero si queremos usar MTCNN avanzado, simplemente pase ` mtcnn=True` entre paréntesis de FER como ` detector = FER(mtcnn=True)`. Para un uso posterior, utilizaremos el modelo MTCNN para obtener resultados más precisos.

Datos:

Los datos son conocidos como el nuevo petróleo del siglo XXI. Podemos hacer diferentes cosas con los datos generados anteriormente, que discutiremos en la ‘Sección de piratería’ por fin, así que estad atentos. Almacenaremos la emoción y el rostro detectado. A continuación, muestre un cuadro amarillo delimitador alrededor de la cara detectada y las puntuaciones debajo. Veamos a continuación cómo podemos hacer esto. 

import cv2
from fer import FER
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
input_image = cv2.imread("smile.jpg")
emotion_detector = FER(mtcnn=True)

Hasta ahora hemos llegado hasta aquí.

A continuación, declararemos la nueva variable `resultado` y almacenaremos nuestra salida en una array separada.

# Save output in result variable
result = emotion_detector.detect_emotions(input_image)

Ahora es el momento de resaltar el cuadro delimitador amarillo alrededor de la cara:

bounding_box = result[0]["box"]
emotions = result[0]["emotions"]
cv2.rectangle(input_image,(
  bounding_box[0], bounding_box[1]),(
  bounding_box[0] + bounding_box[2], bounding_box[1] + bounding_box[3]),
              (0, 155, 255), 2,)

Una explicación del código anterior es:

• La variable `bounding_box` almacenará las coordenadas del cuadro delimitador que se generaron y almacenaron en la variable `resultado`. Accederá y comenzará a almacenar desde sus elementos `0th` (o el primer elemento en lenguaje común) de la clave `”box”`. Si imprime esta variable, obtendrá un resultado como este `(298, 361, 825, 825)`.
• Lo mismo con la variable ‘emociones’, accederá al ‘resultado’ y comenzará a almacenar desde su elemento ‘0º’ de la tecla ‘emociones’. Si imprime, obtendrá una salida como `{‘enojado’: 0.08, ‘disgusto’: 0.03, ‘miedo’: 0.05, ‘feliz’: 0.09, ‘triste’: 0.35, ‘sorpresa’: 0.0, ‘neutral’ : 0.38}`
• El método `cv2.rectangle()` se usa para dibujar un rectángulo alrededor del rostro humano detectado. Tiene `imagen_de_entrada, punto_de_inicio, punto_de_finalización, color, grosor` como parámetros.
• En nuestro caso hemos usado `imagen` como parámetro de `imagen` para especificar la imagen que vamos a usar. `start_point` como `(bounding_box[0],bounding_box[1])` donde `bounding_box[0]` es la coordenada X y `bounding_box[1]` es la coordenada Y del punto de inicio.
• Siguiente `punto_final` como `(cuadro_delimitador[0] + cuadro_delimitador[2], cuadro_delimitador[1] + cuadro_delimitador[3])` donde `cuadro_delimitador[0] + cuadro_delimitador[2]` es la coordenada X y `cuadro_delimitador[1] + bounding_box[3]` es la coordenada Y del punto final.
• * `(0, 155, 255)` es el color amarillo que vamos a usar como color de caja.
• * `grosor` se da como `2`. Para definir el grosor de 2px a la caja.

Añadir puntuación al cuadro delimitador

Ahora agregaremos Score a Bounding Box usando el siguiente código:

emotion_name, score = emotion_detector.top_emotion(image )
for index, (emotion_name, score) in enumerate(emotions.items()):
   color = (211, 211,211) if score < 0.01 else (255, 0, 0)
   emotion_score = "{}: {}".format(emotion_name, "{:.2f}".format(score))
 
   cv2.putText(input_image,emotion_score,
               (bounding_box[0], bounding_box[1] + bounding_box[3] + 30 + index * 15),
               cv2.FONT_HERSHEY_SIMPLEX,0.5,color,1,cv2.LINE_AA,)
 
#Save the result in new image file
cv2.imwrite("emotion.jpg", input_image)

El código anterior dice:

• Almacene los principales valores de emoción en la variable `emotion_name,score` utilizando el método ` detector.top_emotion(img) `.
• Vamos a iterar sobre el índice y el valor de un elemento en una lista usando un bucle `for` básico y el método `enumerar`. Así que ahora se itera 1 emoción en un momento dado. Este proceso se lleva a cabo 6 veces ya que tenemos 6 emociones para probar. Puedes leer documentos.
• Los colores se asignan a la variable `color` en función de las puntuaciones. La abreviatura de la declaración IF & Else se usa para una mejor comprensión del código.
• * La variable `emotion_score` almacena la puntuación de la emoción y se utilizará para imprimirla.
• * El método `cv2.putText()` se usa para dibujar una string de texto en cualquier imagen.
• Fuera del ciclo for `cv2.imwrite()` el método creará y guardará una nueva imagen de salida final con el nombre `”emotion.jpg”`.

Mostrar imagen de salida

# Read image file using matplotlib's image module
result_image = mpimg.imread('emotion.jpg')
imgplot = plt.imshow(result_image)
# Display Output Image
plt.show()

Llegamos al paso final de nuestro artículo. Donde mostramos la imagen de salida usando el método de funciones de biblioteca matplotlib ` mpimg.imread (‘emotion.jpg’) ` lee la imagen proporcionada entre paréntesis. Almacene la imagen de la imagen en ` imgplot ` usando ` plt.imshow(img) `. Y finalmente ` plt.show() ` mostrará nuestra imagen de salida.

Imagen de salida

Nuestro reconocedor de expresiones faciales es solo el punto de partida para nuevos e innovadores sistemas FER. Ha llegado el momento en que puedes construir algo nuevo con lo que has aprendido hasta ahora. Estas son algunas de mis ideas que puedes probar:

1. Hemos construido FER para imágenes fijas. Puede probar FER para el análisis de video de las emociones faciales presentes en el video.
2. Crear un reconocedor de expresiones faciales en tiempo real usando una cámara en vivo será algo muy emocionante de probar.
3. Puede crear un sistema de recomendación diferente basado en la emoción de los humanos extrayendo y manipulando datos de la variable `resultado`. Como recomendar libros divertidos, videos, gifs, etc. a personas que tienen emociones tristes o libros de motivación, videos para personas con miedo o enojo.