Implementering af ansigtsregistrering ved hjælp af Python og OpenCV

kilde: https://www.ariadnext.com/facial-recognition-new-era-for-online-identification/

Computersyn er alt det vrede i maskinlæring og dyb læringsfællesskab i disse dage. Og en af ​​de mest populære applikationer på dette domæne er ansigtsregistrering.

Det er hvad vi lærer at opbygge i denne detaljerede artikel. Men før vi begynder med det, lad os se på to sager i den virkelige verden:

1. At gøre biler mere sikre
Bilproducenter over hele verden som Mercedes, Tesla, BMW osv. Fokuserer i stigende grad på at gøre biler mere personlige og sikre for føreren at køre. I deres forsøg på at bygge smartere bilfunktioner giver det mening at producenterne bruger AI / ML for at hjælpe dem med bedre at forstå menneskelige følelser. Ved hjælp af ansigtsgenkendelse kan smarte biler advare føreren, når han føler sig døsig eller sløv.

Det amerikanske transportministerium rapporterede, at kørselsrelaterede fejl forårsager omkring 95% af de fatale trafikulykker. Detektion af ansigtsfølelser kan finde subtile ændringer i ansigtsmikroudtryk, der går foran døsighed og sende personlige advarsler til chaufføren, der beder ham stoppe bilen og gå en kaffepause, skifte musik eller temperatur osv.

2. Påvisning af ansigtsfølelser i interviews
En kandidat-interviewers interaktion påvirkes for mange dommekategorier og en slags fejlagtig fortolkning. En sådan form for dømmekraft gør det svært at afgøre, om kandidaten faktisk er egnet til jobbet. At identificere, hvad en kandidat forsøger at formidle, er ude af interviewers hænder på grund af de mange lag af sprogtolkning, kognitive forfordringer og kontekst der ligger i mellem. Det er her AI kommer ind, som kan måle kandidatens ansigtsudtryk for at fange deres humør og vurdere deres personlighedstræk yderligere.

Medarbejdermoral kan også opfattes ved hjælp af denne teknologi ved at holde og registrere interaktioner på jobbet. Som HR-værktøj kan det hjælpe ikke kun med at udarbejde rekrutteringsstrategier, men også til at designe HR-politikker, der medfører den bedste ydelse fra medarbejderne.

Som vi har set, hvordan ansigtsdetekteringsteknologi effektivt kan hjælpe med at træffe bedre beslutninger, så lad os grave dybere og forstå, hvad der nøjagtigt er ansigtsgenkendelse, og hvordan vi kan skabe en enkel model, der kan registrere vores ansigt.

Hvad er ansigtsregistrering?

Ansigtsregistrering er computerteknologiens evne til at identificere menneskers ansigter inden for digitale billeder. Ansigtsdetekteringsapplikationer anvender algoritmer, der er fokuseret på at detektere menneskelige ansigter inden for større billeder, der kan indeholde landskaber, genstande osv.

For at arbejde bruger ansigtsgenkendelsesapplikationer maskinlæringsalgoritmer til at registrere menneskelige ansigter i billeder af enhver størrelse. De større billeder kan indeholde adskillige objekter, der ikke vender mod, såsom landskaber, genstande, dyr, bygninger og andre dele af mennesker (f.eks. Ben, skuldre og arme).

Ansigtsdetektering / genkendelsesteknologi var tidligere forbundet med kun sikkerhedssektoren, men i dag er der aktiv ekspansion til andre industrier, herunder detailhandel, marketing, sundhedsvæsen osv.

Hvordan ansigtsgenkendelse fungerer?

Mens processen er noget kompliceret, begynder ansigtsdetekteringsalgoritmer ofte med at søge efter menneskelige øjne. Øjne udgør det, der er kendt som en dalregion, og er en af ​​de nemmeste træk at registrere. Når øjnene er registreret, kan algoritmen derefter forsøge at detektere ansigtsregioner, herunder øjenbryn, mund, næse, næsebor og iris. Når algoritmen antager, at den har registreret et ansigtsregion, kan den derefter anvende yderligere test for at validere, om den faktisk har registreret et ansigt. - https://www.facefirst.com/blog/face-detection-vs-face-recognition/

OpenCV

kilde: https://medium.com/@gsari/digit-recognition-with-opencv-og-python-cbf962f7e2d0

OpenCV (Open Source Computer Vision Library), som er et billed- og videobehandlingsbibliotek med bindinger i C ++, C, Python og Java. OpenCV bruges til alle mulige billed- og videoanalyser, som ansigtsgenkendelse og detektion, nummerpladerlæsning, fotoredigering, avanceret robotvision, optisk karaktergenkendelse og meget mere.

