Utambuzi wa Uso wa wakati halisi: Mradi wa Mwisho-Mwisho: Hatua 8 (na Picha)

2024 Mwandishi: John Day | [email protected]. Mwisho uliobadilishwa: 2024-01-30 12:54

Kwenye mafunzo yangu ya mwisho ya kuchunguza OpenCV, tulijifunza Ufuatiliaji wa DIRA YA AUTOMATIC OBJECT. Sasa tutatumia PiCam yetu kutambua nyuso katika wakati halisi, kama unaweza kuona hapa chini:

Mradi huu ulifanywa na Maktaba hii ya ajabu ya "Open Source Vision Library", OpenCV. Kwenye mafunzo haya, tutazingatia Raspberry Pi (kwa hivyo, Raspbian kama OS) na Python, lakini pia nilijaribu nambari kwenye Mac yangu na inafanya kazi vizuri. OpenCV iliundwa kwa ufanisi wa kihesabu na kwa kuzingatia kwa nguvu matumizi ya wakati halisi. Kwa hivyo, ni kamili kwa utambuzi wa uso wa wakati halisi kutumia kamera.

Ili kuunda mradi kamili juu ya Utambuzi wa Uso, lazima tufanye kazi kwa awamu 3 tofauti sana:

1. Kugundua Uso na Ukusanyaji wa Takwimu
2. Funza Kitambulisho
3. Utambuzi wa Uso

Mchoro wa chini unaendelea na awamu hizo:

Hatua ya 1: BoM - Muswada wa Nyenzo

Sehemu kuu:

1. Raspberry Pi V3 - US $ 32.00
2. Megapixels 5 1080p Sensor OV5647 Moduli ya Video ya Kamera Mini - US $ 13.00

Hatua ya 2: Kusanikisha Kifurushi cha OpenCV 3

Ninatumia Raspberry Pi V3 iliyosasishwa hadi toleo la mwisho la Raspbian (Stretch), kwa hivyo njia bora ya kuwa na OpenCV imewekwa, ni kufuata mafunzo bora yaliyotengenezwa na Adrian Rosebrock: Raspbian Stretch: Sakinisha OpenCV 3 + Python kwenye Raspberry Pi yako.

Nilijaribu miongozo kadhaa tofauti kusanikisha OpenCV kwenye Pi yangu. Mafunzo ya Adrian ndio bora zaidi. Ninakushauri ufanye vivyo hivyo, kufuata mwongozo wake hatua kwa hatua.

Mara tu unapomaliza mafunzo ya Adrian, unapaswa kuwa na mazingira dhahiri ya OpenCV tayari kuendesha majaribio yetu kwenye Pi yako.

Wacha tuende kwenye mazingira yetu halisi na uthibitishe kuwa OpenCV 3 imewekwa kwa usahihi.

Adrian anapendekeza kuendesha amri "chanzo" kila wakati unapofungua kituo kipya ili kuhakikisha vigeuzi vya mfumo vimewekwa kwa usahihi.

chanzo ~ /.profile

Ifuatayo, wacha tuingie kwenye mazingira yetu halisi:

workon cv

Ukiona maandishi (cv) yanatangulia msukumo wako, basi uko katika mazingira ya kawaida ya cv:

(cv) pi @ rasiberi: ~ $Adrian anaita angalizo kuwa mazingira ya cv Python ni huru kabisa na imetengwa kutoka kwa toleo chaguo-msingi la Python iliyojumuishwa kwenye upakuaji wa Raspbian Stretch. Kwa hivyo, vifurushi vyovyote vya Python katika saraka ya vifurushi vya tovuti havitapatikana kwa mazingira ya kawaida ya cv. Vivyo hivyo, vifurushi vyovyote vya Python vilivyowekwa kwenye vifurushi vya tovuti vya cv hazitapatikana kwa usakinishaji wa Python wa ulimwengu

Sasa, ingiza kwa mkalimani wako wa Python:

chatu

na uthibitishe kuwa unaendesha toleo la 3.5 (au hapo juu)

Ndani ya mkalimani (">>>" itaonekana), ingiza maktaba ya OpenCV:

kuagiza cv2

Ikiwa hakuna ujumbe wa hitilafu unaoonekana, OpenCV imewekwa kwa usahihi KWENYE MAZINGIRA YAKO YA PYTHON VIRTUAL.

Unaweza pia kuangalia toleo la OpenCV lililosanikishwa:

cv2._ toleo_

