Phenquestions
Raspberry Pi er en billig mini-computer, der har gjort computing og programmering meget lettere for de fleste, inklusive studerende og hobbyister. Denne mini-computer kan gøre alt, hvad en stationær computer kan gøre, fra at surfe på internettet til at lave spændende projekter og programmer. Og et af disse fantastiske projekter laver en Raspberry Pi Face Recognition. Selvom dette projekt kan være meget interessant, er det ikke meget let at lave. Så jeg vil anbefale dig at følge artiklen trin for trin.
Raspberry Pi ansigtsgenkendelse
At lave et ansigtsgenkendelsesprogram kunne have været en meget vanskelig og avanceret ting en gang. Men med Raspberry Pi er intet for hårdt! I denne artikel har jeg brugt Open Source Computer Vision Library (OpenCV) til at udføre projektet.
Dette lager er designet til at arbejde med beregningseffektivitet og applikationer i realtid. Derfor er det ideelt til vores ansigtsgenkendelsesprogram i realtid. Denne artikel guider dig trin for trin gennem hele projektet. Så hold dig ved slutningen for at få din egen Raspberry Pi Face Recognition!
Krav
Du skal bruge følgende ting til at lave et Raspberry Pi ansigtsgenkendelsessystem:
- Hindbær Pi V4
- Noir kamera
- OpenCV
Raspberry Pi-forbindelser
Sørg for at oprette følgende forbindelser, før du begynder at kode:
- Opret forbindelser mellem Raspberry Pi og Ribbon-kablet fra Display
- Fastgør SDA til SDA-stiften på din Pi
- Sæt SCL fra Display til SCL pin
- Fastgør kameraets båndkabel til Raspberry Pi
- Sæt GND fra skærmen i Pi GND
- Tilslut Raspberry Pi 5V og skærmens 5V
Trin 1: Installer OpenCV på Raspberry Pi
Det første trin er at installere OpenCV på din Pi-enhed. For at gøre det skal du starte din Raspberry Pi og åbne en SSH-forbindelse. Hvis du vil medtage al ledig plads på micro-SD-kortet, skal du udvide dit filsystem.
$ sudo raspi-config
Vælg derefter "Avancerede indstillinger" i menuen og "Udvid filsystem" bagefter:
Derefter skal du trykke på “
$ sudo genstart
Trin 2: Bekræft OpenCV-installationen
Når du er færdig med at genstarte, skal der være et klar OpenCV-virtuelt miljø på din Pi. Nu skal du bekræfte, om OpenCV er korrekt installeret i din Pi. Kør kommandoen "kilde" hver gang du åbner en ny terminal, så systemvariablerne er indstillet korrekt.
kilde ~ /.profil
Indtast nu dit virtuelle miljø:
workon cv
(Cv) -teksten betyder, at du befinder dig i det virtuelle cv-miljø.
(cv) pi @ hindbær: ~ $
Sådan indtaster du din Python-tolk:
python
Du vil se et ">>>" vises i tolken. Sådan importeres OpenCV-biblioteket:
importer cv2
Hvis der ikke er nogen fejlmeddelelser, kan du være sikker på, at OpenCV er installeret korrekt.
Trin 3: Download OpenCV
Download nu din installerede OpenCV. Du bliver nødt til at downloade både OpenCV og OpenCV-bidrag. Bidraget leveres med moduler og funktioner, som du har brug for i dette eksperiment.
$ cd ~ $ wget -O opencv.zip https: // github.com / opencv / opencv / arkiv / 4.0.0.zip $ wget -O opencv_contrib.zip https: // github.com / opencv / opencv_contrib / arkiv / 4.0.0.lynlås
Pak nu arkiverne ud:
$ unzip opencv.zip $ unzip opencv_contrib.lynlås
Trin 4: Installer afhængigheder
Installer nu de nødvendige OpenCV-afhængigheder på din Raspberry Pi for at få det til at fungere korrekt:
$ 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å installere python2.7-dev python3-dev $ sudo apt-get install python3-pil.imagetk
Trin 5: Installer pip
I dette trin skal du installere en pakkehåndtering til python kaldet “pip”.
$ wget https: // bootstrap.pypa.io / get-pip.py $ sudo python3 get-pip.py
Trin 6: Installer Numpy
Derefter skal du installere et pythonbibliotek kaldet “Numpy”.
$ Pip3 installere følelsesløs
Trin 7: Test kameraet
Nu hvor du har installeret alle de nødvendige ting, inklusive OpenCV, er det tid til at kontrollere, om dit kamera fungerer korrekt. Du skal allerede have en Picam installeret på din Raspberry Pi. Indtast følgende kode på din Python IDE:
import numpy som np import cv2 cap = cv2.VideoCapture (0) hætte.sæt (3.640) # sæt Breddehætte.sæt (4.480) # sæt Højde mens (Sand): ret, frame = cap.læs () ramme = cv2.flip (frame, -1) # Flip kamera lodret grå = cv2.cvtColor (ramme, cv2.COLOR_BGR2GRAY) cv2.imshow ('ramme', ramme) cv2.imshow ('grå', grå) k = cv2.waitKey (30) & 0xff hvis k == 27: # tryk på 'ESC' for at afslutte break cap.frigivelse () cv2.destroyAllWindows () Denne kode fungerer ved at optage den videostrøm, der genereres af din PiCam, der viser både grå tilstand og BGR farvetilstand. Udfør derefter koden med følgende kommando:
python simpleCamTest.py
Tryk nu på [ESC] -tasten for at afslutte programmet. Sørg for at klikke på videovinduet, inden du afslutter det. Du skal nu se dit kamera fungere korrekt og vise resultater. Hvis dit kamera viser "Assertion failed" -fejlmeddelelser, skal du bruge følgende kommando til at rette det:
sudo modprobe bcm2835-v4l2
Trin 8: Ansigtsregistrering
Du skal vide, at det første skridt til at gennemføre vores ansigtsgenkendelsesprojekt er at få PiCam til at fange et ansigt. Det skal helt sikkert først opdage et ansigt for at genkende det i fremtiden.
Ansigtsgenkendelsesalgoritmen kræver billeder med ansigtet såvel som uden ansigtet for at træne klassifikatoren og gemme strukturer fra dem. Heldigvis leveres OpenCV, som du downloadede på forhånd, med en detektor og træner. Det har allerede allerede nogle foruddannede klassifikatorer som ansigt, øjne, hænder osv. For at oprette en ansigtsdetektor med OpenCV skal du bruge følgende koder:
import numpy som np import cv2 faceCascade = cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml ') cap = cv2.VideoCapture (0) hætte.sæt (3.640) # sæt Breddehætte.sæt (4.480) # sæt Højde mens Sand: ret, img = cap.læs () img = cv2.flip (img, -1) grå = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansigter = faceCascade.detectMultiScale (grå, skalefaktor = 1.2, minNeighbors = 5, minSize = (20, 20)) for (x, y, w, h) i ansigter: 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 hvis k == 27: # tryk på 'ESC' for at afslutte break cap.frigivelse () cv2.destroyAllWindows () Nu bliver du nødt til at ringe til klassificeringsfunktionen med nogle skaleringsfaktorer, parametre og en minimumsstørrelse på ansigtet, som den registrerer.
ansigter = faceCascade.detectMultiScale (grå, skalefaktor = 1.2, minNeighbors = 5, minSize = (20, 20))
Denne kode fungerer ved at registrere ansigter på et billede. Nu vil du måske markere ansigterne ved hjælp af en form som et rektangel. Brug følgende kode til at gøre det:
for (x, y, w, h) i ansigter: 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 fungerer sådan:
Hvis klassifikatoren finder nogen ansigter på billedet, viser det ansigtets positioner som et rektangel som befalet, hvor det bruger “h” som sin højde og “w” som bredden og de venstre opadgående hjørner (x, y). Det opsummerer stort set vores rektangel (x, y, w, h).
Nu hvor du er færdig med placeringerne, skal du oprette et “ROI” for ansigtet og vise resultatet med imshow () -funktionen. Kør det på python-miljøet ved hjælp af Raspberry Pi Terminal:
python ansigt Detektion.py
Og resultatet:
Trin 9: Lagring af data
I denne del skal du oprette et datasæt, hvor dit program skal gemme de indsamlede data om ID'er for ansigtet, som det har registreret. For at gøre det skal du oprette en mappe (jeg bruger FacialRecognition):
mkdir Ansigtsgenkendelse
Opret nu en underkatalog med navnet "datasæt".
mkdir-datasæt
Brug derefter følgende kode:
import cv2 import os cam = cv2.VideoCapture (0) cam.sæt (3, 640) # sæt videobreddekamera.sæt (4, 480) # sæt videohøjde face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ') # For hver person skal du indtaste et numerisk ansigt id ansigt_id = input (' \ n indtast bruger-id slut tryk ==> ') print ("\ n [INFO] Initialiserer ansigtsoptagelse. Se på kameraet, og vent ... ") # Initialiser individuel optælling af ansigtsantal = 0, mens (Sand): ret, img = cam.læs () img = cv2.flip (img, -1) # flip videobillede lodret grå = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansigter = ansigtsdetektor.detectMultiScale (grå, 1.3, 5) for (x, y, w, h) i ansigter: cv2.rektangel (img, (x, y), (x + w, y + h), (255,0,0), 2) count + = 1 # Gem det optagede billede i datasætmappen cv2.imwrite ("datasæt / bruger."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w]) cv2.imshow ('billede', img) k = cv2.waitKey (100) & 0xff # Tryk på 'ESC' for at afslutte video, hvis k == 27: break elif count> = 10: # Tag 10 ansigtseksempler og stop videopaus # Lav lidt oprydningsudskrivning ("\ n [INFO] Afslutter program og oprydnings ting ") cam.frigivelse () cv2.destroyAllWindows () Bemærk, at vi vil gemme hver af de fangede rammer som en fil i underkataloget "datasæt":
cv2.imwrite ("datasæt / bruger."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w]) Derefter skal du importere "os" -biblioteket for at gemme ovenstående fil. Filernes navn følger en struktur som denne:
Bruger.ansigt_id.tælle.jpg, / pre>
Ovenstående kode vil kun optage 10 billeder for hvert id. Du kan helt sikkert ændre det, hvis du vil.
Prøv nu at køre programmet og fange nogle id'er. Sørg for at køre koden hver gang du skifter bruger eller det eksisterende foto.
Trin 10: Træner
I dette trin skal du bruge en OpenCV-funktion til at træne OpenCV-genkenderen med dataene fra dit datasæt. Start med at oprette en underkatalog til lagring af de uddannede data.
mkdir træner
Kør derefter følgende kode:
import cv2 import numpy som np fra PIL import Image import os # Sti til ansigtsbillede database sti = 'datasæt' genkender = cv2.ansigt.LBPHFaceRecognizer_create () detektor = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml "); # funktion til at få billederne og mærke data def getImagesAndLabels (sti): imagePaths = [os.sti.join (sti, f) for f i os.listdir (sti)] faceSamples = [] ids = [] til imagePath i imagePaths: PIL_img = Image.åben (imagePath).konverter ('L') # konverter det til gråtoner img_numpy = np.array (PIL_img, 'uint8') id = int (os.sti.split (imagePath) [- 1].dele(".") [1]) ansigter = detektor.detectMultiScale (img_numpy) for (x, y, w, h) i ansigter: faceSamples.tilføj (img_numpy [y: y + h, x: x + w]) id'er.append (id) return faceSamples, ids print ("\ n [INFO] Trænings ansigter. Det tager et par sekunder. Vent ... ") ansigter, ids = getImagesAndLabels (sti) genkender.tog (ansigter, np.array (ids)) # Gem modellen i træner / træner.yml-genkender.skriv ('træner / træner.yml ') # genkender.save () arbejdede på Mac, men ikke på Pi # Udskriv antallet af ansigtsuddannede og afslut programudskrivning ("\ n [INFO] 0 ansigtsuddannede. Afslutter program ".format (len (np.unikke (id'er)))) Sørg for, at du har installeret PIL-biblioteket på din Raspberry Pi. Hvis du ikke har det, skal du køre følgende kommando:
pip installer pude
Her bruger jeg LBPH ansigtsgenkenderen, der følger med OpenCV-pakken. Følg nu denne linje:
genkender = cv2.ansigt.LBPHFaceRecognizer_create ()
Alle dine fotos føres til biblioteket "datasæt" med funktionen "getImagesAndLabels". Det returnerer 2 arrays med navnet "Ids" og "ansigter". Nu er det tid til at træne genkenderen.
genkender.tog (ansigter, id'er)
Nu vil du se “træner.yml ”navngivet fil gemt i trænerbiblioteket.
Trin 11: Ansigtsgenkendelse
Det er tid til den sidste handling. Efter dette trin kan din genkender gætte et tilbagevendende id, hvis ansigtet blev fanget før. Så lad os skrive vores endelige kode:
import cv2 import numpy som np import os genkender = cv2.ansigt.LBPHFaceRecognizer_create () genkender.læse ('træner / træner.yml ') cascadePath = "haarcascade_frontalface_default.xml "faceCascade = cv2.CascadeClassifier (cascadePath); skrifttype = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # navne relateret til ids: eksempel ==> Marcelo: id = 1 osv. Names = ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Initialiser og start videooptagelse i realtid cam = cv2.VideoCapture (0) cam.sæt (3, 640) # sæt video med videokamera.sæt (4, 480) # indstil videohøjde # Definer min vinduesstørrelse, der skal genkendes som et ansigt minW = 0.1 * cam.få (3) minH = 0.1 * cam.get (4) mens True: ret, img = cam.læs () img = cv2.flip (img, -1) # Vend lodret grå = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansigter = faceCascade.detectMultiScale (grå, skalefaktor = 1.2, minNeighbors = 5, minSize = (int (minW), int (minH)),) for (x, y, w, h) i ansigter: cv2.rektangel (img, (x, y), (x + w, y + h), (0,255,0), 2) id, konfidens = genkender.forudsig (grå [y: y + h, x: x + w]) # Kontroller om tillid er mindre dem 100 ==> "0" er perfekt match hvis (tillid < 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 fungerer som en genkender. forudsig () -funktionen tager forskellige dele af det fangede ansigt som forskellige parametre og vender tilbage til den gemte ejer, mens id'et vises.
Hvis det ikke genkender ansigtet, vises det "ukendt" på billedet.
Så, Voila!
Endelig Insights
Så det er sådan, du laver en Raspberry Pi ansigtsgenkendelse. Sørg for at følge denne artikel trin for trin for at få det bedste resultat! Nu, foruden denne klassificering af ansigtsgenkendelse, kan du også lave øjengenkendelse eller smilgenkendelse ved hjælp af forskellige klassifikatorer og funktioner. Jeg har undersøgt alle relaterede artikler på Internettet og kom op med denne. Så jeg håber virkelig, at denne guide har hjulpet dig med projekterne. Og jeg håber, at det lykkes for dig. Glem ikke at nævne dine tanker i kommentarfeltet!
