Proiect de detectare a feței în Python [în 5 pași simpli]

Identificarea obiectelor și detectarea feței sunt probabil cele mai populare aplicații ale vederii computerizate. Această tehnologie își găsește aplicații în diverse industrii, cum ar fi securitatea și rețelele sociale. Deci construim un proiect de detectare a feței prin Python.

Rețineți că ar trebui să fiți familiarizați cu programarea în Python, OpenCV și NumPy. Acesta vă va asigura că nu vă confundați în timp ce lucrați la acest proiect. Să începem.

Am împărtășit două metode pentru a efectua recunoașterea feței. Primul folosește biblioteca de recunoaștere a feței a lui Python, în timp ce celălalt folosește OpenCV și NumPy. Consultați programele noastre de știință a datelor pentru a afla mai multe.

Recunoașterea feței cu „Recunoașterea feței” de la Python

Probabil cea mai ușoară metodă de a detecta fețele este utilizarea bibliotecii de recunoaștere a feței din Python . A avut o precizie de 99,38% în baza de date LFW. Utilizarea este destul de simplă și nu necesită mult efort. Mai mult, biblioteca are o comandă dedicată „face_recognition” pentru identificarea fețelor din imagini.

Cum să utilizați recunoașterea feței

Puteți distinge fețele din imagini folosind comanda „face_locations”:

import face_recognition

imagine = face_recognition.load_image_file(„fișierul_dvs..jpg”)

face_locations = face_recognition.face_locations(imagine)

De asemenea, poate recunoaște fețe și le poate asocia cu numele lor:

import face_recognition

imagine_cunoscută = face_recognition.load_image_file(„modi.jpg”)

imagine_necunoscută = face_recognition.load_image_file(„unknown.jpg”)

modi_encoding = face_recognition.face_encodings(imagine_cunoscută)[0]

codificare_necunoscută = recunoaștere_față.codări_face(imagine_necunoscută)[0]

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

Imaginea conține „Narendra Modi”

Există multe alte lucruri pe care le puteți realiza cu această bibliotecă combinând-o cu altele. Vom discuta acum despre realizarea recunoașterii faciale cu alte biblioteci proeminente în Python, în special OpenCV și NumPy.

Citiți mai multe: Tutorial Python NumPy: Învățați Python Numpy cu exemple

Proiect de detectare a feței în Python

În acest proiect, am realizat detectarea și recunoașterea feței utilizând OpenCV și NumPy. Am folosit Raspberry Pi, dar îl puteți folosi și cu alte sisteme. Va trebui doar să modificați ușor codul pentru a-l utiliza pe alt dispozitiv (cum ar fi un Mac sau un PC cu Windows).

Un credit pentru acest proiect îi revine lui Marcelo Rovai .

Pasul #1: Instalați biblioteci

În primul rând, ar trebui să instalați bibliotecile necesare, OpenCV și NumPy. Îl puteți instala cu ușurință prin:

pip install opencv-python

pip install opencv-contrib-python

Pentru a instala NumPy în sistemul dvs., utilizați aceeași comandă ca mai sus și înlocuiți „opencv-python” cu „numpy”:

pip install numpy

Pasul 2: Detectează fețele

Acum, trebuie să vă configurați camera și să o conectați la sistemul dumneavoastră. Camera ar trebui să funcționeze corect pentru a evita orice probleme la detectarea feței.

Înainte ca camera noastră să ne recunoască, trebuie mai întâi să detecteze fețele. Vom folosi clasificatorul Haar Cascade pentru detectarea feței. Este în primul rând o metodă de detectare a obiectelor în care antrenați o funcție în cascadă prin imagini negative și pozitive, după care devine capabil să detecteze obiecte din alte fotografii.

În cazul nostru, dorim ca modelul nostru să detecteze fețe. OpenCV vine cu un antrenor și un detector, astfel încât utilizarea clasificatorului Haar Cascade este relativ mai confortabilă cu această bibliotecă. Vă puteți crea clasificatorul pentru a detecta și alte imagini.

Iată codul:

import numpy ca np

import cv2

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

cap = cv2.VideoCapture(0)

cap.set(3.640) # set Lățimea

cap.set(4.480) # set Înălțime

în timp ce este adevărat:

ret, img = cap.read()

img = cv2.flip(img, -1)

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

fețe = faceCascade.detectMultiScale(

gri,

scaleFactor=1,2,

minVecini=5,

minSize=(20, 20)

)

pentru (x,y,w,h) în fețe:

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

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

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

cv2.imshow('videoclip',img)

k = cv2.waitKey(30) & 0xff

dacă k == 27: # apăsați „ESC” pentru a ieși

pauză

cap.release()

cv2.destroyAllWindows()

Pasul #3: Adunați date

Acum că modelul tău poate identifica fețele, îl poți antrena astfel încât să înceapă să recunoască a cui față este în imagine. Pentru a face acest lucru, trebuie să îi oferiți mai multe fotografii ale fețelor pe care doriți să le amintească.

De aceea, vom începe cu crearea setului nostru de date prin adunarea fotografiilor. După colectarea imaginilor necesare, adăugați ID-uri pentru fiecare persoană, astfel încât modelul să știe ce chip să asocieze cu ce ID. Începeți cu imaginile unei persoane și adăugați cel puțin 10-20. Utilizați diferite expresii pentru a obține cele mai eficiente rezultate.

Creați un script pentru adăugarea de ID-uri de utilizator la imagini, astfel încât să nu fie nevoie să o faceți manual de fiecare dată. Scriptul este vital în cazul în care doriți să utilizați modelul pentru mai multe fețe.

Învață cursuri de învățare automată de la cele mai bune universități din lume. Câștigă programe de master, Executive PGP sau Advanced Certificate pentru a-ți accelera cariera.

