Pandas & NumPy Academy · Lección

Introducción a valores propios y SVD

Calcule valores y vectores propios con np.linalg.eig y comprenda cómo SVD sustenta la reducción de dimensionalidad mediante PCA.

Lección 4 de 413 pasos

Introducción a valores propios y SVD es una lección gratuita de Pandas & NumPy 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 Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Qué son los valores y vectores propios?

Un vector propio de una matriz cuadrada A es un vector no nulo v tal que A @ v = lambda * v: multiplicarlo por A solo escala v, pero no cambia su dirección. El escalar lambda se denomina valor propio correspondiente a v. Los valores propios revelan los «factores de estiramiento» intrínsecos de una transformación lineal: un valor propio de 2 significa que la matriz duplica las longitudes en la dirección del vector propio; un valor propio negativo invierte la dirección.

import numpy as np

A = np.array([[3.0, 1.0],
              [0.0, 2.0]])

eigenvalues, eigenvectors = np.linalg.eig(A)
print('Eigenvalues:', eigenvalues)
print('Eigenvectors (columns):')
print(eigenvectors)

Cálculo de valores propios con np.linalg.eig()

np.linalg.eig(A) devuelve una tupla (eigenvalues, eigenvectors). Los valores propios son un array unidimensional; los vectores propios son un array bidimensional en el que cada columna es un vector propio. En el caso de matrices simétricas reales, como las matrices de covarianza, los valores propios siempre son reales y los vectores propios son ortogonales. Use np.linalg.eigh(A) para matrices simétricas, ya que es más rápido y garantiza resultados reales.

import numpy as np

# Symmetric matrix -> use eigh for efficiency and real eigenvalues
A = np.array([[4.0, 2.0],
              [2.0, 3.0]])

vals, vecs = np.linalg.eigh(A)
print('Eigenvalues (real):', vals)
print('Eigenvectors (orthonormal columns):')
print(vecs)

# Verify: A @ v = lambda * v for each eigenvector
for i in range(len(vals)):
    lhs = A @ vecs[:, i]
    rhs = vals[i] * vecs[:, i]
    print(f'v{i} check:', np.allclose(lhs, rhs))

Valores propios y propiedades de las matrices

Los valores propios codifican propiedades importantes de las matrices. El determinante es igual al producto de todos los valores propios: det(A) = product(eigenvalues). La traza (la suma de los elementos de la diagonal) es igual a la suma de los valores propios: trace(A) = sum(eigenvalues). Una matriz es definida positiva (todos sus valores propios son > 0) únicamente si todos los valores propios son positivos; esta es una propiedad crucial para las matrices de covarianza válidas y los problemas de optimización convexa.

import numpy as np

A = np.array([[4.0, 2.0],
              [2.0, 3.0]])

vals, _ = np.linalg.eigh(A)
print('Eigenvalues:', vals)
print('Product (should = det):', np.prod(vals))
print('np.linalg.det:', np.linalg.det(A))
print('Sum (should = trace):', np.sum(vals))
print('np.trace:', np.trace(A))
print('Positive definite:', np.all(vals > 0))

Descripción general de la descomposición en valores singulares (SVD)

La descomposición en valores singulares (SVD) descompone cualquier matriz A, no solo las cuadradas, como A = U @ S @ V.T, donde U y V son matrices ortogonales y S es diagonal, con valores singulares no negativos en la diagonal. La SVD es la factorización matricial más general y numéricamente estable. Es fundamental para PCA, la compresión de imágenes, los sistemas de recomendación y el cálculo de la pseudoinversa. np.linalg.svd(A) devuelve U, s (los valores singulares en un array unidimensional) y Vh (V transpuesta).

import numpy as np

A = np.array([[1.0, 2.0, 3.0],
              [4.0, 5.0, 6.0]])

U, s, Vh = np.linalg.svd(A, full_matrices=False)
print('U shape:', U.shape)
print('s (singular values):', s)
print('Vh shape:', Vh.shape)

# Reconstruct A
A_reconstructed = U @ np.diag(s) @ Vh
print('Reconstruction correct:', np.allclose(A, A_reconstructed))

Valores singulares y rango de una matriz

