Ansiktsigenkänning med OpenCV

Maskinernas komplexitet har ökat med åren och datorer är inget undantag. Datorer har hjälpt mänskligheten att lösa många problem och slutföra många svåra uppgifter. Borta är de dagar då alla datorer var enkla aritmetiska operationer, datorer driver nu världen.

Datorer har blivit så komplexa att de utbildas för att tänka som människor.
Ja!

Vi kommer att göra något av den typen i den här artikeln. Att känna igen ansikten på andra människor som människor är en enkel uppgift och trots förmågan hos dagens datorer är det inte lika lätt för datorn så vi måste träna den för att kunna göra detsamma.

Många artiklar som du ser där ute kommer att stanna vid enkel ansiktsavkänning, men i den här artikeln skulle det inte bara täcka ansiktsavkänning utan också ansiktsigenkänning.

Detta innebär att om datorn presenteras med två bilder av mig, skulle den inte bara känna igen vilken del av bilden som är mitt ansikte, den skulle också känna igen att jag är den i båda bilderna också.

Till att börja med måste vi först installera opencv på våra maskiner, vilket bara kan göras om du har Python installerat. Installationen av Python är inte målet för den här artikeln, så om du inte redan har den på din maskin kan du installera Python från Pythons webbplats.

För att installera Open CV kan vi göra det med pip-kommandot.

pip installera opencv-python

Vi kommer också att använda numpy-paketet i den här artikeln, som ska installeras tillsammans med OpenCV med ovanstående kommando.

Om numpy inte installerades kan du enkelt göra det med kommandot nedan:

pip install numpy

För att bekräfta att din OpenCV är installerad, försök att importera den med Pythons interaktiva miljö med:

importera cv2

Om du inte får något fel kan du fortsätta.

För att utföra ansiktsigenkänning skulle vi skriva tre manus. En för att skapa en uppsättning bilder, en annan för att träna dessa bilder och sedan den sista som känner igen ansikten baserat på resultaten av träningen som datorn går igenom.

Vi skulle behöva Haar Cascade från Open CV. Den här filen kan hämtas från opencv-katalogen som är cv2 / data / haarcascade_frontalface_default.xml på min maskin bör det vara samma på din maskin också. Kopiera filen till den mapp där du vill göra ansiktsigenkänning.

Låt oss nu gå in i det tjocka av saker.
Vi skulle försöka få vår webbkamera för att få de bilder som behövs för datasetet.

importera cv2
vid_cam = cv2.VideoCapture (0)
face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
räkna = 0
medan (vid_cam.är öppnad()):
ret, image_frame = vid_cam.läsa()
grå = cv2.cvtColor (bildram, cv2.COLOR_BGR2GRAY)
ansikten = ansiktsdetektor.detectMultiScale (grå, 1.3, 5)
för (x, y, w, h) i ansikten:
cv2.rektangel (bildram, (x, y), (x + w, y + h), (255,0,0), 2)
räkna + = 1
cv2.imwrite ("dataset / User."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w])
cv2.imshow ('ram', bild_ram)
om cv2.waitKey (100) & 0xFF == ord ('q'):
ha sönder
elif-tal> 100:
ha sönder
vid_kamera.släpp()
cv2.destroyAllWindows ()

Så för att förklara vad varje kodrad gör:

importera cv2

Här är kommandot som ber python att inkludera ett externt bibliotek som ska användas i den här koden, i det här fallet är det Open CV.

vid_cam = cv2.VideoCapture (0)

Denna kod anropar det importerade Open CV-biblioteket för att börja fånga och webbkameran initieras vid denna tidpunkt. Om Open CV inte stöder din webbkamera kommer koden att misslyckas här.

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

För att vi ska kunna utföra bildavkänning behövs den här koden. Öppet CV använder 'haarcascade_frontalface_default.xml 'för Cascade Classification. Det resulterande objektet lagras sedan i variabeln face_detector.

face_id = 1

Här är ett fall av att ställa in ID-numret på ansiktet, så det första ansiktet får ett ID på 1.

räkna = 0

Vi kommer att ta ett par bilder eftersom Open CV behöver träna bilder för att kunna känna igen ansikten, räkningsvariabeln fungerar som bildräkning.

medan (vid_cam.är öppnad()):

Detta gör att följande åtgärder kan fortsätta förutsatt att videokameran öppnas. Metoden isOpened () returnerar True eller False.

ret, image_frame = vid_cam.läsa()

Här, vid_cam.läs () tittar in i videoinspelningen och fångar sedan ramen som lagras i image_frame-variabeln, om operationen lyckas returneras den booleska True och lagras i ret-variabeln

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

Metoden cvtColor () används för att konvertera bildramen till önskad färgtyp. I det här fallet har vi omvandlat det till gråskala.

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

Detta söker efter ramar i olika storlekar och försöker ställa in dem i skala, detta tillämpas på variabeln som Haar Cascade applicerades på.

för (x, y, w, h) i ansikten:

Här slingrar vi genom ansikten och dess dimensioner, där x och y står för koordinaterna och w och h står för bredd respektive höjd.

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

