Eigenvectores y eigenvalores con NumPy

Los eigenvectores y eigenvalores son la forma más clara de entender cómo una matriz transforma el espacio: no giran ciertos vectores, solo los escalan. Aquí verás, paso a paso, cómo interpretarlos, calcularlos en Google Collab con NumPy, verificarlos en código y visualizarlos con Matplotlib. Todo esto conecta de forma directa con machine learning: la matriz de covarianza y el PCA.

¿Qué son eigenvectores y eigenvalores en una transformación lineal?

Un eigenvector es un vector especial que, al aplicar la transformación A, se mantiene en su misma línea. La matriz no lo rota: solo lo estira, encoge o invierte su sentido. El eigenvalor lambda indica el factor de escala: si λ = 2, duplica su longitud; si λ = 0.5, se reduce a la mitad; si λ = −1, invierte su sentido, pero sigue en la misma línea.

¿Cómo se interpreta el eigenvalor lambda?

• A·V = λ·V: define la relación clave entre matriz, eigenvector y eigenvalor.
• λ > 1: el vector se alarga.
• 0 < λ < 1: el vector se contrae.
• λ < 0: el vector cambia de sentido.

¿Cómo calcular eigenvectores y eigenvalores con NumPy en Google Collab?

Calcularlos es directo con NumPy: la función np.linalg.eig devuelve, primero, un arreglo con los eigenvalores y, segundo, una matriz cuyas columnas son los eigenvectores. En el ejemplo se usa la matriz A = [[3, 1], [1, 2]].

¿Cómo verificar A·V = lambda·V en código?

A continuación, el flujo básico descrito, usando f strings para imprimir resultados:

import numpy as np
import matplotlib.pyplot as plt

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

# Eigenvalores y eigenvectores
eigenvalores, eigenvectores = np.linalg.eig(a)

# Primer eigenvector y su eigenvalor
v1 = eigenvectores[:, 0]
lambda1 = eigenvalores[0]

# Verificación de la relación A·V = λ·V
av1 = a @ v1
lambda1_v1 = lambda1 * v1
print(f"AV1: {av1}")
print(f"lambda*V1: {lambda1_v1}")

• Se observa que ambos resultados son iguales: el vector fue escalado por λ (en el ejemplo, aproximadamente 3.61), sin rotación.

¿Cómo visualizar el vector original y su versión escalada?

La visualización con Matplotlib usa quiver para flechas, con parámetros como angles='xy', scale_units='xy' y scale=1 para mantener la escala en el plano.

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

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

# Vector transformado (A·V1) en rojo
plt.quiver(0, 0, av1[0], av1[1], angles='xy', scale_units='xy', scale=1,
           color='red', label='vector escalado')

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

• Puedes reemplazar AV1 por λ·V1: obtendrás la misma flecha roja.
• El gráfico muestra claramente que el vector no rota: solo cambia su longitud y, si λ < 0, invierte su sentido.

¿Por qué son clave en machine learning y PCA?

En machine learning analizamos una matriz especial: la matriz de covarianza. Sus eigenvectores indican direcciones de máxima varianza en los datos y sus eigenvalores miden cuánta información hay en cada dirección. Este eigenanálisis es la base del análisis de componentes principales (PCA): comprenderlo es un primer paso indispensable para reducir dimensionalidad y revelar estructura en datos.

¿Qué habilidades y conceptos practicas aquí?

• Interpretar la relación A·V = λ·V y su significado geométrico.
• Usar np.linalg.eig para obtener eigenvalores y eigenvectores.
• Trabajar con arreglos: seleccionar columnas como vectores propios.
• Verificar resultados con operaciones vectoriales y f strings.
• Visualizar con quiver, legend, grid y límites de ejes.
• Entender casos de λ: 2, 0.5 y −1 para escalar o invertir sentido.
• Conectar con matriz de covarianza, varianza y PCA.

¿Te animas al reto final? si un eigenvalor λ es negativo, explica en una frase qué le hace la matriz a su eigenvector correspondiente. además, construye una matriz 2x2 con un eigenvalor negativo, grafica como arriba y comparte tus resultados en los comentarios.