Ortogonalidad en machine learning con Python

Comprende por qué la ortogonalidad y la ortonormalidad sostienen modelos más eficientes y estables en machine learning. Desde la relación con la similitud coseno y el ángulo de 90 grados, hasta su papel en PCA, verás cómo ejes independientes eliminan redundancia y aceleran el cómputo. Además, aplica los conceptos en Python con NumPy y visualiza con Matplotlib.

¿Por qué la ortogonalidad mejora machine learning?

La ortogonalidad implica independencia: moverte en una dirección no altera la otra, como norte-sur frente a este-oeste. En términos de datos, cada característica aporta información nueva y no redundante.

• Elimina redundancia: cada rasgo aporta algo distinto. Un modelo aprende mejor.
• Aporta estabilidad y velocidad: operaciones con vectores ortogonales son más simples y robustas.
• Habilita PCA: transforma variables correlacionadas en ejes ortogonales que capturan la esencia de los datos con eficiencia.

¿Qué significan ortogonalidad y ortonormalidad en R^n?

Ortogonalidad significa producto punto igual a cero y ángulo de noventa grados. Ortonormalidad añade que cada vector tenga norma uno (vector unitario). Así, tienes ejes independientes y de longitud estándar.

¿Cómo se relaciona la similitud coseno con el ángulo de 90 grados?

• Similitud coseno igual a cero indica ninguna relación lineal.
• Geométricamente equivale a vectores perpendiculares (90°).
• En datos: señales no redundantes y más informativas.

¿Cuántos vectores caben en R^n sin redundancia?

• Regla clave: en un espacio de n dimensiones, como R^n, hay a lo sumo n vectores mutuamente ortogonales.
• En R2: máximo dos ejes como X y Y.
• En R3: máximo tres ejes como X, Y y Z (la esquina de una habitación).

¿Qué es una base ortonormal y cómo reconstruye vectores?

• Base ortonormal: vectores ortogonales con norma uno.
• Ejemplo: base estándar â i = [1, 0] y ĵ = [0, 1]. Su producto punto es 0 y ambos miden 1.
• Con una base ortonormal puedes reconstruir cualquier vector del plano con combinaciones lineales, por ejemplo 5â i + 3ĵ = [5, 3].

¿Cómo implementarlo en Python con NumPy y Matplotlib?

Pasa de la teoría a la práctica en Google Colab usando NumPy y Matplotlib. Verifica ortogonalidad con el operador @, calcula la norma con np.linalg.norm, normaliza y visualiza con plt.quiver.

¿Cómo verificar el producto punto y la norma con NumPy?

import numpy as np

I = np.array([1, 0])
J = np.array([0, 1])

print(f"producto punto I·J: {I @ J}")  # 0 → ortogonales

norma_I = np.linalg.norm(I)
norma_J = np.linalg.norm(J)
print(f"norma I: {norma_I}")      # 1 → unitario
print(f"norma J: {norma_J}")      # 1 → unitario

¿Cómo reconstruir un vector con la base estándar?

V = np.array([5, 3])
V_reconstruido = 5*I + 3*J

iguales = np.array_equal(V, V_reconstruido)
print(f"¿la base estándar puede construir V? {iguales}")  # True

¿Cómo normalizar y graficar vectores ortogonales?

import numpy as np
import matplotlib.pyplot as plt

V1 = np.array([4, -2])
V2 = np.array([2, 4])
V3 = np.array([3, 3])  # redundante respecto a V1 y V2 (no aporta dirección nueva)

# 1) Ortogonalidad
print(f"V1·V2 = {V1 @ V2}")  # 0 → ortogonales
print(f"V1·V3 = {V1 @ V3}")  # 6 → no ortogonales

# 2) Normas y normalización
n1, n2 = np.linalg.norm(V1), np.linalg.norm(V2)
print(f"norma V1: {n1}")
print(f"norma V2: {n2}")

V1_n = V1 / n1
V2_n = V2 / n2

# 3) Verificación tras normalizar
print(f"V1_n·V2_n = {V1_n @ V2_n}")          # 0 → siguen ortogonales
print(f"norma V1_n: {np.linalg.norm(V1_n):.2f}")  # 1 → unitario
print(f"norma V2_n: {np.linalg.norm(V2_n):.2f}")  # 1 → unitario

# 4) Visualización
plt.figure(figsize=(6, 6))
plt.quiver(0, 0, V1_n[0], V1_n[1], angles='xy', scale_units='xy', scale=1,
           color='blue', label='V1 normalizado')
plt.quiver(0, 0, V2_n[0], V2_n[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.show()

• Usa el operador @ para el producto punto.
• Emplea np.linalg.norm para la norma y normaliza dividiendo por ella.
• np.array_equal compara arreglos para validar reconstrucciones.
• plt.quiver dibuja flechas desde el origen; configura angles='xy', scale_units='xy' y scale=1 para interpretar coordenadas en el plano.

¿Te animas a probarlo? Crea dos vectores 2D que creas ortogonales, valida con NumPy y comparte tu resultado en los comentarios.