Die Gesichtserkennung ist ein Prozess zur Identifizierung von Personen anhand ihrer einzigartigen Merkmale in ihren Gesichtern. Es handelt sich um einen hochkomplexen und faszinierenden Prozess, der vielfältige Anwendungen hat, darunter Sicherheit, Identifizierung und Personenkontrolle, besonders in Zeiten des Coronavirus. OpenCV, eine Open-Source-Bibliothek, die mehrere hundert Algorithmen zur Computer Vision enthält, ist dafür perfekt geeignet.

Hier ist eine Schritt-für-Schritt-Anleitung, wie man ein System zur Gesichtserkennung mit Python und OpenCV aufbaut:

Schritt 1: Installieren Sie die notwendigen Bibliotheken

Zunächst müssen Sie Python und OpenCV auf Ihrem System installiert haben. Sie können diese Module mit pip herunterladen und installieren.

pip install opencv-python
pip install opencv-python-headless

Mit diesen Befehlen wird das OpenCV-Paket für Python installiert.

Schritt 2: Importieren Sie die notwendigen Module

Sie müssen mehrere integrierte Module importieren:

import cv2
import os
import numpy as np

Schritt 3: Bereiten Sie die Trainingsdaten vor

Sie müssen einen Datensatz von Gesichtern vorbereiten, die das System erkennen muss. Sie können diese Daten manuell sammeln oder aus Online-Ressourcen beziehen.

Speichern Sie den Datensatz in einem Verzeichnis. Unterordner dieses Verzeichnisses werden die Bezeichnungen für die Gesichter sein.

Beispiel:

/images
/person1
person1_image1.jpg
person1_image2.jpg
...
/person2
person2_image1.jpg
person2_image2.jpg
...
/person3
person3_image1.jpg
person3_image2.jpg
...
...

Dann schreiben Sie eine Python-Funktion, um die Bilder aus Ihrem Datensatz zu laden und sie in Graustufenbilder umzuwandeln. Der Name jedes Unterordners wird die Bezeichnung für jedes Bild sein.

Funktion, um Gesichter mit OpenCV zu erkennen

def detect_face(img):

Testbild in Graubild umwandeln

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

OpenCV Gesichtsdetektor laden

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

faces = face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5);

Wenn keine Gesichter erkannt werden, dann Bild zurückgeben

if (len(faces) == 0):
return None, None

Extrahieren Sie das Gesicht

(x, y, w, h) = faces[0]

Nur den Gesichtsteil zurückgeben

return gray[y: y+w, x: x+h], faces[0]

Schritt 4: Trainieren Sie das Modell

Als nächstes müssen Sie die Gesichter in den Unterordnern extrahieren und Labels zuweisen. Stellen Sie sicher, dass Sie die Bilder in der gleichen Reihenfolge wie die Labels verarbeiten.

Das Gesichtserkennung wird dann durchgeführt. Dies erzeugt ein Recognizer-Objekt. Das Recognizer-Objekt kann mit den Gesichtern und den Labels trainiert werden.

def prepare_training_data(data_folder_path):

Funktion zur Vorbereitung der Trainingsdaten

Schritt - 1: Verzeichnisse (ein Verzeichnis für jedes Thema) im Datenordner abrufen

dirs = os.listdir(data_folder_path)

Schritt - 2: Etiketten und Bilder für jedes Verzeichnis extrahieren

faces = []
labels = []

for dir_name in dirs:
label = int(dir_name)

   subject_dir_path = data_folder_path + "/" + dir\_name
   
   subject_images_names = os.listdir(subject_dir_path)
   
   for image_name in subject_images\_names:
       if image\_name.startswith("."):
           continue;
        
       # Bild laden
       image_path = subject_dir_path + "/" + image_name
       image = cv2.imread(image\_path)
        
       # Gesicht erkennen
       face, rect = detect\_face(image)
        
       if face is not None:
           # Gesicht zur Liste hinzufügen
           faces.append(face)
           # Label für dieses Gesicht hinzufügen
           labels.append(label)
            

return faces, labels

Testen wir unsere Funktion

Zuerst bereiten wir unsere Trainingsdaten vor

faces, labels = prepare_training_data("training-data")

Erstellen Sie unseren LBPH-Gesichtserkenner

face_recognizer = cv2.face.LBPHFaceRecognizer_create()

Trainieren Sie unseren Gesichtserkenner anhand unserer Trainingsgesichter

face_recognizer.train(faces, np.array(labels))

Schritt 5: Eine Vorhersage treffen

Um eine Vorhersage zu treffen, wird dem Predict() Befehl das Testbild als Eingang gegeben. Dies wird das Label und den Konfidenzscore zurückgeben.

Funktion zur Zeichnung eines Rechtecks auf einem Bild

def draw_rectangle(img, rect):
(x, y, w, h) = rect
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)

Funktion zur Beschriftung auf einem Bild

def draw_text(img, text, x, y):
cv2.putText(img, text, (x, y), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 255, 0), 2)

Funktion zur Erkennung der Person auf dem übergebenen Bild

def predict(test_img):

Gesicht auf dem Bild erkennen

face, rect = detect_face(test_img)
label= face_recognizer.predict(face)

Namen des jeweiligen Labels holen, das vom Gesichtserkenner zurückgegeben wird

label_text = subjects[label[0]]

Ein Rechteck um das erkannte Gesicht ziehen

draw_rectangle(test_img, rect)

Namen der erkannten Person zeichnen

draw_text(test_img, label_text, rect[0], rect[1]-5)
return test_img

Test der Funktion anhand eines Bildes

test_img1 = cv2.imread("test-data/test1.jpg")
predicted_img1 = predict(test_img1)
cv2.imshow(predicted_img1)
cv2.waitKey(0)
cv2.destroyAllWindows()

So bauen Sie ein System zur Gesichtserkennung mit Python und OpenCV.

Für Systeme, die eine hohe Genauigkeit und Robustheit erfordern, wird jedoch empfohlen, Deep-Learning-Frameworks wie Dlib oder FaceNet zu verwenden.