Gesichtserkennung mit Python und OpenCV

Einführung in Haar-Kaskaden-Klassifikatoren

Diese Methode wurde erstmals in dem Artikel Rapid Object Detection Using a Boosted Cascade of Simple Features von Paul Viola und Michael Jones vorgestellt.

Die Idee hinter dieser Technik ist, eine Kaskade von Klassifikatoren zu verwenden, um verschiedene Merkmale in einem Bild zu erkennen. Diese Klassifikatoren werden dann zu einem starken Klassifikator kombiniert, der genau zwischen Proben, die ein menschliches Gesicht enthalten, und solchen, die es nicht enthalten, unterscheiden kann.

Der in OpenCV integrierte Haar-Kaskaden-Klassifikator wurde bereits auf einem großen Datensatz mit menschlichen Gesichtern trainiert, sodass kein weiteres Training erforderlich ist. Wir müssen nur den Klassifikator aus der Bibliothek laden und ihn für die Gesichtserkennung auf einem Eingabebild verwenden.

Installation von OpenCV für Python

Um die OpenCV-Bibliothek zu installieren, öffne einfach deine Eingabeaufforderung oder dein Terminalfenster und führe den folgenden Befehl aus:

pip install opencv-python

Dieser Befehl funktioniert nur, wenn du pip bereits auf deinem Gerät installiert hast. Wenn du mehr über den Paketmanager pip erfahren möchtest, kannst du unser PIP Python Tutorial lesen.

OpenCV für die Erkennung von Gesichtern in Bildern

Wir werden einen Detektor bauen, um das menschliche Gesicht in einem Foto von Unsplash zu identifizieren. Speichere das Bild in deinem Arbeitsverzeichnis und benenne es in input_image um, bevor du weitercodierst.

Schritt 1: Importiere das OpenCV-Paket

Jetzt importieren wir OpenCV und geben den Pfad für das Eingabebild mit den folgenden Codezeilen ein:

import cv2

imagePath = 'input_image.jpg'

Schritt 2: Das Bild lesen

Dann müssen wir das Bild mit der Funktion imread() von OpenCV einlesen:

img = cv2.imread(imagePath)

Diese Funktion lädt das Bild aus dem angegebenen Dateipfad und gibt es in Form eines Numpy-Arrays zurück. 

Lass uns die Dimensionen dieses Arrays ausdrucken:

img.shape

(4000, 2667, 3)

Beachte, dass dies ein 3-dimensionales Array ist. Die Werte des Arrays stehen jeweils für die Höhe, die Breite und die Kanäle des Bildes. Da es sich um ein Farbbild handelt, werden drei Kanäle verwendet, um es darzustellen - Blau, Grün und Rot (BGR). 

Beachte, dass die herkömmliche Sequenz zur Darstellung von Bildern RGB (Rot, Blau, Grün) ist, während die OpenCV-Bibliothek das umgekehrte Layout (Blau, Grün, Rot) verwendet.

Schritt 3: Das Bild in Graustufen umwandeln

Um die Rechenleistung zu verbessern, müssen wir dieses Bild zunächst in Graustufen umwandeln, bevor wir es für die Gesichtserkennung verwenden:

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

Untersuchen wir nun die Abmessungen dieses Graustufenbildes:

gray_image.shape

(4000, 2667)

Beachte, dass dieses Array nur zwei Werte hat, da das Bild Graustufen hat und nicht mehr über den dritten Farbkanal verfügt.

Schritt 4: Den Klassifikator laden

Lass uns den vortrainierten Haar-Cascade-Klassifikator laden, der in OpenCV integriert ist:

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Beachte, dass wir eine Datei namens haarcascade_frontalface_default.xml verwenden. Dieser Klassifikator wurde speziell für die Erkennung von Frontalgesichtern im visuellen Input entwickelt. 

OpenCV bietet auch andere vortrainierte Modelle, um verschiedene Objekte in einem Bild zu erkennen - zum Beispiel die Augen einer Person, ihr Lächeln, ihren Oberkörper und sogar das Nummernschild eines Fahrzeugs. Du kannst mehr über die verschiedenen in OpenCV integrierten Klassifikatoren erfahren, indem du das GitHub-Repository der Bibliothek durchsuchst.

Schritt 5: Die Gesichtserkennung durchführen

Jetzt können wir das Graustufenbild mit dem Klassifikator, den wir gerade geladen haben, auf ein Gesicht prüfen:

face = face_classifier.detectMultiScale(
    gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40)
)

Schauen wir uns die Methoden und Parameter an, die im obigen Code angegeben sind:

1. detectMultiScale():

Die Methode detectMultiScale() wird verwendet, um Gesichter in verschiedenen Größen im Eingabebild zu erkennen.

1. grey_image:

Der erste Parameter in dieser Methode heißt grey_image und ist das Graustufenbild, das wir zuvor erstellt haben.

1. scaleFactor:

Mit diesem Parameter wird die Größe des Eingangsbildes verkleinert, damit der Algorithmus größere Gesichter leichter erkennen kann. In diesem Fall haben wir einen Skalierungsfaktor von 1,1 angegeben, was bedeutet, dass wir das Bild um 10% verkleinern wollen.

