Cómo 'Vemos' los Datos: Por Qué tus Gráficos Engañan y Cómo Usar PCA para Arreglarlo

Source: Dev.to

El problema típico

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.

Generando un dataset de ejemplo

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

# Matriz de correlación (primeras 10 variables)
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()

Nota cómo las variables se mezclan entre sí, dificultando la detección de patrones claros.

Aplicando PCA

# 1. Escalar SIEMPRE antes de PCA (fundamental)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(df.drop('compra', axis=1))

# 2. Reducir a 2 componentes para visualización
pca_visual = PCA(n_components=2)
X_pca_2d = pca_visual.fit_transform(X_scaled)

# 3. Visualizar el resultado
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()

Qué muestra el gráfico

Lo que antes era un caos indistinguible en 30 columnas ahora se separa claramente con solo 2 “lentes” (componentes).

Comparando modelos: con y sin PCA

# --- 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 (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_:.0f} cols): Acc: {acc_pca:.4f} | Tiempo: {time_pca:.4f}s")

Observaciones

• Reducción de tiempo: el modelo con PCA entrena y predice más rápido.
• Precisión comparable: la pérdida de información es mínima cuando se conserva el 95 % de la varianza.

Cuándo usar PCA

• Los modelos tardan demasiado en entrenar.
• Tienes más features que filas.
• Necesitas visualizar datos complejos en 2D o 3D.

Nota: PCA asume relaciones lineales. Si tus datos presentan patrones no lineales, considera técnicas como Autoencoders o t‑SNE, que también cubrimos en nuestro curso avanzado.

Conclusión

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 quieres aprender a elegir las técnicas correctas de pre‑procesamiento, dominar la visualización y construir pipelines eficientes que los reclutadores valoren, Python Baires te espera.

Mirá el programa completo y reservá tu lugar:
https://www.python-baires.ar/