Analyse en composantes indépendantes | Analyse en composantes principales

Introduction

Ce laboratoire démontre l'utilisation des algorithmes FastICA et PCA, deux techniques populaires d'analyse en composantes indépendantes. L'Analyse en Composantes Indépendantes (ICA) est une méthode de séparation de signaux multivariés en sous-composantes additives qui sont maximement indépendantes. Cette technique trouve des directions dans l'espace des caractéristiques correspondant à des projections avec une forte non-gaussianité.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter Notebook pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Générer des données d'échantillonnage

Dans cette étape, nous générons des données d'échantillonnage en utilisant un processus hautement non-gaussien, 2 lois de Student T avec un faible nombre de degrés de liberté.

import numpy as np

from sklearn.decomposition import PCA, FastICA

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

## Mix data
A = np.array([[1, 1], [0, 2]])  ## Mixing matrix

X = np.dot(S, A.T)  ## Generate observations

Utiliser l'algorithme PCA

Dans cette étape, nous utilisons l'algorithme PCA pour trouver des directions orthogonales dans l'espace de caractéristiques brutes qui correspondent à des directions représentant la variance maximale.

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

Utiliser l'algorithme FastICA

Dans cette étape, nous utilisons l'algorithme FastICA, qui trouve des directions dans l'espace de caractéristiques correspondant à des projections avec une forte non-gaussianité.

ica = FastICA(random_state=rng, whiten="arbitrary-variance")
S_ica_ = ica.fit(X).transform(X)  ## Estimate the sources

S_ica_ /= S_ica_.std(axis=0)

Tracer les résultats

Dans cette étape, nous traçons les résultats à l'aide de 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("Vrais sources indépendantes")

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

plt.subplot(2, 2, 3)
plot_samples(S_pca_ / np.std(S_pca_, axis=0))
plt.title("Signaux récupérés par PCA")

plt.subplot(2, 2, 4)
plot_samples(S_ica_ / np.std(S_ica_))
plt.title("Signaux récupérés par ICA")

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

Sommaire

Dans ce laboratoire, nous avons appris à utiliser l'algorithme FastICA et PCA en Python pour effectuer une analyse en composantes indépendantes et à visualiser les résultats à l'aide de matplotlib.

Analyse en composantes indépendantes avec FastICA et PCA