전처리로서의 PCA: 파이프라인에서 속도 향상과 잡음 감소

PCA as a Preprocessing Step

Why PCA Can Reduce Noise

Embedding PCA in a sklearn Pipeline

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))

Comparing Training Time With and Without 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}')

When PCA Helps and When It Does Not

Tuning n_components in a Grid Search

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 Before SVM: A Classic Combination

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 for Noise Reduction: Concrete Example

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}')

Always Fit PCA on Training Data Only

Memory Savings from PCA

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))

Combining PCA with ColumnTransformer

Quick Check

Lesson Recap