deepface
v0.0.93
DeepFace ist ein leichtes Framework zur Gesichtserkennung und Analyse von Gesichtsattributen (Alter, Geschlecht, Emotionen und Rasse) für Python. Es handelt sich um ein hybrides Gesichtserkennungs-Framework , das modernste Modelle umfasst: VGG-Face , FaceNet , OpenFace , DeepFace , DeepID , ArcFace , Dlib , SFace und GhostFaceNet .
Experiments zeigen, dass Menschen bei Gesichtserkennungsaufgaben eine Genauigkeit von 97,53 % haben, während diese Modelle diese Genauigkeitsstufe bereits erreicht und überschritten haben.
Der einfachste Weg, Deepface zu installieren, besteht darin, es von PyPI herunterzuladen. Es werden auch die Bibliothek selbst und ihre Voraussetzungen installiert.
$ pip install deepfaceAlternativ können Sie Deepface auch aus dem Quellcode installieren. Der Quellcode enthält möglicherweise neue Funktionen, die noch nicht in der Pip-Version veröffentlicht wurden.
$ git clone https://github.com/serengil/deepface.git
$ cd deepface
$ pip install -e .Sobald Sie die Bibliothek installiert haben, können Sie sie importieren und ihre Funktionen nutzen.
from deepface import DeepFace Eine moderne Pipeline zur Gesichtserkennung – Demo
Eine moderne Gesichtserkennungspipeline besteht aus fünf gemeinsamen Phasen: Erkennen, Ausrichten, Normalisieren, Darstellen und Überprüfen. Während DeepFace alle diese gängigen Schritte im Hintergrund abwickelt, müssen Sie sich kein tiefgreifendes Wissen über alle Prozesse dahinter aneignen. Sie können die Verifizierungs-, Such- oder Analysefunktion einfach mit einer einzigen Codezeile aufrufen.
Gesichtsverifizierung – Demo
Diese Funktion überprüft Gesichtspaare auf dieselbe Person oder verschiedene Personen. Es erwartet genaue Bildpfade als Eingaben. Die Übergabe von Numpy- oder Base64-codierten Bildern ist ebenfalls willkommen. Anschließend wird ein Wörterbuch zurückgegeben, und Sie sollten nur den verifizierten Schlüssel überprüfen.
result = DeepFace . verify (
img1_path = "img1.jpg" ,
img2_path = "img2.jpg" ,
) Gesichtserkennung – Demo
Für die Gesichtserkennung ist eine mehrfache Gesichtsüberprüfung erforderlich. Hierfür verfügt Deepface über eine sofort einsatzbereite Suchfunktion, um diese Aktion durchzuführen. Es wird nach der Identität des Eingabebildes im Datenbankpfad gesucht und eine Liste der Pandas-Datenrahmen als Ausgabe zurückgegeben. In der Zwischenzeit werden Gesichtseinbettungen der Gesichtsdatenbank in einer Pickle-Datei gespeichert, um beim nächsten Mal schneller durchsucht zu werden. Das Ergebnis wird die Größe der Gesichter sein, die im Quellbild erscheinen. Außerdem können Zielbilder in der Datenbank auch viele Gesichter haben.
dfs = DeepFace . find (
img_path = "img1.jpg" ,
db_path = "C:/workspace/my_db" ,
) Einbettungen – Demo
Gesichtserkennungsmodelle stellen Gesichtsbilder grundsätzlich als mehrdimensionale Vektoren dar. Manchmal benötigen Sie diese Einbettungsvektoren direkt. DeepFace verfügt über eine spezielle Darstellungsfunktion. Die Represent-Funktion gibt eine Liste von Einbettungen zurück. Das Ergebnis wird die Größe der Gesichter sein, die im Bildpfad erscheinen.
embedding_objs = DeepFace . represent (
img_path = "img.jpg"
)Diese Funktion gibt ein Array als Einbettung zurück. Die Größe des Einbettungsarrays würde je nach Modellname unterschiedlich sein. Beispielsweise ist VGG-Face das Standardmodell und stellt Gesichtsbilder als 4096-dimensionale Vektoren dar.
for embedding_obj in embedding_objs :
embedding = embedding_obj [ "embedding" ]
assert isinstance ( embedding , list )
assert (
model_name == "VGG-Face"
and len ( embedding ) == 4096
)Auch hier ist die Einbettung mit 4096 Slots horizontal dargestellt. Jeder Schlitz entspricht einem Dimensionswert im Einbettungsvektor und der Dimensionswert wird in der Farbleiste rechts erläutert. Ähnlich wie bei 2D-Barcodes werden bei der vertikalen Bemaßung keine Informationen in der Abbildung gespeichert.
Gesichtserkennungsmodelle – Demo
DeepFace ist ein hybrides Gesichtserkennungspaket. Es umfasst derzeit viele hochmoderne Gesichtserkennungsmodelle: VGG-Face , FaceNet , OpenFace , DeepFace , DeepID , ArcFace , Dlib , SFace und GhostFaceNet . Die Standardkonfiguration verwendet das VGG-Face-Modell.
models = [
"VGG-Face" ,
"Facenet" ,
"Facenet512" ,
"OpenFace" ,
"DeepFace" ,
"DeepID" ,
"ArcFace" ,
"Dlib" ,
"SFace" ,
"GhostFaceNet" ,
]
#face verification
result = DeepFace . verify (
img1_path = "img1.jpg" ,
img2_path = "img2.jpg" ,
model_name = models [ 0 ],
)
#face recognition
dfs = DeepFace . find (
img_path = "img1.jpg" ,
db_path = "C:/workspace/my_db" ,
model_name = models [ 1 ],
)
#embeddings
embedding_objs = DeepFace . represent (
img_path = "img.jpg" ,
model_name = models [ 2 ],
) FaceNet, VGG-Face, ArcFace und Dlib sind experimentell überdurchschnittlich erfolgreich – weitere Einzelheiten finden Sie unter BENCHMARKS . Die gemessenen Ergebnisse verschiedener Modelle in DeepFace und die gemeldeten Ergebnisse aus ihren Originalstudien finden Sie in der folgenden Tabelle.
| Modell | Gemessene Punktzahl | Deklarierte Punktzahl |
|---|---|---|
| Facenet512 | 98,4 % | 99,6 % |
| Menschen | 97,5 % | 97,5 % |
| Facenet | 97,4 % | 99,2 % |
| Dlib | 96,8 % | 99,3 % |
| VGG-Gesicht | 96,7 % | 98,9 % |
| ArcFace | 96,7 % | 99,5 % |
| GhostFaceNet | 93,3 % | 99,7 % |
| SGesicht | 93,0 % | 99,5 % |
| OpenFace | 78,7 % | 92,9 % |
| DeepFace | 69,0 % | 97,3 % |
| DeepID | 66,5 % | 97,4 % |
Die Durchführung von Experimenten mit diesen Modellen innerhalb von DeepFace kann aufgrund der Verwendung unterschiedlicher Erkennungs- oder Normalisierungstechniken Unterschiede im Vergleich zu den ursprünglichen Studien aufdecken. Darüber hinaus wurden einige Modelle nur mit Rückgrat und ohne vortrainierte Gewichte auf den Markt gebracht. Daher verwenden wir deren Neuimplementierungen anstelle der ursprünglich vorab trainierten Gewichte.
Ähnlichkeit – Demo
Gesichtserkennungsmodelle sind reguläre Faltungs-Neuronale Netze und für die Darstellung von Gesichtern als Vektoren verantwortlich. Wir gehen davon aus, dass ein Gesichtspaar derselben Person ähnlicher sein sollte als ein Gesichtspaar verschiedener Personen.
Die Ähnlichkeit könnte anhand verschiedener Metriken wie Kosinusähnlichkeit, euklidischer Distanz oder L2-normalisierter euklidischer Größe berechnet werden. Die Standardkonfiguration verwendet Kosinusähnlichkeit. Experimenten zufolge ist keine Distanzmetrik besser als die andere.
metrics = [ "cosine" , "euclidean" , "euclidean_l2" ]
#face verification
result = DeepFace . verify (
img1_path = "img1.jpg" ,
img2_path = "img2.jpg" ,
distance_metric = metrics [ 1 ],
)
#face recognition
dfs = DeepFace . find (
img_path = "img1.jpg" ,
db_path = "C:/workspace/my_db" ,
distance_metric = metrics [ 2 ],
) Gesichtsattributanalyse – Demo
DeepFace verfügt außerdem über ein leistungsstarkes Modul zur Analyse von Gesichtsattributen, einschließlich age , gender , facial expression (einschließlich wütend, Angst, neutral, traurig, Ekel, glücklich und Überraschung) und race (einschließlich Asiaten, Weiße, Nahöstliche, Inder, Latinos und Schwarze). Vorhersagen. Das Ergebnis wird die Größe der Gesichter sein, die im Quellbild erscheinen.
objs = DeepFace . analyze (
img_path = "img4.jpg" ,
actions = [ 'age' , 'gender' , 'race' , 'emotion' ],
)Altersmodell erhielt ± 4,65 MAE; Das Geschlechtermodell erreichte eine Genauigkeit von 97,44 %, eine Präzision von 96,29 % und eine Erinnerung von 95,05 %, wie im Tutorial erwähnt.
Gesichtserkennung und -ausrichtung – Demo
Gesichtserkennung und -ausrichtung sind wichtige frühe Phasen einer modernen Gesichtserkennungspipeline. Experimente zeigen, dass die Erkennung die Genauigkeit der Gesichtserkennung um bis zu 42 % erhöht, während die Ausrichtung sie um bis zu 6 % erhöht. OpenCV , Ssd , Dlib , MtCnn , Faster MtCnn , RetinaFace , MediaPipe , Yolo , YuNet und CenterFace -Detektoren sind in Deepface verpackt.
Alle Deepface-Funktionen akzeptieren optionale Detektor-Backends und richten Eingabeargumente aus. Mit diesen Argumenten können Sie zwischen diesen Detektoren und Ausrichtungsmodi wechseln. OpenCV ist der Standarddetektor und die Ausrichtung ist standardmäßig aktiviert.
backends = [
'opencv' ,
'ssd' ,
'dlib' ,
'mtcnn' ,
'fastmtcnn' ,
'retinaface' ,
'mediapipe' ,
'yolov8' ,
'yunet' ,
'centerface' ,
]
alignment_modes = [ True , False ]
#face verification
obj = DeepFace . verify (
img1_path = "img1.jpg" ,
img2_path = "img2.jpg" ,
detector_backend = backends [ 0 ],
align = alignment_modes [ 0 ],
)
#face recognition
dfs = DeepFace . find (
img_path = "img.jpg" ,
db_path = "my_db" ,
detector_backend = backends [ 1 ],
align = alignment_modes [ 0 ],
)
#embeddings
embedding_objs = DeepFace . represent (
img_path = "img.jpg" ,
detector_backend = backends [ 2 ],
align = alignment_modes [ 0 ],
)
#facial analysis
demographies = DeepFace . analyze (
img_path = "img4.jpg" ,
detector_backend = backends [ 3 ],
align = alignment_modes [ 0 ],
)
#face detection and alignment
face_objs = DeepFace . extract_faces (
img_path = "img.jpg" ,
detector_backend = backends [ 4 ],
align = alignment_modes [ 0 ],
)Gesichtserkennungsmodelle sind eigentlich CNN-Modelle und erwarten Eingaben in Standardgröße. Daher ist vor der Darstellung eine Größenänderung erforderlich. Um Verformungen zu vermeiden, fügt Deepface nach der Erkennung und Ausrichtung schwarze Füllpixel entsprechend dem Zielgrößenargument hinzu.
RetinaFace und MtCnn scheinen in den Erkennungs- und Ausrichtungsphasen überdurchschnittliche Leistungen zu erbringen, sind jedoch viel langsamer. Wenn die Geschwindigkeit Ihrer Pipeline wichtiger ist, sollten Sie opencv oder ssd verwenden. Wenn Sie andererseits die Genauigkeit berücksichtigen, sollten Sie Retinaface oder MTCNN verwenden.
Die Leistung von RetinaFace ist selbst in der Menge sehr zufriedenstellend, wie in der folgenden Abbildung zu sehen ist. Darüber hinaus verfügt es über eine unglaubliche Leistung bei der Erkennung von Gesichtspunkten. Hervorgehobene rote Punkte zeigen einige Gesichtsmerkmale wie Augen, Nase und Mund. Aus diesem Grund ist auch der Ausrichtungswert von RetinaFace hoch.
Die Yellow Angels – Frauen-Volleyballteam von Fenerbahce
Mehr über RetinaFace erfahren Sie in diesem Repo.
Echtzeitanalyse – Demo
Sie können Deepface auch für Echtzeitvideos ausführen. Die Stream-Funktion greift auf Ihre Webcam zu und wendet sowohl Gesichtserkennung als auch Gesichtsattributanalyse an. Die Funktion beginnt mit der Analyse eines Bildes, wenn sie ein Gesicht 5 Bilder nacheinander fokussieren kann. Dann werden die Ergebnisse 5 Sekunden lang angezeigt.
DeepFace . stream ( db_path = "C:/User/Sefik/Desktop/database" )Obwohl die Gesichtserkennung auf One-Shot-Lernen basiert, können Sie auch mehrere Gesichtsbilder einer Person verwenden. Sie sollten Ihre Verzeichnisstruktur wie unten dargestellt neu anordnen.
user
├── database
│ ├── Alice
│ │ ├── Alice1.jpg
│ │ ├── Alice2.jpg
│ ├── Bob
│ │ ├── Bob.jpg React UI – Demo part-i , Demo part-ii
Wenn Sie Gesichtsüberprüfungsaufgaben direkt über Ihren Browser ausführen möchten, ist deepface-react-ui ein separates Repository, das mit ReactJS abhängig von der Deepface-API erstellt wird.
Face Anti Spoofing – Demo
DeepFace enthält außerdem ein Anti-Spoofing-Analysemodul, um zu erkennen, ob ein bestimmtes Bild echt oder gefälscht ist. Um diese Funktion zu aktivieren, setzen Sie das Argument anti_spoofing in allen DeepFace-Aufgaben auf True.
# anti spoofing test in face detection
face_objs = DeepFace . extract_faces (
img_path = "dataset/img1.jpg" ,
anti_spoofing = True
)
assert all ( face_obj [ "is_real" ] is True for face_obj in face_objs )
# anti spoofing test in real time analysis
DeepFace . stream (
db_path = "C:/User/Sefik/Desktop/database" ,
anti_spoofing = True
) API – Demo
DeepFace stellt auch eine API bereit – weitere Details finden Sie api folder . Mit dem folgenden Befehl können Sie den Deepface-Quellcode klonen und die API ausführen. Es wird den Gunicorn-Server verwenden, um einen Ruhedienst einzurichten. Auf diese Weise können Sie Deepface von einem externen System wie einer mobilen App oder dem Web aus aufrufen.
cd scripts
./service.sh Gesichtserkennung, Gesichtsattributanalyse und Vektordarstellungsfunktionen werden in der API abgedeckt. Es wird erwartet, dass Sie diese Funktionen als HTTP-Post-Methoden aufrufen. Standard-Dienstendpunkte sind http://localhost:5005/verify für die Gesichtserkennung, http://localhost:5005/analyze für die Analyse von Gesichtsattributen und http://localhost:5005/represent für die Vektordarstellung. Die API akzeptiert Bilder als Datei-Uploads (über Formulardaten) oder als exakte Bildpfade, URLs oder Base64-codierte Zeichenfolgen (entweder über JSON oder Formulardaten) und bietet vielseitige Optionen für unterschiedliche Kundenanforderungen. Hier finden Sie ein Postman-Projekt, um herauszufinden, wie diese Methoden aufgerufen werden sollten.
Dockerisierter Dienst – Demo
Der folgende Befehlssatz stellt Deepface auf localhost:5005 über Docker bereit. Anschließend können Sie Deepface-Dienste wie Verifizierung, Analyse und Darstellung nutzen. Wenn Sie das Image anstelle eines vorgefertigten Images vom Docker Hub selbst erstellen möchten, ist Dockerfile im Stammordner des Projekts verfügbar.
# docker build -t serengil/deepface . # build docker image from Dockerfile
docker pull serengil/deepface # use pre-built docker image from docker hub
docker run -p 5005:5000 serengil/deepface Befehlszeilenschnittstelle – Demo
DeepFace verfügt außerdem über eine Befehlszeilenschnittstelle. Sie können wie unten gezeigt über die Befehlszeile auf die Funktionen zugreifen. Der Befehl deepface erwartet den Funktionsnamen als 1. Argument und danach Funktionsargumente.
# face verification
$ deepface verify -img1_path tests/dataset/img1.jpg -img2_path tests/dataset/img2.jpg
# facial analysis
$ deepface analyze -img_path tests/dataset/img1.jpgSie können diese Befehle auch ausführen, wenn Sie Deepface mit Docker ausführen. Bitte folgen Sie den Anweisungen im Shell-Skript.
Gesichtserkennung im großen Maßstab – Playlist
Wenn Ihre Aufgabe eine Gesichtserkennung in großen Datensätzen erfordert, sollten Sie DeepFace mit einem Vektorindex oder einer Vektordatenbank kombinieren. Dieses Setup führt eine ungefähre Suche nach dem nächsten Nachbarn anstelle einer genauen Suche durch, sodass Sie ein Gesicht in einer Datenbank mit Milliarden von Einträgen innerhalb von Millisekunden identifizieren können. Zu den gängigen Vektorindexlösungen gehören Annoy, Faiss, Voyager, NMSLIB und ElasticSearch. Beliebte Optionen für Vektordatenbanken sind Postgres mit seiner pgvector-Erweiterung und RediSearch.
Umgekehrt, wenn Ihre Aufgabe die Gesichtserkennung in kleinen bis mittelgroßen Datenbanken umfasst, können Sie relationale Datenbanken wie Postgres oder SQLite oder NoSQL-Datenbanken wie Mongo, Redis oder Cassandra verwenden, um eine genaue Suche nach dem nächsten Nachbarn durchzuführen.
Pull-Anfragen sind herzlich willkommen! Wenn Sie vorhaben, einen großen Patch beizusteuern, erstellen Sie bitte zuerst ein Problem, um alle Vorabfragen oder Designentscheidungen zu klären.
Bevor Sie eine PR erstellen, sollten Sie die Komponententests und das Linting lokal ausführen, indem Sie den Befehl make test && make lint ausführen. Sobald eine PR gesendet wird, wird der GitHub-Testworkflow automatisch ausgeführt und Unit-Test- und Linting-Jobs sind vor der Genehmigung in GitHub-Aktionen verfügbar.
Es gibt viele Möglichkeiten, ein Projekt zu unterstützen – starring️ das GitHub-Repo ist nur eine davon
Wenn Ihnen diese Arbeit gefällt, können Sie sie auf Patreon, GitHub Sponsors oder Buy Me a Coffee finanziell unterstützen.
Außerdem wird das Logo Ihres Unternehmens in der README-Datei auf GitHub und PyPI angezeigt, wenn Sie Sponsor der Stufen Gold, Silber oder Bronze werden.
Bitte zitieren Sie Deepface in Ihren Veröffentlichungen, wenn es Ihrer Forschung hilft – weitere Einzelheiten finden Sie CITATIONS . Hier sind die BibTex-Einträge:
Wenn Sie Deepface in Ihrer Forschung zur Gesichtserkennung oder Gesichtserkennung verwenden, zitieren Sie bitte diese Veröffentlichungen:
@article { serengil2024lightface ,
title = { A Benchmark of Facial Recognition Pipelines and Co-Usability Performances of Modules } ,
author = { Serengil, Sefik and Ozpinar, Alper } ,
journal = { Journal of Information Technologies } ,
volume = { 17 } ,
number = { 2 } ,
pages = { 95-107 } ,
year = { 2024 } ,
doi = { 10.17671/gazibtd.1399077 } ,
url = { https://dergipark.org.tr/en/pub/gazibtd/issue/84331/1399077 } ,
publisher = { Gazi University }
} @inproceedings { serengil2020lightface ,
title = { LightFace: A Hybrid Deep Face Recognition Framework } ,
author = { Serengil, Sefik Ilkin and Ozpinar, Alper } ,
booktitle = { 2020 Innovations in Intelligent Systems and Applications Conference (ASYU) } ,
pages = { 23-27 } ,
year = { 2020 } ,
doi = { 10.1109/ASYU50717.2020.9259802 } ,
url = { https://ieeexplore.ieee.org/document/9259802 } ,
organization = { IEEE }
}Wenn Sie Deepface hingegen in Ihrer Forschung für die Analyse von Gesichtsattributen verwenden, z. B. für Aufgaben zur Vorhersage von Alter, Geschlecht, Emotionen oder ethnischer Zugehörigkeit, zitieren Sie bitte diese Veröffentlichung.
@inproceedings { serengil2021lightface ,
title = { HyperExtended LightFace: A Facial Attribute Analysis Framework } ,
author = { Serengil, Sefik Ilkin and Ozpinar, Alper } ,
booktitle = { 2021 International Conference on Engineering and Emerging Technologies (ICEET) } ,
pages = { 1-4 } ,
year = { 2021 } ,
doi = { 10.1109/ICEET53442.2021.9659697 } ,
url = { https://ieeexplore.ieee.org/document/9659697 } ,
organization = { IEEE }
} Wenn Sie Deepface in Ihren GitHub-Projekten verwenden, fügen Sie deepface bitte in der requirements.txt hinzu.
DeepFace ist unter der MIT-Lizenz lizenziert – weitere Einzelheiten finden Sie unter LICENSE .
DeepFace umfasst einige externe Gesichtserkennungsmodelle: VGG-Face, Facenet (sowohl 128d als auch 512d), OpenFace, DeepFace, DeepID, ArcFace, Dlib, SFace und GhostFaceNet. Darüber hinaus wurden Modelle zu Alter, Geschlecht und Rasse/ethnischer Zugehörigkeit auf der Grundlage von VGG-Face mit Transferlernen trainiert. In ähnlicher Weise umschließt DeepFace viele Gesichtsdetektoren: OpenCv, Ssd, Dlib, MtCnn, Fast MtCnn, RetinaFace, MediaPipe, YuNet, Yolo und CenterFace. Schließlich verwendet DeepFace optional Gesichts-Anti-Spoofing, um festzustellen, ob die angegebenen Bilder echt oder gefälscht sind. Lizenztypen werden vererbt, wenn Sie beabsichtigen, diese Modelle zu verwenden. Bitte überprüfen Sie die Lizenztypen dieser Modelle für Produktionszwecke.
Das DeepFace-Logo wurde von Adrien Coquet erstellt und ist unter der Creative Commons: By Attribution 3.0-Lizenz lizenziert.
