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 aritmetiske operasjoner, datamaskiner kjører nå verden.

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

Vi skal gjøre noe av den art i denne artikkelen. Som mennesker er det en enkel oppgave å gjenkjenne ansiktene til andre mennesker.

Mange artikler du vil se der ute få stoppe ved enkel ansiktsdeteksjon, men i denne artikkelen vil også dekke ikke bare ansiktsdeteksjon, men også anerkjennelse.

Dette betyr at hvis datamaskinen blir presentert med to bilder av meg, vil den ikke bare gjenkjenne hvilken del av bildet som er ansiktet mitt, det vil også erkjenne at jeg også er den i 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 åpen CV, kan vi gjøre det ved å bruke PIP -kommandoen.

Pip installer OpenCV-Python

Vi vil også bruke Numpy -pakken i denne artikkelen, som bør 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 installer numpy

For å bekrefte at OpenCV -en din er installert, når du aktiverer Pythons interaktive miljø, prøv å importere det ved hjelp av:

Importer CV2

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

For å utføre ansiktsgjenkjenning, ville vi skrevet tre skript. En for å lage et datasett med bilder, et annet for å trene bildene og deretter den siste som gjenkjenner ansiktene basert på resultatene av treningen datamaskinen går gjennom.

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

La oss nå komme inn i tykke ting.
Vi ville prøve å få webkameraet vårt til å få bildene, nødvendig for datasettet.

Importer CV2
VID_CAM = CV2.Videocapture (0)
face_Detector = CV2.Cascadeclassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
telling = 0
mens (vid_cam.isopened ()):
ret, image_frame = vid_cam.lese()
grå = cv2.cvtColor (image_frame, cv2.Color_bgr2gray)
Faces = face_Detector.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 (telling) + ".jpg ", grå [y: y+h, x: x+w])
CV2.Imshow ('ramme', image_frame)
Hvis CV2.WaitKey (100) & 0xff == Ord ('Q'):
gå i stykker
Elif Count> 100:
gå i stykker
vid_cam.utgivelse()
CV2.DestroyAllWindows ()

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

Importer CV2

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

VID_CAM = CV2.Videocapture (0)

Denne koden ber det importerte åpne CV -biblioteket for å begynne å fange, og webkameraet initieres på dette tidspunktet. Hvis den åpne CVen ikke støtter webkameraet ditt, vil koden mislykkes 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 kaskadeklassifisering. Det resulterende objektet lagres deretter i Face_Detector -variabelen.

face_id = 1

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

telling = 0

Vi kommer til å ta et par bilder da Open CV trenger å trene bilder for å kunne gjenkjenne ansikter, tellevariabelen fungerer som et bildetall.

mens (vid_cam.isopened ()):

Dette gjør at følgende operasjoner kan fortsette forutsatt at videokameraet åpnes. Isopened () -metoden returnerer sann eller usant.

ret, image_frame = vid_cam.lese()

Her, VID_CAM.Les () ser på videoopptaket og fanger deretter rammen som er lagret i Image_frame -variabelen, hvis operasjonen er vellykket, blir den boolske sanne returnert og lagret i RET -variabelen

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

CVTColor () -metoden brukes til å konvertere bildestammen til ønsket fargetype. I dette tilfellet har vi konvertert det til gråtoner.

Faces = face_Detector.DetectMultiscale (grå, 1.3, 5)

Dette sjekker for rammer i forskjellige størrelser og prøver å sette dem til skala, dette brukes på variabelen som Haar -kaskaden ble brukt.

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

Her sløyer vi gjennom ansiktene og dets dimensjoner, der 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 fortsatt jobber med videokamera.

telle += 1

Umiddelbart er det gjort, tellevariabelen som står som en teller og øker deretter.

CV2.IMWRITE ("Datasett/bruker." + str (face_id) + '.' + str (telling) + ".jpg ", grå [y: y+h, x: x+w])

Det beskårne bildet er lagret med navnet bruker (face_id).(telle).JPG og sett i en mappe som heter Dataset.

CV2.Imshow ('ramme', image_frame)

Etter lagring, sikrer denne koden at bildet er videoramme vises med et rektangel på individets ansikt etter at ansiktsdeteksjon 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 som kan gjøres ved å trykke 'Q' på tastaturet for minst 100ms.

Elif Count> 100:
gå i stykker

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

vid_cam.utgivelse()

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

CV2.DestroyAllWindows ()

Da er alle Windows OpenCV åpnet er blitt ødelagt og koden går til konklusjon.

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

Importer CV2, OS
Importer numpy 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).Konverter ('L')
img_numpy = np.Array (pil_img, 'uint8')
id = int (OS.sti.Split (ImagePath) [-1].dele(".")[1])
Faces = Detektor.DetectMultiscale (img_numpy)
for (x, y, w, h) i ansikter:
FaceSampples.vedlegg (img_numpy [y: y+h, x: x+w])
ids.vedlegg (id)
Returner FacesAmples, IDS
Faces, IDS = getImageSandLabels ('Dataset')
gjenkjenning.Tog (ansikter, NP.Array (IDS))
gjenkjenning.Lagre ('Trainer/Trainer.yml ')

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

Importer CV2, OS

Akkurat som den andre koden, her importerer vi OpenCV og OS som vi trenger for filsti.

