Reconnaissance Faciale

La reconnaissance faciale est une tâche de vision par ordinateur consistant à identifier ou vérifier l’identité d’individus à partir d’images de leurs visages. Elle combine la détection de traits caractéristiques avec des techniques d’apprentissage profond afin de produire des représentations discriminantes robustes aux variations d’angle, d’éclairage ou d’expression. Dans cet exemple, nous utilisons le dataset Labeled Faces in the Wild (LFW), largement exploité comme référence en recherche pour l’évaluation des algorithmes de reconnaissance faciale. Les images sont prétraitées et normalisées, puis un réseau de neurones convolutifs (CNN) est entraîné pour apprendre à classer les visages en fonction de leur identité. Cette mise en pratique illustre les étapes essentielles de la reconnaissance faciale supervisée : préparation des données, conception et entraînement d’un modèle CNN, puis évaluation et visualisation des prédictions sur des exemples réels.

Fonctions :

Reconnaissance Faciale (exemple)

La reconnaissance faciale permet de localiser et/ou identifier un ou plusieurs visages dans une image ou une vidéo. Elle peut s'appuyer sur des méthodes simples comme les classifieurs Haar (OpenCV) ou sur des réseaux de neurones convolutifs (CNN) pour des résultats plus précis.

Exemple de code :

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_lfw_people
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelBinarizer
import tensorflow as tf
from tensorflow.keras import layers, models

# 1. Charger le dataset LFW
lfw = fetch_lfw_people(min_faces_per_person=50, resize=0.5)
X = lfw.images  # (n_samples, height, width)
y = lfw.target
target_names = lfw.target_names
print("Classes:", target_names)

# 2. Normalisation et format pour CNN
X = X / 255.0
X = X[..., np.newaxis]  # (n_samples, height, width, 1)

# 3. Encodage one-hot des labels
lb = LabelBinarizer()
y_encoded = lb.fit_transform(y)

# 4. Séparation en train/test
X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, test_size=0.2, random_state=42)

# 5. Construction du CNN
model = models.Sequential([
    layers.Conv2D(32, (3,3), activation='relu', input_shape=X.shape[1:]),
    layers.MaxPooling2D(2,2),
    layers.Conv2D(64, (3,3), activation='relu'),
    layers.MaxPooling2D(2,2),
    layers.Flatten(),
    layers.Dense(128, activation='relu'),
    layers.Dense(len(target_names), activation='softmax')
])

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.summary()

# 6. Entraînement
history = model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.1)

# 7. Évaluation
loss, acc = model.evaluate(X_test, y_test)
print(f"\n✅ Test Accuracy: {acc:.4f}")

# 8. Affichage de quelques prédictions
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = np.argmax(y_test, axis=1)

plt.figure(figsize=(12,6))
for i in range(10):
    plt.subplot(2,5,i+1)
    plt.imshow(X_test[i].squeeze(), cmap='gray')
    plt.title(f"Préd: {target_names[y_pred_classes[i]]}\nVrai: {target_names[y_true[i]]}")
    plt.axis('off')
plt.tight_layout()
plt.show()

Explication du code :

1. Chargement des données LFW (Labeled Faces in the Wild) 
- Dataset : visages de personnes célèbres avec `min_faces_per_person=50` (filtre les classes rares). 
- `X` contient les images (dimensions : n_samples × height × width). 
- `y` contient les indices des classes. 
- `target_names` contient les noms correspondants aux classes.

2. Prétraitement des données 
- **Normalisation** : les valeurs des pixels sont divisées par 255. 
- **Redimensionnement pour CNN** : ajout d’une dimension pour les canaux (grayscale → `(H, W, 1)`).

3. Encodage des labels 
- Utilisation de `LabelBinarizer` pour encoder les labels en one-hot.
4. Séparation des données 
- `train_test_split` : 80% pour l'entraînement, 20% pour le test.

5. Construction du modèle CNN 
- **Architecture** : 
- `Conv2D(32)` + `MaxPooling2D(2x2)` 
- `Conv2D(64)` + `MaxPooling2D(2x2)` 
- `Flatten` - `Dense(128, relu)` 
- `Dense(len(target_names), softmax)` 
- **Compilation** : - Optimiseur : `Adam` 
- Perte : `categorical_crossentropy` 
- Métrique : `accuracy`

6. Entraînement du modèle 
- Entraînement sur 10 époques, batch de 32. 
- 10% des données d'entraînement utilisées pour la validation.

7. Évaluation du modèle 
- Évaluation sur l’ensemble de test. 
- Affichage de la précision finale (`acc`).

8. Prédictions et visualisation 
- Prédiction sur les images de test. 
- Extraction des classes prédites et réelles avec `argmax`. 
- Affichage de 10 images testées avec leur prédiction et leur étiquette réelle.