რეალურ დროში სახის ამოცნობა: ბოლომდე დასრულებული პროექტი: 8 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:20

ჩემს ბოლო გაკვეთილზე, რომელიც შეისწავლის OpenCV- ს, ჩვენ ვისწავლეთ AUTOMATIC VISION OBJECT TRACKING. ახლა ჩვენ გამოვიყენებთ ჩვენს PiCam– ს, რათა ამოვიცნოთ სახეები რეალურ დროში, როგორც ქვემოთ ხედავთ:

ეს პროექტი გაკეთდა ამ ფანტასტიკური "ღია კოდის კომპიუტერული ხედვის ბიბლიოთეკით", OpenCV. ამ გაკვეთილზე ჩვენ ყურადღებას გავამახვილებთ Raspberry Pi (ასე რომ, Raspbian როგორც OS) და Python, მაგრამ მე ასევე გამოვცადე კოდი ჩემს Mac– ზე და ის ასევე კარგად მუშაობს. OpenCV შეიქმნა გამოთვლითი ეფექტურობისთვის და დიდი ყურადღება გამახვილდა რეალურ დროში პროგრამებზე. ასე რომ, ეს სრულყოფილია რეალურ დროში სახის ამოცნობისთვის კამერის გამოყენებით.

სახის ამოცნობის სრული პროექტის შესაქმნელად, ჩვენ უნდა ვიმუშაოთ 3 ძალიან მკაფიო ფაზაზე:

1. სახის გამოვლენა და მონაცემთა შეგროვება
2. გაწვრთნე აღიარებელი
3. Სახის ამოცნობა

ქვემოთ მოყვანილი ბლოკ -დიაგრამა განაგრძობს იმ ფაზებს:

ნაბიჯი 1: BoM - Bill of Material

ძირითადი ნაწილები:

1. ჟოლო Pi V3 - 32,00 აშშ დოლარი
2. 5 მეგაპიქსელიანი 1080p სენსორი OV5647 მინი კამერის ვიდეო მოდული - 13,00 აშშ დოლარი

ნაბიჯი 2: დააინსტალირეთ OpenCV 3 პაკეტი

მე ვიყენებ Raspberry Pi V3- ს, რომელიც განახლებულია Raspbian (Stretch) - ის ბოლო ვერსიით, ამიტომ OpenCV დაყენების საუკეთესო საშუალებაა დაიცვას ადრიან როზებროკის მიერ შემუშავებული შესანიშნავი სახელმძღვანელო: Raspbian Stretch: დააინსტალირეთ OpenCV 3 + Python თქვენს Raspberry Pi– ზე რა

მე შევეცადე რამდენიმე განსხვავებული სახელმძღვანელო, რომ დამეყენებინა OpenCV ჩემს Pi- ზე. ადრიანის გაკვეთილი საუკეთესოა. მე გირჩევთ იგივე გააკეთოთ, დაიცავით მისი სახელმძღვანელო ეტაპობრივად.

ადრიანის გაკვეთილის დასრულების შემდეგ, თქვენ უნდა გქონდეთ OpenCV ვირტუალური გარემო, რომელიც მზად იქნება თქვენი Pi– ზე ჩვენი ექსპერიმენტების გასაშვებად.

მოდით გადავიდეთ ჩვენს ვირტუალურ გარემოში და დავადასტუროთ, რომ OpenCV 3 სწორად არის დაინსტალირებული.

ადრიანი გირჩევთ გაუშვათ ბრძანება "წყარო" ყოველ ჯერზე, როდესაც გახსნით ახალ ტერმინალს, რათა დარწმუნდეთ, რომ თქვენი სისტემის ცვლადები სწორად არის დაყენებული.

წყარო ~/.პროფილი

შემდეგი, მოდით შევიდეთ ჩვენს ვირტუალურ გარემოში:

სამუშაო cv

თუ ხედავთ ტექსტს (cv) თქვენს მოთხოვნაზე წინ, მაშინ ხართ cv ვირტუალურ გარემოში:

