Gerçek Zamanlı Yüz Tanıma: Uçtan Uca Bir Proje: 8 Adım (Resimlerle)

2024 Yazar: John Day | [email protected]. Son düzenleme: 2024-01-30 13:20

OpenCV'yi keşfeden son dersimde OTOMATİK GÖRÜŞ NESNE İZLEME'yi öğrendik. Şimdi, aşağıda görebileceğiniz gibi, yüzleri gerçek zamanlı olarak tanımak için PiCam'imizi kullanacağız:

Bu proje, bu harika "Açık Kaynak Bilgisayar Görme Kitaplığı", OpenCV ile yapıldı. Bu derste, Raspberry Pi (yani, OS olarak Raspbian) ve Python'a odaklanacağız, ancak kodu Mac'imde de test ettim ve aynı zamanda iyi çalışıyor. OpenCV, hesaplama verimliliği için ve gerçek zamanlı uygulamalara güçlü bir şekilde odaklanarak tasarlanmıştır. Bu nedenle, bir kamera kullanarak gerçek zamanlı yüz tanıma için mükemmeldir.

Yüz Tanıma konusunda eksiksiz bir proje oluşturmak için birbirinden çok farklı 3 aşamada çalışmalıyız:

1. Yüz Algılama ve Veri Toplama
2. Tanıyıcıyı Eğitin
3. Yüz tanıma

Aşağıdaki blok diyagram, bu aşamaları sürdürür:

Adım 1: Malzeme Listesi - Malzeme Listesi

Ana parçalar:

1. Ahududu Pi V3 - 32,00 ABD Doları
2. 5 Megapiksel 1080p Sensör OV5647 Mini Kamera Video Modülü - US$ 13.00

Adım 2: OpenCV 3 Paketinin Kurulması

Raspbian'ın (Stretch) son sürümüne güncellenmiş bir Raspberry Pi V3 kullanıyorum, bu nedenle OpenCV'yi kurmanın en iyi yolu Adrian Rosebrock tarafından geliştirilen mükemmel öğreticiyi takip etmektir: Raspbian Stretch: OpenCV 3 + Python'u Raspberry Pi'nize yükleyin.

Pi'me OpenCV yüklemek için birkaç farklı kılavuz denedim. Adrian'ın öğreticisi en iyisidir. Adım adım kılavuzunu izleyerek aynısını yapmanızı tavsiye ederim.

Adrian'ın eğitimini bitirdikten sonra, deneylerimizi Pi'nizde çalıştırmaya hazır bir OpenCV sanal ortamınız olmalıdır.

Sanal ortamımıza gidelim ve OpenCV 3'ün doğru kurulduğunu onaylayalım.

Adrian, sistem değişkenlerinizin doğru şekilde ayarlandığından emin olmak için her yeni terminal açtığınızda "kaynak" komutunu çalıştırmanızı önerir.

kaynak ~/.profile

Ardından sanal ortamımıza girelim:

çalışma özgeçmişi

İsteminizden önce metni (cv) görüyorsanız, cv sanal ortamındasınız demektir:

(cv) pi@ahududu:~$Adrian, cv Python sanal ortamının tamamen bağımsız olduğuna ve Raspbian Stretch'in indirilmesinde bulunan varsayılan Python sürümünden ayrı olduğuna dikkat çekiyor. Bu nedenle, global site paketleri dizinindeki herhangi bir Python paketi, cv sanal ortamında kullanılamaz. Benzer şekilde, cv'nin site paketlerine yüklenen herhangi bir Python paketi, Python'un genel kurulumunda kullanılamayacaktır.

Şimdi Python yorumlayıcınıza girin:

piton

ve 3.5 (veya üzeri) sürümünü çalıştırdığınızı onaylayın

Yorumlayıcının içinde (">>>" görünecektir), OpenCV kitaplığını içe aktarın:

cv2'yi içe aktar

Herhangi bir hata mesajı görüntülenmezse, OpenCV, PYTHON SANAL ORTAMINIZA doğru şekilde yüklenmiştir.

Yüklü OpenCV sürümünü de kontrol edebilirsiniz:

cv2._versiyon_

3.3.0 (veya gelecekte piyasaya sürülebilecek daha üstün bir sürüm) görünmelidir. Yukarıdaki Terminal PrintScreen önceki adımları gösterir.

