Valós idejű arcfelismerés: teljes projekt: 8 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:43

Az OpenCV -t feltáró utolsó oktatóanyagomon megtanultuk az AUTOMATIC VISION OBJECT TRACKING -et. Most a PiCam segítségével valós időben felismerjük az arcokat, amint az alább látható:

Ez a projekt ezzel a fantasztikus "Open Source Computer Vision Library" -vel, az OpenCV -vel készült. Ezen az oktatóanyagon a Raspberry Pi -re (tehát Raspbian, mint operációs rendszer) és a Pythonra fogunk összpontosítani, de teszteltem a kódot a Mac -en is, és az is jól működik. Az OpenCV-t a számítás hatékonyságára tervezték, és nagy hangsúlyt fektetett a valós idejű alkalmazásokra. Tehát tökéletes a valós idejű arcfelismeréshez fényképezőgéppel.

Az arcfelismerésről szóló teljes projekt létrehozásához három nagyon különböző fázison kell dolgoznunk:

1. Arcfelismerés és adatgyűjtés
2. Tanítsa meg a felismerőt
3. Arcfelismerés

Az alábbi tömbvázlat folytatja ezeket a fázisokat:

1. lépés: BoM - Bill of Material

Fő részek:

1. Raspberry Pi V3 - 32,00 USD
2. 5 megapixeles 1080p érzékelő OV5647 mini kamera videomodul - 13,00 USD

2. lépés: Az OpenCV 3 csomag telepítése

A Raspberry Pi V3 -at használom a Raspbian (Stretch) utolsó verziójára frissítve, így az OpenCV telepítésének legjobb módja az Adrian Rosebrock által kifejlesztett kiváló oktatóanyag követése: Raspbian Stretch: Telepítse az OpenCV 3 + Python -t a Raspberry Pi -re.

Többféle útmutatót próbáltam telepíteni az OpenCV -t a Pi -re. Adrian bemutatója a legjobb. Azt tanácsolom, hogy tegye meg ugyanezt, lépésről lépésre követve útmutatását.

Miután befejezte Adrian oktatóanyagát, rendelkeznie kell egy OpenCV virtuális környezettel, hogy futtassa kísérleteinket a Pi -n.

Menjünk a virtuális környezetünkbe, és győződjünk meg arról, hogy az OpenCV 3 helyesen van telepítve.

Adrian azt javasolja, hogy minden alkalommal, amikor új terminált nyit, futtassa a "source" parancsot, hogy megbizonyosodjon arról, hogy a rendszerváltozók helyesen vannak -e beállítva.

forrás ~/.profile

Ezután lépjünk be a virtuális környezetünkbe:

workon cv

Ha látja a kérést megelőző szöveget (cv), akkor a cv virtuális környezetben van:

(cv) pi@málna: ~ $Adrian felhívja a figyelmet arra, hogy a cv Python virtuális környezet teljesen független és el van választva a Raspbian Stretch letöltésében szereplő alapértelmezett Python verziótól. Tehát a globális site-package könyvtárban található bármely Python-csomag nem lesz elérhető a cv virtuális környezet számára. Hasonlóképpen, a cv site-csomagjaiba telepített bármely Python-csomag nem lesz elérhető a Python globális telepítéséhez

Most adja meg a Python tolmácsát:

piton

és erősítse meg, hogy a 3.5 (vagy újabb) verziót futtatja

A tolmács belsejében (a ">>>" jelenik meg) importálja az OpenCV könyvtárat:

import cv2

Ha nem jelenik meg hibaüzenet, akkor az OpenCV helyesen van telepítve a PYTHON VIRTUÁLIS KÖRNYEZETRE.

Ellenőrizheti a telepített OpenCV verziót is:

cv2._ verzió_

Meg kell jelennie a 3.3.0 -nak (vagy egy kiváló verziónak, amely a jövőben is megjelenhet). A fenti terminál nyomtatási képernyő az előző lépéseket mutatja.

3. lépés: A kamera tesztelése

Miután telepítette az OpenCV -t az RPi -be, ellenőrizze, hogy a kamera megfelelően működik -e.

Feltételezem, hogy a PiPam már telepítve van a Raspberry Pi -re.

Írja be az alábbi Python -kódot az IDE -be:

importálja a numpy -t np -ként

import cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Magasság míg (True): ret, frame = cap.read () frame = cv2. flip (keret, -1) # Flip kamera függőlegesen szürke = cv2.cvtColor (keret, cv2. COLOR_BGR2GRAY) cv2.imshow ('keret', keret) cv2.imshow ('szürke', szürke) k = cv2.waitKey (30) & 0xff, ha k == 27: # nyomja meg az "ESC" billentyűt, hogy kilépjen a töréskorlátból. Release () cv2.destroyAllWindows ()

