Maîtriser les méthodes de décomposition croisée

Introduction

Dans ce laboratoire, nous allons apprendre à utiliser différents algorithmes de décomposition croisée tels que PLS Canonique, PLS Regression et CCA pour extraire les directions de covariance à partir de jeux de données multivariés.

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 Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de 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.

Création d'un ensemble de données

Nous créons un ensemble de données avec deux ensembles de données bidimensionnels multivariés co-variant, X et Y. Nous extrayons ensuite les directions de covariance, c'est-à-dire les composantes de chaque ensemble de données qui expliquent la variance partagée la plus importante entre les deux ensembles de données.

import numpy as np

n = 500
## 2 variables 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 Canonique

Nous utilisons l'algorithme PLS Canonique pour transformer les données. Nous créons ensuite un graphique en dispersion des scores.

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

## Sur la diagonale, tracer les scores de X vs Y pour chaque composante
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("scores de x")
plt.ylabel("scores de y")
plt.title(
    "Comp. 1: X vs Y (corr. test = %.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("scores de x")
plt.ylabel("scores de y")
plt.title(
    "Comp. 2: X vs Y (corr. test = %.2f)"
    % np.corrcoef(X_test_r[:, 1], Y_test_r[:, 1])[0, 1]
)
plt.xticks(())
plt.yticks(())
plt.legend(loc="best")

## Hors diagonale, tracer les composantes 1 vs 2 pour X et 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("Composante 1 de X")
plt.ylabel("Composante 2 de X")
plt.title(
    "Composante 1 de X vs Composante 2 de X (corr. test = %.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("Composante 1 de Y")
plt.ylabel("Composante 2 de Y")
plt.title(
    "Composante 1 de Y vs Composante 2 de Y, (corr. test = %.2f)"
    % np.corrcoef(Y_test_r[:, 0], Y_test_r[:, 1])[0, 1]
)
plt.legend(loc="best")
plt.xticks(())
plt.yticks(())
plt.show()

Régression PLS avec réponse multivariée (PLS2)

Nous utilisons l'algorithme de régression PLS avec réponse multivariée pour estimer les valeurs d'une matrice B. Nous comparons ensuite l'estimation de B avec la vraie B.

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
## chaque Yj = 1*X1 + 2*X2 + bruit
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("Vraie B (telle que : Y = XB + Err)")
print(B)
## comparer pls2.coef_ avec B
print("Estimation de B")
print(np.round(pls2.coef_, 1))
pls2.predict(X)

Régression PLS avec réponse univariée (PLS1)

Nous utilisons l'algorithme de régression PLS avec réponse univariée pour estimer les valeurs 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)
## notez que le nombre de composantes dépasse 1 (la dimension de y)
print("Estimation des betas")
print(np.round(pls1.coef_, 1))

CCA (mode PLS B avec déflation symétrique)

Nous utilisons l'algorithme CCA pour transformer les données.

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)

Sommaire

Dans ce laboratoire, nous avons appris à utiliser différents algorithmes de décomposition croisée pour extraire les directions de covariance à partir de jeux de données multivariés. Nous avons créé un jeu de données, transformé les données à l'aide de PLS Canonique, de Régression PLS et de CCA, et estimé les valeurs de matrices et de betas. Nous avons également créé des graphiques en dispersion pour visualiser les scores des composantes.

Comparer les méthodes de décomposition croisée