3. Adım: Kameranızı Test Etme

RPi'nize OpenCV yükledikten sonra, kameranızın düzgün çalıştığını doğrulamak için test edelim.

Raspberry Pi'nizde zaten kurulu bir PiCam'iniz olduğunu varsayıyorum.

IDE'nize aşağıdaki Python kodunu girin:

numpy'yi np olarak içe aktar

import cv2 cap = cv2. VideoCapture(0) cap.set(3, 640) # set Genişlik cap.set(4, 480) # set Yükseklik while(True): ret, çerçeve = cap.read() çerçeve = cv2. flip(frame, -1) # Kamerayı dikey olarak çevir gri = cv2.cvtColor(frame, cv2. COLOR_BGR2GRAY) cv2.imshow('frame', frame) cv2.imshow('gri', gri) k = cv2.waitKey(30) & 0xff ise k == 27: # break cap.release()'den çıkmak için 'ESC' tuşuna basın cv2.destroyAllWindows()

Yukarıdaki kod, PiCam'iniz tarafından oluşturulacak video akışını yakalayacak ve hem BGR renginde hem de Gri modunda görüntülenecektir.

Montaj şekli nedeniyle kameramı dikey olarak döndürdüğümü unutmayın. Sizin durumunuz değilse, "çevir" komut satırını yorumlayın veya silin.

Alternatif olarak kodu GitHub'ımdan indirebilirsiniz: simpleCamTest.py

Yürütmek için şu komutu girin:

python simpleCamTest.py

Programı bitirmek için klavyenizden [ESC] tuşuna basmalısınız.

[ESC] tuşuna basmadan önce video penceresinde farenizi tıklayın

Yukarıdaki resim sonucu göstermektedir.

Bazı yapımcılar kamerayı açmaya çalışırken sorunlar buldu ("Onaylama başarısız" hata mesajları). Bu, OpenCv kurulumu sırasında kamera etkinleştirilmemişse ve bu nedenle kamera sürücüleri doğru şekilde kurulmadıysa olabilir. Düzeltmek için şu komutu kullanın:

sudo modprobe bcm2835-v4l2

Sürücünün önyükleme sırasında yüklenmesi için /etc/modules dosyasının son satırına bcm2835-v4l2 de ekleyebilirsiniz.

OpenCV hakkında daha fazla bilgi edinmek için öğreticiyi takip edebilirsiniz: -video-python-opencv-tutorial yükleme

4. Adım: Yüz Algılama

Yüz Tanıma'daki en temel görev elbette "Yüz Algılama"dır. Her şeyden önce, gelecekte yakalanan yeni bir yüzle (Aşama 3) karşılaştırıldığında onu tanımak için bir yüzü (Aşama 1) "yakalamanız" gerekir.

Bir yüzü (veya herhangi bir nesneyi) algılamanın en yaygın yolu "Haar Cascade sınıflandırıcı" kullanmaktır.

Haar öznitelik tabanlı kademeli sınıflandırıcıları kullanan Nesne Algılama, Paul Viola ve Michael Jones tarafından 2001 yılında yayınlanan "Basit Özelliklerin Yükseltilmiş Kademesi Kullanılarak Hızlı Nesne Algılama" adlı makalelerinde önerilen etkili bir nesne algılama yöntemidir. kademeli işlevi, birçok olumlu ve olumsuz görüntüden eğitilmiştir. Daha sonra diğer görüntülerdeki nesneleri algılamak için kullanılır.

Burada yüz tanıma ile çalışacağız. Başlangıçta algoritma, sınıflandırıcıyı eğitmek için çok sayıda pozitif görüntüye (yüz görüntüleri) ve negatif görüntülere (yüzsüz görüntüler) ihtiyaç duyar. O zaman ondan özellikleri çıkarmamız gerekiyor. İyi haber şu ki, OpenCV bir dedektörün yanı sıra bir eğitici ile birlikte geliyor. Araba, uçak vb. herhangi bir nesne için kendi sınıflandırıcınızı eğitmek istiyorsanız, bir tane oluşturmak için OpenCV'yi kullanabilirsiniz. Tüm detayları burada verilmiştir: Basamaklı Sınıflandırıcı Eğitimi.