Pasul #4: Antrenează-te

După crearea setului de date al imaginilor persoanei, va trebui să antrenați modelul. Veți alimenta imaginile către dispozitivul de recunoaștere OpenCV, iar acesta va crea un fișier numit „trainer.yml” la final.

În această etapă, trebuie doar să furnizați modelului imagini și ID-urile acestora, astfel încât modelul să se familiarizeze cu ID-ul fiecărei imagini. După ce terminăm antrenarea modelului, îl putem testa.

Iată codul:

import cv2

import numpy ca np

din imaginea de import PIL

import os

# Calea pentru baza de date a imaginilor feței

cale = 'set de date'

recunoaștere = cv2.face.LBPHFaceRecognizer_create()

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

# pentru a obține imaginile și datele de etichetare

def getImagesAndLabels(cale):

imagePaths = [os.path.join(cale,f) pentru f în os.listdir(cale)]

faceSamples=[]

id-uri = []

pentru imagePath în imagePaths:

PIL_img = Image.open(imagePath).convert('L') # scala de gri

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

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

fețe = detector.detectMultiScale(img_numpy)

pentru (x,y,w,h) în fețe:

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

ids.append(id)

return faceSamples,ids

tipăriți ("\n [INFO] Fețe de antrenament. Va dura câteva secunde. Așteptați...")

chips,ids = getImagesAndLabels(cale)

reconocer.train(fețe, np.array(ids))

# Salvați modelul în trainer/trainer.yml

reconocer.write('trainer/trainer.yml')

# Tipăriți numărul de fețe antrenate și terminați programul

print(„\n [INFO] {0} fețe antrenate. Se iese din program”.format(len(np.unique(ids))))

Aflați: Aplicația MATLAB în recunoașterea feței: cod, descriere și sintaxă

Pasul #5: Începeți recunoașterea

Acum că ați antrenat modelul, putem începe să testăm modelul. În această secțiune, am adăugat nume la ID-uri, astfel încât modelul să poată afișa numele utilizatorilor respectivi pe care îi recunoaște.

Modelul nu recunoaște o persoană. Acesta prezice dacă fața pe care o detectează se potrivește cu fața prezentă în baza de date. Modelul nostru afișează un procent din cât de mult se potrivește fața cu fața prezentă în baza sa de date. Precizia sa va depinde în mare măsură de imaginea pe care o testați și de imaginile pe care le-ați adăugat în baza de date (imaginile cu care ați antrenat modelul).

Iată codul:

import cv2

import numpy ca np

import os

recunoaștere = cv2.face.LBPHFaceRecognizer_create()

reconocer.read('trainer/trainer.yml')

cascadePath = „haarcascade_frontalface_default.xml”

faceCascade = cv2.CascadeClassifier(cascadePath);

font = cv2.FONT_HERSHEY_SIMPLEX

#inițiați contorul de ID

id = 0

# nume legate de id-uri: exemplu ==> upGrad: id=1 etc

nume = ['Niciuna', UpGrad', Eu', 'Prieten', 'Y', 'X']

# Inițializați și începeți captura video în timp real

cam = cv2.VideoCapture(0)

cam.set(3, 640) # setați lățimea videoclipului

cam.set(4, 480) # setați înălțimea videoclipului

# Definiți dimensiunea minimă a ferestrei pentru a fi recunoscută ca față

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

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

în timp ce este adevărat:

ret, img =cam.read()

img = cv2.flip(img, -1) # Întoarce vertical

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

fețe = faceCascade.detectMultiScale(

gri,

scaleFactor = 1,2,

minVecini = 5,

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

)

pentru(x,y,w,h) în fețe:

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

id, încredere = recognitor.predict(gri[y:y+h,x:x+w])

# Dacă încrederea este mai mică de 100 ==> „0”: potrivire perfectă

dacă (încrederea < 100):

id = nume[id]

încredere = ” {0}%”.format(round(100 – încredere))

altceva:

id = „necunoscut”

încredere = ” {0}%”.format(round(100 – încredere))

cv2.putText(

img,

str(id),

(x+5,y-5),

font,

1,

(255.255.255),

2

)

cv2.putText(

img,

str (încredere),

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

font,

1,

(255,255,0),

1

)

cv2.imshow('camera',img)

k = cv2.waitKey(10) & 0xff # Apăsați „ESC” pentru a ieși din videoclip

dacă k == 27:

pauză

# Faceți o curățare

print(„\n [INFO] Ieșire din program și curățare”)

cam.release()

cv2.destroyAllWindows()

Am ajuns la finalul proiectului nostru de detectare a feței în Python. Acum știți cum să creați un model de învățare automată care detectează și recunoaște fețele. Asigurați-vă că ne împărtășiți rezultatele!

Aflați: Tutorial de detectare a obiectelor TensorFlow pentru începători

Aflați mai multe despre învățarea automată

Sperăm că ți-a plăcut acest proiect de detectare a feței. Dacă doriți să o faceți mai provocatoare, puteți adăuga mai multe fețe în setul de date și puteți antrena modelul în consecință. De asemenea, îl puteți combina cu alte biblioteci și extinde proiectul în altceva, cum ar fi un sistem de securitate de detectare a feței pentru un program!

Dacă sunteți interesat să aflați mai multe despre învățarea automată, consultați Programul Executive PG de la IIIT-B și upGrad în Învățare automată și IA, care este conceput pentru profesioniști care lucrează și oferă peste 450 de ore de pregătire riguroasă, peste 30 de studii de caz și sarcini, IIIT -B Statut de absolvenți, peste 5 proiecte practice practice și asistență pentru locuri de muncă cu firme de top.