(cv) pi@ჟოლო: ~ $ადრიანი ყურადღებას ამახვილებს იმაზე, რომ cv პითონის ვირტუალური გარემო არის სრულიად დამოუკიდებელი და დაცულია ნაგულისხმევი პითონის ვერსიიდან, რომელიც შედის Raspbian Stretch– ის გადმოწერაში. ამრიგად, გლობალური საიტების პაკეტების კატალოგში ნებისმიერი პითონის პაკეტი არ იქნება ხელმისაწვდომი cv ვირტუალური გარემოსთვის. ანალოგიურად, cv საიტის პაკეტებში დაინსტალირებული პითონის ნებისმიერი პაკეტი არ იქნება ხელმისაწვდომი პითონის გლობალური ინსტალაციისთვის

ახლა შეიყვანეთ თქვენი პითონის თარჯიმანი:

პითონი

და დაადასტურეთ, რომ თქვენ იყენებთ 3.5 (ან ზემოთ) ვერსიას

თარჯიმნის შიგნით (გამოჩნდება ">>>"), შემოიტანეთ OpenCV ბიბლიოთეკა:

იმპორტი cv2

თუ შეცდომის შეტყობინებები არ გამოჩნდება, OpenCV სწორად არის დაინსტალირებული თქვენს პიტონის ვირტუალურ გარემოზე.

თქვენ ასევე შეგიძლიათ შეამოწმოთ დაინსტალირებული OpenCV ვერსია:

cv2._ ვერსია_

3.3.0 უნდა გამოჩნდეს (ან უმაღლესი ვერსია, რომელიც შეიძლება გამოქვეყნდეს მომავალში). ზემოთ მოყვანილი ტერმინალური PrintScreen აჩვენებს წინა ნაბიჯებს.

ნაბიჯი 3: თქვენი კამერის ტესტირება

მას შემდეგ რაც დაინსტალირებთ OpenCV თქვენს RPi– ში, მოდით შევამოწმოთ, რომ დაადასტუროთ რომ თქვენი კამერა მუშაობს გამართულად.

მე ვვარაუდობ, რომ თქვენ გაქვთ PiCam უკვე დაინსტალირებული თქვენს Raspberry Pi– ზე.

შეიყვანეთ პითონის კოდი თქვენს IDE– ში:

იმპორტირებული numpy როგორც np

იმპორტი cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # კომპლექტი სიგანე cap.set (4, 480) # კომპლექტი სიმაღლე ხოლო (ჭეშმარიტი): ret, frame = cap.read () frame = cv2. გადაბრუნება (ჩარჩო, -1) # გადატრიალება კამერა ვერტიკალურად ნაცრისფერი = cv2.cvtColor (ჩარჩო, cv2. COLOR_BGR2GRAY) cv2.imshow ("ჩარჩო", ჩარჩო) cv2.imshow ("ნაცრისფერი", ნაცრისფერი) k = cv2.waitKey (30) & 0xff თუ k == 27: # დააჭირეთ 'ESC', რომ დატოვოთ break cap.release () cv2.destroyAllWindows ()

ზემოთ მოყვანილი კოდი გადაიღებს ვიდეო ნაკადს, რომელიც გენერირდება თქვენი PiCam– ით და აჩვენებს ორივე, BGR ფერში და ნაცრისფერ რეჟიმში.

გაითვალისწინეთ, რომ მე გადავატრიალე ჩემი კამერა ვერტიკალურად მისი აწყობის გამო. თუ ეს არ არის თქვენი საქმე, დატოვეთ კომენტარი ან წაშალეთ "გადატრიალების" ბრძანების ხაზი.

ალტერნატიულად შეგიძლიათ ჩამოტვირთოთ კოდი ჩემი GitHub– დან: simpleCamTest.py

შესასრულებლად შეიყვანეთ ბრძანება:

პითონი simpleCamTest.py

პროგრამის დასასრულებლად, თქვენ უნდა დააჭიროთ ღილაკს [ESC] თქვენს კლავიატურაზე.