Kendi sınıflandırıcınızı oluşturmak istemiyorsanız, OpenCV zaten yüz, gözler, gülümseme vb. için önceden eğitilmiş birçok sınıflandırıcı içerir. Bu XML dosyaları haarcascades dizininden indirilebilir.

Yeter teori, hadi OpenCV ile bir yüz dedektörü oluşturalım!

Dosyayı indirin: GitHub'dan faceDetection.py.

numpy'yi np olarak içe aktar

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) gray = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) yüzler = faceCascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20)) yüzlerde (x, y, w, h) için: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = gri[y:y+h, x:x+w] roi_color = img[y:y+h, x:x+w] cv2.imshow('video', img) k = cv2.waitKey(30) & 0xff if k == 27: # break cap.release()'den çıkmak için 'ESC' tuşuna basın cv2.destroyAllWindows()

İster inanın ister inanmayın, Python ve OpenCV kullanarak bir yüzü algılamak için yukarıdaki birkaç satırlık kod yeterlidir.

Kamerayı test etmek için kullanılan son kodla karşılaştırdığınızda, ona birkaç parçanın eklendiğini fark edeceksiniz. Aşağıdaki satıra dikkat edin:

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

Bu, "sınıflandırıcıyı" yükleyen satırdır (bu, proje dizininizin altında "Cascades/" adlı bir dizinde olmalıdır).

Ardından, kameramızı ayarlayacağız ve döngünün içine giriş videomuzu gri tonlama modunda yükleyeceğiz (daha önce gördüğümüz gibi).

Şimdi, ölçek faktörü, komşu sayısı ve tespit edilen yüzün minimum boyutu gibi bazı çok önemli parametreleri geçerek sınıflandırıcı fonksiyonumuzu çağırmalıyız.

yüzler = faceCascade.detectMultiScale(gri, ölçekFaktörü=1,2, minKomşular=5, minSize=(20, 20))

Nereye,

• gri, giriş gri tonlamalı görüntüsüdür.
• scaleFactor, her görüntü ölçeğinde görüntü boyutunun ne kadar küçültüleceğini belirten parametredir. Ölçek piramidini oluşturmak için kullanılır.
• minNeighbors, onu korumak için her aday dikdörtgenin kaç komşusu olması gerektiğini belirten bir parametredir. Daha yüksek bir sayı, daha düşük yanlış pozitifler verir.
• minSize, bir yüz olarak kabul edilecek minimum dikdörtgen boyutudur.

İşlev, görüntüdeki yüzleri algılayacaktır. Ardından, örneğin mavi bir dikdörtgen kullanarak görüntüdeki yüzleri "işaretlemeliyiz". Bu, kodun bu kısmı ile yapılır:

yüzlerde (x, y, w, h) için:

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

Yüzler bulunursa, algılanan yüzlerin konumlarını, sol üst köşesi (x, y) olan ve Genişliği "w" ve Yüksekliği "h" olan bir dikdörtgen olarak döndürür ==> (x, y, w, H). Lütfen yukarıdaki resme bakın.

Bu konumları elde ettikten sonra, yüz için bir "ROI" (çizilmiş dikdörtgen) oluşturabilir ve sonucu imshow() işleviyle sunabiliriz.

Rpi Terminalini kullanarak yukarıdaki python Komut Dosyasını python ortamınızda çalıştırın:

piton faceDetection.py

Sonuç:

"Göz algılama" ve hatta "gülümseme algılama" için sınıflandırıcılar da ekleyebilirsiniz. Bu durumlarda, yüz döngüsünün içine sınıflandırıcı işlevi ve dikdörtgen çizimi dahil edeceksiniz, çünkü bir yüzün dışında bir göz veya bir gülümsemeyi algılamanın bir anlamı olmayacaktır.

Bir Pi'de, aynı kodda birkaç sınıflandırıcıya sahip olmanın, bu algılama yöntemi (HaarCascades) büyük miktarda hesaplama gücü kullandığında işlemeyi yavaşlatacağını unutmayın. Masaüstünde çalıştırmak daha kolaydır.

GitHub'ımda başka örnekler bulacaksınız:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

Ve yukarıdaki resimde sonucu görebilirsiniz.

