Palavras como vetores
Cerca de 24 minutos min de leitura, com 8 exemplos em 10 seções.
Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros
Traduzido do livro em inglês, edição 2026.11.16. Leia o original
Nesta página
- Vetores one-hot não sabem nada
- Descreva um token pelos tokens ao seu redor
- Pondere a coocorrência pela surpresa
- Comprima as contagens em vetores densos
- Aprender vetores prevendo vizinhos
- Compare vetores aprendidos com vetores contados
- Analogias, e onde elas falham
- Encontre nomes semelhantes com vetores
- O que dá errado em produção
- O que este capítulo decidiu
Ao final deste capítulo, você será capaz de transformar cada token do texto da loja em um vetor curto de números, de modo que tokens usados de maneiras parecidas recebam vetores parecidos. Você vai fazer isso por dois métodos: compactar contagens de quais tokens aparecem juntos e treinar um pequeno modelo para prever os vizinhos de cada token. Você vai medir o que esses vetores sabem, onde falham e como eles permitem que um modelo relacione um texto que nunca viu a um texto que ele já conhece.
O capítulo 3 terminou com um limite que a contagem não consegue superar. Seu modelo de 4-gramas tinha visto patio bar stool muitas vezes e sugeria stool depois de patio bar. Depois de outdoor bar, que nenhum nome de treinamento contém, ele recorreu a sugestões genéricas, porque a contagem de um contexto não diz nada sobre outro. Um cliente, ou qualquer leitor, sabe que outdoor e patio significam quase a mesma coisa para a loja, e um modelo precisa de alguma forma de saber disso também. Este capítulo atribui a cada token um vetor, isto é, uma lista de números, e organiza os vetores de modo que tokens usados de forma parecida fiquem próximos.
Vetores precisam de texto que mostre como as palavras são usadas, e a loja, um vendedor on-line de móveis e artigos para casa, tem bastante desse texto nos nomes e nas descrições de seu catálogo. Sua divisão de treinamento, os 80% dos produtos a partir dos quais os modelos aprendem, contém 2,744,320 tokens desse texto, e todo vetor deste capítulo vem somente dele, por meio do tokenizador da loja apresentado no capítulo 2.
Vetores one-hot não sabem nada
Todos os modelos até aqui trataram os tokens como nomes: patio é uma entrada em uma tabela, e outdoor é outra, sem nada que as ligue. Escritos como vetores, isso é uma codificação one-hot, em que cada token recebe um vetor tão longo quanto o vocabulário, com um 1 na sua própria posição e 0 em todas as outras. Para medir o quanto dois vetores se parecem, este livro usa a similaridade do cosseno: o cosseno do ângulo entre eles, 1 quando apontam na mesma direção e 0 quando formam ângulo reto. Ela ignora o comprimento dos vetores e compara apenas as suas direções.
Dê vetores one-hot aos 2,000 tokens mais frequentes do texto de treinamento e compare patio com outdoor, com sofa e com ele mesmo. Esses 2,000 correspondem a cerca de metade do vocabulário do tokenizador da loja, o que mantém todas as matrizes deste capítulo pequenas o suficiente para serem calculadas em 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%
Uma codificação one-hot afirma que as duas palavras de ambiente externo são tão sem relação entre si quanto um pátio e um sofá. A similaridade do cosseno entre patio e outdoor é 0.0, e a de patio e sofa também. Só um token comparado consigo mesmo resulta em 1.0. Cada vetor tem 2000 números. Os 2,000 tokens que recebem vetores somam 91% do texto de treinamento; os demais são mais raros, e este capítulo os deixa de fora. Todo par de tokens diferentes forma ângulo reto, um com o outro, de modo que nada aprendido sobre um pode ser transferido para outro.
Esse é o mesmo defeito das contagens do capítulo 3, de outra forma. Um modelo que lê vetores one-hot precisa aprender sobre cada token separadamente, a partir dos contextos em que o próprio token aparece. Os tokens raros recebem pouco, e as combinações nunca vistas não recebem nada.
Regra prática: não alimente um modelo que precisa relacionar tokens entre si com vetores one-hot. Use-os apenas como índice, como as próximas seções fazem, para buscar um vetor aprendido para cada token.
Descreva um token pelos tokens ao seu redor
A saída é descrever uma palavra pelas companhias que ela tem. Duas palavras que aparecem entre os mesmos vizinhos, como patio e outdoor, que surgem ambas perto de furniture, chair e umbrella, tendem a significar coisas parecidas, mesmo que raramente apareçam juntas. Por isso, descreva cada token pelos seus vizinhos: conte, para cada par de tokens, com que frequência um aparece dentro de uma pequena janela do outro, aqui dois tokens para cada lado, e nunca atravessando a fronteira entre os textos de dois produtos. A linha de contagens de cada token é, então, um vetor daquilo perto do que ele aparece.
Conte as coocorrências nos nomes e descrições do conjunto de treinamento e liste o que mais aparece perto 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
Dos 8,790 tokens a no máximo duas posições de patio, contando um token novamente cada vez que ele aparece ali, os mais frequentes são decepcionantes: uma vírgula, or, with, your e um ponto final, antes da primeira palavra relacionada a pátios, furniture. Esses tokens aparecem perto de quase tudo, porque estão em toda parte. Uma linha de contagens brutas diz principalmente quão comum é cada vizinho, e não o que há de especial no token a que a linha pertence.
Portanto, contagens brutas fazem vetores ruins. Dois tokens que aparecem com frequência parecerão semelhantes porque compartilham os mesmos vizinhos frequentes, vírgulas e with, independentemente do que significam. O que importa é quais vizinhos um token tem com mais frequência do que se esperaria pela frequência desses vizinhos.
Regra prática: conte a coocorrência dentro de uma janela pequena, de dois a cinco tokens, no texto com que o modelo vai aprender, e nunca atravessando limites de documento. Não use as contagens brutas como vetores: pondere-as novamente, como faz a próxima seção, para que os vizinhos frequentes deixem de dominar.
Pondere a coocorrência pela surpresa
A correção compara cada contagem com o que o acaso preveria. Se patio e furniture aparecessem independentemente um do outro, eles coocorreriam aproximadamente com a frequência que suas frequências separadas implicam. A informação mútua pontual, ou PMI, mede o quanto a contagem real se afasta do acaso: o logaritmo da razão entre a frequência com que dois tokens coocorrem e a frequência com que coocorreriam por acaso (Church e Hanks, 1990). Em símbolos, para os tokens a e b:
PMI(a, b) = log [ P(a, b) / (P(a) · P(b)) ]
onde P(a, b) é a proporção de todas as contagens de coocorrência que são de a e b juntos, e P(a) e P(b) são a proporção de cada token. A PMI é positiva quando dois tokens aparecem juntos mais do que o acaso prevê, e negativa quando menos. Valores negativos não são confiáveis, pois "menos do que o acaso" geralmente significa "raramente visto", por isso a PMI positiva, ou PPMI, substitui cada valor negativo por zero. O módulo compartilhado do livro, lib.vectors, calcula-a a partir das contagens de coocorrência da seção anterior, em três linhas: a contagem que o acaso preveria para cada par, o logaritmo da contagem real sobre ela e zero onde isso for negativo ou o par nunca ocorrer:
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)
A reponderação serve para impedir que vizinhos frequentes dominem, então troque as contagens brutas pela PPMI e liste novamente os vizinhos mais fortes 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
As vírgulas sumiram. Os vizinhos mais fortes de patio pela PPMI são porch, deck, backyard, sectional, furniture e garden: palavras que uma pessoa associaria a um pátio, ordenadas pelo quanto mais do que o acaso aparecem perto dele. A maioria dos pares de tokens não coocorre mais do que o acaso prevê, e é por isso que 86% da matriz PPMI é zero.
Os vetores PPMI já são úteis: dois tokens com linhas PPMI semelhantes têm vizinhos distintivos semelhantes. Mas cada vetor ainda tem 2,000 números de comprimento, em sua maioria zeros, e dois tokens com vizinhos relacionados, mas não idênticos, digamos deck e porch, podem compartilhar poucas entradas não nulas.
Regra prática: Repondere as contagens de coocorrência com a PMI positiva antes de usá-las como vetores. Espere que a PMI superestime pares de tokens raros, cujas poucas coocorrências parecem muito acima do acaso; essa é uma razão para manter apenas tokens frequentes, como este capítulo faz, ou para exigir uma contagem mínima.
Comprima as contagens em vetores densos
Um vetor PPMI de 2,000 números, na maioria zeros, tem muito espaço e pouca informação. Comprimi-lo em um vetor curto e denso preserva os padrões mais fortes de coocorrência, descarta o ruído e aproxima tokens com vizinhos relacionados, mesmo quando eles compartilham poucos vizinhos exatos. A ferramenta é a decomposição em valores singulares, SVD, que encontra as 64 direções que, juntas, reconstroem melhor as linhas PPMI, e pondera cada uma pelo quanto ela explica dessas linhas. As 64 coordenadas ponderadas de um token ao longo dessas direções formam seu novo vetor: um embedding, um vetor denso que representa um token. O método lib.vectors.svd_vectors as calcula, normaliza cada uma para comprimento unitário, e lib.vectors.nearest encontra os tokens com a maior similaridade de cosseno com qualquer vetor.
Os quatro vizinhos mais próximos de seis tokens mostram o que os 64 números preservam:
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 agora tem 64 números, e seus vizinhos parecem um tesauro feito para uma loja de móveis. patio e outdoor são o vizinho mais próximo um do outro, com similaridade de cosseno de 0.84, onde seus vetores one-hot davam zero. sofa fica junto de sectional, chaise e loveseat; oak junto de walnut e espresso, um acabamento de madeira; blue junto de outras cores; e 48 junto de outros tamanhos em polegadas.
Nada disso foi ensinado. O método nunca viu uma definição de sofa, uma lista de cores ou uma pista de que 48 é um número. Ele percebeu que esses tokens aparecem entre os mesmos tipos de vizinhos no texto da loja, e a SVD os aproximou por causa disso. Essa é a propriedade que as contagens do capítulo 3 não tinham: o que um modelo aprende sobre patio bar stool agora pode ser transferido, por meio dos embeddings, para outdoor bar stool.
Regra prática: Comprima o PPMI com SVD para algo entre 50 e 300 dimensões, e verifique o resultado como esta seção faz: liste os vizinhos mais próximos de alguns tokens e leia-os. Se os vizinhos forem em sua maioria palavras funcionais frequentes, a reponderação saiu errada; se forem não relacionados, a janela ou o vocabulário são pequenos demais.
Aprender vetores prevendo vizinhos
A outra forma de obter embeddings é aprendê-los por predição, que é como cada modelo neural de linguagem deste livro obtém os seus. Skip-gram com amostragem negativa, o método por trás do word2vec, dá a cada token dois vetores, um para quando ele é o token central e outro para quando ele é um vizinho, e os treina em uma única tarefa: dado um token, distinguir os seus vizinhos reais de tokens aleatórios (Mikolov et al., 2013a; Mikolov et al., 2013b). Para um token e um de seus vizinhos reais, o modelo pontua o par pelo produto escalar dos seus vetores, transforma a pontuação em probabilidade com a função logística e ajusta os vetores para que a probabilidade suba. Para alguns tokens de ruído aleatórios, extraídos do vocabulário, o modelo ajusta a probabilidade para baixo. Repetido sobre milhões de pares, tokens com os mesmos vizinhos acabam com vetores semelhantes. Isso não é coincidência: Levy e Goldberg mostraram que o skip-gram com amostragem negativa, treinado dessa forma, na prática fatoriza uma matriz PMI, deslocada para baixo pelo logaritmo do número de tokens de ruído, de modo semelhante a como a SVD fatoriza a PPMI (Levy and Goldberg, 2014).
Denote por v o vetor do token central, por u o do vizinho real, por uₙ o de cada token de ruído, e por σ a função logística, σ(s) = 1 / (1 + e⁻ˢ), que transforma uma pontuação em probabilidade. A perda skip-gram para um par é a surpresa diante do vizinho real somada à surpresa de cada token de ruído não ser um vizinho:
L = −log σ(v·u) − Σₙ log σ(−v·uₙ)
e lib.skipgram.step a reduz com três linhas de descida do gradiente, em que real é σ(v·u), fake guarda σ(v·uₙ) para cada token de ruído, e rate é o tamanho do passo:
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
Execute três atualizações sobre um par real, patio e umbrella, com sofa e 48 como tokens de ruído. Os vetores centrais começam pequenos e aleatórios, e os vetores de vizinhança em zero, como lib.skipgram.train os inicia:
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
O treinamento aproxima vizinhos reais e afasta tokens aleatórios, e três atualizações mostram isso em miniatura. Antes de qualquer atualização, os vetores de vizinhança são zero, então toda pontuação é zero, e σ(0) é um meio: o modelo não sabe nada. Depois de três, umbrella pontua 0.525 como vizinho de patio, subindo de 0.500, e sofa e 48 caíram para 0.475, 0.475. É tudo o que o treinamento faz, milhões de vezes.
Regra prática: Ao treinar embeddings, inicie o segundo conjunto de vetores em zero e o primeiro com valores aleatórios pequenos, como lib.skipgram.train faz, e sorteie os tokens de ruído proporcionalmente à sua frequência elevada à potência 0.75, que Mikolov et al. constataram funcionar melhor do que a frequência pura. Verifique uma atualização à mão antes de executar milhões: uma probabilidade que se move na direção errada significa que o sinal do gradiente está errado.
Compare vetores aprendidos com vetores contados
Treinar skip-gram sobre todo o texto de treinamento da loja executa milhões de atualizações, e seu resultado exato depende da aritmética de ponto flutuante da máquina, que varia um pouco entre processadores. Por isso ele é executado uma única vez, em recordings/skipgram.py, com o código do próprio livro e uma semente fixa, e os exemplos leem seus vetores salvos. O manifesto registra as configurações: uma janela de dois tokens, 64 dimensões, cinco tokens de ruído por par e duas passagens pelo texto. Uma configuração é fixada em lib.skipgram em vez de registrada: pares centrados em tokens muito frequentes, como vírgulas, são em sua maioria descartados, com um limiar de 10⁻⁴, o que impede que dominem o treinamento (Mikolov et al., 2013b, que sugerem cerca de 10⁻⁵ para textos maiores).
Peça aos vetores skip-gram salvos os vizinhos dos mesmos seis tokens e compare-os com os da 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
O modelo aprendeu a distinguir vizinhos reais de ruído: sua perda de treinamento caiu de 4.16 no primeiro lote para 2.05 nos últimos cem. Seus vizinhos concordam com os da SVD na maioria dos tokens, sofa com sectional e chaise, oak com walnut e espresso, cores com cores, tamanhos com tamanhos, e diferem em ênfase em outros: skip-gram coloca outdoor mais próximo de indoor, porque as duas palavras aparecem nas mesmas posições em descrições como indoor or outdoor use.
Essa diferença merece atenção. Vetores construídos a partir de vizinhança reúnem palavras usadas nos mesmos lugares, e muitas vezes os opostos também são usados nos mesmos lugares: indoor e outdoor aqui, e, na próxima seção, small, cujos vizinhos mais próximos incluem larger além de smaller. Vetores semelhantes significam uso semelhante, não significado semelhante.
Regra prática: Trate os embeddings contados (PPMI e SVD) e os aprendidos (skip-gram) como alternativas próximas: com alguns milhões de tokens eles dão vizinhos parecidos, e os contados são determinísticos e rápidos. Prefira embeddings aprendidos quando eles fizerem parte de um modelo maior que você treinará de qualquer forma, como em todos os capítulos seguintes deste livro. Nunca leia uma similaridade alta como sinonímia sem verificar se há opostos.
Analogias, e onde elas falham
Os embeddings são conhecidos por sustentar analogias por meio de aritmética: se a diferença entre chair e chairs é uma direção que significa "plural", então somá-la a table deveria cair perto de tables. Nos vetores, a resposta para "a está para b assim como c está para quê?" é o token mais próximo de b − a + c, deixando de fora os três tokens da pergunta (Mikolov et al., 2013a). É um teste elegante para verificar se os vetores aprenderam relações consistentes, e um bom lugar para ver os seus limites.
Três analogias sobre os vetores skip-gram mostram onde a aritmética se sustenta e onde ela se rompe, e os vizinhos mais próximos de três tokens que elas levantam mostram o porquê:
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>
Só a primeira analogia obtém a resposta que você esperaria: chair está para chairs assim como table está para tables, a resposta principal. A segunda falha porque lamps não está entre os 2,000 tokens que têm vetores, de modo que a resposta correta não pode ser encontrada, e a aritmética devolve o que estiver mais próximo. A terceira falha de outro modo. light está no vocabulário, mas black está para white assim como dark está para brown, segundo os vetores. As listas de vizinhos mostram o porquê: light aparece junto de lights, bulb, dimmable e candle, porque no texto da loja ele é, na maioria das vezes, um abajur, como em ceiling light, e não uma cúpula, enquanto dark aparece junto de brown, walnut e espresso, os acabamentos que ele descreve. E small aparece junto de larger assim como de smaller: palavras de tamanho aparecem nos mesmos lugares, qualquer que seja o tamanho que nomeiam.
Analogias são uma demonstração, não uma medida. Elas funcionam para relações que o texto expressa de forma consistente e frequente, como os plurais de palavras comuns, e falham para palavras raras, para palavras com vários sentidos e para relações que o texto raramente explicita. Um modelo não usa analogias; ele usa as posições dos vetores, e essas posições carregam os mesmos pontos fortes e pontos cegos.
Regra prática: Não julgue embeddings por analogias; julgue-os pelo quanto ajudam a tarefa para a qual foram feitos, como fazem a próxima seção e todos os capítulos seguintes. Quando uma analogia falhar, verifique se a resposta está no vocabulário e se as palavras significam o que você supõe no seu texto.
Encontre nomes semelhantes com vetores
Embeddings para tokens dão, com mais um passo, embeddings para textos inteiros: calcule a média dos vetores dos tokens de um texto, normalize o resultado para comprimento unitário, e textos parecidos recebem vetores parecidos. Essa é uma versão simplificada do que os mecanismos de busca chamam de recuperação semântica, isto é, encontrar textos pelo significado em vez de pela correspondência de palavras. O livro complementar deste, Introdução à Relevância de Buscas, a desenvolve de forma adequada, com um modelo treinado. Aqui ela testa a única coisa que este capítulo se propôs a corrigir: o modelo de contagem do capítulo 3 não consegue relacionar outdoor bar a patio bar.
Calcular a média dos vetores skip-gram de todos os nomes de treinamento transforma cada nome em um único vetor. Palavras raras, na maioria das vezes o nome de uma linha de produtos, aparecem como [name], como o capítulo 1 explicou. Duas consultas mostram o que isso proporciona: outdoor bar, o prefixo que confundiu o modelo de 4-gramas do capítulo 3, e 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
Os vetores médios colocam dois nomes com patio bar stool entre os mais próximos de outdoor bar, e nenhum deles contém a palavra outdoor. Aquele modelo não conseguia fazer essa ligação, porque tinha contagens para patio bar stool e nenhuma para outdoor bar. A ligação passa por outdoor e patio, cujos vetores são próximos. Para patio umbrella, os nomes mais próximos são produtos de pátio e de área externa, e o primeiro é uma capa de guarda-sol, mas nenhum deles é um guarda-sol em si: a média faz com que patio pese mais que umbrella.
A média é grosseira: ela ignora a ordem das palavras, então bar stool e stool bar recebem o mesmo vetor, e deixa tokens frequentes abafarem o que importa. Mas mostra a propriedade sobre a qual todos os modelos posteriores deste livro se apoiam: um modelo que lê embeddings em vez de tokens one-hot consegue levar o que aprendeu sobre uma frase para outra.
Regra prática: Calcule a média dos embeddings dos tokens quando precisar de uma representação rápida e independente da ordem para textos curtos, e espere que ela encontre itens relacionados, mas os ordene de forma imprecisa. Para recuperação semântica real, use um modelo treinado para isso, como faz o Primer. Para modelagem de linguagem, forneça ao modelo os próprios embeddings e deixe-o aprender como combiná-los, o que o capítulo 5 começa a fazer.
O que dá errado em produção
Embeddings carregam os hábitos do texto de treinamento para tudo o que os utiliza:
- Uso semelhante não significa significado semelhante.
indooreoutdoorficam próximos um do outro. Um sistema que trata vetores próximos como intercambiáveis vai trocar opostos sem hesitar; verifique os vizinhos mais próximos das palavras das quais o seu produto depende. - Tokens raros e novos recebem vetores ruins, ou nenhum. Este capítulo manteve 2,000 tokens. Um token fora dessa lista não tem vetor, e um token visto apenas algumas vezes tem um vetor ruidoso. O tokenizador da loja tem mais que o dobro desse número de tokens, e uma palavra rara que o tokenizador divide em pedaços recebe um vetor apenas a partir daqueles de seus pedaços que estão entre os 2,000; um modelo que aprende os próprios embeddings, como os de todos os capítulos seguintes, cobre o vocabulário inteiro.
- Os vetores refletem o texto de onde vieram. O texto da loja descreve
lightcomo um abajur, então o seu vetor fica junto de iluminação. Embeddings treinados em um domínio carregam os seus sentidos, e os seus vieses, para outro. - Envie os vetores, não a receita. Treinar embeddings por descida de gradiente gera vetores ligeiramente diferentes em processadores diferentes, e é por isso que este livro registra os vetores. Armazene os vetores que você envia, junto com o código e as configurações que os produziram.
- Embeddings ficam desatualizados. Novas linhas de produtos e palavras surgem no catálogo; retreine ou estenda os embeddings quando o vocabulário mudar, e verifique as listas de vizinhos dos tokens importantes após cada retreinamento.
O que este capítulo decidiu
- Tokens são comparados pela similaridade de cosseno de seus vetores. Ela ignora o comprimento e compara a direção, e é isso que
lib.vectors.nearestretorna. Antes disso, cada vetor é normalizado para comprimento unitário, de modo que o cosseno é simplesmente um produto escalar, e tokens frequentes, cujos vetores brutos são mais longos, não vencem por tamanho. - Embeddings por contagem vêm de PMI positiva comprimida com SVD, em uma janela de dois tokens e sobre os 2,000 tokens mais frequentes, em
lib.vectors. No texto da loja, eles colocampatioperto deoutdoor, algo que os vetores one-hot não conseguiam. - Embeddings aprendidos vêm de skip-gram com amostragem negativa, treinados uma única vez em
recordings/skipgram.pycom o código do próprio livro e uma semente fixa, porque seus valores exatos dependem da máquina. Eles concordam com os obtidos por contagem na maioria dos tokens. - Vetores semelhantes indicam uso semelhante. Opostos como
indooreoutdoorrecebem vetores próximos, e analogias funcionam apenas para relações que o texto expressa com frequência; por isso, o livro avalia embeddings pelo quanto ajudam uma tarefa, nunca por analogias. - Todo modelo posterior aprende seus próprios embeddings, como parte da previsão do próximo token, a partir do modelo de linguagem neural do capítulo 5. Os vetores deste capítulo mostram que embeddings carregam conhecimento de um contexto para outro, e os demais modelos do livro colocam isso em prática.
Este capítulo, nesta edição
Edição 2026.11.16Exemplos aprovados em 19 de nov de 20268 de 8 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.16.