Phenquestions
Raspberry Pi er en billig mini-datamaskin som har gjort databehandling og programmering mye enklere for de fleste, inkludert studenter og hobbyister. Denne mini-datamaskinen kan gjøre alt som en stasjonær datamaskin kan gjøre, fra å surfe på internett til å lage spennende prosjekter og programmer. Og et av disse fantastiske prosjektene lager en Raspberry Pi Face Recognition. Selv om dette prosjektet kan være veldig interessant, er det ikke veldig lett å lage. Så jeg vil anbefale deg å følge artikkelen trinn for trinn.
Raspberry Pi ansiktsgjenkjenning
Å lage et ansiktsgjenkjenningsprogram kan ha vært en veldig vanskelig og avansert ting en gang. Men med Raspberry Pi er ingenting for vanskelig! I denne artikkelen har jeg brukt Open Source Computer Vision Library (OpenCV) til å gjøre prosjektet.
Dette depotet er designet for å fungere med beregningseffektivitet og sanntidsapplikasjoner. Derfor er det ideelt for vårt sanntids ansiktsgjenkjenningsprogram. Denne artikkelen vil guide deg trinn for trinn gjennom hele prosjektet. Så hold deg til slutt for å få din egen Raspberry Pi Face Recognition!
Krav
Du trenger følgende ting for å lage et Raspberry Pi ansiktsgjenkjenningssystem:
- Raspberry Pi V4
- Noir kamera
- OpenCV
Raspberry Pi-tilkoblinger
Sørg for å opprette følgende tilkoblinger før du begynner å kode:
- Opprett forbindelser mellom Raspberry Pi og Ribbon-kabelen fra skjermen
- Fest SDA til SDA-pinnen på Pi-en
- Sett SCL fra skjerm til SCL-pinne
- Fest kameraets båndkabel til Raspberry Pi
- Sett GND fra skjermen i Pi GND
- Koble Raspberry Pi 5V og skjermens 5V
Trinn 1: Installer OpenCV på Raspberry Pi
Det første trinnet er å installere OpenCV på Pi-enheten din. For å gjøre det, start Raspberry Pi og åpne en SSH-tilkobling. For å inkludere all tilgjengelig plass på micro-SD-kortet, utvid filsystemet.
$ sudo raspi-config
Velg deretter "Avanserte alternativer" fra menyen og "Utvid filsystem" etterpå:
Etter det, trykk på “
$ sudo omstart
Trinn 2: Bekreft installasjonen av OpenCV
Når du er ferdig med å starte på nytt, bør det være et klart OpenCV virtuelt miljø på din Pi. Nå bør du bekrefte om OpenCV er riktig installert i Pi-en. Kjør "kilde" -kommandoen hver gang du åpner en ny terminal slik at systemvariablene er satt opp riktig.
kilde ~ /.profil
Gå nå inn i ditt virtuelle miljø:
workon cv
Teksten (cv) betyr at du er i det virtuelle cv-miljøet.
(cv) pi @ bringebær: ~ $
Slik skriver du inn Python-tolk:
python
Du vil se et “>>>” vises i tolken. Slik importerer du OpenCV-biblioteket:
importere cv2
Hvis det ikke er noen feilmeldinger, kan du være sikker på at OpenCV er riktig installert.
Trinn 3: Last ned OpenCV
Last ned din installerte OpenCV. Du må laste ned både OpenCV og OpenCV-bidrag. Bidraget kommer med moduler og funksjoner som du trenger i dette eksperimentet.
$ cd ~ $ wget -O opencv.zip https: // github.com / opencv / opencv / archive / 4.0.0.zip $ wget -O opencv_contrib.zip https: // github.no / opencv / opencv_contrib / arkiv / 4.0.0.glidelås
Pakk ut arkivene nå:
$ pakke ut opencv.zip $ pakke ut opencv_contrib.glidelås
Trinn 4: Installer avhengigheter
Installer nå de nødvendige OpenCV-avhengighetene på Raspberry Pi for å få den til å fungere skikkelig:
$ 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
Trinn 5: Installer pip
I dette trinnet må du installere en pakkebehandling for python kalt "pip".
$ wget https: // bootstrap.pypa.io / get-pip.py $ sudo python3 get-pip.py
Trinn 6: Installer Numpy
Deretter installerer du et pythonbibliotek kalt “Numpy”.
$ Pip3 installere nummen
Trinn 7: Test kameraet
Nå som du har installert alle nødvendige ting, inkludert OpenCV, er det på tide å sjekke om kameraet fungerer som det skal. Du bør allerede ha en Picam installert på Raspberry Pi. Skriv inn følgende kode på Python IDE:
importer nummen som np import cv2 cap = cv2.VideoCapture (0) hette.sett (3.640) # sett Breddehett.set (4480) # set Height while (True): ret, frame = cap.les () ramme = cv2.flip (ramme, -1) # Vend kamera vertikalt grått = cv2.cvtColor (ramme, cv2.COLOR_BGR2GRAY) cv2.imshow ('ramme', ramme) cv2.imshow ('grå', grå) k = cv2.waitKey (30) & 0xff hvis k == 27: # trykk 'ESC' for å avslutte break cap.slipp () cv2.destroyAllWindows () Denne koden fungerer ved å fange videostrømmen generert av PiCam, som viser både gråmodus og BGR-fargemodus. Utfør deretter koden med følgende kommando:
python simpleCamTest.py
Trykk nå på [ESC] -tasten for å fullføre programmet. Sørg for å klikke på videovinduet før du fullfører det. Nå skal du se at kameraet fungerer som det skal og viser resultater. Hvis kameraet viser feilmeldingene "Assertion failed", kan du bruke følgende kommando for å fikse det:
sudo modprobe bcm2835-v4l2
Trinn 8: Ansiktsgjenkjenning
Du bør vite at det første trinnet for å fullføre ansiktsgjenkjenningsprosjektet vårt er å få PiCam til å fange et ansikt. Det må sikkert oppdage et ansikt først for å gjenkjenne det i fremtiden.
Ansiktsgjenkjenningsalgoritmen krever bilder med ansiktet så vel som uten ansiktet for å trene klassifisereren og redde strukturer fra dem. Heldigvis kommer OpenCV du lastet ned på forhånd med en detektor og trener. Dessuten har den allerede noen forhåndstrente klassifikatorer som ansikt, øyne, hender osv. For å lage en ansiktsdetektor med OpenCV, bruk følgende koder:
importer nummen som np import cv2 faceCascade = cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml ') cap = cv2.VideoCapture (0) hette.sett (3.640) # sett Breddehett.set (4480) # set Height while True: ret, img = cap.les () img = cv2.flip (img, -1) grå = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansikter = faceCascade.detectMultiScale (grå, scaleFactor = 1.2, minNeighbors = 5, minSize = (20, 20)) for (x, y, w, h) i ansikter: 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: # trykk 'ESC' for å avslutte break cap.slipp () cv2.destroyAllWindows () Nå må du ringe klassifiseringsfunksjonen med noen skaleringsfaktorer, parametere og en minimumsstørrelse på ansiktet som den vil oppdage.
ansikter = faceCascade.detectMultiScale (grå, scaleFactor = 1.2, minNaighbors = 5, minSize = (20, 20))
Denne koden fungerer ved å oppdage ansikter på et bilde. Nå vil du kanskje merke ansiktene ved å bruke en form som et rektangel. Bruk følgende kode for å gjøre det:
for (x, y, w, h) i ansikter: 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å dette fungerer slik:
Hvis klassifisereren finner noen ansikter i bildet, viser det ansiktets posisjoner som et rektangel som befalt der det bruker “h” som høyden og “w” som bredden og de venstre oppe hjørnene (x, y). Det oppsummerer ganske mye vårt rektangel (x, y, w, h).
Nå som du er ferdig med stedene, kan du opprette en “ROI” for ansiktet og vise resultatet med imshow () -funksjonen. Kjør den på python-miljøet ved hjelp av Raspberry Pi Terminal:
python face Detection.py
Og resultatet:
Trinn 9: Lagre data
I denne delen må du opprette et datasett der programmet ditt skal lagre samlet data om ID-er for ansiktet som det har oppdaget. For å gjøre det, opprett en katalog (jeg bruker FacialRecognition):
mkdir Ansiktsgjenkjenning
Lag nå en underkatalog med navnet "datasett".
mkdir datasett
Bruk deretter følgende kode:
import cv2 import os cam = cv2.VideoCapture (0) kamera.sett (3, 640) # sett videobreddekamera.sett (4, 480) # sett videohøyde face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ') # For hver person, skriv inn ett numerisk ansikts-id ansikt_id = inngang (' \ n skriv inn bruker-ID slutt trykk ==> ') utskrift ("\ n [INFO] Initialiserer ansiktsopptak. Se på kameraet og vent ... ") # Initialiser individuell antall ansikts teller = 0 mens (True): ret, img = cam.les () img = cv2.flip (img, -1) # flip video image vertically grey = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansikter = ansiktsdetektor.detectMultiScale (grå, 1.3, 5) for (x, y, w, h) i ansikter: cv2.rektangel (img, (x, y), (x + w, y + h), (255,0,0), 2) count + = 1 # Lagre det fangede bildet i datasettmappen cv2.imwrite ("datasett / bruker."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # Trykk på 'ESC' for å avslutte video hvis k == 27: break elif count> = 10: # Ta 10 ansiktsprøver og stopp videopaus # Gjør litt oppryddingsutskrift ("\ n [INFO] Avslutt program og oppryddingsting ") kamera.slipp () cv2.destroyAllWindows () Vær oppmerksom på at vi skal lagre hver av de fangede rammene som en fil i underkatalogen "datasett":
cv2.imwrite ("datasett / bruker."+ str (face_id) + '.'+ str (count) + ".jpg ", grå [y: y + h, x: x + w]) Etter det må du importere “os” -biblioteket for å lagre filen ovenfor. Filenes navn vil følge en struktur som denne:
Bruker.ansikt_id.telle.jpg, / pre>
Koden nevnt ovenfor vil bare fange 10 bilder for hver id. Du kan sikkert endre det hvis du vil.
Nå kan du prøve å kjøre programmet og fange noen ID-er. Sørg for å kjøre koden hver gang du endrer bruker eller eksisterende bilde.
Trinn 10: Trener
I dette trinnet må du bruke en OpenCV-funksjon for å trene OpenCV-gjenkjenning med dataene fra datasettet ditt. Start med å lage en underkatalog for å lagre de opplærte dataene.
mkdir trener
Kjør deretter følgende kode:
import cv2 import numpy as np from PIL import Image import os # Path for face image database path = 'dataset' recognizer = cv2.ansikt.LBPHFaceRecognizer_create () detektor = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml "); # funksjon for å få bilder og merke data def getImagesAndLabels (sti): imagePaths = [os.sti.bli med (sti, f) for f i os.listdir (sti)] faceSamples = [] ids = [] for imagePath i imagePaths: PIL_img = Image.åpen (imagePath).convert ('L') # convert it to grayscale img_numpy = np.matrise (PIL_img, 'uint8') id = int (os.sti.split (imagePath) [- 1].dele(".") [1]) ansikter = detektor.detectMultiScale (img_numpy) for (x, y, w, h) i ansikter: faceSamples.legg til (img_numpy [y: y + h, x: x + w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Trenings ansikter. Det vil ta noen sekunder. Vent ... ") ansikter, ids = getImagesAndLabels (sti) gjenkjenning.tog (ansikter, np.array (ids)) # Lagre modellen i trener / trener.yml-gjenkjenning.skriv ('trener / trener.yml ') # gjenkjenning.lagre () jobbet på Mac, men ikke på Pi # Skriv ut antall ansikter trent og avslutte programutskrift ("\ n [INFO] 0 ansikter trent. Avslutter programmet ".format (len (np.unike (ider)))) Forsikre deg om at du har installert PIL-biblioteket på Raspberry Pi. Hvis du ikke har det, kjører du følgende kommando:
pip install pute
Her bruker jeg LBPH ansiktsgjenkjenning som følger med OpenCV-pakken. Følg denne linjen:
gjenkjenning = cv2.ansikt.LBPHFaceRecognizer_create ()
Alle bildene dine blir tatt til katalogen "datasett" av "getImagesAndLabels" -funksjonen. Den returnerer to matriser med navnet "Ids" og "ansikter". Nå er det på tide å trene gjenkjent.
gjenkjenning.tog (ansikter, ider)
Nå vil du se “trener.yml ”-fil som er lagret i trenerkatalogen.
Trinn 11: Ansiktsgjenkjenning
Det er tid for den siste handlingen. Etter dette trinnet, kan gjenkjenningen gjette en retur-ID hvis ansiktet ble tatt før. Så la oss skrive vår endelige kode:
import cv2 import numpy as np import os gjenkjenning = cv2.ansikt.LBPHFaceRecognizer_create () gjenkjenning.les ('trener / trener.yml ') cascadePath = "haarcascade_frontalface_default.xml "faceCascade = cv2.CascadeClassifier (cascadePath); font = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # navn relatert til ids: eksempel ==> Marcelo: id = 1, etc names = ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Initialiser og start sanntids videoopptakskamera = cv2.VideoCapture (0) kamera.set (3, 640) # set video widht cam.sett (4, 480) # sett videohøyde # Definer min vindusstørrelse som skal gjenkjennes som et ansikt minW = 0.1 * kamera.få (3) minH = 0.1 * kamera.få (4) mens True: ret, img = cam.les () img = cv2.flip (img, -1) # Vend vertikalt grå = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) ansikter = faceCascade.detectMultiScale (grå, scaleFactor = 1.2, minNaighbors = 5, minSize = (int (minW), int (minH)),) for (x, y, w, h) i ansikter: cv2.rektangel (img, (x, y), (x + w, y + h), (0,255,0), 2) id, konfidens = gjenkjenning.forutsi (grå [y: y + h, x: x + w]) # Sjekk om tilliten er mindre dem 100 ==> "0" er perfekt match hvis (tillit < 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 gjenkjenning. predict () -funksjon tar forskjellige deler av det fangede ansiktet som forskjellige parametere og returnerer til den lagrede eieren mens du viser id.
Hvis den ikke gjenkjenner ansiktet, vil det vise "ukjent" på bildet.
Så, Voila!
Endelig Insights
Så dette er hvordan du lager en Raspberry Pi ansiktsgjenkjenning. Sørg for å følge denne artikkelen trinn for trinn for å få det beste resultatet! Nå, i tillegg til denne ansiktsgjenkjenningsklassifisereren, kan du også lage øyegjenkjenning eller smilgjenkjenning ved hjelp av forskjellige klassifiserere og funksjoner. Jeg har undersøkt alle relaterte artikler på internett og funnet på denne. Så jeg håper virkelig denne guiden har hjulpet deg med prosjektene. Og jeg håper at det lykkes for deg. Ikke glem å nevne tankene dine i kommentarfeltet!
