Tracer la PCR contre la PLS

Introduction

La Régression par Composantes Principales (PCR) et la Régression par Moindres Carrés Partiels (PLS) sont deux méthodes utilisées dans l'analyse de régression. La PCR consiste à appliquer l'Analyse en Composantes Principales (PCA) aux données d'entraînement, puis à entraîner un régresseur sur les échantillons transformés. La transformation PCA est non supervisée, ce qui signifie qu'aucune information sur les cibles n'est utilisée. En conséquence, la PCR peut donner de mauvais résultats dans certains ensembles de données où la cible est fortement corrélée avec des directions ayant une faible variance.

La PLS est à la fois un transformateur et un régresseur, et elle est assez similaire à la PCR. Elle applique également une réduction de dimensionnalité aux échantillons avant d'appliquer un régresseur linéaire aux données transformées. La principale différence avec la PCR est que la transformation PLS est supervisée. Par conséquent, elle ne souffre pas du problème mentionné ci-dessus.

Dans ce laboratoire, nous comparerons la PCR et la PLS sur un ensemble de données de démonstration.

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 Carnet de notes 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.

Skills Graph

Créer un ensemble de données

Nous commençons par créer un ensemble de données simple avec deux caractéristiques. Nous utilisons la bibliothèque numpy pour créer l'ensemble de données et la bibliothèque matplotlib pour le tracer.

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-dimensional dataset with principal components",
    xlabel="première caractéristique",
    ylabel="seconde caractéristique",
)
plt.legend()
plt.show()

Définir la cible

Dans le cadre de cet exemple, nous définissons la cible y de sorte qu'elle soit fortement corrélée avec une direction ayant une faible variance. Nous projetons X sur la deuxième composante et ajoutons du bruit à celle-ci.

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="Données projetées sur la première composante PCA", ylabel="y")
axes[1].scatter(X.dot(pca.components_[1]), y, alpha=0.3)
axes[1].set(xlabel="Données projetées sur la deuxième composante PCA", ylabel="y")
plt.tight_layout()
plt.show()

Créer les régresseurs

Nous créons deux régresseurs : la PCR et la PLS. Pour notre illustration, nous fixons le nombre de composantes à 1. Avant d'alimenter les données dans l'étape PCA de la PCR, nous les standardisons tout d'abord, comme le recommande la bonne pratique. L'estimateur PLS dispose de capacités d'échelle intégrées.

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"]  ## récupérer l'étape PCA du pipeline

pls = PLSRegression(n_components=1)
pls.fit(X_train, y_train)

#Comparer les régresseurs

Nous traçons les données projetées sur la première composante en fonction de la cible pour les deux régresseurs PCR et PLS. Dans les deux cas, ces données projetées sont celles que les régresseurs utiliseront comme données d'entraînement.

fig, axes = plt.subplots(1, 2, figsize=(10, 3))
axes[0].scatter(pca.transform(X_test), y_test, alpha=0.3, label="vérité terrain")
axes[0].scatter(
    pca.transform(X_test), pcr.predict(X_test), alpha=0.3, label="prédictions"
)
axes[0].set(
    xlabel="Données projetées sur la première composante PCA", ylabel="y", titre="PCR / PCA"
)
axes[0].legend()
axes[1].scatter(pls.transform(X_test), y_test, alpha=0.3, label="vérité terrain")
axes[1].scatter(
    pls.transform(X_test), pls.predict(X_test), alpha=0.3, label="prédictions"
)
axes[1].set(xlabel="Données projetées sur la première composante PLS", ylabel="y", titre="PLS")
axes[1].legend()
plt.tight_layout()
plt.show()

Nous affichons les scores R-carré des deux estimateurs, ce qui confirme davantage que la PLS est une meilleure alternative que la PCR dans ce cas.

print(f"PCR r-carré {pcr.score(X_test, y_test):.3f}")
print(f"PLS r-carré {pls.score(X_test, y_test):.3f}")

Utiliser la PCR avec 2 composantes

Nous utilisons la PCR avec 2 composantes pour la comparer à la PLS.

pca_2 = make_pipeline(PCA(n_components=2), LinearRegression())
pca_2.fit(X_train, y_train)
print(f"PCR r-carré avec 2 composantes {pca_2.score(X_test, y_test):.3f}")

Sommaire

Dans ce laboratoire, nous avons comparé la PCR et la PLS sur un jeu de données simplifié. Nous avons constaté que la PLS a mieux performé que la PCR lorsque la cible est fortement corrélée avec des directions ayant une faible variance.