Realtime gezichtsherkenning: een end-to-end project - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

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 tot stand gekomen 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 real-time toepassingen. Het is dus perfect voor realtime gezichtsherkenning met een camera.

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

1. Gezichtsdetectie en gegevensverzameling
2. Train de herkenning
3. Gezichtsherkenning

Het onderstaande blokdiagram hervat die fasen:

Stap 1: Stuklijst - Stuklijst

Hoofd onderdelen:

1. Raspberry Pi V3 - US$ 32,00
2. 5 Megapixels 1080p Sensor OV5647 Mini Camera Videomodule - 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: Installeer OpenCV 3 + Python op je Raspberry Pi.

Ik heb verschillende handleidingen geprobeerd om OpenCV op mijn Pi te installeren. De tutorial van Adrian 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 die klaar is om onze experimenten op je Pi uit te voeren.

Laten we naar onze virtuele omgeving gaan en bevestigen dat 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 naar onze virtuele omgeving gaan:

werk op cv

Zie je de tekst (cv) voor je prompt, dan ben je in de virtuele cv-omgeving:

(cv) pi@raspberry:~$Adrian vestigt de aandacht op het feit dat de cv Python virtuele omgeving volledig onafhankelijk is 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 u versie 3.5 (of hoger) gebruikt

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

import cv2

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._versie_

De 3.3.0 zou moeten verschijnen (of een superieure versie die in de toekomst kan worden uitgebracht). De bovenstaande Terminal PrintScreen toont de vorige stappen.

Stap 3: Uw camera testen

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

Ik ga ervan uit dat je al een PiCam op je Raspberry Pi hebt geïnstalleerd.

Voer de onderstaande Python-code in op uw IDE:

importeer 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 kantelen 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 break cap.release() cv2.destroyAllWindows() te stoppen

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 de opdracht in om uit te voeren:

python simpleCamTest.py

Om het programma te beëindigen, moet u op de toets [ESC] op uw toetsenbord drukken.

Klik met uw muis op het videovenster voordat u op [ESC] drukt

Bovenstaande foto laat het resultaat zien.

Sommige makers hebben problemen ondervonden bij het openen van de camera (foutmeldingen 'Bevestiging mislukt'). Dat kan gebeuren als de camera niet is ingeschakeld tijdens de installatie van OpenCv en de camerastuurprogramma's dus niet correct zijn geïnstalleerd. Gebruik de opdracht 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.

Om meer te 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 het gebruik 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 paper, "Rapid Object Detection using a Boosted Cascade of Simple Features" in 2001. Het is een op machine learning gebaseerde benadering 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 een detector wordt geleverd. Als u uw eigen classifier wilt trainen voor elk object zoals auto, vliegtuigen enz., kunt u OpenCV gebruiken om er een te maken. De volledige details worden hier gegeven: Cascade Classifier Training.

Als je geen eigen classifier wilt maken, bevat OpenCV al veel vooraf getrainde classifiers voor gezicht, ogen, glimlach, enz. Die XML-bestanden kunnen worden gedownload uit de map haarcascades.

Genoeg theorie, laten we een gezichtsdetector maken met OpenCV!

Download het bestand: faceDetection.py van mijn GitHub.

importeer 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 break cap.release() cv2.destroyAllWindows() te stoppen

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 het vergelijkt met de laatste code die is gebruikt om de camera te testen, zul je merken dat er weinig onderdelen aan zijn toegevoegd. Let op de regel hieronder:

faceCascade = cv2. CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')

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

Vervolgens zullen we onze camera instellen en in de lus onze invoervideo laden 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.
• scaleFactor is de parameter die aangeeft hoeveel de afbeeldingsgrootte wordt verkleind bij elke afbeeldingsschaal. Het wordt gebruikt om de schaalpiramide te maken.
• minNeighbours 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, worden de posities van gedetecteerde gezichten geretourneerd als een rechthoek met de linkerbovenhoek (x, y) en met "w" als Breedte en "h" als Hoogte ==> (x, y, w, H). Zie de bovenstaande afbeelding.

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

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

python faceDetection.py

Het resultaat:

U 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.

Op mijn GitHub vind je andere voorbeelden:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

En op de bovenstaande foto kun je het resultaat zien.

U kunt ook de onderstaande zelfstudie volgen om gezichtsdetectie beter te begrijpen:

Haar Cascade Objectdetectie Gezicht & Oog OpenCV Python-zelfstudie

Stap 5: Gegevens verzamelen

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

GEZICHTSHERKENNING MET 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 Facial RecognitionProject

