CursosEmpresasBlogLiveConfPrecios

PCA desde cero con NumPy paso a paso

Clase 6 de 12 • Curso Avanzado de Álgebra Lineal y Machine Learning: PCA y SVD

Contenido del curso

Tomar examen
Resumen

Aprende a implementar PCA desde cero con NumPy y valida tus resultados contra scikit-learn. En pocos pasos verás cómo estandarizar datos, calcular la matriz de covarianza, aplicar eigenanálisis y proyectar componentes principales. Además, comprobarás la equivalencia con la librería y visualizarás la reducción de 3D a 2D.

¿Qué es PCA y cómo implementarlo con NumPy?

PCA es un proceso de cuatro pasos: estandarización, covarianza, eigenanálisis y proyección. Aquí se construye una función que recibe la matriz de datos X y un número de componentes, y devuelve los datos proyectados en menor dimensión. Se trabaja en Google Colab, usando NumPy para el cálculo y comparando al final con scikit-learn.

¿Cómo estandarizar datos correctamente?

  • Centrar con media cero por columna: X − mean(X, axis=0).
  • Escalar dividiendo por la desviación estándar por columna: std(X, axis=0).
  • Resultado: un X estandarizado que evita que una variable domine por escala.

¿Cómo calcular la matriz de covarianza?

  • Usar np.cov sobre el X estandarizado considerando cada columna como característica.
  • Esta matriz describe la forma y orientación de los datos y prepara el terreno para el eigenanálisis.

¿Cómo obtener eigenvalores y proyectar componentes?

  • Calcular eigenvalores y eigenvectores con np.linalg.eig.
  • Ordenar de mayor a menor varianza con np.argsort sobre los eigenvalores en orden descendente.
  • Seleccionar las primeras n columnas de eigenvectores como componentes principales con slicing.
  • Proyectar con el producto matriz-matriz: X_estandarizado @ componentes_principales.
import numpy as np

def PCA_desde_cero(X, n_componentes):
    # Paso 1: estandarizar.
    x_centrado = X - np.mean(X, axis=0)
    x_estandarizado = x_centrado / np.std(X, axis=0)
    # Paso 2: covarianza.
    matriz_cov = np.cov(x_estandarizado, rowvar=False)
    # Paso 3: eigenanálisis.
    eigenvalores, eigenvectores = np.linalg.eig(matriz_cov)
    indices_ordenados = np.argsort(eigenvalores)[::-1]
    eigenvectores_ordenados = eigenvectores[:, indices_ordenados]
    # Paso 4: proyección.
    componentes_principales = eigenvectores_ordenados[:, :n_componentes]
    x_proyectado = x_estandarizado @ componentes_principales
    return x_proyectado

¿Cómo validar el PCA con scikit-learn y visualizar resultados?

Primero se prepara un conjunto 3D con np.column_stack(x, y, z) y se reduce a 2D con la función desde cero. Para la comparación justa con la librería, se estandarizan los datos con StandardScaler de scikit-learn antes de aplicar PCA(n_components=2) con fit_transform. Al imprimir solo las primeras cinco filas y redondear a dos decimales, los resultados coinciden prácticamente.

  • Usar StandardScaler para estandarizar antes de PCA de la librería.
  • Aplicar PCA con n_components=2 y comparar matrices proyectadas.
  • Redondear con dos decimales para una lectura clara.
  • Visualizar con matplotlib: dos subplots, dos scatter, alpha 0.7 y títulos.
  • Comprobar que ambas proyecciones en 2D “se ven exactamente igual”.

También se comenta una situación normal: puede haber diferencias de signo entre resultados. Esto es esperado porque un eigenvector define un eje; v y −v representan la misma dirección. Por eso, que un componente sea positivo en un caso y negativo en otro no significa error, siempre que los valores absolutos coincidan.

¿Qué habilidades, conceptos y keywords refuerzas aquí?

  • Estandarizar datos: centrar y escalar por desviación estándar por columna.
  • Desviación estándar: medida de dispersión usada en el escalado.
  • Matriz de covarianza: forma y orientación de los datos.
  • Eigenanálisis: eigenvalores y eigenvectores para hallar ejes de máxima varianza.
  • Componentes principales: columnas seleccionadas de eigenvectores ordenados.
  • Ordenamiento con np.argsort: selección descendente de varianza.
  • Slicing de matrices: [:, :n] para elegir n componentes.
  • Producto punto: proyección con X @ W.
  • StandardScaler y fit_transform: estandarización y proyección con scikit-learn.
  • Visualización con matplotlib: subplots, scatter, títulos y alpha.
  • Reducción de 3D a 2D: validación visual de PCA propio vs librería.

Ejercicio propuesto: crea una matriz con más de tres dimensiones, aplica el PCA desde cero y el de la librería, reduce a las dimensiones que quieras y comparte tus resultados en los comentarios. ¡Cuéntanos qué observaste y cómo te fue!