Pagkilala sa Real-time na Mukha: isang End-to-end na Proyekto: 8 Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:14

Sa aking huling tutorial na paggalugad sa OpenCV, natutunan namin ang AUTOMATIC VISION OBJECT TRACKING. Gagamitin namin ngayon ang aming PiCam upang makilala ang mga mukha sa real-time, tulad ng nakikita mo sa ibaba:

Ang proyektong ito ay tapos na sa kamangha-manghang "Open Source Computer Vision Library", ang OpenCV. Sa tutorial na ito, magtutuon kami sa Raspberry Pi (kaya, Raspbian bilang OS) at Python, ngunit sinubukan ko rin ang code sa My Mac at gumagana rin ito nang maayos. Ang OpenCV ay idinisenyo para sa kahusayan sa computational at may isang malakas na pagtuon sa mga real-time na application. Kaya, perpekto ito para sa real-time na pagkilala sa mukha gamit ang isang camera.

Upang lumikha ng isang kumpletong proyekto sa Pagkilala sa Mukha, dapat kaming gumana sa 3 magkakakaibang mga phase:

1. Pagtuklas sa Mukha at Pagtitipon ng Data
2. Sanayin ang Recognizer
3. Pagkilala sa Mukha

Ang diagram ng block sa ibaba ay nagpapatuloy sa mga yugto na iyon:

Hakbang 1: BoM - Bill of Material

Pangunahing bahagi:

1. Raspberry Pi V3 - US $ 32.00
2. 5 Megapixels 1080p Sensor OV5647 Mini Camera Video Module - US $ 13.00

Hakbang 2: Pag-install ng OpenCV 3 Package

Gumagamit ako ng isang Raspberry Pi V3 na na-update sa huling bersyon ng Raspbian (Stretch), kaya ang pinakamahusay na paraan upang mai-install ang OpenCV, ay sundin ang mahusay na tutorial na binuo ni Adrian Rosebrock: Raspbian Stretch: I-install ang OpenCV 3 + Python sa iyong Raspberry Pi.

Sinubukan ko ang maraming magkakaibang mga gabay upang mai-install ang OpenCV sa aking Pi. Ang tutorial ni Adrian ang pinakamahusay. Pinapayuhan ko kayo na gawin ang pareho, sumusunod sa kanyang gabay na sunud-sunod.

Kapag natapos mo na ang tutorial ni Adrian, dapat ay handa kang magkaroon ng isang bukas na kapaligiran sa OpenCV upang patakbuhin ang aming mga eksperimento sa iyong Pi.

Pumunta tayo sa ating virtual na kapaligiran at kumpirmahing na-install nang wasto ang OpenCV 3.

Inirekomenda ni Adrian na patakbuhin ang utos na "mapagkukunan" sa tuwing magbubukas ka ng isang bagong terminal upang matiyak na ang iyong mga variable ng system ay na-set up nang tama.

mapagkukunan ~ /.profile

Susunod, ipasok natin ang aming virtual na kapaligiran:

workon cv

Kung nakikita mo ang teksto (cv) na nauna sa iyong prompt, sa gayon ikaw ay nasa cv virtual na kapaligiran:

(cv) pi @ raspberry: ~ $Tinawag ni Adrian ang atensyon na ang cv Python virtual na kapaligiran ay ganap na nakapag-iisa at sinundan mula sa default na bersyon ng Python na kasama sa pag-download ng Raspbian Stretch. Kaya, ang anumang mga pakete ng Python sa pandaigdigang direktoryo ng mga package sa site ay hindi magagamit sa cv virtual na kapaligiran. Katulad nito, ang anumang mga pakete ng Python na naka-install sa mga site-package ng cv ay hindi magagamit sa pandaigdigang pag-install ng Python

Ngayon, ipasok ang iyong interpreter ng Python:

sawa

at kumpirmahing pinapatakbo mo ang bersyon na 3.5 (o mas mataas)