Importer numpy som NP

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

Fra PIL importbilde

Vi importerer Python Image Library, og deretter får vi bildebiblioteket fra denne pakken også.

Gjenkjenning = CV2.ansikt.CreateLBPHFacereCognizer ()

Hva dette gjør er å anvende CreateLBPHFacereCognizer () -metoden på CV2.ansiktsobjekt, dette vil bidra til å gjøre anerkjennelsen av ansiktene enkelt, da vi ikke trenger å komme med vårt eget sett med algoritmer.

Detektor = CV2.Cascadeclassifier ("haarcascade_frontalface_default.xml ");

Hvis du har fulgt opplæringen, ville du kommet over dette før. Det hjelper med ansiktsdeteksjon ved å bruke “haarcascade_frontalface_default.XML ”for kaskadeklassifiseringen.

def getImagesAndLabels (sti):

Nå er vi i ferd med å begynne på bildetreningen, så vi lager en funksjon.

ImagePaths = [OS.sti.Bli med (sti, f) for f i OS.listdir (sti)]

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

FacesAmples = []

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

IDS = []

Initialiser en liste over ID -er, som opprinnelig er tom.

For ImagePath i ImagePaths:

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

Pil_img = bilde.Åpen (ImagePath).Konverter ('L')

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

img_numpy = np.Array (pil_img, 'uint8')

GrayScaled -bildet er bare en serie med tall på ett sted, så vi lager et numpy matrise ut av dem og tildeler det 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 Files -brukeren (face_id).telle.jpg. Så her deler vi navnene med ".”Og så trekker vi ut Face_id og tildeler en variabel her. Vi trenger ID for anerkjennelse.

Faces = Detektor.DetectMultiscale (img_numpy)

Fra Numpy -matrisen vil metoden detectMultiscale (). Så tildeler den verdiene i Faces Variable.

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

Her slår vi gjennom verdiene som er tilordnet variabelen. Verdiene her er X- og Y -koordinatene som vi kan ta som opprinnelse, og deretter W og H står for henholdsvis bredde og høyde.

FaceSampples.vedlegg (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 til ansikter på den listen, og vi legger y til H for å få de to verdiene til Y -koordinatene og det samme gjøres til x.

ids.vedlegg (id)

Vi har nå et ansikt i ansiktseksempellisten, så vi får IDen og legger den til IDS -listen også.

Returner FacesAmples, IDS

Så etter det hele returnerer vi listen over ansiktsprøver og listen over ID -er.

Faces, IDS = getImageSandLabels ('Dataset')

Husk at getImageSandLabels () bare er en funksjon. Så vi får kalle funksjonen her, og returverdiene blir lagret i ansiktene og IDS -variablene.

gjenkjenning.Tog (ansikter, NP.Array (IDS))

Her skjer den virkelige treningen. Vi brukte CreatEelBPhFacereCognizer () -metoden en gang tidligere og tildelt en gjenkjennelsesvariabel. Det er treningstid!

gjenkjenning.Lagre ('Trainer/Trainer.yml ')

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

Her er ansiktsgjenkjenningskoden:

Importer CV2
Importer numpy som NP
Gjenkjenning = CV2.ansikt.CreateLBPHFacereCognizer ()
gjenkjenning.Last ('trener/trener.yml ')
cascadepath = "haarcascade_frontalface_default.XML "
FACECASCADE = CV2.Cascadeclassifier (Cascadepath)
Font = CV2.FONT_HERSHEY_SIMPLEX
CAM = CV2.Videocapture (0)
Mens sant:
ret, im = cam.lese()
grå = cv2.cvtColor (im, cv2.Color_bgr2gray)
Faces = 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 = gjenkjennelse.forutsi (grå [y: y+h, x: x+w])
if (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
Cam.utgivelse()
CV2.DestroyAllWindows ()

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

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

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

cascadepath = "haarcascade_frontalface_default.XML "

Vi jobber med Haarcascade -filen, og her har vi tildelt filnavnet til en variabel.

# Lag klassifiserer fra forhåndsbygget modell
FACECASCADE = CV2.Cascadeclassifier (Cascadepath)

Her får vi utføre kaskadeklassifisering på Haarcascade -filen.

Font = CV2.FONT_HERSHEY_SIMPLEX

Vi angir skrifttypen som vil bli brukt 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, lanserer den webkameraet.

Mens sant:
ret, im = cam.lese()
grå = cv2.cvtColor (im, cv2.Color_bgr2gray)
Faces = Facecascade.DetectMultiscale (grå, 1.2,5)
for (x, y, w, h) i ansikter:

Alle disse har blitt 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 alrerady lastet togfilen inn i gjenkjenneren, så den er i stand til å gjenkjenne ansiktet nå.

if (id == 1):
Id = "meg selv"
ellers:
Id = "ukjent"

Etter å ha prøvd å gjenkjenne hvilket ansikt det er, sjekker det for ID og ser om det eksisterer. Her ville verdien av ID være navnet på den som ble eid møtt med en slik ID da 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 IDen, 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
Cam.utgivelse()
CV2.DestroyAllWindows ()

Så når du er ferdig, kan du stoppe programmet ved å trykke på '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 ønsker det. 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.