Veido atpažinimas realiuoju laiku: visas projektas: 8 žingsniai (su nuotraukomis)

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:48

Paskutinėje pamokoje, kurioje tyrinėjau „OpenCV“, sužinojome AUTOMATINIO VISIJOS OBJEKTO SEKIMĄ. Dabar mes naudosime savo „PiCam“, kad atpažintume veidus realiuoju laiku, kaip matote žemiau:

Šis projektas buvo atliktas su šia fantastiška „atviro kodo kompiuterinės vizijos biblioteka“- „OpenCV“. Šioje pamokoje mes sutelksime dėmesį į „Raspberry Pi“(taigi, „Raspbian“kaip OS) ir „Python“, bet taip pat išbandžiau kodą „My Mac“ir jis taip pat veikia gerai. „OpenCV“buvo sukurtas siekiant skaičiavimo efektyvumo ir daug dėmesio skiriant realaus laiko programoms. Taigi, jis puikiai tinka veido atpažinimui realiuoju laiku naudojant fotoaparatą.

Norėdami sukurti pilną veido atpažinimo projektą, turime atlikti 3 labai skirtingus etapus:

1. Veido aptikimas ir duomenų rinkimas
2. Treniruok atpažintoją
3. Veido atpažinimas

Žemiau pateikta blokinė schema atnaujina šiuos etapus:

1 žingsnis: „BoM - Bill of Material“

Pagrindinės dalys:

1. „Raspberry Pi V3“- 32,00 USD
2. 5 megapikselių 1080p jutiklis OV5647 mini kameros vaizdo modulis - 13,00 USD

2 veiksmas: „OpenCV 3“paketo diegimas

Aš naudoju „Raspberry Pi V3“, atnaujintą į paskutinę „Raspbian“(„Stretch“) versiją, todėl geriausias būdas įdiegti „OpenCV“yra vadovautis puikia Adrian Rosebrock sukurta pamoka: „Raspbian Stretch“: „Raspberry Pi“įdiekite „OpenCV 3 + Python“.

Išbandžiau kelis skirtingus vadovus, kaip įdiegti „OpenCV“į „Pi“. Adriano pamoka yra geriausia. Aš patariu jums daryti tą patį, žingsnis po žingsnio sekant jo gaires.

Baigę Adriano vadovėlį, turėtumėte turėti „OpenCV“virtualią aplinką, kad galėtumėte atlikti mūsų eksperimentus su „Pi“.

Eikime į savo virtualią aplinką ir patvirtinkime, kad „OpenCV 3“yra tinkamai įdiegta.

Adrianas rekomenduoja paleisti komandą „šaltinis“kiekvieną kartą, kai atidarote naują terminalą, kad įsitikintumėte, jog sistemos kintamieji buvo teisingai nustatyti.

šaltinis ~/.profile

Toliau pereikime prie savo virtualios aplinkos:

workon cv

Jei matote tekstą (cv) prieš jūsų raginimą, esate CV virtualioje aplinkoje:

(cv) pi@avietė: ~ $Adrianas atkreipia dėmesį, kad „Cv Python“virtuali aplinka yra visiškai nepriklausoma ir atskirta nuo numatytosios „Python“versijos, įtrauktos į „Raspbian Stretch“atsisiuntimą. Taigi, visi „Python“paketai, esantys pasauliniame svetainių paketų kataloge, nebus pasiekiami cv virtualioje aplinkoje. Panašiai visi „Python“paketai, įdiegti cv svetainės paketuose, nebus prieinami visuotiniam „Python“diegimui

Dabar įveskite savo „Python“vertėją:

pitonas

ir patvirtinkite, kad naudojate 3.5 (ar naujesnę) versiją

Vertėjo viduje (pasirodys „>>>“) importuokite „OpenCV“biblioteką:

importuoti cv2

Jei nerodomi jokie klaidos pranešimai, „OpenCV“yra tinkamai įdiegta JŪSŲ PYTHON VIRTUALINĖJE APLINKOJE.

Taip pat galite patikrinti įdiegtą „OpenCV“versiją:

cv2._ versija_

Turi pasirodyti 3.3.0 (arba geresnė versija, kuri gali būti išleista ateityje). Aukščiau pateiktame terminalo spausdinimo ekrane rodomi ankstesni veiksmai.