Sa loob ng interpreter (lilitaw ang ">>>"), i-import ang OpenCV library:

import cv2

Kung walang lilitaw na mga mensahe ng error, ang OpenCV ay wastong nai-install SA IYONG PYTHON VIRTUAL ENVIRONMENT.

Maaari mo ring suriin ang naka-install na bersyon ng OpenCV:

cv2._ bersyon_

Ang 3.3.0 ay dapat na lumitaw (o isang superior bersyon na maaaring mailabas sa hinaharap). Ipinapakita sa itaas ng Terminal PrintScreen ang mga nakaraang hakbang.

Hakbang 3: Pagsubok sa Iyong Camera

Kapag na-install mo na ang OpenCV sa iyong RPi subukan natin upang kumpirmahing gumagana nang maayos ang iyong camera.

Ipinapalagay ko na mayroon kang naka-install na PiCam sa iyong Raspberry Pi.

Ipasok ang nasa ibaba Python code sa iyong IDE:

i-import ang numpy bilang np

import cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Taas habang (True): ret, frame = cap.read () frame = cv2. flip (frame, -1) # Flip camera vertically grey = cv2.cvtColor (frame, cv2. COLOR_BGR2GRAY) cv2.imshow ('frame', frame) cv2.imshow ('grey', grey) k = cv2.waitKey (30) & 0xff kung k == 27: # pindutin ang 'ESC' upang tumigil sa break cap.release () cv2.destroyAllWindows ()

Ang code sa itaas ay makukuha ang stream ng video na mabubuo ng iyong PiCam, ipinapakita ang pareho, sa kulay ng BGR at Gray mode.

Tandaan na pinaikot ko ang aking camera patayo dahil sa paraan ng pag-assemble nito. Kung hindi ito ang iyong kaso, magbigay ng puna o tanggalin ang linya ng "flip" na utos.

Maaari mong kahalili i-download ang code mula sa aking GitHub: simpleCamTest.py

Upang maipatupad, ipasok ang utos:

python simpleCamTest.py

Upang tapusin ang programa, dapat mong pindutin ang key [ESC] sa iyong keyboard.

I-click ang iyong mouse sa window ng video, bago pindutin ang [ESC]

Ipinapakita ng larawan sa itaas ang resulta.

Ang ilang mga gumagawa ay nakakita ng mga isyu kapag sinusubukang buksan ang camera (mga error na "Nabigo ang assertion"). Maaaring mangyari iyon kung hindi naka-on ang camera sa pag-install ng OpenCv at sa gayon, hindi naka-install nang tama ang mga driver ng camera. Upang maitama, gamitin ang utos:

sudo modprobe bcm2835-v4l2

Maaari ka ring magdagdag ng bcm2835-v4l2 sa huling linya ng / etc / modules file kaya't naglo-load ang driver sa boot.

Upang malaman ang higit pa tungkol sa OpenCV, maaari mong sundin ang tutorial: naglo-load ng -video-python-opencv-tutorial

Hakbang 4: Pagtuklas sa Mukha

Ang pinaka-pangunahing gawain sa Pagkilala sa Mukha ay syempre, "Pagtuklas sa Mukha". Bago ang anumang bagay, kailangan mong "makuha" ang isang mukha (Phase 1) upang makilala ito, kung ihahambing sa isang bagong mukha na nakunan sa hinaharap (Phase 3).

Ang pinaka-karaniwang paraan upang makita ang isang mukha (o anumang mga bagay), ay ang paggamit ng "Haar Cascade classifier"

Ang Pagtuklas ng Bagay na gumagamit ng Haar na batay sa tampok na cascade classifiers ay isang mabisang pamamaraan ng pagtuklas ng object na iminungkahi ni Paul Viola at Michael Jones sa kanilang papel, "Mabilis na Pagtuklas ng Bagay na gumagamit ng isang Boosted Cascade of Simple Features" noong 2001. Ito ay isang diskarte sa pag-aaral batay sa makina kung saan ang isang ang pagpapaandar ng kaskad ay sinanay mula sa maraming positibo at negatibong mga imahe. Ginagamit ito pagkatapos upang makita ang mga bagay sa iba pang mga imahe.

