Lección · Módulo 2 · Álgebra para IA

Espacios vectoriales y normas: el lenguaje de muchas dimensiones

Para hablar de vectores que viven en miles de dimensiones — embeddings, imágenes, mediciones de planta — necesitamos un idioma más general que el plano. Y necesitamos saber cómo medir el tamaño y la distancia entre esos vectores cuando ya no podés dibujarlos.

Mate MathPlay · Lección 2.3 · Álgebra para modelos

10 minutosInteractivoVisualCon Python

Idea central: un espacio vectorial es cualquier conjunto donde podés sumar elementos y multiplicarlos por números sin salirte del conjunto. Una norma es la regla que define cuán grande es un vector. Y hay más de una norma: L1, L2 e infinito son las tres que toda la IA moderna usa todo el tiempo. Cada una mide "tamaño" de manera distinta — y elegir la correcta puede cambiar por completo cómo aprende un modelo.

1 Más allá del plano: el salto a muchas dimensiones

Hasta acá trabajamos con vectores en el plano (x, y): dos coordenadas que podés dibujar. Fácil. Pero los vectores reales en IA suelen tener cientos, miles, incluso millones de coordenadas:

Una imagen de 256x256 píxeles en escala de grises es un vector de 65 536 dimensiones (una por cada píxel).
El embedding de una palabra en un modelo como Word2Vec o BERT es un vector de 300 o 768 dimensiones.
Las mediciones de una planta industrial a lo largo de un día son un vector de varios miles de dimensiones (variables × instantes de tiempo).

No podés dibujar estos vectores. Pero todas las reglas que aprendiste en el plano siguen valiendo: sumar dos vectores se hace coordenada a coordenada, multiplicar por un escalar también. El plano es el caso más fácil de algo mucho más general.

2 Definición: qué es un espacio vectorial

Un espacio vectorial es un conjunto V de objetos (llamados vectores) en el que podés hacer dos cosas sin salirte del conjunto:

Sumar dos vectores: si u y v están en V, entonces u + v también está en V.
Multiplicar un vector por un número: si v está en V y α es un escalar, entonces α · v también está en V.

Y esas dos operaciones tienen que cumplir reglas razonables: la suma es conmutativa, hay un vector cero, multiplicar por 1 no cambia nada, etc. No hace falta memorizar los 8 axiomas formales. La idea práctica es:

Un espacio vectorial es cualquier lugar donde la combinación lineal tiene sentido

Ejemplos que parecen muy distintos pero todos son espacios vectoriales:

Rⁿ: vectores de n números reales. Es el caso más usado en IA.
Polinomios de grado ≤ n: podés sumar polinomios y multiplicarlos por una constante, seguís teniendo un polinomio.
Funciones continuas en un intervalo: sumas dos funciones, obtenés una función. La multiplicás por un número, sigue siendo función.
Matrices de un tamaño fijo: sumarlas o escalarlas no cambia su forma. Las matrices viven en su propio espacio vectorial.

Por qué importa esta abstracción

Cuando un algoritmo (PCA, regresión, redes neuronales) está pensado como "hace combinaciones lineales de cosas", funciona igual sea que las "cosas" sean píxeles, palabras, audio o series temporales. La teoría se escribe una sola vez para todos los espacios vectoriales y se aplica a todos los casos.

3 Base y dimensión

Una base de un espacio vectorial es un conjunto mínimo de vectores tal que cualquier otro vector del espacio se puede escribir como combinación lineal de ellos. La dimensión es el número de vectores que tiene la base.

En el plano R², la base más natural es {(1,0), (0,1)}: con esos dos vectores armás cualquier punto. La dimensión es 2. Y en R⁷⁶⁸ hay una base de 768 vectores — demasiados para dibujar pero exactamente la misma idea.

La intuición clave: la dimensión es la cantidad de "grados de libertad". En 2D te movés en un plano. En 3D en el espacio. En 768D en algo que no podés visualizar pero que el algoritmo sí puede manipular sin problema.

4 Producto interno: ¿cuánto se parecen dos vectores?

El producto interno (también llamado producto punto o producto escalar) toma dos vectores y devuelve un número. En Rⁿ se calcula coordenada a coordenada:

u · v = u₁v₁ + u₂v₂ + … + u_nv_n

Geométricamente, el producto interno mide cuánto apuntan dos vectores en la misma dirección:

Producto interno positivo grande: los vectores apuntan en direcciones parecidas.
Producto interno cero: los vectores son ortogonales (perpendiculares). No se parecen en nada.
Producto interno negativo grande: los vectores apuntan en direcciones opuestas.

Esta es la base de la similitud coseno, la métrica más usada para comparar embeddings en IA:

cos(θ) = (u · v) / (||u|| · ||v||)

