Reaalajas näotuvastus: otsast lõpuni projekt: 8 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:49

Minu viimasel OpenCV -d uurival õpetusel õppisime AUTOMATIC VISION OBJECT TRACKING. Nüüd kasutame oma PiCami nägude reaalajas tuvastamiseks, nagu näete allpool:

See projekt viidi läbi selle fantastilise "Open Source Computer Vision Library", OpenCV abil. Selles õpetuses keskendume Raspberry Pi (seega Raspbian kui OS) ja Pythonile, kuid testisin koodi ka My Macis ja see töötab ka hästi. OpenCV on loodud arvutusliku efektiivsuse tagamiseks ja keskendudes tugevalt reaalajas rakendustele. Niisiis, see sobib ideaalselt kaamera abil reaalajas näotuvastuseks.

Näotuvastuse täieliku projekti loomiseks peame töötama kolme väga erineva etapiga:

1. Näotuvastus ja andmete kogumine
2. Treenige äratundjat
3. Näotuvastus

Allolev plokkskeem jätkab neid etappe:

1. samm: BoM - materjali arve

Peamised osad:

1. Raspberry Pi V3 - 32,00 USA dollarit
2. 5 -megapiksline 1080p andur OV5647 minikaamera videomoodul - 13,00 USA dollarit

Samm: OpenCV 3 paketi installimine

Kasutan Raspberry Pi V3, mis on värskendatud Raspbiani (Stretch) viimasele versioonile, nii et parim viis OpenCV installimiseks on järgida Adrian Rosebrocki välja töötatud suurepärast õpetust: Raspbian Stretch: Installige oma Raspberry Pi -sse OpenCV 3 + Python.

Proovisin mitmeid erinevaid juhendeid OpenCV installimiseks oma Pi -le. Adriani õpetus on parim. Soovitan teil sama teha, järgides tema juhiseid samm-sammult.

Kui olete Adriani õpetuse lõpetanud, peaks teil olema OpenCV virtuaalne keskkond, mis on valmis meie Pi peal katseid tegema.

Läheme oma virtuaalsesse keskkonda ja veendume, et OpenCV 3 on õigesti installitud.

Adrian soovitab käivitada käsu "allikas" iga kord, kui avate uue terminali, veendumaks, et teie süsteemi muutujad on õigesti seadistatud.

allikas ~/.profiil

Järgmisena siseneme oma virtuaalsesse keskkonda:

töö cv

Kui näete viipale eelnevat teksti (cv), olete CV virtuaalses keskkonnas:

(cv) pi@vaarikas: ~ $Adrian juhib tähelepanu sellele, et cv Pythoni virtuaalne keskkond on täiesti sõltumatu ja eraldatud Raspbian Stretchi allalaadimisel sisalduvast Pythoni vaikeversioonist. Seega ei ole kõik globaalsete saidipakettide kataloogi Pythoni paketid cv virtuaalses keskkonnas saadaval. Samamoodi ei ole kõik cv saidipakettidesse installitud Pythoni paketid Pythoni globaalsele installile saadaval

Nüüd sisestage oma Pythoni tõlk:

python

ja veenduge, et kasutate versiooni 3.5 (või uuemat)

Tõlgi sees (ilmub ">>>") importige OpenCV raamatukogu:

import cv2

Kui veateateid ei kuvata, on OpenCV õigesti installitud TEIE PYTHON VIRTUAALKESKKONNA.

Samuti saate kontrollida installitud OpenCV versiooni:

cv2._ versioon_

Ilmuma peaks 3.3.0 (või parem versioon, mille saab tulevikus välja anda). Ülaltoodud terminali printimise ekraan näitab eelnevaid samme.

3. samm: kaamera testimine

Kui olete oma RPi -sse installinud OpenCV, proovime kontrollida, kas teie kaamera töötab korralikult.

Eeldan, et teie Raspberry Pi -le on juba installitud PiCam.

Sisestage IDE -sse järgmine Pythoni kood:

import numpy np -na

import cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Kõrgus samas (True): ret, frame = cap.read () frame = cv2. flip (raam, -1) # Pööra kaamera vertikaalselt hall = cv2.cvtColor (raam, cv2. COLOR_BGR2GRAY) cv2.imshow ('raam', raam) cv2.imshow ('hall', hall) k = cv2.waitKey (30) & 0xff, kui k == 27: # murda korkist väljumiseks vajutage ESC. Release () cv2.destroyAllWindows ()

