Kaip sukurti „Raspberry Pi“ veido atpažinimo projektą

„Raspberry Pi“ yra nebrangus mini kompiuteris, kuris daugeliui žmonių, įskaitant studentus ir mėgėjus, žymiai palengvino skaičiavimą ir programavimą. Šis mini kompiuteris gali viską, ką gali padaryti stalinis kompiuteris, nuo naršymo internete iki įdomių projektų ir programų kūrimo. Ir vienas iš šių nuostabių projektų yra „Raspberry Pi“ veido atpažinimas. Nors šis projektas gali būti labai įdomus, jį padaryti nėra labai lengva. Taigi, aš rekomenduočiau jums sekti straipsnį žingsnis po žingsnio.

Aviečių Pi veido atpažinimas

Veido atpažinimo programos sukūrimas vieną kartą galėjo būti labai sunkus ir pažangus dalykas. Bet naudojant „Raspberry Pi“ niekas nėra per sunku! Šiame straipsnyje aš panaudojau „Open Source Computer Vision Library“ („OpenCV“) projektą.

Ši saugykla buvo sukurta dirbti su skaičiavimo efektyvumu ir realaus laiko programomis. Taigi, tai idealu mūsų realaus laiko veido atpažinimo programai. Šis straipsnis padės jums žingsnis po žingsnio per visą projektą. Taigi, laikykitės pabaigos, kad turėtumėte savo „Raspberry Pi“ veido atpažinimo funkciją!

Reikalavimai

Norėdami sukurti „Raspberry Pi“ veido atpažinimo sistemą, jums reikės šių dalykų:

1. Aviečių Pi V4
2. „Noir“ kamera
3. „OpenCV“

Aviečių Pi jungtys

Prieš pradėdami koduoti, būtinai sukurkite šiuos ryšius:

1. Užmegzkite ryšį tarp „Raspberry Pi“ ir „Ribbon“ kabelio iš „Display“
2. Pritvirtinkite SDA prie savo Pi SDA kaiščio
3. Įdėkite SCL iš ekrano į SCL kaištį
4. Pritvirtinkite fotoaparato juostelės laidą prie „Raspberry Pi“
5. Įdėkite GND iš ekrano į Pi GND
6. Prijunkite „Raspberry Pi 5V“ ir 5V ekraną

1 žingsnis: įdiekite „OpenCV“ į „Raspberry Pi“

Pirmasis žingsnis yra įdiegti „OpenCV“ savo „Pi“ įrenginyje. Norėdami tai padaryti, paleiskite „Raspberry Pi“ ir atidarykite SSH ryšį. Norėdami įtraukti visą laisvą vietą „micro-SD“ kortelėje, išplėskite failų sistemą.

$ sudo raspi-config

Tada meniu pasirinkite „Išplėstinės parinktys“ ir „Išplėsti failų sistemą“:

Po to paspauskite „“ mygtuką ir perkraukite savo „Raspberry Pi“.

$ sudo perkrauti

2 žingsnis: Patvirtinkite „OpenCV“ diegimą

Kai baigsite perkrauti, jūsų „Pi“ turėtų būti paruošta „OpenCV“ virtuali aplinka. Dabar turėtumėte patvirtinti, ar „OpenCV“ tinkamai įdiegta jūsų „Pi“. Vykdykite komandą „source“ kiekvieną kartą, kai atidarote naują terminalą, kad sistemos kintamieji būtų tinkamai nustatyti.

šaltinis ~ /.profilis

Dabar įveskite savo virtualią aplinką:

workon cv

(Cv) tekstas reiškia, kad esate virtualioje cv aplinkoje.

(cv) pi @ avietė: ~ $

Norėdami įvesti į „Python“ vertėją:

pitonas

Jūs pamatysite, kad vertėjas pasirodys „>>>“. Norėdami importuoti „OpenCV“ biblioteką:

importuoti cv2

