Cómo verificar la ecuación A·v = λ·v con NumPy

Comprende en pocos minutos cómo los eigenvectores revelan los ejes fundamentales de una transformación lineal y por qué son clave en machine learning. Con un ejemplo claro en NumPy y una visualización en Matplotlib, verás cómo se verifica A·v = λ·v y cómo esto conecta con PCA.

¿Qué son eigenvectores y eigenvalores y por qué importan en machine learning?

Los eigenvectores son direcciones del espacio que una matriz A no rota: solo las escala o invierte su sentido. Si v es un eigenvector y λ su eigenvalor, la relación es A·v = λ·v. La matriz transforma v, pero el resultado queda sobre la misma línea.

• Si λ = 2: el vector duplica su longitud.
• Si λ = 0.5: el vector se reduce a la mitad.
• Si λ = −1: el vector invierte su sentido, misma línea.

Esto es esencial en machine learning: al analizar la matriz de covarianza, sus eigenvectores marcan las direcciones de máxima varianza y los eigenvalores indican cuánta información hay en cada dirección. Así se fundamenta PCA (análisis de componentes principales).

¿Cómo obtener y verificar eigenvectores con NumPy paso a paso?

El flujo es directo en Google Collab: crear la matriz, calcular eigenvalores y eigenvectores, y comprobar la ecuación A·v = λ·v numéricamente.

import numpy as np
import matplotlib.pyplot as plt

# 1) Matriz de transformación
A = np.array([[3, 1],
              [1, 2]])

# 2) Eigenvalores y eigenvectores
#   - eigenvalores: array de λ
#   - eigenvectores: columnas son los v correspondientes
eigenvalores, eigenvectores = np.linalg.eig(A)
print(f"eigenvectores:\n{eigenvectores}")
print(f"eigenvalores:\n{eigenvalores}")

# 3) Verificación de A·v = λ·v para el primer par (λ1, v1)
v1 = eigenvectores[:, 0]
lambda1 = eigenvalores[0]
AV1 = A @ v1
lambda1_v1 = lambda1 * v1
print(f"AV1: {AV1}")
print(f"lambda1*v1: {lambda1_v1}")

• La matriz de ejemplo es A = [[3, 1], [1, 2]].
• NumPy retorna: eigenvalores y una matriz cuyas columnas son eigenvectores.
• Al imprimir, ambos lados coinciden: AV1 y λ1·v1 dan el mismo vector.
• En el ejemplo mostrado, se observa un vector como (3.07, 1.90) y un factor de escala ≈ 3.61 para el primer eigenvector.

¿Qué devuelve np.linalg.eig y cómo interpretarlo?

• eigenvalores: array de λ, uno por cada dirección propia de A.
• eigenvectores: matriz donde cada columna es un v que cumple A·v = λ·v.
• Índices alineados: eigenvalores[i] corresponde a la columna i de eigenvectores.

¿Cómo visualizar el escalado del eigenvector con Matplotlib?

La gráfica refuerza la intuición: el vector original y su versión transformada quedan en la misma línea, solo escalados o invertidos.

plt.figure(figsize=(8, 8))

# Vector original v1 en azul
plt.quiver(0, 0, v1[0], v1[1], angles='xy', scale_units='xy', scale=1,
           color='blue', label='eigenvector original')

# Vector transformado A·v1 (equivalente a λ1·v1) en rojo
plt.quiver(0, 0, AV1[0], AV1[1], angles='xy', scale_units='xy', scale=1,
           color='red', label='eigenvector escalado')

plt.xlim(0, 4); plt.ylim(0, 4)
plt.title('Un eigenvector y su transformación')
plt.legend(); plt.grid(True); plt.show()

• Quiver dibuja flechas desde el origen: claro para comparar dirección y escala.
• Puedes graficar AV1 o λ1·v1: verás que son idénticos.
• Ajusta límites y cuadrícula para legibilidad.

¿Cómo conecta esto con PCA desde la covarianza?

• La matriz de covarianza captura la forma de los datos.
• Sus eigenvectores indican ejes de máxima varianza.
• Sus eigenvalores cuantifican información por componente.
• Dominar este análisis es el paso previo para aplicar PCA con confianza.

¿Te animas a practicar? Explica en una frase qué ocurre si un eigenvalor es negativo (pista: el vector invierte su sentido). Luego, crea una matriz 2×2 con un eigenvalor negativo, grafica ambos vectores con quiver y comparte tus resultados en los comentarios.