Palabras como vectores
Unos 21 minutos de lectura, con 8 ejemplos en 10 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.16. Lee el original
En esta página
- Los vectores one-hot no saben nada
- Describe un token por los tokens que lo rodean
- Pondera la coocurrencia según su sorpresa
- Comprime los conteos en vectores densos
- Aprender vectores prediciendo vecinos
- Compara los vectores aprendidos con los contados
- Analogías, y dónde fallan
- Encontrar nombres similares con vectores
- Qué sale mal en producción
- Lo que decidió este capítulo
Al final de este capítulo podrás convertir cada token del texto de la tienda en un vector corto de números, de modo que los tokens usados de forma parecida obtengan vectores parecidos, mediante dos métodos: comprimir los conteos de qué tokens aparecen juntos, y entrenar un modelo pequeño para predecir los vecinos de cada token. Medirás qué saben esos vectores, dónde fallan y cómo permiten que un modelo relacione un texto que nunca ha visto con un texto que sí conoce.
Capítulo 3 terminó con un límite que el conteo no puede superar. Su modelo de 4-gramas había visto patio bar stool muchas veces, y sugería stool después de patio bar. Después de outdoor bar, que ningún nombre de entrenamiento contiene, recurría a sugerencias genéricas, porque un conteo de un solo contexto no le dice nada sobre otro. Un comprador, o cualquier lector, sabe que outdoor y patio significan casi lo mismo para la tienda, y un modelo necesita alguna forma de saberlo también. Este capítulo asigna a cada token un vector, una lista de números, y ordena los vectores de manera que los tokens usados de forma parecida queden cerca unos de otros.
Los vectores necesitan texto que muestre cómo se usan las palabras, y la tienda, un vendedor en línea de muebles y artículos para el hogar, dispone de mucho en los nombres y descripciones de su catálogo. Su partición de entrenamiento, el 80% de los productos a partir de los cuales aprenden los modelos, contiene 2,744,320 tokens de ese texto, y cada vector de este capítulo proviene únicamente de él, a través del tokenizador de la tienda del capítulo 2.
Los vectores one-hot no saben nada
Hasta ahora, todos los modelos han tratado los tokens como nombres: patio es una entrada en una tabla y outdoor otra, sin nada que las relacione. Escritos como vectores, eso es una codificación one-hot, en la que cada token recibe un vector tan largo como el vocabulario, con un 1 en su propia posición y 0 en todas las demás. Para medir qué tan parecidos son dos vectores, este libro usa la similitud coseno: el coseno del ángulo entre ellos, 1 cuando apuntan en la misma dirección, 0 cuando forman ángulo recto. Ignora la longitud de los vectores y compara solo sus direcciones.
Asigna vectores one-hot a los 2,000 tokens más frecuentes del texto de entrenamiento, y compara patio con outdoor, con sofa y consigo mismo. Esos 2,000 son alrededor de la mitad del vocabulario del tokenizador de la tienda, lo que mantiene cada matriz de este capítulo lo bastante pequeña como para calcularla en segundos:
1"""One-hot vectors for the 2,000 most frequent tokens, and the cosine similarity of patio with outdoor, with sofa and with2itself. The prose's point rests on the patio–outdoor and patio–sofa lines: patio is as unrelated to outdoor as to sofa."""3import numpy as np45from lib.vectors import BREAK, training_ids # the book's shared module; BREAK marks the gap between two texts67ids, vocabulary = training_ids() # each training token as a number; RARE for tokens outside the vocabulary8index = {token: i for i, token in enumerate(vocabulary)}91011def one_hot(token):12 vector = np.zeros(len(vocabulary))13 vector[index[token]] = 1.0 # one column per token: 1 for this token, 0 everywhere else14 return vector151617def cosine(a, b):18 return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))192021print("numbers in each vector:", len(vocabulary))22print("cosine(patio, outdoor):", cosine(one_hot("patio</w>"), one_hot("outdoor</w>"))) # </w> marks a word's last token: patio</w> is the whole word23print("cosine(patio, sofa):", cosine(one_hot("patio</w>"), one_hot("sofa</w>")))24print("cosine(patio, patio):", cosine(one_hot("patio</w>"), one_hot("patio</w>")))25print("share of training tokens with a vector:", f"{(ids >= 0).sum() / (ids != BREAK).sum():.0%}") # ids >= 0 are the kept tokens; BREAK gaps aren't tokens
python one-hot-vectors.pynumbers in each vector: 2000
cosine(patio, outdoor): 0.0
cosine(patio, sofa): 0.0
cosine(patio, patio): 1.0
share of training tokens with a vector: 91%
Una codificación one-hot dice que las dos palabras de exterior son exactamente tan poco relacionadas entre sí como lo están un patio y un sofá. La similitud coseno de patio y outdoor es 0.0, y lo mismo ocurre con la de patio y sofa. Solo un token comparado consigo mismo obtiene 1.0. Cada vector tiene 2000 números. Los 2,000 tokens que reciben vectores constituyen 91% del texto de entrenamiento; el resto son más raros, y este capítulo los deja fuera. Cada par de tokens distintos forma un ángulo recto, igual que cualquier otro par, así que nada aprendido sobre uno puede transferirse a otro.
Es el mismo defecto que el de los conteos del capítulo 3, bajo otra forma. Un modelo que lee vectores one-hot tiene que aprender sobre cada token por separado, a partir de los contextos en los que ese mismo token aparece. Los tokens raros reciben poco, y las combinaciones no vistas no reciben nada.
Regla práctica: No le des vectores one-hot a un modelo que necesite relacionar tokens entre sí. Úsalos solo como índice, como hacen las secciones siguientes, para buscar un vector aprendido para cada token.
Describe un token por los tokens que lo rodean
La solución consiste en describir una palabra por la compañía que tiene. Dos palabras que aparecen entre los mismos vecinos, como patio y outdoor, que ambas surgen cerca de furniture, chair y umbrella, es probable que signifiquen cosas parecidas, aunque rara vez aparezcan juntas. Así que describe cada token por sus vecinos: cuenta, para cada par de tokens, con qué frecuencia uno aparece dentro de una ventana pequeña del otro, aquí dos tokens a cada lado, y nunca a través del límite entre los textos de dos productos. La fila de conteos de cada token es entonces un vector de aquello cerca de lo que aparece.
Cuenta las coocurrencias en los nombres y descripciones del conjunto de entrenamiento, y enumera lo que aparece con más frecuencia cerca de patio:
1"""Counts how often each of the 2,000 kept tokens appears within two tokens of another, and lists the six tokens seen most2often near patio. The prose's point rests on that list: punctuation and common words come first."""3import numpy as np45from lib.vectors import BREAK, cooccurrence, training_ids # the book's shared module; BREAK marks the gap between two texts67ids, vocabulary = training_ids() # each training token as a number; RARE for tokens outside the vocabulary8counts = cooccurrence(ids, len(vocabulary)) # how often each token appears within 2 tokens of another9patio = vocabulary.index("patio</w>") # </w> marks a word's last token: patio</w> is the whole word, not a piece of a longer one1011print("training tokens:", f"{int((ids != BREAK).sum()):,}") # RARE tokens count here, since they are tokens; only the BREAK gaps don't12print("vocabulary kept:", f"{len(vocabulary):,}")13print("tokens near patio, counting repeats:", f"{int(counts[patio].sum()):,}") # the row's total, a token counted again at each repeat14for i in np.argsort(-counts[patio], kind="stable")[:6]: # the minus sorts most frequent first; ties keep vocabulary order15 print(f" near patio: {vocabulary[i]:<12} {int(counts[patio, i]):>6,}")
python cooccurrence-counts.pytraining tokens: 2,744,320
vocabulary kept: 2,000
tokens near patio, counting repeats: 8,790
near patio: ,</w> 646
near patio: or</w> 448
near patio: with</w> 433
near patio: your</w> 381
near patio: .</w> 340
near patio: furniture</w> 249
De los 8,790 tokens a dos posiciones de patio, contando un token de nuevo cada vez que aparece allí, los más frecuentes son decepcionantes: una coma, or, with, your y un punto, antes de la primera palabra relacionada con patios, furniture. Esos tokens aparecen cerca de casi todo, porque están en todas partes. Una fila de conteos brutos dice sobre todo lo común que es cada vecino, no qué tiene de especial el token cuya fila es.
Así que los conteos brutos hacen malos vectores. Dos tokens que aparecen a menudo se parecerán porque comparten los mismos vecinos frecuentes, comas y with, sea cual sea su significado. Lo que importa es qué vecinos tiene un token con más frecuencia de la que cabría esperar por lo común que es cada uno de ellos.
Regla práctica: Cuenta la coocurrencia dentro de una ventana pequeña, de dos a cinco tokens, en el texto con el que aprenderá el modelo, y nunca a través de los límites de los documentos. No uses los conteos brutos como vectores: vuelve a ponderarlos, como hace la siguiente sección, para que los vecinos frecuentes dejen de dominar.
Pondera la coocurrencia según su sorpresa
La corrección compara cada recuento con lo que predeciría el azar. Si patio y furniture aparecieran de forma independiente el uno del otro, coocurrirían aproximadamente con la frecuencia que implican sus frecuencias por separado. La información mutua puntual, o PMI, mide cuánto se aleja el recuento real del azar: el logaritmo del cociente entre con qué frecuencia coocurren dos tokens y con qué frecuencia lo harían por azar (Church y Hanks, 1990). En símbolos, para los tokens a y b:
PMI(a, b) = log [ P(a, b) / (P(a) · P(b)) ]
donde P(a, b) es la proporción de todos los recuentos de coocurrencia que corresponden a a y b juntos, y P(a) y P(b) son la proporción de cada token. La PMI es positiva cuando dos tokens aparecen juntos más de lo que predice el azar, y negativa cuando lo hacen menos. Los valores negativos no son fiables, porque «menos que el azar» suele significar «casi nunca visto», así que la PMI positiva, o PPMI, reemplaza cada valor negativo por cero. El módulo compartido del libro lib.vectors la calcula a partir de los recuentos de coocurrencia de la sección anterior, en tres líneas: el recuento que predeciría el azar para cada par, el logaritmo del recuento real sobre él, y cero donde eso sea negativo o el par nunca aparece:
expected = counts.sum(1, keepdims=True) * counts.sum(0, keepdims=True) / total
pmi = np.log(counts / expected)
return np.where(counts > 0, np.maximum(pmi, 0), 0.0)
El repesado pretende evitar que los vecinos frecuentes dominen, así que cambia los recuentos brutos por la PPMI y vuelve a listar los vecinos más fuertes de patio:
1"""Reweights the co-occurrence counts with positive PMI, and lists the six tokens with the strongest weight beside patio.2The prose's point rests on that list: the commas and common words of the raw counts are gone."""3import numpy as np45from lib.vectors import cooccurrence, ppmi, training_ids67ids, vocabulary = training_ids() # each training token as a number; RARE for tokens outside the vocabulary8weights = ppmi(cooccurrence(ids, len(vocabulary))) # PPMI of the co-occurrence counts, within the same window of 2 tokens9patio = vocabulary.index("patio</w>") # </w> marks a word's last token: patio</w> is the whole word1011print("share of PPMI entries that are zero:", f"{(weights == 0).mean():.0%}") # zero for pairs that never co-occur and for pairs seen no more often than chance12for i in np.argsort(-weights[patio], kind="stable")[:6]: # the largest weights first; ties keep vocabulary order13 print(f" PPMI with patio: {vocabulary[i]:<12} {weights[patio, i]:.2f}")
python ppmi-neighbours.pyshare of PPMI entries that are zero: 86%
PPMI with patio: porch</w> 4.51
PPMI with patio: deck</w> 4.19
PPMI with patio: backyard</w> 3.97
PPMI with patio: sectional</w> 3.75
PPMI with patio: furniture</w> 3.59
PPMI with patio: garden</w> 3.53
Las comas han desaparecido. Los vecinos más fuertes de patio según la PPMI son porch, deck, backyard, sectional, furniture y garden: palabras que una persona asociaría con un patio, ordenadas según cuánto más de lo que predice el azar aparecen cerca de él. La mayoría de los pares de tokens no coocurren más de lo que predice el azar, por eso 86% de la matriz PPMI es cero.
Los vectores PPMI ya son útiles: dos tokens con filas PPMI similares tienen vecinos distintivos parecidos. Pero cada vector sigue teniendo 2,000 números, en su mayoría ceros, y dos tokens con vecinos relacionados pero no idénticos, por ejemplo deck y porch, pueden compartir pocas entradas no nulas.
Regla práctica: Repondera los recuentos de coocurrencia con la PMI positiva antes de usarlos como vectores. Espera que la PMI sobrevalore los pares de tokens poco frecuentes, cuyas pocas coocurrencias parecen muy por encima del azar; esa es una razón para conservar solo los tokens frecuentes, como hace este capítulo, o para exigir un recuento mínimo.
Comprime los conteos en vectores densos
Un vector PPMI de 2,000 números, en su mayoría ceros, tiene mucho espacio y poca información. Comprimirlo en un vector corto y denso conserva los patrones más fuertes de coocurrencia, descarta el ruido y acerca los tokens con vecinos relacionados, incluso cuando comparten pocos vecinos exactos. La herramienta es la descomposición en valores singulares, SVD, que encuentra las 64 direcciones que, en conjunto, reconstruyen mejor las filas PPMI, y pondera cada una según cuánto de las filas explica. Las 64 coordenadas ponderadas de un token a lo largo de esas direcciones son su nuevo vector: un embedding, un vector denso que representa a un token. El método lib.vectors.svd_vectors las calcula, escala cada una a longitud unitaria, y lib.vectors.nearest encuentra los tokens con mayor similitud coseno con cualquier vector.
Los cuatro vecinos más cercanos de seis tokens muestran lo que conservan los 64 números:
1"""Compresses the PPMI matrix into 64 numbers per token, and lists the four nearest neighbours of six tokens. The prose's2point rests on the first two lists and the last line: patio and outdoor are each other's nearest neighbour, at the cosine printed last."""3from lib.vectors import DIMENSIONS, nearest, svd_vectors # svd_vectors does the PPMI and SVD steps; nearest ranks tokens by cosine similarity45vectors, vocabulary = svd_vectors() # one 64-number row per token, each scaled to unit length6index = {token: i for i, token in enumerate(vocabulary)}78print("dimensions per token:", DIMENSIONS)9for token in ["patio</w>", "outdoor</w>", "sofa</w>", "oak</w>", "blue</w>", "48</w>"]: # </w> marks a word's last token10 neighbours = nearest(vectors, vocabulary, vectors[index[token]], k=4, skip=(token,)) # skip leaves out the token itself, which would otherwise be its own nearest at 1.0011 print(f"{token:<12} -> " + ", ".join(f"{t} {s:.2f}" for t, s in neighbours))12print("cosine(patio, outdoor):", f"{float(vectors[index['patio</w>']] @ vectors[index['outdoor</w>']]):.2f}") # unit-length vectors, so the dot product is the cosine
python svd-neighbours.pydimensions per token: 64
patio</w> -> outdoor</w> 0.84, bistro</w> 0.79, porch</w> 0.79, lounge</w> 0.77
outdoor</w> -> patio</w> 0.84, porch</w> 0.82, indoor</w> 0.80, furniture</w> 0.74
sofa</w> -> sectional</w> 0.93, chaise</w> 0.90, loveseat</w> 0.89, lounge</w> 0.87
oak</w> -> walnut</w> 0.96, veneers</w> 0.90, espresso</w> 0.89, weathered</w> 0.88
blue</w> -> green</w> 0.86, beige</w> 0.86, pur 0.80, abstract</w> 0.79
48</w> -> 36</w> 0.94, 32</w> 0.93, 24</w> 0.92, 30</w> 0.89
cosine(patio, outdoor): 0.84
Cada token tiene ahora 64 números, y sus vecinos se leen como un tesauro hecho para una tienda de muebles. patio y outdoor son mutuamente el vecino más cercano, con una similitud coseno de 0.84, donde sus vectores one-hot daban cero. sofa está junto a sectional, chaise y loveseat; oak junto a walnut y espresso, un acabado de madera; blue junto a otros colores; y 48 junto a otras medidas en pulgadas.
Nada de eso se enseñó. El método nunca vio una definición de sofa, una lista de colores ni una pista de que 48 es un número. Descubrió que estos tokens aparecen entre los mismos tipos de vecinos en el texto de la tienda, y la SVD los acercó por ello. Esa es la propiedad que les faltaba a los conteos del capítulo 3: lo que un modelo aprende sobre patio bar stool puede ahora trasladarse, mediante los embeddings, a outdoor bar stool.
Regla práctica: Comprime PPMI con SVD a entre 50 y 300 dimensiones, y revisa el resultado como lo hace esta sección: enumera los vecinos más cercanos de un puñado de tokens y léelos. Si los vecinos son sobre todo palabras funcionales frecuentes, la reponderación salió mal; si no están relacionados, la ventana o el vocabulario son demasiado pequeños.
Aprender vectores prediciendo vecinos
La otra forma de obtener embeddings es aprenderlos mediante predicción, que es como cada modelo de lenguaje neuronal de este libro obtiene los suyos. Skip-gram con muestreo negativo, el método detrás de word2vec, asigna a cada token dos vectores, uno para cuando es el token central y otro para cuando es un vecino, y los entrena en una sola tarea: dado un token, distinguir sus vecinos reales de tokens aleatorios (Mikolov et al., 2013a; Mikolov et al., 2013b). Para un token y uno de sus vecinos reales, el modelo puntúa el par mediante el producto punto de sus vectores, convierte la puntuación en una probabilidad con la función logística y ajusta los vectores para que la probabilidad aumente. Para algunos tokens de ruido aleatorios extraídos del vocabulario, el modelo ajusta la probabilidad para que disminuya. Repetido sobre millones de pares, los tokens con los mismos vecinos terminan con vectores similares. No es una coincidencia: Levy y Goldberg demostraron que el skip-gram con muestreo negativo, entrenado de esta manera, en la práctica factoriza una matriz PMI, desplazada hacia abajo por el logaritmo del número de tokens de ruido, de forma similar a como la SVD factoriza PPMI (Levy y Goldberg, 2014).
Escribe v para el vector del token central, u para el del vecino real, uₙ para el de cada token de ruido, y σ para la función logística, σ(s) = 1 / (1 + e⁻ˢ), que convierte una puntuación en una probabilidad. La pérdida skip-gram para un par es la sorpresa ante el vecino real más la sorpresa ante que cada token de ruido no sea uno de ellos:
L = −log σ(v·u) − Σₙ log σ(−v·uₙ)
y lib.skipgram.step la reduce con tres líneas de descenso de gradiente, donde real es σ(v·u), fake contiene σ(v·uₙ) para cada token de ruido, y rate es el tamaño de paso:
np.add.at(inputs, centre, -rate * grad_v) # move v: towards u, away from each uₙ
np.add.at(outputs, context, -rate * (real - 1)[:, None] * v) # move u towards v
np.add.at(outputs, noise, -rate * fake[:, :, None] * v[:, None, :]) # move each uₙ away from v
Ejecuta tres actualizaciones sobre un par real, patio y umbrella, con sofa y 48 como tokens de ruido. Los vectores centrales empiezan pequeños y aleatorios, y los vectores de vecinos en cero, como los inicia lib.skipgram.train:
1"""Three updates of skip-gram with negative sampling on one real pair, patio and umbrella, with sofa and 48 as noise tokens,2printing each pair's probability before and after. The prose's point rests on the four probability lines: umbrella's rises,3and the noise tokens' fall."""4import numpy as np56from lib.skipgram import sigmoid, step # one gradient step, and the logistic function7from lib.vectors import training_ids89_, vocabulary = training_ids()10rng = np.random.default_rng(2026) # a fixed seed, so the starting vectors are the same on every run11inputs = (rng.random((len(vocabulary), 8)) - 0.5) / 8 # each token's vector as a centre, small and random12outputs = np.zeros((len(vocabulary), 8)) # and as a neighbour: zero, as training starts13centre, context = [vocabulary.index("patio</w>")], [vocabulary.index("umbrella</w>")] # the real pair: patio as the centre, umbrella its real neighbour14noise = np.array([[vocabulary.index("sofa</w>"), vocabulary.index("48</w>")]]) # noise tokens, picked by hand here; training draws them at random151617def chances():18 real = sigmoid(inputs[centre[0]] @ outputs[context[0]])19 fake = sigmoid(outputs[noise[0]] @ inputs[centre[0]])20 return real, fake212223before = chances() # zero neighbour vectors give every score zero, so every probability is one half24for _ in range(3): # three updates on the same pair25 step(np.array(centre), np.array(context), noise, inputs, outputs, rate=1.0) # rate 1.0, far above the 0.025 that training starts from, so three steps show26after = chances()27print("P(umbrella is a real neighbour of patio), before:", f"{before[0]:.3f}")28print("P(umbrella is a real neighbour of patio), after 3 steps:", f"{after[0]:.3f}")29print("P(sofa, 48 are real neighbours), before:", ", ".join(f"{p:.3f}" for p in before[1]))30print("P(sofa, 48 are real neighbours), after 3 steps:", ", ".join(f"{p:.3f}" for p in after[1]))
python skipgram-step.pyP(umbrella is a real neighbour of patio), before: 0.500
P(umbrella is a real neighbour of patio), after 3 steps: 0.525
P(sofa, 48 are real neighbours), before: 0.500, 0.500
P(sofa, 48 are real neighbours), after 3 steps: 0.475, 0.475
El entrenamiento acerca los vecinos reales y aleja los tokens aleatorios, y tres actualizaciones lo muestran en pequeño. Antes de cualquier actualización, los vectores de vecinos son cero, así que todas las puntuaciones son cero, y σ(0) es un medio: el modelo no sabe nada. Después de tres, umbrella puntúa 0.525 como vecino de patio, frente a 0.500 antes, y sofa y 48 han bajado a 0.475, 0.475. Eso es todo lo que hace el entrenamiento, millones de veces.
Regla práctica: Al entrenar embeddings, inicia el segundo conjunto de vectores en cero y el primero con valores pequeños aleatorios, como lo hace lib.skipgram.train, y extrae tokens de ruido en proporción a su frecuencia elevada a la potencia 0.75, lo que Mikolov et al. hallaron que funciona mejor que la frecuencia simple. Comprueba a mano una actualización antes de ejecutar millones: una probabilidad que se mueve en sentido contrario significa que el signo del gradiente es incorrecto.
Compara los vectores aprendidos con los contados
Entrenar skip-gram con todo el texto de entrenamiento de la tienda requiere millones de actualizaciones, y su resultado exacto depende de la aritmética de punto flotante de la máquina, que varía ligeramente entre procesadores. Por eso se ejecuta una sola vez, en recordings/skipgram.py, con el código propio del libro y una semilla fija, y los ejemplos leen los vectores guardados. Su manifiesto registra la configuración: una ventana de dos tokens, 64 dimensiones, cinco tokens de ruido por par y dos pasadas sobre el texto. Hay una configuración que no se registra sino que queda fijada en lib.skipgram: los pares centrados en tokens muy frecuentes, como las comas, se omiten en su mayoría, con un umbral de 10⁻⁴, lo que evita que dominen el entrenamiento (Mikolov et al., 2013b, quienes sugieren alrededor de 10⁻⁵ para textos más grandes).
Pide a los vectores skip-gram guardados los vecinos de los mismos seis tokens y compáralos con los del SVD:
1"""Reads the skip-gram vectors and training losses that recordings/skipgram.py saved, and lists the same six tokens' four2nearest neighbours as the SVD example. The prose's point rests on the two loss lines and on outdoor's nearest neighbour."""3import json45import numpy as np67from lib.vectors import nearest89recorded = "data/recorded/skipgram/" # saved by recordings/skipgram.py, which trains once: its values depend on the machine10vectors = np.load(recorded + "vectors.npy")11vocabulary = json.load(open(recorded + "vocabulary.json", encoding="utf-8"))12losses = np.load(recorded + "losses.npy") # one loss per batch, in training order13index = {token: i for i, token in enumerate(vocabulary)}1415print("training loss, first batch:", f"{losses[0]:.2f}") # index 0: the first batch, when nothing has been learned yet16print("training loss, last 100 batches:", f"{losses[-100:].mean():.2f}")17for token in ["patio</w>", "outdoor</w>", "sofa</w>", "oak</w>", "blue</w>", "48</w>"]:18 neighbours = nearest(vectors, vocabulary, vectors[index[token]], k=4, skip=(token,)) # skip leaves out the token itself19 print(f"{token:<12} -> " + ", ".join(f"{t} {s:.2f}" for t, s in neighbours))
python skipgram-neighbours.pytraining loss, first batch: 4.16
training loss, last 100 batches: 2.05
patio</w> -> porch</w> 0.77, bistro</w> 0.69, garden</w> 0.69, couch</w> 0.67
outdoor</w> -> indoor</w> 0.75, patio</w> 0.66, garden</w> 0.65, living</w> 0.61
sofa</w> -> couch</w> 0.85, sleeper</w> 0.84, chaise</w> 0.80, sectional</w> 0.78
oak</w> -> walnut</w> 0.91, espresso</w> 0.84, weathered</w> 0.81, glossy</w> 0.80
blue</w> -> beige</w> 0.88, gray</w> 0.87, green</w> 0.85, brown</w> 0.80
48</w> -> 36</w> 0.94, 32</w> 0.92, 1.5</w> 0.89, 24</w> 0.89
El modelo aprendió a distinguir los vecinos reales del ruido: su pérdida de entrenamiento bajó de 4.16 en el primer lote a 2.05 en los últimos cien. Sus vecinos coinciden con los del SVD en la mayoría de los tokens: sofa con sectional y chaise, oak con walnut y espresso, colores con colores, tamaños con tamaños, y difieren en el énfasis en otros tokens: skip-gram coloca outdoor lo más cerca posible de indoor, porque ambas palabras aparecen en las mismas posiciones en descripciones como indoor or outdoor use.
Vale la pena fijarse en esa diferencia. Los vectores construidos a partir de vecinos agrupan palabras usadas en los mismos lugares, y a menudo los opuestos lo son: aquí, indoor y outdoor, y, en la sección siguiente, small, cuyos vecinos más cercanos incluyen a larger además de smaller. Vectores similares significan uso similar, no significado similar.
Regla práctica: Trata los embeddings contados (PPMI y SVD) y los aprendidos (skip-gram) como alternativas cercanas: con unos pocos millones de tokens dan vecinos parecidos, y los contados son deterministas y rápidos. Prefiere los embeddings aprendidos cuando formen parte de un modelo más grande que entrenas de todos modos, como en cada capítulo posterior de este libro. Nunca leas una similitud alta como sinonimia sin comprobar si hay opuestos.
Analogías, y dónde fallan
Los embeddings son conocidos por admitir analogías mediante aritmética: si la diferencia entre chair y chairs es una dirección que significa "plural", entonces sumarla a table debería caer cerca de tables. En los vectores, la respuesta a "a es a b como c es a ¿qué?" es el token más cercano a b − a + c, excluyendo los tres tokens de la pregunta (Mikolov et al., 2013a). Es una prueba ingeniosa de si los vectores han aprendido relaciones consistentes, y un buen lugar para ver sus límites.
Tres analogías sobre los vectores skip-gram muestran dónde funciona la aritmética y dónde se rompe, y los vecinos más cercanos de tres tokens que plantean explican por qué:
1"""Three analogies on the skip-gram vectors, each answered by the tokens nearest b minus a plus c; whether lamps and light2have vectors at all; and the nearest tokens to a few single words. The prose rests on the three analogy lines, the lamps line and the neighbour lists."""3import json45import numpy as np67from lib.vectors import nearest89vectors = np.load("data/recorded/skipgram/vectors.npy") # saved by recordings/skipgram.py, which trains once10vocabulary = json.load(open("data/recorded/skipgram/vocabulary.json", encoding="utf-8"))11index = {token: i for i, token in enumerate(vocabulary)}1213for a, b, c in [("chair", "chairs", "table"), ("chair", "chairs", "lamp"), ("black", "white", "dark")]: # each reads: a is to b as c is to what14 a, b, c = (word + "</w>" for word in (a, b, c)) # the tokenizer marks each word's last token with </w>, so words are looked up in that form15 query = vectors[index[b]] - vectors[index[a]] + vectors[index[c]] # b - a + c: "c, changed the way a became b"16 answers = nearest(vectors, vocabulary, query, k=3, skip=(a, b, c)) # the words in the question can't be their own answer17 print(f"{a} : {b} :: {c} : ? -> " + ", ".join(t for t, _ in answers))18print("lamps in the vocabulary:", "lamps</w>" in index)19print("light in the vocabulary:", "light</w>" in index)20for token in ["light</w>", "dark</w>", "small</w>"]:21 print(f"{token:<12} -> " + ", ".join(t for t, _ in nearest(vectors, vocabulary, vectors[index[token]], k=4, skip=(token,))))
python analogies.pychair</w> : chairs</w> :: table</w> : ? -> tables</w>, cup</w>, stools</w>
chair</w> : chairs</w> :: lamp</w> : ? -> tops</w>, coffee</w>, tray</w>
black</w> : white</w> :: dark</w> : ? -> brown</w>, blue</w>, glossy</w>
lamps in the vocabulary: False
light in the vocabulary: True
light</w> -> lights</w>, bulb</w>, dimmable</w>, candle</w>
dark</w> -> brown</w>, walnut</w>, gray</w>, espresso</w>
small</w> -> smaller</w>, larger</w>, displaying</w>, storing</w>
Solo la primera analogía da la respuesta que cabría esperar: chair es a chairs como table es a tables, la respuesta principal. La segunda falla porque lamps no está entre los 2,000 tokens que tienen vectores, así que la respuesta correcta no puede encontrarse, y la aritmética devuelve lo que esté más cerca. La tercera falla de otra manera. light está en el vocabulario, pero black es a white como dark es a brown, según los vectores. Las listas de vecinos muestran por qué: light aparece junto a lights, bulb, dimmable y candle, porque en el texto de la tienda es sobre todo una lámpara, como en ceiling light, y no una pantalla, mientras que dark aparece junto a brown, walnut y espresso, los acabados que describe. Y small aparece junto a larger así como a smaller: las palabras de tamaño aparecen en los mismos lugares, sea cual sea el tamaño que nombren.
Las analogías son una demostración, no una medida. Funcionan para relaciones que el texto expresa de forma consistente y frecuente, como los plurales de palabras comunes, y fallan con palabras raras, con palabras de varios sentidos y con relaciones que el texto rara vez explicita. Un modelo no usa analogías; usa las posiciones de los vectores, y estas tienen las mismas fortalezas y puntos ciegos.
Regla práctica: No juzgues los embeddings por sus analogías; júzgalos por cuánto ayudan a la tarea para la que sirven, como hacen la siguiente sección y todos los capítulos posteriores. Cuando una analogía falle, comprueba si la respuesta está en el vocabulario y si las palabras significan en tu texto lo que supones.
Encontrar nombres similares con vectores
Los embeddings de tokens dan, con un paso más, embeddings de textos completos: se promedian los vectores de los tokens de un texto, se escala el resultado a longitud unitaria, y los textos similares obtienen vectores similares. Es una versión aproximada de lo que los motores de búsqueda llaman recuperación semántica, es decir, encontrar textos por su significado en lugar de por coincidencia de palabras, algo que el libro complementario de este, A Primer on Search Relevance, construye como es debido con un modelo entrenado (recuperación semántica). Aquí sirve para probar lo único que este capítulo pretendía corregir: el modelo de conteo del capítulo 3 no puede relacionar outdoor bar con patio bar.
Promediar los vectores skip-gram de cada nombre de entrenamiento convierte cada nombre en un solo vector. Las palabras raras, sobre todo el nombre de una línea de productos, se representan como [name], tal como explicó el capítulo 1. Dos consultas muestran lo que eso aporta: outdoor bar, el prefijo que desconcertó al modelo de 4-gramas del capítulo 3, y patio umbrella:
1"""Averages each training name's skip-gram token vectors into one unit-length vector, and prints the four training names2nearest to each of two queries. The prose's point rests on the first query: two patio bar stool names come up for outdoor bar."""3import json45import numpy as np67from lib import bpe8from lib.store import load_products, masked910vectors = np.load("data/recorded/skipgram/vectors.npy")11vocabulary = json.load(open("data/recorded/skipgram/vocabulary.json", encoding="utf-8"))12index, tokenizer = {t: i for i, t in enumerate(vocabulary)}, bpe.store_tokenizer()131415def name_vector(text): # the average of the text's token vectors, at unit length16 found = [index[t] for t in tokenizer.encode(text) if t in index] # tokens outside the 2,000 kept have no vector, so they're left out17 average = vectors[found].mean(0) if found else np.zeros(vectors.shape[1]) # a text with no kept tokens gets the zero vector18 return average / (np.linalg.norm(average) or 1.0) # `or 1.0`: a zero average stays zero, rather than dividing by zero192021names = load_products("train")["name"].tolist() # the training split's product names, the texts to compare22matrix = np.array([name_vector(n) for n in names])23for query in ["outdoor bar", "patio umbrella"]:24 best = np.argsort(-(matrix @ name_vector(query)), kind="stable")[:4] # unit vectors, so the dot product is the cosine; the four largest, most similar first25 print(f"{query}: " + " | ".join(masked(names[i]) for i in best)) # [name]: a rare word
python name-vectors.pyoutdoor bar: outdoor modern industrial 5 piece bar height dining set | [name] bar & bar stool | 29.5 '' patio bar stool | 28.5 '' patio bar stool
patio umbrella: premium tight weave outdoor patio umbrella cover | patio lantern | garden patio 88 [name] rattan deck box | outdoor patio chair
Los vectores promediados sitúan dos nombres de patio bar stool entre los más cercanos a outdoor bar, y ninguno contiene la palabra outdoor. Ese modelo no podía establecer esa relación, porque tenía conteos para patio bar stool y ninguno para outdoor bar. El vínculo pasa por outdoor y patio, cuyos vectores están cerca. Para patio umbrella, los nombres más cercanos son productos de patio y de exterior, y el primero es una funda para sombrilla, pero ninguno es una sombrilla en sí; el promedio deja que patio pese más que umbrella.
Promediar es rudimentario: olvida el orden de las palabras, de modo que bar stool y stool bar reciben el mismo vector, y deja que los tokens frecuentes ahoguen al que importa. Pero muestra la propiedad sobre la que se construye cada modelo posterior de este libro: un modelo que lee embeddings en lugar de tokens one-hot puede trasladar lo que aprendió sobre una frase a otra.
Regla práctica: Promedia los embeddings de tokens cuando necesites una representación rápida e independiente del orden de textos cortos, y espera que encuentre elementos relacionados pero que los ordene de forma imprecisa. Para una recuperación semántica real, usa un modelo entrenado para ello, como hace el Primer. Para el modelado del lenguaje, entrega al modelo los propios embeddings y deja que aprenda a combinarlos, lo que el capítulo 5 empieza a hacer.
Qué sale mal en producción
Los embeddings arrastran los hábitos de su texto de entrenamiento a todo lo que los usa:
- Un uso parecido no significa un significado parecido.
indooryoutdoorquedan cerca entre sí. Un sistema que trata los vectores cercanos como intercambiables cambiará con gusto opuestos; revisa los vecinos más cercanos de las palabras de las que depende tu producto. - Los tokens raros y nuevos reciben vectores pobres, o ninguno. Este capítulo conservó 2,000 tokens. Un token fuera de esa lista no tiene vector, y uno que apareció unas pocas veces tiene un vector ruidoso. El tokenizador del almacén tiene más del doble de esa cantidad de tokens, y una palabra rara que el tokenizador divide en fragmentos recibe un vector solo a partir de aquellos fragmentos que están entre los 2,000; un modelo que aprende sus propios embeddings, como lo hacen todos los capítulos posteriores, cubre todo el vocabulario.
- Los vectores reflejan el texto del que provienen. El texto del almacén describe
lightcomo una lámpara, así que su vector queda junto a la iluminación. Los embeddings entrenados en un dominio trasladan a otro sus sentidos y también sus sesgos. - Envía los vectores, no la receta. Entrenar embeddings por descenso de gradiente produce vectores ligeramente distintos en procesadores distintos, por eso este libro los registra. Guarda los vectores que envías junto con el código y la configuración que los produjeron.
- Los embeddings envejecen. En el catálogo aparecen nuevas líneas de producto y nuevas palabras; vuelve a entrenar o amplía los embeddings cuando el vocabulario cambie, y revisa las listas de vecinos de los tokens que importan después de cada reentrenamiento.
Lo que decidió este capítulo
- Los tokens se comparan por la similitud coseno de sus vectores. Ignora la longitud y compara la dirección, y es lo que devuelve
lib.vectors.nearest. Primero cada vector se escala a longitud unitaria, así que el coseno es un simple producto punto y los tokens frecuentes, cuyos vectores crudos son más largos, no ganan por tamaño. - Los embeddings basados en conteos provienen de PMI positivo comprimido con SVD, con una ventana de dos tokens y los 2,000 tokens más frecuentes, en
lib.vectors. Con el texto de la tienda, colocanpatiojunto aoutdoor, algo que los vectores one-hot no lograban. - Los embeddings aprendidos provienen de skip-gram con muestreo negativo, entrenado una sola vez en
recordings/skipgram.pycon el código del propio libro y una semilla fija, porque sus valores exactos dependen de la máquina. Coinciden con los basados en conteos en la mayoría de los tokens. - Vectores similares significan uso similar. Opuestos como
indooryoutdoorreciben vectores cercanos, y las analogías funcionan solo para relaciones que el texto expresa con frecuencia, así que el libro juzga los embeddings por cuánto ayudan a una tarea, nunca por las analogías. - Cada modelo posterior aprende sus propios embeddings, como parte de la predicción del siguiente token, empezando por el modelo de lenguaje neuronal del capítulo 5. Los vectores de este capítulo muestran que los embeddings transportan conocimiento de un contexto a otro, y los demás modelos del libro lo aprovechan.
Este capítulo, en esta edición
Edición 2026.11.16Ejemplos verificados el 19 de nov de 2026Superan la prueba 8 de 8 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.16.