3.3.0 inapaswa kuonekana (au toleo bora ambalo linaweza kutolewa baadaye). Print Screen ya Skrini hapo juu inaonyesha hatua zilizopita.

Hatua ya 3: Kupima Kamera yako

Mara tu unapoweka OpenCV kwenye RPi yako wacha tujaribu ili kuthibitisha kuwa kamera yako inafanya kazi vizuri.

Ninafikiria kuwa unayo PiCam iliyowekwa tayari kwenye Raspberry Pi yako.

Ingiza nambari ya chini ya Python kwenye IDE yako:

kuagiza numpy kama np

kuagiza cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # kuweka Upana cap.set (4, 480) # set Urefu wakati (Kweli): ret, frame = cap.read () frame = cv2. pindua (fremu, -1) # Pindua kamera wima kijivu = cv2.cvtColor (fremu, cv2. COLOR_BGR2GRAY) cv2.imshow ('frame', frame) cv2.imshow ('gray', gray) k = cv2.waitKey (30 & 0xff ikiwa k == 27: # waandishi wa habari 'ESC' ili kuacha kofia ya kuvunja tafadhali () cv2.destroyAllWindows ()

Nambari iliyo hapo juu itanasa mkondo wa video ambao utatengenezwa na PiCam yako, ikionyesha zote mbili, katika rangi ya BGR na hali ya Kijivu.

Kumbuka kuwa nilizungusha kamera yangu kwa wima kutokana na jinsi imekusanyika. Ikiwa sio kesi yako, toa maoni au ufute laini ya amri ya "flip".

Unaweza kupakua nambari kutoka kwa GitHub yangu: simpleCamTest.py

Ili kutekeleza, ingiza amri:

chatu rahisiCamTest.py

Ili kumaliza programu, lazima bonyeza kitufe [ESC] kwenye kibodi yako.

Bonyeza kipanya chako kwenye dirisha la video, kabla ya kubonyeza [ESC]

Picha hapo juu inaonyesha matokeo.

Watengenezaji wengine walipata shida wakati wa kujaribu kufungua kamera ("Assertion imeshindwa" ujumbe wa makosa). Hiyo inaweza kutokea ikiwa kamera haikuwezeshwa wakati wa usanidi wa OpenCv na kwa hivyo, madereva ya kamera hayakusanikishwa kwa usahihi. Ili kurekebisha, tumia amri:

sudo modprobe bcm2835-v4l2

Unaweza pia kuongeza bcm2835-v4l2 kwenye laini ya mwisho ya faili ya / nk / moduli ili dereva apakie kwenye buti.

Ili kujua zaidi kuhusu OpenCV, unaweza kufuata mafunzo: kupakia -video-python-opencv-tutorial

Hatua ya 4: Kugundua uso

Kazi ya msingi zaidi juu ya Utambuzi wa Uso ni kweli, "Kugundua Uso". Kabla ya kitu chochote, lazima "unasa" uso (Awamu ya 1) ili kuitambua, ikilinganishwa na sura mpya iliyonaswa siku za usoni (Awamu ya 3).

Njia ya kawaida kugundua uso (au vitu vyovyote), ni kutumia "Haar Cascade classifier"

Ugunduzi wa kitu ukitumia vigeuzi vya msingi vya Haar vya msingi ni njia bora ya kugundua kitu iliyopendekezwa na Paul Viola na Michael Jones kwenye jarida lao, "Kugundua Kitu cha Haraka kwa kutumia Utaftaji ulioimarishwa wa Vipengele Rahisi" mnamo 2001. Ni njia ya kujifunza mashine ambapo kazi ya kuteleza imefundishwa kutoka kwa picha nyingi nzuri na hasi. Inatumiwa kugundua vitu kwenye picha zingine.

Hapa tutafanya kazi na kugundua uso. Hapo awali, algorithm inahitaji picha nyingi nzuri (picha za nyuso) na picha hasi (picha bila nyuso) kumfundisha mpatanishi. Kisha tunahitaji kutoa huduma kutoka kwake. Habari njema ni kwamba OpenCV inakuja na mkufunzi pamoja na kigunduzi. Ikiwa unataka kufundisha kitambulisho chako mwenyewe kwa kitu chochote kama gari, ndege nk unaweza kutumia OpenCV kuunda moja. Maelezo yake kamili yametolewa hapa: Mafunzo ya Kusasisha Mpangilio.