Devuelve un número entre -1 y 1. Cuando dos embeddings de palabras tienen similitud coseno cercana a 1, el modelo "piensa" que las palabras son sinónimos. Cuando está cerca de 0, no tienen relación. Cuando está cerca de -1, son antónimos.

Dónde aparece

Cada vez que un buscador encuentra "documentos similares" o un sistema de recomendación te muestra "productos que te pueden gustar", está calculando el producto interno entre dos vectores de alta dimensión. La misma fórmula que podés hacer a mano para dos vectores en el plano.

5 Normas: tres maneras de medir el tamaño de un vector

Una norma es la regla que dice cuán grande es un vector. La más familiar es la norma euclídea, la del teorema de Pitágoras. Pero hay otras que en IA aparecen tan seguido como esa — o más. Las tres principales son:

L1: ||v||₁ = |v₁| + |v₂| + … + |v_n|

L2 (euclídea): ||v||₂ = √(v₁² + v₂² + … + v_n²)

L∞ (máximo): ||v||_∞ = max(|v₁|, |v₂|, …, |v_n|)

Las tres cumplen las propiedades intuitivas de "tamaño": son positivas, valen cero solo para el vector cero, y respetan la desigualdad triangular. Pero miden distinto. Cada una tiene una geometría distinta — mejor que verlo, jugá con ellas abajo.

6 Tu turno: arrastrá el vector y mirá las tres normas en vivo

Las tres formas (rombo, círculo, cuadrado) son las bolas unitarias de cada norma — el conjunto de vectores con norma exactamente 1. En L2 (la familiar) es un círculo. En L1 es un rombo. En L∞ es un cuadrado. Mové el slider para cambiar el vector y mirá cómo cada norma le asigna un número distinto.

L1: rombo (Manhattan) L2: círculo (euclídea) L∞: cuadrado (Chebyshev) v: tu vector

Sandbox interactivo

Mové los sliders vx y vy para cambiar el vector. Las tres normas se recalculan en vivo.

vx+1.50

vy+1.00

Norma L1

"Manhattan"

2.50

Suma de valores absolutos. Como caminar por calles cuadriculadas.

Norma L2

"Euclídea"

1.80

Pitágoras: raíz de la suma de cuadrados. La distancia "en línea recta".

Norma L∞

"Máximo"

1.50

La mayor coordenada en valor absoluto. Como el peor caso.

Sobre el eje X con vector (2, 0): las tres normas dan 2. Cuando solo hay una coordenada activa, las normas coinciden.
En la diagonal con vector (1.41, 1.41): L2 da 2 (Pitágoras), L1 da 2.82 (suma), L∞ da 1.41 (máximo). Las tres miden distinto.
En la esquina con vector (2, 2): L2 da 2.83, L1 da 4, L∞ da 2. L1 es la más "grande" cuando todas las coordenadas tiran.
Probaste tantas posiciones que ya ves la regla: L1 ≥ L2 ≥ L∞ siempre (en cualquier dimensión). La euclídea queda en el medio.

7 ¿Cuándo se usa cada norma?

No son intercambiables. Cada norma penaliza distinto y se usa donde su forma de medir tiene sentido:

L2 (euclí>dea): la opción por defecto. Aparece en regresión clásica (mínimos cuadrados), en la función de pérdida MSE, en clustering K-Means, en la similitud coseno. Es suave y derivable, ideal para optimizar.
L1 (Manhattan): se usa cuando querés que el modelo descarte features irrelevantes. La regularización Lasso usa L1 y produce modelos sparse: muchas coordenadas en cero. Si tenés 1000 variables pero solo 20 importan, L1 las encuentra.
L∞ (máximo): se usa cuando lo que te interesa es controlar el peor caso. En control de procesos, en garantías de robustez de modelos, en ataques adversariales sobre redes neuronales.

Conexión con la lección anterior

Las normas son a los vectores lo que los valores propios son a las matrices: máquinas que reducen un objeto complejo a un número que dice algo útil. De hecho, en una matriz simétrica, el mayor valor singular (SVD) es exactamente la norma espectral — otra norma más, definida directamente sobre matrices.

8 Por qué los embeddings funcionan: un espacio vectorial gigante

La aplicación más espectacular de los espacios vectoriales en IA moderna son los embeddings: la idea de representar cosas complejas (palabras, fotos, audios, productos, usuarios) como puntos en un espacio vectorial de alta dimensión — típicamente R²⁵⁶, R⁷⁶⁸, R¹⁵³⁶.

Por qué vale la pena: cuando algo es un vector, podés calcular distancias, hacer combinaciones lineales, encontrar vecinos cercanos, agrupar por similitud. Toda la maquinaria del álgebra lineal se vuelve aplicable.

Esta es la magia escondida detrás de ChatGPT, los buscadores semánticos, los sistemas de recomendación modernos y la búsqueda por imagen. Los modelos no entienden palabras — entienden geometría en un espacio vectorial.

