Projeto de detecção de rosto em Python [em 5 etapas fáceis]

A identificação de objetos e a detecção de rostos são provavelmente as aplicações mais populares da visão computacional. Essa tecnologia encontra aplicações em diversos setores, como segurança e mídia social. Então, estamos construindo um projeto de detecção de rosto por meio do Python.

Observe que você deve estar familiarizado com programação em Python, OpenCV e NumPy. Isso garantirá que você não fique confuso enquanto trabalha neste projeto. Vamos começar.

Compartilhamos dois métodos para realizar o reconhecimento facial. O primeiro usa a biblioteca de reconhecimento facial do Python, enquanto o outro usa OpenCV e NumPy. Confira nossos programas de ciência de dados para saber mais.

Reconhecimento de rosto com o 'Reconhecimento de rosto' do Python

Provavelmente, o método mais fácil de detectar rostos é usar a biblioteca de reconhecimento de rosto em Python . Teve 99,38% de precisão no banco de dados LFW. Usá-lo é bastante simples e não requer muito esforço. Além disso, a biblioteca possui um comando 'face_recognition' dedicado para identificar rostos em imagens.

Como usar o reconhecimento facial

Você pode distinguir rostos em imagens usando o comando 'face_locations':

importar reconhecimento facial

imagem = face_recognition.load_image_file(“your_file.jpg”)

face_locations = face_recognition.face_locations(imagem)

Também pode reconhecer rostos e associá-los aos seus nomes:

importar reconhecimento facial

known_image = face_recognition.load_image_file(“modi.jpg”)

desconhecido_image = face_recognition.load_image_file(“desconhecido.jpg”)

modi_encoding = face_recognition.face_encodings(known_image)[0]

unknown_encoding = face_recognition.face_encodings(unknown_image)[0]

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

A imagem contém “Narendra Modi”

Há muitas outras coisas que você pode realizar com esta biblioteca combinando-a com outras. Agora discutiremos a execução do reconhecimento facial com outras bibliotecas proeminentes em Python, particularmente OpenCV e NumPy.

Leia mais: Tutorial Python NumPy: Aprenda Python Numpy com exemplos

Projeto de detecção de rosto em Python

Neste projeto, realizamos detecção e reconhecimento de rosto usando OpenCV e NumPy. Usamos o Raspberry Pi, mas você também pode usá-lo com outros sistemas. Você só terá que modificar um pouco o código para usá-lo em algum outro dispositivo (como um Mac ou um PC com Windows).

Algum crédito por este projeto vai para Marcelo Rovai .

Etapa 1: instalar bibliotecas

Primeiro, você deve instalar as bibliotecas necessárias, OpenCV e NumPy. Você pode instalá-lo facilmente através de:

pip instalar opencv-python

pip instalar opencv-contrib-python

Para instalar o NumPy em seu sistema, use o mesmo comando acima e substitua 'opencv-python' por 'numpy':

pip instalar numpy

Etapa 2: detectar rostos

Agora, você deve configurar sua câmera e conectá-la ao seu sistema. A câmera deve funcionar corretamente para evitar problemas na detecção de rosto.

Antes que nossa câmera nos reconheça, primeiro ela precisa detectar rostos. Usaremos o classificador Haar Cascade para detecção de rosto. É principalmente um método de detecção de objetos onde você treina uma função de cascata através de imagens negativas e positivas, após o que se torna capaz de detectar objetos em outras fotos.

No nosso caso, queremos que nosso modelo detecte rostos. O OpenCV vem com um treinador e um detector, portanto, usar o classificador Haar Cascade é relativamente mais confortável com esta biblioteca. Você pode criar seu classificador para detectar outras imagens também.

Aqui está o código:

importar numpy como np

importar cv2

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

cap = cv2.VideoCapture(0)

cap.set(3.640) # define a largura

cap.set(4.480) # define Altura

enquanto Verdadeiro:

ret, img = cap.read()

img = cv2.flip(img, -1)

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

faces = faceCascade.detectMultiScale(

cinza,

fator de escala=1,2,

minVizinhos=5,

minTamanho=(20, 20)

)

para (x,y,w,h) em faces:

cv2.retângulo(img,(x,y),(x+w,y+h),(255,0,0),2)

roi_gray = cinza[y:y+h, x:x+w]

roi_color = img[y:y+h, x:x+w]

cv2.imshow('vídeo',img)

k = cv2.waitKey(30) & 0xff

if k == 27: # pressione 'ESC' para sair

pausa

cap.release()

cv2.destroyAllWindows()

Etapa 3: coletar dados

Agora que seu modelo pode identificar rostos, você pode treiná-lo para que ele comece a reconhecer qual rosto está na foto. Para fazer isso, você deve fornecer várias fotos dos rostos que deseja lembrar.

É por isso que começaremos a criar nosso conjunto de dados reunindo fotos. Depois de coletar as imagens necessárias, adicione IDs para cada pessoa, para que o modelo saiba qual rosto associar a qual ID. Comece com as imagens de uma pessoa e adicione pelo menos 10-20. Use expressões diferentes para obter os resultados mais eficazes.

Crie um script para adicionar IDs de usuário a imagens, para que você não precise fazer isso manualmente todas as vezes. O script é vital caso você queira usar seu modelo para várias faces.

Aprenda os cursos de aprendizado de máquina das melhores universidades do mundo. Ganhe Masters, Executive PGP ou Advanced Certificate Programs para acelerar sua carreira.

Etapa 4: Treinar