დააწკაპუნეთ მაუსზე ვიდეო ფანჯარაზე, სანამ დააჭირეთ [ESC]

ზემოთ ნაჩვენები შედეგი აჩვენებს.

ზოგიერთმა შემქმნელმა აღმოაჩინა პრობლემები კამერის გახსნის მცდელობისას ("მტკიცება ვერ მოხერხდა" შეცდომის შეტყობინებები). ეს შეიძლება მოხდეს, თუ კამერა არ არის ჩართული OpenCv ინსტალაციის დროს და ასე რომ, კამერის დრაივერები არ არის დაინსტალირებული სწორად. გამოსასწორებლად გამოიყენეთ ბრძანება:

sudo modprobe bcm2835-v4l2

თქვენ ასევე შეგიძლიათ დაამატოთ bcm2835-v4l2 ბოლოში /etc /მოდულების ფაილი, რათა მძღოლი ჩატვირთოს ჩატვირთვისას.

OpenCV– ს შესახებ მეტი რომ იცოდეთ, შეგიძლიათ გაეცნოთ გაკვეთილს: loading -video-python-opencv-tutorial

ნაბიჯი 4: სახის ამოცნობა

სახის ამოცნობის ყველაზე ძირითადი ამოცანაა, რა თქმა უნდა, "სახის ამოცნობა". ყველაფრის წინ, თქვენ უნდა "დაიჭიროთ" სახე (ფაზა 1), რათა აღიაროთ იგი, როდესაც შევადარებთ მომავალში ახალ სახეს (ფაზა 3).

სახის (ან რაიმე საგნის) გამოვლენის ყველაზე გავრცელებული გზა არის "ჰაარის კასკადის კლასიფიკატორის" გამოყენება.

ობიექტის გამოვლენა ჰაარის ფუნქციაზე დაფუძნებული კასკადის კლასიფიკატორების გამოყენებით არის ობიექტების გამოვლენის ეფექტური მეთოდი, რომელიც შემოთავაზებულია პოლ ვიოლას და მაიკლ ჯონსის მიერ ნაშრომში "სწრაფი ობიექტების გამოვლენა მარტივი მახასიათებლების გაძლიერებული კასკადის გამოყენებით" 2001 წელს. ეს არის მანქანათმცოდნეობის მიდგომა, სადაც კასკადის ფუნქცია გაწვრთნილია ბევრი დადებითი და უარყოფითი სურათისგან. შემდეგ იგი გამოიყენება სხვა გამოსახულებებში საგნების აღმოსაჩენად.

აქ ჩვენ ვიმუშავებთ სახის ამოცნობაზე. თავდაპირველად, ალგორითმს სჭირდება ბევრი დადებითი სურათი (სახეების გამოსახულებები) და უარყოფითი სურათები (სურათები სახის გარეშე) კლასიფიკატორის მოსამზადებლად. შემდეგ ჩვენ უნდა ამოვიღოთ მისგან მახასიათებლები. კარგი ამბავი ის არის, რომ OpenCV– ს მოყვება ტრენერი და დეტექტორი. თუ გსურთ საკუთარი კლასიფიკატორის მომზადება ნებისმიერი ობიექტისთვის, როგორიცაა მანქანა, თვითმფრინავები და ა.შ., შეგიძლიათ გამოიყენოთ OpenCV, რომ შექმნათ იგი. მისი სრული დეტალები მოცემულია აქ: კასკადის კლასიფიკატორთა სწავლება.

თუ არ გსურთ შექმნათ თქვენი კლასიფიკატორი, OpenCV უკვე შეიცავს ბევრ წინასწარ მომზადებულ კლასიფიკატორს სახის, თვალების, ღიმილის და ა.შ. იმ XML ფაილების ჩამოტვირთვა შესაძლებელია haarcascades დირექტორიიდან.

საკმარისია თეორია, მოდით შევქმნათ სახის დეტექტორი OpenCV– ით!

