Phenquestions
Raspberry Pi är en billig minidator som har gjort datorer och programmering mycket enklare för de flesta, inklusive studenter och hobbyister. Denna minidator kan göra allt som en stationär dator kan göra, från att surfa på internet till att göra spännande projekt och program. Och ett av dessa fantastiska projekt gör en Raspberry Pi Face Recognition. Även om detta projekt kan vara mycket intressant är det inte så enkelt att göra. Så jag skulle rekommendera dig att följa artikeln steg för steg.
Raspberry Pi ansiktsigenkänning
Att göra ett ansiktsigenkänningsprogram kan ha varit en mycket svår och avancerad sak en gång. Men med Raspberry Pi är ingenting för svårt! I denna artikel har jag använt Open Source Computer Vision Library (OpenCV) för att göra projektet.
Detta arkiv har utformats för att fungera med beräkningseffektivitet och realtidsapplikationer. Därför är det perfekt för vårt program för ansiktsigenkänning i realtid. Den här artikeln guidar dig steg för steg genom hela projektet. Så håll dig i slutet för att få din egen Raspberry Pi Face Recognition!
Krav
Du behöver följande saker för att skapa ett Raspberry Pi-ansiktsigenkänningssystem:
- Raspberry Pi V4
- Noir-kamera
- OpenCV
Raspberry Pi-anslutningar
Se till att skapa följande anslutningar innan du börjar koda:
- Gör anslutningar mellan Raspberry Pi och Ribbon-kabeln från Display
- Fäst SDA till SDA-stiftet på din Pi
- Sätt SCL från display till SCL-stift
- Anslut kamerans bandkabel till Raspberry Pi
- Sätt in GND från skärmen i Pi GND
- Anslut Raspberry Pi 5V och skärmens 5V
Steg 1: Installera OpenCV på Raspberry Pi
Det första steget är att installera OpenCV på din Pi-enhet. För att göra det, starta din Raspberry Pi och öppna en SSH-anslutning. För att inkludera allt tillgängligt utrymme på micro-SD-kortet, expandera ditt filsystem.
$ sudo raspi-config
Välj sedan "Avancerade alternativ" från menyn och "Expand Filesystem" efteråt:
Efter det, slå på “
$ sudo omstart
Steg 2: Bekräfta OpenCV-installationen
När du har startat om bör det finnas en klar OpenCV-virtuell miljö på din Pi. Nu bör du bekräfta om OpenCV är korrekt installerad i din Pi. Kör kommandot "source" varje gång du öppnar en ny terminal så att systemvariablerna är korrekt inställda.
källa ~ /.profil
Gå nu in i din virtuella miljö:
workon cv
(Cv) texten betyder att du befinner dig i cv virtuell miljö.
(cv) pi @ hallon: ~ $
Så här skriver du in din Python-tolk:
pytonorm
Du kommer att se ett “>>>” visas i tolken. Så här importerar du OpenCV-biblioteket:
importera cv2
Om det inte finns några felmeddelanden kan du vara säker på att OpenCV är korrekt installerat.
Steg 3: Ladda ner OpenCV
Ladda nu ner din installerade OpenCV. Du måste ladda ner både OpenCV och OpenCV-bidrag. Bidraget kommer med moduler och funktioner som du behöver i detta experiment.
$ cd ~ $ wget -O opencv.zip https: // github.com / opencv / opencv / archive / 4.0.0.zip $ wget -O opencv_contrib.zip https: // github.com / opencv / opencv_contrib / arkiv / 4.0.0.blixtlås
Packa nu upp arkiven:
$ unzip opencv.zip $ unzip opencv_contrib.blixtlås
Steg 4: Installera beroenden
Installera nu nödvändiga OpenCV-beroenden på din Raspberry Pi för att få det att fungera ordentligt:
$ sudo apt-get update && sudo apt-get upgrade $ sudo apt-get install build-essential cmake pkg-config $ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng-dev $ sudo apt-get install libavcodec -dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev $ sudo apt-get install libgtk2.0-dev libgtk-3-dev $ sudo apt-get install libfontconfig1-dev libcairo2-dev $ sudo apt-get install libgdk-pixbuf2.0-dev libpango1.0-dev $ sudo apt-get install libhdf5-dev libhdf5-serial-dev libhdf5-103 $ sudo apt-get install libqtgui4 libqtwebkit4 libqt4-test python3-pyqt5 $ sudo apt-get install libatlas-base-dev gfortran $ sudo apt- få installera python2.7-dev python3-dev $ sudo apt-get install python3-pil.imagetk
Steg 5: Installera pip
I det här steget måste du installera en pakethanterare för python som heter "pip".
$ wget https: // bootstrap.pypa.io / get-pip.py $ sudo python3 get-pip.py
Steg 6: Installera Numpy
Installera sedan ett pythonbibliotek som heter “Numpy”.
$ Pip3 installera bedövad
Steg 7: Testa kameran
Nu när du har installerat alla nödvändiga saker, inklusive OpenCV, är det dags att kontrollera om din kamera fungerar som den ska. Du borde redan ha en Picam installerad på din Raspberry Pi. Ange följande kod på din Python IDE:
importera numpy som np importera cv2 cap = cv2.VideoCapture (0) lock.set (3,640) # set Breddlock.set (4480) # set Höjd medan (True): ret, frame = cap.läs () ram = cv2.vänd (ram, -1) # Vänd kameran vertikalt grå = cv2.cvtColor (ram, cv2.COLOR_BGR2GRAY) cv2.imshow ('ram', ram) cv2.imshow ('grå', grå) k = cv2.waitKey (30) & 0xff om k == 27: # tryck på 'ESC' för att avsluta break cap.släpp () cv2.destroyAllWindows () Den här koden fungerar genom att fånga den videoström som genereras av din PiCam som visar både Grå-läge och BGR-färgläge. Kör sedan koden med följande kommando:
python simpleCamTest.py
Tryck nu på [ESC] för att avsluta programmet. Se till att klicka på videofönstret innan du avslutar det. Du bör nu se att din kamera fungerar korrekt och visar resultat. Om felmeddelandena "Assertion failed" visas på din kamera kan du använda följande kommando för att åtgärda det:
sudo modprobe bcm2835-v4l2
Steg 8: Ansiktsavkänning
Du bör veta att det första steget för att slutföra vårt ansiktsigenkänningsprojekt är att få PiCam att fånga ett ansikte. Visst måste den först upptäcka ett ansikte för att känna igen det i framtiden.
Ansiktsdetekteringsalgoritmen kräver bilder med ansiktet såväl som utan ansiktet för att träna klassificeraren och spara strukturer från dem. Lyckligtvis kommer OpenCV som du laddade ner i förväg med en detektor och tränare. Dessutom har den redan några förutbildade klassificeringsapparater som ansikte, ögon, händer osv. Använd följande koder för att skapa en ansiktsdetektor med OpenCV:
importera numpy som np importera cv2 faceCascade = cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.'.xml ') cap = cv2.VideoCapture (0) lock.set (3,640) # set Breddlock.set (4480) # set Height while True: ret, img = cap.läs () img = cv2.vänd (img, -1) grå = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansikten = faceCascade.detectMultiScale (grå, skalaFaktor = 1.2, minNeighbors = 5, minSize = (20, 20)) för (x, y, w, h) i ansikten: cv2.rektangel (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = grå [y: y + h, x: x + w] roi_color = img [ y: y + h, x: x + w] cv2.imshow ('video', img) k = cv2.waitKey (30) & 0xff om k == 27: # tryck på 'ESC' för att avsluta break cap.släpp () cv2.destroyAllWindows () Nu måste du ringa klassificeringsfunktionen med några skalfaktorer, parametrar och en minsta storlek på ansiktet som den kommer att upptäcka.
ansikten = faceCascade.detectMultiScale (grå, skalaFaktor = 1.2, minNeighbors = 5, minSize = (20, 20))
Den här koden fungerar genom att detektera ansikten på en bild. Nu kanske du vill markera ansikten med en form som en rektangel. Använd följande kod för att göra det:
för (x, y, w, h) i ansikten: cv2.rektangel (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = grå [y: y + h, x: x + w] roi_color = img [ y: y + h, x: x + w]
Så det är så det fungerar:
Om klassificeraren hittar några ansikten i bilden, visar den ansiktspositionerna som en rektangel enligt kommandot där det använder “h” som höjd och “w” som bredden och de vänstra hörnen (x, y). Det summerar ganska mycket vår rektangel (x, y, w, h).
Nu när du är klar med platserna, skapa en “ROI” för ansiktet och visa resultatet med imshow () -funktionen. Kör den på pythonmiljön med hjälp av Raspberry Pi Terminal:
python faceDetection.py
Och resultatet:
Steg 9: Spara data
I den här delen måste du skapa en datauppsättning där ditt program kommer att spara de insamlade uppgifterna om ID för ansiktet som det har upptäckt. För att göra det, skapa en katalog (jag använder FacialRecognition):
mkdir Ansiktsigenkänning
Skapa nu en underkatalog med namnet "dataset".
mkdir dataset
Använd sedan följande kod:
importera cv2 import os cam = cv2.VideoCapture (0) kamera.set (3, 640) # set videobreddkamera.set (4, 480) # set video height face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ') # För varje person anger du ett numeriskt ansikts-id face_id = input (' \ n anger användar-ID och tryck ==> ') skriv ut ("\ n [INFO] Initiera ansiktsfångst. Titta på kameran och vänta ... ") # Initiera individuell antal ansiktsantal = 0 medan (True): ret, img = cam.läs () img = cv2.vänd (bild, -1) # vänd videobild vertikalt grå = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansikten = ansiktsdetektor.detectMultiScale (grå, 1.3, 5) för (x, y, w, h) i ansikten: cv2.rektangel (img, (x, y), (x + w, y + h), (255,0,0), 2) count + = 1 # Spara den tagna bilden i datamängden mapp cv2.imwrite ("dataset / User."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w]) cv2.imshow ('bild', img) k = cv2.waitKey (100) & 0xff # Tryck på 'ESC' för att avsluta video om k == 27: bryt elifantal> = 10: # Ta 10 ansiktsprov och stoppa videopaus # Gör lite rengöringsutskrift ("\ n [INFO] Avslutande program och sanering grejer ") cam.släpp () cv2.destroyAllWindows () Observera att vi kommer att spara var och en av de fångade ramarna som en fil i underkatalogen "dataset":
cv2.imwrite ("dataset / User."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w]) Därefter måste du importera biblioteket “os” för att spara ovanstående fil. Filernas namn kommer att följa en struktur så här:
Användare.face_id.räkna.jpg, / pre>
Koden som nämns ovan tar bara 10 bilder för varje id. Du kan säkert ändra det om du vill.
Försök nu köra programmet och fånga några ID. Se till att köra koden varje gång du byter användare eller befintligt foto.
Steg 10: Tränare
I det här steget måste du använda en OpenCV-funktion för att träna OpenCV-igenkännaren med data från din dataset. Börja med att skapa en underkatalog för att lagra utbildad data.
mkdir tränare
Kör sedan följande kod:
importera cv2 import numpy som np från PIL import Bildimport os # Sökväg för ansiktsbild databasväg = 'dataset' igenkännare = cv2.ansikte.LBPHFaceRecognizer_create () detektor = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml "); # -funktion för att få bilderna och märka data 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 = [] ids = [] för imagePath i imagePaths: PIL_img = Image.öppna (imagePath).convert ('L') # konvertera den till gråskala 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: faceSamples.lägg till (img_numpy [y: y + h, x: x + w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Tränings ansikten. Det tar några sekunder. Vänta ... ") ansikten, ids = getImagesAndLabels (sökväg) igenkännare.tåg (ansikten, np.array (ids)) # Spara modellen i tränare / tränare.yml-igenkänning.skriv ('tränare / tränare.yml ') # igenkännare.save () fungerade på Mac, men inte på Pi # Skriv ut antalet tränade ansikten och avsluta programutskrift ("\ n [INFO] 0 tränade ansikten. Avslutar programmet ".format (len (np.unik (id)))) Se till att du har installerat PIL-biblioteket på din Raspberry Pi. Om du inte har det, kör följande kommando:
pip installera kudde
Här använder jag LBPH ansiktsigenkänning som ingår i OpenCV-paketet. Följ nu den här raden:
igenkännare = cv2.ansikte.LBPHFaceRecognizer_create ()
Alla dina foton tas till katalogen ”dataset” med funktionen ”getImagesAndLabels”. Den returnerar två matriser med namnet "Ids" och "ansikten". Nu är det dags att träna igenkännaren.
igenkännare.träna (ansikten, id)
Nu kommer du att se ”tränaren.yml ”namngiven fil sparad i tränarkatalogen.
Steg 11: Ansiktsigenkänning
Det är dags för den sista åtgärden. Efter detta steg kan din igenkännare gissa ett återkommande ID om ansiktet fångades tidigare. Så, låt oss skriva vår slutliga kod:
importera cv2 importera numpy som np import os igenkännare = cv2.ansikte.LBPHFaceRecognizer_create () igenkännare.läs ('tränare / tränare.yml ') cascadePath = "haarcascade_frontalface_default.xml "faceCascade = cv2.CascadeClassifier (cascadePath); font = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # namn relaterade till ids: exempel ==> Marcelo: id = 1, etc names = ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Initiera och starta videoinspelningskamera i realtid = cv2.VideoCapture (0) kamera.set (3, 640) # set video widht cam.set (4, 480) # set video height # Definiera min fönsterstorlek som ska kännas igen som ett ansikte minW = 0.1 * kamera.få (3) minH = 0.1 * kamera.få (4) medan True: ret, img = cam.läs () img = cv2.vänd (bild, -1) # Vänd vertikalt grått = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansikten = faceCascade.detectMultiScale (grå, skalaFaktor = 1.2, minNeighbors = 5, minSize = (int (minW), int (minH)),) för (x, y, w, h) i ansikten: cv2.rektangel (img, (x, y), (x + w, y + h), (0,255,0), 2) id, konfidens = igenkännare.förutsäga (grå [y: y + h, x: x + w]) # Kontrollera om förtroendet är mindre än dem 100 ==> "0" är perfekt matchning om (förtroende < 100): id = names[id] confidence = " 0%".format(round(100 - confidence)) else: id = "unknown" confidence = " 0%".format(round(100 - confidence)) cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2) cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1) cv2.imshow('camera',img) k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video if k == 27: break # Do a bit of cleanup print("\n [INFO] Exiting Program and cleanup stuff") cam.release() cv2.destroyAllWindows() Programmet fungerar som en igenkännare. förutsäga () -funktionen tar olika delar av det fångade ansiktet som olika parametrar och återvänder till den sparade ägaren medan id visas.
Om det inte känner igen ansiktet kommer det att visas ”okänt” på bilden.
Så, Voila!
Slutligen Insikter
Så det här är hur du gör en Raspberry Pi ansiktsigenkänning. Se till att följa den här artikeln steg för steg för att få bästa resultat! Förutom denna klassificering för ansiktsigenkänning kan du nu också göra ögonigenkänning eller leendeigenkänning med olika klassificerare och funktioner. Jag har undersökt alla relaterade artiklar på internet och kommit med den här. Så jag hoppas verkligen att den här guiden har hjälpt dig med projekten. Och jag hoppas att det är framgångsrikt för dig. Glöm inte att nämna dina tankar i kommentarsektionen!