Ülaltoodud kood jäädvustab teie PiCami loodud videovoo, näidates nii BGR -värvi kui ka halli režiimi.

Pange tähele, et pöörasin kaamerat vertikaalselt selle kokkupanemise tõttu. Kui see pole teie juhtum, kommenteerige või kustutage käsurida "flip".

Koodi saate alla laadida ka minu GitHubist: simpleCamTest.py

Täitmiseks sisestage käsk:

python simpleCamTest.py

Programmi lõpetamiseks peate vajutama klaviatuuri klahvi [ESC].

Enne [ESC] vajutamist klõpsake hiirega videoaknal

Ülaltoodud pilt näitab tulemust.

Mõned tegijad leidsid kaamera avamisel probleeme (veateated "Kinnitus ebaõnnestus"). See võib juhtuda, kui kaamera pole OpenCv installimise ajal lubatud ja kaamera draiverid ei installitud õigesti. Parandamiseks kasutage käsku:

sudo modprobe bcm2835-v4l2

Samuti saate faili bcm2835-v4l2 lisada faili /etc /modules viimasele reale, nii et draiver laaditakse alglaadimisel.

OpenCV kohta lisateabe saamiseks järgige õpetust: laadimine -video-python-opencv-tutorial

4. samm: näotuvastus

Näotuvastuse kõige põhilisem ülesanne on muidugi "Näotuvastus". Enne kui midagi teha, peate näo "jäädvustama" (1. etapp), et seda ära tunda, võrreldes tulevikku jäädvustatud uue näoga (3. etapp).

Kõige tavalisem näo (või mis tahes esemete) tuvastamise viis on Haar Cascade klassifikaatori kasutamine

Objektide tuvastamine, kasutades Haari funktsioonipõhiseid kaskaadiklassifikaatoreid, on tõhus objektide tuvastamise meetod, mille on välja pakkunud Paul Viola ja Michael Jones oma artiklis "Objektide kiire tuvastamine, kasutades lihtsate funktsioonide võimendatud kaskaadi" 2001. aastal. See on masinõppepõhine lähenemisviis, kus kaskaadfunktsiooni treenitakse paljude positiivsete ja negatiivsete piltide põhjal. Seejärel kasutatakse seda objektide tuvastamiseks teistel piltidel.

Siin töötame näotuvastusega. Alguses vajab algoritm klassifikaatori koolitamiseks palju positiivseid pilte (näopilte) ja negatiivseid (näota pilte). Siis peame sellest funktsioone välja võtma. Hea uudis on see, et OpenCV -l on kaasas treener ja detektor. Kui soovite koolitada oma klassifikaatorit mis tahes objekti jaoks, näiteks auto, lennukid jne, saate selle loomiseks kasutada OpenCV -d. Selle täielikud üksikasjad on toodud siin: Cascade Classifier Training.

Kui te ei soovi oma klassifikaatorit luua, sisaldab OpenCV juba palju eelnevalt koolitatud näo, silmade, naeratuse jne klassifikaatoreid. Neid XML-faile saab alla laadida kataloogist haarcascades.

Aitab teooriast, loome OpenCV abil näotuvastuse!

Laadige minu GitHubist alla fail: faceDetection.py.

import numpy np -na

