Machine Learning Academy · Leçon

PCA comme prétraitement : accélération et réduction du bruit dans les chaînes de traitement

Vous intégrerez PCA dans une chaîne de traitement sklearn avant un classifieur, puis comparerez le temps d’entraînement et la précision sur le jeu de test avec et sans réduction de dimensionnalité.

Leçon 4 sur 413 étapes

PCA comme prétraitement : accélération et réduction du bruit dans les chaînes de traitement est une leçon Machine Learning Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Machine Learning Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Machine Learning Academy comprend 4 leçons au total.

PCA comme étape de prétraitement

Au-delà de la visualisation, PCA constitue une étape de prétraitement pratique qui fournit des caractéristiques compressées à un classificateur ou un régresseur en aval. En écartant les composantes à faible variance, qui encodent souvent du bruit, PCA peut accélérer l’entraînement, réduire l’utilisation de la mémoire et parfois améliorer la capacité de généralisation, en particulier lorsque l’espace initial des caractéristiques possède une très grande dimension.

Pourquoi PCA peut réduire le bruit

Le bruit de mesure aléatoire se répartit généralement dans de nombreuses directions de l’espace des caractéristiques, mais sa variance reste faible dans chaque direction. PCA concentre le signal pertinent dans les premières composantes et laisse le bruit dans la queue à faible variance. Lorsque vous écartez cette queue, vous débruitez de fait les données. C’est pourquoi le prétraitement par PCA aide parfois des algorithmes comme la régression logistique, sensibles aux caractéristiques corrélées ou bruitées.

Intégrer PCA dans un Pipeline sklearn

La manière la plus propre d’utiliser PCA comme prétraitement consiste à l’intégrer dans un Pipeline. Le pipeline garantit que le dispositif de mise à l’échelle et PCA sont ajustés uniquement sur les données d’entraînement, puis appliqués de manière cohérente aux données d’évaluation. Cela élimine toute une catégorie d’erreurs de fuite de données qui se produisent lorsque l’on oublie d’appliquer la même transformation PCA à l’ensemble d’évaluation.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA(n_components=0.95)),
    ('clf', LogisticRegression(max_iter=500))
])

pipe.fit(X_train, y_train)
print('Test accuracy:', pipe.score(X_test, y_test).round(4))

Comparer le temps d’entraînement avec et sans PCA

Sur les jeux de données à grande dimension, PCA peut réduire considérablement le temps d’entraînement, car le classificateur traite beaucoup moins de caractéristiques. Comparons le temps d’exécution de la régression logistique sur le jeu de données des chiffres (64 caractéristiques), avec et sans réduction préalable par PCA.

import time
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

# Without PCA
t0 = time.time()
pipe_full = Pipeline([('sc', StandardScaler()), ('clf', LogisticRegression(max_iter=1000))])
pipe_full.fit(X_train, y_train)
t_full = time.time() - t0

# With PCA
t0 = time.time()
pipe_pca = Pipeline([('sc', StandardScaler()), ('pca', PCA(n_components=0.95)),
                     ('clf', LogisticRegression(max_iter=500))])
pipe_pca.fit(X_train, y_train)
t_pca = time.time() - t0

print(f'Without PCA: {t_full:.3f}s  acc={pipe_full.score(X_test, y_test):.4f}')
print(f'With PCA:    {t_pca:.3f}s  acc={pipe_pca.score(X_test, y_test):.4f}')

Quand PCA est utile et quand elle ne l’est pas

Le prétraitement par PCA est particulièrement utile lorsque le nombre de caractéristiques est élevé par rapport au nombre d’échantillons (régime de grande dimension avec peu d’échantillons), lorsque les caractéristiques sont corrélées (informations redondantes) ou lorsque l’algorithme est lent avec de nombreuses caractéristiques (par exemple, un SVM avec un noyau RBF). PCA n’est généralement PAS utile lorsque le jeu de données possède déjà peu de caractéristiques informatives ou lorsque vous utilisez des modèles fondés sur des arbres (forêts aléatoires, XGBoost), qui gèrent naturellement les caractéristiques redondantes et ne tirent pas parti de la compression linéaire de PCA.

Régler n_components dans une recherche sur grille

Comme PCA constitue une étape d’un Pipeline, vous pouvez régler n_components en même temps que les hyperparamètres du classificateur à l’aide de GridSearchCV. Utilisez la notation avec double soulignement pca__n_components pour faire référence au paramètre de l’étape PCA. La boucle de validation croisée peut ainsi trouver simultanément le niveau de compression optimal et la force de régularisation du modèle.

from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits

X, y = load_digits(return_X_y=True)

pipe = Pipeline([
    ('sc', StandardScaler()),
    ('pca', PCA()),
    ('clf', LogisticRegression(max_iter=500))
])

param_grid = {
    'pca__n_components': [10, 20, 30, 40],
    'clf__C': [0.1, 1.0, 10.0]
}

grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
grid.fit(X, y)
print('Best params:', grid.best_params_)
print('Best CV score:', grid.best_score_.round(4))

PCA avant un SVM : une combinaison classique

Les SVM avec des noyaux RBF calculent les distances deux à deux dans l’espace initial des caractéristiques, ce qui est coûteux pour les données à grande dimension. Appliquer PCA au préalable réduit le nombre de dimensions tout en conservant le signal, ce qui diminue le coût du calcul des distances. Cette combinaison était courante pour les tâches de classification d’images avant la généralisation de l’apprentissage profond : réduire les pixels de l’image avec PCA, puis effectuer la classification avec un SVM.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.datasets import load_digits
from sklearn.model_selection import cross_val_score
import numpy as np