Ikiwa hautaki kuunda upatanishi wako mwenyewe, OpenCV tayari ina vitangulizi vingi vya mafunzo ya awali ya uso, macho, tabasamu, nk faili hizo za XML zinaweza kupakuliwa kutoka kwa saraka ya haarcascades.

Nadharia ya kutosha, wacha tuunda kichunguzi cha uso na OpenCV!

Pakua faili: faceDetection.py kutoka kwa GitHub yangu.

kuagiza numpy kama np

kuagiza uso wa cv2Cascade = cv2. CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml') cap = cv2. VideoCapture (0) cap., img = cap.read () img = cv2.flip (img, -1) kijivu = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) nyuso = usoCascade.detectMultiScale (kijivu, scaleFactor = 1.2, min Majirani = 5, minSize = (20, 20)) kwa (x, y, w, h) katika nyuso: cv2. Mstatili (img, (x, y), (x + w, y + h), (255, 0, 0), 2) roi_gray = kijivu [y: y + h, x: x + w] roi_color = img [y: y + h, x: x + w] cv2.imshow ('video', img) k = cv2.waitKey (30) & 0xff ikiwa k == 27: # bonyeza 'ESC' ili kuacha cap. Tafadhali () cv2.destroyAllWindows ()

Amini usiamini, mistari michache hapo juu ya nambari ndio unahitaji kujua uso, ukitumia Python na OpenCV.

Unapolinganisha na nambari ya mwisho iliyotumika kujaribu kamera, utagundua kuwa sehemu chache ziliongezwa kwake. Kumbuka mstari hapa chini:

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

Huu ndio mstari unaobeba "kiainishaji" (hiyo lazima iwe kwenye saraka inayoitwa "Cascades /", chini ya saraka ya mradi wako).

Kisha, tutaweka kamera yetu na ndani ya kitanzi, tupakia video yetu ya kuingiza katika hali ya kijivu (sawa na tulivyoona hapo awali).

Sasa lazima tuite kazi yetu ya kuainisha, kuipitisha vigezo muhimu sana, kama sababu ya kiwango, idadi ya majirani na saizi ya chini ya uso uliogunduliwa.

nyuso = usoCascade.detectMultiScale (kijivu, wadogoFactor = 1.2, min Majirani = 5, minSize = (20, 20))

Wapi,

• kijivu ni picha ya kijivu ya pembejeo.
• scaleFactor ni parameter inayoelezea ni kiasi gani saizi ya picha imepunguzwa kwa kila kiwango cha picha. Inatumika kuunda piramidi ya kiwango.
• Majirani ni parameta inayoainisha ni ngapi majirani kila mstatili wa mgombea anapaswa kuwa nayo, kuihifadhi. Nambari ya juu inatoa chanya za chini za uwongo.
• minSize ni saizi ya chini ya mstatili kuzingatiwa kama uso.

Kazi itagundua nyuso kwenye picha. Ifuatayo, lazima "tuweke alama" nyuso kwenye picha, kwa kutumia, kwa mfano, mstatili wa bluu. Hii imefanywa na sehemu hii ya nambari:

kwa (x, y, w, h) katika nyuso:

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

Ikiwa nyuso zinapatikana, inarudisha nafasi za nyuso zilizogunduliwa kama mstatili na kona ya kushoto juu (x, y) na kuwa na "w" kama Upana wake na "h" kama Urefu wake ==> (x, y, w, h). Tafadhali angalia picha hapo juu.

Mara tu tutakapopata maeneo haya, tunaweza kuunda "ROI" (mstatili uliochorwa) kwa uso na kuwasilisha matokeo na kazi ya imshow ().

Endesha Hati ya chatu hapo juu kwenye mazingira yako ya chatu, ukitumia Kituo cha Rpi:

chatu usoDetection.py

Matokeo:

Unaweza pia kujumuisha vitambulisho vya "kugundua macho" au hata "kugundua tabasamu". Katika visa hivyo, utajumuisha kazi ya kuainisha na kuteka mstatili ndani ya kitanzi cha uso, kwa sababu haitakuwa na maana kugundua jicho au tabasamu nje ya uso.

Kumbuka kuwa kwenye Pi, kuwa na viainishaji kadhaa kwa nambari moja kutapunguza usindikaji, mara tu njia hii ya kugundua (HaarCascades) itatumia nguvu kubwa ya kihesabu. Kwenye desktop, ni rahisi kuiendesha.

