Ortogonalidad y ortonormalidad con NumPy

Cuando dos vectores tienen una similitud coseno de cero, en álgebra lineal decimos que son ortogonales: forman un ángulo de 90 grados y no comparten relación lineal. Esta propiedad es clave en machine learning porque garantiza independencia entre características, y aquí vas a ver cómo comprobarla con NumPy.

¿Qué significa que dos vectores sean ortogonales?

La ortogonalidad es sinónimo de independencia. Piensa en un mapa: moverte al norte no cambia tu posición este-oeste. Cada eje aporta información nueva y no redundante [0:18].

En machine learning esta independencia importa por tres motivos concretos:

• Elimina redundancia, porque cada característica aporta información nueva y el modelo aprende con más eficiencia.
• Aporta estabilidad y velocidad, ya que las operaciones con vectores ortogonales son más simples y robustas.
• Habilita técnicas avanzadas como PCA, que transforma características correlacionadas en un nuevo conjunto ortogonal capturando la esencia de los datos [0:55].

¿Qué es la ortogonalidad en álgebra lineal? Es la propiedad de dos vectores cuyo producto punto es cero. Geométricamente, forman un ángulo de 90 grados y no tienen relación lineal entre sí.

¿Cuántos vectores ortogonales caben en un espacio?

La regla es simple: un espacio de n dimensiones admite como máximo n vectores mutuamente ortogonales. En un plano R2 puedes tener dos (los ejes X y Y). En R3 puedes tener tres, como las aristas que forman la esquina de un cubo [1:35].

No existe un tercer vector en un plano que sea perpendicular a otros dos al mismo tiempo. Esa es la frontera matemática.

¿Qué es un vector ortonormal y por qué importa?

Un conjunto de vectores es ortonormal cuando cumple dos condiciones simultáneamente: son ortogonales entre sí (producto punto igual a cero) y cada uno tiene norma uno, es decir, son vectores unitarios [2:08].

Los vectores de la base estándar i y j, con valores (1,0) y (0,1), son el ejemplo perfecto. Su producto punto es cero y ambos miden uno. Esto los convierte en una base ortonormal: un conjunto que puedes combinar linealmente para construir cualquier otro vector del espacio.

¿Cuál es la diferencia entre ortogonal y ortonormal? Ortogonal solo exige que el producto punto sea cero. Ortonormal exige además que cada vector tenga norma uno.

¿Cómo comprobar ortogonalidad y ortonormalidad con NumPy?

Para llevarlo a Python abre Google Colab e importa NumPy. Empieza creando los vectores de la base estándar y verificando su producto punto con el operador @ [3:00]:

python import numpy as np

i = np.array([1, 0]) j = np.array([0, 1])

print(f"Producto punto entre i y j: {i @ j}")

El resultado es cero, así que son ortogonales. Para confirmar que también son ortonormales calcula la norma de cada uno:

python norma_i = np.linalg.norm(i) norma_j = np.linalg.norm(j) print(f"Norma de i: {norma_i}, Norma de j: {norma_j}")

Ambas normas dan uno. Confirmado: i y j son ortonormales.

¿Cómo reconstruir un vector con una combinación lineal?

Una base ortonormal te permite construir cualquier vector del espacio. Toma un vector v = (5,3) y reconstrúyelo como combinación de i y j [4:20]:

python v = np.array([5, 3]) v_reconstruido = 5 * i + 3 * j

print(f"¿La base estándar puede construir v?: {np.array_equal(v, v_reconstruido)}")

El método np.array_equal devuelve True, demostrando que la base estándar reconstruye cualquier vector del plano bidimensional.

¿Cómo normalizar vectores que no son unitarios?

No todos los pares ortogonales son ortonormales. Prueba con V1 = (4,-2) y V2 = (2,4) [5:40]:

python v1 = np.array([4, -2]) v2 = np.array([2, 4]) v3 = np.array([3, 3])

print(f"Producto punto V1 y V2: {v1 @ v2}") print(f"Producto punto V1 y V3: {v1 @ v3}")

El primero da cero (ortogonales), el segundo da seis (no ortogonales). Sin embargo, las normas de V1 y V2 no son uno, así que no son ortonormales todavía.

La solución es normalizar: dividir cada vector por su norma para convertirlo en unitario sin alterar su dirección [7:15]:

python v1_norm = v1 / np.linalg.norm(v1) v2_norm = v2 / np.linalg.norm(v2)

print(f"Producto punto normalizado: {v1_norm @ v2_norm}") print(f"Norma V1 normalizado: {np.linalg.norm(v1_norm):.2f}")

El producto punto sigue siendo cero y la norma ahora es uno. Ya tienes una base ortonormal lista para reconstruir vectores en ese espacio.

¿Cómo visualizar vectores ortonormales con Matplotlib?

La gráfica confirma lo que dice la matemática. Usa plt.quiver para dibujar flechas desde el origen [8:30]:

python import matplotlib.pyplot as plt

plt.figure(figsize=(6, 6)) plt.quiver(0, 0, v1_norm[0], v1_norm[1], angles='xy', scale_units='xy', scale=1, color='blue', label='V1 normalizado') plt.quiver(0, 0, v2_norm[0], v2_norm[1], angles='xy', scale_units='xy', scale=1, color='red', label='V2 normalizado') plt.xlim(-5, 5); plt.ylim(-5, 5) plt.title('Visualización de vectores ortonormales') plt.legend(); plt.grid(True); plt.show()

Las flechas aparecen pequeñas porque su longitud es exactamente uno, pero el ángulo entre ellas es de 90 grados. Visualmente confirmas que son ortonormales.

Con esto ya manejas las herramientas fundamentales del álgebra lineal aplicada: suma, escalamiento, norma y producto punto. El siguiente paso es la multiplicación de matrices. ¿Qué par de vectores 2D vas a probar tú? Compártelo en los comentarios.