Nun kommen wir zur «face recognition» – wir wollen also nicht nur ein Gesicht erkennen, sondern auch zu welcher Person es gehört.
Der Code dieses Kapitels basiert mit Modifikationen auf einem Github-Artikel von Ramiz Raja (opens new window)
# Übersicht
Wir werden in drei Schritten vorgehen:
- Daten sammeln – Bilder von Personen sammeln, welche erkannt werden sollen.
- Training – Die Bilder und die Namen der dazugehörigen Personen der Gesichtserkennung füttern, so dass diese lernen kann.
- Erkennen – Der Gesichtserkennung neue Bilder der erkannten Personen füttern und testen ob diese korrekt erkannt werden.
# Gesichtserkennung in OpenCV
OpenCV hat drei verschiedene Methoden eingebaut, wie Gesichter erkannt werden können (3 verschiedene sogenannte «Face Recognizer»):
- EigenFaces Face Recognizer -
cv2.face.createEigenFaceRecognizer()
- FisherFaces Face Recognizer -
cv2.face.createFisherFaceRecognizer()
- Local Binary Patterns Histograms (LBPH) Face Recognizer -
cv2.face.createLBPHFaceRecognizer()
Mit einer Zeile Code können wir die Gesichtserkennungs-Methode umstellen. Wir wollen die drei Methoden kurz miteinander vergleichen:
# EigenFaces Face Recognizer
Wenn wir jemanden erkennen, so geschieht dies anhand spezieller Eigenschaften, wie z.B. Augen, Nase, Backen, Stirn und vor allem den Übergängen dazwischen. Wenn wir mehrere Gesichter vergleichen, dann vergleichen wir vor allem diese Teile, weil dort die Unterschiede am deutlichsten sind.
Genau so funktioniert der EigenFaces-Algorithmus: Er schaut sich die Trainingsbilder der Personen an und versucht diejenigen Elemente zu extrahieren, welche sich am meisten hervorheben. Weniger interessante Elemente werden ignoriert, wodurch auch noch gerade Speicher gespart wird. Den extrahierten Elementen sagt man «Principal Components». Sie lassen sich auch darstellen:
Die «Principal Components» stellen Gesichter dar. Man sagt ihnen «Eigen Faces».
Der Algorithmus nimmt auch die Lichtverhältnisse der Bilder als wichtig war. Damit ist er nicht immer der best-geeignete Gesichtserkennungs-Algorithmus.
Bei der eigentlichen Erkennung, werden aus dem unbekannten Bild die «Principal Components» extrahiert und mit den trainierten Daten verglichen. So kann das Gesicht einer Person zugeordnet werden.
# FisherFaces Face Recognizer
Bei diesem Algorithmus handelt es sich um eine verbesserte Version des EigenFaces-Algorithmus: Statt wichtige Elemente aller Gesichter zu extrahieren, versucht FisherFaces Unterschiede zwischen den Personen zu finden. Auch diese Features lassen sich darstellen:
Wiederum stellen die extrahierten Features Gesichter dar. Man sagt diesen «Fisher Faces».
Immer noch ist dieser Algorithmus anfällig auf harte Grenzen, etwa durch Schattenwurf. Diese harten Kanten werden vom Algorithmus als wichtige Features extrahiert.
# Local Binary Patterns Histograms (LBPH) Face Recognizer
Die beiden vorherigen Algorithmen werden beide durch die Beleuchtungssitutaion beeinflusst. Der LBPH-Face Recognizer soll dieses Problem lösen.
Dies soll dadurch erreicht werden, dass nicht das Bild als Ganzes angeschaut wird, sondern indem lokale Strukturen gefunden und einzelne Bildpunkte mit ihren Nachbarn verglichen werden. Für jeden Bildpunkt und seine Nachbarn wird so ein lokales Binärmuster erzeugt. Alle solchen Muster eines Bildes werden in Form eines Histogramms abgespeichert. Daher der Name «LBPH».
Soll ein unbekanntes Gesicht zugewiesen werden, so wird daraus ein Histogramm erstellt und dieses mit den Histogrammen vom Training verglichen.
# Umsetzung in Python
Die Gesichtserkennung kann in 3 Schritte unterteilt werden:
- Daten vorbereiten
- Face Recognizer trainieren
- Face Recognizer testen
# Wichtige Module importieren
Zusätzlich zu den bereits im vorherigen Kapitel verwendeten Packages müssen wir in Thonny neu das Package opencv-contrib-python
installieren.
Dann können wir die Module wie folgt importieren:
#import OpenCV module
import cv2
#import os module for reading training data directories and paths
import os
#import numpy to convert python lists to numpy arrays as
#it is needed by OpenCV face recognizers
import numpy as np
2
3
4
5
6
7
# Trainings-Daten
Die Bilder für das Training werden in nummerierten Unterordner des Trainings-Ordners training-data
abgelegt. Person1
steht also für den Namen der ersten Person und beinhaltet mehrere Bilder mit ihrem Gesicht. Die Struktur sieht wie folgt aus:
projekt-ordner
|
|------training-data
| |------ Person1
| | |-- 1.jpg
| | |-- 2.jpg
| | |-- ...
| |
| |------ Person2
| |-- 1.jpg
| |-- 2.jpg
| |-- ...
|
|------test-data
|-- test1.jpg
|-- test2.jpg
|-- ...
Aufgabe
Erstelle die benötigte Ordner-Struktur und stelle ein Trainings-Set zusammen:
- mindestens 2 Personen
- pro Person mindestens 10 Bilder
Sie können Berühmtheiten im Internet suchen, oder Bilder von sich selbst verwenden (sie brauchen aber mindestens 10 Bilder). Legen sie pro Person mindesten ein Bild zur Seite für die Test-Phase. Diese Bild kommt in den Ordner test-data
.
Hinweis
Ihr könnt auch Trainingssets untereinander austauschen!
subjects = []
Aufgabe
Erstelle in deinem Projekt-Ordner einen neue Python-Datei.
- Importiere die benötigten Module
- Lege die leere Liste für deine Personen fest
# Trainings-Daten vorbereiten
Der OpenCV-Face Recognizer wünscht sich die Trainingsdaten in einem bestimmten Format. Wir müssen also unsere Daten aufbereiten, so dass wir ihm zwei Listen liefern können: Eine Liste mit dem Gesichtsausschnitt als Bild und eine zweite Liste mit der Nummer der dazugehörigen Person. Für 2 Personen mit je 2 Bildern würden wir also folgendes tun:
PERSON-1 | PERSON-2 |
---|---|
img1 | img1 |
img2 | img2 |
Dann würden wir in den Bildern die Gesichter erkennen und in einer Liste speichern. In der zweiten Liste wären dann die Nummern der Person:
FACES | LABELS |
---|---|
person1_img1_face | 1 |
person1_img2_face | 1 |
person2_img1_face | 2 |
person2_img2_face | 2 |
Die genauen Schritte lassen sich weiter unterteilen:
- Lese alle Ordnernamen der Personen im Trainingsordner. In diesem Beispiel also
s1
,s2
, … - Extrahiere für jede Person die Nummer. Unsere Ordner haben eine spezielle Benennungskonvention: In
s1
stehts
für «subject» und die1
ist die Nummer. Die hier extrahierte Nummer wird für die Bilder im nächsten Schritt alslabel
verwendet. - Lies alle Bilder der Person und extrahiere das Gesicht. (Für EigenFaces und FisherFaces muss das Gesicht auf eine Standard-Grösse verkleinert oder vergrössert werden.)
- Füge jedes Gesicht der Liste
faces
und das passendelabel
der Listelabels
an der korrekten Stelle hinzu.
Wir schreiben eine Funktion welche ein Gesicht erkennt und extrahiert. Dabei gehen wir davon aus, dass maximal ein Gesicht pro Bild existiert.
#function to detect face using OpenCV
def detect_face(img):
#convert the test image to gray image as opencv face detector expects gray images
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#load OpenCV face detector, I am using LBP which is fast
face_cascade = cv2.CascadeClassifier(cv2.data.lbpcascades + "lbpcascade_frontalface.xml")
#there is also a more accurate but slow Haar classifier:
#face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
#let's detect multiscale (some images may be closer to camera than others) images
#result is a list of faces
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5);
#if no faces are detected then return original img
if (len(faces) == 0):
return None, None
#under the assumption that there will be only one face,
#extract the face area
(x, y, w, h) = faces[0]
#extract and resize face
face = cv2.resize(gray[y:y+w, x:x+h],(200,200))
#return only the resized face part of the image
return face, faces[0]
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Jetzt haben wir ein detect_face()
und können dieses verwenden, um unsere Daten vorzubereiten. Im Code sind die 4 oben beschrieben Schritte im Kommentar markiert.
#this function will read all persons' training images, detect face from each image
#and will return two lists of exactly same size, one list
# of faces and another list of labels for each face
def prepare_training_data(data_folder_path):
#------STEP-1--------
#get the directories (one directory for each subject) in data folder
dirs = os.listdir(data_folder_path)
#list to hold all subject faces
faces = []
#list to hold labels for all subjects
labels = []
label = 0
#let's go through each directory and read images within it
for dir_name in dirs:
#ignore system files like .DS_Store or Thumbs.db
if dir_name.startswith(".") or dir_name == "Thumbs.db":
continue;
#------STEP-2--------
subjects.append(dir_name)
#build path of directory containing images for current subject subject
#sample subject_dir_path = "training-data/s1"
subject_dir_path = data_folder_path + "/" + dir_name
#get the images names that are inside the given subject directory
subject_images_names = os.listdir(subject_dir_path)
#------STEP-3--------
#go through each image name, read image,
#detect face and add face to list of faces
for image_name in subject_images_names:
#ignore system files like .DS_Store or Thumbs.db
if image_name.startswith(".") or image_name == "Thumbs.db":
continue;
#build image path
image_path = subject_dir_path + "/" + image_name
#read image
image = cv2.imread(image_path)
#display an image window to show the image
cv2.imshow("Training on image...", image)
cv2.waitKey(100)
#detect face
face, rect = detect_face(image)
#------STEP-4--------
#for the purpose of this tutorial
#we will ignore faces that are not detected
if face is not None:
#add face to list of faces
faces.append(face)
#add label for this face
labels.append(label)
label = label + 1
cv2.destroyAllWindows()
return faces, labels
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
Nun wollen wir die Trainings-Daten vorbereiten. Dazu rufen wir unsere prepare_training_data()
-Funktion auf und geben einige Infos aus, damit wir wissen was gemacht wird und wie viele Gesichter erkannt wurden.
#let's first prepare our training data
#data will be in two lists of same size
#one list will contain all the faces
#and other list will contain respective labels for each face
print("Preparing data...")
faces, labels = prepare_training_data("training-data")
print("Data prepared")
#print total faces and labels
print("Total faces: ", len(faces))
print("Total labels: ", len(labels))
2
3
4
5
6
7
8
9
10
11
Aufgabe
- Füge deinem Python-Skript die beiden Funktionen
detect_face()
undprepare_training_data()
hinzu. - Rufe nun
prepare_training_data()
wie oben beschrieben auf und schaue wieviele Gesichter erkannt wurden.
Du solltest einen Output erhalten der in etwa wie folgt aussieht:
Preparing data...
Data prepared
Total faces: 23
Total labels: 23
2
3
4
Die Zahl kann natürlich abweichen, aber beide Listen sollten gleich lange sein!
# Trainieren
Wir können nun einen der besprochenen Face Recognizer trainieren. Zuerst müssen wir uns für einen der drei entscheiden:
#create our LBPH face recognizer
face_recognizer = cv2.face.LBPHFaceRecognizer_create()
#or use EigenFaceRecognizer by replacing above line with
#face_recognizer = cv2.face.EigenFaceRecognizer_create()
#or use FisherFaceRecognizer by replacing above line with
#face_recognizer = cv2.face.FisherFaceRecognizer_create()
2
3
4
5
6
7
8
Dann füttern wir ihm einfach die vorbereiteten Daten in Form der beiden Listen:
#train our face recognizer of our training faces
face_recognizer.train(faces, np.array(labels))
2
Die labels
-Liste müssen wir dabei in ein numpy-Array umwandeln.
Aufgabe
Ergänze dein Skript um den obenstehenden Code.
# Testen
Im letzten Teil wollen wir nun schauen, ob unserer Face Recognizer korrekt trainiert wurde und die Personen im Test-Set erkennt.
Zuerst definieren wir zwei Hilfsfunktionen um Gesichter zu umranden und mit Text zu beschriften:
#function to draw rectangle on image
#according to given (x, y) coordinates and
#given width and height
def draw_rectangle(img, rect):
(x, y, w, h) = rect
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
#function to draw text on give image starting from
#passed (x, y) coordinates.
def draw_text(img, text, x, y):
cv2.putText(img, text, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
2
3
4
5
6
7
8
9
10
11
Nun können wir die predict()
-Funktion des Face Recognizers verwenden, um Gesichter zu erkennen und mit Hilfe unserer Hilfsfunktionen zu markieren. Dazu schreiben wir eine eigene predict()
-Funktion. (Wir wollen das ja auf alle Bilder im test-Ordner anwenden.)
#this function recognizes the person in image passed
#and draws a rectangle around detected face with name of the
#subject
def predict(img):
#detect face from the image
face, (x,y,w,h) = detect_face(img)
#predict the image using our face recognizer
label, confidence = face_recognizer.predict(face)
#get name of respective label returned by face recognizer
label_text = subjects[label]
#draw a rectangle around face detected
draw_rectangle(img, (x,y,w,h))
#draw name of predicted person
draw_text(img, label_text, x, y-5)
#draw confidence of predicted person
draw_text(img, str(int(confidence)), x, y+h+20)
return img
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Jetzt haben wir unsere predict()
-Funktion und können sie auf unsere Test-Bilder anwenden:
print("Predicting images...")
test_image_names = os.listdir("test-data")
for test_image_name in test_image_names:
#ignore system files like .DS_Store or Thumbs.db
if test_image_name.startswith(".") or test_image_name == "Thumbs.db":
continue;
test_img = cv2.imread("test-data/" + test_image_name)
predicted_img = predict(test_img)
cv2.imshow(test_image_name, predicted_img)
print("Prediction complete, press any key to close windows")
cv2.waitKey(0)
cv2.destroyAllWindows()
exit()
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Aufgabe
Füge deinem Skript den restlichen Code hinzu und teste es aus!
- Teste die Ergebnisse mit den drei verschiedenen Face Recognizer.
- Vergleiche die Ergebnisse in Abhängigkeit der Bild-Grösse (
resize
in der Funktiondetect_face()
, Bilder 20x20 bis ca. 800x800 machen Sinn)
Zeitmessung (fakultativ)
Versuche die Zeit zu messen die für das Training verwendet wird. Du kannst das Modul time
verwenden:
import time
t = time.process_time()
#do some stuff
elapsed_time = time.process_time() - t
2
3
4
5
- Vergleiche die Trainingszeit für die drei verschiedenen Face Recognizer.
- Vergleiche die Trainingszeit in Abhängigkeit der Bild-Grösse (
resize
in der Funktiondetect_face()