Zerlegungen des Faces Datensatzes

Einführung

In diesem Lab werden verschiedene methoden der unüberwachten matrixzerlegung (dimension reduction) aus dem modul sklearn.decomposition auf den Olivetti faces dataset angewandt. Der Olivetti faces dataset besteht aus 400 Gesichtern der größe 64x64 pixel von 40 personen, die jeweils mit verschiedenen facial expressions und lighting conditions aufgenommen wurden.

VM Tipps

Nachdem der VM startup abgeschlossen ist, klicken Sie in der oberen linken ecke, um zur Notebook Registerkarte zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige sekunden warten, bis Jupyter Notebook fertig geladen ist. Die validierung von operationen kann aufgrund von einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der lernphase probleme haben, können Sie Labby gerne fragen. Geben Sie nach der session feedback, und wir werden das problem für Sie prompt beheben.

Skills Graph

Datensatzvorbereitung

Zunächst laden und verarbeiten wir den Olivetti faces dataset. Wir zentrieren die Daten, sodass der Mittelwert null ist, sowohl global (konzentrieren sich auf eine eigenschaft, zentrieren alle samples) als auch lokal (konzentrieren sich auf ein sample, zentrieren alle eigenschaften). Wir definieren auch eine basisfunktion, um die galerie von gesichtern zu plotten.

## Laden und Vorverarbeiten des Olivetti faces dataset.

import logging

from numpy.random import RandomState
import matplotlib.pyplot as plt

from sklearn.datasets import fetch_olivetti_faces
from sklearn import cluster
from sklearn import decomposition

rng = RandomState(0)

## Zeige Fortschrittslogs auf der Standardausgabe
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")

faces, _ = fetch_olivetti_faces(return_X_y=True, shuffle=True, random_state=rng)
n_samples, n_features = faces.shape

## Globale Zentrierung (konzentrieren sich auf eine eigenschaft, zentrieren alle samples)
faces_centered = faces - faces.mean(axis=0)

## Lokale Zentrierung (konzentrieren sich auf ein sample, zentrieren alle eigenschaften)
faces_centered -= faces_centered.mean(axis=1).reshape(n_samples, -1)

print("Datensatz besteht aus %d Gesichtern" % n_samples)

## Definiere eine basisfunktion, um die galerie von gesichtern zu plotten.

n_row, n_col = 2, 3
n_components = n_row * n_col
image_shape = (64, 64)


def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
    fig, axs = plt.subplots(
        nrows=n_row,
        ncols=n_col,
        figsize=(2.0 * n_col, 2.3 * n_row),
        facecolor="white",
        constrained_layout=True,
    )
    fig.set_constrained_layout_pads(w_pad=0.01, h_pad=0.02, hspace=0, wspace=0)
    fig.set_edgecolor("black")
    fig.suptitle(title, size=16)
    for ax, vec in zip(axs.flat, images):
        vmax = max(vec.max(), -vec.min())
        im = ax.imshow(
            vec.reshape(image_shape),
            cmap=cmap,
            interpolation="nearest",
            vmin=-vmax,
            vmax=vmax,
        )
        ax.axis("off")

    fig.colorbar(im, ax=axs, orientation="horizontal", shrink=0.99, aspect=40, pad=0.01)
    plt.show()


## Schauen wir uns unsere Daten an. Graue Farbe zeigt negative werte an,
## weiß zeigt positive werte an.

plot_gallery("Gesichter aus dem Datensatz", faces_centered[:n_components])

Eigenfaces - PCA mit randomisierter SVD

Die erste methode, die wir anwenden, ist PCA, eine lineare dimensionsreduzierungstechnik, die die singulärwertzerlegung (SVD) der daten verwendet, um sie in einen raum mit niedrigerer dimension zu projizieren. Wir verwenden eine randomisierte SVD, die eine schnellere annäherung an den standard svd-algorithmus ist. Wir plotten die ersten sechs hauptkomponenten, die als eigenfaces bezeichnet werden.