Dito kami gagana sa pagtuklas ng mukha. Sa una, ang algorithm ay nangangailangan ng maraming positibong mga imahe (mga imahe ng mga mukha) at negatibong mga imahe (mga imahe nang walang mukha) upang sanayin ang classifier. Pagkatapos ay kailangan nating kunin ang mga tampok mula rito. Ang magandang balita ay ang OpenCV ay may kasamang trainer pati na rin isang detector. Kung nais mong sanayin ang iyong sariling classifier para sa anumang bagay tulad ng kotse, eroplano atbp maaari mong gamitin ang OpenCV upang lumikha ng isa. Ang buong detalye nito ay ibinibigay dito: Pagsasanay sa Cascade Classifier.

Kung hindi mo nais na lumikha ng iyong sariling classifier, naglalaman ang OpenCV ng maraming pre-sanay na mga classifier para sa mukha, mata, ngiti, atbp. Ang mga XML na file na iyon ay maaaring ma-download mula sa direktoryo ng haarcascades.

Sapat na teorya, lumikha tayo ng isang detektor ng mukha na may OpenCV!

I-download ang file: faceDetection.py mula sa aking GitHub.

i-import ang numpy bilang np

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 Taas habang Totoo: ret, img = cap.read () img = cv2.flip (img, -1) grey = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) mga mukha = faceCascade.detectMultiScale (grey, scaleFactor = 1.2, minNeighbours = 5, minSize = (20, 20)) para sa (x, y, w, h) sa mga mukha: cv2.rectangle (img, (x, y), (x + w, y + h), (255, 0, 0), 2) roi_gray = grey [y: y + h, x: x + w] roi_color = img [y: y + h, x: x + w] cv2.imshow ('video', img) k = cv2.waitKey (30) & 0xff kung k == 27: # pindutin ang 'ESC' upang tumigil sa break cap.release () cv2.destroyAllWindows ()

Maniwala ka o hindi, sa itaas na ilang mga linya ng code ang kailangan mo lamang upang makita ang isang mukha, gamit ang Python at OpenCV.

Kapag inihambing mo sa huling code na ginamit upang subukan ang camera, malalaman mo na ilang bahagi ang naidagdag dito. Tandaan ang linya sa ibaba:

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

Ito ang linya na naglo-load ng "classifier" (na dapat nasa isang direktoryo na pinangalanang "Cascades /", sa ilalim ng iyong direktoryo ng proyekto).

Pagkatapos, itatakda namin ang aming camera at sa loob ng loop, i-load ang aming input video sa grayscale mode (pareho ng nakita natin dati).

Ngayon ay dapat nating tawagan ang aming pag-andar ng classifier, na ipinapasa ang ilang napakahalagang mga parameter, bilang scale factor, bilang ng mga kapitbahay at minimum na laki ng napansin na mukha.

mukha = faceCascade.detectMultiScale (grey, scaleFactor = 1.2, minNeighbours = 5, minSize = (20, 20))

Kung saan,

• grey ang input na grayscale na imahe.
• scaleFactor ay ang parameter na tumutukoy kung gaano ang laki ng imahe ay nabawasan sa bawat sukat ng imahe. Ginagamit ito upang lumikha ng scale pyramid.
• Ang minNeighbours ay isang parameter na tumutukoy kung gaano karaming mga kapit-bahay ang dapat mayroon ang bawat rektanggulo ng kandidato, upang mapanatili ito. Ang isang mas mataas na bilang ay nagbibigay ng mas mababang maling mga positibo.
• Ang minSize ay ang minimum na laki ng rektanggulo na maituturing na isang mukha.