Los valores singulares (la diagonal de S) siempre son no negativos y, por convención, se enumeran en orden descendente. El número de valores singulares distintos de cero es igual al rango de la matriz. Los valores singulares cercanos a cero indican una dependencia casi lineal entre las filas o columnas. El mayor valor singular proporciona la norma espectral de la matriz, y el cociente entre el mayor y el menor valor singular distinto de cero es el número de condición utilizado para medir la estabilidad numérica.

import numpy as np

# Full-rank matrix
A = np.random.rand(5, 3)
U, s, Vh = np.linalg.svd(A, full_matrices=False)
print('Singular values:', np.round(s, 4))
print('Rank (non-zero sv):', np.linalg.matrix_rank(A))
print('Condition number:', s[0] / s[-1])

# Rank-deficient matrix
B = np.array([[1.0, 2.0], [2.0, 4.0], [3.0, 6.0]])
_, sb, _ = np.linalg.svd(B, full_matrices=False)
print('Rank-deficient sv:', np.round(sb, 8))

SVD y PCA: la conexión

El análisis de componentes principales (PCA) se puede implementar directamente mediante SVD. Después de centrar la matriz de datos X (restando las medias de las columnas), los vectores singulares derechos de Vh son los componentes principales, y los valores singulares al cuadrado, divididos por n-1, son las varianzas explicadas. El PCA de Sklearn utiliza exactamente este enfoque. Comprender esta conexión le permite implementar o personalizar PCA desde cero para reducir la dimensionalidad.

import numpy as np

np.random.seed(0)
X = np.random.randn(100, 4)

# Center the data
X_centered = X - X.mean(axis=0)

# SVD-based PCA
U, s, Vh = np.linalg.svd(X_centered, full_matrices=False)

# Variance explained by each component
var_explained = (s ** 2) / (X.shape[0] - 1)
total_var = var_explained.sum()
print('Variance explained ratio:', np.round(var_explained / total_var, 3))

# Project onto top 2 principal components
X_pca = X_centered @ Vh[:2].T
print('Reduced shape:', X_pca.shape)

Aproximación de bajo rango con SVD

La SVD permite realizar una aproximación matricial de bajo rango: conserve solo los k valores singulares y vectores principales, y reconstruya una aproximación de la matriz original. Esta técnica es la base de la compresión de imágenes y del filtrado colaborativo para recomendaciones. La SVD truncada U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :] proporciona la mejor aproximación de rango k en el sentido de mínimos cuadrados (teorema de Eckart-Young).

import numpy as np

np.random.seed(1)
A = np.random.rand(20, 15)

U, s, Vh = np.linalg.svd(A, full_matrices=False)

# Rank-3 approximation
k = 3
A_approx = U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :]

error = np.linalg.norm(A - A_approx, 'fro')
total = np.linalg.norm(A, 'fro')
print(f'Approximation error: {error/total:.3f} (fraction of total)')
print(f'Top-3 singular values capture {(s[:3]**2).sum()/(s**2).sum():.1%} of variance')

Descomposición propia frente a SVD: cuándo usar cada una

Use la descomposición propia (np.linalg.eig o eigh) cuando tenga una matriz cuadrada y simétrica y quiera comprender sus ejes principales; por ejemplo, la matriz de covarianza en PCA o las matrices de transición de Markov. Use la SVD (np.linalg.svd) cuando su matriz sea rectangular o necesite la máxima estabilidad numérica. La SVD siempre existe; la descomposición propia puede producir números complejos en matrices no simétricas.

import numpy as np

# Non-symmetric matrix: eigenvalues may be complex
A = np.array([[0.0, -1.0],
              [1.0,  0.0]])
vals, _ = np.linalg.eig(A)
print('Eigenvalues (complex for rotation):', vals)

# SVD always gives real singular values
_, s, _ = np.linalg.svd(A)
print('Singular values (always real):', s)

Teorema espectral para matrices simétricas

El teorema espectral establece que toda matriz simétrica real A puede descomponerse como A = Q @ diag(eigenvalues) @ Q.T, donde Q es ortogonal (Q.T = Q⁻¹). Esto significa que las matrices simétricas siempre se pueden diagonalizar con valores propios reales y vectores propios ortogonales. Las matrices de covarianza, las matrices de kernel en las SVM y la matriz hessiana en optimización son todas simétricas, por lo que este teorema resulta de utilidad general en la teoría del aprendizaje automático.

import numpy as np