1. minNeighbors:

Der Kaskadenklassifikator wendet ein gleitendes Fenster auf das Bild an, um Gesichter darin zu erkennen. Du kannst dir diese Fenster als Rechtecke vorstellen. 

Anfänglich wird der Klassifikator eine große Anzahl von falsch-positiven Ergebnissen erfassen. Diese werden mit dem Parameter minNeighbors eliminiert, der die Anzahl der benachbarten Rechtecke angibt, die identifiziert werden müssen, damit ein Objekt als gültig erkannt wird.

Zusammenfassend lässt sich sagen, dass ein kleiner Wert wie 0 oder 1 für diesen Parameter zu einer hohen Anzahl von Falschmeldungen führen würde, während eine große Zahl dazu führen könnte, dass viele echte Meldungen verloren gehen.

Die Kunst besteht darin, einen Kompromiss zu finden, der es uns ermöglicht, Falschmeldungen zu eliminieren und gleichzeitig die richtigen Meldungen zu erkennen.

1. minSize:

Der Parameter minSize schließlich legt die Mindestgröße des zu erfassenden Objekts fest. Das Modell ignoriert Flächen, die kleiner als die angegebene Mindestgröße sind.

Schritt 6: Zeichnen einer Bounding Box

Nachdem das Modell nun die Gesichter im Bild erkannt hat, lassen wir die folgenden Codezeilen laufen, um einen Begrenzungsrahmen um diese Gesichter zu erstellen:

for (x, y, w, h) in face:
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 4)

Die Variable face ist ein Array mit vier Werten: die x- und y-Achse, in der die Gesichter erkannt wurden, sowie ihre Breite und Höhe. Der obige Code iteriert über die identifizierten Flächen und erstellt einen Begrenzungsrahmen, der sich über diese Maße erstreckt.

Der Parameter 0,255,0 steht für die Farbe des Begrenzungsrahmens, die grün ist, und 4 gibt seine Dicke an.

Schritt 7: Das Bild anzeigen

Um das Bild mit den erkannten Gesichtern anzuzeigen, müssen wir das Bild zunächst vom BGR-Format in RGB umwandeln:

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

Nun wollen wir die Matplotlib-Bibliothek verwenden, um das Bild anzuzeigen:

import matplotlib.pyplot as plt



plt.figure(figsize=(20,10))
plt.imshow(img_rgb)
plt.axis('off')

Der obige Code sollte die folgende Ausgabe erzeugen: 

Toll!

Das Modell hat das menschliche Gesicht in diesem Bild erfolgreich erkannt und eine Bounding Box um es herum erstellt. 

Gesichtserkennung in Echtzeit mit OpenCV

Nachdem wir die Gesichtserkennung mit OpenCV erfolgreich an einem statischen Bild durchgeführt haben, wollen wir nun sehen, wie wir das Gleiche an einem Live-Video-Stream machen können. 

Schritt 1: Voraussetzungen

Als Erstes importieren wir die OpenCV-Bibliothek und laden das Haar-Cascade-Modell, wie wir es im vorherigen Abschnitt getan haben. Du kannst diesen Codeblock überspringen, wenn du ihn schon einmal ausgeführt hast:

import cv2

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Schritt 2: Zugriff auf die Webcam

Jetzt müssen wir auf die Kamera unseres Geräts zugreifen, um einen Live-Stream von Videodaten zu lesen. Das kannst du mit dem folgenden Code tun:

video_capture = cv2.VideoCapture(0)

Beachte, dass wir den Parameter 0 an die Funktion VideoCapture() übergeben haben. Damit wird OpenCV angewiesen, die Standardkamera auf unserem Gerät zu verwenden. Wenn du mehrere Kameras an dein Gerät angeschlossen hast, kannst du diesen Parameterwert entsprechend ändern.

Schritt 3: Gesichter im Videostrom erkennen

Jetzt wollen wir eine Funktion erstellen, die Gesichter im Videostream erkennt und einen Begrenzungsrahmen um sie herum zeichnet:

def detect_bounding_box(vid):
    gray_image = cv2.cvtColor(vid, cv2.COLOR_BGR2GRAY)
    faces = face_classifier.detectMultiScale(gray_image, 1.1, 5, minSize=(40, 40))
    for (x, y, w, h) in faces:
        cv2.rectangle(vid, (x, y), (x + w, y + h), (0, 255, 0), 4)
    return faces

Die Funktion detect_bounding_box nimmt das Videobild als Eingabe.

In dieser Funktion verwenden wir die gleichen Codes wie zuvor, um das Bild in Graustufen umzuwandeln, bevor wir die Gesichtserkennung durchführen.

Dann erkennen wir auch das Gesicht in diesem Bild, indem wir die gleichen Parameterwerte für scaleFactor, minNeighbors und minSize verwenden wie zuvor.

Zum Schluss zeichnen wir einen grünen Begrenzungsrahmen mit der Dicke 4 um den Rahmen.

Schritt 4: Erstellen einer Schleife für die Gesichtserkennung in Echtzeit

