Projekt wykrywania twarzy w Pythonie [w 5 prostych krokach]

Identyfikacja obiektów i detekcja twarzy to prawdopodobnie najpopularniejsze zastosowania wizji komputerowej. Technologia ta znajduje zastosowanie w różnych branżach, takich jak bezpieczeństwo czy media społecznościowe. Dlatego budujemy projekt wykrywania twarzy za pomocą Pythona.

Pamiętaj, że powinieneś znać programowanie w Pythonie, OpenCV i NumPy. Zapewni to, że nie pomylisz się podczas pracy nad tym projektem. Zacznijmy.

Udostępniliśmy dwie metody wykonywania rozpoznawania twarzy. Pierwsza korzysta z biblioteki rozpoznawania twarzy Pythona, a druga korzysta z OpenCV i NumPy. Sprawdź nasze programy nauki o danych, aby dowiedzieć się więcej.

Rozpoznawanie twarzy za pomocą „Rozpoznawania twarzy” Pythona

Prawdopodobnie najłatwiejszą metodą wykrywania twarzy jest użycie biblioteki rozpoznawania twarzy w Pythonie . W bazie danych LFW miał dokładność 99,38%. Korzystanie z niego jest dość proste i nie wymaga dużego wysiłku. Ponadto biblioteka posiada dedykowane polecenie „rozpoznawanie twarzy” służące do identyfikowania twarzy na obrazach.

Jak korzystać z rozpoznawania twarzy

Możesz rozróżnić twarze na obrazach za pomocą polecenia „face_locations”:

importuj rozpoznawanie twarzy

obraz = rozpoznawanie_twarzy.load_image_file(„Twój_plik.jpg”)

face_locations = face_recognition.face_locations (obraz)

Może również rozpoznawać twarze i kojarzyć je z ich imionami:

importuj rozpoznawanie twarzy

znany_obraz = rozpoznawanie_twarzy.load_image_file(„modi.jpg”)

nieznany_obraz = face_recognition.load_image_file („nieznany.jpg”)

modi_encoding = face_recognition.face_encodings(known_image)[0]

unknown_encoding = face_recognition.face_encodings(unknown_image)[0]

wyniki = rozpoznawanie_twarzy.compare_faces([kodowanie_modi], kodowanie_nieznane)

Zdjęcie zawiera „Narendra Modi”

Jest wiele innych rzeczy, które możesz wykonać za pomocą tej biblioteki, łącząc ją z innymi. Omówimy teraz wykonywanie rozpoznawania twarzy z innymi znanymi bibliotekami w Pythonie, w szczególności OpenCV i NumPy.

Przeczytaj więcej: Samouczek Pythona NumPy: Naucz się Pythona Numpy z przykładami

Projekt wykrywania twarzy w Pythonie

W tym projekcie wykonaliśmy wykrywanie i rozpoznawanie twarzy za pomocą OpenCV i NumPy. Użyliśmy Raspberry Pi, ale możesz go również używać z innymi systemami. Wystarczy nieznacznie zmodyfikować kod, aby można go było używać na innym urządzeniu (takim jak Mac lub Windows PC).

Część zasług dla tego projektu należy do Marcelo Rovai .

Krok #1: Zainstaluj biblioteki

Najpierw powinieneś zainstalować wymagane biblioteki, OpenCV i NumPy. Możesz go łatwo zainstalować poprzez:

pip zainstaluj opencv-python

pip zainstaluj opencv-contrib-python

Aby zainstalować NumPy w swoim systemie, użyj tego samego polecenia co powyżej i zamień 'opencv-python' na 'numpy':

pip zainstaluj numpy

Krok #2: Wykryj twarze

Teraz musisz skonfigurować kamerę i podłączyć ją do swojego systemu. Kamera powinna działać prawidłowo, aby uniknąć problemów z wykrywaniem twarzy.

Zanim nasz aparat nas rozpozna, musi najpierw wykryć twarze. Do wykrywania twarzy użyjemy klasyfikatora Haar Cascade. Jest to przede wszystkim metoda wykrywania obiektów, w której trenujesz funkcję kaskadową za pomocą obrazów negatywowych i pozytywowych, po czym staje się ona w stanie wykrywać obiekty na innych zdjęciach.

W naszym przypadku chcemy, aby nasz model wykrywał twarze. OpenCV jest dostarczany z trenażerem i detektorem, więc korzystanie z klasyfikatora Haar Cascade jest stosunkowo wygodniejsze z tą biblioteką. Możesz utworzyć swój klasyfikator, aby wykrywać również inne obrazy.

