Ansigtsgenkendelse med OpenCV

Maskins kompleksitet er steget gennem årene, og computere er ikke en undtagelse. Computere har hjulpet menneskeheden med at løse mange problemer og gennemføre mange vanskelige opgaver. Borte er de dage, hvor alle computere gjorde var enkle aritmetiske operationer, computere kører nu verden.

Computere er blevet så komplekse, at de bliver uddannet til at tænke som mennesker.
Ja!

Vi vil gøre noget af den art i denne artikel. At genkende andre menneskers ansigter er som mennesker en simpel opgave, og på trods af dagens computers computere er det ikke så let for computeren, så vi er nødt til at træne den for at kunne gøre det samme.

Mange artikler, du ville se derude, stopper ved simpel ansigtsgenkendelse, men i denne artikel dækker det ikke kun ansigtsgenkendelse, men også ansigtsgenkendelse.

Dette betyder, at hvis computeren præsenteres for to billeder af mig, ville den ikke kun genkende, hvilken del af billedet der er mit ansigt, det ville også anerkende, at jeg også er den i begge billeder.

Til at begynde med skal vi først installere opencv på vores maskiner, hvilket kun kan gøres, hvis du har Python installeret. Installationen af ​​Python er ikke formålet med denne artikel, så hvis du ikke allerede har det på din maskine, kan du installere Python fra Python-webstedet.

For at installere Open CV kan vi gøre det ved hjælp af pip-kommandoen.

pip installer opencv-python

Vi bruger også den numpy pakke i denne artikel, som skal installeres sammen med OpenCV ved hjælp af ovenstående kommando.

Hvis numpy ikke blev installeret, kan du nemt gøre det ved hjælp af kommandoen nedenfor:

pip install numpy

For at bekræfte, at din OpenCV er installeret, skal du importere den ved hjælp af: når du aktiverer Pythons interaktive miljø:

importer cv2

Hvis du ikke får en fejl, kan du fortsætte.

For at udføre ansigtsgenkendelse ville vi skrive tre manuskripter. Én til at oprette et datasæt med billeder, en anden til at træne disse billeder og derefter den sidste til at genkende ansigterne baseret på resultaterne af den træning, computeren gennemgår.

Vi har brug for Haar Cascade leveret af Open CV. Denne fil kan hentes fra opencv-biblioteket, som er cv2 / data / haarcascade_frontalface_default.xml på min maskine, det skal også være det samme på din maskine. Kopier filen til den mappe, hvor du ønsker at gøre ansigtsgenkendelsen.

Lad os nu komme ind i det tykke af ting.
Vi ville forsøge at få vores webkamera til at få de billeder, der er nødvendige for datasættet.

importer cv2
vid_cam = cv2.VideoCapture (0)
face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
tælle = 0
mens (vid_cam.isOpened ()):
ret, image_frame = vid_cam.Læs()
grå = cv2.cvtColor (billedramme, cv2.COLOR_BGR2GRAY)
ansigter = ansigtsdetektor.detectMultiScale (grå, 1.3, 5)
for (x, y, w, h) i ansigter:
cv2.rektangel (billedramme, (x, y), (x + w, y + h), (255,0,0), 2)
tælle + = 1
cv2.imwrite ("datasæt / bruger."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w])
cv2.imshow ('frame', image_frame)
hvis cv2.waitKey (100) & 0xFF == ord ('q'):
pause
elif count> 100:
pause
vid_cam.frigøre()
cv2.destroyAllWindows ()

Så for at forklare, hvad hver linje kode gør:

importer cv2

Her er kommandoen, der beder python om at inkludere et eksternt bibliotek, der skal bruges i denne kode, i dette tilfælde er det Open CV.

vid_cam = cv2.VideoCapture (0)

Denne kode opfordrer det importerede Open CV-bibliotek til at begynde at optage, og webcam startes på dette tidspunkt. Hvis Open CV ikke understøtter dit webcam, mislykkes koden her.

face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')

For at vi kan udføre billeddetektering, er denne kode nødvendig. Åben CV bruger 'haarcascade_frontalface_default.xml 'til Cascade-klassificering. Det resulterende objekt gemmes derefter i face_detector-variablen.

