Una guía técnica sobre cómo reducir dimensiones y acelerar tus modelos sin perder información crítica.
Introducción
Como mentores en Python Baires, vemos un error constante en el código de quienes se inician en Data Science: se obsesionan con la cantidad de datos, no con la calidad de la información.
Tienen un dataset con 50 columnas y piensan: "Genial, tengo mucha información". Luego entrenan un modelo que tarda horas en correr y tiene una precisión mediocre. ¿La razón? El ruido y la alta correlación.
Hoy te voy a enseñar cómo usar PCA (Principal Component Analysis). No solo para reducir el tiempo de entrenamiento, sino para que tus modelos dejen de "adivinar" y empiecen a "entender" la estructura real de tus datos.
Paso 1: Creando el Caos (Datos de E-commerce Simulado)
Vamos a crear un dataset donde muchas variables explican lo mismo.
import pandas as pd
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import time
import matplotlib.pyplot as plt
import seaborn as sns
# Configuración visual para el blog
plt.style.use('dark_background')
# Generamos 30 características, pero solo 5 son realmente informativas
X, y = make_classification(
n_samples=1000,
n_features=30,
n_informative=5,
n_redundant=10, # Muchas redundantes
n_classes=2,
random_state=42
)
# Convertimos a DataFrame para que parezca real
feature_names = [f'metrica_{i}' for i in range(30)]
df = pd.DataFrame(X, columns=feature_names)
df['compra'] = y
print("Dataset generado con 30 columnas (ruido incluido):")
print(df.head())
print(f"\nForma del dataset: {df.shape}")
Visualizando el ruido: Nota cómo las variables se mezclan entre sí, haciendo difícil distinguir patrones claros.
Paso 2: Visualización del Problema
Si intentamos ver estos datos crudos, no entenderemos nada. Veamos la correlación para confirmar el caos.
# Matriz de correlación para ver el caos (Usamos solo las primeras 10 para visualizar mejor)
plt.figure(figsize=(10, 8))
sns.heatmap(df.iloc[:, :10].corr(), annot=False, cmap='coolwarm')
plt.title("Mapa de Calor: Confusión de Variables (Primeras 10)")
plt.show()
Paso 3: El Protagonista - PCA
Aquí está la magia. PCA rotará los datos para encontrar las "mejores direcciones" o componentes principales.
# 1. Escalar SIEMPRE antes de PCA (fundamental)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(df.drop('compra', axis=1))
# 2. Aplicar PCA: Reduciremos las 30 dimensiones a 2 para visualizar
pca_visual = PCA(n_components=2)
X_pca_2d = pca_visual.fit_transform(X_scaled)
# 3. Visualizar el resultado final
plt.figure(figsize=(8, 6))
plt.scatter(X_pca_2d[:, 0], X_pca_2d[:, 1], c=y, cmap='viridis', alpha=0.6)
plt.xlabel(f"Componente Principal 1 ({pca_visual.explained_variance_ratio_[0]:.2%} varianza)")
plt.ylabel(f"Componente Principal 2 ({pca_visual.explained_variance_ratio_[1]:.2%} varianza)")
plt.title("Datos Proyectados en 2D con PCA (Separación Visible)")
plt.show()
Magia en 2D: Lo que antes era un caos indistinguible en 30 columnas, ahora se puede separar con solo 2 'lentes' (componentes).
Paso 4: Impacto en el Modelo (Velocidad vs. Precisión)
Ahora probemos en un modelo real. ¿Merece la pena perder 28 dimensiones?
# --- MODELO ORIGINAL (30 features) ---
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
# Medición de tiempo
start_time = time.time()
model_full = RandomForestClassifier(n_estimators=100, random_state=42)
model_full.fit(X_train, y_train)
pred_full = model_full.predict(X_test)
time_full = time.time() - start_time
acc_full = accuracy_score(y_test, pred_full)
# --- MODELO PCA (Reduciendo a componentes que explican el 95% de varianza) ---
pca_optimo = PCA(n_components=0.95) # Conserva el 95% de la varianza
X_train_pca = pca_optimo.fit_transform(X_train)
X_test_pca = pca_optimo.transform(X_test)
start_time = time.time()
model_pca = RandomForestClassifier(n_estimators=100, random_state=42)
model_pca.fit(X_train_pca, y_train)
pred_pca = model_pca.predict(X_test_pca)
time_pca = time.time() - start_time
acc_pca = accuracy_score(y_test, pred_pca)
print("\n--- RESULTADOS DEL RENDIMIENTO ---")
print(f"Modelo Original (30 cols): Acc: {acc_full:.4f} | Tiempo: {time_full:.4f}s")
print(f"Modelo PCA ({pca_optimo.n_components_} cols): Acc: {acc_pca:.4f} | Tiempo: {time_pca:.4f}s")
La Brecha de Conocimiento
PCA es la puerta de entrada al mundo de la reducción de dimensionalidad. Es una herramienta esencial cuando:
- Tus modelos tardan demasiado en entrenar.
- Tienes más features que filas.
- Necesitas visualizar datos complejos en 2D o 3D.
Sin embargo, PCA asume relaciones lineales. Si tus datos tienen patrones complejos no lineales, necesitas herramientas más avanzadas como Autoencoders o t-SNE, conceptos que vemos en nuestro curso avanzado.
El Siguiente Paso
Dejar de aplicar modelos "a ciegas" y empezar a entender la estructura matemática de tus datos es lo que separa a un Programador de Python de un Científico de Datos.
Si querés aprender a elegir las técnicas correctas de pre-procesamiento, dominar la visualización de datos y construir pipelines eficientes que los reclutadores valoren, Python Baires te espera.
No se trata de llenar el modelo de datos. Se trata de darle los datos correctos.
Mirá el programa completo y reservá tu lugar:
👉 (https://www.python-baires.ar/)
SOCIAL SHARE CARD GENERATOR