Sejas atpazīšana ar OpenCV

Gadu gaitā mašīnu sarežģītība ir pieaugusi, un datori nav izņēmums. Datori cilvēcei ir palīdzējuši atrisināt daudz problēmu un paveikt daudz sarežģītu uzdevumu. Ir pagājuši laiki, kad visi datori bija vienkārši aritmētiskas darbības, un datori tagad virza pasauli.

Datori ir kļuvuši tik sarežģīti, ka viņi tiek apmācīti domāt kā cilvēki.
Jā!

Šajā rakstā mēs darīsim kaut ko tādu. Kā cilvēkiem, citu cilvēku seju atpazīšana ir vienkāršs uzdevums, un, neskatoties uz mūsdienu datoru spējām, datoram tas nav tik vienkārši, tāpēc mums tas ir jāapmāca, lai varētu darīt to pašu.

Daudzi raksti, kurus jūs redzētu, apstājas pie vienkāršas sejas noteikšanas, taču šajā rakstā būtu apskatīts ne tikai sejas noteikšana, bet arī sejas atpazīšana.

Tas nozīmē, ka, ja datoram tiek uzrādītas divas manas bildes, tas ne tikai atpazīs, kāda attēla daļa ir mana seja, bet arī atpazīs, ka es esmu arī abās bildēs.

Vispirms mums vispirms ir jāinstalē opencv mūsu mašīnās, ko var izdarīt tikai tad, ja esat instalējis Python. Šī raksta mērķis nav Python instalēšana, tādēļ, ja jūsu datorā tā vēl nav, varat instalēt Python no Python vietnes.

Lai instalētu Open CV, mēs to varam izdarīt, izmantojot komandu pip.

pip instalējiet opencv-python

Šajā rakstā mēs izmantosim arī numpy pakotni, kas jāinstalē līdzās OpenCV, izmantojot iepriekš minēto komandu.

Ja numpy netika instalēts, to varat viegli izdarīt, izmantojot zemāk esošo komandu:

pip instalēt numpy

Lai apstiprinātu, ka jūsu OpenCV ir instalēts, aktivizējot Python interaktīvo vidi, mēģiniet to importēt, izmantojot:

importēt cv2

Ja nesaņemat kļūdu, varat turpināt.

Lai veiktu sejas atpazīšanu, mēs rakstītu trīs scenārijus. Viens, lai izveidotu attēlu datu kopu, cits, lai apmācītu šos attēlus, un pēc tam pēdējais, kas atpazīst sejas, pamatojoties uz datora apmācības rezultātiem.

Mums būtu nepieciešama Haar kaskāde, ko nodrošina Open CV. Šo failu var iegūt no atvērtā direktorija cv2 / data / haarcascade_frontalface_default.xml manā mašīnā arī tam jābūt vienādam ar jūsu mašīnu. Nokopējiet failu mapē, kurā vēlaties veikt sejas atpazīšanu.

Tagad iedziļināsimies visdažādākajās lietās.
Mēs mēģinātu iegūt mūsu tīmekļa kameru, lai iegūtu attēlam nepieciešamos attēlus.

importēt cv2
vid_cam = cv2.Video uzņemšana (0)
sejas_detektors = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
skaits = 0
kamēr (vid_cam.isOpened ()):
ret, image_frame = vid_cam.lasīt ()
pelēks = cv2.cvtColor (image_frame, cv2.COLOR_BGR2GRAY)
sejas = sejas_detektors.noteiktMultiScale (pelēks, 1.3, 5)
(x, y, w, h) sejās:
CV2.taisnstūris (image_frame, (x, y), (x + w, y + h), (255,0,0), 2)
skaits + = 1
CV2.imwrite ("datu kopa / Lietotājs."+ str (face_id) + '.'+ str (skaits) + ".jpg ", pelēks [y: y + h, x: x + w])
CV2.imshow ('rāmis', image_frame)
ja cv2.waitKey (100) un 0xFF == ord ('q'):
pārtraukums
elifu skaits> 100:
pārtraukums
vid_cam.atbrīvot ()
CV2.destrAllWindows ()