Jei klaidos pranešimų nėra, galite būti tikri, kad „OpenCV“ įdiegta tinkamai.

3 žingsnis: Atsisiųskite „OpenCV“

Dabar atsisiųskite įdiegtą „OpenCV“. Turėsite atsisiųsti tiek „OpenCV“, tiek „OpenCV“ įnašus. „Contrib“ yra moduliai ir funkcijos, kurių jums prireiks šiame eksperimente.

$ cd ~ $ wget -O atidarymas.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.užtrauktukas

Dabar išarchyvuokite archyvus:

$ išpakuokite opencv.zip $ išpakuokite opencv_contrib.užtrauktukas

4 žingsnis: įdiekite priklausomybes

Dabar įdiekite reikalingas „OpenCV“ priklausomybes savo „Raspberry Pi“, kad jis veiktų tinkamai:

$ 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- gauti įdiegti python2.7-dev python3-dev $ sudo apt-get įdiekite python3-pil.imagetk

5 žingsnis: įdiekite pip

Šiame žingsnyje turėsite įdiegti „python“ paketų tvarkyklę, vadinamą „pip“.

$ wget https: // bootstrap.pypa.io / get-pip.py $ sudo python3 get-pip.py

6 žingsnis: įdiekite „Numpy“

Po to įdiekite python biblioteką pavadinimu „Numpy“.

$ Pip3 įdiegti numerį

7 veiksmas: išbandykite kamerą

Dabar, kai įdiegėte visus reikalingus dalykus, įskaitant „OpenCV“, laikas patikrinti, ar jūsų fotoaparatas veikia tinkamai. Savo „Raspberry Pi“ turėtumėte jau įdiegti „Picam“. „Python IDE“ įveskite šį kodą:

import numerį kaip np importuoti cv2 cap = cv2.„VideoCapture“ (0) dangtelis.rinkinys (3 640) # rinkinys Pločio dangtelis.set (4480) # set Aukštis, kol (True): ret, rėmas = dangtelis.read () rėmas = cv2.apversti (kadras, -1) # Apverskite fotoaparatą vertikaliai pilka = cv2.„cvtColor“ (rėmas, cv2.COLOR_BGR2GRAY) cv2.„imshow“ („rėmas“, rėmelis) cv2.imshow ('pilka', pilka) k = cv2.waitKey (30) & 0xff, jei k == 27: # paspauskite „ESC“, kad uždarytumėte pertraukos ribą.paleisti () cv2.destrAllWindows ()

Šis kodas užfiksuoja jūsų „PiCam“ sugeneruotą vaizdo srautą, kuriame rodomas ir pilkas, ir BGR spalvų režimas. Tada vykdykite kodą naudodami šią komandą:

python simpleCamTest.py

Norėdami užbaigti programą, paspauskite [ESC] mygtuką. Prieš baigdami, būtinai spustelėkite vaizdo įrašo langą. Dabar turėtumėte pamatyti, kaip fotoaparatas veikia tinkamai ir rodo rezultatus. Jei fotoaparate rodomi klaidos pranešimai „Nepatvirtinta“, naudokite šią komandą, kad išspręstumėte tai:

sudo modprobe bcm2835-v4l2

8 žingsnis: veido aptikimas

Turėtumėte žinoti, kad pirmas žingsnis užbaigiant mūsų veido atpažinimo projektą yra priversti „PiCam“ užfiksuoti veidą. Be abejo, pirmiausia jis turi aptikti veidą, kad ateityje jį atpažintų.

Veido aptikimo algoritmui reikalingi vaizdai su veidu, taip pat be veido, kad mokytų klasifikatorių ir išsaugotų struktūras nuo jų. Laimei, iš anksto atsisiųstame „OpenCV“ yra detektorius ir treniruoklis. Be to, jis jau turi keletą iš anksto apmokytų klasifikatorių, tokių kaip veidas, akys, rankos ir kt. Norėdami sukurti veido detektorių su „OpenCV“, naudokite šiuos kodus:

import numerį kaip np importuoti cv2 faceCascade = cv2.„CascadeClassifier“ ('Kaskados / haarcascade_frontalface_default.xml ') dangtelis = cv2.„VideoCapture“ (0) dangtelis.rinkinys (3 640) # rinkinys Pločio dangtelis.set (4,480) # set Aukštis, o True: ret, img = cap.perskaityti () img = cv2.apversti (img, -1) pilka = cv2.„cvtColor“ (img, cv2.COLOR_BGR2GRAY) veidai = faceCascade.aptiktiMultiScale (pilka, scaleFactor = 1.2, min Kaimynai = 5, min Dydis = (20, 20)) (x, y, w, h) veiduose: cv2.stačiakampis (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = pilkas [y: y + h, x: x + w] roi_color = img [ y: y + h, x: x + w] cv2.imshow ('video', img) k = cv2.waitKey (30) & 0xff, jei k == 27: # paspauskite „ESC“, kad išeitumėte iš pertraukos dangtelio.paleisti () cv2.destrAllWindows ()

Dabar turėsite iškviesti klasifikatoriaus funkciją su tam tikrais mastelio veiksniais, parametrais ir minimaliu veido dydžiu, kurį ji aptiks.

veidai = faceCascade.aptiktiMultiScale (pilka, scaleFactor = 1.2, min. Kaimynai = 5, min. Dydis = (20, 20))

Šis kodas aptinka veidus atvaizde. Dabar galite pažymėti veidus naudodami formą kaip stačiakampį. Norėdami tai padaryti, naudokite šį kodą:

už (x, y, w, h) veiduose: cv2.stačiakampis (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = pilkas [y: y + h, x: x + w] roi_color = img [ y: y + h, x: x + w]

Taigi, taip jis veikia:

Jei klasifikatorius randa paveikslėlyje veidų, jis nurodo veido padėtį stačiakampiu, kaip nurodyta komandoje, kur jis naudoja „h“ kaip aukštį, o „w“ - kaip plotį ir kairiuosius aukštyn kampus (x, y). Tai beveik apibendrina mūsų stačiakampį (x, y, w, h).

Kai baigsite vietas, sukurkite veido „IG“ ir parodykite rezultatą naudodami funkciją „imshow“). Paleiskite jį python aplinkoje naudodami „Raspberry Pi“ terminalą:

python faceDetection.py

Ir rezultatas:

9 žingsnis: Duomenų išsaugojimas

Šioje dalyje turite sukurti duomenų rinkinį, kuriame jūsų programa išsaugos surinktus duomenis apie aptiktus veido ID. Norėdami tai padaryti, sukurkite katalogą (naudoju „FacialRecognition“):

mkdir veido atpažinimas

Dabar sukurkite pakatalogį pavadinimu „duomenų rinkinys“.

„mkdir“ duomenų rinkinys

Tada naudokite šį kodą:

import cv2 import os cam = cv2.„VideoCapture“ (0) kamera.rinkinys (3, 640) # nustatytas vaizdo pločio vaizdo kamera.nustatyti (4, 480) # nustatyti vaizdo aukštį face_detector = cv2.„CascadeClassifier“ ('haarcascade_frontalface_default.xml ') # Kiekvienam asmeniui įveskite vieną skaitinį veido ID face_id = input (' \ n įveskite vartotojo ID pabaigos paspauskite  ==> ') print ("\ n [INFO] Inicijuojamas veido fiksavimas. Pažvelkite į fotoaparatą ir palaukite ... ") # Inicializuokite individualų mėginių ėmimo veidų skaičių = 0, o (Tiesa): ret, img = kumštelis.perskaityti () img = cv2.apversti (img, -1) # vaizdo vaizdo vaizdas vertikaliai pilkas = cv2.„cvtColor“ (img, cv2.COLOR_BGR2GRAY) veidai = veido detektorius.nustatyti „MultiScale“ (pilka, 1.3, 5) (x, y, w, h) veiduose: cv2.stačiakampis (img, (x, y), (x + w, y + h), (255,0,0), 2) count + = 1 # Įrašytą vaizdą išsaugokite duomenų rinkinių aplanke cv2.imwrite ("duomenų rinkinys / Vartotojas."+ str (face_id) + '.„+ str (skaičius) +“.jpg ", pilka [y: y + h, x: x + w]) cv2.imshow ('vaizdas', img) k = cv2.waitKey (100) & 0xff # Norėdami išeiti iš vaizdo įrašo, paspauskite „ESC“, jei k == 27: pertraukos elifų skaičius> = 10: # Imkite 10 veido pavyzdžių ir sustabdykite vaizdo pertrauką # Atlikite šiek tiek valymo spausdinimo funkciją ("\ n [INFO] Išeinama iš programos ir valymo dalykų “) kamera.paleisti () cv2.destrAllWindows ()

