Einführung
In diesem Lab werden Sie Schritt für Schritt durch die Durchführung von Gesichtserkennung mithilfe von Eigenfaces und Support Vector Machines (SVMs) geführt. Der in diesem Lab verwendete Datensatz ist ein vorverarbeiteter Auszug aus dem "Labeled Faces in the Wild"-Datensatz.
Tipps für die virtuelle Maschine (VM)
Nachdem die VM gestartet wurde, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und auf Jupyter Notebook für die Übung zuzugreifen.
Manchmal müssen Sie möglicherweise einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Aufgrund von Einschränkungen in Jupyter Notebook kann die Überprüfung von Vorgängen nicht automatisiert werden.
Wenn Sie während des Lernens Probleme haben, können Sie sich gerne an Labby wenden. Geben Sie uns nach der Sitzung Feedback, und wir werden das Problem umgehend für Sie lösen.
Bibliotheken importieren
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
Zunächst müssen wir alle erforderlichen Bibliotheken importieren.
Datensatz laden und erkunden
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]
Wir laden den Datensatz mit der Funktion fetch_lfw_people() aus scikit-learn herunter. Anschließend erkunden wir den Datensatz, indem wir die Anzahl der Stichproben, die Höhe und die Breite der Bilder ermitteln. Wir erhalten auch die Eingabedaten X, das Ziel y, die Zielnamen target_names und die Anzahl der Klassen n_classes.
Datenvorverarbeitung
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)
Wir teilen den Datensatz in einen Trainingssatz und einen Testsatz auf und verarbeiten die Daten vor, indem wir die Eingabedaten mit der Funktion StandardScaler() skalieren.
Hauptkomponentenanalyse (PCA) durchführen
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)
Wir führen eine Hauptkomponentenanalyse (Principal Component Analysis, PCA) durch, um Merkmale aus den Eingabedaten zu extrahieren. Wir setzen die Anzahl der Komponenten auf 150 und passen das PCA-Modell an die Trainingsdaten an. Anschließend erhalten wir die Eigenfaces (Eigengesichter) und transformieren die Eingabedaten in Hauptkomponenten.
Ein Support-Vektor-Maschinen (Support Vector Machine, SVM)-Klassifizierungsmodell trainieren
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)
Wir trainieren ein SVM-Klassifizierungsmodell mit den transformierten Daten. Wir verwenden RandomizedSearchCV(), um die besten Hyperparameter für das SVM-Modell zu finden.
Modellleistung auswerten
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"
)
Wir prognostizieren die Zielwerte mit den Testdaten und bewerten die Modellleistung mit der Funktion classification_report(). Wir zeichnen auch die Konfusionsmatrix (Confusion Matrix) mit der Funktion ConfusionMatrixDisplay() auf.
Vorhersagen visualisieren
def plot_gallery(images, titles, h, w, n_row=3, n_col=4):
"""Helper function to plot a gallery of 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)
Wir visualisieren die Vorhersagen, indem wir eine Galerie von Porträts mit ihren vorhergesagten und tatsächlichen Namen darstellen.
Eigenfaces (Eigengesichter) visualisieren
eigenface_titles = ["eigenface %d" % i for i in range(eigenfaces.shape[0])]
plot_gallery(eigenfaces, eigenface_titles, h, w)
plt.show()
Wir stellen auch die Eigenfaces (Eigengesichter) dar, um die aus den Eingabedaten extrahierten Merkmale zu visualisieren.
Zusammenfassung
In diesem Lab haben wir gelernt, wie man Gesichtserkennung (Face Recognition) mit Eigenfaces (Eigengesichtern) und Support-Vektor-Maschinen (SVMs) durchführt. Zunächst haben wir den Datensatz geladen und untersucht, dann die Daten vorverarbeitet, indem wir die Eingabedaten skaliert haben. Anschließend haben wir eine Hauptkomponentenanalyse (Principal Component Analysis, PCA) durchgeführt, um Merkmale aus den Eingabedaten zu extrahieren, und ein SVM-Klassifizierungsmodell trainiert. Wir haben die Modellleistung ausgewertet und die Vorhersagen sowie die Eigenfaces visualisiert.