Oto kod:

importuj numer jako np

importuj cv2

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

cap = cv2.VideoCapture(0)

zestaw nasadek (3,640) # zestaw Szerokość

cap.set(4,480) # ustaw Wysokość

podczas gdy prawda:

ret, img = cap.odczyt()

img = cv2.flip(img, -1)

szary = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

twarze = twarzCascade.detectMultiScale(

szary,

współczynnik skali=1,2,

minSąsiedzi=5,

minRozmiar=(20, 20)

)

dla (x,y,w,h) w twarzach:

cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)

roi_gray = szary[y:y+h, x:x+w]

roi_color = img[y:y+h, x:x+w]

cv2.imshow('wideo',img)

k = cv2.waitKey(30) & 0xff

if k == 27: # naciśnij 'ESC', aby wyjść

zepsuć

cap.zwolnienie()

cv2.destroyAllWindows()

Krok #3: Zbierz dane

Teraz, gdy Twój model może identyfikować twarze, możesz go wytrenować, aby zaczął rozpoznawać, czyja twarz jest na zdjęciu. Aby to zrobić, musisz dostarczyć mu wiele zdjęć twarzy, które chcesz zapamiętać.

Dlatego zaczniemy od stworzenia naszego zbioru danych od zebrania zdjęć. Po zebraniu niezbędnych zdjęć dodaj identyfikatory dla każdej osoby, aby modelka wiedziała, jaką twarz skojarzyć z jakim identyfikatorem. Zacznij od zdjęć jednej osoby i dodaj co najmniej 10-20. Użyj różnych wyrażeń, aby uzyskać najbardziej efektywne wyniki.

Utwórz skrypt do dodawania identyfikatorów użytkowników do obrazów, dzięki czemu nie musisz za każdym razem robić tego ręcznie. Skrypt jest niezbędny, jeśli chcesz użyć swojego modelu na wielu twarzach.

Ucz się kursów uczenia maszynowego z najlepszych światowych uniwersytetów. Zdobywaj programy Masters, Executive PGP lub Advanced Certificate Programy, aby przyspieszyć swoją karierę.

Krok 4: Trenuj

Po utworzeniu zbioru danych z obrazami osoby, musisz trenować model. Przesyłasz obrazy do swojego aparatu rozpoznawania OpenCV, który na końcu utworzy plik o nazwie „trainer.yml”.

Na tym etapie wystarczy dostarczyć modelowi obrazy i ich identyfikatory, aby model mógł zapoznać się z identyfikatorem każdego obrazu. Po zakończeniu trenowania modelu możemy go przetestować.

Oto kod:

importuj cv2

importuj numer jako np

z obrazu importu PIL

importuj system

# Ścieżka do bazy danych obrazów twarzy

ścieżka = „zbiór danych”

aparat rozpoznawania = cv2.face.LBPFaceRecognizer_create()

detektor = cv2.CascadeClassifier(„haarcascade_frontalface_default.xml”);

# funkcja pobierania obrazów i danych etykiet

def getImagesAndLabels(ścieżka):

imagePaths = [os.path.join(ścieżka,f) dla f w os.listdir(ścieżka)]

Próbki twarzy=[]

identyfikatory = []

dla imagePath w imagePaths:

PIL_img = Image.open(imagePath).convert('L') # grayscale