⛏Caso aplicado · embeddings en operaciones mineras

Búsqueda semántica en bibliotecas técnicas

Una empresa minera acumula miles de documentos técnicos: estudios geológicos, reportes de planta, protocolos operativos, análisis metálurgicos, registros de mantenimiento. Cuando un ingeniero busca "pérdida de finos en columna de flotación por reactivo péptizante", la búsqueda tradicional por palabras clave falla porque los reportes hablan de "arrastre de mineral en celda primaria con exceso de espumante".

La solución: convertir cada documento a un embedding de 768 dimensiones, convertir la consulta también, y buscar los embeddings con mayor similitud coseno. La búsqueda encuentra documentos que hablan del mismo concepto aunque las palabras sean distintas.

Embeddings = bibliotecas técnicas que entienden lo que buscás, no solo lo que escribiste

Clasificación automática de fallas operacionales

Cada incidente operacional se describe en texto libre. Embebiendo esos textos en un mismo espacio vectorial y aplicando clustering (con norma L2), aparecen automáticamente categorí>as de fallas que un experto reconoce: "atascamiento", "sobrecarga", "fuga", "vibración anómala". El sistema clasifica nuevas fallas sin que nadie programe las reglas.

Espacios vectoriales = inventariar automáticamente lo que pasa en planta

Identificación de muestras geoquímicas similares

Cada testigo de perforación tiene un perfil geoquímico de 30+ elementos. Cada muestra es un vector en R³⁰. Buscar las muestras más similares a una de interés se reduce a buscar los vectores más cercanos en norma L2 (o L1 para penalizar diferencias extremas).

Norma + espacio vectorial = encontrar alálogos geológicos directamente

+ Más parientes del concepto

El mundo de los espacios donde "viven" los vectores se ramifica en direcciones más ricas. Algunos parámetros que se generalizan:

Espacios de HilbertVer▾

Generalizan Rⁿ a dimensión infinita pero conservan la geometría "lim", producto interno, ortogonalidad, proyecciones. Aparecen al estudiar funciones como vectores (las series de Fourier viven ahí), y son la base matemática de la mecánica cuántica y de buena parte de la teoría moderna de procesamiento de señales.

Ortogonalidad y bases ortonormalesVer▾

Dos vectores son ortogonales si su producto interno vale 0. Una base es ortonormal si todos sus vectores son ortogonales entre sí y tienen norma 1. Trabajar con bases ortonormales simplifica muchísimo todo: las proyecciones son inmediatas y las inversas de matrices coinciden con las transpuestas (matrices ortogonales).

Métricas no derivadas de normasVer▾

No toda manera de medir distancia entre dos puntos viene de una norma. La distancia de Hamming (número de coordenadas que difieren) y la distancia de edición (cambios para pasar de una cadena a otra) son ejemplos clásicos. En procesos biológicos y en NLP clásico aparecen seguido.

Subespacios y proyeccionesVer▾

Un subespacio es un espacio vectorial más chico dentro de uno más grande (una recta dentro del plano, un plano dentro del espacio 3D). Proyectar un vector sobre un subespacio es la base de la regresión por mínimos cuadrados: la mejor aproximación posible dentro de un subespacio se calcula con producto interno.

Ver el código en Python: normas, similitud coseno y embeddings de juguete Click para abrir

Cinco snippets que van de las tres normas básicas hasta una búsqueda semántica de juguete sobre embeddings sintéticos.

1. Las tres normas con numpy:

01_tres_normas.pyPYTHON

import numpy as np

v = np.array([1.5, 1.0, -2.0, 0.5])

# Norma L1: suma de valores absolutos
l1 = np.linalg.norm(v, ord=1)

# Norma L2 (euclídea): raíz de la suma de cuadrados
l2 = np.linalg.norm(v, ord=2)   # también: np.linalg.norm(v)

# Norma L infinito: máximo en valor absoluto
linf = np.linalg.norm(v, ord=np.inf)

print(f"L1   = {l1:.3f}")
print(f"L2   = {l2:.3f}")
print(f"Linf = {linf:.3f}")

# Siempre se cumple: L1 ≥ L2 ≥ Linf
print(f"L1 ≥ L2 ≥ Linf? {l1 >= l2 >= linf}")

2. Producto interno y similitud coseno:

02_similitud_coseno.pyPYTHON

import numpy as np

def coseno(u, v):
    """Similitud coseno entre dos vectores."""
    return np.dot(u, v) / (np.linalg.norm(u) * np.linalg.norm(v))

# Vectores "parecidos"
u1 = np.array([1, 2, 3])
v1 = np.array([2, 4, 6])
print(f"cos(u1, v1) = {coseno(u1, v1):.3f}")   # cerca de 1: misma dirección