Tātad, lai izskaidrotu katras koda rindiņas darbību:

importēt cv2

Šī ir komanda, kas liek python iekļaut ārēju bibliotēku, kas jāizmanto šajā kodā, šajā gadījumā tā ir Open CV.

vid_cam = cv2.Video uzņemšana (0)

Šis kods aicina importēto Open CV bibliotēku sākt tvert, un šajā brīdī tiek sākta tīmekļa kamera. Ja atvērtais CV neatbalsta jūsu tīmekļa kameru, kods šeit neizdosies.

sejas_detektors = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')

Lai mēs varētu veikt attēlu noteikšanu, ir nepieciešams šis kods. Atvērtajā CV tiek izmantota 'haarcascade_frontalface_default.xml 'kaskādes klasifikācijai. Rezultātā iegūtais objekts tiek saglabāts mainīgajā face_detector.

face_id = 1

Šeit ir gadījums, kad tiek iestatīts sejas ID numurs, tāpēc pirmā seja iegūst ID 1.

skaits = 0

Mēs uzņemsim pāris attēlus, jo atvērtajam CV ir jāapmāca attēli, lai varētu atpazīt sejas, skaitļu mainīgais kalpo kā attēlu skaits.

kamēr (vid_cam.isOpened ()):

Tas ļauj turpināt šādas darbības, ja tiek atvērta videokamera. Metode isOpened () atgriež patiesu vai nepatiesu.

ret, image_frame = vid_cam.lasīt ()

Lūk, vid_cam.read () ieskatās video uzņemšanā un pēc tam uzņem kadru, kas tiek saglabāts mainīgajā image_frame, ja darbība ir veiksmīga, būla vērtība True tiek atgriezta un saglabāta mainīgajā mainīgajā

pelēks = cv2.cvtColor (image_frame, cv2.COLOR_BGR2GRAY)

Lai pārveidotu attēla rāmi vajadzīgajā krāsu tipā, tiek izmantota metode cvtColor (). Šajā gadījumā mēs to esam pārveidojuši pelēktoņos.

sejas = sejas_detektors.noteiktMultiScale (pelēks, 1.3, 5)

Tas pārbauda dažāda lieluma rāmjus un mēģina tos iestatīt mērogā, tas tiek piemērots mainīgajam, kuram tika izmantota Haar Cascade.

(x, y, w, h) sejās:

Šeit mēs cilpojam cauri sejām un to izmēriem, kur x un y apzīmē koordinātas, bet w un h - attiecīgi platumu un augstumu.

CV2.taisnstūris (image_frame, (x, y), (x + w, y + h), (255,0,0), 2)

Atcerieties, ka mēs joprojām strādājam ar videokameru, pēc tam videokamera apgriež vajadzīgo attēla daļu atbilstoši iepriekš minētajiem izmēriem.

skaits + = 1

Tiklīdz tas ir izdarīts, skaitītāja mainīgais, kas stāv kā skaitītājs, pēc tam palielinās.

CV2.imwrite ("datu kopa / Lietotājs."+ str (face_id) + '.'+ str (skaits) + ".jpg ", pelēks [y: y + h, x: x + w])

Apgrieztais attēls tiek saglabāts ar vārdu User (face_id).(skaitīt).JPG un ievietojiet mapē ar nosaukumu datu kopa.

CV2.imshow ('rāmis', image_frame)

Pēc saglabāšanas šis kods nodrošina, ka attēla video rāmis tiek parādīts ar taisnstūri uz personas sejas pēc sejas noteikšanas.

ja cv2.waitKey (100) un 0xFF == ord ('q'):
pārtraukums