img_numpy = np. tablica (PIL_img, 'uint8′)

id = int(os.path.split(ŚcieżkaObrazu)[-1].split(“.”)[1])

twarze = detektor.detectMultiScale(img_numpy)

dla (x,y,w,h) w twarzach:

faceSamples.append(img_numpy[y:y+h,x:x+w])

ids.append(id)

return faceSamples,ids

print („\n [INFO] Treningowe twarze. Zajmie to kilka sekund. Poczekaj…”)

twarze,ids = getImagesAndLabels(ścieżka)

resolver.train(faces, np.array(ids))

# Zapisz model w trainer/trainer.yml

rozpoznanie.write('trener/trener.yml')

# Wydrukuj liczbę przeszkolonych twarzy i zakończ program

print(„\n [INFO] {0} twarze przeszkolone. Kończę program”.format(len(np.unique(ids))))

Dowiedz się: Aplikacja MATLAB w rozpoznawaniu twarzy: kod, opis i składnia

Krok #5: Rozpocznij rozpoznawanie

Teraz, po wytrenowaniu modelu, możemy rozpocząć testowanie modelu. W tej sekcji dodaliśmy nazwy do identyfikatorów, aby model mógł wyświetlać nazwy odpowiednich użytkowników, których rozpoznaje.

Modelka nie rozpoznaje osoby. Przewiduje, czy wykryta twarz pasuje do twarzy znajdującej się w jego bazie danych. Nasz model wyświetla procent tego, jak bardzo twarz pasuje do twarzy znajdującej się w jego bazie danych. Jego dokładność będzie w dużej mierze zależeć od testowanego obrazu i obrazów dodanych do bazy danych (obrazów, za pomocą których trenowałeś model).

Oto kod:

importuj cv2

importuj numer jako np

importuj system

aparat rozpoznawania = cv2.face.LBPFaceRecognizer_create()

rozpoznanie.read('trener/trener.yml')

cascadePath = „haarcascade_frontalface_default.xml”

faceCascade = cv2.CascadeClassifier(cascadePath);

czcionka = cv2.FONT_HERSHEY_SIMPLEX

#inicjuj licznik identyfikatorów

identyfikator = 0

# nazwy związane z identyfikatorami: przykład ==> upGrad: id=1, itd

imiona = ['Brak', uaktualnij', Ja', 'Przyjaciel', 'Y', 'X']

# Zainicjuj i rozpocznij przechwytywanie wideo w czasie rzeczywistym

krzywka = cv2.VideoCapture(0)

cam.set(3, 640) # ustaw szerokość wideo

cam.set(4, 480) # ustaw wysokość wideo

# Określ minimalny rozmiar okna, które ma być rozpoznawane jako twarz

minW = 0.1*cam.get(3)

minH = 0.1*cam.get(4)

podczas gdy prawda:

ret, img = kamera.odczyt()

img = cv2.flip(img, -1) # Odwróć w pionie

szary = cv2.cvtColor(img,cv2.COLOR_BGR2GREY)

twarze = twarzCascade.detectMultiScale(

szary,

współczynnik skali = 1,2,

minSąsiedzi = 5,

minSize = (int(minW), int(minH)),

)

for(x,y,w,h) w twarzach:

cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)

id, zaufanie = rozpoznanie.predict(szary[y:y+h,x:x+w])

# Jeśli ufność jest mniejsza niż 100 ==> „0” : idealne dopasowanie

jeżeli (pewność < 100):

id = imiona[id]

pewność = ” {0}%”.format(round(100 – pewność))

w przeciwnym razie:

id = „nieznany”

pewność = ” {0}%”.format(round(100 – pewność))

cv2.putTekst(

obraz,

str(id),

(x+5,y-5),

czcionka,

1,

(255,255,255),

2

)

cv2.putTekst(

obraz,

str(zaufanie),

(x+5,y+h-5),

czcionka,

1,

(255.255,0),

1

)

cv2.imshow('kamera',img)

k = cv2.waitKey(10) & 0xff # Naciśnij 'ESC', aby wyjść z wideo

jeśli k == 27:

zepsuć

# Zrób porządki

print(„\n [INFO] Wychodzenie z programu i czyszczenie”)

krzywka.zwolnienie()

cv2.destroyAllWindows()

Dotarliśmy do końca naszego projektu wykrywania twarzy w Pythonie. Wiesz już, jak stworzyć model uczenia maszynowego, który wykrywa i rozpoznaje twarze. Podziel się z nami swoimi wynikami!

Dowiedz się: samouczek wykrywania obiektów TensorFlow dla początkujących

Dowiedz się więcej o uczeniu maszynowym

Mamy nadzieję, że podobał Ci się ten projekt wykrywania twarzy. Jeśli chcesz, aby było to trudniejsze, możesz dodać wiele twarzy do swojego zbioru danych i odpowiednio wytrenować swój model. Możesz również połączyć go z innymi bibliotekami i rozszerzyć projekt o coś innego, np. system bezpieczeństwa wykrywania twarzy dla programu!

Jeśli chcesz dowiedzieć się więcej o uczeniu maszynowym, zapoznaj się z programem IIIT-B i upGrad Executive PG w zakresie uczenia maszynowego i sztucznej inteligencji, który jest przeznaczony dla pracujących profesjonalistów i oferuje ponad 450 godzin rygorystycznych szkoleń, ponad 30 studiów przypadków i zadań, IIIT Status -B Alumni, ponad 5 praktycznych praktycznych projektów zwieńczenia i pomoc w pracy z najlepszymi firmami.