Jetzt müssen wir eine unendliche while-Schleife erstellen, die das Videobild von unserer Webcam aufnimmt und die Gesichtserkennungsfunktion darauf anwendet:

while True:

    result, video_frame = video_capture.read()  # read frames from the video
    if result is False:
        break  # terminate the loop if the frame is not read successfully

    faces = detect_bounding_box(
        video_frame
    )  # apply the function we created to the video frame

    cv2.imshow(
        "My Face Detection Project", video_frame
    )  # display the processed frame in a window named "My Face Detection Project"

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

video_capture.release()
cv2.destroyAllWindows()

Nachdem du den obigen Code ausgeführt hast, sollte ein Fenster namens My Face Detection Project auf dem Bildschirm erscheinen:

Der Algorithmus sollte dein Gesicht verfolgen und eine grüne Bounding Box um es herum erstellen, unabhängig davon, wo du dich innerhalb des Rahmens bewegst.

In dem Bild oben erkennt das Model mein Gesicht und mein Bild auf dem Führerschein, den ich hochhalte.

Du kannst die Wirksamkeit dieses Modells auch testen, indem du mehrere Bilder hochhältst oder verschiedene Personen in unterschiedlichen Winkeln hinter der Kamera stehen lässt. Das Modell sollte in der Lage sein, alle menschlichen Gesichter vor verschiedenen Hintergründen oder bei unterschiedlichen Lichtverhältnissen zu erkennen.

Wenn du das Programm verlassen möchtest, kannst du die Taste "q" auf deiner Tastatur drücken, um aus der Schleife auszusteigen.

Gesichtserkennung mit OpenCV - Die nächsten Schritte

Nachdem du nun gelernt hast, mit der OpenCV-Bibliothek menschliche Gesichter sowohl in Bildern als auch in Echtzeitvideos zu erkennen, folgen nun einige Schritte, mit denen du dein Wissen auf die nächste Stufe bringen kannst:

Erstelle dein eigenes Projekt

Du kannst den Code in diesem Tutorial als Ausgangspunkt für dein eigenes Projekt zur Gesichtserkennung verwenden.

Eine Möglichkeit, dieses Projekt zu erweitern, besteht darin, menschliche Gesichter in verschiedenen Arten von Eingabedaten zu erkennen, z. B. in PDF-Dateien oder Überwachungsbildern. Du kannst sogar eine eigene Sicherheitskamera einrichten und die Daten, die sie aufnimmt, in Echtzeit zur Gesichtserkennung nutzen.

Außerdem kannst du ein Gesichtserkennungsmodell für große Datensätze erstellen oder noch einen Schritt weiter gehen und z. B. erkennen, ob eine Person in einem Bilddatensatz eine Maske trägt.

Die Datensätze "Face Detection in Images" und "Face Mask Detection" auf Kaggle sind gute Ausgangspunkte für ein Portfolio-Projekt in diesem Bereich.

Ein Gesichtserkennungsmodell erstellen

Während die Gesichtserkennung dazu dient, ein menschliches Gesicht im visuellen Input zu erkennen, geht die Gesichtserkennung einen Schritt weiter. Diese Technologie wird verwendet, um die Identität einer Person zu überprüfen, indem ihr Gesicht mit einer bestehenden Datenbank abgeglichen wird.

Du kannst versuchen, ein Gesichtserkennungsmodell zu erstellen, das ein bestimmtes Gesicht (vielleicht sogar deines) in einer Menge von anderen Menschen identifiziert. 

Diese Aufgabe ist etwas anspruchsvoller als die Gesichtserkennung, da das Modell an vielen Datenproben trainiert werden muss, bevor es zwischen Personen unterscheiden kann.

Bevor du ein Gesichtserkennungsmodell erstellst, musst du eventuell auch Vorverarbeitungstechniken wie Rauschunterdrückung und Bildtransformation durchführen. 

Wenn dir diese Konzepte fremd vorkommen, mach dir keine Sorgen! In unserem Kurs Bildverarbeitung in Python kannst du alles über Bildverarbeitung lernen.

Fachwissen erwerben

Die Bild- und Videoverarbeitung findet in vielen Bereichen Anwendung, z. B. in der Sicherheitsbranche, im Einzelhandel, im Gesundheitswesen und in der Produktion.

Wenn du einen Job als Bildverarbeitungsspezialist/in bekommen möchtest, musst du zunächst die Arten von Daten verstehen, die in diesen Branchen verwendet werden. Fachwissen erleichtert dir das Beschriften, Umwandeln und Trainieren von Datensätzen in realen Szenarien.

Um loszulegen, kannst du unseren Kurs Biomedizinische Bildanalyse in Python besuchen. In diesem Programm lernst du, wie du CT-Bilder verarbeitest, eine MRT-Zeitreihe des Herzens segmentierst und feststellst, ob die Alzheimer-Krankheit die Gehirnstruktur verändert. 

Diese Konzepte vermitteln dir die nötigen Fähigkeiten, um in den Bereich der biomedizinischen Bildgebung einzusteigen.