Kwenye GitHub yangu utapata mifano mingine:

usoEyeDetection.py

usoSmileDetection.py

usoSmileEyeDetection.py

Na kwenye picha hapo juu, unaweza kuona matokeo.

Unaweza pia kufuata mafunzo hapa chini ili uelewe zaidi Kugundua Uso:

Ugunduzi wa Haar Cascade Object Face & Eye OpenCV Mafunzo ya Python

Hatua ya 5: Ukusanyaji wa Takwimu

Kwanza kabisa, lazima nimshukuru Ramiz Raja kwa kazi yake nzuri juu ya Utambuzi wa Uso kwenye picha:

KUTAMBUA USO KUTUMIA OPENCV NA PYTHON: MWONGOZO WA MWANZO

na pia Anirban Kar, ambayo ilitengeneza mafunzo kamili sana kwa kutumia video:

KUTAMBUA USO - sehemu 3

Ninapendekeza uangalie mafunzo yote mawili.

Kusema hivyo, wacha tuanze awamu ya kwanza ya mradi wetu. Tutafanya hapa, ni kutoka kwa hatua ya mwisho (Kugundua Uso), tutaunda tu hifadhidata, ambapo tutahifadhi kwa kila kitambulisho, kikundi cha picha za kijivu na sehemu ambayo ilitumika kugundua uso.

Kwanza, tengeneza saraka ambapo unaendeleza mradi wako, kwa mfano, FacialRecognitionProject:

Mkdir UsoniKutambuaProject

Katika saraka hii, kando na hati 3 za chatu ambazo tutatengeneza kwa mradi wetu, lazima tuhifadhiwe juu yake Kiainishaji cha usoni. Unaweza kuipakua kutoka kwa GitHub yangu: haarcascade_frontalface_default.xml

Ifuatayo, tengeneza kijitabu kidogo ambapo tutahifadhi sampuli zetu za uso na kukipa jina "setaseti":

mkusanyiko wa data wa mkdir

Na pakua nambari kutoka kwa GitHub yangu: 01_face_dataset.py

kuagiza cv2

kuagiza os cam = cv2. VideoCapture (0) cam.set (3, 640) # set up video width cam.set (4, 480) # set video height face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # Kwa kila mtu, ingiza kitambulisho kimoja cha uso cha uso face_id = ingizo ('\ n ingiza kitambulisho cha mwisho cha kitambulisho cha mtumiaji ==>') chapisha ("\ n [INFO] Inapoanza kukamata uso. Angalia kamera na subiri …") # Anzisha hesabu ya hesabu ya uso ya mtu binafsi = 0 wakati (kweli): kijivu, 1.3, 5) kwa (x, y, w, h) katika nyuso: cv2. mstatili (img, (x, y), (x + w, y + h), (255, 0, 0), 2 hesabu + = 1 # Hifadhi picha iliyonaswa kwenye folda ya hifadhidata cv2.imwrite ("hifadhidata / Mtumiaji." + str (uso_id) + '.' + str (hesabu) + ".jpg", kijivu [y: y + h, x: x + w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # Bonyeza 'ESC' kwa kutoka video ikiwa k == 27: kuvunja hes count> = 30: # Chukua sampuli ya uso 30 na uache mapumziko ya video # Do ab ya kuchapisha ("\ n [INFO] Programu ya Kuacha na kusafisha vitu") cam.release () cv2.destroyAllWindows ()

Nambari hiyo ni sawa na nambari ambayo tuliona kwa kugundua uso. Tulichoongeza, ilikuwa "amri ya kuingiza" kukamata kitambulisho cha mtumiaji, hiyo inapaswa kuwa nambari kamili (1, 2, 3, nk)

uso_id = ingizo ('ingiza kitambulisho cha mtumiaji mwisho vyombo vya habari ==>')

Na kwa kila moja ya fremu zilizonaswa, tunapaswa kuzihifadhi kama faili kwenye saraka ya "hifadhidata":

cv2.imwrite ("hifadhidata / Mtumiaji." + str (uso_id) + '.' + str (hesabu) + ".jpg", kijivu [y: y + h, x: x + w])

Kumbuka kuwa kwa kuhifadhi faili hapo juu, lazima uwe umeingiza maktaba "os". Kila jina la faili litafuata muundo:

Mtumiaji.face_id.count.jpg

Kwa mfano, kwa mtumiaji aliye na uso wa uso = 1, faili ya sampuli ya 4 kwenye hifadhidata / saraka itakuwa kitu kama:

Mtumiaji.1.4.jpg

kama inavyoonyeshwa kwenye picha hapo juu kutoka kwa Pi yangu. Kwenye nambari yangu, ninachukua sampuli 30 kutoka kwa kila kitambulisho. Unaweza kuibadilisha kwenye "elif" ya mwisho. Idadi ya sampuli hutumiwa kuvunja kitanzi ambapo sampuli za uso zinakamatwa.

Endesha hati ya chatu na ukamata vitambulisho vichache. Lazima uendeshe hati kila wakati unapotaka kujumlisha mtumiaji mpya (au kubadilisha picha kwa ile ambayo tayari ipo).

Hatua ya 6: Mkufunzi

Katika awamu hii ya pili, lazima tuchukue data zote za mtumiaji kutoka kwa hifadhidata yetu na "mkufunzi" Kitambuzi cha OpenCV. Hii imefanywa moja kwa moja na kazi maalum ya OpenCV. Matokeo yake yatakuwa faili ya.yml ambayo itahifadhiwa kwenye saraka ya "mkufunzi /".

Kwa hivyo, wacha tuanze kuunda saraka ndogo ambapo tutahifadhi data iliyofunzwa:

mkufunzi wa mkdir

Pakua kutoka kwa GitHub yangu hati ya pili ya chatu: 02_face_training.py

kuagiza cv2

kuagiza numpy kama np kutoka PIL kuagiza Image kuagiza os # Njia ya hifadhidata ya picha ya uso = 'dataset' kutambua = cv2.face. LBPHFaceRecognizer_create () detector = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # kazi ili kupata picha na lebo ya data def getImagesAndLabels (njia): imagePaths = [os.path.join (path, f) for f in os.listdir (path)] faceSamples = ids = for imagePath in imagePaths: PIL_img = Image.open (imagePath). Convert ('L') # ibadilishe kuwa kijivu img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [- 1]. mgawanyiko (".") [1]) nyuso = detector.detectMultiScale (img_numpy) ya (x, y, w, h) katika nyuso: faceSamples.append (img_numpy [y: y + h, x: x + w]) ids. ids)) # Hifadhi mfano kwa mkufunzi / mkufunzi.yml kitambulisho.andika ('mkufunzi / mkufunzi.yml') # recognizer.save () alifanya kazi kwenye Mac, lakini sio kwenye Pi # Chapisha idadi ya nyuso zilizofunzwa na kumaliza mpango wa kuchapisha. ("\ n [INFO] {0} nyuso zimefundishwa. Programu ya Kuondoka". muundo (len (np.unique (ids))))

Thibitisha ikiwa una maktaba ya PIL iliyosanikishwa kwenye Rpi yako. Ikiwa sivyo, tumia amri ya chini kwenye Kituo:

bomba kufunga mto

Tutatumia kama kitambulisho, LBPH (HISTOGRAM ZA BINARY PATTERNS HISTOGRAMS) Kitambulisho cha Uso, kilichojumuishwa kwenye kifurushi cha OpenCV. Tunafanya hivyo katika mstari ufuatao:

kitambuzi = cv2.face. LBPHFaceRecognizer_create ()

Kazi "getImagesAndLabels (njia)", itachukua picha zote kwenye saraka: "seta /", ikirudisha safu mbili: "Vitambulisho" na "nyuso". Na safu hizo kama pembejeo, "tutafundisha kitambulisho chetu":

treni ya kutambua (nyuso, vitambulisho)

Kama matokeo, faili inayoitwa "mkufunzi.yml" itahifadhiwa kwenye saraka ya mkufunzi ambayo iliundwa hapo awali na sisi.

Hiyo ndio! Nilijumuisha taarifa ya kuchapisha ya mwisho ambapo nilionyeshea uthibitisho, idadi ya nyuso za Mtumiaji tulizozifundisha.

Kila wakati unapofanya Awamu ya 1, Awamu ya 2 lazima pia iendeshwe

Hatua ya 7: Kutambua

Sasa, tulifikia awamu ya mwisho ya mradi wetu. Hapa, tutanasa sura mpya kwenye kamera yetu na ikiwa mtu huyu alikuwa amekamata uso wake na kufundishwa hapo awali, kitambulisho chetu kitatengeneza "utabiri" wa kurudisha kitambulisho chake na faharisi, iliyoonyeshwa jinsi kitambuaji kina imani na mechi hii.

