Einführung
Principal Component Regression (PCR) und Partial Least Squares Regression (PLS) sind zwei Methoden, die in der Regressionsanalyse eingesetzt werden. Beim PCR wird die PCA auf die Trainingsdaten angewendet, gefolgt von der Ausbildung eines Regressors auf den transformierten Proben. Die PCA-Transformation ist unüberwacht, was bedeutet, dass keine Informationen über die Ziele verwendet werden. Folglich kann der PCR in einigen Datensätzen schlecht performen, in denen das Ziel stark mit Richtungen korreliert ist, die eine geringe Varianz aufweisen.
PLS ist sowohl ein Transformator als auch ein Regressor und ähnelt dem PCR ziemlich stark. Es wendet auch eine Dimensionsreduzierung auf die Proben an, bevor ein linearer Regressor auf die transformierten Daten angewendet wird. Der Hauptunterschied zum PCR besteht darin, dass die PLS-Transformation überwacht ist. Daher leidet es nicht unter dem oben genannten Problem.
In diesem Lab werden wir PCR und PLS auf einem Toy-Datensatz vergleichen.
VM-Tipps
Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken 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 von Einschränkungen in 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.
Ein Dataset erstellen
Wir beginnen mit der Erstellung eines einfachen Datasets mit zwei Merkmalen. Wir verwenden die numpy-Bibliothek, um das Dataset zu erstellen, und die matplotlib-Bibliothek, um es zu plotten.
import numpy as np
import matplotlib.pyplot as plt
rng = np.random.RandomState(0)
n_samples = 500
cov = [[3, 3], [3, 4]]
X = rng.multivariate_normal(mean=[0, 0], cov=cov, size=n_samples)
plt.scatter(X[:, 0], X[:, 1], alpha=0.3, label="samples")
plt.gca().set(
aspect="equal",
title="2-dimensionales Dataset mit Hauptkomponenten",
xlabel="erstes Merkmal",
ylabel="zweites Merkmal",
)
plt.legend()
plt.show()
Definiere das Ziel
Zwecks dieses Beispiels definieren wir das Ziel y so, dass es stark mit einer Richtung korreliert, die eine geringe Varianz aufweist. Wir projizieren X auf die zweite Komponente und fügen ein wenig Rauschen hinzu.
y = X.dot(pca.components_[1]) + rng.normal(size=n_samples) / 2
fig, axes = plt.subplots(1, 2, figsize=(10, 3))
axes[0].scatter(X.dot(pca.components_[0]), y, alpha=0.3)
axes[0].set(xlabel="Projizierte Daten auf die erste PCA-Komponente", ylabel="y")
axes[1].scatter(X.dot(pca.components_[1]), y, alpha=0.3)
axes[1].set(xlabel="Projizierte Daten auf die zweite PCA-Komponente", ylabel="y")
plt.tight_layout()
plt.show()
Erstelle die Regressoren
Wir erstellen zwei Regressoren: PCR und PLS. Und zu illustrativen Zwecken setzen wir die Anzahl der Komponenten auf 1. Bevor wir die Daten der PCA-Schritt des PCR zuführen, standardisieren wir sie zunächst, wie es die gute Praxis empfiehlt. Der PLS-Schätzer hat integrierte Skalierungsfähigkeiten.
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.cross_decomposition import PLSRegression
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=rng)
pcr = make_pipeline(StandardScaler(), PCA(n_components=1), LinearRegression())
pcr.fit(X_train, y_train)
pca = pcr.named_steps["pca"] ## retrieve the PCA step of the pipeline
pls = PLSRegression(n_components=1)
pls.fit(X_train, y_train)
Vergleiche die Regressoren
Wir plotten die projizierten Daten auf die erste Komponente gegen das Ziel für beide Regressoren PCR und PLS. In beiden Fällen sind diese projizierten Daten diejenigen, die die Regressoren als Trainingsdaten verwenden werden.
fig, axes = plt.subplots(1, 2, figsize=(10, 3))
axes[0].scatter(pca.transform(X_test), y_test, alpha=0.3, label="ground truth")
axes[0].scatter(
pca.transform(X_test), pcr.predict(X_test), alpha=0.3, label="predictions"
)
axes[0].set(
xlabel="Projizierte Daten auf die erste PCA-Komponente", ylabel="y", title="PCR / PCA"
)
axes[0].legend()
axes[1].scatter(pls.transform(X_test), y_test, alpha=0.3, label="ground truth")
axes[1].scatter(
pls.transform(X_test), pls.predict(X_test), alpha=0.3, label="predictions"
)
axes[1].set(xlabel="Projizierte Daten auf die erste PLS-Komponente", ylabel="y", title="PLS")
axes[1].legend()
plt.tight_layout()
plt.show()
Wir drucken die R²-Werte beider Schätzer aus, was weiterhin bestätigt, dass PLS in diesem Fall eine bessere Alternative als PCR ist.
print(f"PCR r-squared {pcr.score(X_test, y_test):.3f}")
print(f"PLS r-squared {pls.score(X_test, y_test):.3f}")
Verwende PCR mit 2 Komponenten
Wir verwenden PCR mit 2 Komponenten, um es mit PLS zu vergleichen.
pca_2 = make_pipeline(PCA(n_components=2), LinearRegression())
pca_2.fit(X_train, y_train)
print(f"PCR r-squared mit 2 Komponenten {pca_2.score(X_test, y_test):.3f}")
Zusammenfassung
In diesem Lab haben wir PCR und PLS auf einem Toy-Datensatz verglichen. Wir haben festgestellt, dass PLS besser als PCR performt, wenn das Ziel stark mit Richtungen korreliert, die eine geringe Varianz aufweisen.