## Eigenfaces - PCA using randomized SVD
pca_estimator = decomposition.PCA(
    n_components=n_components, svd_solver="randomized", whiten=True
)
pca_estimator.fit(faces_centered)
plot_gallery(
    "Eigenfaces - PCA using randomized SVD", pca_estimator.components_[:n_components]
)

Nichtnegative Komponenten - NMF

Als nächstes wenden wir die Nichtnegative Matrix Faktorisierung (NMF) an, die die Datenmatrix in zwei nichtnegative Matrizen zerlegt, wobei eine die Basisvektoren und die andere die Koeffizienten enthält. Dies führt zu einer teilenbasierten Darstellung der Daten.

## Non-negative components - NMF
nmf_estimator = decomposition.NMF(n_components=n_components, tol=5e-3)
nmf_estimator.fit(faces)  ## original non- negative dataset
plot_gallery("Non-negative components - NMF", nmf_estimator.components_[:n_components])

Unabhängige Komponenten - FastICA

Die Unabhängige Komponentenanalyse (ICA) ist eine Methode zur Trennung multivariate Signale in additive subkomponenten, die maximal unabhängig sind. Wir wenden FastICA an, was ein schnelles und robustes Verfahren für die ICA ist.

## Independent components - FastICA
ica_estimator = decomposition.FastICA(
    n_components=n_components, max_iter=400, whiten="arbitrary-variance", tol=15e-5
)
ica_estimator.fit(faces_centered)
plot_gallery(
    "Independent components - FastICA", ica_estimator.components_[:n_components]
)

Sparse Komponenten - MiniBatchSparsePCA

Sparse PCA ist eine Variante von PCA, die Sparsamkeit in den Ladevektoren fördert, was zu einer interpretierbareren Dekomposition führt. Wir verwenden MiniBatchSparsePCA, eine schnellere Version von SparsePCA, die für große Datensätze besser geeignet ist.

## Sparse components - MiniBatchSparsePCA
batch_pca_estimator = decomposition.MiniBatchSparsePCA(
    n_components=n_components, alpha=0.1, max_iter=100, batch_size=3, random_state=rng
)
batch_pca_estimator.fit(faces_centered)
plot_gallery(
    "Sparse components - MiniBatchSparsePCA",
    batch_pca_estimator.components_[:n_components],
)

Wörterbuchlern (Dictionary learning)

Das Wörterbuchlern ist eine Methode, um eine spärliche Darstellung der Eingabedaten als eine Kombination einfacher Elemente zu finden, die ein Wörterbuch bilden. Wir wenden MiniBatchDictionaryLearning an, was eine schnellere Version von DictionaryLearning ist und für große Datensätze besser geeignet ist.

## Dictionary learning
batch_dict_estimator = decomposition.MiniBatchDictionaryLearning(
    n_components=n_components, alpha=0.1, max_iter=50, batch_size=3, random_state=rng
)
batch_dict_estimator.fit(faces_centered)
plot_gallery("Dictionary learning", batch_dict_estimator.components_[:n_components])

Clusterzentren - MiniBatchKMeans

Das K-Means-Clustering ist eine Methode, um einen Datensatz in Cluster zu unterteilen, indem die Summe der quadrierten Abstände zwischen jedem Punkt und dem Schwerpunkt seines zugewiesenen Clusters minimiert wird. Wir wenden MiniBatchKMeans an, was eine schnellere Version von KMeans ist und für große Datensätze besser geeignet ist.

## Cluster centers - MiniBatchKMeans
kmeans_estimator = cluster.MiniBatchKMeans(
    n_clusters=n_components,
    tol=1e-3,
    batch_size=20,
    max_iter=50,
    random_state=rng,
    n_init="auto",
)
kmeans_estimator.fit(faces_centered)
plot_gallery(
    "Cluster centers - MiniBatchKMeans",
    kmeans_estimator.cluster_centers_[:n_components],
)

Faktorenanalysekomponenten - FA