ჩამოტვირთეთ ფაილი: faceDetection.py ჩემი GitHub– დან.

იმპორტირებული numpy როგორც np

იმპორტი cv2 faceCascade = cv2. CascadeClassifier ('Cascades/haarcascade_frontalface_default.xml') cap = cv2. VideoCapture (0) cap.set (3, 640) # კომპლექტი Width cap.set (4, 480) # კომპლექტი სიმაღლე ხოლო ჭეშმარიტი: ret, img = cap.read () img = cv2.flip (img, -1) ნაცრისფერი = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) სახეები = faceCascade.detectMultiScale (ნაცრისფერი, scaleFactor = 1.2, წთ მეზობლები = 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', რომ დატოვოთ break cap.release () cv2.destroyAllWindows ()

გინდ დაიჯერეთ, გინდ არა, კოდის რამოდენიმე ხაზი არის ის, რაც გჭირდებათ სახის დასადგენად, პითონისა და OpenCV– ს გამოყენებით.

როდესაც შეადარებთ კამერის შესამოწმებლად გამოყენებულ ბოლო კოდს, მიხვდებით, რომ მას რამდენიმე ნაწილი დაემატა. გაითვალისწინეთ ქვემოთ მოცემული ხაზი:

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

ეს არის ხაზი, რომელიც იტვირთება "კლასიფიკატორი" (ის უნდა იყოს დირექტორიაში სახელწოდებით "კასკადები/", თქვენი პროექტის დირექტორიის ქვეშ).

შემდეგ, ჩვენ დავაყენებთ ჩვენს კამერას და მარყუჟის შიგნით, ჩავტვირთავთ ჩვენს შეყვანის ვიდეოს ნაცრისფერი მასშტაბის რეჟიმში (იგივე, რაც ადრე ვნახეთ).

ახლა ჩვენ უნდა გამოვიძახოთ ჩვენი კლასიფიკატორის ფუნქცია და გავავლოთ მას რამდენიმე ძალიან მნიშვნელოვანი პარამეტრი, როგორც მასშტაბის ფაქტორი, მეზობლების რაოდენობა და გამოვლენილი სახის მინიმალური ზომა.

სახეები = faceCascade.detectMultiScale (ნაცრისფერი, scaleFactor = 1.2, წთ მეზობლები = 5, წთ ზომა = (20, 20))

სად,

• ნაცრისფერი არის ნაცრისფერი მასშტაბის შეყვანის სურათი.
• scaleFactor არის პარამეტრი, რომელიც განსაზღვრავს რამდენად მცირდება გამოსახულების ზომა თითოეული გამოსახულების მასშტაბზე. იგი გამოიყენება მასშტაბის პირამიდის შესაქმნელად.
• minNeighbours არის პარამეტრი, რომელიც განსაზღვრავს რამდენი მეზობელი უნდა ჰყავდეს თითოეულ კანდიდატს ოთხკუთხედს, რომ შეინარჩუნოს იგი. უფრო მაღალი რიცხვი იძლევა ქვედა ცრუ დადებითს.
• minSize არის მართკუთხედის მინიმალური ზომა, რომელიც უნდა ჩაითვალოს სახედ.

ფუნქცია გამოავლენს სახეებს სურათზე. შემდეგი, ჩვენ უნდა "მონიშნოთ" სახეები სურათზე, მაგალითად, ლურჯი ოთხკუთხედის გამოყენებით. ეს კეთდება კოდის ამ ნაწილის გამოყენებით:

for (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]

თუ სახეები მოიძებნება, ის აბრუნებს აღმოჩენილი სახეების პოზიციებს მართკუთხედის სახით მარცხენა ზემოთ კუთხეში (x, y) და აქვს "w" მისი სიგანე და "h" როგორც სიმაღლე ==> (x, y, w, თ) გთხოვთ იხილოთ ზემოთ მოცემული სურათი.