Kom ihåg att vi fortfarande arbetar med videokameran, videokameran beskär sedan bildens behovsdel enligt dimensionerna ovan.

räkna + = 1

Omedelbart görs detta, räknar variabeln som står som en räknare sedan.

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

Den beskurna bilden sparas med namnet User (face_id).(räkna).jpg och lägg i en mapp som heter dataset.

cv2.imshow ('ram', bild_ram)

Efter spara säkerställer den här koden att bilden är videoramen visas med en rektangel i individens ansikte efter att ansiktsavkänning har gjorts.

om cv2.waitKey (100) & 0xFF == ord ('q'):
ha sönder

Efter varje bild får användaren stoppa programmet från att ta fler bilder, vilket kan göras genom att trycka på 'q' på tangentbordet i minst 100 ms.

elif-tal> 100:
ha sönder

Vad den här koden gör är att stoppa videon från att fungera när 100 bilder har tagits, oavsett om användaren vill ta mer eller inte.

vid_kamera.släpp()

Här är webbkameran stängd och inte bara stoppad från att ta bilder.

cv2.destroyAllWindows ()

Sedan har alla fönster som OpenCV har öppnat förstörts och koden körs till slut.

Nu när vi är klara med det kan vi sedan träna bilddatauppsättningen:

importera cv2, os
importera numpy som np
från PIL-importbild
igenkännare = cv2.ansikte.createLBPHFaceRecognizer ()
detektor = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");
def getImagesAndLabels (sökväg):
imagePaths = [os.väg.gå med (sökväg, f) för f i os.listdir (sökväg)]
faceSamples = []
id = []
för imagePath i imagePaths:
PIL_img = Bild.öppna (imagePath).konvertera ('L')
img_numpy = np.array (PIL_img, 'uint8')
id = int (os.väg.split (imagePath) [- 1].dela(".") [1])
ansikten = detektor.detectMultiScale (img_numpy)
för (x, y, w, h) i ansikten:
ansikte Prov.lägg till (img_numpy [y: y + h, x: x + w])
id.bifoga (id)
return faceSamples, ids
ansikten, ids = getImagesAndLabels ('dataset')
igenkännare.tåg (ansikten, np.array (ids))
igenkännare.spara ('tränare / tränare.yml ')

Låt oss gå vidare och förklara den här koden också:

importera cv2, os

Precis som den andra koden importerar vi här OpenCV och os som vi skulle behöva för filsökvägen.

importera numpy som np

Vi importerar också det domna biblioteket som skulle användas för matrisberäkning (en matris är bara ett arrangemang av matriser).

från PIL-importbild

Vi importerar Python Image Library och sedan från det får vi också Image-biblioteket från det här paketet.

igenkännare = cv2.ansikte.createLBPHFaceRecognizer ()

Vad detta gör är att tillämpa metoden createLBPHFaceRecognizer () på cv2.ansikte objekt, skulle detta göra det lätt att känna igen ansikten eftersom vi inte behöver komma med vår egen uppsättning algoritmer.

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

Om du har följt handledningen skulle du ha stött på detta tidigare. Det hjälper till med ansiktsavkänning med hjälp av “haarcascade_frontalface_default.xml ”för Cascade Classification.

def getImagesAndLabels (sökväg):

Nu håller vi på att börja bildutbildningen ordentligt, så vi skapar en funktion.

imagePaths = [os.väg.gå med (sökväg, f) för f i os.listdir (sökväg)]

Den här koden kontrollerar i den aktuella katalogen för filen och söker efter bildfilerna och lägger dem sedan till denna lista.

faceSamples = []

Detta initialiserar en lista med prover, den är tom vid denna punkt men ansikten skulle läggas till när koden körs.

id = []

Initiera en lista med id: er som ursprungligen är tomma.

för imagePath i imagePaths:

Kom ihåg koden som kontrollerade bildfilerna i katalogen? Ja? Nu ska vi gå igenom var och en av dessa filer och utföra operationer på dem.

PIL_img = Bild.öppna (imagePath).konvertera ('L')

Nu är det första vi gör mot bilden att konvertera den till gråskala, och den här koden gör det.

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

Den gråskaliga bilden är bara en serie siffror på ett och samma ställe, så vi skapar en dum matris av dem och tilldelar den till en variabel.

id = int (os.väg.split (imagePath) [- 1].dela(".") [1])

Om du kommer ihåg filen som får bilderna, skulle du komma ihåg att vi namngav filerna Användare (face_id).räkna.jpg. Så här delar vi upp namnen med ”.”Och sedan extraherar vi face_id och tilldelar en variabel här. Vi skulle behöva id för erkännande.

ansikten = detektor.detectMultiScale (img_numpy)

Från numpy array kommer detectMultiScale () -metoden att försöka upptäcka ansikten från mönstret som den hittar i numpy array. Sedan tilldelas värdena i ansiktsvariabeln.

för (x, y, w, h) i ansikten:

Här går vi igenom de värden som tilldelats variabeln. Värdena här är x- och y-koordinaterna som vi kan ta som ursprung, och sedan står w och h för bredd respektive höjd.

ansikte Prov.lägg till (img_numpy [y: y + h, x: x + w])

Tidigare skapade vi en lista över ansiktsprover, men den var tom. Här får vi lägga till ansikten i den listan, och vi lägger till y till h för att få de två värdena på y-koordinaterna och samma görs till x.

id.bifoga (id)

Vi har nu ett ansikte i listan över ansiktsprover, så vi får dess id och lägger till det till id-listan också.

return faceSamples, ids

När allt kommer omkring returnerar vi listan över ansiktsprover och listan över id: n.

ansikten, ids = getImagesAndLabels ('dataset')

Kom ihåg att getImagesAndLabels () bara är en funktion. Så vi får kalla funktionen här, och returvärdena sparas i ansikts- och id-variablerna.

igenkännare.tåg (ansikten, np.array (ids))

Här sker den riktiga träningen. Vi använde metoden createLBPHFaceRecognizer () någon gång tidigare och tilldelades en igenkännarvariabel. Det är träningstid!

igenkännare.spara ('tränare / tränare.yml ')

Efter träningen får vi spara resultaten från träningen.
Efter att ha kört koden skapas en fil som heter tränare.yml som sedan skulle användas av ansiktsigenkänningskoden.

Här är koden för ansiktsigenkänning:

importera cv2
importera numpy som np
igenkännare = cv2.ansikte.createLBPHFaceRecognizer ()
igenkännare.load ('tränare / tränare.yml ')
cascadePath = "haarcascade_frontalface_default.xml "
faceCascade = cv2.CascadeClassifier (cascadePath)
font = cv2.FONT_HERSHEY_SIMPLEX
cam = cv2.VideoCapture (0)
medan det är sant:
ret, im = cam.läsa()
grå = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
ansikten = faceCascade.detectMultiScale (grå, 1.2,5)
för (x, y, w, h) i ansikten:
cv2.rektangel (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)
Id = igenkännare.förutsäga (grå [y: y + h, x: x + w])
om (Id == 1):
Id = "Nazmi"
annan:
Id = "Okänd"
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)
om cv2.waitKey (10) & 0xFF == ord ('q'):
ha sönder
kam.släpp()
cv2.destroyAllWindows ()

Om du har följt artikeln från början har vi gjort det tidigare. Om du inte vänligen gör det.

igenkännare.load ('tränare / tränare.yml ')

Kom ihåg att vi tränade igenkännaren och sparade en fil? Ja? Vi laddar den filen nu.

cascadePath = "haarcascade_frontalface_default.xml "

Vi skulle arbeta med haarcascade-filen, och här har vi tilldelat filnamnet till en variabel.

# Skapa klassificerare från förbyggd modell
faceCascade = cv2.CascadeClassifier (cascadePath)

Här får vi utföra Cascade-klassificering på haarcascade-filen.

font = cv2.FONT_HERSHEY_SIMPLEX

Vi ställer in typsnitt som skulle användas när koden känner igen ansiktet i en bild och visar namnet.

cam = cv2.VideoCapture (0)

Vi har varit här tidigare, men den här gången är det dags att känna igen ansikten. Om du inte vet vad den här koden gör startar den webbkameran.

medan det är sant:
ret, im = cam.läsa()
grå = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
ansikten = faceCascade.detectMultiScale (grå, 1.2,5)
för (x, y, w, h) i ansikten:

Alla dessa har gjorts tidigare, vänligen kontrollera koden som användes för att spara bilder om du inte vet vad koden gör.

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

Så detta hjälper webbkameran att upptäcka var ansikten är och placerar en rektangel på för att indikera ett ansikte.

Id = igenkännare.förutsäga (grå [y: y + h, x: x + w])

Vi har alrerady laddat tågfilen i igenkännaren, så den kan känna igen ansiktet nu.

om (Id == 1):
Id = "Jag själv"
annan:
Id = "Okänd"

Efter att ha försökt känna igen vilket ansikte det är kontrollerar det efter id och ser om det finns. Här skulle ID-värdet vara namnet på vem som ägdes inför ett sådant id när bilddatauppsättningen skapades.

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 att ha hittat ägaren till Id, ritar en rektangel runt ansiktet och placerar namnet på ansiktsägaren. Ansikte igenkänt!

cv2.imshow ('im', im)

Här visas videoramen med den avgränsade rektangeln.

om cv2.waitKey (10) & 0xFF == ord ('q'):
ha sönder
kam.släpp()
cv2.destroyAllWindows ()

Så när du är klar kan du stoppa programmet genom att trycka på "q" -knappen, och det stoppar webbkameran och stänger den.

Där har du det, din webbkamera kan nu känna igen ansikten och du kan använda den när du vill. Förutom att använda webbkameran kan du också ladda en bild, men det kräver några andra steg än de som tas i den här artikeln.

Du hittar källkoden som används på github repo. Tweeta oss också om du har kommentarer eller vill diskutera @linuxhint