Realtime gezichtsherkenning:een end-to-end project

We zullen stap voor stap leren hoe we een PiCam kunnen gebruiken om gezicht in realtime te herkennen. Tijdens mijn laatste tutorial waarin ik OpenCV verkende, leerden we AUTOMATIC VISION OBJECT TRACKING.

Nu gaan we onze PiCam gebruiken om gezichten in realtime te herkennen, zoals je hieronder kunt zien:

Dit project is gedaan met deze fantastische "Open Source Computer Vision Library", de OpenCV. In deze tutorial zullen we ons concentreren op Raspberry Pi (dus Raspbian als OS) en Python, maar ik heb de code ook getest op My Mac en het werkt ook prima. OpenCV is ontworpen voor rekenefficiëntie en met een sterke focus op realtime toepassingen. Het is dus perfect voor realtime gezichtsherkenning met een camera.

3 fasen

Om een ​​compleet project over gezichtsherkenning te creëren, moeten we aan 3 zeer verschillende fasen werken:

• Gezichtsdetectie en gegevensverzameling

• Train de herkenning

• Gezichtsherkenning

Het onderstaande blokschema vat deze fasen samen:

Stap 1:Stuklijst – Stuklijst

Belangrijkste onderdelen:

• Raspberry Pi V3 - US$ 32,00

• 5 Megapixel 1080p Sensor OV5647 Mini Camera Video Module - US$ 13,00

Stap 2:OpenCV 3-pakket installeren

Ik gebruik een Raspberry Pi V3 die is bijgewerkt naar de laatste versie van Raspbian (Stretch), dus de beste manier om OpenCV te installeren, is door de uitstekende tutorial te volgen die is ontwikkeld door Adrian Rosebrock: Raspbian Stretch:Install OpenCV 3 + Python op je Raspberry Pi.

Ik heb verschillende handleidingen geprobeerd om OpenCV op mijn Pi te installeren. Adrian's tutorial is de beste. Ik raad je aan hetzelfde te doen en zijn richtlijn stap voor stap te volgen.

Als je de tutorial van Adrian hebt voltooid, zou je een virtuele OpenCV-omgeving moeten hebben om onze experimenten op je Pi uit te voeren.

Laten we naar onze virtuele omgeving gaan en controleren of OpenCV 3 correct is geïnstalleerd.

Adrian raadt aan om elke keer dat je een nieuwe terminal opent het commando "source" uit te voeren om er zeker van te zijn dat je systeemvariabelen correct zijn ingesteld.

bron ~/.profile

Laten we vervolgens onze virtuele omgeving invoeren:

werk op cv

Als u de tekst (cv) voor uw prompt ziet, bevindt u zich in de cv virtual omgeving:

(cv) pi@raspberry:~$

Adrian vestigt de aandacht op de cv Python virtuele omgeving is volledig onafhankelijk en afgezonderd van de standaard Python-versie die is opgenomen in de download van Raspbian Stretch. Dus alle Python pakketten in de globale site-packages directory zullen niet beschikbaar zijn voor de cv virtuele omgeving. Evenzo zullen alle Python-pakketten die zijn geïnstalleerd in site-pakketten van cv niet beschikbaar zijn voor de algemene installatie van Python.

Voer nu uw Python-interpreter in:

python

en bevestig dat je versie 3.5 (of hoger) gebruikt.

In de interpreter (de ">>>" zal verschijnen), importeer de OpenCV-bibliotheek:

cv2 importeren

Als er geen foutmeldingen verschijnen, is de OpenCV correct geïnstalleerd OP UW VIRTUELE PYTHON-OMGEVING.

U kunt ook de geïnstalleerde OpenCV-versie controleren:

cv2.__version__

De 3.3.0 zou moeten verschijnen (of een betere versie die in de toekomst kan worden uitgebracht).

De bovenstaande Terminal PrintScreen toont de vorige stappen.

Stap 3:Uw camera testen

Zodra OpenCV in uw RPi is geïnstalleerd, gaan we testen of uw camera correct werkt.

Ik neem aan dat je al een PiCam op je Raspberry Pi hebt geïnstalleerd.

Je moet de camera hebben ingeschakeld toen je Adrian's tutorial doorliep, anders worden de stuurprogramma's niet correct geïnstalleerd.

In het geval u een foutmelding krijgt zoals: OpenCV-fout:bevestiging mislukt , kunt u proberen het probleem op te lossen met het commando:

sudo modprobe bcm2835-v4l2

Zodra u alle stuurprogramma's correct hebt geïnstalleerd, voert u de onderstaande Python-code in uw IDE in:

import numpy als np
import cv2
cap =cv2.VideoCapture(0)
cap.set(3.640) # set Width
cap.set(4.480) # set Height
while(True):
ret, frame =cap.read()
frame =cv2.flip(frame, -1) # Camera verticaal draaien
grijs =cv2.cvtColor(frame , cv2.COLOR_BGR2GRAY)

cv2.imshow(‘frame’, frame)
cv2.imshow(‘grijs’, grijs)

k =cv2.waitKey(30) &0xff
if k ==27:# druk op 'ESC' om te stoppen
break
cap.release()
cv2.destroyAllWindows()

De bovenstaande code legt de videostream vast die wordt gegenereerd door uw PiCam, waarbij beide worden weergegeven, in BGR-kleur en grijsmodus.

Merk op dat ik mijn camera verticaal heb gedraaid vanwege de manier waarop deze is gemonteerd. Als dit niet jouw geval is, becommentarieer of verwijder de "flip"-opdrachtregel.

Je kunt de code ook downloaden van mijn GitHub: simpleCamTest.py

Voer het commando in om uit te voeren:

python simpleCamTest.py

Om het programma te beëindigen, moet je op de toets [ESC] op je toetsenbord drukken. Klik met uw muis op het videovenster voordat u op [ESC] drukt.

De bovenstaande afbeelding toont het resultaat.

Sommige makers hebben problemen gevonden bij het openen van de camera (foutmeldingen 'Bevestiging mislukt'). Dat kan gebeuren als de camera niet was ingeschakeld tijdens de OpenCv-installatie en de camerastuurprogramma's dus niet correct zijn geïnstalleerd. Gebruik het commando om te corrigeren:

sudo modprobe bcm2835-v4l2

Je kunt ook bcm2835-v4l2 toevoegen aan de laatste regel van het bestand /etc/modules, zodat het stuurprogramma wordt geladen bij het opstarten.

Als je meer wilt weten over OpenCV, kun je de tutorial volgen: loading -video-python-opencv-tutorial

Stap 4:Gezichtsdetectie

De meest elementaire taak voor gezichtsherkenning is natuurlijk 'Gezichtsdetectie'. Voor alles moet je een gezicht "vastleggen" (fase 1) om het te herkennen, in vergelijking met een nieuw gezicht dat in de toekomst is vastgelegd (fase 3).

De meest gebruikelijke manier om een ​​gezicht (of andere objecten) te detecteren, is met behulp van de “Haar Cascade classifier“

Objectdetectie met behulp van op Haar kenmerken gebaseerde cascadeclassificaties is een effectieve objectdetectiemethode die is voorgesteld door Paul Viola en Michael Jones in hun artikel "Rapid Object Detection using a Boosted Cascade of Simple Features" in 2001. Het is is een op machine learning gebaseerde aanpak waarbij een cascadefunctie wordt getraind uit veel positieve en negatieve beelden. Het wordt vervolgens gebruikt om objecten in andere afbeeldingen te detecteren.

Hier gaan we werken met gezichtsherkenning. In eerste instantie heeft het algoritme veel positieve afbeeldingen (afbeeldingen van gezichten) en negatieve afbeeldingen (afbeeldingen zonder gezichten) nodig om de classifier te trainen. Dan moeten we er functies uit halen. Het goede nieuws is dat OpenCV zowel met een trainer als met een detector wordt geleverd. Als je je eigen classifier wilt trainen voor elk object zoals auto, vliegtuigen enz., kun je OpenCV gebruiken om er een te maken. De volledige details worden hier gegeven: Cascade Classifier-training.

Als u niet uw eigen classificatie wilt maken, bevat OpenCV al veel vooraf getrainde classificaties voor gezicht, ogen, glimlach, enz. Die XML-bestanden kunnen worden gedownload van de map Haarcascades.

Genoeg theorie, laten we een gezichtsdetector maken met OpenCV!

Download het bestand: faceDetection.py van mijn GitHub.