მას შემდეგ რაც მივიღებთ ამ ადგილებს, ჩვენ შეგვიძლია შევქმნათ "ROI" (დახაზული ოთხკუთხედი) სახისთვის და შედეგი წარმოვადგინოთ imshow () ფუნქციით.

გაუშვით ზემოთ პითონის სკრიპტი თქვენს პითონის გარემოზე, Rpi ტერმინალის გამოყენებით:

პითონის faceDetection.py

Შედეგი:

თქვენ ასევე შეგიძლიათ ჩართოთ კლასიფიკატორები "თვალების გამოვლენის" ან თუნდაც "ღიმილის გამოვლენისთვის". ამ შემთხვევებში თქვენ შეიტანთ კლასიფიკატორის ფუნქციას და ოთხკუთხედის დახაზვას სახის მარყუჟში, რადგან აზრი არ ექნება თვალის ან ღიმილის გამოვლენას სახის გარეთ.

გაითვალისწინეთ, რომ Pi– ზე, რამდენიმე კლასიფიკატორის ერთ კოდში დამუშავება შენელდება, მას შემდეგ რაც გამოვლენის ეს მეთოდი (HaarCascades) გამოიყენებს გამოთვლილ ძალას. დესკტოპზე მისი გაშვება უფრო ადვილია.

ჩემს GitHub– ზე ნახავთ სხვა მაგალითებს:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

და ზემოთ სურათზე, თქვენ ხედავთ შედეგს.

თქვენ ასევე შეგიძლიათ მიყევით ქვემოთ მოცემულ გაკვეთილს, რათა უკეთ გაიგოთ სახის ამოცნობა:

ჰაარის კასკადის ობიექტის ამოცნობის სახე და თვალი OpenCV პითონის სამეურვეო პროგრამა

ნაბიჯი 5: მონაცემთა შეგროვება

უპირველეს ყოვლისა, უნდა მადლობა გადავუხადო რამიზ რაჯას მისი შესანიშნავი მუშაობისათვის სახის ამოცნობაზე ფოტოებზე:

სახის ამოცნობა OPENCV და PYTHON- ის გამოყენებით: დამწყების სახელმძღვანელო

და ასევე Anirban Kar, რომელმაც შეიმუშავა ძალიან ყოვლისმომცველი გაკვეთილი ვიდეოს გამოყენებით:

სახის ამოცნობა - 3 ნაწილი

მე ნამდვილად გირჩევთ, რომ გადახედოთ ორივე გაკვეთილს.

რომ ვთქვათ, დავიწყოთ ჩვენი პროექტის პირველი ეტაპი. რასაც ჩვენ გავაკეთებთ აქ, იწყება ბოლო საფეხურიდან (სახის ამოცნობა), ჩვენ უბრალოდ შევქმნით მონაცემთა ნაკრებს, სადაც შევინახავთ თითოეული პირადობის მოწმობის ნაცრისფერი ფოტოების ჯგუფს იმ ნაწილისთვის, რომელიც გამოიყენებოდა სახის გამოვლენისთვის.

პირველი, შექმენით დირექტორია, სადაც შეიმუშავებთ თქვენს პროექტს, მაგალითად, FacialRecognitionProject:

mkdir სახის ამოცნობა პროექტი

ამ დირექტორიაში, პითონის 3 სკრიპტის გარდა, რომელსაც ჩვენ შევქმნით ჩვენი პროექტისთვის, ჩვენ უნდა შევინახოთ სახის კლასიფიკატორი. შეგიძლიათ გადმოწეროთ ჩემი GitHub– დან: haarcascade_frontalface_default.xml

შემდეგი, შექმენით ქვე დირექტორია, სადაც ჩვენ ვინახავთ ჩვენი სახის ნიმუშებს და დავარქვით მას "მონაცემთა ნაკრები":

mkdir მონაცემთა ნაკრები

და გადმოწერეთ კოდი ჩემი GitHub– დან: 01_face_dataset.py

იმპორტი cv2

