Análisis de Componentes Principales (PCA) — 9:20

• Ultima modificación: 2023-02-27 | YouTube

• Este método se usa para descomponer un dataset multivariado en un conjunto de componentes ortogonales que explican la máxima cantidad de la varianza. Para ello, considere el siguiente dataset donde claramente se observa una relación lineal entre las variables, y se grafican los ejes ortogonales:

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

df = sns.load_dataset("tips")[["total_bill", "tip"]]
X = StandardScaler().fit_transform(df)

pca = PCA(n_components=2)
pca.fit(X)

plt.figure(figsize=(3.5, 3.5))
plt.scatter(X[:, 0], X[:, 1], color="tab:red", edgecolors="k", s=30, alpha=0.8)

for length, vector in zip(pca.explained_variance_, pca.components_):
    v = vector * 3 * np.sqrt(length)
    ax = plt.gca()
    ax.annotate(
        "",
        pca.mean_ + v,
        pca.mean_,
        arrowprops=dict(arrowstyle="-|>", linewidth=4, shrinkA=0, shrinkB=0),
    )

plt.xlabel("total_bill")
plt.ylabel("tip")
plt.axis("equal")
plt.show()

• En el gráfico anterior, las componentes definen la dirección los vectores, mientras que la varianza explicada corresponde al cuadrado de la longitud de los vectores. Estos definen las principales componentes de los datos.

• Este es un método para la reducción lineal de la dimensionalidad de los datos (ya que estos son proyectados en un espacio dimensional menor), que también puede ser usado para visualización.

• En scikit-learn, PCA es implementado como un transfomer que aprende n componentes del conjunto de datos para entrenamiento, y luego es usado para proyectar nuevos datos en estos componentes.

• PCA centra pero no escala los datos de entrada antes de aplicar la SVD.

• El parámetro whiten=True hace posible escalar los datos en el espacio singular mientras que escala cada componente para que tenga varianza unitaria. Esto es usualmente util para los modelos que usan los datos transformados, tal como las SVM y K-Means.

• El objeto PCA también incorpora una interpretación probabilistica que permite computar la verosimilitud a partir de la varianza explicada. De esta forma, el método score puede ser usado en validación cruzada.

from sklearn.datasets import load_digits

digits = load_digits(n_class=6)

X = digits.data
y = digits.target

pca = PCA(
    # --------------------------------------------------------------------------
    # Number of components to keep.
    # * None: all components are kept with
    #   n_components == min(n_samples, n_features)
    # * integer
    # * float: percentage of the variance explained
    n_components=2,
    # --------------------------------------------------------------------------
    # When True, components_ are uncorrelated with unit variance
    whiten=False,
    # --------------------------------------------------------------------------
    # Used solver:
    # * 'auto'
    # * 'full'
    # * 'arpack'
    # * 'randomized'
    svd_solver="auto",
    # --------------------------------------------------------------------------
    # Tolerance for singular values computed by svd_solver == ‘arpack’. Must be
    # of range [0.0, infinity).
    tol=0.0,
    # --------------------------------------------------------------------------
    # Number of iterations for the power method computed by
    # svd_solver == ‘randomized’. Must be of range [0, infinity).
    iterated_power="auto",
    # --------------------------------------------------------------------------
    # This parameter is only relevant when svd_solver="randomized". It
    # corresponds to the additional number of random vectors to sample the
    # range of X so as to ensure proper conditioning.
    n_oversamples=10,
    # --------------------------------------------------------------------------
    # Power iteration normalizer for randomized SVD solver. Not used by ARPACK.
    # * 'none'
    # * 'auto'
    # * 'QR'
    # * 'LU'
    power_iteration_normalizer="auto",
    # --------------------------------------------------------------------------
    # Used when the ‘arpack’ or ‘randomized’ solvers are used.
    random_state=None,
)


X_proj = pca.fit_transform(X)

plt.figure(figsize=(3.5, 3.5))

for i in range(X_proj.shape[0]):
    plt.text(
        X_proj[i, 0],
        X_proj[i, 1],
        str(y[i]),
        color=plt.cm.Set1(y[i] / 10.0),
        fontdict={"weight": "bold", "size": 8},
    )

plt.xlim((X_proj[:, 0].min(), X_proj[:, 0].max()))
plt.ylim((X_proj[:, 1].min(), X_proj[:, 1].max()))

plt.gca().spines["left"].set_visible(False)
plt.gca().spines["bottom"].set_visible(False)
plt.gca().spines["top"].set_visible(False)
plt.gca().spines["right"].set_visible(False)

plt.xticks([])
plt.yticks([])

plt.show()

pca = PCA().fit(digits.data)

plt.figure(figsize=(7, 3.5))
plt.plot(np.cumsum(pca.explained_variance_ratio_), color="tab:orange", linewidth=3)
plt.xlabel("number of components")
plt.ylabel("cumulative explained variance")
plt.grid()
plt.show()