Разпознаване на лица в реално време: проект от край до край: 8 стъпки (със снимки)

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:53

В последния ми урок, проучващ OpenCV, научихме АВТОМАТИЧНО ПРОСЛЕДВАНЕ НА ОБЕКТИ НА ВИЗИЯ. Сега ще използваме нашия PiCam за разпознаване на лица в реално време, както можете да видите по-долу:

Този проект беше направен с тази фантастична „Библиотека за компютърно виждане с отворен код“, OpenCV. В този урок ще се съсредоточим върху Raspberry Pi (така че Raspbian като операционна система) и Python, но също така тествах кода на My Mac и той също работи добре. OpenCV е проектиран за изчислителна ефективност и със силен акцент върху приложения в реално време. Така че, той е идеален за разпознаване на лица в реално време с помощта на камера.

За да създадем цялостен проект за разпознаване на лица, трябва да работим върху 3 много различни фази:

1. Откриване на лица и събиране на данни
2. Обучете разпознаващия
3. Разпознаване на лица

Блок схемата по -долу възобновява тези фази:

Стъпка 1: BoM - материална сметка

Главни части:

1. Raspberry Pi V3 - 32,00 щ.д.
2. 5 -мегапикселов 1080p сензор OV5647 мини камерен видео модул - 13,00 щ.д.

Стъпка 2: Инсталиране на пакет OpenCV 3

Използвам Raspberry Pi V3, актуализиран до последната версия на Raspbian (Stretch), така че най -добрият начин да инсталирате OpenCV е да следвате отличния урок, разработен от Adrian Rosebrock: Raspbian Stretch: Инсталирайте OpenCV 3 + Python на вашия Raspberry Pi.

Опитах няколко различни ръководства за инсталиране на OpenCV на моя Pi. Урокът на Адриан е най -добрият. Съветвам ви да направите същото, следвайки стъпка по стъпка неговото ръководство.

След като завършите урока на Адриан, трябва да имате виртуална среда на OpenCV, готова за провеждане на нашите експерименти на вашия Pi.

Нека да отидем в нашата виртуална среда и да потвърдим, че OpenCV 3 е правилно инсталиран.

Адриан препоръчва да изпълнявате командата „източник“всеки път, когато отваряте нов терминал, за да сте сигурни, че системните ви променливи са настроени правилно.

източник ~/.профил

След това нека влезем във нашата виртуална среда:

Workon cv

Ако видите текста (cv), предхождащ вашата подкана, значи сте във виртуалната среда cv:

(cv) pi@малина: ~ $Адриан привлича вниманието, че виртуалната среда на cv Python е напълно независима и изолирана от стандартната версия на Python, включена в изтеглянето на Raspbian Stretch. Така че всички пакети на Python в глобалната директория на пакети сайтове няма да бъдат достъпни за виртуалната среда cv. По подобен начин всички пакети на Python, инсталирани в пакети на сайтове на cv, няма да бъдат достъпни за глобалната инсталация на Python

Сега въведете във вашия интерпретатор на Python:

python

и потвърдете, че използвате версия 3.5 (или по -нова)

Вътре в интерпретатора (ще се появи ">>>"), импортирайте библиотеката на OpenCV:

импортиране на cv2

Ако не се появят съобщения за грешка, OpenCV е правилно инсталиран НА ВАШАТА ПИТОННА ВИРТУАЛНА СРЕДА.

Можете също да проверите инсталираната версия на OpenCV:

cv2._ версия_

Трябва да се появи 3.3.0 (или по -добра версия, която може да бъде пусната в бъдеще). Горният терминал PrintScreen показва предишните стъпки.

Стъпка 3: Тестване на камерата

След като инсталирате OpenCV във вашия RPi, нека тестваме, за да потвърдим, че камерата ви работи правилно.

Предполагам, че вече имате инсталиран PiCam на вашия Raspberry Pi.

Въведете долния код на Python във вашата IDE:

внос numpy като np

import cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Height while (True): ret, frame = cap.read () frame = cv2. флип (кадър, -1) # Обърнете камерата вертикално сиво = cv2.cvt Цвят (рамка, cv2. COLOR_BGR2GREY) cv2.imshow ('рамка', рамка) cv2.imshow ('сиво', сиво) k = cv2.waitKey (30) & 0xff, ако k == 27: # натиснете 'ESC', за да излезете от прекъсването cap.release () cv2.destroyAllWindows ()

