Ansiktsgjenkjenning med OpenCV

Kompleksiteten til maskiner har økt gjennom årene, og datamaskiner er ikke et unntak. Datamaskiner har hjulpet menneskeheten med å løse mange problemer og fullføre mange vanskelige oppgaver. Borte er dagene da alle datamaskiner gjorde var enkle regneoperasjoner, datamaskiner driver nå verden.

Datamaskiner har blitt så kompliserte at de blir opplært til å tenke som mennesker.
Ja!

Vi kommer til å gjøre noe av den art i denne artikkelen. Å anerkjenne ansiktene til andre mennesker er som mennesker en enkel oppgave, og til tross for dagens datamaskins evner er det ikke like lett for datamaskinen, så vi må trene den for å kunne gjøre det samme.

Mange artikler du ser der ute, stopper ved enkel ansiktsgjenkjenning, men i denne artikkelen vil de ikke bare dekke ansiktsgjenkjenning, men også ansiktsgjenkjenning.

Dette betyr at hvis datamaskinen presenteres med to bilder av meg, vil den ikke bare gjenkjenne hvilken del av bildet som er ansiktet mitt, det vil også gjenkjenne at jeg også er den på begge bildene.

Til å begynne med må vi først installere opencv på maskinene våre, noe som bare kan gjøres hvis du har Python installert. Installasjonen av Python er ikke målet med denne artikkelen, så hvis du ikke allerede har den på maskinen din, kan du installere Python fra Python-nettstedet.

For å installere Open CV kan vi gjøre det ved hjelp av pip-kommandoen.

pip installer opencv-python

Vi vil også bruke den numpy pakken i denne artikkelen, som skal installeres ved siden av OpenCV ved hjelp av kommandoen ovenfor.

Hvis numpy ikke installerte, kan du enkelt gjøre det ved å bruke kommandoen nedenfor:

pip install nummen

For å bekrefte at OpenCV er installert, prøv å importere det ved å aktivere Pythons interaktive miljø:

importere cv2

Hvis du ikke får feil, kan du fortsette.

For å utføre ansiktsgjenkjenning skriver vi tre manus. Én for å lage et datasett med bilder, en annen for å trene bildene og deretter den siste som gjenkjenner ansiktene basert på resultatene av opplæringen datamaskinen går gjennom.

Vi trenger Haar Cascade levert av Open CV. Denne filen kan hentes fra opencv-katalogen som er cv2 / data / haarcascade_frontalface_default.xml på maskinen min, det skal også være det samme på maskinen din. Kopier filen til mappen der du ønsker å gjøre ansiktsgjenkjenning.

La oss nå komme inn i det tykke av ting.
Vi ville prøve å få webkameraet vårt til å hente bildene som trengs for datasettet.