OpenCV har tre indbyggede ansigtsgenkendere, og takket være dens rene kodning kan du bruge en af ​​dem bare ved at ændre en enkelt kodelinie. Her er navnene på disse ansigtsgenkendere og deres OpenCV-opkald:

EigenFaces - cv2.face.createEigenFaceRecognizer ()
FisherFaces - cv2.face.createFisherFaceRecognizer ()
Lokale binære mønstre histogrammer (LBPH) - cv2.face.createLBPHFaceRecognizer ()

Hvordan finder man ansigter ved hjælp af OpenCV?

Der er stort set to primære måder at finde ansigter ved hjælp af OpenCV:

Haar Classifier
LBP Cascade Classifier

De fleste udviklere bruger Haar, fordi det er mere nøjagtigt, men det er også meget langsommere end LBP. Jeg tager også med Haar Classifier til denne tutorial. OpenCV-pakken har faktisk alle de data, du har brug for for at bruge Haar effektivt. Grundlæggende har du bare brug for en XML-fil med de rigtige ansigtsdata i den. Du kan også oprette dine egne, hvis du vidste, hvad du gjorde, eller du bare kan bruge, hvad der følger med OpenCV. For at vide mere om Haar Classifier og LBP Cascade Classifier skal du klikke på dette og dette.

Så nu skriver vi et simpelt python-program, der tager prøvebilleder som input og forsøger at registrere ansigter og øjne ved hjælp af OpenCV. Du kan downloade Haar Classifier XML-fil til ansigtsregistrering og øjenpåvisning her og her og opbevare XML-filer i dit arbejdsmappe.

Afhængigheder:

pip installere numpy
pip installer matplotlib
pip installere opencv-python

Indtast billeder:

Kildekode:

import cv2
import numpy som np
fra matplotlib import pyplot som plt
import glob
txtfiles = []
til fil i glob.glob ("*. jpg"):
    txtfiles.append (fil)
    
til ix i txtfiles:
    img = cv2.imread (ix, cv2.IMREAD_COLOR)
    imgtest1 = img.copy ()
    imgtest = cv2.cvtColor (imgtest1, cv2.COLOR_BGR2GRAY)
    facecascade = cv2.CascadeClassifier ('D: \\ KJ \\ Nagesh \\ Downloads \\ face_recognition \\ haarcascade_frontalface_default.xml')
    eye_cascade = cv2.CascadeClassifier ('D: \\ KJ \\ Nagesh \\ Downloads \\ face_recognition \\ haarcascade_eye.xml')
   
    ansigter = facecascade.detectMultiScale (imgtest, skalafaktor = 1,2, min naboer = 5)
 
    print ('Samlet antal fundne ansigter', len (ansigter))
    
    for (x, y, w, h) i ansigter:
        face_detect = cv2.rectangle (imgtest, (x, y), (x + w, y + h), (255, 0, 255), 2)
        roi_gray = imgtest [y: y + h, x: x + w]
        roi_color = imgtest [y: y + h, x: x + w] plt.imshow (face_detect)
        øjne = eye_cascade.detectMultiScale (roi_gray)
        for (ex, ey, ew, eh) i øjne:
            eye_detect = cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,0,255), 2)
            plt.imshow (eye_detect)

Lad os nu forstå dette enkle program:

Trin 1: Importer numpy, matplotlib, open-cv og glob

import numpy som np
fra matplotlib import pyplot som plt
import cv2
import glob

Trin 2: Brug en glob-loop gennem hver af .jpg-filer, der findes i dit aktuelle arbejdsmappe, og gem dem på en liste 'txtfiles'. Klik her for at vide, hvordan du læser filer ved hjælp af glob.

txtfiles = []
til fil i glob.glob ("*. jpg"):
    txtfiles.append (fil)

Trin 3: Læs hver af .jpg-filerne ved hjælp af cv2.imread (). Funktionen cv2.imread () kræver to argumenter: den første er stien til selve billedet og den anden specificerer måden, billedet skal læses på. Vi kan bruge en af ​​nedenstående tre som vores andet argument.

cv2.IMREAD_COLOR - bruges til at indlæse et farvebillede. Det forsømmer billedets gennemsigtighed og er standardflagget. Det er til 8-bit-billeder, der ikke har alfakanalen.
cv2.IMREAD_GRAYSCALE - ansvarlig for indlæsning af vores billeder i gråtoner.
cv2.IMREAD_UNCHANGED - Det indlæser et billede ved hjælp af alfakanal (RGBA).

Når du indlæser et billede ved hjælp af OpenCV, indlæses det som standard i BGR-farverum.

Lav derefter en kopi af billedet, der er bestået, så det bestilte billede ikke ændres.