Горният код ще заснеме видео потока, който ще бъде генериран от вашия PiCam, показвайки и двете, в BGR цветен и сив режим.

Обърнете внимание, че завъртях камерата си вертикално поради начина на сглобяване. Ако не е вашият случай, коментирайте или изтрийте командния ред "flip".

Алтернативно можете да изтеглите кода от моя GitHub: simpleCamTest.py

За да изпълните, въведете командата:

python simpleCamTest.py

За да завършите програмата, трябва да натиснете клавиша [ESC] на клавиатурата си.

Щракнете с мишката върху прозореца на видеото, преди да натиснете [ESC]

Горната снимка показва резултата.

Някои производители откриха проблеми, когато се опитваха да отворят камерата (съобщения за грешка „Успехът е неуспешен“). Това може да се случи, ако камерата не е била активирана по време на инсталирането на OpenCv и затова драйверите на камерата не са се инсталирали правилно. За да коригирате, използвайте командата:

sudo modprobe bcm2835-v4l2

Можете също така да добавите bcm2835-v4l2 към последния ред на файла /etc /modules, така че драйверът да се зареди при зареждане.

За да научите повече за OpenCV, можете да следвате урока: зареждане -video-python-opencv-tutorial

Стъпка 4: Откриване на лица

Най -основната задача за разпознаване на лица е, разбира се, „Откриване на лица“. Преди всичко трябва да "заснемете" лице (Фаза 1), за да го разпознаете, в сравнение с ново лице, заснето в бъдеще (Фаза 3).

Най -често срещаният начин за откриване на лице (или каквито и да било обекти) е използването на "Haar Cascade класификатор"

Откриването на обекти с помощта на каскадни класификатори, базирани на функции на Haar, е ефективен метод за откриване на обекти, предложен от Пол Виола и Майкъл Джоунс в тяхната статия „Бързо откриване на обекти с помощта на подсилена каскада от прости функции“през 2001 г. Това е подход, базиран на машинно обучение, когато каскадната функция се обучава от много положителни и отрицателни изображения. След това се използва за откриване на обекти в други изображения.

Тук ще работим с разпознаване на лица. Първоначално алгоритъмът се нуждае от много положителни изображения (изображения на лица) и отрицателни изображения (изображения без лица), за да обучи класификатора. След това трябва да извлечем функции от него. Добрата новина е, че OpenCV идва с инструктор, както и с детектор. Ако искате да обучите свой собствен класификатор за всеки обект като кола, самолети и т.н., можете да използвате OpenCV, за да го създадете. Пълните му подробности са дадени тук: Cascade Classifier Training.

Ако не искате да създавате свой собствен класификатор, OpenCV вече съдържа много предварително обучени класификатори за лице, очи, усмивки и т.н. Тези XML файлове могат да бъдат изтеглени от директорията haarcascades.

Стига теория, нека създадем детектор за лице с OpenCV!

Изтеглете файла: faceDetection.py от моя GitHub.