Atkreipkite dėmesį, kad kiekvieną užfiksuotą rėmelį išsaugosime kaip failą pakatalogyje „duomenų rinkinys“:

cv2.imwrite ("duomenų rinkinys / Vartotojas."+ str (face_id) + '.„+ str (skaičius) +“.JPG ", pilka [y: y + h, x: x + w])

Po to, norėdami išsaugoti aukščiau esantį failą, turite importuoti „os“ biblioteką. Failų pavadinimai bus tokie:

Vartotojas.face_id.suskaičiuoti.JPG, / pre>

Aukščiau paminėtas kodas užfiksuos tik 10 vaizdų kiekvienam ID. Jei norite, galite tai tikrai pakeisti.
Dabar pabandykite paleisti programą ir užfiksuokite keletą ID. Būtinai paleiskite kodą kiekvieną kartą, kai pakeisite naudotoją ar esamą nuotrauką.

10 žingsnis: treneris

Atlikdami šį veiksmą, turėsite naudoti „OpenCV“ funkciją, kad mokytumėte „OpenCV“ atpažintuvą naudodami duomenis iš jūsų duomenų rinkinio. Pirmiausia sukurkite pakatalogį, kuriame bus saugomi apmokyti duomenys.

mkdir treneris

Tada paleiskite šį kodą:

importuoti cv2 importuoti numerį kaip np iš PIL importuoti vaizdą importuoti os # veido atvaizdų duomenų bazės kelias path = 'duomenų rinkinys' tunnistiklis = cv2.veidas.LBPHFaceRecognizer_create () detektorius = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml "); # funkcija norint gauti vaizdus ir etikečių duomenis def getImagesAndLabels (kelias): imagePaths = [os.kelias.prisijungti (kelias, f) už f in os.listdir (path)] faceSamples = [] ids = [] „imagePath“ programoje „imagePaths“: PIL_img = Image.atidaryti („imagePath“).konvertuoti ('L') # konvertuoti į pilkos spalvos skalę img_numpy = np.masyvas (PIL_img, 'uint8') id = int (os.kelias.padalinti („imagePath“) [- 1].padalinti (".") [1]) veidai = detektorius.„detMultiScale “(img_numpy) (x, y, w, h) veidams: faceSamples.pridėti (img_numpy [y: y + h, x: x + w]) ID.pridėti (id) return faceMėginiai, ids print ("\ n [INFO] Treniruočių veidai. Tai užtruks kelias sekundes. Palaukite ... ") veidai, ids = getImagesAndLabels (kelio) atpažintuvas.traukinys (veidai, np.masyvas (ID)) # Išsaugokite modelį treniruoklyje.yml atpažintuvas.rašyti ('treneris / treneris.yml ') # atpažintuvas.save () dirbo „Mac“, bet ne „Pi“ # Spausdinkite išmokytų veidų skaičių ir baigkite programos spausdinimą ("\ n [INFO] 0 išmokyti veidai. Išeinama iš programos ".formatas (len (np.unikalus (ID))))

Įsitikinkite, kad „Raspberry Pi“ įdiegėte PIL biblioteką. Jei to neturite, vykdykite šią komandą:

pip montuoti pagalvę

Čia aš naudoju LBPH veido atpažintuvą, kuris yra kartu su „OpenCV“ paketu. Laikykitės šios eilutės:

atpažintuvas = cv2.veidas.LBPHFaceRecognizer_create ()

Visos jūsų nuotraukos bus perkeltos į „duomenų rinkinio“ katalogą naudojant funkciją „getImagesAndLabels“. Jis grąžins 2 masyvus pavadinimu „ID“ ir „veidai“. Dabar atėjo laikas mokyti atpažintuvą.

atpažintojas.traukinys (veidai, tapatybės dokumentai)

Dabar pamatysite „trenerį.yml “pavadinimu failas išsaugotas trenerio kataloge.

11 žingsnis: veido atpažinimas

Atėjo laikas paskutiniam veiksmui. Po šio veiksmo jūsų atpažintuvas gali atspėti grįžtamąjį ID, jei veidas buvo užfiksuotas anksčiau. Taigi, parašykime savo galutinį kodą:

import cv2 import numerį kaip np import os atpažintuvas = cv2.veidas.LBPHFaceRecognizer_create () atpažintuvas.skaityti ('treneris / treneris.yml ') cascadePath = "haarcascade_frontalface_default.xml "faceCascade = cv2.CascadeClassifier (cascadePath); font = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # pavadinimai, susiję su ID: example ==> Marcelo: id = 1, etc. names = ['Nėra', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Inicializuokite ir paleiskite realaus laiko vaizdo įrašymo kamerą = cv2.„VideoCapture“ (0) kamera.rinkinys (3, 640) # rinkinys vaizdo plačiakampio vaizdo.nustatyti (4, 480) # nustatyti vaizdo aukštį # Apibrėžti minimalų lango dydį, kuris bus atpažįstamas kaip veidas minW = 0.1 * kumštelis.gauti (3) minH = 0.1 * kumštelis.gauti (4), o tiesa: ret, img = kumštelis.perskaityti () img = cv2.apversti (img, -1) # Apversti vertikaliai pilka = cv2.„cvtColor“ (img, cv2.COLOR_BGR2GRAY) veidai = faceCascade.aptiktiMultiScale (pilka, scaleFactor = 1.2, min Kaimynai = 5, min Dydis = (int (minW), int (minH)),) (x, y, w, h) veiduose: cv2.stačiakampis (img, (x, y), (x + w, y + h), (0,255,0), 2) id, pasitikėjimas = atpažintuvas.numatyti (pilka [y: y + h, x: x + w]) # Patikrinkite, ar pasitikėjimas yra mažesnis, jei 100 (= pasitikėjimas) < 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()

Programa veikia kaip atpažintuvas. Numatyti () funkcija ima skirtingas užfiksuoto veido dalis kaip skirtingus parametrus ir grąžinama išsaugotam savininkui, rodant ID.
Jei veidas neatpažins, paveikslėlyje bus rodoma „nežinoma“.

Taigi, Voila!

Galiausiai, įžvalgos

Taigi, taip jūs darote „Raspberry Pi“ veido atpažinimo funkciją. Norėdami gauti geriausią rezultatą, būtinai sekite šį straipsnį žingsnis po žingsnio! Be šio veido atpažinimo klasifikatoriaus, taip pat galite atpažinti akis ar atpažinti šypseną naudodami skirtingus klasifikatorius ir funkcijas. Aš ištyriau visus susijusius straipsnius internete ir sugalvojau šį. Taigi, labai tikiuosi, kad šis vadovas jums padėjo įgyvendinant projektus. Tikiuosi, kad tai jums pavyks. Nepamirškite paminėti savo minčių komentarų skiltyje!