Unabhängige Komponentenanalyse mit FastICA und PCA

Einführung

In diesem Lab wird die Verwendung des FastICA- und PCA-Algorithmus, zwei populäre Techniken der unabhängigen Komponentenanalyse (Independent Component Analysis, ICA), demonstriert. Die unabhängige Komponentenanalyse (ICA) ist eine Methode, um multivariate Signale in additive Teilkomponenten zu trennen, die maximal unabhängig voneinander sind. Diese Technik findet Richtungen im Merkmalsraum, die mit Projektionen mit hoher Nicht-Gauß-Verteilung übereinstimmen.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby um Hilfe bitten. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem für Sie prompt beheben.

Beispiel-Daten generieren

In diesem Schritt generieren wir Beispiel-Daten mithilfe eines stark nicht-gaußschen Prozesses, eines Student's t-Verteilten mit einer geringen Freiheitsgradzahl.

import numpy as np

from sklearn.decomposition import PCA, FastICA

rng = np.random.RandomState(42)
S = rng.standard_t(1.5, Größe=(20000, 2))
S[:, 0] *= 2.0

## Daten mischen
A = np.array([[1, 1], [0, 2]])  ## Mischmatrix

X = np.dot(S, A.T)  ## Beobachtungen generieren

PCA-Algorithmus verwenden

In diesem Schritt verwenden wir den PCA-Algorithmus, um orthogonale Richtungen im ursprünglichen Merkmalsraum zu finden, die den Richtungen entsprechen, die für die maximale Varianz verantwortlich sind.

pca = PCA()
S_pca_ = pca.fit(X).transform(X)

FastICA-Algorithmus verwenden

In diesem Schritt verwenden wir den FastICA-Algorithmus, der Richtungen im Merkmalsraum findet, die mit Projektionen mit hoher Nicht-Gauß-Verteilung übereinstimmen.

ica = FastICA(random_state=rng, whiten="arbitrary-variance")
S_ica_ = ica.fit(X).transform(X)  ## Quellen schätzen

S_ica_ /= S_ica_.std(axis=0)

Ergebnisse plotten

In diesem Schritt plotten wir die Ergebnisse mit matplotlib.

import matplotlib.pyplot as plt

def plot_samples(S, axis_list=None):
    plt.scatter(
        S[:, 0], S[:, 1], s=2, marker="o", zorder=10, color="steelblue", alpha=0.5
    )
    if axis_list is not None:
        for axis, color, label in axis_list:
            axis /= axis.std()
            x_axis, y_axis = axis
            plt.quiver(
                (0, 0),
                (0, 0),
                x_axis,
                y_axis,
                zorder=11,
                width=0.01,
                scale=6,
                color=color,
                label=label,
            )

    plt.hlines(0, -3, 3)
    plt.vlines(0, -3, 3)
    plt.xlim(-3, 3)
    plt.ylim(-3, 3)
    plt.xlabel("x")
    plt.ylabel("y")


plt.figure()
plt.subplot(2, 2, 1)
plot_samples(S / S.std())
plt.title("Wahre unabhängige Quellen")

axis_list = [(pca.components_.T, "orange", "PCA"), (ica.mixing_, "red", "ICA")]
plt.subplot(2, 2, 2)
plot_samples(X / np.std(X), axis_list=axis_list)
legend = plt.legend(loc="lower right")
legend.set_zorder(100)

plt.title("Beobachtungen")

plt.subplot(2, 2, 3)
plot_samples(S_pca_ / np.std(S_pca_, axis=0))
plt.title("Durch PCA wiederhergestellte Signale")

plt.subplot(2, 2, 4)
plot_samples(S_ica_ / np.std(S_ica_))
plt.title("Durch ICA wiederhergestellte Signale")

plt.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.36)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man den FastICA- und PCA-Algorithmus in Python verwendet, um eine unabhängige Komponentenanalyse durchzuführen, und wie man die Ergebnisse mit matplotlib visualisiert.