იმპორტი os cam = cv2. VideoCapture (0) cam.set (3, 640) # დააყენეთ ვიდეო სიგანე cam.set (4, 480) # დააყენეთ ვიდეოს სიმაღლე face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # თითოეული ადამიანისთვის, შეიყვანეთ ერთი რიცხვითი სახის პიგმენტი face_id = შეყვანა ('\ n შეიყვანეთ მომხმარებლის იდენტიფიკატორი პრეს ==>') ბეჭდვა ("\ n [ინფორმაცია] სახის გადაღების ინიციალიზება. შეხედეთ კამერას და დაელოდეთ …") # ინდივიდუალური შერჩევის ინიციალიზაცია = 0 ხოლო (ჭეშმარიტი): 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. მართკუთხედი (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 სახის ნიმუში და შეაჩერეთ ვიდეო შესვენება # Do ab ეს არის გასუფთავების ბეჭდვა ("\ n [INFO] Exiting Program and Cleanup stuff") cam.release () cv2.destroyAllWindows ()

კოდი ძალიან ჰგავს კოდს, რომელიც ჩვენ ვნახეთ სახის ამოცნობისთვის. რაც ჩვენ დავამატეთ, იყო "შეყვანის ბრძანება" მომხმარებლის პირადობის დამადასტურებლად, რომელიც უნდა იყოს მთელი რიცხვი (1, 2, 3 და ა.შ.)

face_id = შეყვანა ('\ n შეიყვანეთ მომხმარებლის ID ბოლოს დააჭირეთ ==>')

და თითოეული გადაღებული ჩარჩოსთვის, ჩვენ უნდა შევინახოთ იგი როგორც ფაილი "მონაცემთა ნაკრების" დირექტორიაში:

cv2.imwrite ("მონაცემთა ნაკრები/მომხმარებელი." + str (face_id) + '.' + str (რაოდენობა) + ". jpg", ნაცრისფერი [y: y + h, x: x + w])

გაითვალისწინეთ, რომ ზემოაღნიშნული ფაილის შესანახად, თქვენ უნდა შემოიტანოთ ბიბლიოთეკა "os". თითოეული ფაილის სახელი მიჰყვება სტრუქტურას:

User.face_id.count.jpg

მაგალითად, მომხმარებლისთვის face_id = 1, მონაცემთა ნაკრების/ დირექტორიის მე -4 ნიმუში ფაილი იქნება მსგავსი:

User.1.4.jpg

როგორც ნაჩვენებია ზემოთ მოცემულ ფოტოში ჩემი პი. ჩემს კოდზე მე ვიღებ 30 ნიმუშს თითოეული პირადობის მოწმობიდან. თქვენ შეგიძლიათ შეცვალოთ იგი ბოლო "ელიფზე". ნიმუშების რაოდენობა გამოიყენება მარყუჟის შესამცირებლად, სადაც აღებულია სახის ნიმუშები.

გაუშვით პითონის სკრიპტი და გადაიღეთ რამდენიმე ID. თქვენ უნდა გაუშვათ სკრიპტი ყოველ ჯერზე, როდესაც გსურთ ახალი მომხმარებლის გაერთიანება (ან შეცვალოთ უკვე არსებული ფოტოები).

ნაბიჯი 6: ტრენერი

ამ მეორე ფაზაზე, ჩვენ უნდა ავიღოთ მომხმარებლის ყველა მონაცემი ჩვენი მონაცემთა ნაკრებიდან და "მოვამზადოთ" OpenCV Recognizer. ეს კეთდება პირდაპირ კონკრეტული OpenCV ფუნქციით. შედეგი იქნება.yml ფაილი, რომელიც შეინახება "ტრენერი/" დირექტორიაში.

მოდით, დავიწყოთ ქვე დირექტორიის შექმნა, სადაც შევინახავთ გაწვრთნილ მონაცემებს:

mkdir ტრენერი

ჩამოტვირთეთ ჩემი GitHub– დან მეორე პითონის სკრიპტი: 02_face_training.py

იმპორტი cv2

