Meisterung von Kreuzzerlegungsmethoden

Einführung

In diesem Lab werden wir lernen, wie verschiedene Kreuzzerlegungsmethoden wie PLS Canonical, PLS Regression und CCA verwendet werden, um Kovarianzrichtungen aus multivariaten Datensätzen zu extrahieren.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine abgeschlossen ist, klicken Sie in der linken oberen Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Dataset-Erstellung

Wir erstellen einen Datensatz mit zwei multivariaten, kovariierenden zweidimensionalen Datensätzen, X und Y. Anschließend extrahieren wir die Kovarianzrichtungen, d.h. die Komponenten jedes Datensatzes, die die größte gemeinsame Varianz zwischen beiden Datensätzen erklären.

import numpy as np

n = 500
## 2 latente Variablen:
l1 = np.random.normal(size=n)
l2 = np.random.normal(size=n)

latents = np.array([l1, l1, l2, l2]).T
X = latents + np.random.normal(size=4 * n).reshape((n, 4))
Y = latents + 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))

Kanonischer PLS

Wir verwenden den PLS Canonical-Algorithmus, um die Daten zu transformieren. Anschließend erstellen wir einen Streudiagramm der 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

## Auf der Diagonalen: Plot von X vs Y Scores auf jeder Komponente
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("x scores")
plt.ylabel("y scores")
plt.title(
    "Comp. 1: X vs Y (test corr = %.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("x scores")
plt.ylabel("y scores")
plt.title(
    "Comp. 2: X vs Y (test corr = %.2f)"
    % np.corrcoef(X_test_r[:, 1], Y_test_r[:, 1])[0, 1]
)
plt.xticks(())
plt.yticks(())
plt.legend(loc="best")

## Off-diagonale Plot: Komponenten 1 vs 2 für X und 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("X comp. 1")
plt.ylabel("X comp. 2")
plt.title(
    "X comp. 1 vs X comp. 2 (test corr = %.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("Y comp. 1")
plt.ylabel("Y comp. 2")
plt.title(
    "Y comp. 1 vs Y comp. 2, (test corr = %.2f)"
    % np.corrcoef(Y_test_r[:, 0], Y_test_r[:, 1])[0, 1]
)
plt.legend(loc="best")
plt.xticks(())
plt.yticks(())
plt.show()

PLS Regression mit multivariater Antwort (PLS2)

Wir verwenden den PLS Regression-Algorithmus mit multivariater Antwort, um die Werte einer Matrix B zu schätzen. Anschließend vergleichen wir die geschätzte B mit der wahren 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
## jeder Yj = 1*X1 + 2*X2 + Rauschen
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("Wahre B (so dass: Y = XB + Err)")
print(B)
## Vergleiche pls2.coef_ mit B
print("Geschätzte B")
print(np.round(pls2.coef_, 1))
pls2.predict(X)

PLS Regression mit eindimensionaler Antwort (PLS1)

Wir verwenden den PLS Regression-Algorithmus mit eindimensionaler Antwort, um die Werte von beta zu schätzen.

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)
## beachten Sie, dass die Anzahl der Komponenten größer als 1 (die Dimension von y) ist
print("Geschätzte betas")
print(np.round(pls1.coef_, 1))

CCA (PLS-Modus B mit symmetrischer Deflation)

Wir verwenden den CCA-Algorithmus, um die Daten zu transformieren.

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)

Zusammenfassung

In diesem Lab haben wir gelernt, wie verschiedene Kreuzzerlegungsmethoden verwendet werden, um die Kovarianzrichtungen aus multivariaten Datensätzen zu extrahieren. Wir haben einen Datensatz erstellt, die Daten mit PLS Canonical, PLS Regression und CCA transformiert und die Werte von Matrizen und Betas geschätzt. Wir haben auch Streudiagramme erstellt, um die Scores der Komponenten zu visualisieren.

Vergleiche Kreuzzerlegungsmethoden