Yüz Algılamayı daha iyi anlamak için aşağıdaki öğreticiyi de takip edebilirsiniz:

Haar Cascade Nesne Algılama Yüz ve Göz OpenCV Python Eğitimi

Adım 5: Veri Toplama

Her şeyden önce, fotoğraflarda Yüz Tanıma konusundaki harika çalışması için Ramiz Raja'ya teşekkür etmeliyim:

OPENCV VE PYTHON KULLANARAK YÜZ TANIMA: BAŞLANGIÇ KILAVUZU

ve ayrıca video kullanarak çok kapsamlı bir eğitim geliştiren Anirban Kar:

YÜZ TANIMA - 3 parça

Her iki eğitime de bir göz atmanızı gerçekten tavsiye ederim.

Bunu söyleyerek projemizin ilk aşamasına başlayalım. Burada yapacağımız şey, son adımdan (Yüz Algılama) başlayarak, her bir kimlik için depolayacağımız bir veri kümesi oluşturacağız, yüz algılama için kullanılan kısım ile gri bir grup fotoğraf.

İlk olarak, projenizi geliştireceğiniz bir dizin oluşturun, örneğin FacialRecognitionProject:

mkdir Yüz Tanıma Projesi

Bu dizinde projemiz için oluşturacağımız 3 python scriptinin yanı sıra Facial Classifier'ı da kaydetmiş olmamız gerekiyor. GitHub'ımdan indirebilirsiniz: haarcascade_frontalface_default.xml

Ardından, yüz örneklerimizi depolayacağımız ve "veri kümesi" olarak adlandıracağımız bir alt dizin oluşturun:

mkdir veri kümesi

Ve kodu GitHub'ımdan indirin: 01_face_dataset.py

cv2'yi içe aktar

os cam içe aktar = cv2. VideoCapture(0) cam.set(3, 640) # video genişliğini ayarla cam.set(4, 480) # video yüksekliğini ayarla face_detector = cv2. CascadeClassifier('haarcascade_frontalface_default.xml') # Her kişi için, bir sayısal yüz kimliği girin face_id = input('\n kullanıcı kimliğini girin son basın ==> ') print("\n [BİLGİ] Yüz yakalama başlatılıyor. Kameraya bakın ve bekleyin…") # Bireysel örnekleme yüz sayımı sayımını başlat = 0 while(True): ret, img = cam.read() img = cv2.flip(img, -1) # video görüntüsünü dikey olarak çevir gri = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) yüzler = face_detector.detectMultiScale(gri, 1.3, 5) yüzlerde (x, y, w, h) için: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) count += 1 # Yakalanan görüntüyü veri kümeleri klasörüne kaydedin cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", grey[y:y+ h, x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # k == 27 ise videodan çıkmak için 'ESC' tuşuna basın: elif sayısını kes >= 30: # 30 yüz örneği alın ve video arasını durdurun # Ab yapın temizleme yazdır("\n [BİLGİ] Programdan Çıkış ve temizleme öğeleri") cam.release() cv2.destroyAllWindows()

Kod, yüz algılama için gördüğümüz koda çok benziyor. Eklediğimiz, bir tamsayı (1, 2, 3, vb.) olması gereken bir kullanıcı kimliğini yakalamak için bir "giriş komutu" idi.

face_id = input('\n kullanıcı kimliğini girin ve ==> ' tuşuna basın)

Ve yakalanan karelerin her biri için, onu bir "veri kümesi" dizinine bir dosya olarak kaydetmeliyiz:

cv2.imwrite("veri kümesi/Kullanıcı." + str(face_id) + '.' + str(sayım) + ".jpg", gri[y:y+h, x:x+w])

Yukarıdaki dosyayı kaydetmek için "os" kitaplığını içe aktarmış olmanız gerektiğini unutmayın. Her dosyanın adı yapıyı takip edecektir:

User.face_id.count.jpg

Örneğin, face_id = 1 olan bir kullanıcı için veri kümesi/dizinindeki 4. örnek dosya şöyle olacaktır:

Kullanıcı.1.4.jpg

Pi'mden yukarıdaki fotoğrafta gösterildiği gibi. Kodumda, her kimlikten 30 örnek alıyorum. Son "elif" üzerinde değiştirebilirsiniz. Örnek sayısı, yüz örneklerinin yakalandığı döngüyü kırmak için kullanılır.

