Embeddings: el significado como geometría

Un embedding es una fila de una matriz

Sea $V$ el tamaño del vocabulario y $d$ la dimensión de los vectores. La tabla es una matriz $E\in\mathbb{R}^{V\times d}$. La palabra de índice $i$ es el vector one-hot $x_i\in\{0,1\}^V$ (un uno en la posición $i$, ceros en el resto) y su embedding es

Multiplicar por un one-hot equivale a elegir una fila: es una capa lineal sin activación (lección 7) cuyos $V\cdot d$ pesos se aprenden. Con $V=400\,000$ y $d=100$ son $40\,000\,000$ de números. En la práctica no se multiplica: se consulta la fila. El mismo mecanismo abre los modelos de lenguaje: en GPT-2 pequeño la tabla es de $50\,257\times 768\approx 38.6$ millones de parámetros (lecciones 20 y 22).

Similitud coseno

Si los dos vectores tienen longitud 1, $\cos(a,b)=a\cdot b$ y $\lVert a-b\rVert^2=2-2\cos(a,b)$: ordenar por coseno y ordenar por distancia euclídea da el mismo orden. Ejemplo: $a=(3,4)$ y $b=(4,3)$ dan $\cos=\frac{12+12}{5\cdot 5}=0.96$, un ángulo de unos $16^\circ$. Con $\cos=0.88$ ("perro" y "gato") el ángulo es $\arccos 0.88\approx 28^\circ$.

¿De dónde salen los números?

Skip-gram (Mikolov et al., 2013) maximiza la probabilidad promedio de las palabras vecinas de cada palabra $w_t$, con una ventana de tamaño $c$:

Cada palabra tiene un vector de entrada $v$ (su embedding) y uno de salida $v'$. El denominador recorre todo el vocabulario, y por eso el artículo propone aproximaciones, como el muestreo negativo. GloVe (Pennington et al., 2014) ajusta en cambio

donde $X_{ij}$ cuenta cuántas veces aparece $j$ cerca de $i$ en el corpus, y se entrena con AdaGrad. Dos caminos, una misma idea: las palabras que comparten contextos acaban con vectores parecidos.

La aritmética, paso a paso

La pregunta «$a$ es a $a^*$ como $b$ es a ...» se responde con

Con vectores de longitud 1, $\lVert a^*-a+b\rVert$ no depende de $x$, así que esto equivale a maximizar $\cos(x,a^*)-\cos(x,a)+\cos(x,b)$. La exclusión no es un detalle: Linzen (2016) midió que, sin ella, la más cercana era $b$ en el 93 % de los casos y $a^*$ en el 5 %. En esta lección, con los 100 números de GloVe y eligiendo entre sus 400 000 palabras:

Preguntas	Con exclusión	Sin exclusión	La más cercana era una de las 3 de entrada
Capital–país (342)	80.1 % (274)	68.1 %	19.3 %
Género (90)	85.6 % (77)	55.6 %	41.1 %

Los pares los elegí yo y son relaciones limpias; el conjunto de Mikolov et al. (19 544 preguntas, 14 tipos, y solo cuenta la palabra exacta, no sinónimos) es más difícil: su mejor modelo llegó a 65.6 %. Con solo las 880 palabras de la lección el examen es mucho más fácil (94.4 % y 85.6 %): hay menos candidatos entre los que equivocarse. Linzen añade que el método mezcla la consistencia del desplazamiento con la estructura de vecindad: no mide solo «relaciones».

Cómo se mide el sesgo en la lección

Con $F$ = {mujer, niña, madre, esposa, hermana, hija} y $M$ = {hombre, niño, padre, esposo, hermano, hijo} (en inglés en los datos), el puntaje de una palabra $w$ es

Positivo es más cerca de lo femenino. Se usan conjuntos y no un par porque «man» tiene varios sentidos. Es una versión simplificada de las pruebas de asociación de Caliskan et al. (2017). Resultado con las 52 profesiones del vocabulario: de $-0.16$ («boss») a $+0.10$ («receptionist»); 26 objetos sin género (mesa, árbol, río…) quedan entre $-0.05$ y $+0.03$. La correlación de Spearman con el puntaje «she» − «he» en GloVe completo es 0.91. El puntaje mezcla género con tema (en el texto, lo femenino aparece más junto a «vestido» o «jabón»): sirve para ver la pendiente, no para dar un veredicto sobre una persona. Si a cada vector se le resta su componente en $g=\bar F-\bar M$ (normalizado), el puntaje en ese eje vale 0 por construcción; aun así, adivinar si cada profesión estaba por encima o por debajo de la mediana del puntaje original, con el centroide más cercano por coseno y dejando una fuera cada vez, acierta 41 de 52 antes y 35 de 52 después (azar: 26). Es un experimento mínimo, con pocas palabras, en el espíritu del de Gonen y Goldberg (2019), quienes mostraron que los métodos para «desagregar» el sesgo en gran medida lo esconden, no lo quitan.

Búsqueda semántica

