DeepFace : reconnais un visage en 5 lignes de Python

Ton téléphone se déverrouille rien qu'en te regardant. Une caméra estime ton âge avant de te laisser acheter une bière. La reconnaissance faciale n'est plus un gadget de film d'espionnage : c'est une brique logicielle que n'importe qui peut brancher en Python. DeepFace, la bibliothèque de référence du domaine, met ces modèles à portée de main — littéralement en cinq lignes.

DeepFace encapsule une dizaine de modèles de vision (Facenet, VGG-Face, ArcFace, etc.) derrière une API unique. Tu lui donnes deux photos, il te dit si c'est la même personne. Tu lui donnes une photo et un dossier, il retrouve à qui elle appartient. Tu lui donnes un portrait, il estime l'âge, le genre et l'émotion. Aucun entraînement à faire : les modèles sont pré-entraînés et téléchargés automatiquement au premier appel.

Dans ce tutoriel, on va faire les trois : vérifier une identité, chercher dans une base de visages et analyser un portrait. Le tout avec du code exécutable, sans clé API, et sans envoyer tes photos dans un cloud quelconque — tout tourne en local.

1. Installer DeepFace et préparer ses photos

L'installation tient en une commande. DeepFace embarque TensorFlow comme moteur par défaut : c'est un gros téléchargement (quelques centaines de mégaoctets), mais il n'est payé qu'une fois. Prépare ensuite deux ou trois photos de visage bien éclairés, de face de préférence, et range-les dans un dossier dédié.

bash

pip install deepface

Premier réflexe : vérifier que l'import fonctionne et que la version est récente.

python

from deepface import DeepFace

print(DeepFace.__version__)

2. Vérifier que deux photos montrent la même personne

verify() compare deux images et répond à une question simple : même personne, oui ou non ? Sous le capot, le modèle extrait une empreinte numérique du visage (un vecteur de quelques centaines de nombres) puis mesure la distance entre les deux. Plus la distance est petite, plus les visages se ressemblent. Sous un certain seuil, DeepFace tranche pour un « même personne ».

python

from deepface import DeepFace

resultat = DeepFace.verify(
    img1_path="alice.jpg",           # photo de référence
    img2_path="alice_recente.jpg",   # photo à comparer
    model_name="Facenet",
)

print("Même personne :", resultat["verified"])
print("Distance :", round(resultat["distance"], 3))

La sortie est un dictionnaire : verified vaut True ou False, distance est un flottant, et threshold donne le seuil retenu. Si tes deux photos sont très différentes (barbe fraîche, lunettes, angle), change de modèle avec model_name="ArcFace" ou model_name="VGG-Face" et compare les distances.

3. Retrouver une personne dans un dossier de portraits

find() fait le travail inverse : il prend une photo inconnue, la compare à tout un dossier de portraits, et renvoie les visages les plus proches, triés par similarité. Organise ta base comme ceci — un sous-dossier par personne, nommé d'après elle :

plaintext

portraits/
├── alice/
│   └── alice_1.jpg
├── bob/
│   └── bob_1.jpg
└── chloe/
    └── chloe_1.jpg

python

resultats = DeepFace.find(
    img_path="inconnu.jpg",   # la photo à identifier
    db_path="portraits/",     # ta base de visages
    model_name="Facenet",
)

# find() renvoie une liste : un DataFrame par photo trouvée
for df in resultats:
    if not df.empty:
        meilleur = df.iloc[0]
        print("Identité probable :", meilleur["identity"])
        print("Distance :", round(meilleur["distance"], 3))

Chaque DataFrame contient les chemins des portraits, classés du plus proche au plus lointain, avec leur distance. La première ligne est le meilleur candidat. À toi de poser un seuil — par exemple 0.6 — en dessous duquel tu acceptes l'identification, et de traiter le cas où rien ne descend sous ce seuil.

4. Estimer l'âge, le genre et l'émotion d'un visage

analyze() enchaîne plusieurs petits modèles de classification en une seule passe : âge, genre, émotion dominante (colère, joie, tristesse, surprise…) et origine ethnique. Le résultat est une liste, avec une entrée par visage détecté — pratique quand une photo contient plusieurs personnes.

python

analyses = DeepFace.analyze(
    img_path="photo.jpg",
    actions=["age", "gender", "emotion"],
)

for a in analyses:  # une entrée par visage détecté
    print("Âge estimé :", a["age"])
    print("Genre dominant :", a["dominant_gender"])
    print("Émotion dominante :", a["dominant_emotion"])

Ces prédictions restent des estimations, pas des vérités : l'âge a une marge d'erreur de quelques années, et l'émotion se lit sur une expression figée. Garde ça en tête avant d'utiliser le résultat pour autre chose qu'un prototype ou une démo.

5. Reconnaître en direct depuis la webcam

DeepFace a une carte bonus : stream() ouvre ta webcam et identifie en temps réel les visages qui passent devant, en les comparant à ta base. C'est la fonction qui impressionne en démo — et elle ne demande qu'une ligne.

python

DeepFace.stream(db_path="portraits/")

Appuie sur la touche q pour quitter. Le flux s'appuie sur OpenCV, installé automatiquement avec DeepFace.

Conclusion

En une poignée de lignes, tu as vérifié une identité, retrouvé une personne dans une base et lu des attributs sur un visage — le tout en local, sans API payante. DeepFace est le couteau suisse de la vision faciale : moins fin qu'un modèle entraîné sur mesure, mais imbattable pour prototyper vite.

De là, tout est possible : verrouiller un accès par badge visuel, trier automatiquement tes albums photo par personne, ou construire un miroir connecté qui te salue par ton prénom. La suite logique ? Coupler DeepFace à un détecteur de visages comme MediaPipe ou YOLO pour suivre plusieurs personnes dans une vidéo — mais ça, c'est un autre tutoriel.

Auteur

Krugz

Développeur fullstack

Développeur fullstack qui tente, tant bien que mal, de suivre l'actualité de l'IA au milieu d'une marée d'informations imbuvables et des milliers d'outils et de modèles qui sortent chaque jour.