Reconocimiento facial con eigenfaces y SVMs

Introducción

Esta práctica te guiará a través de los pasos para realizar el reconocimiento facial utilizando eigenfaces y Máquinas de Soporte Vectorial (SVM). El conjunto de datos utilizado en esta práctica es un extracto preprocesado del conjunto de datos "Labeled Faces in the Wild".

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haz clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tengas que esperar unos segundos a que Jupyter Notebook termine de cargar. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tienes problemas durante el aprendizaje, no dudes en preguntar a Labby. Proporciona retroalimentación después de la sesión y resolveremos el problema para ti de inmediato.

Importar bibliotecas

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

En primer lugar, necesitamos importar todas las bibliotecas necesarias.

Cargar y explorar el conjunto de datos

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]

Descargamos el conjunto de datos utilizando la función fetch_lfw_people() de scikit-learn. Luego exploramos el conjunto de datos obteniendo el número de muestras, la altura y el ancho de las imágenes. También obtenemos los datos de entrada X, la variable objetivo y, los nombres de las variables objetivo target_names y el número de clases n_classes.

Preprocesamiento de datos

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)

Dividimos el conjunto de datos en un conjunto de entrenamiento y un conjunto de prueba y preprocesamos los datos escalando los datos de entrada utilizando la función StandardScaler().

Realizar Análisis de Componentes Principales (PCA)

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)

Realizamos el Análisis de Componentes Principales (PCA) para extraer características de los datos de entrada. Establecemos el número de componentes en 150 y ajustamos el modelo PCA a los datos de entrenamiento. Luego obtenemos las eigenfaces y transformamos los datos de entrada en componentes principales.

Entrenar un modelo de clasificación con Máquinas de Vectores de Soporte (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)

Entrenamos un modelo de clasificación con SVM utilizando los datos transformados. Utilizamos RandomizedSearchCV() para encontrar los mejores hiperparámetros para el modelo SVM.

Evaluar el rendimiento del modelo

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"
)

Predecimos los valores de la variable objetivo utilizando los datos de prueba y evaluamos el rendimiento del modelo utilizando la función classification_report(). También trazamos la matriz de confusión utilizando la función ConfusionMatrixDisplay().

Visualizar las predicciones

def plot_gallery(images, titles, h, w, n_row=3, n_col=4):
    """Función auxiliar para graficar una galería de retratos"""
    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)

Visualizamos las predicciones graficando una galería de retratos con sus nombres predichos y reales.

Visualizar eigenfaces

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

plt.show()

También graficamos las eigenfaces para visualizar las características extraídas de los datos de entrada.

Resumen

En este laboratorio, aprendimos cómo realizar el reconocimiento facial utilizando eigenfaces y SVMs. Primero cargamos y exploramos el conjunto de datos, luego preprocesamos los datos escalando los datos de entrada. Luego realizamos PCA para extraer características de los datos de entrada y entrenamos un modelo de clasificación con SVM. Evaluamos el rendimiento del modelo y visualizamos las predicciones y las eigenfaces.