Makikita ng pagpapaandar ang mga mukha sa imahe. Susunod, dapat nating "markahan" ang mga mukha sa imahe, gamit, halimbawa, isang asul na parihaba. Ginagawa ito sa bahaging ito ng code:

para sa (x, y, w, h) sa mga mukha:

cv2.rectangle (img, (x, y), (x + w, y + h), (255, 0, 0), 2) roi_gray = grey [y: y + h, x: x + w] roi_color = img [y: y + h, x: x + w]

Kung ang mga mukha ay natagpuan, ibabalik nito ang mga posisyon ng mga natukoy na mukha bilang isang rektanggulo na may kaliwang pataas na sulok (x, y) at pagkakaroon ng "w" bilang Lapad nito at "h" bilang Taas ==> (x, y, w, h). Mangyaring tingnan ang larawan sa itaas.

Sa sandaling makuha namin ang mga lokasyon na ito, makakalikha kami ng isang "ROI" (iginuhit na rektanggulo) para sa mukha at ipakita ang resulta sa pagpapaandar ng imshow ().

Patakbuhin ang nasa itaas na python Script sa iyong kapaligiran sa sawa, gamit ang Rpi Terminal:

mukha ng sawaDetection.py

Ang resulta:

Maaari mo ring isama ang mga classifier para sa "detection ng mata" o kahit na "detection ng ngiti". Sa mga kasong iyon, isasama mo ang pag-andar ng classifier at pagguhit ng rektanggulo sa loob ng loop ng mukha, dahil walang katuturan na makita ang isang mata o isang ngiti sa labas ng isang mukha.

Tandaan na sa isang Pi, ang pagkakaroon ng maraming mga classifier sa parehong code ay magpapabagal sa pagproseso, sa sandaling ang pamamaraang ito ng pagtuklas (HaarCascades) ay gumagamit ng isang malaking halaga ng computational power. Sa isang desktop, mas madali itong patakbuhin.

Sa aking GitHub makakakita ka ng iba pang mga halimbawa:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

At sa larawan sa itaas, makikita mo ang resulta.

Maaari mo ring sundin ang tutorial sa ibaba upang mas maunawaan ang Pagtuklas sa Mukha:

Haar Cascade Object Detection Mukha at Mata OpenCV Python Tutorial

Hakbang 5: Pagtitipon ng Data

Una sa lahat, dapat kong pasalamatan si Ramiz Raja para sa kanyang mahusay na gawain sa Pagkilala sa Mukha sa mga larawan:

PAGKAKILALA SA MUKHA GUMAGAMIT NG OPENCV AT PYTHON: GABAY NG ISANG PASIMULA

at pati na rin ang Anirban Kar, na bumuo ng isang napaka-komprehensibong tutorial na gumagamit ng video:

PAGKAKILALA SA MUKHA - 3 bahagi

Inirerekumenda ko talaga na tingnan mo ang parehong mga tutorial.

Sinasabi iyon, simulan natin ang unang yugto ng aming proyekto. Ang gagawin namin dito, ay nagsisimula sa huling hakbang (Pagtuklas sa Mukha), lilikha lamang kami ng isang dataset, kung saan kami mag-iimbak para sa bawat id, isang pangkat ng mga larawan na kulay-abo na may bahaging ginamit para sa pagtuklas ng mukha.

Una, lumikha ng isang direktoryo kung saan mo binuo ang iyong proyekto, halimbawa, FacialRecognitionProject:

mkdir MukhaRecognitionProject

Sa direktoryo na ito, bukod sa 3 mga script ng python na lilikha namin para sa aming proyekto, dapat ay nai-save namin dito ang Facial Classifier. Maaari mong i-download ito mula sa aking GitHub: haarcascade_frontalface_default.xml

Susunod, lumikha ng isang subdirectory kung saan iimbak namin ang aming mga sample sa pangmukha at pangalanan itong "dataset":