In deze map moeten we, naast de 3 python-scripts die we voor ons project zullen maken, de Facial Classifier 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) # stel videobreedte in cam.set(4, 480) # stel videohoogte in face_detector = cv2. CascadeClassifier('haarcascade_frontalface_default.xml') # Voor elke persoon, voer één numeriek gezichts-ID in face_id = input('\n voer gebruikers-ID in end press ==> ') print("\n [INFO] Initialiseren van gezichtsopname. Kijk in de camera en wacht …") # Initialiseer het aantal individuele bemonstering van gezichten = 0 while(True): ret, img = cam.read() img = cv2.flip(img, -1) # flip videobeeld verticaal grijs = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) faces = face_detector.detectMultiScale(grijs, 1.3, 5) voor (x, y, w, h) in vlakken: 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/User." + str(face_id) + '.' + str(count) + ".jpg", grey[y:y+ h, x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # Druk op 'ESC' om de video te verlaten als k == 27: break elif count >= 30: # Neem 30 gezichtsmonsters en stop de videopauze # Doe ab it of cleanup print("\n [INFO] Programma afsluiten en dingen opruimen") cam.release() cv2.destroyAllWindows()

De code lijkt erg op de code die we zagen voor gezichtsherkenning. 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", grijs[y:y+h, x:x+w])

Merk op dat voor het opslaan van het bovenstaande bestand, u de bibliotheek "os" moet hebben geïmporteerd. De naam van elk bestand volgt de structuur:

Gebruiker.face_id.count.jpg

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

Gebruiker.1.4.jpg

zoals weergegeven in de bovenstaande foto van mijn Pi. Op mijn code leg ik 30 monsters van elke id vast. U kunt het wijzigen op de laatste "elif". Het aantal monsters wordt gebruikt om de lus te doorbreken waarin de gezichtsmonsters worden vastgelegd.

Voer het Python-script uit en leg een paar id's vast. U moet het script elke keer uitvoeren dat 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/".

Laten we dus beginnen met het maken van een submap waarin we de getrainde gegevens opslaan:

mkdir-trainer

Download van mijn GitHub het tweede python-script: 02_face_training.py

import cv2

importeer numpy als np van PIL import Image import os # Pad voor gezicht afbeelding database path = 'dataset' herkenner = cv2.face. LBPHFaceRecognizer_create() detector = cv2. CascadeClassifier("haarcascade_frontalface_default.xml"); # functie om de afbeeldingen en labelgegevens te krijgen def getImagesAndLabels(path): imagePaths = [os.path.join(path, f) for f in os.listdir(path)] faceSamples= ids = for imagePath in imagePaths: PIL_img = Image.open(imagePath).convert('L') # converteer het naar grijswaarden img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1]. split(".")[1]) faces = detector.detectMultiScale(img_numpy) for (x, y, w, h) in faces: faceSamples.append(img_numpy[y:y+h, x:x+w]) ids.append(id) return faceSamples, ids print ("\n [INFO] Gezichten trainen. Het duurt een paar seconden. Wacht …") faces, ids = getImagesAndLabels(pad) herkenner.train(gezichten, np.array(ids)) # Sla het model op in trainer/trainer.yml herkenner.write('trainer/trainer.yml') # herkenner.save() werkte op Mac, maar niet op Pi # Druk het aantal getrainde gezichten af en beëindig het afdrukken van het programma ("\n [INFO] {0} gezichten getraind. Programma verlaten".format(len(np.unique(ids))))

Controleer of u de PIL-bibliotheek op uw Rpi hebt geïnstalleerd. Als dat niet het geval is, voert u de onderstaande opdracht uit in Terminal:

pip installeren kussen

We zullen als herkenner de LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) gezichtsherkenning gebruiken, die is opgenomen in het OpenCV-pakket. Dit doen we in de volgende regel:

herkenner = cv2.face. LBPHFaceRecognizer_create()

De functie "getImagesAndLabels (path)", zal alle foto's nemen in de directory: "dataset/", waarbij 2 arrays worden geretourneerd: "Ids" en "faces". Met die arrays als invoer, zullen we "onze herkenner trainen":