внос numpy като 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 Height while True: ret, img = cap.read () img = cv2.flip (img, -1) сиво = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) лица = faceCascade.detectMultiScale (сиво, scaleFactor = 1.2, minNeighbors = 5, minSize = (20, 20)) за (x, y, w, h) в лица: cv2.правоъгълник (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = сив [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w] cv2.imshow ('видео', img) k = cv2.waitKey (30) & 0xff, ако k == 27: # натиснете 'ESC', за да излезете от прекъсването cap.release () cv2.destroyAllWindows ()

Вярвате или не, горните няколко реда код са всичко, от което се нуждаете, за да откриете лице, използвайки Python и OpenCV.

Когато сравните с последния код, използван за тестване на камерата, ще разберете, че към нея са добавени няколко части. Обърнете внимание на реда по -долу:

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

Това е редът, който зарежда "класификатора" (който трябва да е в директория, наречена "Cascades/", под директорията на вашия проект).

След това ще настроим нашата камера и вътре в цикъла, ще заредим входното си видео в режим на сиво (същото видяхме преди).

Сега трябва да извикаме функцията ни за класификатор, като й предадем някои много важни параметри, като мащабен коефициент, брой съседи и минимален размер на откритото лице.

фасони = faceCascade.detectMultiScale (сиво, scaleFactor = 1,2, minNeighbors = 5, minSize = (20, 20))

Където,

• сивото е входното изображение в сивата скала.
• scaleFactor е параметърът, определящ колко се намалява размерът на изображението при всеки мащаб на изображението. Използва се за създаване на мащабна пирамида.
• minNeighbors е параметър, определящ колко съседи трябва да има всеки кандидат правоъгълник, за да го запази. По -висок брой дава по -малко фалшиви положителни резултати.
• minSize е минималният размер на правоъгълника, който трябва да се счита за лице.

Функцията ще разпознава лица на изображението. След това трябва да „маркираме“лицата в изображението, използвайки, например, син правоъгълник. Това става с тази част от кода:

за (x, y, w, h) в лица:

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

Ако се открият лица, той връща позициите на откритите лица като правоъгълник с левия нагоре ъгъл (x, y) и с "w" като ширина и "h" като височина ==> (x, y, w, з). Моля, вижте горната снимка.

След като получим тези местоположения, можем да създадем "ROI" (нарисуван правоъгълник) за лицето и да представим резултата с функцията imshow ().

Стартирайте горния скрипт на python във вашата среда на python, като използвате терминала Rpi:

python faceDetection.py

Резултатът:

Можете също така да включите класификатори за „откриване на очи“или дори „разпознаване на усмивка“. В тези случаи ще включите функцията за класифициране и рисуване на правоъгълник вътре в цикъла на лицето, защото няма смисъл да откривате око или усмивка извън лицето.

Имайте предвид, че на Pi, като няколко класификатора в един и същ код ще забавят обработката, след като този метод за откриване (HaarCascades) използва голямо количество изчислителна мощ. На работния плот е по -лесно да го стартирате.

На моя GitHub ще намерите други примери:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

И на горната снимка можете да видите резултата.

Можете също да следвате следния урок, за да разберете по -добре функцията за разпознаване на лица:

Haar Cascade Object Detection Object Face and Eye OpenCV Python Урок

Стъпка 5: Събиране на данни

Преди всичко трябва да благодаря на Рамиз Раджа за страхотната му работа по разпознаване на лица върху снимки:

ПРИЗНАВАНЕ НА ЛИЦА С ИЗПОЛЗВАНЕ НА OPENCV И ПИТОН: РЪКОВОДСТВО ЗА НАЧАЛНИК

и също Анирбан Кар, който разработи много изчерпателен урок, използващ видео:

ПРИЗНАНИЕ НА ЛИЦЕ - 3 части

Наистина ви препоръчвам да разгледате и двата урока.

Казвайки това, нека започнем първата фаза на нашия проект. Това, което ще направим тук, започва от последната стъпка (разпознаване на лица), ние просто ще създадем набор от данни, където ще съхраняваме за всеки идентификатор, група снимки в сиво с частта, която е била използвана за разпознаване на лица.

Първо създайте директория, в която разработвате вашия проект, например FacialRecognitionProject:

mkdir FacialRecognitionProject

В тази директория, освен 3 -те скрипта на python, които ще създадем за нашия проект, трябва да сме записали в него Класификатора на лицето. Можете да го изтеглите от моя GitHub: haarcascade_frontalface_default.xml

След това създайте поддиректория, където ще съхраняваме нашите образци на лицето и я кръстете „набор от данни“:

набор от данни mkdir

И изтеглете кода от моя GitHub: 01_face_dataset.py

импортиране на 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') # За всеки човек, въведете една цифрова идентификация на лицето face_id = input ('\ n въведете потребителски идентификатор end press ==>') print ("\ n [INFO] Инициализиране на заснемането на лица. Погледнете камерата и изчакайте …") # Инициализирайте индивидуалния брой извадки = 0 while (Вярно): ret, img = cam.read () img = cv2.flip (img, -1) # флип видео изображение вертикално сиво = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) лица = face_detector.detectMultiScale (сиво, 1.3, 5) за (x, y, w, h) в лица: cv2.rectangle (img, (x, y), (x+w, y+h), (255, 0, 0), 2) count + = 1 # Запазете заснетото изображение в папката с набори от данни cv2.imwrite ("набор от данни/потребител." + str (face_id) + '.' + str (брой) + ".jpg", сиво [y: y + h, x: x+w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # Натиснете 'ESC' за излизане от видео, ако k == 27: прекъсване на elif> = 30: # Вземете проба от 30 лица и спрете видео паузата # Направете ab it of cleanup print ("\ n [INFO] Излизане от програмата и неща за почистване") cam.release () cv2.destroyAllWindows ()

Кодът е много подобен на кода, който видяхме за разпознаване на лица. Това, което добавихме, беше „команда за въвеждане“за улавяне на потребителски идентификатор, който трябва да е цяло число (1, 2, 3 и т.н.)

face_id = input ('\ n въведете потребителски идентификатор end press ==>')

И за всеки един от заснетите кадри, трябва да го запишем като файл в директория "набор от данни":

cv2.imwrite ("набор от данни/потребител." + str (face_id) + '.' + str (брой) + ".jpg", сиво [y: y + h, x: x + w])

Обърнете внимание, че за да запазите горния файл, трябва да сте импортирали библиотеката "os". Името на всеки файл ще следва структурата:

User.face_id.count.jpg

Например, за потребител с face_id = 1, четвъртият примерен файл в набор от данни/ директория ще бъде нещо като:

Потребител.1.4.jpg

както е показано на горната снимка от моя Pi. В моя код записвам 30 проби от всеки идентификатор. Можете да го промените на последния "elif". Броят на пробите се използва за прекъсване на цикъла, където се улавят пробите от лицето.

Стартирайте скрипта на Python и заснемете няколко идентификатора. Трябва да стартирате скрипта всеки път, когато искате да обедините нов потребител (или да промените снимките за такъв, който вече съществува).

Стъпка 6: Треньор

На тази втора фаза трябва да вземем всички потребителски данни от нашия набор от данни и да „обучим“OpenCV Recognizer. Това се прави директно от определена функция OpenCV. Резултатът ще бъде.yml файл, който ще бъде записан в директория "trainer/".

Така че, нека започнем да създаваме поддиректория, където ще съхраняваме обучените данни:

треньор mkdir

Изтеглете от моя GitHub втория скрипт на python: 02_face_training.py

импортиране на cv2

импортиране на numpy като np от PIL импортиране на изображение за импортиране os # Път за базата данни за изображение на пътя = 'набор от данни' разпознавач = cv2.face. LBPHFaceRecognizer_create () детектор = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # функция за получаване на изображения и данни за етикети def getImagesAndLabels (път): imagePaths = [os.path.join (пътека, f) за f в os.listdir (път)] faceSamples = ids = за imagePath в imagePaths: PIL_img = Image. разделяне (".") [1]) лица = детектор.detectMultiScale (img_numpy) за (x, y, w, h) в лица: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) връщане faceSamples, ids print ("\ n [INFO] Обучаващи лица. Ще отнеме няколко секунди. Изчакайте …") лица, ids = getImagesAndLabels (пътека) разпознаващ.train (лица, np.array (ids)) # Запазете модела в trainer/trainer.yml Reconizer.write ('trainer/trainer.yml') # Reconizer.save () работеше на Mac, но не и на Pi # Отпечатайте броя на обучените лица и отпечатайте крайната програма ("\ n [INFO] {0} лица са обучени. Излизане от програмата".format (len (np.unique (ids))))

Потвърдете дали имате инсталирана PIL библиотека на вашия Rpi. Ако не, изпълнете командата по -долу в терминала:

възглавница за инсталиране на пип

Ще използваме като разпознавател, LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) Face Recognizer, включен в пакета OpenCV. Правим това в следния ред:

разпознавач = cv2.face. LBPHFaceRecognizer_create ()

Функцията "getImagesAndLabels (пътека)" ще направи всички снимки в директорията: "набор от данни/", връщайки 2 масива: "Идентификатори" и "лица". С тези масиви като вход, ние ще "обучим нашия разпознавател":

разпознаващ влак (лица, идентификатори)

В резултат на това файл с име „trainer.yml“ще бъде записан в директорията на обучителя, която е създадена преди това от нас.

Това е! Включих последното изявление за печат, където показах за потвърждение, броя на лицата на потребителя, които сме обучили.

Всеки път, когато изпълнявате Фаза 1, Фаза 2 също трябва да се изпълнява

Стъпка 7: Разпознаване

Сега стигнахме до последната фаза на нашия проект. Тук ще заснемем свежо лице на нашата камера и ако този човек е имал заснето и обучено лице преди това, нашият разпознавач ще направи „прогноза“, връщайки идентификационния му номер и индекс, показващ колко уверен е разпознаващият с този мач.

Нека изтеглим Python скрипта от третата фаза от моя GitHub: 03_face_recognition.py.

импортиране на cv2

импортиране на numpy като np импортиране на ос разпознавател = cv2.face. LBPHFaceRecognizer_create () разпознавател.read ('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # имена, свързани с идентификатори: example ==> Marcelo: id = 1, etc names = ['None', 'Marcelo', 'Paula', 'Ilza', 'Z ',' W '] # Инициализирайте и стартирайте камера за заснемане на видео в реално време = cv2. VideoCapture (0) cam.set (3, 640) # задайте видео widht cam.set (4, 480) # задайте височина на видеото # Определете минималния размер на прозореца да бъде разпознат като лице minW = 0,1*cam.get (3) minH = 0,1*cam.get (4) докато True: ret, img = cam.read () img = cv2.flip (img, -1) # Обърнете вертикално сиво = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) лица = faceCascade.detectMultiScale (сиво, scaleFactor = 1.2, minNeighbors = 5, minSize = (int (minW), int (minH)),) за (x, y, w, h) в лица: cv2.rectangle (img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, доверие = разпознаващ. predict (grey [y: y+h, x: x+w]) # Проверете дали доверието е по -малко от тях 100 ==> "0" е перфектно съвпадение, ако (доверие <100): id = names [id] trust = "{0}% ".format (кръг (100 - доверие)) else: id =" неизвестно "доверие =" {0}%". формат (кръг (100 - конфи idence)) cv2.putText (img, str (id), (x+5, y-5), font, 1, (255, 255, 255), 2) cv2.putText (img, str (доверие), (x+5, y+h-5), шрифт, 1, (255, 255, 0), 1) cv2.imshow ('камера', img) k = cv2.waitKey (10) & 0xff # Натиснете 'ESC' за излизане от видеоклип, ако k == 27: break # Направете малко почистващо отпечатване ("\ n [INFO] Излизане от програмата и почистващи неща") cam.release () cv2.destroyAllWindows ()

Тук включваме нов масив, така че ще показваме „имена“, вместо номерирани идентификатори:

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

Така например: Marcelo ще потребителят с id = 1; Паула: id = 2 и т.н.

След това ще открием лице, както направихме преди с класификатора haasCascade. Като имаме открито лице, можем да извикаме най -важната функция в горния код:

идентификатор, увереност = разпознаващ.предсказване (сива част на лицето)

Разпознавателят.predict (), ще вземе като параметър заснетата част от лицето, което ще се анализира, и ще върне вероятния си собственик, като посочи неговия идентификатор и колко доверие разпознаващият е във връзка с това съвпадение.

Обърнете внимание, че индексът на доверие ще върне "нула", ако се съчетае перфектно

И накрая, ако разпознаващият може да предвиди лице, ние поставяме текст върху изображението с вероятния идентификатор и колко е "вероятността" в %, че съвпадението е правилно ("вероятност" = 100 - индекс на доверие). Ако не, върху лицето се поставя етикет „неизвестен“.

Под-g.webp

На горната снимка показвам някои тестове, направени с този проект, където също съм използвал снимки, за да проверя дали разпознавателят работи.

Стъпка 8: Заключение

Както винаги, надявам се този проект да помогне на другите да намерят своя път във вълнуващия свят на електрониката!

За подробности и окончателен код, моля, посетете моя депозитар на GitHub: OpenCV-Face-Recognition

За повече проекти, моля, посетете моя блог: MJRoBot.org

По -долу бегъл поглед към бъдещ урок, където ще изследваме „автоматичното проследяване на лицето и други методи за разпознаване на лица“:

Поздрави от юга на света!

Ще се видим в следващата ми инструкция!

Благодаря ти, Марсело