A = np.array([[5.0, 2.0, 1.0],
              [2.0, 3.0, 0.0],
              [1.0, 0.0, 4.0]])

vals, Q = np.linalg.eigh(A)
print('Eigenvalues:', np.round(vals, 4))

# Reconstruct A = Q @ diag(vals) @ Q.T
A_reconstructed = Q @ np.diag(vals) @ Q.T
print('Reconstruction correct:', np.allclose(A, A_reconstructed))
print('Q is orthogonal:', np.allclose(Q.T @ Q, np.eye(3)))

Práctica: iteración de potencias para el valor propio dominante

Cuando solo necesite el mayor valor propio y su vector propio, la iteración de potencias es mucho más eficiente que calcular todos los valores propios. Comience con un vector aleatorio, multiplíquelo repetidamente por A y normalícelo; el proceso converge al vector propio dominante. Así funcionaba el algoritmo PageRank original de Google. NumPy hace que cada iteración consista en una sola multiplicación de matriz por vector con @.

import numpy as np

A = np.array([[4.0, 1.0, 2.0],
              [1.0, 3.0, 0.0],
              [2.0, 0.0, 2.0]])

v = np.random.rand(3)
for _ in range(50):
    v = A @ v
    v = v / np.linalg.norm(v)

eigenvalue_approx = v @ A @ v
print('Dominant eigenvector:', np.round(v, 4))
print('Approx eigenvalue:', round(eigenvalue_approx, 4))

# Verify with eigh
vals, vecs = np.linalg.eigh(A)
print('True max eigenvalue:', round(vals[-1], 4))

Uso de np.linalg.svd en canalizaciones reales

En una canalización de datos real, la SVD se utiliza para la reducción del ruido y la compresión de datos. Después de ajustar la SVD con los datos de entrenamiento, conserve solo los k componentes principales que capturen el 95 % de la varianza. Esto reduce la dimensionalidad de los datos nuevos antes de introducirlos en un clasificador o regresor, acelera el entrenamiento y a menudo mejora la generalización al eliminar dimensiones ruidosas. Ajuste siempre la SVD únicamente con los datos de entrenamiento y aplique la misma transformación a los datos de prueba.

import numpy as np

np.random.seed(7)
X_train = np.random.randn(200, 50)
X_test = np.random.randn(40, 50)

# Fit on training data
X_mean = X_train.mean(axis=0)
X_centered = X_train - X_mean
U, s, Vh = np.linalg.svd(X_centered, full_matrices=False)

# Choose k to capture 90% variance
cumvar = np.cumsum(s**2) / (s**2).sum()
k = np.searchsorted(cumvar, 0.9) + 1
print(f'Components to capture 90% variance: {k}')

# Transform test data using the same Vh
X_test_reduced = (X_test - X_mean) @ Vh[:k].T
print('Reduced test shape:', X_test_reduced.shape)

Comprobación rápida

Compruebe su comprensión de los conceptos de análisis de datos de esta lección.

Resumen de la lección

En esta lección ha aprendido que np.linalg.eig()/eigh() calculan valores y vectores propios que revelan las direcciones de estiramiento intrínsecas de una matriz, np.linalg.svd() descompone cualquier matriz en U, valores singulares y Vh, lo que permite realizar PCA y aproximaciones de bajo rango, y los valores singulares cuantifican la varianza capturada por cada componente y determinan el rango de la matriz. A continuación, abordaremos el manejo de grandes conjuntos de datos mediante la lectura de archivos CSV en fragmentos.

Gratis para empezar

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 «Introducción a valores propios y SVD» es gratis?

Sí — el texto completo de «Introducción a valores propios y SVD» 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 Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Introducción a valores propios y SVD»?

Calcule valores y vectores propios con np.linalg.eig y comprenda cómo SVD sustenta la reducción de dimensionalidad mediante PCA. Practicas Pandas & NumPy 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 Pandas & NumPy Academy?

No se requiere experiencia previa. Pandas & NumPy 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 «Introducción a valores propios y SVD»?

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 Pandas & NumPy Academy?

Sí. Cada lección de Pandas & NumPy 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

  1. Multiplicación de matrices con np.matmul y @
  2. Determinantes, inversas y transpuestas
  3. Resolución de sistemas lineales
  4. Introducción a valores propios y SVD
← Volver a Pandas & NumPy Academy