Reconhecimento Facial com Eigenfaces e SVMs

Introdução

Este laboratório guiará você pelos passos para realizar reconhecimento facial usando eigenfaces e Máquinas de Vetores de Suporte (SVMs). O conjunto de dados utilizado neste laboratório é um extrato pré-processado do conjunto de dados "Labeled Faces in the Wild".

Dicas da Máquina Virtual

Após o término da inicialização da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para você.

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

Primeiro, precisamos importar todas as bibliotecas necessárias.

Carregar e Explorar o Conjunto de Dados

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]

Baixamos o conjunto de dados usando a função fetch_lfw_people() do scikit-learn. Em seguida, exploramos o conjunto de dados obtendo o número de amostras, altura e largura das imagens. Também obtemos os dados de entrada X, o alvo y, os nomes dos alvos target_names e o número de classes n_classes.

Pré-processamento de Dados

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 o conjunto de dados em um conjunto de treinamento e um conjunto de teste e pré-processamos os dados escalando os dados de entrada usando a função StandardScaler().

Executar 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 a Análise de Componentes Principais (PCA) para extrair características dos dados de entrada. Definimos o número de componentes para 150 e ajustamos o modelo PCA aos dados de treinamento. Em seguida, obtemos as faces próprias e transformamos os dados de entrada em componentes principais.

Treinar um Modelo de Classificação de Máquina de Vetores de Suporte (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)

Treinamos um modelo de classificação SVM usando os dados transformados. Usamos RandomizedSearchCV() para encontrar os melhores hiperparâmetros para o modelo SVM.

Avaliar o Desempenho do 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"
)

Prevemos os valores-alvo usando os dados de teste e avaliamos o desempenho do modelo usando a função classification_report(). Também plotamos a matriz de confusão usando a função ConfusionMatrixDisplay().

Visualizar Predições

def plot_gallery(images, titles, h, w, n_row=3, n_col=4):
    """Função auxiliar para plotar uma galeria 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 as predições plotando uma galeria de retratos com seus nomes previstos e reais.

Visualizar Eigenfaces

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

plt.show()

Também plotamos os eigenfaces para visualizar as características extraídas dos dados de entrada.

Resumo

Neste laboratório, aprendemos a realizar reconhecimento facial utilizando eigenfaces e SVMs. Primeiro, carregamos e exploramos o conjunto de dados, em seguida, pré-processamos os dados escalando os dados de entrada. Realizamos PCA para extrair características dos dados de entrada e treinamos um modelo de classificação SVM. Avaliamos o desempenho do modelo e visualizamos as predições e os eigenfaces.