import numpy als np
import cv2
faceCascade =cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
cap =cv2.VideoCapture(0)
cap.set(3.640) # set Width
cap.set(4.480) # set Height
while True:
ret, img =cap.read()
img =cv2.flip(img, –1 )
grijs =cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces =faceCascade.detectMultiScale(
grijs,
scaleFactor=1.2,
minNeighbors=5,
minSize=(20, 20)
)
voor (x,y,w,h) in vlakken:
cv2.rectangle(img,(x,y),(x +w,y+h),(255,0,0),2)
roi_gray =grijs[y:y+h, x:x+w]
roi_color =img[y:y+ h, x:x+w]
cv2.imshow('video',img)
k =cv2.waitKey(30) &0xff
if k ==27:# druk op 'ESC ' om te stoppen
break
cap.release()
cv2.destroyAllWindows()

Geloof het of niet, de bovenstaande paar regels code zijn alles wat je nodig hebt om een ​​gezicht te detecteren, met Python en OpenCV.

Als je vergelijkt met de laatste code die is gebruikt om de camera te testen, zul je je realiseren dat er maar weinig onderdelen aan zijn toegevoegd. Let op de onderstaande regel:

faceCascade =cv2.CascadeClassifier(‘Cascades/haarcascade_frontalface_default.xml’)

Dit is de regel die de "classifier" laadt (die in een map met de naam "Cascades/" moet staan, onder uw projectmap).

Vervolgens stellen we onze camera in en in de loop, laden we onze invoervideo in grijswaardenmodus (hetzelfde als we eerder zagen).

Nu moeten we onze classificatiefunctie aanroepen en deze enkele zeer belangrijke parameters doorgeven, zoals schaalfactor, aantal buren en minimale grootte van het gedetecteerde gezicht.

gezichten =faceCascade.detectMultiScale(
grijs,
scaleFactor=1.2,
minNeighbours=5,
minSize=(20, 20)
)

Waar,

• grijs is de ingevoerde grijswaardenafbeelding.

• schaalfactor is de parameter die aangeeft hoeveel de afbeeldingsgrootte wordt verkleind bij elke afbeeldingsschaal. Het wordt gebruikt om de schaalpiramide te maken.

• min Buren is een parameter die aangeeft hoeveel buren elke kandidaat-rechthoek moet hebben om deze te behouden. Een hoger getal geeft minder valse positieven.

• minSize is de minimale rechthoekgrootte om als een gezicht te worden beschouwd.

De functie detecteert gezichten op de afbeelding. Vervolgens moeten we de gezichten in de afbeelding "markeren", bijvoorbeeld met een blauwe rechthoek. Dit wordt gedaan met dit gedeelte van de code:

voor (x,y,w,h) in vlakken:
cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray =grijs[y:y+h, x:x+w]
roi_color =img[y:y+h, x:x+w]

Als er gezichten worden gevonden, retourneert het de posities van gedetecteerde gezichten als een rechthoek met de linkerbovenhoek (x,y) en met "w" als Breedte en "h" als Hoogte ==> (x,y,w,h). Zie de foto.

Zodra we deze locaties hebben gevonden, kunnen we een 'ROI' (getekende rechthoek) voor het gezicht maken en het resultaat presenteren met imshow()  functie.

Voer het bovenstaande python-script uit in uw python-omgeving met behulp van de Rpi-terminal:

python faceDetection.py

Het resultaat:

Je kunt ook classificaties opnemen voor 'oogdetectie' of zelfs 'glimlachdetectie'. In die gevallen neemt u de classificatiefunctie en rechthoektekening op in de gezichtslus, omdat het geen zin heeft om een ​​oog of een glimlach buiten een gezicht te detecteren.

Merk op dat op een Pi, het hebben van meerdere classifiers bij dezelfde code de verwerking zal vertragen, zodra deze detectiemethode (HaarCascades) een grote hoeveelheid rekenkracht gebruikt. Op een desktop is het gemakkelijker om het uit te voeren.

Voorbeelden

Op mijn GitHub vind je andere voorbeelden:

• faceEyeDetection.py

• faceSmileDetection.py

• faceSmileEyeDetection.py

En op de foto kun je het resultaat zien.

Je kunt ook de onderstaande tutorial volgen om gezichtsdetectie beter te begrijpen:

Haar Cascade Objectdetectie Gezicht &Oog OpenCV Python-zelfstudie

Stap 5:Gegevens verzamelen

Allereerst wil ik Ramiz Raja bedanken voor zijn geweldige werk aan gezichtsherkenning op foto's:

GEZICHTSHERKENNING BIJ OPENCV EN PYTHON:EEN BEGINNERSGIDS

en ook Anirban Kar, die een zeer uitgebreide tutorial met video ontwikkelde:

GEZICHTSHERKENNING – 3 delen

Ik raad je echt aan om beide tutorials te bekijken.

Dat gezegd hebbende, laten we beginnen met de eerste fase van ons project. Wat we hier zullen doen, is beginnen bij de laatste stap (Gezichtsdetectie), we zullen eenvoudig een dataset maken, waar we voor elke id een groep foto's in grijs zullen opslaan met het gedeelte dat werd gebruikt voor gezichtsdetectie.

Maak eerst een map waarin u uw project ontwikkelt, bijvoorbeeld FacialRecognitionProject:

mkdir FacialRecognitionProject

In deze map moeten we, naast de 3 python-scripts die we voor ons project zullen maken, de Facial Classifier erin hebben opgeslagen. Je kunt het downloaden van mijn GitHub: haarcascade_frontalface_default.xml

Maak vervolgens een submap waarin we onze gezichtsmonsters opslaan en noem deze "dataset":

mkdir-gegevensset

En download de code van mijn GitHub: 01_face_dataset.py

import cv2
import os
cam =cv2.VideoCapture(0)
cam.set(3, 640) # set video width
cam.set(4, 480) # set videohoogte
face_detector =cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
# Voer voor elke persoon één numeriek gezichts-ID in
face_id =input('\n voer gebruikers-ID in en druk op ==> ')
print(“\n [INFO] Gezichtsopname initialiseren. Kijk in de camera en wacht …”)
# Initialiseer individuele bemonstering van gezichten
count =0
while(True):
ret, img =cam.read()
img =cv2.flip(img, -1) # videobeeld verticaal omdraaien
grijs =cv2.cvtColor(img , cv2.COLOR_BGR2GRAY)
faces =face_detector.detectMultiScale(gray, 1.3, 5)
for (x,y,w,h) in faces:
cv2.rectangle(img, (x ,y), (x+w,y+h), (255,0,0), 2)
count +=1
# Sla de vastgelegde afbeelding op in de map datasets
cv2 .imwrite(“dataset/gebruiker.” + str(face_id) + '.' + str(count) + “.jpg”, grey[y:y+h,x:x+w])
cv2. imshow('afbeelding', img)
k =cv2.waitKey(100) &0x ff # Druk op 'ESC' om de video af te sluiten
if k ==27:
break
elif count>=30:# Neem 30 gezichtssamples en stop de video
break
# Doe een beetje opruiming
print(“\n [INFO] Programma afsluiten en dingen opruimen”)
cam.release()
cv2.destroyAllWindows()

De code lijkt erg op de code die we hebben gezien voor gezichtsdetectie. Wat we hebben toegevoegd, was een "invoeropdracht" om een ​​gebruikers-ID vast te leggen, dat zou een geheel getal moeten zijn (1, 2, 3, enz.)

face_id =input(‘\n voer gebruikers-ID in en druk op ==> ‘)

En voor elk van de vastgelegde frames moeten we het opslaan als een bestand in een "dataset" -directory:

cv2.imwrite(“dataset/gebruiker.” + str(face_id) + ‘.’ + str(count) + “.jpg”, grey[y:y+h,x:x+w])

Merk op dat om het bovenstaande bestand op te slaan, je de bibliotheek "os" moet hebben geïmporteerd. De naam van elk bestand volgt de structuur:

User.face_id.count.jpg

Bijvoorbeeld, voor een gebruiker met een face_id =1, zal het 4e voorbeeldbestand in de dataset/ directory er ongeveer zo uitzien:

Gebruiker.1.4.jpg

zoals getoond op de foto van mijn Pi:

In mijn code leg ik 30 voorbeelden van elke id vast. U kunt het wijzigen op de laatste "elif". Het aantal samples wordt gebruikt om de lus te doorbreken waarin de gezichtssamples worden vastgelegd.

Voer het Python-script uit en leg een paar ID's vast. U moet het script telkens uitvoeren als u een nieuwe gebruiker wilt verzamelen (of om de foto's te wijzigen voor een die al bestaat).

Stap 6:Trainer

In deze tweede fase moeten we alle gebruikersgegevens uit onze dataset halen en de OpenCV-herkenning 'trainen'. Dit wordt rechtstreeks gedaan door een specifieke OpenCV-functie. Het resultaat is een .yml-bestand dat wordt opgeslagen in een map "trainer/".

Lees meer details:Realtime gezichtsherkenning:een end-to-end project