Comparar métodos de descomposición cruzada

Introducción

En este laboratorio, aprenderemos a usar diferentes algoritmos de descomposición cruzada, como PLS Canónico, PLS Regresión y CCA, para extraer direcciones de covarianza de conjuntos de datos multivariados.

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

Creación del conjunto de datos

Creamos un conjunto de datos con dos conjuntos de datos bidimensionales multivariados covariantes, X e Y. Luego extraemos las direcciones de covarianza, es decir, los componentes de cada conjunto de datos que explican la mayor varianza compartida entre ambos conjuntos de datos.

import numpy as np

n = 500
## 2 vars latentes:
l1 = np.random.normal(size=n)
l2 = np.random.normal(size=n)

latentes = np.array([l1, l1, l2, l2]).T
X = latentes + np.random.normal(size=4 * n).reshape((n, 4))
Y = latentes + np.random.normal(size=4 * n).reshape((n, 4))

X_train = X[: n // 2]
Y_train = Y[: n // 2]
X_test = X[n // 2 :]
Y_test = Y[n // 2 :]

print("Corr(X)")
print(np.round(np.corrcoef(X.T), 2))
print("Corr(Y)")
print(np.round(np.corrcoef(Y.T), 2))

PLS Canónico

Usamos el algoritmo PLS Canónico para transformar los datos. Luego creamos un diagrama de dispersión de las puntuaciones.

from sklearn.cross_decomposition import PLSCanonical

plsca = PLSCanonical(n_components=2)
plsca.fit(X_train, Y_train)
X_train_r, Y_train_r = plsca.transform(X_train, Y_train)
X_test_r, Y_test_r = plsca.transform(X_test, Y_test)

import matplotlib.pyplot as plt

## En el diagrama diagonal, puntuaciones de X vs Y en cada componente
plt.figure(figsize=(12, 8))
plt.subplot(221)
plt.scatter(X_train_r[:, 0], Y_train_r[:, 0], label="train", marker="o", s=25)
plt.scatter(X_test_r[:, 0], Y_test_r[:, 0], label="test", marker="o", s=25)
plt.xlabel("puntuaciones de x")
plt.ylabel("puntuaciones de y")
plt.title(
    "Comp. 1: X vs Y (corr. de prueba = %.2f)"
    % np.corrcoef(X_test_r[:, 0], Y_test_r[:, 0])[0, 1]
)
plt.xticks(())
plt.yticks(())
plt.legend(loc="best")

plt.subplot(224)
plt.scatter(X_train_r[:, 1], Y_train_r[:, 1], label="train", marker="o", s=25)
plt.scatter(X_test_r[:, 1], Y_test_r[:, 1], label="test", marker="o", s=25)
plt.xlabel("puntuaciones de x")
plt.ylabel("puntuaciones de y")
plt.title(
    "Comp. 2: X vs Y (corr. de prueba = %.2f)"
    % np.corrcoef(X_test_r[:, 1], Y_test_r[:, 1])[0, 1]
)
plt.xticks(())
plt.yticks(())
plt.legend(loc="best")

## En el diagrama no diagonal, componentes 1 vs 2 para X e Y
plt.subplot(222)
plt.scatter(X_train_r[:, 0], X_train_r[:, 1], label="train", marker="*", s=50)
plt.scatter(X_test_r[:, 0], X_test_r[:, 1], label="test", marker="*", s=50)
plt.xlabel("Comp. 1 de X")
plt.ylabel("Comp. 2 de X")
plt.title(
    "Comp. 1 de X vs Comp. 2 de X (corr. de prueba = %.2f)"
    % np.corrcoef(X_test_r[:, 0], X_test_r[:, 1])[0, 1]
)
plt.legend(loc="best")
plt.xticks(())
plt.yticks(())

plt.subplot(223)
plt.scatter(Y_train_r[:, 0], Y_train_r[:, 1], label="train", marker="*", s=50)
plt.scatter(Y_test_r[:, 0], Y_test_r[:, 1], label="test", marker="*", s=50)
plt.xlabel("Comp. 1 de Y")
plt.ylabel("Comp. 2 de Y")
plt.title(
    "Comp. 1 de Y vs Comp. 2 de Y, (corr. de prueba = %.2f)"
    % np.corrcoef(Y_test_r[:, 0], Y_test_r[:, 1])[0, 1]
)
plt.legend(loc="best")
plt.xticks(())
plt.yticks(())
plt.show()

Regresión PLS con Respuesta Multivariada (PLS2)

Usamos el algoritmo de Regresión PLS con respuesta multivariada para estimar los valores de una matriz B. Luego comparamos la B estimada con la B real.

n = 1000
q = 3
p = 10
X = np.random.normal(size=n * p).reshape((n, p))
B = np.array([[1, 2] + [0] * (p - 2)] * q).T
## cada Yj = 1*X1 + 2*X2 + ruido
Y = np.dot(X, B) + np.random.normal(size=n * q).reshape((n, q)) + 5

from sklearn.cross_decomposition import PLSRegression

pls2 = PLSRegression(n_components=3)
pls2.fit(X, Y)
print("B real (tal que: Y = XB + Err)")
print(B)
## compare pls2.coef_ con B
print("B estimada")
print(np.round(pls2.coef_, 1))
pls2.predict(X)

Regresión PLS con Respuesta Univariada (PLS1)

Usamos el algoritmo de Regresión PLS con respuesta univariada para estimar los valores de beta.

n = 1000
p = 10
X = np.random.normal(size=n * p).reshape((n, p))
y = X[:, 0] + 2 * X[:, 1] + np.random.normal(size=n * 1) + 5
pls1 = PLSRegression(n_components=3)
pls1.fit(X, y)
## observe que el número de componentes excede 1 (la dimensión de y)
print("Betas estimadas")
print(np.round(pls1.coef_, 1))

CCA (Modo PLS B con deflación simétrica)

Usamos el algoritmo CCA para transformar los datos.

cca = CCA(n_components=2)
cca.fit(X_train, Y_train)
X_train_r, Y_train_r = cca.transform(X_train, Y_train)
X_test_r, Y_test_r = cca.transform(X_test, Y_test)

Resumen

En este laboratorio, aprendimos cómo usar diferentes algoritmos de descomposición cruzada para extraer direcciones de covarianza de conjuntos de datos multivariados. Creamos un conjunto de datos, transformamos los datos usando PLS Canónico, Regresión PLS y CCA, y estimamos los valores de matrices y betas. También creamos diagramas de dispersión para visualizar las puntuaciones de los componentes.