3 veiksmas: fotoaparato testavimas

Įdiegę „OpenCV“savo RPi, patikrinkime, ar jūsų kamera veikia tinkamai.

Aš darau prielaidą, kad „Raspberry Pi“jau turite įdiegtą „PiCam“.

Įveskite žemiau esantį Python kodą savo IDE:

importuoti numpy kaip np

importuoti cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Aukštis o (tiesa): ret, frame = cap.read () frame = cv2. apversti (kadras, -1) # Apversti fotoaparatą vertikaliai pilka = cv2.cvtColor (kadras, cv2. COLOR_BGR2GRAY) cv2.imshow ('kadras', kadras) cv2.imshow ('pilka', pilka) k = cv2.waitKey (30) & 0xff, jei k == 27: # paspauskite „ESC“, kad uždarytumėte „break cap“. Release () cv2.destroyAllWindows ()

Aukščiau pateiktas kodas užfiksuos vaizdo srautą, kurį sukurs jūsų „PiCam“, ir bus rodomas tiek BGR spalvos, tiek pilkos spalvos režimu.

Atminkite, kad fotoaparatą pasukau vertikaliai dėl jo surinkimo būdo. Jei ne jūsų atvejis, komentuokite arba ištrinkite komandinę eilutę „apversti“.

Taip pat galite atsisiųsti kodą iš mano „GitHub“: simpleCamTest.py

Norėdami vykdyti, įveskite komandą:

python simpleCamTest.py

Norėdami baigti programą, turite paspausti klaviatūros klavišą [ESC].

Spustelėkite pelės klavišą ant vaizdo įrašo lango prieš paspausdami [ESC]

Aukščiau pateiktame paveikslėlyje parodytas rezultatas.

Kai kurie gamintojai nustatė problemų bandydami atidaryti fotoaparatą (klaidos pranešimai „Įspėjimas nepavyko“). Taip gali atsitikti, jei fotoaparatas nebuvo įjungtas diegiant „OpenCv“, todėl fotoaparato tvarkyklės nebuvo tinkamai įdiegtos. Norėdami pataisyti, naudokite komandą:

sudo modprobe bcm2835-v4l2

Taip pat galite pridėti bcm2835-v4l2 į paskutinę failo /etc /modules eilutę, kad tvarkyklė būtų įkelta įkrovos metu.

Norėdami sužinoti daugiau apie „OpenCV“, galite sekti vadovėlį: įkėlimas -video-python-opencv-tutorial

4 žingsnis: veido aptikimas

Žinoma, pagrindinė veido atpažinimo užduotis yra „Veido aptikimas“. Prieš ką nors turite „užfiksuoti“veidą (1 etapas), kad jį atpažintumėte, palyginti su nauju ateityje užfiksuotu veidu (3 etapas).

Dažniausias būdas aptikti veidą (ar bet kokius objektus) yra naudojant „Haar Cascade“klasifikatorių

Objektų aptikimas naudojant „Haar“funkcijomis pagrįstus kaskadinius klasifikatorius yra veiksmingas objektų aptikimo metodas, kurį Paulius Viola ir Michaelas Jonesas pasiūlė savo darbe „Greitas objektų aptikimas naudojant sustiprintą paprastų funkcijų kaskadą“. Tai mašininiu mokymu pagrįstas metodas, kai kaskados funkcija mokoma iš daugybės teigiamų ir neigiamų vaizdų. Tada jis naudojamas kitų vaizdų objektams aptikti.

Čia dirbsime su veido aptikimu. Iš pradžių algoritmui reikia daug teigiamų vaizdų (veidų atvaizdų) ir neigiamų vaizdų (vaizdų be veidų), kad būtų išmokytas klasifikatorius. Tada turime iš jo išgauti ypatybes. Geros naujienos yra tai, kad „OpenCV“yra su treniruokliu ir detektoriumi. Jei norite išmokyti savo klasifikatorių bet kuriam objektui, pavyzdžiui, automobiliui, lėktuvui ir pan., Galite jį sukurti naudodami „OpenCV“. Išsami informacija pateikiama čia: Kaskados klasifikatoriaus mokymas.