იმპორტის numpy როგორც np PIL– დან იმპორტის სურათი იმპორტი os # გზა სახის გამოსახულების მონაცემთა ბაზისთვის ბილიკი = 'მონაცემთა ნაკრები' ცნობა = cv2.face. LBPHFaceRecognizer_create () დეტექტორი = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # ფუნქცია სურათებისა და ეტიკეტის მონაცემების მისაღებად defIImagesAndLabels (გზა): imagePaths = [os.path.join (path, f) for f in os.listdir (path)] faceSamples = ids = imagePath in imagePaths: PIL_img = Image.open (imagePath).convert ('L') # გადააკეთეთ ნაცრისფერში img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. გაყოფა (".") [1]) სახეები = დეტექტორი. detectMultiScale (img_numpy) for (x, y, w, h) in სახეები: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Training სახეები. დასჭირდება რამდენიმე წამი. დაელოდეთ …") სახეები, ids = getImagesAndLabels (გეზი) ამოცნობა.ტრენაჟი (სახეები, np.array (ID)) # შეინახეთ მოდელი ტრენერ/ტრენერში. ("\ n [ინფორმაცია] {0} გაწვრთნილი სახეები. პროგრამიდან გასვლა". ფორმატი (len (np.unique (ids))))

დაადასტურეთ გაქვთ თუ არა PIL ბიბლიოთეკა დაინსტალირებული თქვენს Rpi– ზე. თუ არა, გაუშვით ქვემოთ მოცემული ბრძანება ტერმინალში:

პიპის დაყენების ბალიში

ჩვენ ვიყენებთ როგორც აღიარებას, LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) Face Recognizer, რომელიც შედის OpenCV პაკეტში. ჩვენ ამას ვაკეთებთ შემდეგ სტრიქონში:

აღიარებელი = cv2.face. LBPHFaceRecognizer_create ()

ფუნქცია "getImagesAndLabels (გზა)", გადაიღებს ყველა ფოტოს დირექტორიაში: "dataset/", დააბრუნებს 2 მასივს: "Ids" და "სახეები". იმ მასივებით, როგორც შეყვანა, ჩვენ "მოვამზადებთ ჩვენს აღიარებას":

ამოცნობა. მატარებელი (სახეები, ID)

შედეგად, ფაილი სახელწოდებით "trainer.yml" შეინახება ტრენერების დირექტორიაში, რომელიც ადრე შეიქმნა ჩვენს მიერ.

Ის არის! მე ჩავრთე ბოლო ამობეჭდილი განცხადება, სადაც მე ვაჩვენე დადასტურების მიზნით, ჩვენ მიერ გაწვრთნილი მომხმარებლის სახეების რაოდენობა.

ყოველ ჯერზე, როდესაც ასრულებთ 1 ფაზას, მეორე ფაზაც ასევე უნდა ჩატარდეს

ნაბიჯი 7: ამოცნობა

ახლა ჩვენ მივედით ჩვენი პროექტის დასკვნით ფაზაზე. აქ, ჩვენ გადავიღებთ ახალ სახეს ჩვენს კამერაზე და თუ ამ ადამიანს მისი სახე ადრე ჰქონდა დაკავებული და გაწვრთნილი, ჩვენი ამოცნობის შემსრულებელი გააკეთებს "პროგნოზს", რომელიც დააბრუნებს თავის პირადობას და ინდექსს, რომელიც აჩვენებს რამდენად დარწმუნებულია ამ მატჩში ცნობადი პირი.

მოდით გადმოწეროთ მე –3 ფაზის პითონის სკრიპტი ჩემი GitHub– დან: 03_face_recognition.py.

იმპორტი cv2

