Phenquestions
Raspberry Pi ir lēts mini-dators, kas lielākai daļai cilvēku, tostarp studentiem un hobijiem, ir ievērojami atvieglojis skaitļošanu un programmēšanu. Šis mini dators var darīt visu, ko var darīt galddators, sākot no interneta pārlūkošanas līdz aizraujošu projektu un programmu izveidošanai. Un viens no šiem apbrīnojamajiem projektiem ir Raspberry Pi sejas atpazīšana. Lai gan šis projekts var būt daudz interesants, to nav ļoti viegli izveidot. Tātad, es ieteiktu jums sekot rakstam soli pa solim.
Aveņu Pi sejas atpazīšana
Sejas atpazīšanas programmas izveidošana, iespējams, reiz bija ļoti sarežģīta un progresīva lieta. Bet ar Aveņu Pi nekas nav pārāk grūti! Šajā rakstā projekta veikšanai esmu izmantojis atvērtā pirmkoda datorvīzijas bibliotēku (OpenCV).
Šī krātuve tika izstrādāta darbam ar skaitļošanas efektivitāti un reāllaika lietojumprogrammām. Tādējādi tas ir ideāli piemērots mūsu reāllaika sejas atpazīšanas programmai. Šis raksts jums soli pa solim palīdzēs veikt visu projektu. Tātad, pieturieties līdz beigām, lai jums būtu sava Raspberry Pi sejas atpazīšana!
Prasības
Lai izveidotu Raspberry Pi sejas atpazīšanas sistēmu, jums būs nepieciešamas šādas lietas:
- Aveņu Pi V4
- Noir kamera
- OpenCV
Aveņu Pi savienojumi
Pirms kodēšanas sākšanas noteikti izveidojiet šādus savienojumus:
- Izveidojiet savienojumus starp Raspberry Pi un lentes kabeli no displeja
- Pievienojiet SDA sava Pi SDA tapai
- Ievietojiet SCL no displeja uz SCL tapu
- Pievienojiet kameras lentes kabeli Raspberry Pi
- Ievietojiet GND no displeja Pi GND
- Pievienojiet Raspberry Pi 5V un displeja 5V
1. solis: Instalējiet OpenCV uz Raspberry Pi
Pirmais solis ir instalēt OpenCV savā Pi ierīcē. Lai to izdarītu, palaidiet Raspberry Pi un atveriet SSH savienojumu. Lai iekļautu visu pieejamo vietu micro-SD kartē, paplašiniet failu sistēmu.
$ sudo raspi-config
Pēc tam izvēlnē atlasiet “Papildu opcijas” un pēc tam “Paplašināt failu sistēmu”:
Pēc tam nospiediet “
$ sudo atsāknēšana
2. darbība: apstipriniet OpenCV instalēšanu
Kad esat restartējis, jūsu Pi jābūt gatavai OpenCV virtuālajai videi. Tagad jums vajadzētu apstiprināt, vai OpenCV ir pareizi instalēts jūsu Pi. Palaidiet komandu “source” katru reizi, kad atverat jaunu termināli, lai sistēmas mainīgie būtu pareizi iestatīti.
avots ~ /.profils
Tagad ievadiet virtuālo vidi:
workon cv
(Cv) teksts nozīmē, ka jūs atrodaties cv virtuālajā vidē.
(cv) pi @ aveņu: ~ $
Lai ievadītu Python tulku:
pitons
Tulkā parādīsies “>>>”. Lai importētu OpenCV bibliotēku:
importēt cv2
Ja nav kļūdu ziņojumu, varat būt pārliecināts, ka OpenCV ir pareizi instalēts.
3. darbība: lejupielādējiet OpenCV
Tagad lejupielādējiet instalēto OpenCV. Jums būs jālejupielādē gan OpenCV, gan OpenCV ieguldījums. Ieguldījums nāk ar moduļiem un funkcijām, kas jums būs nepieciešamas šajā eksperimentā.
$ cd ~ $ wget -O atvēršana.zip https: // github.com / opencv / opencv / archive / 4.0.0.zip $ wget -O opencv_contrib.zip https: // github.com / opencv / opencv_contrib / archive / 4.0.0.zip
Tagad atvienojiet arhīvu:
$ unzip opencv.zip $ unzip opencv_contrib.zip
4. solis: instalējiet atkarības
Tagad instalējiet nepieciešamās OpenCV atkarības no Raspberry Pi, lai tā darbotos pareizi:
$ 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 libpango.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- iegūt instalēt python2.7-dev python3-dev $ sudo apt-get instalēt python3-pil.imagetk
5. solis: instalējiet pip
Šajā solī jums būs jāinstalē pakotņu pārvaldnieks pitonam ar nosaukumu “pip”.
$ wget https: // bootstrap.pypa.io / get-pip.py $ sudo python3 get-pip.py
6. darbība: instalējiet Numpy
Pēc tam instalējiet pitona bibliotēku ar nosaukumu “Numpy”.
$ Pip3 instalēt numpy
7. darbība. Pārbaudiet kameru
Tagad, kad esat instalējis visas nepieciešamās lietas, ieskaitot OpenCV, ir pienācis laiks pārbaudīt, vai kamera darbojas pareizi. Jūsu Raspberry Pi jau vajadzētu būt instalētam Picam. Ievadiet šo kodu savā Python IDE:
import numpy kā np importēt cv2 cap = cv2.VideoCapture (0) vāciņš.set (3 640) # set Platuma vāciņš.set (4480) # set Height while (True): ret, rāmis = vāciņš.lasīt () rāmis = cv2.uzsist (kadrs, -1) # Apgrieziet kameru vertikāli pelēkā krāsā = cv2.cvtColor (rāmis, cv2.COLOR_BGR2GRAY) cv2.imshow ('rāmis', rāmis) cv2.imshow ('pelēks', pelēks) k = cv2.waitKey (30) & 0xff, ja k == 27: # nospiediet taustiņu ESC, lai pārtrauktu pārtraukuma ierobežojumu.izlaidums () cv2.destrAllWindows () Šis kods darbojas, uzņemot jūsu PiCam ģenerēto video straumi, kas parāda gan pelēko režīmu, gan BGR krāsu režīmu. Pēc tam izpildiet kodu ar šādu komandu:
pitons simpleCamTest.py
Tagad nospiediet taustiņu [ESC], lai pabeigtu programmu. Pirms tā pabeigšanas noteikti noklikšķiniet uz video loga. Tagad jums vajadzētu redzēt, kā kamera darbojas pareizi un parāda rezultātus. Ja jūsu kamerā tiek parādīti kļūdas ziņojumi “Apstiprināšana neizdevās”, izmantojiet šo komandu, lai to novērstu:
sudo modprobe bcm2835-v4l2
8. solis: sejas noteikšana
Jums jāzina, ka pirmais solis, lai pabeigtu mūsu sejas atpazīšanas projektu, ir panākt, lai PiCam uzņemtu seju. Protams, tai vispirms ir jānosaka seja, lai to atpazītu nākotnē.
Sejas noteikšanas algoritmam ir nepieciešami attēli ar seju, kā arī bez sejas, lai apmācītu klasifikatoru un saglabātu struktūras no tiem. Par laimi, iepriekš lejupielādētajam OpenCV ir detektors un trenažieris. Turklāt tam jau ir daži iepriekš apmācīti klasifikatori, piemēram, seja, acis, rokas utt. Lai izveidotu sejas detektoru ar OpenCV, izmantojiet šādus kodus:
importēt numpy kā np importēt cv2 faceCascade = cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml ') vāciņš = cv2.VideoCapture (0) vāciņš.set (3 640) # set Platuma vāciņš.set (4480) # set Height while True: ret, img = vāciņš.lasīt () img = cv2.uzsist (img, -1) pelēks = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) sejas = faceCascade.detektētMultiScale (pelēks, scaleFactor = 1.2, min Kaimiņi = 5, minIzmērs = (20, 20)) (x, y, w, h) sejās: cv2.taisnstūris (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = pelēks [y: y + h, x: x + w] roi_color = img [ y: y + h, x: x + w] cv2.imshow ('video', img) k = cv2.waitKey (30) & 0xff, ja k == 27: # nospiediet 'ESC', lai pārtrauktu pārtraukuma ierobežojumu.izlaidums () cv2.destrAllWindows () Tagad jums būs jāizsauc klasifikatora funkcija ar dažiem mēroga faktoriem, parametriem un minimālo sejas izmēru, ko tā noteiks.
sejas = faceCascade.detektētMultiScale (pelēks, scaleFactor = 1.2, min Kaimiņi = 5, minIzmērs = (20, 20))
Šis kods darbojas, attēlā atrodot sejas. Tagad jūs varētu vēlēties atzīmēt sejas, izmantojot formu kā taisnstūri. Lai to izdarītu, izmantojiet šādu kodu:
par (x, y, w, h) sejās: cv2.taisnstūris (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = pelēks [y: y + h, x: x + w] roi_color = img [ y: y + h, x: x + w]
Tātad tas darbojas šādi:
Ja klasifikators attēlā atrod kādas sejas, tas parāda sejas pozīcijas kā taisnstūri, kā norādīts, kur tā izmanto “h” kā augstumu un “w” kā platumu un kreiso augšējo stūri (x, y). Tas diezgan daudz apkopo mūsu taisnstūri (x, y, w, h).
Tagad, kad esat pabeidzis atrašanās vietas, izveidojiet “ROI” sejai un parādiet rezultātu ar funkciju imshow (). Palaidiet to pitona vidē, izmantojot Raspberry Pi termināli:
pitona sejas noteikšana.py
Un rezultāts:
9. darbība: datu saglabāšana
Šajā daļā jums jāizveido datu kopa, kurā jūsu programma saglabās apkopotos datus par konstatētajiem sejas ID. Lai to izdarītu, izveidojiet direktoriju (es izmantoju FacialRecognition):
mkdir sejas atpazīšana
Tagad izveidojiet apakšdirektoriju ar nosaukumu “datu kopa”.
mkdir datu kopa
Pēc tam izmantojiet šādu kodu:
importēt cv2 importēt os cam = cv2.VideoCapture (0) kamera.komplekts (3, 640) # iestatiet video platuma kameru.set (4, 480) # set video augstums face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ') # Katrai personai ievadiet vienu ciparu sejas ID face_id = input (' \ n ievadiet lietotāja ID beigu nospiešana ==> ') print ("\ n [INFO] Inicializē sejas tveršanu. Paskatieties kamerā un pagaidiet ... ") # Inicializējiet individuālo sejas paraugu skaitu = 0, kamēr (True): ret, img = cam.lasīt () img = cv2.uzsist (img, -1) # video attēla vertikāli pelēks = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) sejas = sejas_detektors.noteiktMultiScale (pelēks, 1.3, 5) (x, y, w, h) sejās: cv2.taisnstūris (img, (x, y), (x + w, y + h), (255,0,0), 2) count + = 1 # Saglabājiet uzņemto attēlu datu kopu mapē cv2.imwrite ("datu kopa / Lietotājs."+ str (face_id) + '.'+ str (skaits) + ".jpg ", pelēks [y: y + h, x: x + w]) cv2.imshow ('attēls', img) k = cv2.waitKey (100) & 0xff # Lai izietu no video, nospiediet taustiņu 'ESC', ja k == 27: pārtraukuma elifu skaits> = 10: # Paņemiet 10 sejas paraugu un pārtrauciet video pārtraukumu # Veiciet nelielu tīrīšanas druku ("\ n [INFO] Iziet no programmas un tīrīšanas lietām ") cam.izlaidums () cv2.destrAllWindows () Ņemiet vērā, ka mēs katru no uzņemtajiem kadriem saglabāsim kā failu apakšdirektorijā “dataset”:
CV2.imwrite ("datu kopa / Lietotājs."+ str (face_id) + '.'+ str (skaits) + ".jpg ", pelēks [y: y + h, x: x + w]) Pēc tam jums jāimportē “os” bibliotēka, lai saglabātu iepriekš minēto failu. Failu nosaukumam būs šāda struktūra:
Lietotājs.face_id.skaitīt.jpg, / pre>
Iepriekš minētais kods uzņems tikai 10 attēlus katram ID. Ja vēlaties, varat to droši mainīt.
Tagad mēģiniet palaist programmu un uzņemiet dažus ID. Pārliecinieties, ka kods tiek palaists katru reizi, kad maināt lietotāju vai esošo fotoattēlu.
10. solis: treneris
Šajā solī jums būs jāizmanto OpenCV funkcija, lai apmācītu OpenCV atpazītāju ar datiem no jūsu datu kopas. Vispirms izveidojiet apakšdirektoriju apmācīto datu glabāšanai.
mkdir treneris
Pēc tam palaidiet šādu kodu:
importēt cv2 importēt numpy kā np no PIL importēt attēlu importēt os # sejas attēlu datu bāzes ceļš path = 'datu kopa' tunnistotājs = cv2.seja.LBPHFaceRecognizer_create () detektors = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml "); # funkcija, lai iegūtu attēlus un iezīmētu datu def getImagesAndLabels (ceļš): imagePaths = [os.ceļš.pievienoties (ceļš, f) f in os.listdir (path)] faceSamples = [] ids = [] imagePath mapē imagePaths: PIL_img = Image.atvērt (imagePath).konvertēt ('L') # pārvērst to pelēktoņos img_numpy = np.masīvs (PIL_img, 'uint8') id = int (os.ceļš.sadalīt (imagePath) [- 1].sadalīt (".") [1]) sejas = detektors.diagnosticMultiScale (img_numpy) (x, y, w, h) sejās: faceSamples.pievienot (img_numpy [y: y + h, x: x + w]) id.append (id) return faceSamples, ids print ("\ n [INFO] Apmācības sejas. Tas prasīs dažas sekundes. Uzgaidiet ... ") sejas, ids = getImagesAndLabels (ceļš) atpazītājs.vilciens (sejas, np.masīvs (ids)) # Saglabājiet modeli trenerī / trenerī.yml atpazinējs.rakstīt ('treneris / treneris.yml ') # atpazinējs.save () strādāja Mac datorā, bet ne Pi # Izdrukājiet apmācīto seju skaitu un beigiet programmas drukāšanu ("\ n [INFO] 0 apmācītās sejas. Iziet no programmas ".formāts (len (np.unikāls (id)))) Pārliecinieties, vai savā Raspberry Pi esat instalējis PIL bibliotēku. Ja jums tā nav, palaidiet šādu komandu:
pip instalēt spilvenu
Šeit es izmantoju LBPH sejas atpazīšanas ierīci, kas ir iekļauta OpenCV pakotnē. Izpildiet šo rindu:
atpazītājs = cv2.seja.LBPHFaceRecognizer_create ()
Izmantojot funkciju “getImagesAndLabels”, visi jūsu fotoattēli tiks aizvesti uz “datu kopas” direktoriju. Tas atgriezīs 2 masīvus ar nosaukumu “ID” un “sejas”. Tagad ir pienācis laiks apmācīt atpazinēju.
atpazinējs.vilciens (sejas, ID)
Tagad jūs redzēsiet “treneri.yml ”nosauktais fails saglabāts trenera direktorijā.
11. solis: sejas atpazīšana
Ir pienācis pēdējās darbības laiks. Pēc šīs darbības jūsu atpazinējs var uzminēt atgriešanās ID, ja seja tika notverta iepriekš. Tātad, uzrakstīsim mūsu galīgo kodu:
importēt cv2 importēt numpy kā np importēt os atpazīšanas = cv2.seja.LBPHFaceRecognizer_create () atpazinējs.lasīt ('treneris / treneris.yml ') cascadePath = "haarcascade_frontalface_default.xml "faceCascade = cv2.CascadeClassifier (cascadePath); font = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # nosaukumi, kas saistīti ar id: example ==> Marcelo: id = 1 utt. Nosaukumi = ['Neviens', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Inicializējiet un sāciet reāllaika video uzņemšanas kameru = cv2.VideoCapture (0) kamera.komplekts (3, 640) # iestatiet video platekameru.set (4, 480) # set video height # Definējiet minimālo loga izmēru, kas jāatzīst par seju minW = 0.1 * izciļņa.iegūt (3) minH = 0.1 * izciļņa.get (4), bet True: ret, img = cam.lasīt () img = cv2.uzsist (img, -1) # Apvērst vertikāli pelēks = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) sejas = faceCascade.detektētMultiScale (pelēks, scaleFactor = 1.2, min Kaimiņi = 5, minSize = (int (minW), int (minH)),) (x, y, w, h) sejās: cv2.taisnstūris (img, (x, y), (x + w, y + h), (0,255,0), 2) id, ticamība = atpazinējs.prognozēt (pelēks [y: y + h, x: x + w]) # Pārbaudiet, vai pārliecība ir mazāka, ja 100 ==> "0" ir ideāli piemērots, ja (pārliecība < 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() Programma darbojas kā atpazinējs. Funkcija pareģot () prognozē dažādas uzņemtās sejas daļas kā atšķirīgus parametrus un atgriežas saglabātajā īpašniekā, vienlaikus parādot ID.
Ja seja neatpazīst seju, attēlā būs redzams “nezināms”.
Tātad, Voila!
Visbeidzot, Ieskats
Tātad, šādi jūs izveidojat Raspberry Pi sejas atpazīšanu. Lai iegūtu vislabāko rezultātu, noteikti sekojiet šim rakstam soli pa solim! Bez šī sejas atpazīšanas klasifikatora jūs varat arī veikt acu atpazīšanu vai smaida atpazīšanu, izmantojot dažādus klasifikatorus un funkcijas. Esmu izpētījis visus saistītos rakstus internetā un nācis klajā ar šo. Tāpēc es ļoti ceru, ka šī rokasgrāmata jums ir palīdzējusi projektos. Un es ceru, ka tas jums ir veiksmīgs. Neaizmirstiet pieminēt savas domas komentāru sadaļā!