Pēc katra attēla lietotājam ir atļauts apturēt programmu no vairāk attēlu uzņemšanas, ko var izdarīt, nospiežot taustiņu 'q' vismaz 100 ms.

elifu skaits> 100:
pārtraukums

Šis kods palīdz apturēt video darbību brīdī, kad tiek uzņemti 100 attēli, neatkarīgi no tā, vai lietotājs vēlas uzņemt vairāk vai nē.

vid_cam.atbrīvot ()

Šeit tīmekļa kamera ir aizvērta un ne tikai apstājusies no fotografēšanas.

CV2.destrAllWindows ()

Tad visi OpenCV atvērtie logi ir iznīcināti, un kods beidzas.

Tagad, kad tas ir paveikts, mēs varam sākt apmācīt attēlu datu kopu:

importēt cv2, os
importēt numpy kā np
no PIL importa attēla
atpazinējs = cv2.seja.createLBPHFaceRecognizer ()
detektors = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");
def getImagesAndLabels (ceļš):
imagePaths = [os.ceļš.pievienoties (ceļš, f) f in os.listdir (ceļš)]
faceSamples = []
id = []
priekš imagePath mapē imagePaths:
PIL_img = Attēls.atvērt (imagePath).konvertēt ('L')
img_numpy = np.masīvs (PIL_img, 'uint8')
id = int (os.ceļš.sadalīt (imagePath) [- 1].sadalīt (".") [1])
sejas = detektors.noteiktMultiScale (img_numpy)
(x, y, w, h) sejās:
sejasParaugi.pievienot (img_numpy [y: y + h, x: x + w])
ID.pievienot (id)
atgriezties faceSamples, ids
sejas, ids = getImagesAndLabels ('datu kopa')
atpazinējs.vilciens (sejas, np.masīvs (ID))
atpazinējs.saglabāt ('treneris / treneris.yml ')

Turpināsim un izskaidrosim arī šo kodu:

importēt cv2, os

Tāpat kā cits kods, arī šeit mēs importējam OpenCV un OS, kas mums būtu nepieciešami faila ceļam.

importēt numpy kā np

Mēs importējam arī numpy bibliotēku, kas tiktu izmantota matricas aprēķināšanai (matrica ir tikai masīvu izkārtojums).

no PIL importa attēla

Mēs importējam Python attēlu bibliotēku un pēc tam arī no šīs paketes iegūstam attēlu bibliotēku.

atpazītājs = cv2.seja.createLBPHFaceRecognizer ()

Tas tiek darīts, izmantojot metodi createLBPHFaceRecognizer () cv2.sejas objektu, tas palīdzētu padarīt sejas atpazīšanu vieglu, jo mums nav jāizdomā savs algoritmu kopums.

detektors = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");

Ja esat sekojis apmācībai, jūs ar to būtu saskāries jau iepriekš. Tas palīdz sejas noteikšanā, izmantojot “haarcascade_frontalface_default.xml ”kaskādes klasifikācijai.

def getImagesAndLabels (ceļš):

Tagad mēs gatavojamies sākt attēlu apmācību, tāpēc mēs izveidojam funkciju.

imagePaths = [os.ceļš.pievienoties (ceļš, f) f in os.listdir (ceļš)]

Šis kods tiek pārbaudīts faila pašreizējā direktorijā un tiek pārbaudīti attēlu faili, pēc tam tie tiek pievienoti šim sarakstam.

faceSamples = []

Tas inicializē paraugu sarakstu, šajā brīdī tas ir tukšs, bet koda darbībai tiks pievienotas sejas.

id = []

Inicializējiet id sarakstu, kas sākotnēji ir tukšs.

priekš imagePath mapē imagePaths:

Atcerieties kodu, kas direktorijā pārbaudīja attēlu failus? Jā? Tagad mēs pārskatīsim katru no šiem failiem un veiksim ar tiem operācijas.

PIL_img = Attēls.atvērt (imagePath).konvertēt ('L')