Die Faktorenanalyse ist eine Methode zur modellierung der Varianz in jeder Richtung des Eingaberaums unabhängig (heteroskedastischer Rauschen), ähnlich wie die PCA, aber mit diesem Vorteil. Wir wenden FactorAnalysis an, was eine Implementierung der Faktorenanalyse in scikit-learn ist.

## Factor Analysis components - FA
fa_estimator = decomposition.FactorAnalysis(n_components=n_components, max_iter=20)
fa_estimator.fit(faces_centered)
plot_gallery("Factor Analysis (FA)", fa_estimator.components_[:n_components])

## --- Pixelweise Varianz
plt.figure(figsize=(3.2, 3.6), facecolor="white", tight_layout=True)
vec = fa_estimator.noise_variance_
vmax = max(vec.max(), -vec.min())
plt.imshow(
    vec.reshape(image_shape),
    cmap=plt.cm.gray,
    interpolation="nearest",
    vmin=-vmax,
    vmax=vmax,
)
plt.axis("off")
plt.title("Pixelweise Varianz aus \n Faktorenanalyse (FA)", size=16, wrap=True)
plt.colorbar(orientation="horizontal", shrink=0.8, pad=0.03)
plt.show()

Dekomposition: Wörterbuchlern (Dictionary learning)

Wir wenden erneut MiniBatchDictionaryLearning an, aber diesmal erzwingen wir die Positivität, wenn das Wörterbuch und/oder die Codierungskoeffizienten gefunden werden.

Wörterbuchlern (Dictionary learning) - positives Wörterbuch

dict_pos_dict_estimator = decomposition.MiniBatchDictionaryLearning(
    n_components=n_components,
    alpha=0.1,
    max_iter=50,
    batch_size=3,
    random_state=rng,
    positive_dict=True,
)
dict_pos_dict_estimator.fit(faces_centered)
plot_gallery(
    "Dictionary learning - positive dictionary",
    dict_pos_dict_estimator.components_[:n_components],
    cmap=plt.cm.RdBu,
)

Wörterbuchlern (Dictionary learning) - positive Codierung

dict_pos_code_estimator = decomposition.MiniBatchDictionaryLearning(
    n_components=n_components,
    alpha=0.1,
    max_iter=50,
    batch_size=3,
    fit_algorithm="cd",
    random_state=rng,
    positive_code=True,
)
dict_pos_code_estimator.fit(faces_centered)
plot_gallery(
    "Dictionary learning - positive code",
    dict_pos_code_estimator.components_[:n_components],
    cmap=plt.cm.RdBu,
)

Wörterbuchlern (Dictionary learning) - positives Wörterbuch & positive Codierung

dict_pos_estimator = decomposition.MiniBatchDictionaryLearning(
    n_components=n_components,
    alpha=0.1,
    max_iter=50,
    batch_size=3,
    fit_algorithm="cd",
    random_state=rng,
    positive_dict=True,
    positive_code=True,
)
dict_pos_estimator.fit(faces_centered)
plot_gallery(
    "Dictionary learning - positive dictionary & code",
    dict_pos_estimator.components_[:n_components],
    cmap=plt.cm.RdBu,
)

Zusammenfassung

In diesem Lab haben wir verschiedene methoden der unüberwachten Matrixdekomposition auf den Olivetti Faces Datensatz angewendet. Wir haben PCA, NMF, ICA, Sparse PCA, Wörterbuchlern (Dictionary Learning), K-Means-Clustering und Faktorenanalyse verwendet, um verschiedene Arten von Merkmalen aus den Daten zu extrahieren. Wir haben auch die Positivität erzwingt, wenn das Wörterbuch und/oder die Codierungskoeffizienten in der Methode des Wörterbuchlern (Dictionary Learning) gefunden werden. Insgesamt können diese Methoden hilfreich sein, um die Dimension von hochdimensionalen Datensätzen zu reduzieren und sinnvolle Merkmale für nachfolgende Aufgaben wie Klassifikation und Clustering zu extrahieren.