img = cv2.imread (ix, cv2.IMREAD_COLOR)
    imgtest1 = img.copy ()

Trin 4: Konverter billedet til gråt billede, da OpenCV-ansigtsdetektor forventer grå billeder.

imgtest = cv2.cvtColor (imgtest1, cv2.COLOR_BGR2GRAY)

Trin 5: Nu skal vi indlæse vores Haar-klassifikatorer (downloadede XML-filer) til ansigtsregistrering og øjenpåvisning, der tager input af træningsfilen for Haar-klassificeren.

facecascade = cv2.CascadeClassifier ('D: \\ KJ \\ Nagesh \\ Downloads \\ face_recognition \\ haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier ('D: \\ KJ \\ Nagesh \\ Downloads \\ face_recognition \\ haarcascade_eye.xml')

trin 6: Hvordan registrerer vi et ansigt fra et billede ved hjælp af CascadeClassifier?

Nå, igen har OpenCV's CascadedClassifier gjort det enkelt for os på grund af detectMultiScale (), der registrerer nøjagtigt, hvad du har brug for.

detectMultiScale (billede, skalaFaktor, min naboer)

Nedenfor er argumenter, der skal videregives til detectMultiScale ().

Dette er en generel funktion til at registrere objekter, i dette tilfælde vil det registrere ansigter, da vi kaldte på ansigtskaskaden. Hvis det finder et ansigt, returnerer det en liste over positioner af nævnte ansigt i formen "Rect (x, y, w, h).", Hvis ikke, returnerer du "None".

  • Billede: Den første input er gråtonebilledet.
  • skalafaktor: Denne funktion kompenserer en falsk opfattelse i størrelse, der opstår, når det ene ansigt ser ud til at være større end det andet, blot fordi det er tættere på kameraet.
  • minNeighbours: Detektionsalgoritme, der bruger et bevægeligt vindue til at registrere objekter, det gør det ved at definere, hvor mange objekter der findes i nærheden af ​​det aktuelle, inden det kan erklære det fundne ansigt.
ansigter = facecascade.detectMultiScale (imgtest, skalafaktor = 1,2, min naboer = 5)

Trin 7: Udskriv nu antallet af ansigter fra hvert billede:

print ('Samlet antal fundne ansigter', len (ansigter))

Trin 8: Gå igennem listen over ansigter, og tegn rektangler på billederne. Her finder vi grundlæggende ansigter, bryder ansigterne, deres størrelser og tegner rektangler

for (x, y, w, h) i ansigter:
face_detect = cv2.rectangle (imgtest, (x, y), (x + w, y + h), (255, 0, 255), 2)
roi_gray = imgtest [y: y + h, x: x + w]
roi_color = imgtest [y: y + h, x: x + w]
plt.imshow (face_detect)

Trin 9: Derefter udfører vi øjedetektion, og den interessante del er, at det sandsynligvis ikke ville finde et øjeæppe til at opdage et øje. De fleste af øjenopdagelsesalgoritmerne bruger den omgivende hud, øjenlåg, øjenvipper og øjenbryn til også at foretage detekteringen.

øjne = eye_cascade.detectMultiScale (roi_gray)
for (ex, ey, ew, eh) i øjne:
eye_detect = cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,0,255), 2)
plt.imshow (eye_detect)

Endelig vores output:

Output-fil: friends.PNGOutput-fil: Leonardo.PNGOutput-fil: Nagesh.PNGOutput-fil: Rahul.PNGOutput-fil: Amar.PNGOutput-fil: Sachin.PNGOutput-fil: Vishak.PNGOutput-fil: Shahrukh.PNGOutput-fil: Dog.PNGOutput-fil: download1.PNG

Fedt nok !!! Er det ikke?

En ting kan du bemærke her, at der i de sidste to output, som vi har, ikke udføres nogen ansigtsgenkendelse, hvilket naturligvis skyldes, at disse to billeder ikke har noget ansigt, der kan registreres. Den ene er et billede af en hund, og den anden er en blå rose.

Konklusion:

Så vi kan se, at vi med bare et par kodelinjer kom i gang med ansigtsregistrering. Herfra kan vi gå videre og oprette en ansigtsgenkendelsesmodel ved hjælp af openCV, som vil forudsige navn og anden information relateret til den pågældende person. Denne blog er til begyndere, der vil bygge noget cool ved hjælp af dette fantastiske programsprog Python.

Der er mange tilgængelige Haar-klassifikatorer til at detektere forskellige menneskelige kropsdele. Tjek det her.

Det er alt sammen i denne blog. Tak for at have læst :)

glad læring !!!

Du kan nå mig ud i LinkedIn.