Run this notebook: Open in Colab Open in Kaggle

Plot Face Recognition

=================================================== Faces recognition example using eigenfaces and SVMs

The dataset used in this example is a preprocessed excerpt of the “Labeled Faces in the Wild”, aka LFW: https://www.kaggle.com/datasets/jessicali9530/lfw-dataset

Imports for Eigenface-Based Face Recognition with PCA and SVM

The eigenface approach combines PCA for unsupervised dimensionality reduction with SVM classification to recognize faces from high-dimensional pixel data: Each face image (resized to roughly 50x37 pixels) is flattened into a ~1850-dimensional feature vector, which is far too high-dimensional for direct SVM classification given the limited number of training samples. PCA(n_components=150, whiten=True) projects the data onto 150 orthogonal directions of maximum variance (the “eigenfaces”), reducing dimensionality by 90%+ while retaining the most discriminative facial structure. The whiten=True parameter normalizes each component to unit variance, which is critical for SVM performance because it ensures that all projected features contribute equally to the RBF kernel distance computation.

RandomizedSearchCV efficiently tunes the SVM hyperparameters C and gamma using log-uniform distributions, which is more efficient than grid search for continuous parameters: The C parameter (sampled from loguniform(1e3, 1e5)) controls the regularization strength – larger values reduce misclassification at the risk of overfitting – while gamma (sampled from loguniform(1e-4, 1e-1)) controls the RBF kernel bandwidth – smaller values create smoother decision boundaries. The class_weight="balanced" parameter adjusts the SVM’s penalty for each class inversely proportional to its frequency, compensating for the imbalanced representation of different people in the LFW dataset. The classification_report and ConfusionMatrixDisplay provide per-person precision, recall, and F1 metrics that reveal which individuals are hardest to distinguish.

# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

# %%
from time import time

import matplotlib.pyplot as plt
from scipy.stats import loguniform

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

# %%
# Download the data, if not already on disk and load it as numpy arrays

lfw_people = fetch_lfw_people(min_faces_per_person=70, resize=0.4)

# introspect the images arrays to find the shapes (for plotting)
n_samples, h, w = lfw_people.images.shape

# for machine learning we use the 2 data directly (as relative pixel
# positions info is ignored by this model)
X = lfw_people.data
n_features = X.shape[1]

# the label to predict is the id of the person
y = lfw_people.target
target_names = lfw_people.target_names
n_classes = target_names.shape[0]

print("Total dataset size:")
print("n_samples: %d" % n_samples)
print("n_features: %d" % n_features)
print("n_classes: %d" % n_classes)


# %%
# Split into a training set and a test and keep 25% of the data for testing.

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)

# %%
# Compute a PCA (eigenfaces) on the face dataset (treated as unlabeled
# dataset): unsupervised feature extraction / dimensionality reduction

n_components = 150

print(
    "Extracting the top %d eigenfaces from %d faces" % (n_components, X_train.shape[0])
)
t0 = time()
pca = PCA(n_components=n_components, svd_solver="randomized", whiten=True).fit(X_train)
print("done in %0.3fs" % (time() - t0))

eigenfaces = pca.components_.reshape((n_components, h, w))

print("Projecting the input data on the eigenfaces orthonormal basis")
t0 = time()
X_train_pca = pca.transform(X_train)
X_test_pca = pca.transform(X_test)
print("done in %0.3fs" % (time() - t0))


# %%
# Train an SVM classification model

print("Fitting the classifier to the training set")
t0 = time()
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)
print("done in %0.3fs" % (time() - t0))
print("Best estimator found by grid search:")
print(clf.best_estimator_)


# %%
# Quantitative evaluation of the model quality on the test set

print("Predicting people's names on the test set")
t0 = time()
y_pred = clf.predict(X_test_pca)
print("done in %0.3fs" % (time() - t0))

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"
)
plt.tight_layout()
plt.show()


# %%
# Qualitative evaluation of the predictions using matplotlib