1. Introducción a las normas de un vector

En matemáticas y en áreas como Machine Learning, optimización o simulaciones, la norma de un vector es una medida de su longitud o magnitud. Formalmente, una norma \(\|\cdot\|\) es una función que asigna a cada vector \(\mathbf{x}\in\mathbb{R}^n\) un número real no negativo cumpliendo tres axiomas:

1. Positividad: \(\|\mathbf{x}\| \ge 0\) y \(\|\mathbf{x}\| = 0 \iff \mathbf{x}=\mathbf{0}\).
2. Homogeneidad: \(\|\alpha\mathbf{x}\| = |\alpha|\,\|\mathbf{x}\|\) para cualquier escalar \(\alpha\).
3. Desigualdad triangular: \(\|\mathbf{x}+\mathbf{y}\| \le \|\mathbf{x}\| + \|\mathbf{y}\|\).

2. Tipos de normas más usadas

3. Algoritmo genérico para calcular una p‑norm

def p_norm(vector, p=2):
    """Calcula la p‑norma de un vector iterable.
    Args:
        vector (Iterable[float]): componentes del vector.
        p (float): orden de la norma (p≥1). El valor 2 corresponde a la norma Euclidiana.
    Returns:
        float: valor de la p‑norma.
    """
    if p < 1:
        raise ValueError("p debe ser >= 1")
    total = sum(abs(x) ** p for x in vector)
    return total ** (1.0 / p)

El algoritmo anterior es sencillo, pero tiene limitaciones de rendimiento para vectores muy grandes o cuando se necesita precisión de punto flotante alta.

4. Implementaciones en Python: Pure vs. NumPy

import random, time
vec = [random.random() for _ in range(1000)]
start = time.time()
print('L2:', p_norm(vec, p=2))
print('Tiempo:', time.time() - start)

import numpy as np, time
vec_np = np.random.rand(1_000_000)
start = time.time()
print('L2 (NumPy):', np.linalg.norm(vec_np, ord=2))
print('Tiempo (NumPy):', time.time() - start)

Recomendación: Usa siempre NumPy o bibliotecas basadas en C/Fortran para cálculos de gran escala. La versión pura es útil para enseñanza o entornos sin dependencias externas.

5. Comparativa de rendimiento (benchmark)

Los resultados pueden variar según la arquitectura CPU y la versión de BLAS vinculada a NumPy.

6. Casos de uso reales

• Regularización en modelos lineales: L1 para Lasso, L2 para Ridge.
• Clustering K‑means: se basa en la distancia Euclidiana (L2).
• Detección de anomalías: la norma L∞ permite identificar la característica más desviada.
• Redes neuronales y embeddings: normalizar vectores de embedding con L2 antes de calcular similitudes de coseno.

7. Buenas prácticas y consideraciones de seguridad numérica

1. Evita overflow/underflow: Cuando los componentes son muy grandes, calcula la norma usando np.linalg.norm con dtype=np.float64 o escala el vector antes de la suma.
2. Precisión de punto flotante: En entornos críticos (finanzas, simulaciones científicas) prefiere Decimal o bibliotecas de precisión arbitraria.
3. Vectorización: Siempre que sea posible, utiliza operaciones vectorizadas (NumPy, JAX, PyTorch) para aprovechar SIMD y GPU.
4. Validación de entrada: Asegúrate de que la entrada sea un iterable de números; rechaza NaN o Inf con una excepción clara.

8. Troubleshooting frecuente

8.1 Resultado inesperado con NaN

Si np.linalg.norm devuelve nan, verifica que el vector no contenga np.nan o np.inf. Usa np.isfinite() para filtrar.

if not np.all(np.isfinite(vec)):
    raise ValueError('El vector contiene valores no finitos')

8.2 Diferencias entre ord=2 y ord=None

En NumPy, ord=None calcula la norma Frobenius (para matrices) que equivale a la L2 vectorial cuando la entrada es 1‑D. Asegúrate de especificar ord=2 para evitar ambigüedad.

9. Optimización avanzada

Para entornos de alto rendimiento (HPC) o entrenamiento de modelos con miles de millones de parámetros, considera:

• JAX: jax.numpy.linalg.norm compila a XLA y ejecuta en GPU/TPU.
• PyTorch: torch.norm con dim especificado permite cálculos en lotes sin bucles de Python.
• Numba: Decorar la función p_norm con @njit para generar código máquina nativo.

from numba import njit
@njit
def p_norm_numba(arr, p=2):
    total = 0.0
    for x in arr:
        total += abs(x) ** p
    return total ** (1.0 / p)