A fenti kód rögzíti a PiCam által generált videófolyamot, mindkettőt megjelenítve BGR színű és szürke módban.

Vegye figyelembe, hogy a fényképezőgépet függőlegesen forgattam az összeszerelés módja miatt. Ha nem ez a te eseted, írj megjegyzést vagy töröld a "flip" parancssort.

Alternatívaként letöltheti a kódot a GitHub webhelyemről: simpleCamTest.py

A végrehajtáshoz írja be a következő parancsot:

python simpleCamTest.py

A program befejezéséhez nyomja meg az [ESC] gombot a billentyűzeten.

Kattintson az egérrel a videoablakra, mielőtt megnyomja az [ESC] gombot

A fenti kép az eredményt mutatja.

Egyes gyártók problémákat találtak a kamera megnyitása során ("Az érvényesítés sikertelen" hibaüzenetek). Ez akkor fordulhat elő, ha a fényképezőgépet nem engedélyezték az OpenCv telepítése során, és ezért a kamera illesztőprogramjai nem megfelelően lettek telepítve. A javításhoz használja a következő parancsot:

sudo modprobe bcm2835-v4l2

A bcm2835-v4l2 fájlt is hozzáadhatja az /etc /modules fájl utolsó sorához, így az illesztőprogram betöltődik.

Ha többet szeretne megtudni az OpenCV-ről, kövesse az oktatóanyagot: loading -video-python-opencv-tutorial

4. lépés: Arcfelismerés

Az arcfelismerés legalapvetőbb feladata természetesen az "Arcfelismerés". Mielőtt bármit is tennie kell, "el kell készítenie" egy arcot (1. fázis), hogy felismerje azt, összehasonlítva a jövőben rögzített új arccal (3. fázis).

Az arc (vagy bármely tárgy) észlelésének leggyakoribb módja a "Haar Cascade osztályozó"

Az objektumfelismerés Haar szolgáltatáson alapuló kaszkádosztályozók segítségével hatékony objektumfelismerési módszer, amelyet Paul Viola és Michael Jones javasolt a 2001-es "Rapid Object Detection using Boosted Cascade of Simple Features" című dokumentumában. Ez egy gépi tanuláson alapuló megközelítés, ahol egy a kaszkád funkciót sok pozitív és negatív képből képzik. Ezután más képeken lévő tárgyak észlelésére használják.

Itt az arcfelismeréssel fogunk dolgozni. Kezdetben az algoritmusnak sok pozitív képre (arckép) és negatív képre (arc nélküli képre) van szüksége az osztályozó képzéséhez. Akkor ki kell vonnunk belőle a funkciókat. A jó hír az, hogy az OpenCV oktatóval és érzékelővel is rendelkezik. Ha saját osztályozóját szeretné képezni bármilyen objektumhoz, például autóhoz, repülőgéphez stb., Akkor az OpenCV használatával létrehozhat egyet. A részletes információkat itt találja: Cascade Classifier Training.

Ha nem akarja létrehozni saját osztályozóját, az OpenCV már tartalmaz számos előre betanított osztályozót arcra, szemre, mosolyra stb. Ezek az XML fájlok letölthetők a haarcascades könyvtárból.

Elég elmélet, hozzunk létre egy arcérzékelőt OpenCV -vel!

Töltse le a fájlt: faceDetection.py a GitHub -ból.

