Reconnaissance faciale avec eigenfaces et machines à vecteurs de support (SVM)

Introduction

Ce laboratoire vous guidera tout au long des étapes pour effectuer la reconnaissance faciale à l'aide d'eigenfaces et de Machines à Vecteurs de Support (SVM). L'ensemble de données utilisé dans ce laboratoire est un extrait prétraité du jeu de données "Labeled Faces in the Wild".

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

from time import time
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.model_selection import RandomizedSearchCV
from sklearn.datasets import fetch_lfw_people
from sklearn.metrics import classification_report
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from scipy.stats import loguniform

Tout d'abord, nous devons importer toutes les bibliothèques nécessaires.

Charger et explorer l'ensemble de données

lfw_people = fetch_lfw_people(min_faces_per_person=70, resize=0.4)
n_samples, h, w = lfw_people.images.shape
X = lfw_people.data
n_features = X.shape[1]
y = lfw_people.target
target_names = lfw_people.target_names
n_classes = target_names.shape[0]

Nous téléchargeons l'ensemble de données à l'aide de la fonction fetch_lfw_people() de scikit-learn. Nous explorons ensuite l'ensemble de données en obtenant le nombre d'échantillons, la hauteur et la largeur des images. Nous obtenons également les données d'entrée X, la cible y, les noms de cibles target_names et le nombre de classes n_classes.

Prétraitement des données

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Nous divisons l'ensemble de données en un ensemble d'entraînement et un ensemble de test et prétraitons les données en mettant à l'échelle les données d'entrée à l'aide de la fonction StandardScaler().

Effectuer une ACP

n_components = 150

pca = PCA(n_components=n_components, svd_solver="randomized", whiten=True).fit(X_train)
eigenfaces = pca.components_.reshape((n_components, h, w))

X_train_pca = pca.transform(X_train)
X_test_pca = pca.transform(X_test)

Nous effectuons une Analyse en Composantes Principales (ACP) pour extraire des caractéristiques des données d'entrée. Nous fixons le nombre de composantes à 150 et ajustons le modèle ACP aux données d'entraînement. Nous obtenons ensuite les eigenfaces et transformons les données d'entrée en composantes principales.

Entraîner un modèle de classification à machine à vecteurs de support (SVM)

param_grid = {
    "C": loguniform(1e3, 1e5),
    "gamma": loguniform(1e-4, 1e-1),
}

clf = RandomizedSearchCV(
    SVC(kernel="rbf", class_weight="balanced"), param_grid, n_iter=10
)
clf = clf.fit(X_train_pca, y_train)

Nous entraînons un modèle de classification SVM en utilisant les données transformées. Nous utilisons RandomizedSearchCV() pour trouver les meilleurs hyperparamètres pour le modèle SVM.

Évaluer les performances du modèle

y_pred = clf.predict(X_test_pca)
print(classification_report(y_test, y_pred, target_names=target_names))
ConfusionMatrixDisplay.from_estimator(
    clf, X_test_pca, y_test, display_labels=target_names, xticks_rotation="vertical"
)

Nous prédisons les valeurs cibles en utilisant les données de test et évaluons les performances du modèle à l'aide de la fonction classification_report(). Nous traçons également la matrice de confusion à l'aide de la fonction ConfusionMatrixDisplay().

Visualiser les prédictions

def plot_gallery(images, titles, h, w, n_row=3, n_col=4):
    """Fonction d'aide pour tracer une galerie de portraits"""
    plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))
    plt.subplots_adjust(bottom=0, left=0.01, right=0.99, top=0.90, hspace=0.35)
    for i in range(n_row * n_col):
        plt.subplot(n_row, n_col, i + 1)
        plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)
        plt.title(titles[i], size=12)
        plt.xticks(())
        plt.yticks(())

prediction_titles = [
    title(y_pred, y_test, target_names, i) for i in range(y_pred.shape[0])
]

plot_gallery(X_test, prediction_titles, h, w)

Nous visualisons les prédictions en traçant une galerie de portraits avec leurs noms prédits et réels.

Visualiser les eigenfaces

eigenface_titles = ["eigenface %d" % i for i in range(eigenfaces.shape[0])]
plot_gallery(eigenfaces, eigenface_titles, h, w)

plt.show()

Nous traçons également les eigenfaces pour visualiser les caractéristiques extraites des données d'entrée.

Sommaire

Dans ce laboratoire, nous avons appris à effectuer la reconnaissance faciale à l'aide d'eigenfaces et de machines à vecteurs de support (SVM). Nous avons tout d'abord chargé et exploré l'ensemble de données, puis avons prétraité les données en mettant à l'échelle les données d'entrée. Nous avons ensuite effectué une analyse en composantes principales (PCA) pour extraire des caractéristiques des données d'entrée et avons entraîné un modèle de classification SVM. Nous avons évalué les performances du modèle et avons visualisé les prédictions et les eigenfaces.