Depois de criar o conjunto de dados das imagens da pessoa, você teria que treinar o modelo. Você alimentaria as imagens no seu reconhecedor OpenCV e ele criaria um arquivo chamado 'trainer.yml' no final.

Neste estágio, você só precisa fornecer ao modelo as imagens e seus IDs para que o modelo possa se familiarizar com o ID de cada imagem. Após terminarmos de treinar o modelo, podemos testá-lo.

Aqui está o código:

importar cv2

importar numpy como np

da imagem de importação PIL

importar SO

# Caminho para banco de dados de imagens de rosto

caminho = 'conjunto de dados'

reconhecedor = cv2.face.LBHFaceRecognizer_create()

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

# função para obter as imagens e os dados do rótulo

def getImagesAndLabels(caminho):

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

faceSamples=[]

id = []

para imagePath em imagePaths:

PIL_img = Image.open(imagePath).convert('L') # tons de cinza

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

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

faces = detector.detectMultiScale(img_numpy)

para (x,y,w,h) em faces:

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

ids.append(id)

return faceSamples,ids

print ("\n [INFO] Rostos de treinamento. Levará alguns segundos. Aguarde ...")

faces,ids = getImagesAndLabels(caminho)

reconhecer.train(faces, np.array(ids))

# Salve o modelo em trainer/trainer.yml

reconhecer.write('treinador/treinador.yml')

# Imprime o número de faces treinadas e finaliza o programa

print(“\n [INFO] {0} rostos treinados. Saindo do programa”.format(len(np.unique(ids)))))

Aprenda: Aplicação MATLAB em Reconhecimento Facial: Código, Descrição e Sintaxe

Etapa 5: iniciar o reconhecimento

Agora que você treinou o modelo, podemos começar a testá-lo. Nesta seção, adicionamos nomes aos IDs para que o modelo possa exibir os nomes dos respectivos usuários que reconhece.

O modelo não reconhece uma pessoa. Ele prevê se o rosto detectado corresponde ao rosto presente em seu banco de dados. Nosso modelo exibe uma porcentagem de quanto o rosto corresponde ao rosto presente em seu banco de dados. Sua precisão dependerá muito da imagem que você está testando e das imagens que você adicionou ao seu banco de dados (as imagens com as quais você treinou o modelo).

Aqui está o código:

importar cv2

importar numpy como np

importar SO

reconhecedor = cv2.face.LBHFaceRecognizer_create()

reconhecer.read('treinador/treinador.yml')

cascadePath = “haarcascade_frontalface_default.xml”

faceCascade = cv2.CascadeClassifier(cascadePath);

fonte = cv2.FONT_HERSHEY_SIMPLEX

#initiate contador de id

código = 0

# nomes relacionados a ids: exemplo ==> upGrad: id=1, etc

nomes = ['Nenhum', upGrad', Me', 'Amigo', 'Y', 'X']

# Inicialize e inicie a captura de vídeo em tempo real

cam = cv2.VideoCapture(0)

cam.set(3, 640) # define a largura do vídeo

cam.set(4, 480) # define a altura do vídeo

# Defina o tamanho mínimo da janela para ser reconhecido como um rosto

minW = 0,1*cam.get(3)

minH = 0,1*cam.get(4)

enquanto Verdadeiro:

ret, img =cam.read()

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

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

faces = faceCascade.detectMultiScale(

cinza,

fator de escala = 1,2,

minVizinhos = 5,

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

)

for(x,y,w,h) em faces:

cv2.retângulo(img, (x,y), (x+w,y+h), (0,255,0), 2)

id, confiança = reconhecedor.predict(cinza[y:y+h,x:x+w])

# Se a confiança for menor que 100 ==> “0” : correspondência perfeita

se (confiança < 100):

id = nomes[id]

confiança = ” {0}%”.format(round(100 – confiança))

outro:

id = “desconhecido”

confiança = ” {0}%”.format(round(100 – confiança))

cv2.putText(

img,

str(id),

(x+5,y-5),

Fonte,

1,

(255.255.255),

2

)

cv2.putText(

img,

str(confiança),

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

Fonte,

1,

(255.255,0),

1

)

cv2.imshow('câmera',img)

k = cv2.waitKey(10) & 0xff # Pressione 'ESC' para sair do vídeo

se k == 27:

pausa

#Faça uma limpeza

print(“\n [INFO] Saindo do programa e fazendo limpeza”)

cam.release()

cv2.destroyAllWindows()

Chegamos ao fim do nosso projeto de detecção de rosto em Python. Agora você sabe como criar um modelo de aprendizado de máquina que detecta e reconhece rostos. Não deixe de compartilhar seus resultados conosco!

Aprenda: Tutorial de detecção de objetos do TensorFlow para iniciantes

Saiba mais sobre aprendizado de máquina

Esperamos que você tenha gostado deste projeto de detecção de rosto. Se quiser torná-lo mais desafiador, você pode adicionar várias faces em seu conjunto de dados e treinar seu modelo de acordo. Você também pode combiná-lo com outras bibliotecas e estender o projeto para outra coisa, como um sistema de segurança de detecção de rosto para um programa!

Se você estiver interessado em aprender mais sobre aprendizado de máquina, confira o Programa PG Executivo do IIIT-B e do upGrad em Machine Learning e IA, projetado para profissionais que trabalham e oferece mais de 450 horas de treinamento rigoroso, mais de 30 estudos de caso e atribuições, IIIT -B Alumni status, mais de 5 projetos práticos práticos e assistência de trabalho com as principais empresas.