mkdir dataset

At i-download ang code mula sa aking GitHub: 01_face_dataset.py

import cv2

import os cam = cv2. VideoCapture (0) cam.set (3, 640) # itakda ang lapad ng video cam.set (4, 480) # itakda ang taas ng video face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # Para sa bawat tao, ipasok ang isang numerong mukha id face_id = input ('\ n ipasok ang user id end press ==>') i-print ("\ n [INFO] Pinasimulan ang pagkuha ng mukha. Tingnan ang camera at maghintay…") # Pinasimulan ang bilang ng indibidwal na bilang ng bilang ng bilang ng mukha = 0 habang (Totoo): ret, img = cam.read () img = cv2.flip (img, -1) # flip video image vertically grey = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) mga mukha = face_detector.detectMultiScale (kulay abo, 1.3, 5) para sa (x, y, w, h) sa mga mukha: cv2.rectangle (img, (x, y), (x + w, y + h), (255, 0, 0), 2) count + = 1 # I-save ang nakunan ng imahe sa folder ng mga folder na cv2.imwrite ("dataset / Gumagamit." + str (face_id) + '.' + str (count) + ".jpg", kulay abong [y: y + h, x: x + w]) cv2.imshow ('imahe', img) k = cv2.waitKey (100) & 0xff # Pindutin ang 'ESC' para sa paglabas ng video kung k == 27: basahin ang bilang ng elif> = 30: # Kumuha ng 30 sample ng mukha at ihinto ang video break # Do ab ito ng paglilinis na naka-print ("\ n [INFO] Lumalabas na Program at mga bagay sa paglilinis") cam.release () cv2.destroyAllWindows ()

Ang code ay halos kapareho sa code na nakita namin para sa pagtuklas ng mukha. Ang idinagdag namin, ay isang "input command" upang makuha ang isang user id, dapat iyon ay isang numero ng integer (1, 2, 3, atbp)

face_id = input ('\ n ipasok ang user id end press ==>')

At para sa bawat isa sa mga nakuhang mga frame, dapat nating i-save ito bilang isang file sa isang direktoryo ng "dataset":

cv2.imwrite ("dataset / Gumagamit." + str (face_id) + '.' + str (count) + ".jpg", grey [y: y + h, x: x + w])

Tandaan na para sa pag-save ng file sa itaas, dapat ay na-import mo ang library na "os". Susunod ang pangalan ng bawat file sa istraktura:

User.face_id.count.jpg

Halimbawa, para sa isang gumagamit na may face_id = 1, ang ika-4 na sample na file sa dataset / direktoryo ay magiging tulad ng:

Gumagamit.1.4.jpg

tulad ng ipinakita sa larawan sa itaas mula sa aking Pi. Sa aking code, nakakakuha ako ng 30 mga sample mula sa bawat id. Maaari mo itong palitan sa huling "elif". Ang bilang ng mga sample ay ginagamit upang masira ang loop kung saan nakunan ang mga sample ng mukha.

Patakbuhin ang script ng Python at makuha ang ilang Ids. Dapat mong patakbuhin ang script sa bawat oras na nais mong pagsamahin ang isang bagong gumagamit (o upang baguhin ang mga larawan para sa isa na mayroon na).

Hakbang 6: Tagasanay

Sa pangalawang yugto na ito, dapat naming kunin ang lahat ng data ng gumagamit mula sa aming dataset at "trainer" na OpenCV Recognizer. Ginagawa ito nang direkta ng isang tukoy na pagpapaandar ng OpenCV. Ang resulta ay magiging isang.yml file na mai-save sa isang direktoryo ng "trainer /".

Kaya, magsimula tayong lumikha ng isang subdirectory kung saan maiimbak natin ang sanay na data:

mkdir trainer

Mag-download mula sa aking GitHub ang pangalawang script ng sawa: 02_face_training.py

