Análisis de Componentes Independientes con FastICA y PCA

Introducción

Esta práctica demuestra el uso de los algoritmos FastICA y PCA, dos técnicas populares de análisis de componentes independientes. El Análisis de Componentes Independientes (ICA) es un método para separar señales multivariadas en subcomponentes aditivos que son lo más independientes posible. Esta técnica encuentra direcciones en el espacio de características correspondientes a proyecciones con alta no gaussianidad.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Generar datos de muestra

En este paso, generamos datos de muestra utilizando un proceso altamente no gaussiano, una distribución de Student T con un bajo número de grados de libertad.

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

## Mezclar datos
A = np.array([[1, 1], [0, 2]])  ## Matriz de mezcla

X = np.dot(S, A.T)  ## Generar observaciones

Utilizar el algoritmo PCA

En este paso, utilizamos el algoritmo PCA para encontrar direcciones ortogonales en el espacio de características bruto que corresponden a las direcciones que representan la varianza máxima.

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

Utilizar el algoritmo FastICA

En este paso, utilizamos el algoritmo FastICA, que encuentra direcciones en el espacio de características correspondientes a proyecciones con alta no gaussianidad.

ica = FastICA(random_state=rng, whiten="arbitrary-variance")
S_ica_ = ica.fit(X).transform(X)  ## Estimar las fuentes

S_ica_ /= S_ica_.std(axis=0)

Graficar los resultados

En este paso, graficamos los resultados utilizando 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("Fuentes independientes reales")

axis_list = [(pca.components_.T, "naranja", "PCA"), (ica.mixing_, "rojo", "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("Observaciones")

plt.subplot(2, 2, 3)
plot_samples(S_pca_ / np.std(S_pca_, axis=0))
plt.title("Señales recuperadas por PCA")

plt.subplot(2, 2, 4)
plot_samples(S_ica_ / np.std(S_ica_))
plt.title("Señales recuperadas por ICA")

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

Resumen

En este laboratorio, aprendimos cómo utilizar los algoritmos FastICA y PCA en Python para realizar el análisis de componentes independientes y cómo visualizar los resultados utilizando matplotlib.