Jei nenorite sukurti savo klasifikatoriaus, „OpenCV“jau yra daug iš anksto apmokytų veido, akių, šypsenos ir tt klasifikatorių. Šiuos XML failus galima atsisiųsti iš „haarcascades“katalogo.

Užteks teorijos, sukurkime veido detektorių su „OpenCV“!

Atsisiųskite failą: faceDetection.py iš mano „GitHub“.

importuoti numpy kaip np

importuoti 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 = kepurė 20, 20)) (x, y, w, h) veiduose: cv2. stačiakampis (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = pilka [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 uždarytumėte „break cap“. Release () cv2.destroyAllWindows ()

Patikėkite ar ne, bet kelios aukščiau esančios kodo eilutės yra viskas, ko jums reikia norint aptikti veidą naudojant „Python“ir „OpenCV“.

Palyginę su paskutiniu kodu, naudojamu fotoaparatui išbandyti, suprasite, kad į jį buvo pridėta nedaug dalių. Atkreipkite dėmesį į žemiau esančią eilutę:

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

Tai eilutė, įkelianti „klasifikatorių“(kuris turi būti kataloge, pavadintame „Kaskados/“, jūsų projekto kataloge).

Tada mes nustatysime savo fotoaparatą ir ciklo viduje įkeliame įvesties vaizdo įrašą pilkos spalvos režimu (tą patį, ką matėme anksčiau).

Dabar mes turime iškviesti savo klasifikatoriaus funkciją, perduodami jai keletą labai svarbių parametrų, kaip mastelio koeficientas, kaimynų skaičius ir minimalus aptikto veido dydis.

veidai = faceCascade.detectMultiScale (pilka, skalė Faktorius = 1,2, min Kaimynai = 5, minDydis = (20, 20))

Kur,

• pilka yra įvestas pilkos spalvos vaizdas.
• scaleFactor yra parametras, nurodantis, kiek vaizdo dydis sumažinamas kiekvienoje vaizdo skalėje. Jis naudojamas masto piramidei sukurti.
• „minNeighbors“yra parametras, nurodantis, kiek kaimynų turi būti kiekvienas kandidatas stačiakampis, kad jį išsaugotų. Didesnis skaičius suteikia mažiau klaidingų teigiamų rezultatų.
• „MinSize“yra mažiausias stačiakampio dydis, kurį reikia laikyti veidu.

Funkcija aptiks veidus ant vaizdo. Toliau mes turime „pažymėti“veidus vaizde, naudodami, pavyzdžiui, mėlyną stačiakampį. Tai daroma naudojant šią kodo dalį:

(x, y, w, h) veiduose:

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

Jei veidai randami, jis grąžina aptiktų veidų pozicijas kaip stačiakampis su kairiuoju viršutiniu kampu (x, y), kurio plotis yra „w“, o aukštis - „h“==> (x, y, w, h). Žiūrėkite aukščiau pateiktą paveikslėlį.

Gavę šias vietas, galime sukurti veidui „ROI“(nubrėžtą stačiakampį) ir pateikti rezultatą naudodami funkciją imshow ().

Paleiskite aukščiau pateiktą „python“scenarijų savo „python“aplinkoje, naudodami „Rpi“terminalą:

python faceDetection.py

Rezultatas:

Taip pat galite įtraukti „akių aptikimo“ar net „šypsenos aptikimo“klasifikatorius. Tokiais atvejais į veido kilpą įtrauksite klasifikatoriaus funkciją ir stačiakampio brėžinį, nes nebūtų prasmės aptikti akių ar šypsenos už veido.

Atminkite, kad naudojant „Pi“, turint kelis klasifikatorius tuo pačiu kodu, sulėtės apdorojimas, kai šis aptikimo metodas („HaarCascades“) naudoja daug skaičiavimo galios. Staliniame kompiuteryje lengviau jį paleisti.

Mano „GitHub“rasite kitų pavyzdžių:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

Ir aukščiau esančiame paveikslėlyje galite pamatyti rezultatą.

Taip pat galite sekti žemiau pateiktą pamoką, kad geriau suprastumėte veido aptikimą:

„Haar“kaskados objektų aptikimo veido ir akių „OpenCV Python“vadovėlis

5 veiksmas: duomenų rinkimas

Pirmiausia turiu padėkoti Ramizui Raja už puikų darbą, susijusį su veido atpažinimu nuotraukose:

VEIDO PRIPAŽINIMAS NAUDOJANT OPENCV IR PYTHON: PRADŽIOS VADOVAS

taip pat Anirban Kar, kuris sukūrė labai išsamią mokymo programą, naudodamas vaizdo įrašą:

VEIDO ATPAŽINIMAS - 3 dalys

Tikrai rekomenduoju pažiūrėti abi pamokas.

Tai sakydami, pradėkime pirmąjį mūsų projekto etapą. Tai, ką mes čia darysime, pradedame nuo paskutinio veiksmo (veido aptikimo), mes tiesiog sukursime duomenų rinkinį, kuriame kiekvienam ID išsaugosime pilkos spalvos nuotraukų grupę su dalimi, kuri buvo naudojama veidui aptikti.

Pirmiausia sukurkite katalogą, kuriame kuriate savo projektą, pavyzdžiui, „FacialRecognitionProject“:

mkdir FacialRecognitionProject

Šiame kataloge, be 3 „python“scenarijų, kuriuos sukursime savo projektui, jame būtinai išsaugojome veido klasifikatorių. Ją galite atsisiųsti iš mano „GitHub“: haarcascade_frontalface_default.xml

Tada sukurkite pakatalogį, kuriame laikysime savo veido pavyzdžius ir pavadinsime jį „duomenų rinkiniu“:

mkdir duomenų rinkinys

Ir atsisiųskite kodą iš mano „GitHub“: 01_face_dataset.py

importuoti cv2

import os cam = cv2. VideoCapture (0) cam.set (3, 640) # set video width cam.set (4, 480) # set video height face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # Kiekvienam asmeniui, įveskite vieną skaitinį veido ID face_id = įvestis ('\ n įveskite vartotojo ID pabaigos paspauskite ==>') print ("\ n [INFO] Veido fiksavimo inicijavimas. Pažiūrėkite į fotoaparatą ir palaukite …") # Inicijuokite individualų mėginių ėmimo veidų skaičių = 0 o (tiesa): ret, img = cam.read () img = cv2.flip (img, -1) # apversti vaizdo vaizdą vertikaliai pilka = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) veidai = face_detector.detectMultiScale (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 # Išsaugokite užfiksuotą vaizdą duomenų rinkinių aplanke cv2.imwrite ("duomenų rinkinys/vartotojas." + str (face_id) + '.' + str (count) + ".jpg", pilka [y: y + h, x: x+w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # Norėdami išeiti iš vaizdo įrašo, paspauskite „ESC“, jei k == 27: pertraukos elifų skaičius> = 30: # Paimkite 30 veido pavyzdžių ir sustabdykite vaizdo pertrauką # Ar ab it of cleanup print ("\ n [INFO] Išeinama iš programos ir valymo medžiagos") cam.release () cv2.destroyAllWindows ()

Kodas yra labai panašus į kodą, kurį matėme veido aptikimui. Mes pridėjome „įvesties komandą“, skirtą užfiksuoti vartotojo ID, kuris turėtų būti sveikasis skaičius (1, 2, 3 ir tt)

face_id = įvestis ('\ n įveskite vartotojo ID pabaigos paspauskite ==>')

Ir kiekvienam iš užfiksuotų kadrų turėtume jį išsaugoti kaip failą „duomenų rinkinio“kataloge:

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

Atminkite, kad norėdami išsaugoti aukščiau pateiktą failą, turite importuoti biblioteką „os“. Kiekvieno failo pavadinimas bus toks:

User.face_id.count.jpg

Pvz., Vartotojui, turinčiam „face_id = 1“, ketvirtasis duomenų rinkinio/ katalogo failo pavyzdys bus toks:

Vartotojas.1.4.jpg

kaip parodyta aukščiau esančioje nuotraukoje iš mano Pi. Pagal savo kodą aš fiksuoju 30 pavyzdžių iš kiekvieno ID. Galite jį pakeisti paskutiniame „elife“. Mėginių skaičius naudojamas nutraukti kilpą, kurioje yra užfiksuoti veido mėginiai.

Paleiskite „Python“scenarijų ir užfiksuokite keletą ID. Turite paleisti scenarijų kiekvieną kartą, kai norite surinkti naują naudotoją (arba pakeisti nuotraukas į jau esamą).

6 žingsnis: treneris

Antrame etape turime paimti visus vartotojo duomenis iš savo duomenų rinkinio ir „treniruoti“„OpenCV Recognizer“. Tai atliekama tiesiogiai naudojant konkrečią „OpenCV“funkciją. Rezultatas bus.yml failas, kuris bus išsaugotas kataloge „trainer/“.

Taigi, pradėkime kurti pakatalogį, kuriame išsaugosime apmokytus duomenis:

mkdir treneris

Atsisiųskite iš mano „GitHub“antrąjį „python“scenarijų: 02_face_training.py

importuoti cv2

importuoti numpy kaip np iš PIL importo Vaizdo importavimas os # Veido vaizdo duomenų bazės kelias = 'duomenų rinkinys' atpažinimo priemonė = cv2.face. LBPHFaceRecognizer_create () detektorius = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # funkcija, skirta gauti vaizdus ir etikečių duomenis def getImagesAndLabels (kelias): imagePaths = [os.path.join (path, f) f f os.listdir (path)] faceSamples = ids = imagePath in imagePaths: PIL_img = Image.open (imagePath).convert ('L') # konvertuoti jį į pilkos spalvos skalę img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. padalinti (".") [1]) veidai = detektorius.detectMultiScale (img_numpy) (x, y, w, h) veiduose: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Treniruoja veidus. Tai užtruks kelias sekundes. Palaukite …") veidai, ids = getImagesAndLabels (kelias) atpažinimo priemonė.train (veidai, np.array (id)) # Išsaugokite modelį į trenerį/trenerį.yml atpažinimo priemonė.write („treneris/treneris.yml“) # atpažinimo priemonė.save () dirbo „Mac“, bet ne „Pi“# Išspausdinkite apmokytų veidų skaičių ir baigkite programos spausdinimą ("\ n [INFO] {0} veidai apmokyti. Išeinama iš programos".format (len (np.unique (ids))))

Patvirtinkite, ar jūsų Rpi įdiegta PIL biblioteka. Jei ne, paleiskite žemiau esančią komandą terminale:

pip įdiegti pagalvę

Kaip atpažinimo priemonę naudosime veido atpažinimo priemonę LBPH (LOCAL BINARY PATTERNS HISTOGRAMS), įtrauktą į „OpenCV“paketą. Mes tai darome šioje eilutėje:

atpažinimo priemonė = cv2.face. LBPHFaceRecognizer_create ()

Funkcija „getImagesAndLabels (kelias)“padarys visas nuotraukas kataloge: „duomenų rinkinys/“, grąžindamas 2 masyvus: „ID“ir „veidai“. Naudodami šiuos masyvus, mes „apmokysime savo atpažinimo įrenginį“:

atpažinimo įrenginys (veidai, ID)

Dėl to failas pavadinimu „trainer.yml“bus išsaugotas anksčiau mūsų sukurtame trenerių kataloge.

Viskas! Įtraukiau paskutinį spausdinimo pareiškimą, kuriame pateikiau patvirtinimui, naudotojų veidų, kuriuos mes apmokėme, skaičių.

Kiekvieną kartą, kai atliekate 1 etapą, 2 etapas taip pat turi būti paleistas

7 žingsnis: atpažinimo priemonė

Dabar mes pasiekėme paskutinį savo projekto etapą. Čia mes užfiksuosime naują veidą savo fotoaparate ir, jei šio asmens veidas buvo užfiksuotas ir apmokytas anksčiau, mūsų atpažinimo priemonė pateiks „prognozę“, grąžindama savo ID ir rodyklę, parodydama, koks atpažįstamasis yra tikras dėl šios rungtynės.

Atsisiųskime trečiojo etapo „python“scenarijų iš mano „GitHub“: 03_face_recognition.py.

importuoti cv2

importuoti numpy kaip np importuoti os atpažinimo priemonę = cv2.face. LBPHFaceRecognizer_create () atpažintojas.read ('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # pavadinimai, susiję su ID: pavyzdys ==> Marcelo: id = 1 ir tt names = ['Nėra', 'Marcelo', 'Paula', 'Ilza', 'Z ',' W '] # Inicializuokite ir pradėkite vaizdo įrašų fiksavimą realiuoju laiku cam = cv2. VideoCapture (0) cam.set (3, 640) # set video widht cam.set (4, 480) # nustatyti vaizdo aukštį # Nustatykite mažiausio lango dydį būti atpažįstamas kaip veidas minW = 0,1*kamera.get (3) minH = 0,1*kamera.get (4), o tiesa: ret, img = cam.read () img = cv2.flip (img, -1) # Apverskite vertikaliai pilką = cv2.cvtSpalva (img, cv2. COLOR_BGR2GRAY), w, h) veiduose: cv2. stačiakampis (img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, pasitikėjimas = atpažinimo priemonė.predict (pilka [y: y+h, x: x+w]) # Patikrinkite, ar pasitikėjimas yra mažesnis 100 ==> "0" puikiai atitinka, jei (pasitikėjimas <100): id = vardai [id] pasitikėjimas = "{0}% ".formatas (apvalus (100 - pasitikėjimas)) else: id =" nežinomas "pasitikėjimas =" {0}%". formatas (apvalus (100 - conf idence)) cv2.putText (img, str (id), (x+5, y-5), šriftas, 1, (255, 255, 255), 2) cv2.putText (img, str (pasitikėjimas), (x+5, y+h-5), šriftas, 1, (255, 255, 0), 1) cv2.imshow ('kamera', img) k = cv2.waitKey (10) & 0xff # Paspauskite 'ESC' jei norite išeiti iš vaizdo įrašo, jei k == 27: break # Padarykite šiek tiek valymo spausdinimo ("\ n [INFO] Išeikite iš programos ir išvalykite") cam.release () cv2.destroyAllWindows ()

Čia įtraukiame naują masyvą, todėl vietoj sunumeruotų ID rodysime „vardus“:

vardai = ['Nėra', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Taigi, pavyzdžiui: „Marcelo“vartotojas, turintis id = 1; Paula: id = 2 ir kt.

Toliau aptiksime veidą, tą patį padarėme anksčiau naudodami „haasCascade“klasifikatorių. Turėdami aptiktą veidą, galime iškviesti svarbiausią aukščiau esančio kodo funkciją:

ID, pasitikėjimas = atpažintojas. numatyti (pilka veido dalis)

Atpažinimo priemonė.predict () kaip parametrą paims užfiksuotą veido dalį, kurią reikia išanalizuoti, ir grąžins tikrąjį jos savininką, nurodydama jo identifikatorių ir pasitikėjimą atpažįstančiu šios rungtynės atžvilgiu.

Atminkite, kad pasitikėjimo indeksas grąžins „nulį“, jei jis bus visiškai suderintas

Ir pagaliau, jei atpažinimo priemonė galėtų nuspėti veidą, ant paveikslėlio uždedame tekstą su tikėtinu ID ir kiek yra „tikimybė“procentais, kad atitiktis yra teisinga („tikimybė“= 100 - pasitikėjimo indeksas). Jei ne, ant veido uždedama etiketė „nežinoma“.

Žemiau gifas su rezultatu:

Aukščiau esančiame paveikslėlyje aš parodau kai kuriuos su šiuo projektu atliktus bandymus, kuriuose taip pat naudoju nuotraukas, norėdamas patikrinti, ar atpažinimo aparatas veikia.

8 žingsnis: Išvada

Kaip visada, tikiuosi, kad šis projektas gali padėti kitiems rasti kelią į jaudinantį elektronikos pasaulį!

Norėdami gauti daugiau informacijos ir galutinį kodą, apsilankykite mano „GitHub“saugykloje: „OpenCV-Face-Recognition“

Norėdami gauti daugiau projektų, apsilankykite mano tinklaraštyje: MJRoBot.org

Žemiau žvilgsnis į būsimą pamoką, kurioje išnagrinėsime „automatinį veido stebėjimą ir kitus veido aptikimo metodus“:

Saludos iš pasaulio pietų!

Iki pasimatymo mano kitoje pamokoje!

Ačiū, Marcelo