import cv2

i-import ang numpy bilang np mula sa PIL import I-import ang imahe ng os # Path para sa path ng database ng imahe ng mukha = 'data' recognizer = cv2.face. LBPHFaceRecognizer_create () detector = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # pagpapaandar upang makuha ang mga imahe at data ng label def getImagesAndLabels (path): imagePaths = [os.path.join (path, f) para sa f in os.listdir (path)] faceSamples = ids = para sa imagePath sa imagePaths: PIL_img = Image.open (imagePath).convert ('L') # i-convert ito sa grayscale img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [- 1]. hatiin (".") [1]) mga mukha = detector.detectMultiScale (img_numpy) para sa (x, y, w, h) sa mga mukha: faceSamples.append (img_numpy [y: y + h, x: x + w]) ids.append (id) ibalik ang faceSamples, ids print ("\ n [INFO] Mga mukha sa pagsasanay. Magtatagal ng ilang segundo. Maghintay…") mga mukha, ids = getImagesAndLabels (path) na makilala.train (mukha, np.array (ids)) # I-save ang modelo sa trainer / trainer.yml recognitor.write ('trainer / trainer.yml') # recognizer.save () nagtrabaho sa Mac, ngunit hindi sa Pi # I-print ang bilang ng mga mukha na sinanay at tapusin ang pag-print ng programa ("\ n [INFO] {0} nakaharap sa pagsasanay. Lumalabas na Programa".format (len (np.unique (ids))))

Kumpirmahin kung mayroon kang naka-install na PIL library sa iyong Rpi. Kung hindi, patakbuhin ang utos sa ibaba sa Terminal:

pip install unan

Gagamitin namin bilang isang nakikilala, ang LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) Face Recognizer, kasama sa OpenCV package. Ginagawa namin ito sa sumusunod na linya:

kinikilala = cv2.face. LBPHFaceRecognizer_create ()

Ang pagpapaandar na "getImagesAndLabels (path)", kukuha ng lahat ng mga larawan sa direktoryo: "dataset /", ibabalik ang 2 arrays: "Ids" at "mukha". Sa mga array na iyon bilang input, "isasanay namin ang aming kinikilala":

kinikilala.train (mukha, id)

Bilang isang resulta, isang file na pinangalanang "trainer.yml" ay nai-save sa direktoryo ng tagapagsanay na dating nilikha namin.

Ayan yun! Isinama ko ang huling pahayag sa pag-print kung saan ipinakita ko para sa kumpirmasyon, ang bilang ng mga mukha ng Gumagamit na sinanay namin.

Sa tuwing gumanap ka ng Phase 1, ang Phase 2 ay dapat ding patakbuhin

Hakbang 7: Pagkilala

Ngayon, naabot namin ang huling yugto ng aming proyekto. Dito, makukuha namin ang isang sariwang mukha sa aming camera at kung ang taong ito ay nakunan at sinanay ang kanyang mukha dati, ang aming tagakilala ay gagawa ng isang "hula" na ibabalik ang id nito at isang index, ipinakita kung gaano kumpiyansa ang tagakilala sa laban na ito.

I-download natin ang ika-3 yugto ng python script mula sa aking GitHub: 03_face_recognition.py.

import cv2