Python betiğini çalıştırın ve birkaç kimlik yakalayın. Yeni bir kullanıcıyı bir araya getirmek (veya zaten var olanın fotoğraflarını değiştirmek) istediğiniz her seferinde komut dosyasını çalıştırmanız gerekir.

Adım 6: Eğitmen

Bu ikinci aşamada, tüm kullanıcı verilerini veri setimizden almalı ve OpenCV Tanıyıcıyı "eğitmen" yapmalıyız. Bu, doğrudan belirli bir OpenCV işlevi tarafından yapılır. Sonuç, bir "eğitmen/" dizinine kaydedilecek bir.yml dosyası olacaktır.

Öyleyse, eğitilmiş verileri depolayacağımız bir alt dizin oluşturmaya başlayalım:

mkdir eğitmeni

GitHub'ımdan ikinci python betiğini indirin: 02_face_training.py

cv2'yi içe aktar

numpy'yi PIL'den np olarak içe aktar Görüntü içe aktarma işletim sistemi # Yüz görüntüsü veritabanı yolu yolu = 'veri kümesi' tanıyıcı = cv2.face. LBPHFaceRecognizer_create() detektör = cv2. CascadeClassifier("haarcascade_frontalface_default.xml"); # görüntüleri ve etiket verilerini alma işlevi def getImagesAndLabels(path): imagePaths = [os.path.join(path, f) for f in os.listdir(path)] faceSamples= ids = imagePaths içindeki imagePath için: PIL_img = Image.open(imagePath).convert('L') # onu gri tonlamaya dönüştür img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1]. split(".")[1]) yüzler = dedektör.detectMultiScale(img_numpy) için (x, y, w, h) yüzlerde: faceSamples.append(img_numpy[y:y+h, x:x+w]) ids.append(id) return faceSamples, ids print ("\n [BİLGİ] Eğitim yüzleri. Birkaç saniye sürecek. Bekleyin …") yüzler, ids = getImagesAndLabels(path) tanıyıcı.train(yüzler, np.array(ids)) # Modeli trainer/trainer.yml tanıyıcı.write('trainer/trainer.yml') içine kaydedin # tanıyıcı.save() Mac'te çalıştı ama Pi'de çalışmadı # Eğitilen yüzlerin sayısını yazdırın ve program yazdırmayı bitirin ("\n [BİLGİ] {0} eğitilmiş yüzler. Programdan Çıkılıyor".format(len(np.unique(ids))))

Rpi'nizde PIL kitaplığının kurulu olup olmadığını onaylayın. Değilse, Terminal'de aşağıdaki komutu çalıştırın:

pip yükleme yastığı

Tanıyıcı olarak OpenCV paketinde bulunan LBPH (LOCAL BINARY DESEN HISTOGRAMS) Face Recognizer'ı kullanacağız. Bunu aşağıdaki satırda yapıyoruz:

tanıyıcı = cv2.face. LBPHFaceRecognizer_create()

"getImagesAndLabels (yol)" işlevi, dizindeki tüm fotoğrafları çeker: "dataset/", 2 dizi döndürür: "Ids" ve "faces". Girdi olarak bu dizilerle "tanıyıcımızı eğiteceğiz":

tanıyıcı.tren(yüzler, kimlikler)

Sonuç olarak daha önce tarafımızca oluşturulmuş olan trainer dizinine "trainer.yml" isimli bir dosya kaydedilecektir.

Bu kadar! Onay için gösterdiğim son baskı ifadesini, eğittiğimiz Kullanıcı yüzlerinin sayısını ekledim.

Faz 1'i her gerçekleştirdiğinizde, Faz 2 de çalıştırılmalıdır.

Adım 7: Tanıyıcı

Artık projemizin son aşamasına geldik. Burada, kameramızda yeni bir yüz yakalayacağız ve bu kişi daha önce yüzünü yakalayıp eğitmişse, tanıyıcımız kimliğini ve indeksini döndürerek tanıyıcının bu eşleşmeden ne kadar emin olduğunu gösteren bir "tahmin" yapacaktır.

GitHub'ımdan 3. aşama python betiğini indirelim: 03_face_recognition.py.