importálja a numpy -t np -ként

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 while True: ret, img = cap.read () img = cv2.flip (img, -1) szürke = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) arcok = faceCascade.detectMultiScale (szürke, scaleFactor = 1,2, minSzomszédok = 5, minSize = (20, 20)) (x, y, w, h) arcokhoz: cv2.téglalap (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = szürke [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w] cv2.imshow ('videó', img) k = cv2.waitKey (30) & 0xff, ha k == 27: # nyomja meg az "ESC" billentyűt, hogy kilépjen a töréskorlátból. Release () cv2.destroyAllWindows ()

Akár hiszed, akár nem, a fenti néhány kódsor mindössze annyit tesz, hogy felismerjen egy arcot a Python és az OpenCV használatával.

Ha összehasonlítja a kamera teszteléséhez használt utolsó kóddal, rájön, hogy kevés alkatrész került hozzá. Vegye figyelembe az alábbi sort:

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

Ez az a sor, amely betölti az "osztályozót" (ennek a "Cascades/" nevű könyvtárban kell lennie, a projekt könyvtára alatt).

Ezután beállítjuk a kameránkat, és a cikluson belül betöltjük a bemeneti videónkat szürkeárnyalatos módban (ugyanazt láttuk korábban).

Most meg kell hívnunk az osztályozó függvényünket, és át kell adnunk néhány nagyon fontos paramétert, például a léptéktényezőt, a szomszédok számát és az észlelt arc minimális méretét.

arcok = faceCascade.detectMultiScale (szürke, skálaTényező = 1,2, perc Szomszédok = 5, minMéret = (20, 20))

Ahol,

• szürke a bemeneti szürkeárnyalatos kép.
• scaleFactor az a paraméter, amely meghatározza, hogy az egyes képskálákon mennyit csökken a képméret. A skálapiramis létrehozására szolgál.
• A minNeighbors egy paraméter, amely meghatározza, hogy az egyes jelölt téglalapoknak hány szomszédjuk legyen, hogy megtartsák azt. A magasabb szám alacsonyabb hamis pozitív eredményeket ad.
• A minSize a minimális téglalapméret, amelyet arcnak kell tekinteni.

A funkció érzékeli az arcokat a képen. Ezt követően meg kell jelölnünk az arcokat a képen, például egy kék téglalap segítségével. Ez a kód ezen részével történik:

(x, y, w, h) esetén:

cv2.téglalap (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = szürke [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w]

Ha arcokat talál, akkor az észlelt arcok helyzetét téglalapként adja vissza, bal bal sarokkal (x, y), szélessége "w", magassága pedig "h" ==> (x, y, w, h). Kérjük, nézze meg a fenti képet.

Miután megkaptuk ezeket a helyeket, létrehozhatunk egy "ROI" -t (rajzolt téglalapot) az arc számára, és az eredményt imshow () függvénnyel mutathatjuk be.

Futtassa a fenti python szkriptet a python környezetében az Rpi terminál használatával:

python faceDetection.py

Az eredmény:

A "szemérzékelés" vagy akár a "mosolyfelismerés" osztályozókat is megadhatja. Ezekben az esetekben az osztályozó funkciót és a téglalaprajzot az archurok belsejébe fogja beépíteni, mert értelmetlen lenne szemet vagy mosolyt észlelni az arcon kívül.

Ne feledje, hogy a Pi -n, ha több osztályozó van ugyanazon a kódon, lelassul a feldolgozás, ha ez az észlelési módszer (HaarCascades) nagy számítási teljesítményt használ. Asztali számítógépen egyszerűbb futtatni.

A GitHub -on más példákat is talál:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

És a fenti képen láthatja az eredményt.

Az alábbi bemutatót követheti az arcfelismerés jobb megértése érdekében:

Haar Cascade Object Detection Face & Eye OpenCV Python bemutató

5. lépés: Adatgyűjtés

Először is meg kell köszönnöm Ramiz Raja -nak az arcfelismeréssel kapcsolatos remek munkáját a fotókon:

ARCFELISMERÉS OPENCV ÉS PYTHON HASZNÁLATÁVAL: KEZDŐI ÚTMUTATÓ

és Anirban Kar, aki egy nagyon átfogó oktatóanyagot dolgozott ki videó segítségével:

ARCFELISMERÉS - 3 rész

Nagyon ajánlom, hogy nézze meg mindkét oktatóanyagot.

Mondjuk így, kezdjük el projektünk első szakaszát. Itt az utolsó lépéstől (Arcfelismerés) fogunk kezdeni, egyszerűen létrehozunk egy adathalmazt, ahol minden azonosítóhoz tároljuk a szürke színű fényképek csoportját az arcfelismeréshez használt részekkel.

Először hozzon létre egy könyvtárat, ahol a projektet fejleszti, például FacialRecognitionProject:

mkdir FacialRecognitionProject

Ebben a könyvtárban a projektünkhöz létrehozandó 3 python -szkript mellett el kell mentenünk az Arcosztályozót is. Letöltheti a GitHub -ból: haarcascade_frontalface_default.xml

Ezután hozzon létre egy alkönyvtárat, ahol tároljuk arcmintáinkat, és nevezzük "adathalmaznak":

mkdir adatkészlet

És töltse le a kódot a GitHub -ból: 01_face_dataset.py

import cv2

import os cam = cv2. VideoCapture (0) cam.set (3, 640) # video szélesség beállítása cam.set (4, 480) # video magasság beállítása face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # Minden személy számára, adjon meg egy numerikus arcazonosítót face_id = input ('\ n adja meg a felhasználói azonosítót, nyomja meg ==>') print ("\ n [INFO] Az arcfelvétel inicializálása. Nézze meg a kamerát, és várjon…") # Egyéni mintavételi arcszámlálás inicializálása = 0 while (True): ret, img = cam.read () img = cv2.flip (img, -1) # flip videó kép függőlegesen szürke = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) arcok = face_detector.detectMultiScale (szürke, 1.3, 5) (x, y, w, h) esetén: cv2.téglalap (img, (x, y), (x+w, y+h), (255, 0, 0), 2)) count + = 1 # Mentse a rögzített képet a cv2.imwrite ("dataset/User." + str (face_id) + '.' + str (count) + ".jpg", szürke [y: y + h, x: x+w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # Nyomja meg az "ESC" gombot a kilépéshez, ha k == 27: break elif count> = 30: # Vegyen 30 arcmintát, és állítsa le a videó szünetet it of cleanup print ("\ n [INFO] Kilépés a programból és a tisztítási dolgokból") cam.release () cv2.destroyAllWindows ()

A kód nagyon hasonlít az arcfelismeréshez használt kódhoz. Hozzáadtuk egy „beviteli parancsot” egy felhasználói azonosító rögzítéséhez, amelynek egész számnak kell lennie (1, 2, 3 stb.)

face_id = input ('\ n adja meg a felhasználói azonosítót, nyomja meg ==>')

És minden egyes rögzített képkocka esetében el kell mentenünk fájlként egy "adatkészlet" könyvtárba:

cv2.imwrite ("adatkészlet/felhasználó." + str (face_id) + '.' + str (count) + ".jpg", szürke [y: y + h, x: x + w])

Ne feledje, hogy a fenti fájl mentéséhez importálnia kell az "os" könyvtárat. Minden fájl neve követi a struktúrát:

User.face_id.count.jpg

Például egy face_id = 1 felhasználóval az adathalmaz/ könyvtár 4. mintafájlja valami ilyesmi lehet:

Felhasználó.1.4.jpg

ahogy az a fenti fotón látható a Pi -ből. A kódomon 30 mintát rögzítek minden azonosítóból. Meg lehet változtatni az utolsó "elif" -en. A minták számát arra használják, hogy megszakítsák azt a hurkot, ahol az arcmintákat rögzítik.

Futtassa a Python szkriptet, és rögzítsen néhány azonosítót. A szkriptet minden alkalommal futtatnia kell, amikor új felhasználót szeretne összesíteni (vagy módosítani szeretné a már létező fényképeket).

6. lépés: Edző

Ebben a második fázisban ki kell vennünk az összes felhasználói adatot az adatkészletünkből, és "oktatnunk" kell az OpenCV Recognizer -t. Ezt közvetlenül egy adott OpenCV függvény végzi. Az eredmény egy.yml fájl lesz, amely a "trainer/" könyvtárba kerül.

Tehát kezdjünk el létrehozni egy alkönyvtárat, ahol a betanított adatokat tároljuk:

mkdir tréner

Töltse le a GitHub -ból a második python -szkriptet: 02_face_training.py

import cv2

importálja a numpy -t np -ként a PIL importálásából Képimportálás os # Útvonal az arc képadatbázisának elérési útjához = 'adatkészlet' felismerő = cv2.face. LBPHFaceRecognizer_create () detektor = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # függvény a képek és a címkeadatok lekéréséhez def getImagesAndLabels (elérési út): imagePaths = [os.path.join (elérési út, f) az f -hez os.listdir (elérési út)] faceSamples = ids = az imagePath -hoz imagePaths: PIL_img = Image.open (imagePath).convert ('L') # konvertálja szürkeárnyalatosra img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. osztott (".") [1]) arcok = detektor.detectMultiScale (img_numpy) (x, y, w, h) esetén: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Képzési arcok. Néhány másodpercbe telik. Várjon…") arcok, ids = getImagesAndLabels (elérési út) felismerő.train (arcok, np.array (ids)) # Mentse el a modellt a trainer/trainer.yml fájlba. ("\ n [INFO] {0} képzett arcok. Kilépés a programból".format (len (np.unique (ids)))))

Győződjön meg arról, hogy a PIL könyvtár telepítve van -e az Rpi készüléken. Ha nem, futtassa az alábbi parancsot a terminálon:

pip szerelje párna

Felismerőként az LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) arcfelismerőt fogjuk használni, amely az OpenCV csomagban található. Ezt a következő sorban tesszük:

felismerő = cv2.face. LBPHFaceRecognizer_create ()

A "getImagesAndLabels (elérési út)" függvény az összes fényképet elkészíti a "dataset/" könyvtárban, és két tömböt ad vissza: "azonosítók" és "arcok". Ha ezeket a tömböket használja bemenetként, "betanítjuk a felismerőnket":

felismerő.vonat (arcok, azonosítók)

Ennek eredményeként a "trainer.yml" nevű fájl a korábban általunk létrehozott oktatókönyvtárba kerül.

Ez az! Mellékeltem az utolsó nyomtatott nyilatkozatot, ahol megerősítésként megjelenítettem, a Felhasználó által képzett arcok számát.

Minden alkalommal, amikor végrehajtja az 1. fázist, a 2. fázist is le kell futtatni

7. lépés: Felismerő

Most elérkeztünk a projektünk utolsó szakaszához. Itt egy friss arcot rögzítünk a fényképezőgépünkön, és ha ennek a személynek az arcát korábban rögzítették és kiképezték, akkor a felismerőnk "jóslatot" tesz, és visszaadja azonosítóját és indexét, megmutatva, mennyire magabiztos a felismerő ezzel a mérkőzéssel.

Töltsük le a 3. fázisú python -szkriptet a GitHub -ból: 03_face_recognition.py.

import cv2

importálja a számjegyeket np -ként import os felismerő = cv2.face. LBPHFaceRecognizer_create () felismerő.read ('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # azonosítókhoz kapcsolódó nevek: example ==> Marcelo: id = 1, etc names = ['Nincs', 'Marcelo', 'Paula', 'Ilza', 'Z ',' W '] # Inicializálja és indítsa el a valós idejű videó rögzítést. arcként kell felismerni minW = 0,1*cam.get (3) minH = 0,1*cam.get (4), míg True: ret, img = cam.read () img = cv2.flip (img, -1) # Függőlegesen szürke = cv2.cvt w y: y+h, x: x+w]) # Ellenőrizze, hogy a magabiztosság kisebb -e. ".format (kerek (100 - megbízhatóság)) else: id =" ismeretlen "konfidencia =" {0}%". format (forduló (100 - konf idence)) cv2.putText (img, str (id), (x+5, y-5), font, 1, (255, 255, 255), 2) cv2.putText (img, str (megbízhatóság), (x+5, y+h-5), betűtípus, 1, (255, 255, 0), 1) cv2.imshow ('kamera', img) k = cv2.waitKey (10) & 0xff # Nyomja meg az 'ESC' gombot a kilépő videóból, ha k == 27: break # Végezzen egy kis tisztítást ("\ n [INFO] Kilépés a programból és a tisztítási dolgokból") cam.release () cv2.destroyAllWindows ()

Itt egy új tömböt is beillesztünk, így a számozott azonosítók helyett "neveket" fogunk megjeleníteni:

names = ['Nincs', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Így például: Marcelo fogja az id = 1 felhasználót; Paula: id = 2 stb.

Ezután egy arcot észlelünk, ugyanúgy, mint korábban a haasCascade osztályozónál. Ha észlelt arcunk van, a fenti kód legfontosabb funkcióját hívhatjuk meg:

azonosító, bizalom = felismerő. előrejelzés (az arc szürke része)

A felismerő.prediktum () paraméterként az arc elfoglalt részét veszi figyelembe elemzésre, és visszaadja valószínű tulajdonosát, jelezve azonosítóját és azt, hogy a felismerő mennyire bízik ebben a mérkőzésben.

Ne feledje, hogy a megbízhatósági index "nullát" ad vissza, ha tökéletes egyezésnek minősül

És végül, ha a felismerő meg tudott jósolni egy arcot, akkor egy szöveget helyeztünk a képre a valószínű azonosítóval, és mennyi a "valószínűség" % -ban, hogy az egyezés helyes ("valószínűség" = 100 - bizalmi index). Ha nem, akkor "ismeretlen" címkét helyeznek az arcra.

Alább egy-g.webp

A fenti képen néhány, ezzel a projekttel végzett tesztet mutatok be, ahol fényképekkel is ellenőriztem, hogy a felismerő működik -e.

8. lépés: Következtetés

Mint mindig, remélem, hogy ez a projekt segíthet másoknak is eligazodni az elektronika izgalmas világában!

A részletekért és a végső kódért keresse fel a GitHub letéteményemet: OpenCV-Face-Recognition

További projektekért látogasson el a blogomra: MJRoBot.org

Az alábbiakban egy pillantást vetünk egy jövőbeli oktatóanyagra, ahol az „automatikus arckövetést és az arcfelismerés egyéb módszereit” vizsgáljuk:

Üdvözlet a világ déli részéről!

Találkozunk a következő tanításomban!

Köszönöm, Marcelo