Pirmais, ko mēs darām ar attēlu, ir pārveidot to par pelēktoņu, un šis kods to dara.

img_numpy = np.masīvs (PIL_img, 'uint8')

Pelēktoņu attēls ir tikai skaitļu virkne vienā vietā, tāpēc mēs no tiem izveidojam numpy masīvu un piešķiram tam mainīgajam.

id = int (os.ceļš.sadalīt (imagePath) [- 1].sadalīt (".") [1])

Ja atceraties failu, kas iegūst attēlus, jūs atceraties, ka mēs nosaukām failus lietotājam (face_id).skaitīt.jpg. Tātad šeit mēs sadalām vārdus ar “.”Un pēc tam mēs izvelkam face_id un šeit piešķiram mainīgajam. Mums būtu vajadzīgs identifikācija, lai to atzītu.

sejas = detektors.noteiktMultiScale (img_numpy)

No numpy masīva detektētMultiScale () metode mēģinās noteikt sejas no modeļa, ko tā atrod numpy masīvā. Tad tā piešķir vērtības mainīgajā sejas.

(x, y, w, h) sejās:

Šeit mēs aplūkojam mainīgajam piešķirtās vērtības. Vērtības šeit ir x un y koordinātas, kuras mēs varētu ņemt par izcelsmi, un pēc tam w un h attiecīgi stāv platumā un augstumā.

sejasParaugi.pievienot (img_numpy [y: y + h, x: x + w])

Iepriekš mēs izveidojām sejas paraugu sarakstu, taču tas bija tukšs. Šeit mums jāpievieno sejas šim sarakstam, un mēs pievienojam y līdz h, lai iegūtu divas y koordinātu vērtības, un tas pats tiek darīts x.

ID.pievienot (id)

Tagad sejas paraugu sarakstā ir seja, tāpēc mēs iegūstam tā ID un pievienojam to arī ID sarakstam.

atgriezties faceSamples, ids

Tad pēc visa tā mēs atgriežam sejas paraugu sarakstu un id sarakstu.

sejas, ids = getImagesAndLabels ('datu kopa')

Atcerieties, ka getImagesAndLabels () ir tikai funkcija. Tātad mums šeit jāizsauc funkcija, un atgriešanās vērtības tiek saglabātas seju un ID mainīgajos.

atpazinējs.vilciens (sejas, np.masīvs (ID))

Šeit notiek reālā apmācība. Mēs kādreiz agrāk izmantojām metodi createLBPHFaceRecognizer () un piešķirām atpazīšanas mainīgajam. Ir apmācību laiks!

atpazinējs.saglabāt ('treneris / treneris.yml ')

Pēc treniņa mums jāsaglabā apmācības rezultāti.
Pēc koda palaišanas tas izveido failu ar nosaukumu treneris.yml, ko pēc tam izmantotu sejas atpazīšanas kods.

Šeit ir sejas atpazīšanas kods:

importēt cv2
importēt numpy kā np
atpazītājs = cv2.seja.createLBPHFaceRecognizer ()
atpazinējs.slodze ('treneris / treneris.yml ')
cascadePath = "haarcascade_frontalface_default.xml "
faceCascade = cv2.CascadeClassifier (cascadePath)
font = cv2.FONT_HERSHEY_SIMPLEX
cam = cv2.Video uzņemšana (0)
kamēr patiess:
ret, im = izciļņa.lasīt ()
pelēks = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
sejas = faceCascade.noteiktMultiScale (pelēks, 1.2,5)
(x, y, w, h) sejās:
CV2.taisnstūris (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)
Id = atpazinējs.paredzēt (pelēks [y: y + h, x: x + w])
ja (Id == 1):
Id = "Nazmi"
cits:
Id = "Nezināms"
CV2.taisnstūris (im, (x-22, y-90), (x + w + 22, y-22), (0,255,0), -1)
CV2.putText (im, str (Id), (x, y-40), fonts, 2, (255,255,255), 3)
CV2.imshow ('im', im)
ja cv2.waitKey (10) un 0xFF == ord ('q'):
pārtraukums
izciļņa.atbrīvot ()
CV2.destrAllWindows ()