import numpy as np import os recognitor = cv2.face. LBPHFaceRecognizer_create () recognitor.read ('trainer / trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # mga pangalan na nauugnay sa ids: halimbawa ==> Marcelo: id = 1, etc mga pangalan = ['Wala', 'Marcelo', 'Paula', 'Ilza', 'Z ',' W '] # Pinasimulan at simulan ang realtime video capture cam = cv2. VideoCapture (0) cam.set (3, 640) # set video widht cam.set (4, 480) # set video taas # Tukuyin ang min laki ng window upang makilala bilang isang mukha minW = 0.1 * cam.get (3) minH = 0.1 * cam.get (4) habang Totoo: ret, img = cam.read () img = cv2.flip (img, -1) # I-flip nang patayo grey = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) mga mukha = faceCascade.detectMultiScale (grey, scaleFactor = 1.2, minNeighbours = 5, minSize = (int (minW), int (minH)),) para sa (x, y, w, h) sa mga mukha: cv2.rectangle (img, (x, y), (x + w, y + h), (0, 255, 0), 2) id, kumpiyansa = kinikilala.predict (grey [y: y + h, x: x + w]) # Suriin kung mas mababa ang kumpiyansa sa kanila 100 ==> "0" ay perpektong tugma kung (kumpiyansa <100): id = names [id] kumpiyansa = "{0}% ".format (bilog (100 - kumpiyansa)) iba pa: id =" unknown "kumpiyansa =" {0}% ". format (bilog (100 - conf idence)) cv2.putText (img, str (id), (x + 5, y-5), font, 1, (255, 255, 255), 2) cv2.putText (img, str (kumpiyansa), (x + 5, y + h-5), font, 1, (255, 255, 0), 1) cv2.imshow ('camera', img) k = cv2.waitKey (10) & 0xff # Press 'ESC' para sa paglabas ng video kung k == 27: basagin # Gumawa ng kaunting paglilinis na naka-print ("\ n [INFO] Lumalabas na Program at mga bagay sa paglilinis") cam.release () cv2.destroyAllWindows ()

Nagsasama kami dito ng isang bagong array, kaya ipapakita namin ang "mga pangalan", sa halip na mga id na may bilang:

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

Kaya, halimbawa: gagawin ni Marcelo ang gumagamit na may id = 1; Paula: id = 2, atbp.

Susunod, makakakita kami ng isang mukha, katulad ng ginawa namin dati sa classifier ng haasCascade. Ang pagkakaroon ng napansin na mukha maaari nating tawagan ang pinakamahalagang pagpapaandar sa nasa itaas na code:

id, kumpiyansa = kinikilala.predict (kulay abong bahagi ng mukha)

Ang tagakilala.predict (), ay kukuha bilang isang parameter ng isang nakunan na bahagi ng mukha upang masuri at ibabalik ang maaaring may-ari nito, na nagpapahiwatig ng id nito at kung gaano kalaki ang kumpiyansa na kinikilala ng relo sa tugma na ito.

Tandaan na ang index ng kumpiyansa ay magbabalik ng "zero" kung ito ay gawing cosidered isang perpektong tugma

At sa wakas, kung mahuhulaan ng kumikilala ang isang mukha, naglalagay kami ng isang teksto sa imaheng may probable id at kung magkano ang "posibilidad" sa% na tama ang laban ("probabilidad" = 100 - kumpyansa index). Kung hindi, isang label na "hindi alam" ang mailalagay sa mukha.

Sa ibaba ng isang-g.webp

Sa larawan sa itaas, nagpapakita ako ng ilang mga pagsubok na ginawa sa proyektong ito, kung saan gumamit din ako ng mga larawan upang mapatunayan kung gumagana ang kinikilala.

Hakbang 8: Konklusyon

Tulad ng nakasanayan, inaasahan kong ang proyekto na ito ay maaaring makatulong sa iba na mahanap ang kanilang mga paraan sa kapanapanabik na mundo ng electronics!

Para sa mga detalye at pangwakas na code, mangyaring bisitahin ang aking deposito sa GitHub: OpenCV-Face-Recognition

Para sa higit pang mga proyekto, mangyaring bisitahin ang aking blog: MJRoBot.org

Sa ibaba ng isang sulyap ng isang hinaharap na tutorial, kung saan susaliksikin namin ang "awtomatikong track ng mukha at iba pang mga pamamaraan para sa pagtuklas ng mukha":

Saludos mula sa timog ng mundo!

Kita tayo sa susunod kong turo!

Salamat, Marcelo