face_id = 1

Her er et tilfælde af indstilling af ansigtets id-nummer, så det første ansigt får en id på 1.

tælle = 0

Vi skal tage et par billeder, da Open CV skal træne billeder for at kunne genkende ansigter, tællervariablen fungerer som et billedtælling.

mens (vid_cam.isOpened ()):

Dette gør det muligt for følgende operationer at gå, forudsat at videokameraet åbnes. Metoden isOpened () returnerer sand eller falsk.

ret, image_frame = vid_cam.Læs()

Her vid_cam.read () ser på videooptagelsen og fanger derefter den ramme, der er gemt i image_frame-variablen, hvis operationen er vellykket returneres den boolske True og lagres i ret-variablen

grå = cv2.cvtColor (billedramme, cv2.COLOR_BGR2GRAY)

Metoden cvtColor () bruges til at konvertere billedrammen til den ønskede farvetype. I dette tilfælde har vi konverteret det til gråtoner.

ansigter = ansigtsdetektor.detectMultiScale (grå, 1.3, 5)

Dette kontrollerer for rammer i forskellige størrelser og forsøger at indstille dem til skalering, dette anvendes på den variabel, som Haar Cascade blev anvendt på.

for (x, y, w, h) i ansigter:

Her løber vi gennem ansigterne og dens dimensioner, hvor x og y står for koordinaterne og w og h står for henholdsvis bredde og højde.

cv2.rektangel (billedramme, (x, y), (x + w, y + h), (255,0,0), 2)

Husk at vi stadig arbejder med videokameraet, så beskærer videokameraet den nødvendige del af billedet i henhold til dimensionerne ovenfor.

tælle + = 1

Straks det er gjort, tælles variablen for tælling, der står som en tæller, derefter.

cv2.imwrite ("datasæt / bruger."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w])

Det beskårne billede gemmes med navnet User (face_id).(tælle).jpg og sættes i en mappe kaldet datasæt.

cv2.imshow ('frame', image_frame)

Efter gemning sikrer denne kode, at billedet er, at videorammen vises med et rektangel på individets ansigt, efter ansigtsgenkendelse er udført.

hvis cv2.waitKey (100) & 0xFF == ord ('q'):
pause

Efter hvert billede får brugeren lov til at stoppe programmet med at tage flere billeder, hvilket kan gøres ved at trykke på 'q' på tastaturet i mindst 100 ms.

elif count> 100:
pause

Hvad denne kode gør, er at stoppe videoen i at virke, i det øjeblik 100 billeder er taget, uanset om brugeren vil tage mere eller ej.

vid_cam.frigøre()

Her er webkameraet lukket og ikke kun stoppet fra at tage billeder.

cv2.destroyAllWindows ()

Derefter er alle vinduer, som OpenCV har åbnet, blevet ødelagt, og koden kører til konklusion.

Nu hvor vi er færdige med det, kan vi træne billeddatasættet:

importer cv2, os
importer numpy som np
fra PIL-importbillede
genkender = cv2.ansigt.createLBPHFaceRecognizer ()
detektor = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");
def getImagesAndLabels (sti):
imagePaths = [os.sti.join (sti, f) for f i os.listdir (sti)]
faceSamples = []
id'er [[]
til imagePath i imagePaths:
PIL_img = Billede.åben (imagePath).konvertere ('L')
img_numpy = np.matrix (PIL_img, 'uint8')
id = int (os.sti.split (imagePath) [- 1].dele(".") [1])
ansigter = detektor.detectMultiScale (img_numpy)
for (x, y, w, h) i ansigter:
ansigt Prøver.tilføj (img_numpy [y: y + h, x: x + w])
id'er.tilføje (id)
retur ansigt Prøver, id'er
ansigter, ids = getImagesAndLabels ('datasæt')
genkender.tog (ansigter, np.matrix (id'er))
genkender.gem ('træner / træner.yml ')

Lad os gå videre og forklare denne kode også:

importer cv2, os

Ligesom den anden kode importerer vi her OpenCV og os, som vi har brug for til filstien.

importer numpy som np

Vi importerer også det følelsesløse bibliotek, som ville blive brugt til matrixberegning (en matrix er bare et arrangement af arrays).

fra PIL-importbillede

Vi importerer Python-billedbiblioteket, og derefter får vi også billedbiblioteket fra denne pakke.

genkender = cv2.ansigt.createLBPHFaceRecognizer ()

Hvad dette gør er at anvende metoden createLBPHFaceRecognizer () til cv2.ansigt objekt, dette ville hjælpe med at gøre det let at genkende ansigter, da vi ikke behøver at komme med vores eget sæt algoritmer.

detektor = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");

Hvis du har fulgt vejledningen, ville du være stødt på dette før. Det hjælper med ansigtsgenkendelse ved hjælp af “haarcascade_frontalface_default.xml ”til Cascade Classification.

def getImagesAndLabels (sti):

Nu er vi ved at begynde billedtræningen korrekt, så vi opretter en funktion.

imagePaths = [os.sti.join (sti, f) for f i os.listdir (sti)]

Denne kode tjekker ind i den aktuelle mappe for filen og kontrollerer for billedfilerne og tilføjer dem derefter til denne liste.

faceSamples = []

Dette initialiserer en liste over prøver, den er tom på dette tidspunkt, men ansigter tilføjes, når koden kører.

id'er [[]

Initialiser en liste over id'er, der oprindeligt er tomme.

til imagePath i imagePaths:

Husk koden, der kontrollerede billedfilerne i biblioteket? Ja? Nu skal vi gennemgå hver af disse filer og udføre operationer på dem.

PIL_img = Billede.åben (imagePath).konvertere ('L')

Nu er det første, vi gør med billedet, at konvertere det til gråtoner, og denne kode gør det.

img_numpy = np.matrix (PIL_img, 'uint8')

Det gråtonede billede er bare en række numre alt på ét sted, så vi opretter et dumt array ud af dem og tildeler det til en variabel.

id = int (os.sti.split (imagePath) [- 1].dele(".") [1])

Hvis du husker den fil, der får billederne, vil du huske, at vi navngav filerne Bruger (face_id).tælle.jpg. Så her deler vi navnene med ".”Og derefter trækker vi face_id ud og tildeler en variabel her. Vi har brug for id'et til anerkendelse.

ansigter = detektor.detectMultiScale (img_numpy)

Fra det bedøvede array vil metoden detectMultiScale () forsøge at opdage ansigterne fra det mønster, den finder i den numpy array. Derefter tildeles værdierne i ansigtsvariablen.

for (x, y, w, h) i ansigter:

Her løber vi gennem de værdier, der er tildelt variablen. Værdierne her er x- og y-koordinaterne, som vi kunne tage som oprindelse, og derefter står w og h for henholdsvis bredde og højde.

ansigt Prøver.tilføj (img_numpy [y: y + h, x: x + w])

Tidligere oprettede vi en liste over ansigtseksempler, men den var tom. Her får vi tilføjet ansigter til denne liste, og vi tilføjer y til h for at få de to værdier af y-koordinaterne, og det samme gøres til x.

id'er.tilføje (id)

Vi har nu et ansigt i listen over ansigtseksempler, så vi får dets id og tilføjer det også til ids-listen.

retur ansigt Prøver, id'er

Derefter returnerer vi listen over ansigtseksempler og listen over id'er.

ansigter, ids = getImagesAndLabels ('datasæt')

Husk, at getImagesAndLabels () kun er en funktion. Så vi får kaldt funktionen her, og returværdierne gemmes i ansigts- og id-variablerne.

genkender.tog (ansigter, np.matrix (id'er))

Her er hvor den rigtige træning sker. Vi anvendte metoden createLBPHFaceRecognizer () engang tidligere og tildelte en genkendelsesvariabel. Det er træningstid!

genkender.gem ('træner / træner.yml ')

Efter træning gemmer vi resultaterne fra træningen.
Efter kørsel af koden opretter den en fil kaldet træner.yml, som derefter ville blive brugt af ansigtsgenkendelseskoden.

Her er koden til ansigtsgenkendelse:

importer cv2
importer numpy som np
genkender = cv2.ansigt.createLBPHFaceRecognizer ()
genkender.load ('træner / træner.yml ')
cascadePath = "haarcascade_frontalface_default.xml "
faceCascade = cv2.CascadeClassifier (cascadePath)
skrifttype = cv2.FONT_HERSHEY_SIMPLEX
cam = cv2.VideoCapture (0)
mens det er sandt:
ret, im = cam.Læs()
grå = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
ansigter = faceCascade.detectMultiScale (grå, 1.2,5)
for (x, y, w, h) i ansigter:
cv2.rektangel (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)
Id = genkender.forudsige (grå [y: y + h, x: x + w])
hvis (Id == 1):
Id = "Nazmi"
andet:
Id = "Ukendt"
cv2.rektangel (im, (x-22, y-90), (x + w + 22, y-22), (0,255,0), -1)
cv2.putText (im, str (Id), (x, y-40), font, 2, (255,255,255), 3)
cv2.imshow ('im', im)
hvis cv2.waitKey (10) & 0xFF == ord ('q'):
pause
cam.frigøre()
cv2.destroyAllWindows ()

Hvis du har fulgt artiklen fra starten, har vi gjort det før. Hvis du ikke venligt har gjort det.

genkender.load ('træner / træner.yml ')

Husk, at vi uddannede genkenderen og gemte en fil? Ja? Vi indlæser den fil nu.

cascadePath = "haarcascade_frontalface_default.xml "

Vi ville arbejde med haarcascade-filen, og her har vi tildelt filnavnet til en variabel.

# Opret klassifikator fra den forudbyggede model
faceCascade = cv2.CascadeClassifier (cascadePath)

Her får vi udført Cascade-klassificering på haarcascade-filen.

skrifttype = cv2.FONT_HERSHEY_SIMPLEX

Vi indstiller den skrifttype, der skal bruges, når koden genkender ansigtet i et billede og viser navnet.

cam = cv2.VideoCapture (0)

Vi har været her før, men denne gang er det tid til at genkende ansigterne. Hvis du ikke ved, hvad denne kode gør, starter den webkameraet.

mens det er sandt:
ret, im = cam.Læs()
grå = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
ansigter = faceCascade.detectMultiScale (grå, 1.2,5)
for (x, y, w, h) i ansigter:

Alle disse er gjort før, bedes du kontrollere koden, der blev brugt til at gemme billeder, hvis du ikke ved hvad koden gør.

cv2.rektangel (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)

Så dette hjælper webkameraet med at registrere, hvor ansigterne er, og placerer et rektangel på for at angive et ansigt.

Id = genkender.forudsige (grå [y: y + h, x: x + w])

Vi har alrerady indlæst togfilen i genkenderen, så den er i stand til at genkende ansigtet nu.

hvis (Id == 1):
Id = "mig selv"
andet:
Id = "Ukendt"

Efter at have forsøgt at genkende hvilket ansigt det er, kontrollerer det for id'et og ser om det findes. Her ville værdien af ​​id'et være navnet på den, der var ejet, der står over for en sådan id, når billeddatasættet blev oprettet.

cv2.rektangel (im, (x-22, y-90), (x + w + 22, y-22), (0,255,0), -1)
cv2.putText (im, str (Id), (x, y-40), font, 2, (255,255,255), 3)

Koden efter at have fundet ejeren af ​​Id, tegner et rektangel rundt om ansigtet og placerer navnet på ansigtets ejer. Ansigt genkendt!

cv2.imshow ('im', im)

Her vises videorammen med det afgrænsede rektangel.

hvis cv2.waitKey (10) & 0xFF == ord ('q'):
pause
cam.frigøre()
cv2.destroyAllWindows ()

Så når du er færdig, kan du stoppe programmet ved at trykke på 'q' -tasten, og det stopper webkameraet og lukker det.

Der har du det, dit webcam kan nu genkende ansigter, og du kan bruge det, når du vil. Udover at bruge webkameraet kan du også indlæse et billede, men det kræver nogle andre trin end dem, der er taget i denne artikel.

Du kan finde kildekoden, der bruges på dens github repo. Tweet også os, hvis du har kommentarer eller vil diskutere @linuxhint