# Vectores ortogonales
u2 = np.array([1, 0])
v2 = np.array([0, 1])
print(f"cos(u2, v2) = {coseno(u2, v2):.3f}")   # 0: sin relación

# Vectores opuestos
u3 = np.array([1, 2])
v3 = np.array([-1, -2])
print(f"cos(u3, v3) = {coseno(u3, v3):.3f}")   # -1: opuestos

3. Regularización L1 vs L2 (Lasso vs Ridge):

03_lasso_vs_ridge.pyPYTHON

import numpy as np
from sklearn.linear_model import Lasso, Ridge

# Datos sintéticos: 5 features, solo 2 importan de verdad
np.random.seed(42)
n = 100
X = np.random.randn(n, 5)
y = 3 * X[:, 0] - 2 * X[:, 2] + np.random.randn(n) * 0.3

# Lasso usa norma L1 → hace ceros (selección de variables)
lasso = Lasso(alpha=0.1).fit(X, y)
print(f"Lasso (L1): {lasso.coef_.round(2)}")
# Esperado: pesos en posición 0 y 2, los demás en 0

# Ridge usa norma L2 → reduce todos pero no hace ceros
ridge = Ridge(alpha=1.0).fit(X, y)
print(f"Ridge (L2): {ridge.coef_.round(2)}")
# Esperado: todos los pesos no cero, los irrelevantes pequeños

4. Embeddings y búsqueda semántica de juguete:

04_busqueda_semantica.pyPYTHON

import numpy as np

# Embeddings sintéticos en R^4 (lo real son R^768)
np.random.seed(42)
embeddings = {
    "rey":      np.array([0.8, 0.2, 0.9, 0.3]),
    "reina":    np.array([0.7, 0.9, 0.8, 0.4]),
    "hombre":   np.array([0.6, 0.1, 0.2, 0.5]),
    "mujer":    np.array([0.5, 0.8, 0.1, 0.6]),
    "manzana":  np.array([0.1, 0.0, 0.0, 0.9]),
}

def coseno(u, v):
    return np.dot(u, v) / (np.linalg.norm(u) * np.linalg.norm(v))

# Buscar las palabras más parecidas a "rey"
consulta = embeddings["rey"]
ranking = sorted(
    [(w, coseno(consulta, e)) for w, e in embeddings.items() if w != "rey"],
    key=lambda x: -x[1]
)
print("Más parecidas a 'rey':")
for palabra, sim in ranking:
    print(f"  {palabra:10s}  cos = {sim:.3f}")

5. Aritmética de embeddings: rey - hombre + mujer ≈ reina:

05_aritmetica_embeddings.pyPYTHON

import numpy as np

embeddings = {
    "rey":    np.array([0.8, 0.2, 0.9, 0.3]),
    "reina":  np.array([0.7, 0.9, 0.8, 0.4]),
    "hombre": np.array([0.6, 0.1, 0.2, 0.5]),
    "mujer":  np.array([0.5, 0.8, 0.1, 0.6]),
}

# Operación vectorial clásica de embeddings
objetivo = embeddings["rey"] - embeddings["hombre"] + embeddings["mujer"]

def coseno(u, v):
    return np.dot(u, v) / (np.linalg.norm(u) * np.linalg.norm(v))

# ¿Qué palabra es más cercana al vector resultante?
ranking = sorted(
    [(w, coseno(objetivo, e)) for w, e in embeddings.items()],
    key=lambda x: -x[1]
)
print("rey - hombre + mujer = ?")
for palabra, sim in ranking[:3]:
    print(f"  {palabra:8s}  cos = {sim:.3f}")
# Idealmente "reina" aparece primero

9 Pregunta de chequeo

Querés entrenar un modelo de regresión con 500 variables, pero sospechás que solo unas pocas son realmente importantes. ¿Qué tipo de regularización te conviene usar?

Próxima lección

Ya sabés cómo viven los vectores en muchas dimensiones, cómo se miden y cómo se relacionan. Lo que falta es entender qué transformaciones lineales se les aplican y cómo esa abstracción se vuelve la mismísima capa de una red neuronal. Eso cierra el Módulo 2.

Regístrate al boletín MathPlay

De la idea al laboratorio que funciona: datos, simulación, visualización e IA explicadas con imágenes que se mueven. Te escribo cuando hay algo nuevo que vale la pena compartir.

Sin calendario fijo. Sin spam.

Listo. Te escribo cuando haya algo nuevo.

Mate MathPlay

Matemática visual abierta

MathPlay conecta matemática, programación y visualización para que los conceptos se entiendan jugando, no memorizando. Cada lección se sostiene por sí sola y trae código Python para que pruebes en tu máquina.

Más de MathPlay

▶ YouTube · Tech ☰ Datos · IA aplicada ⚙ Prototipado 3D

← Lección anterior: eigenvalores Siguiente: transformaciones lineales →Volver al módulo