herkenner.trein(gezichten, id's)

Als gevolg hiervan wordt een bestand met de naam "trainer.yml" opgeslagen in de trainermap die eerder door ons is gemaakt.

Dat is het! Ik heb de laatste afdrukverklaring bijgevoegd die ik ter bevestiging heb weergegeven, het aantal gezichten van de gebruiker dat we hebben getraind.

Elke keer dat u Fase 1 uitvoert, moet Fase 2 ook worden uitgevoerd

Stap 7: Herkenner

Nu zijn we in de laatste fase van ons project aangekomen. Hier zullen we een nieuw gezicht op onze camera vastleggen en als deze persoon zijn gezicht eerder heeft laten vastleggen en trainen, zal onze herkenner een "voorspelling" doen die zijn ID en een index retourneert, om te laten zien hoe zeker de herkenner is met deze match.

Laten we het python-script van de derde fase downloaden van mijn GitHub: 03_face_recognition.py.

import cv2

import numpy als np import os herkenner = cv2.face. LBPHFaceRecognizer_create() herkenner.read('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier(cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # namen gerelateerd aan ids: voorbeeld ==> Marcelo: id=1, etc names = ['None', 'Marcelo', 'Paula', 'Ilza', 'Z ', 'W'] # Initialiseer en start realtime video-opname cam = cv2. VideoCapture(0) cam.set(3, 640) # stel videobreedte in cam.set(4, 480) # stel videohoogte in # Definieer min venstergrootte te herkennen als een gezicht minW = 0.1*cam.get(3) minH = 0.1*cam.get(4) while True: ret, img =cam.read() img = cv2.flip(img, -1) # Verticaal grijs spiegelen = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale(grey, scaleFactor = 1.2, minNeighbours = 5, minSize = (int(minW), int(minH)),) for(x, y, w, h) in gezichten: cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, vertrouwen = herkenner.predict(grijs[y:y+h, x:x+w]) # Controleer of het vertrouwen minder is dan ze 100 ==> "0" is een perfecte match if (betrouwbaarheid < 100): id = name[id] vertrouwen = " {0}% ".format(round(100 - vertrouwen)) else: id = "onbekend" vertrouwen = " {0}%".format(round(100 - conf idence)) cv2.putText(img, str(id), (x+5, y-5), lettertype, 1, (255, 255, 255), 2) cv2.putText(img, str(vertrouwen), (x+5, y+h-5), lettertype, 1, (255, 255, 0), 1) cv2.imshow('camera', img) k = cv2.waitKey(10) & 0xff # Druk op 'ESC' voor het verlaten van de video if k == 27: break # Doe een beetje opruiming print("\n [INFO] Programma afsluiten en dingen opruimen") cam.release() cv2.destroyAllWindows()

We nemen hier een nieuwe array op, dus we zullen "namen" weergeven in plaats van genummerde id's:

namen = ['Geen', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Dus bijvoorbeeld: Marcelo zal de gebruiker met id = 1; Paula: id=2, enz.

Vervolgens zullen we een gezicht detecteren, hetzelfde als we eerder deden met de haasCascade-classificator. Met een gedetecteerd gezicht kunnen we de belangrijkste functie in de bovenstaande code noemen:

id, vertrouwen = herkenner.predict (grijze gedeelte van het gezicht)

De herkenner.predict (), zal een vastgelegd deel van het te analyseren gezicht als parameter nemen en de waarschijnlijke eigenaar teruggeven, met vermelding van zijn id en hoeveel vertrouwen de herkenner heeft met betrekking tot deze overeenkomst.

Merk op dat de betrouwbaarheidsindex "nul" retourneert als deze als een perfecte match wordt beschouwd

En ten slotte, als de herkenner een gezicht zou kunnen voorspellen, plaatsen we een tekst over de afbeelding met de waarschijnlijke id en hoeveel is de "waarschijnlijkheid" in % dat de overeenkomst correct is ("waarschijnlijkheid" = 100 - betrouwbaarheidsindex). Zo niet, dan wordt er een "onbekend" label op het gezicht gezet.

Hieronder een-g.webp

Op de bovenstaande foto laat ik enkele tests zien die met dit project zijn gedaan, waarbij ik ook foto's heb gebruikt om te controleren of de herkenner werkt.

Stap 8: Conclusie

Zoals altijd hoop ik dat dit project anderen kan helpen hun weg te vinden in de opwindende wereld van elektronica!

Ga voor meer informatie en de definitieve code naar mijn GitHub-depot: OpenCV-Face-Recognition

Ga voor meer projecten naar mijn blog: MJRoBot.org

Hieronder een glimp van een toekomstige tutorial, waarin we "automatische gezichtsherkenning en andere methoden voor gezichtsdetectie" zullen onderzoeken:

Saludos uit het zuiden van de wereld!

Tot ziens in mijn volgende instructable!

Bedankt, Marcelo