El promedio de un texto con palabras $w_1,\dots,w_n$ es $q=\frac1n\sum_k e_{w_k}$; se ordenan los documentos por $\cos(q,D_j)$. Comparar contra $N$ documentos cuesta $O(N\cdot d)$ por consulta, y con millones se usan índices aproximados. Los vectores de oraciones (Reimers y Gurevych, 2019) se calculan una sola vez por documento: encontrar el par más parecido entre 10 000 oraciones con BERT exige unos 50 millones de inferencias (unas 65 horas); con vectores de oraciones, unos 5 segundos. La tercera columna de la escena usa paraphrase-multilingual-MiniLM-L12-v2 (Apache-2.0, 384 dimensiones, más de 50 idiomas; Reimers y Gurevych, 2020), con promedio de los vectores de salida y coseno. Sus puntajes se calcularon fuera de línea para las 36 preguntas de prueba.

Con 36 preguntas, 19 aciertos son 52.8 % con un intervalo de Wilson al 95 % de 37 % a 68 %: un margen de unos ±15 puntos. Por eso la lección 34 insiste en el tamaño de la muestra.

En código

Con vectores de juguete (números inventados) se ve el mecanismo completo:

import numpy as np

# Tabla de embeddings de juguete: una fila por palabra, 3 números cada una (inventados; un modelo real usa cientos).
palabras = ["rey", "reina", "hombre", "mujer", "pan"]
E = np.array([
    [4.0, 3.0,  1.0],   # rey
    [4.0, 0.5, -2.0],   # reina
    [4.0, 0.0,  1.0],   # hombre
    [4.0, 0.0, -1.0],   # mujer
    [0.0, 0.5,  3.0],   # pan
])
E = E / np.linalg.norm(E, axis=1, keepdims=True)   # longitud 1: el producto punto es el coseno
fila = {w: i for i, w in enumerate(palabras)}

def coseno(a, b):
    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))

def cercanas(v, excluir=()):
    pares = [(w, round(coseno(v, E[i]), 2)) for w, i in fila.items() if w not in excluir]
    return sorted(pares, key=lambda p: -p[1])[:3]

print(round(coseno(E[fila["rey"]], E[fila["reina"]]), 2))          # rey y reina
v = E[fila["rey"]] - E[fila["hombre"]] + E[fila["mujer"]]           # rey - hombre + mujer
print(cercanas(v))                                                   # sin excluir
print(cercanas(v, excluir=["rey", "hombre", "mujer"]))               # excluyendo las tres de entrada
# 0.68
# [('rey', 0.89), ('reina', 0.87), ('mujer', 0.81)]
# [('reina', 0.87), ('pan', -0.18)]

Y con los vectores reales de GloVe (el archivo glove.6B.100d.txt sale de la página de Stanford, ver las fuentes; leerlo tarda unos segundos):

import numpy as np

palabras, filas = [], []
with open("glove.6B.100d.txt", encoding="utf8") as f:
    for linea in f:
        w, _, resto = linea.partition(" ")
        palabras.append(w)
        filas.append(np.asarray(resto.split(), dtype=np.float32))
E = np.stack(filas)
E /= np.linalg.norm(E, axis=1, keepdims=True)   # longitud 1: el producto punto es el coseno
idx = {w: i for i, w in enumerate(palabras)}

def cercanas(v, k=5, excluir=()):
    s = E @ (v / np.linalg.norm(v))
    for w in excluir:
        s[idx[w]] = -1
    top = np.argsort(-s)[:k]
    return [(palabras[i], round(float(s[i]), 2)) for i in top]

print(cercanas(E[idx["dog"]], 5, excluir=["dog"]))
v = E[idx["king"]] - E[idx["man"]] + E[idx["woman"]]
print(cercanas(v, 3))
print(cercanas(v, 3, excluir=["king", "man", "woman"]))
# [('cat', 0.88), ('dogs', 0.83), ('pet', 0.74), ('puppy', 0.72), ('horse', 0.71)]
# [('king', 0.84), ('queen', 0.77), ('monarch', 0.68)]
# [('queen', 0.77), ('monarch', 0.68), ('throne', 0.68)]

De dónde salen los datos de esta lección

Vectores: GloVe 6B de 100 dimensiones (Wikipedia 2014 y Gigaword 5, 6 mil millones de palabras, 400 000 de vocabulario, solo inglés), publicado por Stanford bajo la licencia Public Domain Dedication and License v1.0, que permite redistribuir. Se normalizan a longitud 1 y se guardan en 8 bits (error de coseno máximo 0.0095). El mapa es t-SNE (van der Maaten y Hinton, 2008) con perplejidad 20, métrica coseno y semilla 0: Wattenberg et al. (2016) advierten que en un t-SNE el tamaño de los grupos y la distancia entre ellos pueden no significar nada. Las 10 frases de soporte y las 36 preguntas de prueba las escribió el autor de la lección: son ilustrativas. Todo se regenera con los scripts de la carpeta de la lección (build-vectors.py, eval-search.py, eval-analogies.py, measure-data.py).

Lo que viene

Los vectores de esta lección son estáticos: una palabra, un vector. La atención (lección 21) y el transformer (lección 22) producen un vector distinto para cada palabra según la frase. La lección 15 pregunta si, además de representar lo que existe, se puede generar algo nuevo; la 18 une vectores de imágenes y de texto en un mismo espacio, y la 31 usa la búsqueda semántica para dar conocimiento propio a un modelo.