Detectar emoções em vídeo parece um tema muito complexo e difícil, que deve envolver um código gigante. Mas, na verdade, com o auxílio da inteligência artificial e técnicas de deep learning, essa é uma tarefa simples. Neste post, faremos isso em poucas linhas de código com a biblioteca DeepFace. Obviamente, essa é uma biblioteca Python.
O que é DeepFace?
DeepFace é um sistema de reconhecimento facial de deep learning. Ele foi construído a partir de uma série de modelos famosos de deep learning específicos para tarefas de visão computacional. DeepFace identifica rostos humanos em imagens digitais, mas pode ser usado também em vídeos fazendo detecções frame por frame.
A estrutura do DeepFace consiste numa pipeline moderna de deep learning para reconhecimento facial. Ela realiza 5 tarefas: detecção, alinhamento, normalização, representação e verificação. Como o Deepface lida com todos esses estágios, não é necessário possuir conhecimento aprofundado sobre cada um deles para usá-lo. Cada função do DeepFace pode simplesmente ser chamada com uma única linha de código.
O sistema DeepFace pode ser usado para tarefas de verificação e reconhecimento facial, verificação de similaridades entre faces e também para a computação de atributos faciais. Essa última tarefa consegue verificar idade, gênero, raça e emoções. A detecção de emoções será nosso tópico neste post.
Bibliotecas
pip install deepface opencv-python
As instalações com conda podem ser feitas com os comandos:
conda install -c conda-forge deepface
conda install -c conda-forge opencv
Em seguida, crie um arquivo Python que pode se chamar emocoes.py e importe os pacotes que serão usados.
import os
import cv2
from deepface import DeepFace
Detecção de emoções faciais com deep learning
A detecção de emoções ocorre através do reconhecimento da expressão facial. A biblioteca DeepFace reconhece sete expressões: raiva (angry), medo (fear), neutra (neutral), triste (sad), nojo (disgust), feliz (happy) e surpresa (surprise). No nosso código Python, o primeiro passo para fazer essa detecção é selecionar o modelo que utilizaremos e incluir os rótulos para cada emoção. No seu código Python, copie os comandos:
model = DeepFace.build_model("Emotion")
emotion_labels = ['angry', 'disgust', 'fear', 'happy', 'sad', 'surprise', 'neutral']
Também utilizaremos o Haar Cascade de detecção facial para auxiliar na localização dos rostos. O link para obter seu arquivo xml é esse. O arquivo precisa estar na mesma pasta do seu código Python. Insira o comando abaixo no seu código.
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
O próximo passo é selecionar um vídeo para ser analisado como mostrado abaixo. Para o post, usaremos um vídeo do pexels. Você pode usar um vídeo qualquer ou usar a câmera para captar imagens em tempo real. Para usar um vídeo, não se esqueça de substituir path_para_seu_video pela localização correta do seu arquivo (linha 1). Para usar a câmera, delete as linhas 1 e 2 e descomente a linha 3.
path_name = 'path_para_seu_video'
cap = cv2.VideoCapture(path_name) # para usar um vídeo
#cap = cv2.VideoCapture(0) # para usar a câmera
DeepFace em vídeo
O modelo DeepFace para detectar emoções faciais é usado abaixo num while loop. O loop é necessário para analisar o vídeo frame por frame. Copie o trecho inteiro no seu código Python.
while True:
ret, frame = cap.read()
gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray_frame, scaleFactor=1.1, minNeighbors=7, minSize=(30, 30))
for (x, y, w, h) in faces:
face_roi = gray_frame[y:y + h, x:x + w]
resized_face = cv2.resize(face_roi, (48, 48), interpolation=cv2.INTER_AREA)
normalized_face = resized_face / 255.0
reshaped_face = normalized_face.reshape(1, 48, 48, 1)
preds = model.predict(reshaped_face)[0]
emotion_idx = preds.argmax()
emotion = emotion_labels[emotion_idx]
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
cv2.putText(frame, emotion, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
cv2.imshow('Real-time Emotion Detection', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
Esse trecho faz um monte de coisas que precisam ser entendidas. Na linha 2, um frame do vídeo é retornado para ser analisado. Ele é convertido para escala de cinzas (linha 3). Depois, na linha 4, o classificador Haar Cascade é aplicado para fazer a detecção de faces (clique aqui para saber mais). Quando uma face é encontrada, o classificador retorna uma tupla com suas coordenadas (x, y, w, h). Essas coordenadas são usadas para extrair a face e enviá-la para o DeepFace reconhecer sua emoção. Como é possível haver múltiplas faces num único frame, usamos um for loop para detectar a emoção em cada uma delas (linha 5).
DeepFace na prática
Dando sequência a explicação do trecho de código acima, nos concentraremos agora no uso do modelo de detecção de emoções do DeepFace em si. Para usá-lo, uma face detectada precisa ser transformada no formato correto. Portanto, na linha 6, o termo roi se refere a sigla region of interest (região de interesse). Essa linha define a área contendo uma face identificada. As coordenadas x, y, h e w são usadas para extrair a área completa contendo a face.
Em seguida, a face isolada é transformada no tamanho necessário para que ela seja usada no modelo de detecção de emoções (linha 7). A linha 8 apenas normaliza as intensidades dos píxeis da imagem. Na linha 9, a forma da imagem é convertida nas dimensões apropriadas para o modelo. Essas transformações são comuns em modelos de deep learning e redes neurais. Se você não tem familiaridade com os comandos usados, procure conhecer a biblioteca NumPy e leia um pouco sobre redes neurais e deep learning.
Na linha 10, o modelo é usado para identificar a emoção da face. Essa identificação retorna um vetor de probabilidades com sete valores, um para cada emoção. Por isso, na linha 11, usamos a função argmax para identificar o índice da probabilidade mais alta no vetor retornado. Depois, com esse valor, identificamos a qual emoção ele corresponde (linha 12). Na linha 13, desenhamos um retângulo na face localizada e depois escrevemos a emoção identificada (linha 14). A linha 15 exibe o frame do vídeo. As últimas linhas do trecho acima definem como interromper o vídeo (linhas 16 e 17) e também destroem as janelas após sua execução.
Testando alguns vídeos
Testamos dois vídeos obtidos no pexels. Eles são mostrados abaixo. Use o vídeo que quiser. Esse é o primeiro vídeo que testamos.
E esse é o segundo vídeo que usamos.
Um detalhe importante é que o classificador Haar Cascade que usamos para encontrar as faces nos vídeos faz detecção apenas de faces em posição frontal. Por isso, ele falha quando a pessoa vira de lado, por exemplo. Optamos por usá-lo por ele ser rápido, mas existem outros classificadores mais precisos como o MTCNN.
Para concluir
Neste post, mostramos como fazer detecção de emoções em vídeo usando a biblioteca DeepFace e OpenCV. O código é pequeno e não é super difícil, mas seus comandos podem ser complexos para iniciantes. Portanto, para quem tem interesse, estude a área e tente desenvolver pequenos projetos por conta própria. Como mencionamos no início do post, a biblioteca DeepFace tem várias outras funcionalidades como reconhecimento facial, de idade e gênero. Esses temas podem ser sugestões interessantes de pequenos projetos para quem quer treinar seus conhecimentos na área.