cv2'yi içe aktar

numpy'yi np olarak içe aktar tanıyıcıyı içe aktar = cv2.face. LBPHFaceRecognizer_create() tanıyıcı.read('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier(cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # kimliklerle ilgili isimler: örnek ==> Marcelo: id=1, etc isimler = ['None', 'Marcelo', 'Paula', 'Ilza', 'Z ', 'W'] # Gerçek zamanlı video yakalama kamerasını başlat ve başlat = cv2. VideoCapture(0) cam.set(3, 640) # video genişliğini ayarla cam.set(4, 480) # video yüksekliğini ayarla # Minimum pencere boyutunu tanımla bir yüz olarak tanınmak için minW = 0.1*cam.get(3) minH = 0.1*cam.get(4) iken True: ret, img =cam.read() img = cv2.flip(img, -1) # Dikey olarak çevir gray = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) face = faceCascade.detectMultiScale(gray, scaleFactor = 1.2, minNeighbors = 5, minSize = (int(minW), int(minH)),) for(x, y), w, h) yüzlerde: cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, güven = tanıyıcı.tahmin(gri[y:y+h, x:x+w]) # Güvenin onlardan daha az olup olmadığını kontrol edin 100 ==> "0", eğer (güven < 100): id = isimler[id] güven = " % {0} ".format(round(100 - güven)) else: id = "bilinmeyen" güven = " {0}%".format(round(100 - conf) idence)) cv2.putText(img, str(id), (x+5, y-5), font, 1, (255, 255, 255), 2) cv2.putText(img, str(güven), (x+5, y+h-5), yazı tipi, 1, (255, 255, 0), 1) cv2.imshow('kamera', img) k = cv2.waitKey(10) & 0xff # 'ESC' tuşuna basın k == 27 ise videodan çıkmak için: break # Biraz temizlik yapın print("\n [BİLGİ] Programdan Çıkma ve temizleme öğeleri") cam.release() cv2.destroyAllWindows()

Buraya yeni bir dizi ekliyoruz, bu yüzden numaralandırılmış kimlikler yerine "adları" göstereceğiz:

isimler = ['Yok', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Yani, örneğin: Marcelo, id = 1 olan kullanıcıyı; Paula: id=2, vb.

Ardından, daha önce haasCascade sınıflandırıcı ile yaptığımızın aynısını bir yüz tespit edeceğiz. Algılanan bir yüze sahip olmak, yukarıdaki koddaki en önemli işlevi çağırabiliriz:

id, güven = tanıyıcı.predict(yüzün gri kısmı)

tanıyıcı.öngörü (), analiz edilecek yüzün yakalanan bir bölümünü parametre olarak alacak ve kimliğini ve tanıyıcının bu eşleşmeyle ilgili ne kadar güvenilir olduğunu belirterek olası sahibine geri dönecektir.

Mükemmel bir eşleşme olarak kabul edilecekse, güven endeksinin "sıfır" vereceğini unutmayın.

Ve son olarak, eğer tanıyıcı bir yüzü tahmin edebiliyorsa, görüntünün üzerine olası kimliği ve eşleşmenin doğru olduğuna dair "olasılık" yüzdesinin ne kadar olduğunu ("olasılık" = 100 - güven endeksi) içeren bir metin koyarız. Değilse, yüze "bilinmeyen" bir etiket konur.

Sonuçla birlikte bir gif'in altında:

Yukarıdaki resimde, tanıyıcının çalışıp çalışmadığını doğrulamak için fotoğrafları kullandığım bu projeyle yapılan bazı testleri gösteriyorum.

Adım 8: Sonuç

Her zaman olduğu gibi, umarım bu proje başkalarının heyecan verici elektronik dünyasına girmelerine yardımcı olabilir!

Ayrıntılar ve son kod için lütfen GitHub depomu ziyaret edin: OpenCV-Face-Recognition

Daha fazla proje için lütfen blogumu ziyaret edin: MJRoBot.org

Aşağıda, "otomatik yüz izleme ve yüz algılama için diğer yöntemleri" keşfedeceğimiz gelecek eğitime bir göz atalım:

Dünyanın güneyinden selamlar!

Bir sonraki talimatımda görüşürüz!

Teşekkürler, Marcelo