import cv2 faceCascade = cv2. CascadeClassifier ('Cascades/haarcascade_frontalface_default.xml') cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Height samas True: ret, img = cap.read () img = cv2.flip (img, -1) hall = cv2.cvtVärv (img, cv2. COLOR_BGR2GRAY) näod = faceCascade.detectMultiScale (hall, scaleFactor = 1,2, minNeighbors = 5, minSize = (20, 20)) jaoks (x, y, w, h) nägudes: cv2. ristkülik (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = hall [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w] cv2.imshow ('video', img) k = cv2.waitKey (30) & 0xff, kui k == 27: # murda korkist väljumiseks vajutage ESC. Release () cv2.destroyAllWindows ()

Uskuge või mitte, kuid ülaltoodud koodirid on kõik, mida vajate näo tuvastamiseks, kasutades Pythoni ja OpenCV -d.

Kui võrrelda kaamera testimiseks viimati kasutatud koodiga, saate aru, et sellele on lisatud vähe osi. Pange tähele järgmist rida:

faceCascade = cv2. CascadeClassifier ('Cascades/haarcascade_frontalface_default.xml')

See on rida, mis laadib "klassifikaatori" (mis peab olema teie projekti kataloogi all kataloogis nimega "Cascades/").

Seejärel seadistame kaamera ja laadime silmuse sisse oma sisendvideo halltoonides (sama, mida nägime varem).

Nüüd peame kutsuma oma klassifikaatorifunktsiooni, andes sellele mõned väga olulised parameetrid, nagu skaala tegur, naabrite arv ja tuvastatud näo minimaalne suurus.

näod = faceCascade.detectMultiScale (hall, skaalaTegur = 1,2, min Naabrid = 5, minSuurus = (20, 20))

Kus,

• hall on sisestatud halltoonides pilt.
• scaleFactor on parameeter, mis määrab, kui palju vähendatakse pildi suurust igas pildiskaalas. Seda kasutatakse skaala püramiidi loomiseks.
• minNeighbors on parameeter, mis määrab kindlaks, kui palju naabreid peaks igal kandidaatnurgal olema selle säilitamiseks. Suurem arv annab vähem valepositiivseid tulemusi.
• minSize on minimaalne ristküliku suurus, mida tuleb näonahaks pidada.

Funktsioon tuvastab pildil olevad näod. Järgmisena peame pildil näod "märkima", kasutades näiteks sinist ristkülikut. Seda tehakse koodi selle osaga:

(x, y, w, h) nägude puhul:

cv2. täisnurk (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = hall [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w]

Kui leitakse nägusid, tagastab see tuvastatud nägude positsioonid ristkülikuna, mille vasak nurk on üles (x, y) ja mille laius on "w" ja kõrgus "=" (x, y, w, h). Palun vaadake ülaltoodud pilti.

Kui oleme need asukohad kätte saanud, saame näole luua "ROI" (joonistatud ristküliku) ja esitada tulemuse funktsiooniga imshow ().

Käivitage ülaltoodud pythoni skript oma pythoni keskkonnas, kasutades Rpi -terminali:

python faceDetection.py

Tulemus:

Võite lisada ka klassifikaatoreid silmade tuvastamiseks või isegi naeratuse tuvastamiseks. Nendel juhtudel lisate näo silmuse sisse klassifitseerimisfunktsiooni ja ristküliku joonistamise, sest väljaspool nägu pole mõtet silma või naeratust tuvastada.

Pange tähele, et kui Pi -l on sama koodiga mitu klassifikaatorit, aeglustub töötlemine, kui see tuvastamismeetod (HaarCascades) kasutab palju arvutusvõimsust. Töölaual on seda lihtsam kasutada.

Minu GitHubist leiate muid näiteid:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

Ja ülaltoodud pildil näete tulemust.

Näotuvastuse paremaks mõistmiseks võite järgida ka järgmist õpetust.

Haari kaskaadobjektide tuvastamise näo ja silma OpenCV Pythoni õpetus

5. samm: andmete kogumine

Kõigepealt pean tänama Ramiz Raja suurepärase töö eest näotuvastuse osas fotodel:

NÄOTUNNISTUS OPENCV JA PYTHONI KASUTAMISES: ALGATUSJUHEND

ja ka Anirban Kar, kes töötas video abil välja väga põhjaliku õpetuse:

NÄOTUNNISTUS - 3 osa

Ma tõesti soovitan teil vaadata mõlemat õpetust.

Seda öeldes alustame oma projekti esimest etappi. Siinkohal alustame viimasest etapist (näotuvastus), loome lihtsalt andmestiku, kuhu salvestame iga ID jaoks halli fotode rühma koos näo tuvastamiseks kasutatud osaga.

Kõigepealt looge kataloog, kus arendate oma projekti, näiteks FacialRecognitionProject:

mkdir FacialRecognitionProject

Selles kataloogis pidime peale 3 pythoni skripti, mille me oma projekti jaoks loome, olema sellele salvestanud ka näoklassifikaatori. Saate selle alla laadida minu saidilt GitHub: haarcascade_frontalface_default.xml

Seejärel looge alamkataloog, kuhu salvestame oma näoproovid ja nimetame selle "andmestikuks":

mkdir andmekogum

Ja laadige kood alla minu GitHubist: 01_face_dataset.py

import cv2

import os cam = cv2. VideoCapture (0) cam.set (3, 640) # video laiuse määramine cam.set (4, 480) # video kõrguse määramine face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # Iga inimese jaoks, sisestage üks numbriline näo ID face_id = sisend ('\ n sisestage kasutaja ID lõpp vajutage ==>') print ("\ n [INFO] Näo jäädvustamise initsialiseerimine. Vaadake kaamerat ja oodake…") # Individuaalse proovide võtmise nägude loendamine = 0 samas (True): ret, img = cam.read () img = cv2.flip (img, -1) # flip video image vertikaalselt hall = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) näod = face_detector.detectMultiScale (hall, 1.3, 5) (x, y, w, h) nägudel: cv2. ristkülik (img, (x, y), (x+w, y+h), (255, 0, 0), 2) count + = 1 # Salvesta jäädvustatud pilt andmekogumite kausta cv2.imwrite ("andmestik/kasutaja." + str (näo ID) + '.' + str (loend) + ".jpg", hall [y: y + h, x: x+w]) cv2.imshow ('pilt', img) k = cv2.waitKey (100) & 0xff # Videost väljumiseks vajutage klahvi ESC, kui k == 27: katkestuste arv> = 30: # Võtke 30 näoproovi ja lõpetage videopaus # Tehke ab it of cleanup print ("\ n [INFO] Programmist väljumine ja puhastusteave") cam.release () cv2.destroyAllWindows ()

Kood on väga sarnane koodiga, mida nägime näotuvastuse jaoks. Lisasime kasutaja ID sisestamiseks sisendkäsu, mis peaks olema täisarv (1, 2, 3 jne)

face_id = sisend ('\ n sisestage kasutaja ID lõpp vajutage ==>')

Ja iga jäädvustatud kaadri puhul peaksime selle salvestama failina andmekogumi kataloogi:

cv2.imwrite ("andmestik/kasutaja." + str (näo ID) + '.' + str (loend) + ".jpg", hall [y: y + h, x: x + w])

Pange tähele, et ülaltoodud faili salvestamiseks peate importima kogu "os". Iga faili nimi järgib struktuuri:

User.face_id.count.jpg

Näiteks kasutaja jaoks, kellel on face_id = 1, on andmestiku/ kataloogi neljas näidisfail midagi sellist:

Kasutaja.1.4.jpg

nagu on näidatud ülaltoodud fotol minu Pi -st. Oma koodi järgi jäädvustan igast id -st 30 näidist. Saate seda muuta viimasel "elifil". Proovide arvu kasutatakse silmuse katkestamiseks, kus näoproovid on jäädvustatud.

Käivitage Pythoni skript ja jäädvustage mõned ID -d. Peate skripti käivitama iga kord, kui soovite uue kasutaja koondada (või muuta olemasoleva fotosid).

6. samm: treener

Selles teises etapis peame võtma kõik kasutajaandmed oma andmestikust ja "koolitama" OpenCV Recognizeri. Seda teeb otse konkreetne OpenCV funktsioon. Tulemuseks on.yml -fail, mis salvestatakse kataloogi "trainer/".

Alustame siis alamkataloogi loomist, kuhu salvestame koolitatud andmed:

mkdir treener

Laadige minu GitHubist alla teine pythoni skript: 02_face_training.py

import cv2

importige numpy np -na PIL -i importimisest Pildi importimine os # Näo kujutiste andmebaasi tee = 'andmestik' äratundja = cv2.face. LBPHFaceRecognizer_create () detektor = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # funktsioon piltide ja siltide andmete saamiseks: PIL_img = Image.open (imagePath).convert ('L') # teisenda see halltoonideks img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. split (".") [1]) näod = detektor.detectMultiScale (img_numpy) (x, y, w, h) nägudel: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Treenib nägusid. See võtab paar sekundit. Oota…") näod, ids = getImagesAndLabels (tee) tunnistaja.train (näod, np.array (id)) # Salvestage mudel treener/trainer.yml tunnistaja.write ('treener/treener.yml') # tunnistaja.save () töötas Macis, kuid mitte Pi -s # Printige nägude arv ja lõpetage programmi printimine ("\ n [INFO] {0} nägu on koolitatud. Programmist väljumine".format (len (np.unique (ids))))

Kontrollige, kas teie Rpi -sse on installitud PIL -kogu. Kui ei, käivitage terminalis järgmine käsk:

pip paigaldada padi

Kasutame äratundjana OpenCV paketis sisalduvat LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) näotuvastust. Teeme seda järgmises reas:

äratundja = cv2.face. LBPHFaceRecognizer_create ()

Funktsioon "getImagesAndLabels (tee)" võtab kõik fotod kataloogist: "dataset/", tagastab 2 massiivi: "Id" ja "näod". Nende massiivide sisendina treenime oma äratundjat:

tunnistaja.treen (näod, ID -d)

Selle tulemusel salvestatakse fail nimega "trainer.yml" meie loodud koolitajate kataloogi.

See on kõik! Lisasin viimase trükiväljaande, kus kinnitusena kuvasin, kasutaja nägude arvu, mida oleme koolitanud.

Iga kord, kui teostate esimest etappi, tuleb käivitada ka teine etapp

7. samm: äratundja

Nüüd oleme jõudnud oma projekti lõppfaasi. Siin jäädvustame oma kaamerasse värske näo ning kui sellel inimesel oli nägu varem jäädvustatud ja treenitud, teeb meie äratundja "ennustuse", mis tagastab oma ID ja indeksi, näidates, kui kindel on see vaste selle vaste puhul.

Laadime kolmanda faasi pythoni skripti alla minu GitHubist: 03_face_recognition.py.

import cv2

impordi numpy np -na importimise os äratundja = cv2.face. LBPHFaceRecognizer_create () tunnistaja.read ('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # ID -dega seotud nimed: näide ==> Marcelo: id = 1 jne nime = ['puudub', 'Marcelo', 'Paula', 'Ilza', 'Z ',' W '] # Initsialiseeri ja käivita reaalajas videosalvestus cam = cv2. VideoCapture (0) cam.set (3, 640) # seada video lai cam.set (4, 480) # video kõrguse määramine # Määra minimaalne akna suurus nägu minW = 0,1*nukk.get (3) minH = 0,1*nukk.get (4), samas kui tõene: ret, img = nukk.lugemine () img = cv2.flip (img, -1) # Flip vertikaalselt hall = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) näod = faceCascade.detectMultiScale (hall, scaleFactor = 1,2, minNeighbors = 5, minSize = (int (minW), int (minH)),) (x, y, w, h) nägudes: cv2. täisnurk (img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, usaldus = tunnustaja.prognoos (hall [y: y+h, x: x+w]) # Kontrollige, kas enesekindlus on väiksem 100 ==> "0" sobib ideaalselt, kui (usaldus <100): id = nimed [id] usaldus = "{0}% ".format (ümmargune (100 - usaldus)) else: id =" tundmatu "usaldus =" {0}%". format (ümmargune (100 - conf idence)) cv2.putText (img, str (id), (x+5, y-5), font, 1, (255, 255, 255), 2) cv2.putText (img, str (usaldus), (x+5, y+h-5), font, 1, (255, 255, 0), 1) cv2.imshow ('kaamera', img) k = cv2.waitKey (10) & 0xff # Vajutage 'ESC' videost väljumiseks, kui k == 27: break # Tehke natuke puhastustrükki ("\ n [INFO] Programmist väljumine ja koristustööd") cam.release () cv2.destroyAllWindows ()

Lisame siia uue massiivi, seega kuvame nummerdatud ID -de asemel „nimed”:

nimed = ['puudub', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Nii näiteks: Marcelo teeb kasutaja id = 1; Paula: id = 2 jne.

Järgmisena tuvastame näo, sama tegime varem haasCascade klassifikaatoriga. Tuvastatud näo korral võime nimetada ülaltoodud koodi kõige olulisemaks funktsiooniks:

id, usaldus = tunnustaja. ennustus (näo hall osa)

Tunnistaja.predict () võtab parameetriks analüüsitava näo jäädvustatud osa ja tagastab selle tõenäolise omaniku, näidates ära selle ID ja selle usalduse suuruse seoses selle vastega.

Pange tähele, et usaldusindeks tagastab nulli, kui seda loetakse ideaalseks sobivuseks

Ja lõpuks, kui äratundja oskas nägu ette näha, panime pildi kohale teksti, millel on tõenäoline id ja kui suur on "tõenäosus" protsentides, et vaste on õige ("tõenäosus" = 100 - usaldusindeks). Kui ei, siis pannakse näole silt "tundmatu".

Allpool-g.webp

Ülaltoodud pildil näitan mõningaid selle projektiga tehtud katseid, kus olen kasutanud ka fotosid, et kontrollida, kas äratundja töötab.

8. samm: järeldus

Nagu alati, loodan, et see projekt aitab teistel leida tee põnevasse elektroonikamaailma!

Üksikasjade ja lõpliku koodi saamiseks külastage minu GitHubi hoidlat: OpenCV-Face-Recognition

Rohkemate projektide jaoks külastage palun minu ajaveebi: MJRoBot.org

Allpool pilguheit tulevasele õpetusele, kus uurime "automaatset näo jälgimist ja muid näotuvastuse meetodeid":

Tervitused maailma lõunaosast!

Kohtumiseni minu järgmises juhendis!

Aitäh, Marcelo