importere cv2
vid_cam = cv2.VideoCapture (0)
face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
telle = 0
mens (vid_cam.isOpened ()):
ret, image_frame = vid_cam.lese()
grå = cv2.cvtColor (image_frame, cv2.COLOR_BGR2GRAY)
ansikter = ansiktsdetektor.detectMultiScale (grå, 1.3, 5)
for (x, y, w, h) i ansikter:
cv2.rektangel (image_frame, (x, y), (x + w, y + h), (255,0,0), 2)
telle + = 1
cv2.imwrite ("datasett / bruker."+ 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'):
gå i stykker
elif count> 100:
gå i stykker
vid_kamera.utgivelse()
cv2.destroyAllWindows ()

Så for å forklare hva hver kodelinje gjør:

importere cv2

Her er kommandoen som ber python om å inkludere et eksternt bibliotek som skal brukes i denne koden, i dette tilfellet er det Open CV.

vid_cam = cv2.VideoCapture (0)

Denne koden ber det importerte Open CV-biblioteket om å begynne å fange, og webkameraet startes på dette tidspunktet. Hvis Open CV ikke støtter webkameraet ditt, mislykkes koden her.

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

For at vi skal kunne utføre bildedeteksjon, er denne koden nødvendig. Åpen CV bruker 'haarcascade_frontalface_default.xml 'for Cascade Classification. Det resulterende objektet lagres deretter i face_detector-variabelen.

face_id = 1

Her er et tilfelle av å angi ID-nummeret til ansiktet, så det første ansiktet får en ID på 1.

telle = 0

Vi skal ta et par bilder ettersom Open CV trenger å trene bilder for å kunne gjenkjenne ansikter, tellervariabelen fungerer som et bildetall.

mens (vid_cam.isOpened ()):

Dette gjør at følgende operasjoner kan fortsette forutsatt at videokameraet åpnes. Metoden isOpened () returnerer True eller False.

ret, image_frame = vid_cam.lese()

Her, vid_kameraet.read () ser på videoopptaket og fanger deretter rammen som er lagret i image_frame-variabelen. Hvis operasjonen er vellykket, returneres den boolske True og lagres i ret-variabelen

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

Metoden cvtColor () brukes til å konvertere bilderammen til ønsket fargetype. I dette tilfellet har vi konvertert det til gråtoner.

ansikter = ansiktsdetektor.detectMultiScale (grå, 1.3, 5)

Dette ser etter rammer av forskjellige størrelser og prøver å sette dem i skala, dette brukes på variabelen som Haar Cascade ble brukt på.

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

Her sløyfer vi gjennom ansiktene og dens dimensjoner, hvor x og y står for koordinatene og w og h står for henholdsvis bredde og høyde.

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

Husk at vi fremdeles jobber med videokameraet, og deretter beskjærer videokameraet behovsdelen av bildet i henhold til dimensjonene ovenfor.

telle + = 1

Straks det er gjort, øker tellingsvariabelen som står som en teller.

cv2.imwrite ("datasett / bruker."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w])

Det beskårne bildet lagres med navnet User (face_id).(telle).jpg og settes i en mappe som heter datasett.

cv2.imshow ('frame', image_frame)

Etter lagring sørger denne koden for at bildet er at videorammen vises med et rektangel i ansiktet til ansiktet etter at ansiktsgjenkjenning er gjort.

hvis cv2.waitKey (100) & 0xFF == ord ('q'):
gå i stykker

Etter hvert bilde har brukeren lov til å stoppe programmet fra å ta flere bilder, noe som kan gjøres ved å trykke på 'q' på tastaturet i minst 100 ms.

elif count> 100:
gå i stykker

Hva denne koden gjør, er å hindre at videoen fungerer i det øyeblikket 100 bilder er tatt, uansett om brukeren vil ta mer eller ikke.

vid_kamera.utgivelse()

Her er webkameraet stengt og ikke bare stoppet fra å ta bilder.

cv2.destroyAllWindows ()

Da har alle vinduene som OpenCV har åpnet blitt ødelagt, og koden går til konklusjon.

Nå som vi er ferdige med det, kan vi trene bildedatasettet:

importer cv2, os
importer nummen som np
fra PIL-importbilde
gjenkjenning = cv2.ansikt.createLBPHFaceRecognizer ()
detektor = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");
def getImagesAndLabels (sti):
imagePaths = [os.sti.bli med (sti, f) for f i os.listdir (sti)]
faceSamples = []
ids [[]
for imagePath i imagePaths:
PIL_img = Bilde.åpen (imagePath).konvertere ('L')
img_numpy = np.matrise (PIL_img, 'uint8')
id = int (os.sti.split (imagePath) [- 1].dele(".")[1])
ansikter = detektor.detectMultiScale (img_numpy)
for (x, y, w, h) i ansikter:
ansikt Prøver.legg til (img_numpy [y: y + h, x: x + w])
ID-er.legge til (id)
return faceSamples, ids
ansikter, ids = getImagesAndLabels ('datasett')
gjenkjenning.tog (ansikter, np.array (ids))
gjenkjenning.save ('trener / trener.yml ')

La oss gå videre og forklare denne koden også:

importer cv2, os

Akkurat som den andre koden, importerer vi OpenCV og os som vi trenger for filstien.

importer nummen som np

Vi importerer også det numme biblioteket som vil bli brukt til matriksberegning (en matrise er bare et arrangement av matriser).

fra PIL-importbilde

Vi importerer Python Image Library, og fra det får vi også Image-biblioteket fra denne pakken.

gjenkjenning = cv2.ansikt.createLBPHFaceRecognizer ()

Hva dette gjør er å bruke createLBPHFaceRecognizer () -metoden på cv2.ansiktsobjekt, vil dette bidra til å gjøre det lett å gjenkjenne ansikter, ettersom vi ikke trenger å komme med vårt eget sett med algoritmer.

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

Hvis du har fulgt veiledningen, ville du ha kommet over dette før. Det hjelper med ansiktsgjenkjenning ved å bruke “haarcascade_frontalface_default.xml ”for Cascade Classification.

def getImagesAndLabels (sti):

Nå er vi i ferd med å begynne med riktig bildetrening, så vi lager en funksjon.

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

Denne koden sjekker inn i den gjeldende katalogen for filen, og ser etter bildefilene og legger dem til i denne listen.

faceSamples = []

Dette initialiserer en liste over prøver, den er tom på dette punktet, men ansikter vil bli lagt til når koden kjører.

ids [[]

Initialiser en liste over ID-er, som i utgangspunktet er tomme.

for imagePath i imagePaths:

Husk koden som sjekket for bildefilene i katalogen? Ja? Nå skal vi gå gjennom hver av disse filene og utføre operasjoner på dem.

PIL_img = Bilde.åpen (imagePath).konvertere ('L')

Nå er det første vi gjør mot bildet å konvertere det til gråtoner, og denne koden gjør det.

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

Det gråtonede bildet er bare en serie tall alt på ett sted, så vi lager en nummen matrise ut av dem og tilordner den til en variabel.

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

Hvis du husker filen som får bildene, vil du huske at vi kalte filene User (face_id).telle.jpg. Så her deler vi navnene med ".”Og så trekker vi ut face_id og tilordner til en variabel her. Vi trenger ID-en for anerkjennelse.

ansikter = detektor.detectMultiScale (img_numpy)

Fra nummen matrise, vil detectMultiScale () -metoden prøve å oppdage ansiktene fra mønsteret den finner i nummen matrise. Deretter tildeles verdiene i ansiktsvariabelen.

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

Her går vi gjennom verdiene som er tildelt variabelen. Verdiene her er x- og y-koordinatene som vi kan ta som opprinnelse, og deretter står w og h for henholdsvis bredde og høyde.

ansikt Prøver.legg til (img_numpy [y: y + h, x: x + w])

Tidligere opprettet vi en liste over ansiktsprøver, men den var tom. Her får vi legge ansikter til den listen, og vi legger til y til h for å få de to verdiene til y-koordinatene, og det samme gjøres til x.

ID-er.legge til (id)

Vi har nå et ansikt i listen over ansiktseksempler, så vi får ID-en og legger den til ID-listen også.

return faceSamples, ids

Så når alt kommer til alt, returnerer vi listen over ansiktsprøver og listen over ID-er.

ansikter, ids = getImagesAndLabels ('datasett')

Husk at getImagesAndLabels () bare er en funksjon. Så vi får kalle funksjonen her, og returverdiene lagres i ansikts- og id-variablene.

gjenkjenning.tog (ansikter, np.array (ids))

Her er der den virkelige treningen skjer. Vi brukte metoden createLBPHFaceRecognizer () en gang tidligere og tilordnet en gjenkjenningsvariabel. Det er treningstid!

gjenkjenning.save ('trener / trener.yml ')

Etter trening får vi lagre resultatene fra treningen.
Etter å ha kjørt koden, oppretter den en fil som heter trener.yml som deretter vil bli brukt av ansiktsgjenkjenningskoden.

Her er koden for ansiktsgjenkjenning:

importere cv2
importer nummen som np
gjenkjenning = cv2.ansikt.createLBPHFaceRecognizer ()
gjenkjenning.load ('trener / trener.yml ')
cascadePath = "haarcascade_frontalface_default.xml "
faceCascade = cv2.CascadeClassifier (cascadePath)
font = cv2.FONT_HERSHEY_SIMPLEX
cam = cv2.VideoCapture (0)
mens det er sant:
ret, im = cam.lese()
grå = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
ansikter = faceCascade.detectMultiScale (grå, 1.2,5)
for (x, y, w, h) i ansikter:
cv2.rektangel (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)
Id = gjenkjenning.forutsi (grå [y: y + h, x: x + w])
hvis (Id == 1):
Id = "Nazmi"
ellers:
Id = "Ukjent"
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'):
gå i stykker
kamera.utgivelse()
cv2.destroyAllWindows ()

Hvis du har fulgt artikkelen fra begynnelsen, har vi gjort dette før. Hvis du ikke har gjort det.

gjenkjenning.load ('trener / trener.yml ')

Husk at vi trente gjenkjenningen og lagret en fil? Ja? Vi laster den filen nå.

cascadePath = "haarcascade_frontalface_default.xml "

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

# Lag klassifiser fra forhåndsbygd modell
faceCascade = cv2.CascadeClassifier (cascadePath)

Her får vi utføre Cascade-klassifisering på haarcascade-filen.

font = cv2.FONT_HERSHEY_SIMPLEX

Vi angir skrifttypen som skal brukes når koden gjenkjenner ansiktet i et bilde og viser navnet.

cam = cv2.VideoCapture (0)

Vi har vært her før, men denne gangen er det på tide å gjenkjenne ansiktene. Hvis du ikke vet hva denne koden gjør, starter den webkameraet.

mens det er sant:
ret, im = cam.lese()
grå = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
ansikter = faceCascade.detectMultiScale (grå, 1.2,5)
for (x, y, w, h) i ansikter:

Alt dette er gjort før, vennligst sjekk koden som ble brukt til å lagre bilder hvis du ikke vet hva koden gjør.

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

Så dette hjelper webkameraet med å oppdage hvor ansiktene er og plasserer et rektangel på for å indikere et ansikt.

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

Vi har allerede lastet inn togfilen i gjenkjenneren, så den er i stand til å gjenkjenne ansiktet nå.

hvis (Id == 1):
Id = "Meg selv"
ellers:
Id = "Ukjent"

Etter å ha prøvd å gjenkjenne hvilket ansikt det er, ser det etter ID og ser om det eksisterer. Her ville verdien av ID-en være navnet på den som var eid og møtt med en slik id når bildedatasettet ble opprettet.

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 etter å ha funnet eieren av ID, tegner et rektangel rundt ansiktet og plasserer navnet på ansiktet. Ansikt anerkjent!

cv2.imshow ('im', im)

Her vises videorammen med det avgrensede rektangelet.

hvis cv2.waitKey (10) & 0xFF == ord ('q'):
gå i stykker
kamera.utgivelse()
cv2.destroyAllWindows ()

Så når du er ferdig, kan du stoppe programmet ved å trykke 'q' -tasten, og det stopper webkameraet og lukker det.

Der har du det, webkameraet ditt kan nå gjenkjenne ansikter, og du kan bruke det når du vil. Bortsett fra å bruke webkameraet, kan du også laste inn et bilde, men det krever noen andre trinn enn de som er tatt i denne artikkelen.

Du kan finne kildekoden som brukes på github repo. Tweet oss også hvis du har kommentarer eller vil diskutere @linuxhint