Wacha tupakue hati ya chatu ya awamu ya 3 kutoka kwa GitHub yangu: 03_face_recognition.py.

kuagiza cv2

kuagiza numpy kama np kuagiza os recognizer = cv2.face. LBPHFaceRecognizer_create () recognizer.read ('mkufunzi / mkufunzi.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. ',' W '] # Anzisha na anza kukamata video ya wakati halisi cam = cv2. VideoCapture (0) cam.set (3, 640) # set video widht cam.set (4, 480) # set video height # Define min window size kutambuliwa kama uso minW = 0.1 * cam.get (3) minH = 0.1 * cam.get (4) wakati True: ret, img = cam.read () img = cv2.flip (img, -1) # Flip wima kijivu = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) nyuso = usoCascade.detectMultiScale (kijivu, scaleFactor = 1.2, minMajirani = 5, minSize = (int (minW), int (minH)),) kwa (x, y, w, h) katika nyuso: cv2. mstatili (img, (x, y), (x + w, y + h), (0, 255, 0), 2) id, kujiamini = kutambua. tabiri (kijivu [y: y + h, x: x + w]) # Angalia ikiwa kujiamini ni chini yao 100 ==> "0" inafanana kabisa ikiwa (kujiamini <100): id = majina [id] kujiamini = "{0}% fomati (duru (100 - ujasiri)) mwingine: id = "haijulikani" kujiamini = "{0}%". fomati (duru (100 - conf idence)) cv2.putText (img, str (id), (x + 5, y-5), font, 1, (255, 255, 255), 2) cv2.putText (img, str (kujiamini), (x + 5, y + h-5), font, 1, (255, 255, 0), 1) cv2.imshow ('camera', img) k = cv2.waitKey (10) & 0xff # Bonyeza 'ESC' kwa kutoka kwa video ikiwa k == 27: kuvunja # Fanya chapisho kidogo la kusafisha ("\ n [INFO] Toka kwa Mpango na vitu vya kusafisha") cam.release () cv2.destroyAllWindows ()

Tunajumuisha hapa safu mpya, kwa hivyo tutaonyesha "majina", badala ya vitambulisho vyenye nambari:

majina = ['Hakuna', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Kwa hivyo, kwa mfano: Marcelo atatumia mtumiaji id = 1; Paula: id = 2, nk.

Ifuatayo, tutagundua uso, vile vile tulivyofanya hapo awali na upatanishi wa haasCascade. Kuwa na uso uliogunduliwa tunaweza kupiga kazi muhimu zaidi katika nambari hapo juu:

kitambulisho, kujiamini = kutambua. kutabiri (sehemu ya kijivu ya uso)

Kitabiri. Kitabiri (), itachukua kama kigezo sehemu iliyokamatwa ya uso kuchambuliwa na itamrudisha mmiliki wake anayewezekana, ikionyesha kitambulisho chake na jinsi mtambuaji ana imani kubwa kuhusiana na mechi hii.

Kumbuka kuwa faharisi ya kujiamini itarudi "sifuri" ikiwa itahesabiwa kuwa mechi inayofaa

Na mwishowe, kama kitambulisho kingeweza kutabiri uso, tunaweka maandishi juu ya picha na kitambulisho kinachowezekana na ni "uwezekano" gani katika% kwamba mechi ni sahihi ("uwezekano" = 100 - faharisi ya kujiamini). Ikiwa sivyo, lebo ya "unknow" imewekwa usoni.

Chini ya zawadi na matokeo:

Kwenye picha hapo juu, ninaonyesha majaribio kadhaa yaliyofanywa na mradi huu, ambapo pia nimetumia picha kudhibitisha ikiwa kitambulisho kinafanya kazi.

Hatua ya 8: Hitimisho

Kama kawaida, natumahi mradi huu unaweza kusaidia wengine kupata njia yao katika ulimwengu wa kusisimua wa umeme!

Kwa maelezo na nambari ya mwisho, tafadhali tembelea duka langu la GitHub: OpenCV-Face-Recognition

Kwa miradi zaidi, tafadhali tembelea blogi yangu: MJRoBot.org

Chini ya muhtasari wa mafunzo ya siku za usoni, ambapo tutachunguza "wimbo wa moja kwa moja wa uso na njia zingine za kugundua uso":

Saludos kutoka kusini mwa ulimwengu!

Tukutane kwenye mafunzo yangu yafuatayo!

Asante, Marcelo