PCA como preprocesamiento: velocidad y reducción del ruido en pipelines
Incorporará PCA en un sklearn Pipeline antes de un clasificador y comparará el tiempo de entrenamiento y la precisión de prueba con y sin reducción de dimensionalidad.
PCA como preprocesamiento: velocidad y reducción del ruido en pipelines es una lección gratuita de Machine Learning Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Machine Learning Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Machine Learning Academy incluye 4 lecciones en total.
PCA como paso de preprocesamiento
Además de para visualización, PCA sirve como práctico paso de preprocesamiento que proporciona características comprimidas a un clasificador o regresor posterior. Al descartar componentes de baja varianza que a menudo codifican ruido, PCA puede acelerar el entrenamiento, reducir el uso de memoria y, en ocasiones, mejorar la generalización, especialmente cuando el espacio de características original tiene una dimensionalidad muy alta.
Por qué PCA puede reducir el ruido
El ruido de medición aleatorio suele distribuirse en muchas direcciones del espacio de características, pero su varianza es pequeña en cada dirección individual. PCA concentra la señal significativa en los componentes principales y deja el ruido en la cola de baja varianza. Al descartar esa cola, en la práctica elimina ruido de los datos. Por eso el preprocesamiento con PCA a veces ayuda a algoritmos como la regresión logística, que son sensibles a características correlacionadas o ruidosas.
Incorporar PCA en una Pipeline de sklearn
La forma más limpia de utilizar PCA como preprocesamiento es incluirlo dentro de una Pipeline. La canalización garantiza que el escalador y PCA se ajusten únicamente con los datos de entrenamiento y que después se apliquen de forma coherente a los datos de prueba. Esto elimina toda una clase de errores de fuga de datos que se producen cuando se olvida aplicar la misma transformación PCA al conjunto de prueba.
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))Comparación del tiempo de entrenamiento con y sin PCA
En conjuntos de datos de alta dimensionalidad, PCA puede reducir drásticamente el tiempo de entrenamiento porque el clasificador recibe muchas menos características. Compare el rendimiento de la regresión logística en el conjunto de datos de dígitos (64 características), con y sin reducción previa mediante 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}')Cuándo ayuda PCA y cuándo no
El preprocesamiento con PCA resulta especialmente útil cuando: el número de características es grande en relación con el número de muestras (régimen de alta dimensionalidad y pocas muestras), las características están correlacionadas (información redundante) o el algoritmo es lento cuando hay muchas características (por ejemplo, SVM con kernel RBF). PCA TIENDE A NO ser útil cuando: el conjunto de datos ya tiene pocas características informativas o se utilizan modelos basados en árboles (random forests, XGBoost), que gestionan de forma nativa las características redundantes y no se benefician de la compresión lineal de PCA.
Ajustar n_components en una búsqueda en rejilla
Como PCA es un paso dentro de una Pipeline, puede ajustar n_components junto con los hiperparámetros del clasificador mediante GridSearchCV. Utilice la notación de doble guion bajo pca__n_components para hacer referencia al parámetro del paso PCA. De este modo, el ciclo de validación cruzada puede encontrar simultáneamente el nivel de compresión óptimo y la intensidad de regularización del modelo.
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 antes de SVM: una combinación clásica
Las SVM con kernels RBF calculan distancias por pares en el espacio de características original, lo que resulta costoso en datos de alta dimensionalidad. Aplicar PCA primero reduce las dimensiones conservando la señal y disminuye el coste del cálculo de distancias. Esta combinación era habitual en tareas de clasificación de imágenes antes del predominio del aprendizaje profundo: reducir los píxeles de la imagen con PCA y clasificar después con 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 para reducir el ruido: un ejemplo concreto
Añadamos ruido gaussiano al conjunto de datos de dígitos y comparemos la precisión del clasificador con y sin eliminación de ruido mediante PCA. En datos ruidosos, PCA suele mejorar la precisión al descartar los componentes de baja varianza dominados por el ruido.
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}')Ajuste siempre PCA únicamente con los datos de entrenamiento
Una regla fundamental: no ajuste nunca la transformación PCA con el conjunto de prueba. Ajustarla con datos de prueba filtra las estadísticas de dicho conjunto al preprocesamiento y produce estimaciones del rendimiento excesivamente optimistas. El uso de una Pipeline impone esta regla automáticamente: cuando llama a pipeline.fit(X_train, y_train), cada paso, incluido PCA, se ajusta únicamente con la partición de entrenamiento.
Ahorro de memoria gracias a PCA
En conjuntos de datos con millones de muestras y miles de características (por ejemplo, matrices de texto TF-IDF o datos genómicos), PCA reduce drásticamente la huella de memoria. Una matriz de 1M×5000 en float32 ocupa 20 GB; aplicar PCA para obtener 100 componentes produce una matriz de 1M×100 de 400 MB, una reducción de 50×. En estos casos, utilice IncrementalPCA de scikit-learn, que ajusta PCA por bloques y nunca necesita cargar la matriz completa en 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))Combinar PCA con ColumnTransformer
En conjuntos de datos de tipos mixtos, puede aplicar PCA únicamente a las columnas numéricas, codificar las categóricas por separado y combinar después los resultados con un ColumnTransformer. Se trata de un patrón avanzado, pero realista, para canalizaciones de ML en producción en las que las características de imágenes, las mediciones numéricas y los indicadores categóricos coexisten en la misma fila.
Comprobación rápida
Compruebe su comprensión del preprocesamiento de PCA en una canalización a partir de esta lección.
Resumen de la lección
En esta lección ha aprendido que PCA dentro de una Pipeline evita la fuga de datos al ajustar la transformación únicamente con los datos de entrenamiento, que PCA puede acelerar el entrenamiento y reducir el ruido, especialmente en conjuntos de características de alta dimensionalidad o correlacionadas, y que n_components puede ajustarse mediante GridSearchCV junto con otros hiperparámetros del modelo utilizando la notación de doble guion bajo. A continuación, construiremos nuestra primera Pipeline completa de scikit-learn, combinando un escalador y un clasificador.
Aprende Python con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 30
- Lecciones
- 120
Preguntas frecuentes
¿La lección «PCA como preprocesamiento: velocidad y reducción del ruido en pipelines» es gratis?
Sí — el texto completo de «PCA como preprocesamiento: velocidad y reducción del ruido en pipelines» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Machine Learning Academy, actualiza a CoddyKit PRO. El curso de Machine Learning Academy incluye 4 lecciones en total.
¿Qué aprenderé en «PCA como preprocesamiento: velocidad y reducción del ruido en pipelines»?
Incorporará PCA en un sklearn Pipeline antes de un clasificador y comparará el tiempo de entrenamiento y la precisión de prueba con y sin reducción de dimensionalidad. Practicas Machine Learning Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Machine Learning Academy?
No se requiere experiencia previa. Machine Learning Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «PCA como preprocesamiento: velocidad y reducción del ruido en pipelines»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Machine Learning Academy?
Sí. Cada lección de Machine Learning Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- PCA: varianza, autovectores y componentes principales
- Proyección de datos y reconstrucción a partir de componentes
- t-SNE: preservación de vecindarios para visualización
- PCA como preprocesamiento: velocidad y reducción del ruido en pipelines