Ja jūs esat sekojis rakstam no sākuma, mēs to esam darījuši jau iepriekš. Ja neesat laipni darījis.

atpazinējs.slodze ('treneris / treneris.yml ')

Atcerieties, ka mēs apmācījām atpazinēju un saglabājām failu? Jā? Mēs tagad ielādējam šo failu.

cascadePath = "haarcascade_frontalface_default.xml "

Mēs darbotos ar haarcascade failu, un šeit mēs faila nosaukumu esam piešķīruši mainīgajam.

# Izveidojiet klasifikatoru no iepriekš uzbūvēta modeļa
faceCascade = cv2.CascadeClassifier (cascadePath)

Šeit mums jāveic kaskādes klasifikācija haarkaskādes failā.

font = cv2.FONT_HERSHEY_SIMPLEX

Mēs iestatījām fonta veidu, kas tiktu izmantots, kad kods atpazīst seju attēlā un parāda vārdu.

cam = cv2.Video uzņemšana (0)

Mēs esam bijuši šeit jau iepriekš, bet šoreiz ir pienācis laiks atpazīt sejas. Ja nezināt, ko šis kods dara, tas palaiž tīmekļa kameru.

kamēr patiess:
ret, im = izciļņa.lasīt ()
pelēks = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
sejas = faceCascade.noteiktMultiScale (pelēks, 1.2,5)
(x, y, w, h) sejās:

Tas viss ir izdarīts iepriekš, lūdzu, pārbaudiet kodu, kas tika izmantots attēlu saglabāšanai, ja nezināt, ko kods dara.

CV2.taisnstūris (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)

Tātad tas palīdz tīmekļa kamerai noteikt seju atrašanās vietu un novieto taisnstūri, kas norāda seju.

Id = atpazinējs.paredzēt (pelēks [y: y + h, x: x + w])

Mēs vienmēr esam ielādējuši vilciena failu atpazītājā, tāpēc tas tagad spēj atpazīt seju.

ja (Id == 1):
Id = "Es pats"
cits:
Id = "Nezināms"

Pēc mēģinājuma atpazīt, kas tā ir, tā pārbauda, ​​vai nav ID, un redz, vai tā pastāv. Šeit ID vērtība būtu tā, kurš piederēja, saskaroties ar šādu ID, kad tika izveidota attēlu datu kopa.

CV2.taisnstūris (im, (x-22, y-90), (x + w + 22, y-22), (0,255,0), -1)
CV2.putText (im, str (Id), (x, y-40), fonts, 2, (255,255,255), 3)

Kods, atrodot ID īpašnieku, ap seju uzzīmē taisnstūri un ievieto sejas īpašnieka vārdu. Seja atpazīta!

CV2.imshow ('im', im)

Šeit video rāmis tiek parādīts ar norobežotu taisnstūri.

ja cv2.waitKey (10) un 0xFF == ord ('q'):
pārtraukums
izciļņa.atbrīvot ()
CV2.destrAllWindows ()

Tātad, kad esat pabeidzis, varat pārtraukt programmu, nospiežot taustiņu q, un tā aptur tīmekļa kameru un aizver to.

Tur jums tas ir pieejams, jūsu tīmekļa kamera tagad var atpazīt sejas, un jūs varat to izmantot, kad vēlaties. Papildus tīmekļa kameras izmantošanai varat ielādēt arī attēlu, taču tam ir nepieciešamas citas darbības, nekā šajā rakstā minētās.

Jūs varat atrast avota kodu, kas izmantots tā github repo. Čivināt arī mūs, ja jums ir komentāri vai vēlaties apspriest @linuxhint