Régression PCR & PLS en R : composantes principales & moindres carrés partiels
Maîtrisez de nombreux prédicteurs corrélés en régressant sur quelques composantes — choisies honnêtement par validation croisée
Un guide pratique de la régression sur composantes principales (PCR) et de la régression des moindres carrés partiels (PLS) en R. Les deux compressent de nombreux prédicteurs corrélés en quelques composantes et régressent sur celles-ci — la PCR construit les composantes à partir des seuls prédicteurs, la PLS les construit pour qu’elles corrèlent aussi avec la réponse (réduction de dimension supervisée). Découvrez comment choisir le nombre de composantes par validation croisée à partir de la courbe RMSEP-vs-composantes, lire la variance expliquée et opposer la PCR à la PLS. Traité de deux façons — le paquet classique pls (pcr/plsr + validationplot) et la recette moderne tidymodels (step_pca + tune) — sur les données Boston intégrées.
Date de publication
25 juin 2026
Modifié
7 juillet 2026
AstucePoints clés
La PCR (régression sur composantes principales) et la PLS (moindres carrés partiels) corrigent toutes deux le même problème : trop de prédicteurs, surtout des prédicteurs corrélés. Elles compressent les prédicteurs en quelques composantes, puis régressent la réponse sur ces composantes plutôt que sur les originaux.
La PCR construit les composantes avec l’ACP — à partir des prédicteurs seuls, en ignorant la réponse. La PLS les construit pour qu’elles corrèlent aussi avec la réponse — réduction de dimension supervisée. C’est toute la différence.
L’unique bouton de réglage est ncomp, le nombre de composantes à conserver. Vous le choisissez par validation croisée, en lisant la courbe RMSEP-vs-composantes — le graphique emblématique de cette méthode.
Standardisez d’abord les prédicteurs (scale = TRUE, ou step_normalize()) — les composantes sont construites à partir de variances, donc les prédicteurs doivent partager une même échelle, sinon un prédicteur à grande unité dominerait.
Comme la PLS utilise la réponse pour construire ses composantes, elle atteint généralement un bon modèle avec moins de composantes que la PCR. Sur les données Boston, l’erreur de la PCR se stabilise autour de 5 composantes, la PLS vers environ 3 — même précision, un modèle plus compact.
Deux routes, une même idée : le paquet classique pls (pcr() / plsr() + validationplot()), et la recette moderne tidymodels (step_pca() + tune()), qui laisse la validation croisée choisir ncomp à l’intérieur d’un workflow.
Vous avez une régression avec de nombreux prédicteurs, et plusieurs d’entre eux sont corrélés les uns aux autres. La méthode des moindres carrés ordinaires déteste cela : des prédicteurs corrélés rendent ses coefficients instables, et lorsque les prédicteurs approchent du nombre d’observations, elle surajuste sévèrement. Un remède consiste à supprimer ou réduire des prédicteurs (la régression pas-à-pas et la régression pénalisée le font). Un autre remède est la réduction de dimension : ne choisissez pas quels prédicteurs garder — à la place, compressez-les tous en une poignée de nouvelles composantes non corrélées, et régressez sur celles-ci.
C’est ce que font la régression sur composantes principales (PCR) et les moindres carrés partiels (PLS). Les deux résument les prédicteurs originaux en quelques composantes — des combinaisons linéaires des originaux — et ajustent le modèle linéaire sur ces composantes. Comme les composantes sont non corrélées par construction, le problème de multicolinéarité disparaît tout simplement ; et comme il n’y en a que quelques-unes, le modèle est bien moins enclin au surajustement.
Les deux méthodes diffèrent par la façon dont elles construisent les composantes :
La PCR exécute une analyse en composantes principales sur les prédicteurs, en prenant les directions de plus grande variance des prédicteurs — la réponse n’y joue aucun rôle. Elle régresse ensuite la réponse sur les premières de ces composantes.
La PLS construit des composantes qui résument les prédicteurs et corrèlent avec la réponse — réduction de dimension supervisée. En orientant les composantes vers ce que vous prédisez, la PLS a généralement besoin de moins d’entre elles.
Cette leçon couvre les deux, de façon pratique : choisir le nombre de composantes par validation croisée, lire la variance expliquée et opposer la PCR à la PLS. Nous le traitons de deux façons — le paquet classique pls que la plupart des utilisateurs R apprennent en premier, et la recette moderne tidymodels.
NoteQuand recourir à la PCR / PLS
Utilisez-les lorsque vous avez de nombreux prédicteurs, surtout fortement corrélés, ou lorsque le nombre de prédicteurs approche (ou dépasse) le nombre d’observations (p proche de n) — le cadre classique en chimiométrie, en génomique et pour les données de capteurs. Préférez la PLS à la PCR lorsque vous voulez le modèle le plus compact, puisque ses composantes sont orientées vers la réponse. Le compromis : contrairement à la régression pénalisée, la PCR et la PLS n’effectuent pas de sélection de variables et ne vous fournissent pas de coefficients par prédicteur interprétables — vous échangez l’interprétabilité contre un prédicteur stable et compact.
Les données
Nous utilisons le jeu de données intégré Boston du paquet MASS : 506 banlieues de Boston, prédisant medv — la valeur médiane des logements (en milliers de $) — à partir de 13 prédicteurs socio-économiques et structurels (taux de criminalité crim, nombre moyen de pièces rm, ratio élèves–enseignant ptratio, population % lower-statuslstat, et ainsi de suite). Plusieurs de ces prédicteurs sont corrélés — exactement le cadre où la réduction de dimension fait ses preuves.
Nous séparons en un jeu d’entraînement (80 %, pour l’ajustement et le choix de ncomp) et un jeu de test (20 %, mis de côté pour juger honnêtement le modèle final), en stratifiant sur medv et en fixant une graine pour la reproductibilité :
library(rsample)data("Boston", package ="MASS")# 506 Boston suburbs: predict median home value (medv) from 13 predictorsset.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)test_data <-testing(split)c(train =nrow(train_data), test =nrow(test_data), predictors =ncol(Boston) -1)
Environ 400 banlieues pour apprendre, 100 mises de côté pour être le juge, et 13 prédicteurs corrélés à compresser.
La route classique : le paquet pls
La plupart des utilisateurs R découvrent la PCR et la PLS via le paquet pls. Ses deux fonctions — pcr() et plsr() — ont une interface identique, donc dès que vous en connaissez une vous les connaissez toutes les deux. Deux arguments importent :
scale = TRUE standardise les prédicteurs avant de construire les composantes (requis — voir la note sur la standardisation ci-dessus).
validation = "CV" exécute une validation croisée à 10 plis intégrée, donc le modèle connaît déjà son erreur validée par validation croisée pour chaque nombre de composantes.
Régression sur composantes principales
Nous ajustons la PCR sur le jeu d’entraînement avec la validation croisée activée :
Le graphique emblématique : RMSEP vs nombre de composantes
Le graphique le plus utile en PCR/PLS est l’erreur de prédiction validée par validation croisée (RMSEP) en fonction du nombre de composantes. validationplot() le trace directement à partir du modèle ajusté. Il montre tout le compromis biais–variance en une seule image — combien chaque composante supplémentaire vous rapporte :
library(pls)library(rsample)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)set.seed(123)pcr_model <-pcr(medv ~ ., data = train_data, scale =TRUE, validation ="CV")# RMSEP against the number of components (the signature PCR/PLS plot)validationplot(pcr_model, val.type ="RMSEP",main ="PCR: cross-validated error vs number of components",col ="#3a86d4", lwd =2)
Lisez-le de gauche à droite. Avec zéro composante, le modèle n’est que la moyenne de medv et l’erreur est élevée (~9). Chacune des premières composantes porte un vrai signal, donc l’erreur chute fortement. Puis — autour de cinq composantes — la courbe s’aplatit en un plateau : les composantes supplémentaires n’ajoutent presque rien d’autre que de la complexité au modèle. La lecture pratique n’est pas « trouver le point le plus bas » (la courbe est si plate que le minimum technique se situe au modèle complet et est statistiquement indiscernable de ses voisins) — c’est « où la courbe cesse-t-elle de s’améliorer ? » Ici, c’est environ cinq composantes.
Combien de composantes ? Lisez les chiffres
RMSEP() donne l’erreur exacte validée par validation croisée pour chaque nombre de composantes, et summary() ajoute le pourcentage de variance expliquée — à la fois dans les prédicteurs (X) et dans la réponse (medv) :
library(pls)library(rsample)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)set.seed(123)pcr_model <-pcr(medv ~ ., data = train_data, scale =TRUE, validation ="CV")# Cross-validated RMSEP at each number of components (adjusted CV)round(RMSEP(pcr_model)$val["adjCV", 1, ], 2)
La RMSEP chute de 9.2 (0 composante) à environ 5.1 dès 5 composantes, puis bouge à peine — le plateau qu’a montré le graphique. Et les chiffres de variance expliquent pourquoi : les 5 premières composantes captent environ 81 % de l’information contenue dans les prédicteurs. La lecture classique du livre sur ces données exactes est que 5 composantes est le point optimal — il minimise l’erreur de validation croisée tout en expliquant suffisamment de variation à la fois dans les prédicteurs et dans la réponse. Nous verrouillerons ce choix et l’évaluerons ci-dessous.
Évaluer le modèle choisi sur le jeu de test
Choisissez ncomp = 5, prédisez le jeu de test mis de côté, et lisez l’erreur honnête hors échantillon avec yardstick :
library(pls)library(rsample)library(yardstick)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)test_data <-testing(split)set.seed(123)pcr_model <-pcr(medv ~ ., data = train_data, scale =TRUE, validation ="CV")# Predict the test set using the first 5 componentspcr_pred <-as.vector(predict(pcr_model, test_data, ncomp =5))data.frame(ncomp =5,RMSE =rmse_vec(test_data$medv, pcr_pred),R2 =rsq_vec(test_data$medv, pcr_pred))
ncomp RMSE R2
1 5 5.470239 0.6412357
Lisez les chiffres :
RMSE ≈ 5.5 — une prédiction typique de la valeur médiane des logements s’écarte d’environ 5 500 $ (la réponse est en milliers de $). Plus bas est meilleur ; c’est le chiffre sur lequel comparer les modèles.
R² ≈ 0.64 — le modèle à 5 composantes explique environ 64 % de la variance de la valeur médiane des logements sur des banlieues qu’il n’a jamais vues. Un modèle compact construit à partir de seulement 5 composantes, et non des 13 prédicteurs corrélés.
Moindres carrés partiels
Le code PLS est identique — remplacez pcr() par plsr(). La différence est interne : la PLS construit ses composantes pour qu’elles corrèlent avec medv, et pas seulement pour résumer les prédicteurs. Observez ce que cela fait à la courbe :
library(pls)library(rsample)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)# PLS: supervised dimension reduction (components correlate with the outcome)set.seed(123)pls_model <-plsr(medv ~ ., data = train_data, scale =TRUE, validation ="CV")validationplot(pls_model, val.type ="RMSEP",main ="PLS: cross-validated error vs number of components",col ="#3a86d4", lwd =2)
Même forme, mais le coude arrive plus tôt : la PLS atteint son plateau après seulement environ 2–3 composantes, là où la PCR en avait besoin de 5. C’est la réduction de dimension supervisée qui porte ses fruits — en orientant les composantes vers medv, la PLS concentre le signal pertinent pour la réponse dans moins de dimensions.
Le tableau de variance expliquée le rend concret :
library(pls)library(rsample)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)set.seed(123)pls_model <-plsr(medv ~ ., data = train_data, scale =TRUE, validation ="CV")# Cross-validated RMSEP at each number of componentsround(RMSEP(pls_model)$val["adjCV", 1, ], 2)
La PLS atteint déjà son plancher (RMSEP ≈ 5.0) dès 3 composantes et ne s’améliore plus guère au-delà — un modèle plus compact que la PCR pour la même précision. Évaluez une PLS à 3 composantes sur le jeu de test :
library(pls)library(rsample)library(yardstick)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)test_data <-testing(split)set.seed(123)pls_model <-plsr(medv ~ ., data = train_data, scale =TRUE, validation ="CV")# Predict the test set with 3 PLS componentspls_pred <-as.vector(predict(pls_model, test_data, ncomp =3))data.frame(ncomp =3,RMSE =rmse_vec(test_data$medv, pls_pred),R2 =rsq_vec(test_data$medv, pls_pred))
ncomp RMSE R2
1 3 5.152494 0.6819448
La PLS égale ou bat légèrement la précision de la PCR à 5 composantes (RMSE ≈ 5.2, R² ≈ 0.68) avec 3 composantes au lieu de 5. Prédiction comparable, un modèle plus petit — l’argument pratique en faveur de la PLS plutôt que de la PCR lorsque vos prédicteurs sont nombreux et corrélés.
NotePCR ou PLS — laquelle ?
Les deux compressent des prédicteurs corrélés en composantes non corrélées, donc toutes deux éliminent la multicolinéarité. La PCR construit les composantes à partir des seuls prédicteurs (non supervisée), donc elle peut dépenser ses premières composantes sur de la variance des prédicteurs qui n’a rien à voir avec la réponse. La PLS oriente ses composantes vers la réponse, donc elle atteint généralement la même précision avec moins de composantes — un modèle plus compact. En pratique, la PLS est le choix par défaut pour le travail prédictif ; la PCR est plus simple à expliquer et convient lorsque vous interpréterez les composantes elles-mêmes. Ni l’une ni l’autre ne fait de sélection de variables — si vous en avez besoin, utilisez le lasso ou l’elastic net.
La route moderne : tidymodels (la PCR comme recette)
La PCR n’est que de l’ACP + régression linéaire, et tidymodels vous permet d’exprimer exactement cela comme une recipe : step_normalize() pour standardiser, puis step_pca() pour construire les composantes, puis un linear_reg() ordinaire. Le nombre de composantes devient un paramètre réglable — num_comp = tune() — que la validation croisée choisit à l’intérieur du workflow, le même enchaînement tidymodels que vous connaissez déjà :
library(rsample)library(recipes)library(parsnip)library(workflows)library(tune)library(yardstick)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)# PCR = normalize -> PCA (number of components to tune) -> linear regressionpcr_rec <-recipe(medv ~ ., data = train_data) |>step_normalize(all_numeric_predictors()) |>step_pca(all_numeric_predictors(), num_comp =tune())pcr_wf <-workflow() |>add_recipe(pcr_rec) |>add_model(linear_reg() |>set_engine("lm"))# Try 1 to 13 components, scored by 10-fold CV on the training setset.seed(123)folds <-vfold_cv(train_data, v =10)grid <-data.frame(num_comp =1:13)set.seed(123)pcr_tuned <-tune_grid( pcr_wf, resamples = folds, grid = grid,metrics =metric_set(rmse, rsq))# The cross-validated RMSE at each number of componentssubset(collect_metrics(pcr_tuned), .metric =="rmse")[, c("num_comp", "mean", "std_err")]
La RMSE validée par validation croisée trace la même courbe qu’a montrée le graphique pls — abrupte sur les premières composantes, puis un plateau plat à partir d’environ cinq. Plutôt que d’estimer le coude à l’œil, tidymodels dispose d’une règle de principe pour « le modèle le plus simple qui reste aussi bon que le meilleur » : select_by_one_std_err() choisit le plus petit nombre de composantes dont l’erreur reste à moins d’une erreur standard de la plus basse. C’est le choix parcimonieux — et il se fixe sur 5 composantes, en accord avec la lecture classique :
library(rsample)library(recipes)library(parsnip)library(workflows)library(tune)library(yardstick)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)pcr_rec <-recipe(medv ~ ., data = train_data) |>step_normalize(all_numeric_predictors()) |>step_pca(all_numeric_predictors(), num_comp =tune())pcr_wf <-workflow() |>add_recipe(pcr_rec) |>add_model(linear_reg() |>set_engine("lm"))set.seed(123); folds <-vfold_cv(train_data, v =10)set.seed(123)pcr_tuned <-tune_grid(pcr_wf, resamples = folds, grid =data.frame(num_comp =1:13),metrics =metric_set(rmse, rsq))# Simplest model within one standard error of the bestbest_ncomp <-select_by_one_std_err(pcr_tuned, num_comp, metric ="rmse")best_ncomp
# Finalize with that choice, fit on train, score ONCE on the held-out test setfinal_fit <-finalize_workflow(pcr_wf, best_ncomp) |>last_fit(split)collect_metrics(final_fit)
# A tibble: 2 × 4
.metric .estimator .estimate .config
<chr> <chr> <dbl> <chr>
1 rmse standard 5.47 pre0_mod0_post0
2 rsq standard 0.641 pre0_mod0_post0
select_by_one_std_err() a choisi 5 composantes — le même nombre que celui vers lequel pointait la route pls — et le modèle finalisé obtient RMSE ≈ 5.5, R² ≈ 0.64 sur le jeu de test intact, en accord avec la PCR classique ci-dessus. Deux routes, une seule réponse : un modèle compact à 5 composantes qui gère les prédicteurs corrélés sans surajuster.
NotePourquoi pas plsmod ?
tidymodels dispose d’un moteur parsnip pour la PLS via le paquet plsmod (pls_reg() |> set_engine("mixOmics")), mais il n’est pas installé dans cet environnement, donc nous enseignons la PLS via la route plsr() ci-dessus (ce qu’utilisent de toute façon la plupart des utilisateurs R) et réservons l’approche tidymodels par recipe à la PCR, où step_pca() l’exprime exactement. L’idée est identique : si vous avez plsmod, un workflow PLS règle num_comp de la même façon que le fait ici la recette PCR.
NoteComment la PCR & la PLS construisent leurs composantes (optionnel)
Les deux méthodes remplacent les prédicteurs originaux \(X_1, \dots, X_p\) par quelques composantes\(Z_1, \dots,
Z_M\) (\(M \ll p\)), chacune une combinaison linéaire des originaux, \(Z_m = \sum_{j} \phi_{jm} X_j\), puis ajustent les moindres carrés ordinaires de la réponse sur \(Z_1, \dots, Z_M\). Comme les composantes sont construites pour être non corrélées, la multicolinéarité qui déstabilise les MCO sur les prédicteurs bruts a disparu.
Les méthodes ne diffèrent que par la façon dont les chargements \(\phi_{jm}\) sont choisis :
La PCR les fixe par analyse en composantes principales : \(Z_1\) est la direction de plus grande variance dans \(X\), \(Z_2\) la suivante orthogonale à elle, et ainsi de suite. La réponse \(Y\) n’est jamais consultée — les directions sont choisies purement pour résumer les prédicteurs, c’est pourquoi la PCR peut « gaspiller » ses premières composantes sur de la variance des prédicteurs sans rapport avec \(Y\).
La PLS choisit chaque \(Z_m\) pour qu’il ait une variance élevée et une corrélation élevée avec \(Y\) — elle pondère les prédicteurs selon leur association univariée avec la réponse. En regardant \(Y\), la PLS oriente ses composantes vers ce que vous prédisez, donc elle atteint généralement un bon ajustement avec moins de composantes que la PCR (comme l’ont montré les courbes Boston : la PLS a plafonné vers ~3, la PCR vers ~5).
Dans les deux cas, le nombre de composantes \(M\) est l’unique paramètre de réglage, choisi par validation croisée (\(M = p\) retrouve les moindres carrés ordinaires sur tous les prédicteurs ; un petit \(M\) est le modèle régularisé et compact). Et comme les composantes sont construites à partir de variances et de covariances, les prédicteurs doivent être standardisés d’abord — sinon un prédicteur à grande unité dominerait chaque composante simplement par son échelle.
Vous venez de caret ? La table de correspondance
Si vous calculiez la PCR/PLS avec le train(method = "pcr" / "pls") de caret, les idées se transposent directement — caret ne faisait lui-même qu’appeler le paquet pls en coulisses. Les verbes changent ; le workflow non :
RMSEP() / validationplot() sur toutes les composantes
model$bestTune (meilleur ncomp)
lire le plateau depuis validationplot(), ou select_by_one_std_err()
predict(model, test.data)
predict(model, test_data, ncomp = M)
La route tidymodels par recette (step_pca() + tune()) est l’équivalent moderne pour la PCR, avec la validation croisée intégrée au workflow.
🟢 Avec un agent IA
Vous avez une régression avec trop de prédicteurs corrélés ? Demandez à Prova« ajuste une PCR et une PLS à ces données, choisis le nombre de composantes par validation croisée, et dis-moi laquelle donne le modèle le plus compact » — elle répond avec du code pls + tidymodels que vous pouvez exécuter sur vos propres données, puis vous aide à lire la courbe RMSEP-vs-composantes et à choisir ncomp. The runtime is the judge.Demander à Prova →
Problèmes courants
Vous avez oublié de standardiser les prédicteurs. Les composantes sont construites à partir de variances, donc un prédicteur en grandes unités les dominerait simplement par son échelle. Passez toujours scale = TRUE à pcr() / plsr() (ou step_normalize(all_numeric_predictors()) dans une recette). L’omettre donne des composantes dénuées de sens.
Vous avez choisi le point le plus bas de la courbe de CV. La courbe RMSEP est généralement plate au-delà du coude, donc le minimum technique se situe souvent au modèle complet et n’est pas meilleur qu’un modèle bien plus simple. Choisissez là où la courbe cesse de s’améliorer (le plateau), pas le minimum absolu — ou utilisez select_by_one_std_err() pour rendre ce choix de principe.
Vous attendiez des coefficients par prédicteur à interpréter. La PCR et la PLS régressent sur des composantes, pas sur les prédicteurs originaux, donc elles ne vous fournissent pas un coefficient propre « effet de lstat ». Si l’interprétation compte plus qu’un prédicteur compact, utilisez la régression pénalisée (qui sélectionne des variables) ou ajustez une régression ordinaire.
Deux exécutions donnent des ncomp légèrement différents. Le découpage de la validation croisée est aléatoire. Appelez set.seed() avant l’ajustement (la CV de pls) ou avant vfold_cv() pour un résultat reproductible.
Questions fréquentes
NoteComment exécuter une régression sur composantes principales (PCR) en R ?
Utilisez le paquet pls : pcr(y ~ ., data = train, scale = TRUE, validation = "CV") ajuste une PCR avec des prédicteurs standardisés et une validation croisée intégrée. Lisez le nombre de composantes depuis validationplot(model) (choisissez le plateau), puis predict(model, test, ncomp = M). De manière équivalente, en tidymodels, construisez une recette avec step_normalize() + step_pca(num_comp = tune()), ajoutez un modèle linear_reg(), et réglez num_comp avec tune_grid().
NoteComment exécuter une régression des moindres carrés partiels (PLS) en R ?
Comme la PCR mais avec plsr() au lieu de pcr() : plsr(y ~ ., data = train, scale = TRUE, validation = "CV"). L’interface est identique ; la PLS construit simplement des composantes qui corrèlent aussi avec la réponse, donc elle en a généralement besoin de moins. Choisissez ncomp depuis validationplot(model) et prédisez avec predict(model, test, ncomp = M).
NoteQuelle est la différence entre la PCR et la PLS ?
Les deux réduisent de nombreux prédicteurs corrélés à quelques composantes non corrélées et régressent sur celles-ci. La PCR construit les composantes à partir des seuls prédicteurs (ACP non supervisée — la réponse est ignorée), donc les premières composantes peuvent capter de la variance des prédicteurs sans rapport avec ce que vous prédisez. La PLS construit des composantes qui corrèlent aussi avec la réponse (supervisée), donc elle atteint généralement la même précision avec moins de composantes — un modèle plus compact. La PLS est le choix par défaut courant pour la prédiction.
NoteComment choisir le nombre de composantes en PCR ou PLS ?
Par validation croisée. Ajustez avec validation = "CV" et regardez le graphique RMSEP-vs-composantes (validationplot()) : l’erreur chute fortement, puis s’aplatit. Choisissez le nombre de composantes là où la courbe cesse de s’améliorer (le plateau), pas le minimum absolu — les composantes supplémentaires au-delà ajoutent de la complexité sans gain de précision. En tidymodels, select_by_one_std_err() fait ce choix automatiquement (le plus petit nombre de composantes à moins d’une erreur standard du meilleur).
NoteQuand devrais-je utiliser la PCR/PLS plutôt que le lasso ou la régression ridge ?
Recourez à la PCR/PLS lorsque vous avez de nombreux prédicteurs fortement corrélés ou p proche de n, et que vous n’avez pas besoin d’interpréter les coefficients individuels — elles compressent tout en quelques composantes stables. Recourez à la régression pénalisée (lasso/ridge/elastic net) lorsque vous voulez une sélection de variables ou des coefficients par prédicteur interprétables — le lasso supprime entièrement les prédicteurs faibles. Elles prédisent souvent de manière similaire ; le choix porte sur l’interprétabilité par rapport à la compression.
Testez vos connaissances
ImportantExercice : ajuster une PLS et trouver où son erreur plafonne
À partir des données Boston (MASS), ajustez un modèle PLS à la façon pls : séparez en 80/20 stratifié sur medv, standardisez les prédicteurs, et exécutez une validation croisée à 10 plis. Affichez la RMSEP validée par validation croisée pour chaque nombre de composantes et identifiez où la courbe plafonne. Évaluez ensuite un modèle à ce nombre de composantes sur le jeu de test. De combien de composantes avez-vous besoin ?
AstuceIndice
Utilisez plsr(medv ~ ., data = train_data, scale = TRUE, validation = "CV"). Lisez l’erreur par composante avec RMSEP(model)$val["adjCV", 1, ]. Le plateau est là où les composantes supplémentaires cessent d’abaisser la RMSEP. Prédisez avec predict(model, test_data, ncomp = M) et évaluez avec rmse_vec() / rsq_vec() de yardstick.
AstuceSolution
library(pls); library(rsample); library(yardstick)data("Boston", package ="MASS")set.seed(123)split <-initial_split(Boston, prop =0.80, strata = medv)train_data <-training(split)test_data <-testing(split)set.seed(123)pls_model <-plsr(medv ~ ., data = train_data, scale =TRUE, validation ="CV")# Cross-validated RMSEP at each number of componentsround(RMSEP(pls_model)$val["adjCV", 1, ], 2)# Score a 3-component model on the test setpred <-as.vector(predict(pls_model, test_data, ncomp =3))data.frame(RMSE =rmse_vec(test_data$medv, pred),R2 =rsq_vec(test_data$medv, pred))
La RMSEP chute à ≈ 5.0 dès 3 composantes et ne s’améliore guère après — donc une PLS à 3 composantes suffit. Elle obtient RMSE ≈ 5.2, R² ≈ 0.68 sur le jeu de test : égalant ou battant légèrement la PCR à 5 composantes, avec moins de composantes. C’est la réduction de dimension supervisée qui fait ses preuves.
Vérification rapide. Vous ajustez une PCR et une PLS aux mêmes données. La PCR a besoin de 5 composantes pour atteindre son erreur la plus basse validée par validation croisée ; la PLS atteint la même erreur avec 3. Quelle méthode a utilisé la réponse pour construire ses composantes, et pourquoi cela explique-t-il la différence ?
NoteAfficher la réponse
La PLS a utilisé la réponse. La PCR construit ses composantes par ACP sur les seuls prédicteurs — elle choisit des directions de plus grande variance des prédicteurs sans tenir compte de leur rapport avec medv, donc elle peut « gaspiller » ses premières composantes sur une structure des prédicteurs sans rapport avec la réponse. La PLS construit des composantes qui corrèlent aussi avec medv (réduction de dimension supervisée), donc elle concentre le signal pertinent pour la réponse dans moins de composantes — atteignant la même précision avec 3 au lieu de 5. Ce modèle plus petit est la raison pratique de préférer la PLS.
Conclusion
Vous avez vu la régression par réduction de dimension de bout en bout sur les données Boston. La PCR exécute une ACP sur les prédicteurs et régresse sur les premières composantes ; la PLS construit ses composantes pour qu’elles corrèlent aussi avec la réponse — réduction de dimension supervisée — et atteint ainsi la même précision avec moins de composantes (≈ 3 vs ≈ 5 ici). Vous avez choisi ncomp honnêtement à partir de la courbe RMSEP-vs-composantes — le graphique emblématique — à la fois de la façon classique (pls::pcr() / plsr() + validationplot()) et de la façon moderne tidymodels (step_pca() + tune() + select_by_one_std_err()), et lu la variance expliquée dans les prédicteurs et la réponse. La règle pratique : standardisez d’abord, laissez la validation croisée choisir le nombre de composantes là où la courbe plafonne, et préférez la PLS quand vous voulez le modèle le plus compact.
Régression pénalisée — l’alternative par sélection de variables (ridge, lasso, elastic net) lorsque vous voulez des coefficients interprétables plutôt que des composantes. · Analyse en composantes principales — la réduction de dimension sur laquelle la PCR régresse, expliquée en détail. · Construire & valider des modèles avec tidymodels — le workflow séparation → recipe → tune → finalisation qu’utilise cette leçon. · Validation croisée — comment le nombre de composantes est choisi honnêtement.
Prouvez que vous savez le faire. Maîtrisez toute la série Sélection de modèles en R — suivez votre parcours, construisez des projets et obtenez un certificat.
Cette leçon est reproductible : chaque métrique, courbe et figure a été produite par le code montré — copiez n’importe quel bloc et exécutez-le pour les reproduire. The runtime is the judge.
Références
James, G., Witten, D., Hastie, T., & Tibshirani, R. (2014). An Introduction to Statistical Learning, with Applications in R. Springer. (Chapitre 6 — Linear Model Selection and Regularization.)
Mevik, B.-H., & Wehrens, R. (2007). The pls Package: Principal Component and Partial Least Squares Regression in R. Journal of Statistical Software, 18(2).
Kuhn, M., & Silge, J. Tidy Modeling with R. En ligne gratuitement (CC BY-NC-SA).