X, y = load_digits(return_X_y=True)

pipe = Pipeline([
    ('sc', StandardScaler()),
    ('pca', PCA(n_components=30)),
    ('svm', SVC(kernel='rbf', C=10, gamma='scale'))
])

scores = cross_val_score(pipe, X, y, cv=5)
print(f'Accuracy: {np.mean(scores):.4f} +/- {np.std(scores):.4f}')

PCA pour réduire le bruit : exemple concret

Ajoutons du bruit gaussien au jeu de données des chiffres et comparons la précision du classificateur avec et sans débruitage par PCA. Sur des données bruitées, PCA améliore souvent la précision en écartant les composantes à faible variance dominées par le bruit.

import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_digits
from sklearn.model_selection import cross_val_score

X, y = load_digits(return_X_y=True)
X_noisy = X + np.random.randn(*X.shape) * 5.0  # heavy noise

for nc in [None, 10, 20, 30, 40]:
    steps = [('sc', StandardScaler())]
    if nc:
        steps.append(('pca', PCA(n_components=nc)))
    steps.append(('clf', LogisticRegression(max_iter=500)))
    pipe = Pipeline(steps)
    acc = cross_val_score(pipe, X_noisy, y, cv=5).mean()
    label = f'PCA({nc})' if nc else 'No PCA'
    print(f'{label:10s}  acc={acc:.4f}')

Ajuster toujours PCA uniquement sur les données d’entraînement

Règle essentielle : n’ajustez jamais la transformation PCA sur l’ensemble d’évaluation. L’ajustement sur les données d’évaluation introduit les statistiques de cet ensemble dans le prétraitement et fournit des estimations de performances trop optimistes. L’utilisation d’un Pipeline applique automatiquement cette règle : lorsque vous appelez pipeline.fit(X_train, y_train), chaque étape — y compris PCA — est ajustée uniquement sur la partition d’entraînement.

Économies de mémoire grâce à PCA

Pour les jeux de données comportant des millions d’échantillons et des milliers de caractéristiques (par exemple, des matrices TF-IDF de textes ou des données génomiques), PCA réduit considérablement l’empreinte mémoire. Une matrice de 1M×5000 en float32 occupe 20 Go ; une réduction par PCA à 100 composantes produit une matrice de 1M×100 de 400 Mo, soit une réduction d’un facteur 50. Dans ce cas, utilisez IncrementalPCA de scikit-learn, qui ajuste PCA par blocs et n’a jamais besoin de charger la matrice complète dans la RAM.

from sklearn.decomposition import IncrementalPCA
import numpy as np

# Simulate large dataset as batches
n_samples, n_features = 10000, 500
n_components = 50
batch_size = 500

ipca = IncrementalPCA(n_components=n_components)
for i in range(0, n_samples, batch_size):
    batch = np.random.randn(batch_size, n_features)
    ipca.partial_fit(batch)

print('Explained variance ratio sum:', ipca.explained_variance_ratio_.sum().round(4))

Combiner PCA avec ColumnTransformer

Dans les jeux de données de types mixtes, vous pouvez appliquer PCA uniquement aux colonnes numériques, tout en encodant séparément les variables catégorielles, puis combiner le tout avec un ColumnTransformer. Il s’agit d’un schéma avancé, mais réaliste, pour les chaînes de traitement ML en production, lorsque des caractéristiques d’image, des mesures numériques et des indicateurs catégoriels coexistent sur une même ligne.

Vérification rapide

Vérifiez votre compréhension de PCA en tant qu’étape de prétraitement d’une chaîne de traitement dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que PCA dans une chaîne de traitement empêche les fuites de données en ajustant la transformation uniquement sur les données d’entraînement, que PCA peut accélérer l’entraînement et réduire le bruit, en particulier pour les ensembles de caractéristiques de grande dimension ou corrélées, et que n_components peut être réglé avec GridSearchCV en même temps que les autres hyperparamètres du modèle grâce à la notation utilisant deux traits de soulignement. Nous allons maintenant construire notre première chaîne de traitement scikit-learn complète, combinant un mise à l’échelle et un classifieur.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
30
Leçons
120

Questions Fréquemment Posées

La leçon « PCA comme prétraitement : accélération et réduction du bruit dans les chaînes de traitement » est-elle gratuite ?

Oui — le texte complet de « PCA comme prétraitement : accélération et réduction du bruit dans les chaînes de traitement » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Machine Learning Academy, passe à CoddyKit PRO. Le cours Machine Learning Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « PCA comme prétraitement : accélération et réduction du bruit dans les chaînes de traitement » ?

Vous intégrerez PCA dans une chaîne de traitement sklearn avant un classifieur, puis comparerez le temps d’entraînement et la précision sur le jeu de test avec et sans réduction de dimensionnalité. Tu pratiques Machine Learning Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Machine Learning Academy ?

Aucune expérience préalable n'est requise. Machine Learning Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « PCA comme prétraitement : accélération et réduction du bruit dans les chaînes de traitement » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Machine Learning Academy ?

Oui. Chaque leçon Machine Learning Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. PCA : variance, vecteurs propres et composantes principales
  2. Projeter les données et reconstruire les caractéristiques à partir des composantes
  3. t-SNE : préservation du voisinage pour la visualisation
  4. PCA comme prétraitement : accélération et réduction du bruit dans les chaînes de traitement
← Retour à Machine Learning Academy