იმპორტი numpy როგორც np იმპორტი os აღიარებელი = cv2.face. LBPHFaceRecognizer_create () cognizer.read ('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # სახელები, რომლებიც დაკავშირებულია id- თან: მაგალითი ==> მარსელო: id = 1 და ა.შ. სახელები = ['არცერთი', 'მარსელო', 'პაულა', 'ილზა', 'Z ',' W '] # ინიციალიზაცია და რეალურ დროში ვიდეო გადაღების კამერის დაწყება = cv2. VideoCapture (0) cam.set (3, 640) # set video widht cam.set (4, 480) # set video height # min min window window აღიარებული იყოს როგორც სახე 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. მართკუთხედი (img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, ნდობა = ცნობადი. წინასწარმეტყველება (ნაცრისფერი [y: y+h, x: x+w]) # შეამოწმეთ არის თუ არა თავდაჯერებულობა 100 ==> "0" იდეალურია თუ (ნდობა <100): id = სახელები [id] ნდობა = "{0}% ".format (რაუნდი (100 - ნდობა)) სხვა: id =" უცნობი "trust =" {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: შესვენება # გააკეთეთ ცოტაოდენი გასუფთავების ბეჭდვა ("\ n [INFO] პროგრამის გასვლა და გასუფთავება") cam.release () cv2.destroyAllWindows ()

ჩვენ აქ ჩავრთავთ ახალ მასივს, ასე რომ, ჩვენ გამოვყოფთ "სახელებს", დანომრილი ნომრების ნაცვლად:

სახელები = ['არცერთი', 'მარსელო', 'პაულა', 'ილზა', 'Z', 'W']

ასე, მაგალითად: მარსელო მომხმარებელს id = 1; პაულა: id = 2 და ა.

შემდეგი, ჩვენ გამოვავლენთ სახეს, იგივე რაც ადრე გავაკეთეთ haasCascade კლასიფიკატორთან. გამოვლენილი სახის მქონე ჩვენ შეგვიძლია დავარქვათ ყველაზე მნიშვნელოვანი ფუნქცია ზემოხსენებულ კოდში:

id, ნდობა = ამოცნობა. წინასწარმეტყველება (სახის ნაცრისფერი ნაწილი)

აღიარებელი.წინასწარმეტყველება (), როგორც პარამეტრი მიიღებს გასაანალიზებელ სახის დაკავებულ ნაწილს და დაუბრუნებს მის სავარაუდო მფლობელს, მიუთითებს მის პირადობას და რამდენად დარწმუნებულია აღიარებული ამ მატჩთან მიმართებაში.

გაითვალისწინეთ, რომ ნდობის ინდექსი დაუბრუნდება "ნულს", თუ იგი იდეალური შესატყვისი იქნება

და ბოლოს, თუ აღიარებელს შეეძლო სახის პროგნოზირება, ჩვენ სურათს დავდებთ ტექსტს სავარაუდო id- ით და რამდენად არის % "ალბათობა", რომ შესატყვისი სწორია ("ალბათობა" = 100 - ნდობის ინდექსი). თუ არა, სახეზე ედება "შეუცნობელი" იარლიყი.

ქვემოთ-g.webp

ზემოთ მოცემულ სურათზე მე ვაჩვენებ ამ პროექტზე გაკეთებულ რამდენიმე ტესტს, სადაც ასევე გამოვიყენე ფოტოები იმის დასადასტურებლად, მუშაობს თუ არა ამოცნობადი.

ნაბიჯი 8: დასკვნა

როგორც ყოველთვის, ვიმედოვნებ, რომ ეს პროექტი სხვებს დაეხმარება იპოვონ გზა ელექტრონიკის ამაღელვებელ სამყაროში!

დეტალებისა და საბოლოო კოდისათვის ეწვიეთ ჩემს GitHub საცავს: OpenCV-Face-Recognition

მეტი პროექტისთვის ეწვიეთ ჩემს ბლოგს: MJRoBot.org

ქვემოთ მოცემულია მომავალი გაკვეთილი, სადაც ჩვენ შევისწავლით "სახის ავტომატურ თვალყურს და სახის გამოვლენის სხვა მეთოდებს":

სალუდო მსოფლიოს სამხრეთიდან!

შევხვდებით ჩემს შემდეგ ინსტრუქტაჟში!

Გმადლობთ, მარსელო