Dentro de um modelo aberto
Cerca de 25 minutos min de leitura, com 7 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
- Contar os parâmetros em escala
- Compare os tamanhos de uma família
- Conte o que custa executar
- Pontue o texto da loja com um modelo geral
- Encontre as mesmas cabeças em escala
- Testar a cópia em escala
- Sugerir a próxima palavra em escala
- Coloque os dois modelos lado a lado
- O que dá errado em produção
- O que este capítulo decidiu
Ao final deste capítulo, você saberá ler um modelo de linguagem aberto com o que este livro construiu: contar para onde vão os seus parâmetros, calcular quanto custa executá-lo, pontuar um texto com ele de forma justa em comparação com um modelo de outro tokenizador, encontrar nas cabeças de atenção os padrões de atenção do capítulo 6, testar o que ele copia e descobrir o que o seu tamanho traz para o texto da loja, e o que não traz.
O capítulo 9 terminou com descrições do próprio modelo da loja que precisam ser verificadas antes que alguém as leia. Esse modelo é o pequeno transformer que os capítulos 6 a 9 construíram, treinaram e usaram em um único catálogo de móveis e artigos para casa. O SmolLM2-360M, um modelo aberto lançado pela Hugging Face sob a licença Apache 2.0, é construído com as mesmas partes, como mostrou o capítulo 7. Ele tem mais de duzentas vezes mais parâmetros e foi treinado com 4 trilhões de tokens (cartão do modelo) de texto da web, código, matemática e livros didáticos sintéticos (Allal et al., 2025, seção 6). A pergunta que este capítulo faz é se um modelo gratuito e disponível para download, treinado com muito mais texto, poderia fazer o trabalho do modelo próprio da loja: sugerir a próxima palavra na caixa de busca e prever descrições. O capítulo 2 leu o tokenizador do SmolLM2; este capítulo lê o modelo.
Executar o SmolLM2 exige PyTorch e um download de cerca de 0.7 gigabytes, com os pesos armazenados como números de 16 bits; por isso ele foi executado uma única vez, como os demais resultados gravados do livro. O script recordings/open_model.py carregou o modelo base, aquele treinado apenas para prever o próximo token, como era o modelo da loja, em uma revisão fixada, isto é, uma versão fixa do seu repositório. Ele executou o modelo sobre o texto da loja e salvou o que este capítulo lê: o formato de cada peso, suas pontuações nos nomes e descrições de validação da loja, os padrões de atenção de suas cabeças, o teste de cópia do capítulo 6 e os prefixos da caixa de busca do capítulo 8. Um segundo script, recordings/open_model_family.py, baixou apenas os arquivos de configuração dos três tamanhos do SmolLM2, também em revisões fixadas. Os exemplos leem as duas gravações, em examples/data/recorded/, por meio de lib.open_model.
Contar os parâmetros em escala
As partes são conhecidas, então a primeira pergunta é onde estão os parâmetros. O Capítulo 7 contou o modelo da loja por parte: 1,334,144 parâmetros, dos quais 40% estão na tabela de embeddings que ele compartilha com sua saída.
Faça a mesma contagem com os pesos registrados do SmolLM2 e observe qual parte passa a concentrar mais parâmetros:
1"""Counts SmolLM2-360M's recorded weights by part, with the embedding table shared with the output counted once.2The point that the feed-forward layers hold most of the parameters rests on the feed-forward line."""3import math45from lib import open_model67shapes = {name: shape for name, shape in open_model.read("parameters").items()8 if name != "lm_head.weight"} # the output layer is tied to the embeddings: the same weights, counted once9# A part is matched by name: a weight counts toward the part whose key appears in the weight's name.10parts = {"embedding (shared with the output)": ["embed_tokens"], "attention": ["q_proj", "k_proj", "v_proj", "o_proj"],11 "feed-forward": ["gate_proj", "up_proj", "down_proj"], "normalization": ["layernorm", "model.norm"]}12total = sum(math.prod(shape) for shape in shapes.values())13for part, keys in parts.items():14 count = sum(math.prod(shape) for name, shape in shapes.items() if any(key in name for key in keys))15 print(f"{part}:", f"{count:,}", f"({count / total:.0%})")16print("total:", f"{total:,}")17config = open_model.read("manifest")["config"] # the configuration recorded with the weights18print("layers:", config["num_hidden_layers"])19print("width:", config["hidden_size"])20print("query heads:", config["num_attention_heads"])21print("key and value heads:", config["num_key_value_heads"])22print("feed-forward width:", config["intermediate_size"])23print("vocabulary:", f"{config['vocab_size']:,}")24# Layer 0 stands for every layer: each layer's weights have the same shapes.25print("one layer's query weights:", shapes["model.layers.0.self_attn.q_proj.weight"])26print("one layer's key weights:", shapes["model.layers.0.self_attn.k_proj.weight"])
python open-model-parameters.pyembedding (shared with the output): 47,185,920 (13%)
attention: 78,643,200 (22%)
feed-forward: 235,929,600 (65%)
normalization: 62,400 (0%)
total: 361,821,120
layers: 32
width: 960
query heads: 15
key and value heads: 5
feed-forward width: 2560
vocabulary: 49,152
one layer's query weights: [960, 960]
one layer's key weights: [320, 960]
O equilíbrio mudou em relação ao modelo da loja. As camadas feed-forward concentram 235,929,600 (65%) dos 361,821,120 parâmetros do SmolLM2. A tabela de embeddings, ainda compartilhada com a saída, concentra 47,185,920 (13%), a atenção 78,643,200 (22%), e os ganhos da normalização quase nada. Os blocos crescem com o número de camadas vezes o quadrado da largura, enquanto a tabela de embeddings, para um vocabulário fixo, cresce apenas com a largura; por isso, à medida que um modelo cresce, os blocos passam a dominar.
A atenção tem menos parâmetros do que teriam 15 cabeças completas, por causa da atenção com consultas agrupadas, que compartilha cada cabeça de chave e valor entre várias cabeças de consulta. Cada camada tem 15 cabeças de consulta, mas apenas 5 cabeças de chaves e valores, cada uma compartilhada por 3 cabeças de consulta (Ainslie et al., 2023). Os pesos mostram isso. Os pesos de consulta de uma camada têm a forma [960, 960], e os de chave [320, 960], um terço da quantidade de números. Por camada, sendo o tamanho da cabeça a largura dividida pelo número de cabeças de consulta:
parâmetros de atenção = 2 × largura² + 2 × largura × cabeças de chave e valor × tamanho da cabeça
para os pesos de consulta e de saída, depois os pesos de chave e valor. Durante a geração, um modelo guarda as chaves e os valores de cada camada para cada token anterior; compartilhá-los reduz esse armazenamento, como mede uma seção posterior. Ainslie e colegas constataram que essa escolha custa pouco em qualidade.
Regra prática: Conte os parâmetros de um modelo aberto por parte, a partir de seus pesos, antes de usá-lo, e leia as formas dos pesos para identificar suas escolhas de projeto: embeddings atrelados, chaves e valores agrupados, uma camada feed-forward com portão. Espere que os blocos, e não os embeddings, concentrem a maior parte dos parâmetros de um modelo grande.
Compare os tamanhos de uma família
O SmolLM2 vem em três tamanhos, cada um construído com as mesmas partes, e suas configurações mostram como os criadores de um modelo gastam mais parâmetros. Cada arquivo de configuração informa as camadas, a largura, as cabeças e a largura da camada feed-forward, e isso basta para contar cada parâmetro, parte por parte, com a aritmética do capítulo 7 e a fórmula acima. lib.open_model.parameters faz isso.
Conte os três tamanhos a partir de suas configurações registradas, e confira a contagem do modelo de 360M com os pesos que a primeira gravação salvou:
1"""Counts all three SmolLM2 sizes from their recorded configurations, part by part, and checks the 360M model's count2against its recorded weights. The claim that the counts match the weights rests on the 360M parameters line and the last line."""3import math45from lib import open_model67for name in open_model.SIZES:8 config = open_model.config(name)9 parts = open_model.parameters(config) # the count by part, from the configuration alone, grouped keys and values included10 print(f"{name}, layers:", config["num_hidden_layers"])11 print(f"{name}, width:", f"{config['hidden_size']:,}")12 print(f"{name}, query heads:", config["num_attention_heads"])13 print(f"{name}, query heads per key and value head:", config["num_attention_heads"] // config["num_key_value_heads"]) # query heads sharing each key and value head14 print(f"{name}, feed-forward width:", f"{config['intermediate_size']:,}")15 print(f"{name}, RoPE base:", f"{config['rope_theta']:,}") # the rotary base: a larger base makes positions turn more slowly16 print(f"{name}, parameters:", f"{parts['total']:,}")17 print(f"{name}, embedding's share:", f"{parts['embedding'] / parts['total']:.0%}")18# The output layer is tied to the embeddings, so its weights are skipped: the shared weights are counted once.19recorded = sum(math.prod(shape) for key, shape in open_model.read("parameters").items() if key != "lm_head.weight")20print("SmolLM2-360M, parameters in the recorded weights:", f"{recorded:,}")
python open-model-family.pySmolLM2-135M, layers: 30
SmolLM2-135M, width: 576
SmolLM2-135M, query heads: 9
SmolLM2-135M, query heads per key and value head: 3
SmolLM2-135M, feed-forward width: 1,536
SmolLM2-135M, RoPE base: 100,000
SmolLM2-135M, parameters: 134,515,008
SmolLM2-135M, embedding's share: 21%
SmolLM2-360M, layers: 32
SmolLM2-360M, width: 960
SmolLM2-360M, query heads: 15
SmolLM2-360M, query heads per key and value head: 3
SmolLM2-360M, feed-forward width: 2,560
SmolLM2-360M, RoPE base: 100,000
SmolLM2-360M, parameters: 361,821,120
SmolLM2-360M, embedding's share: 13%
SmolLM2-1.7B, layers: 24
SmolLM2-1.7B, width: 2,048
SmolLM2-1.7B, query heads: 32
SmolLM2-1.7B, query heads per key and value head: 1
SmolLM2-1.7B, feed-forward width: 8,192
SmolLM2-1.7B, RoPE base: 130,000
SmolLM2-1.7B, parameters: 1,711,376,384
SmolLM2-1.7B, embedding's share: 6%
SmolLM2-360M, parameters in the recorded weights: 361,821,120
A contagem a partir da configuração do modelo de 360M coincide exatamente com seus pesos registrados: 361,821,120 contados contra 361,821,120 registrados. A largura, e não a profundidade, é onde foi parar a maior parte dos parâmetros extras do maior modelo. O SmolLM2-1.7B tem 24 camadas, menos que as 30 do modelo de 135M e as 32 do modelo de 360M, com uma largura de 2,048, bem maior que as 576 do modelo de 135M e as 960 do modelo de 360M.
A fatia da tabela de embeddings diminui à medida que os modelos crescem, de 21% para 13% e para 6%, porque os três compartilham um mesmo vocabulário enquanto seus blocos crescem. E o maior difere em mais do que o tamanho. Ele não agrupa chaves e valores, e tem 1 cabeça de consulta para cada cabeça de chave e valor, enquanto os dois menores compartilham cada uma entre 3 cabeças de consulta. Sua camada feed-forward tem largura de 8,192, quatro vezes a sua largura, enquanto a do modelo de 360M tem 2,560, ou 8/3 da sua largura. E suas posições rotacionais giram mais devagar, com uma base de 130,000, contra 100,000.
Regra prática: Conte os parâmetros de um modelo a partir de sua configuração e confira a contagem com os pesos; uma divergência significa que você leu mal algum detalhe. Compare os tamanhos de uma família para ver como seus criadores escalaram o projeto, e não presuma que um modelo maior difere de um menor apenas no tamanho.
Conte o que custa executar
Os parâmetros definem o que um modelo pode aprender; eles também definem o que custa executá-lo. Seus pesos precisam ficar na memória, com dois bytes por peso nos formatos de 16 bits, a forma em que os pesos do SmolLM2 são armazenados (cartão do modelo). E durante a geração, como o capítulo 9 observou, cada camada guarda uma chave e um valor para cada token anterior, de modo que cada novo token não refaz o trabalho do texto que veio antes. O cache de chaves e valores, as chaves e os valores de cada camada para os tokens anteriores, cresce com o comprimento do texto:
cache por token, em bytes = camadas × 2 × cabeças de chave e valor × tamanho da cabeça × 2
contando uma chave e um valor por camada, e dois bytes por número.
Para planejar os recursos, é preciso, para cada tamanho, os pesos, o cache por token e o cache para o texto mais longo para o qual os modelos estão configurados, 8,192 tokens, com e sem chaves e valores agrupados:
1"""Works out each size's weights and key and value cache, with and without grouped keys and values, in decimal gigabytes2and kilobytes. The point that grouping cuts the 360M model's cache to a third rests on its two cache lines for the longest text."""3from lib import open_model45longest = open_model.config("SmolLM2-360M")["max_position_embeddings"] # the longest text the models are set up for6print("longest text, in tokens:", f"{longest:,}")7for name in open_model.SIZES:8 config = open_model.config(name)9 head_size = config["hidden_size"] // config["num_attention_heads"] # the width shared out over the query heads, grouped or not10 weights = open_model.parameters(config)["total"] * 2 # 16-bit numbers: 2 bytes each11 cache = config["num_hidden_layers"] * 2 * config["num_key_value_heads"] * head_size * 2 # a key and a value per layer, 2 bytes each12 # The same cache with every query head keeping its own key and value.13 ungrouped = config["num_hidden_layers"] * 2 * config["num_attention_heads"] * head_size * 214 # Decimal units: a gigabyte is 1e9 bytes and a kilobyte 1e3 bytes.15 print(f"{name}, weights in 16-bit numbers, in GB:", f"{weights / 1e9:.1f}")16 print(f"{name}, key and value cache per token, in KB:", f"{cache / 1e3:.0f}")17 print(f"{name}, cache for the longest text, in GB:", f"{cache * longest / 1e9:.2f}")18 print(f"{name}, cache for the longest text without grouping, in GB:", f"{ungrouped * longest / 1e9:.2f}")
python open-model-memory.pylongest text, in tokens: 8,192
SmolLM2-135M, weights in 16-bit numbers, in GB: 0.3
SmolLM2-135M, key and value cache per token, in KB: 23
SmolLM2-135M, cache for the longest text, in GB: 0.19
SmolLM2-135M, cache for the longest text without grouping, in GB: 0.57
SmolLM2-360M, weights in 16-bit numbers, in GB: 0.7
SmolLM2-360M, key and value cache per token, in KB: 41
SmolLM2-360M, cache for the longest text, in GB: 0.34
SmolLM2-360M, cache for the longest text without grouping, in GB: 1.01
SmolLM2-1.7B, weights in 16-bit numbers, in GB: 3.4
SmolLM2-1.7B, key and value cache per token, in KB: 197
SmolLM2-1.7B, cache for the longest text, in GB: 1.61
SmolLM2-1.7B, cache for the longest text without grouping, in GB: 1.61
Agrupar chaves e valores mantém pequeno o cache do modelo de 360M. Ele usa 41 kilobytes por token, de modo que um texto do comprimento máximo precisa de 0.34 gigabytes, um terço dos 1.01 que exigiria sem o agrupamento.
Um serviço que escreve muitas descrições ao mesmo tempo mantém um cache por texto, de modo que, com textos longos, os caches podem superar os pesos. O modelo de 1.7B, que não agrupa chaves e valores, precisa de 197 kilobytes por token, e 1.61 gigabytes para um texto longo, cerca de metade de seus 3.4 gigabytes de pesos.
Regra prática: Planeje a memória de um modelo como seus pesos mais um cache por texto em andamento, calculado a partir da sua configuração. Prefira modelos que agrupam chaves e valores quando você servir textos longos ou muitos textos ao mesmo tempo, e limite o comprimento do texto permitido àquilo que você planejou.
Pontue o texto da loja com um modelo geral
Um modelo com duzentas vezes os parâmetros, treinado em mais de um milhão de vezes o número de tokens que o catálogo da loja contém, seria de esperar que previsse o texto da loja melhor do que o modelo pequeno da própria loja. Testar isso exige cuidado, porque os dois modelos usam tokenizadores diferentes: o vocabulário de 49,152 tokens do SmolLM2 divide o texto de maneira diferente do tokenizador da loja, então suas perplexidades por token contam coisas diferentes. O que eles compartilham é o texto. Uma perplexidade por palavra divide a log-probabilidade total que um modelo atribui a um texto pelo número de palavras nele, em vez de pelo número de tokens. Em símbolos, para um texto de W palavras cujos tokens recebem do modelo as probabilidades p₁ a pₙ, qualquer que seja o número de tokens:
perplexidade por palavra = exp(−(log p₁ + … + log pₙ) / W)
Dividir o total de cada modelo pelo mesmo número de palavras coloca ambos na mesma escala, não importa quantos tokens cada um gastou.
Cada modelo pontua os mesmos eventos. Para um nome, o modelo da loja começa a partir de <s> e o SmolLM2 a partir de seu próprio token inicial, <|endoftext|>, e ambos preveem as palavras do nome e depois o seu fim: <sep> para o modelo da loja, uma quebra de linha para o SmolLM2. Para uma descrição, ambos recebem o nome e preveem as palavras da descrição e o seu fim. Os nomes são os primeiros 500 nomes de validação, e as descrições são os 446 produtos do capítulo 8. A gravação também pontuou cada nome depois de um rótulo, Product name: , para testar se dizer ao SmolLM2 o que ele está lendo ajuda.
Qual modelo pontua melhor os nomes da loja por palavra, e por quanto? Decida antes de continuar a leitura. Depois calcule as pontuações do modelo da loja em NumPy, leia as do SmolLM2 a partir da gravação e compare-as por token e por palavra:
1"""Scores the store's model and SmolLM2-360M on the same names and the same descriptions, per word, the unit the two share.2The point that the small model wins on both kinds of text rests on the per-word lines for names and for descriptions."""3import math45from lib import bpe, open_model, transformer6from lib.products import product_texts7from lib.store import load_products89_, vocabulary, _ = transformer.load() # load() returns the weights, the vocabulary and the manifest; only the vocabulary is used10index = {token: i for i, token in enumerate(vocabulary)}11scores, tokenizer = open_model.read("scores"), bpe.store_tokenizer()12per = lambda log_p, count: f"{math.exp(-log_p / count):,.1f}" # perplexity: e to the average negative log-probability per count1314# Names: each name's tokens and its end (<sep> for the store's model, a newline for SmolLM2), from the start token.15names = list(load_products("validation")["name"])[:len(scores["names"])] # as many names as SmolLM2 was scored on, from the top of the split16# The start marker, the name's tokens and <sep>: the model scores everything after the start marker.17encoded = [[index[transformer.START]] + [index[t] for t in tokenizer.encode(name)] + [index[transformer.SEP]] for name in names]18store = sum(transformer.total_log_probability(ids, 1) for ids in encoded) # scores ids[1:], every token after <s>19smollm2 = sum(row["log_p"] for row in scores["names"])20# Words are whitespace-separated, as the recording counted them; both models are divided by the same count.21words = sum(row["words"] for row in scores["names"])22print("validation names scored:", len(names))23print("names, per-token perplexity, the store's model:", per(store, sum(len(ids) - 1 for ids in encoded))) # all but <s>24print("names, per-token perplexity, SmolLM2-360M:", per(smollm2, sum(row["tokens"] for row in scores["names"]))) # SmolLM2's own count25print("names, per-word perplexity, the store's model:", per(store, words))26print("names, per-word perplexity, SmolLM2-360M:", per(smollm2, words))27# The label is context for the recording and is not scored; the same words count.28print("names after a label, per-word perplexity, SmolLM2-360M:", per(sum(r["log_p"] for r in scores["labelled names"]), words))2930# Descriptions: chapter 8's products, each description's tokens and its end, given the name.31end = index[transformer.END] # the end marker closes a description32# The first 500 validation products. Keeps those whose text ends rather than being cut at the length limit, and that have33# at least one description token after <sep>. Scores from sep + 1: the description and its end, given everything up to <sep>.34store = sum(transformer.total_log_probability(ids, sep + 1) for ids, sep in product_texts("validation", 500)35 if ids[-1] == end and sep < len(ids) - 2)36words = sum(row["words"] for row in scores["descriptions"])37print("descriptions scored:", len(scores["descriptions"]))38print("descriptions, per-word perplexity, the store's model:", per(store, words))39print("descriptions, per-word perplexity, SmolLM2-360M:", per(sum(r["log_p"] for r in scores["descriptions"]), words))
python open-model-on-the-store.pyvalidation names scored: 500
names, per-token perplexity, the store's model: 25.8
names, per-token perplexity, SmolLM2-360M: 564.8
names, per-word perplexity, the store's model: 199.3
names, per-word perplexity, SmolLM2-360M: 54,352.8
names after a label, per-word perplexity, SmolLM2-360M: 67,101.5
descriptions scored: 446
descriptions, per-word perplexity, the store's model: 37.0
descriptions, per-word perplexity, SmolLM2-360M: 61.2
O modelo pequeno vence nos dois tipos de texto, por larga margem nos nomes. Por palavra, o modelo da loja pontua 199.3 nos nomes contra 54,352.8 do SmolLM2, e 37.0 nas descrições contra 61.2. Por token, nestes nomes, o modelo da loja pontua 25.8 e o SmolLM2 564.8. A pontuação por token esconde a diferença, porque o SmolLM2 gasta mais tokens em cada palavra da loja.
Dizer ao SmolLM2 que ele está lendo um nome de produto não fecha a diferença. Depois do rótulo, ele pontua 67,101.5 por palavra, não melhor do que sem ele. Então a diferença não está em o SmolLM2 não saber que um nome virá; está nos próprios nomes. Nossa avaliação, não testada aqui, é que duas características do texto da loja explicam grande parte dela: muitos nomes começam com um nome inventado de uma linha de produtos, que o modelo da loja viu em todo o seu catálogo, e o texto da loja está em minúsculas, com espaços em volta da pontuação, diferentemente da maior parte do que o SmolLM2 aprendeu.
A lição não é que modelos pequenos sejam melhores. Um modelo prevê melhor o tipo de texto com que aprendeu: o SmolLM2 conhece muito mais inglês do que o modelo da loja, e pouco dos hábitos da loja. Ensinar-lhe esses hábitos exige treinamento adicional com o texto da loja, que o capítulo 11 descreve.
Regra prática: Compare modelos com tokenizadores diferentes por palavra, ou por caractere, sobre exatamente o mesmo texto e os mesmos eventos, nunca por token. Antes de escolher um modelo geral grande em vez de um pequeno treinado com o seu próprio texto, meça os dois no seu texto; o tamanho não compensa um texto diferente de tudo o que o modelo aprendeu.
Encontre as mesmas cabeças em escala
O capítulo 6 mediu as cabeças do modelo da loja pelos seus hábitos, em comparação com uma distribuição uniforme, que põe 1 / (i + 1) do peso de uma posição em cada um dos i + 1 tokens que a posição i pode ver. As mesmas medidas funcionam em qualquer modelo, e o SmolLM2 tem 480 cabeças para medir.
Observe a média registrada do peso de cada cabeça sobre o token anterior e sobre o primeiro token, nos primeiros 50 dos 446 produtos pontuados acima, cada texto um nome, uma quebra de linha e a sua descrição. A distribuição uniforme é calculada da mesma forma, para que os dois possam ser comparados lado a lado:
1"""Reads SmolLM2's recorded head averages over the recorded texts, and compares them with an even spread averaged the same way.2The point that a few heads specialize and many put their weight on the first token rests on the head counts and the first-token averages."""3import numpy as np4from tokenizers import Tokenizer56from lib import open_model, transformer7from lib.products import product_texts8from lib.store import load_products910heads = open_model.read("heads")11previous, first = np.array(heads["previous"]), np.array(heads["first"]) # (layers, heads)12print("texts averaged:", heads["texts"])13print("heads in all:", previous.size)14print("heads with more than half their weight on the previous token:", int((previous > 0.5).sum())) # a position's weights sum to 1, so above 0.5 is most of it15print("the most weight a head puts on the previous token:", f"{previous.max():.2f}")16print("average weight on the first token, layers 1 to 4:", f"{first[:4].mean():.2f}") # rows count layers from 0: rows 0 to 317print("average weight on the first token, layers 5 to 32:", f"{first[4:].mean():.2f}") # rows from 4 on are layers 5 to 3218print("heads with more than half their weight on the first token:", int((first > 0.5).sum()))1920# An even spread, averaged the same way: each position i shares its weight equally among the i + 1 tokens it sees.21smollm2 = Tokenizer.from_file("data/smollm2-tokenizer/tokenizer.json")22end = transformer.load()[1].index(transformer.END) # [1] is the vocabulary: load() returns weights, vocabulary, manifest23rows = load_products("validation").head(500) # the first 500 validation products, the ones product_texts reads24# The same products as product_texts, with their names and descriptions, filtered the same way. Each text is a name, a newline25# and a description, as the recording wrote it.26texts = [f"{name}\n{description}\n" for (ids, sep), name, description in27 zip(product_texts("validation", 500), rows["name"], rows["description"]) if ids[-1] == end and sep < len(ids) - 2]28# Only the texts the recording averaged. The +1 is the start token the recording put before every text.29lengths = [len(smollm2.encode(text, add_special_tokens=False).ids) + 1 for text in texts[:heads["texts"]]]30# A position with k tokens to see gives an even spread 1 / k on each of them. k runs from 2 to the text's length.31print("an even spread's weight on the previous token, and on the first:",32 f"{np.mean([np.mean(1 / np.arange(2, n + 1)) for n in lengths]):.2f}")
python open-model-heads.pytexts averaged: 50
heads in all: 480
heads with more than half their weight on the previous token: 3
the most weight a head puts on the previous token: 0.79
average weight on the first token, layers 1 to 4: 0.13
average weight on the first token, layers 5 to 32: 0.61
heads with more than half their weight on the first token: 286
an even spread's weight on the previous token, and on the first: 0.05
Algumas cabeças se especializam fortemente. 3 cabeças colocam mais da metade do seu peso no token anterior, e a mais forte coloca 0.79 ali, contra 0.05 da distribuição uniforme. A cabeça do modelo da loja mais voltada ao token anterior, medida da mesma forma, colocou 0.35 no token anterior. Com centenas de cabeças, um modelo pode dar a algumas delas uma tarefa estreita.
O peso sobre o primeiro token é a surpresa maior. Nas quatro primeiras camadas, as cabeças colocam em média 0.13 do seu peso nele; a partir da camada 5, 0.61, contra 0.05 da distribuição uniforme, e 286 cabeças colocam mais da metade ali. Esse é o sumidouro de atenção que Xiao e colegas encontraram em modelos grandes (Xiao et al., 2024). Eles o explicam pelo softmax: uma cabeça sem nada útil em que prestar atenção ainda precisa colocar o seu peso em algum lugar, e o primeiro token está sempre presente. O capítulo 6 encontrou esse padrão apenas fracamente no modelo da loja, cujos tokens de descrição colocam 0.11 da sua atenção nos seus dois marcadores, contra 0.05 da distribuição uniforme.
Regra prática: Descreva as cabeças de um modelo grande pelas mesmas médias medidas que você usaria em um pequeno, comparadas com a distribuição uniforme. Espere algumas cabeças especializadas e muitas que colocam o seu peso no primeiro token, e mantenha esse token quando reduzir o contexto de um modelo para economizar memória.
Testar a cópia em escala
O capítulo 6 mostrou o modelo da loja copiando cover do nome de um produto para a descrição, ao mudar o nome e observar como a previsão acompanhava a mudança. O mesmo teste pergunta se o SmolLM2 também faz isso. Não é possível verificar se o texto de treinamento dele continha o texto deste produto, e o teste não precisa disso: se o SmolLM2 previsse cover por lembrar do produto, tirar cover do nome não mudaria a previsão.
Verifique as probabilidades registradas do SmolLM2 para cover e set em um ponto da descrição de double chaise patio furniture cover, depois de this outdoor patio furniture, com o nome como é vendido, sem cover, e terminando em set:
1"""Prints SmolLM2's recorded probabilities of cover and set after the same words of a description, under three versions of the name.2The point that each word follows its own name rests on the cover lines for the name as sold and without cover, and the set line for the name ending in set."""3from lib import open_model45copying = open_model.read("copying") # keyed by the version of the name, each with the probabilities of the tokens after the same words6for label, probabilities in copying.items():7 for token, p in probabilities.items():8 print(f"SmolLM2-360M, {label}, P({token.strip()}):", f"{p:.2f}") # the recorded tokens carry the space before them; strip removes it
python open-model-copying.pySmolLM2-360M, name as sold, P(cover): 0.75
SmolLM2-360M, name as sold, P(set): 0.00
SmolLM2-360M, name without cover, P(cover): 0.02
SmolLM2-360M, name without cover, P(set): 0.02
SmolLM2-360M, name ending in set, P(cover): 0.01
SmolLM2-360M, name ending in set, P(set): 0.77
Os dois modelos copiam a palavra que vem depois de uma frase anterior quando a frase se repete. Com o nome como é vendido, o SmolLM2 atribui a cover a probabilidade 0.75. Tire cover do nome e ela cai para 0.02; termine o nome em set e set recebe 0.77.
O modelo da loja se comportou da mesma forma, com 0.97, 0.00 e 0.70 para o nome terminado em set. Essa cópia é o comportamento de cabeças de indução, cabeças de atenção que encontram uma cópia anterior do token atual e prestam atenção ao que veio depois dela. Olsson e colaboradores as encontraram em todos os modelos que estudaram com mais de uma camada (Olsson et al., 2022).
Portanto, a cópia não é algo que a escala acrescenta; o modelo de 4 camadas da loja também a aprendeu. Para uma loja como esta, o hábito é útil e arriscado ao mesmo tempo: um modelo que copia palavras do nome do produto permanece no produto, e um que copia do texto do produto errado espalha o seu erro.
Regra prática: Teste um comportamento mudando a entrada e observando a saída, e execute o mesmo teste em todo modelo que você comparar. Quando dois modelos de tamanhos muito diferentes compartilham um comportamento, ele é básico; procure o que difere em outros pontos.
Sugerir a próxima palavra em escala
A caixa de busca é onde o texto da loja mais importa. O Capítulo 8 mostrou que o modelo da loja, sozinho, atribui a stool uma probabilidade de 0.50 depois de outdoor bar, e que a mistura do modelo da loja com as suas contagens, o modelo que a caixa de busca usa, dá 0.28.
Estes são os três tokens seguintes mais prováveis do SmolLM2 depois dos mesmos cinco prefixos, cada um dado sem nada antes dele, do mesmo modo como o modelo da loja os obteve:
1"""Prints SmolLM2's three likeliest next tokens after five search-box prefixes, and its probability of stool after outdoor bar.2The point that its suggestions are the wrong text rests on the top token after each prefix, and on the stool line."""3from lib import open_model45for prefix, recorded in open_model.read("prefixes").items():6 shown = ", ".join(f"{token!r} {p:.2f}" for token, p in recorded["top"][:3]) # the three likeliest tokens, as recorded7 print(f"{prefix:<12} -> {shown}")8# The recorded key keeps the space before stool. Four places: at two, this probability would print as 0.00.9print("P(stool | outdoor bar), SmolLM2-360M:", f"{open_model.read('prefixes')['outdoor bar']['P( stool)']:.4f}")
python open-model-autocomplete.pybar -> 'ry' 0.05, 'ley' 0.05, 'b' 0.04
patio bar -> '\n' 0.21, 'be' 0.06, ',' 0.06
outdoor bar -> '\n' 0.28, ',' 0.06, '\n\n' 0.04
kitchen bar -> '\n' 0.37, '\n\n' 0.03, ',' 0.02
wine bar -> '\n' 0.20, ',' 0.09, '\n\n' 0.03
P(stool | outdoor bar), SmolLM2-360M: 0.0002
As sugestões do SmolLM2 soam como inglês geral, e não como a caixa de busca da loja. Depois de outdoor bar, patio bar, kitchen bar e wine bar, o token seguinte mais provável é uma quebra de linha: ele trata cada prefixo como uma linha completa, provavelmente porque linhas curtas como essas terminam em quebra de linha em boa parte do texto com que foi treinado. A probabilidade que ele atribui a stool depois de outdoor bar é 0.0002. Depois de bar sozinho, ele sugere pedaços de palavras mais longas, como ry e ley, como em barry ou barley. Nada disso é inglês errado; é o texto errado. Uma caixa de busca precisa dos hábitos da loja, e os modelos próprios da loja os têm. Uma caixa de busca também precisa responder a cada tecla digitada, e o modelo da loja executa uma pequena fração dos cálculos do SmolLM2 por token.
Regra prática: Não coloque um modelo geral na frente dos compradores sem medir as suas sugestões nos seus próprios prefixos, comparando-as com o que você tem. Quando um modelo treinado no seu texto sugerir melhor, mantenha-o, e meça um modelo geral nas tarefas em que o seu conhecimento mais amplo possa importar.
Coloque os dois modelos lado a lado
Com todas as medidas feitas, os dois modelos podem ser comparados em uma única tabela. O modelo da loja é o próprio modelo do livro, medido nos capítulos 6 a 8; o SmolLM2-360M é lido a partir dos registros feitos neste capítulo.
| O modelo da loja | SmolLM2-360M | |
|---|---|---|
| Parâmetros | 1,334,144 | 361,821,120 |
| Camadas e largura | 4 camadas, 128 de largura | 32 camadas, 960 de largura |
| Cabeças de consulta, e cabeças de chave e valor, por camada | 4 e 4 | 15 e 5 |
| Vocabulário | 4,142 | 49,152 |
| Texto, em tokens: o catálogo, ou tokens usados no treinamento | 2,843,222, o catálogo da loja | 4 trilhões, em sua maioria texto geral |
| Perplexidade por palavra nos nomes da loja | 199.3 | 54,352.8 |
| Perplexidade por palavra nas descrições da loja | 37.0 | 61.2 |
P(cover) quando a descrição repete o nome |
0.97 | 0.75 |
| O maior peso que uma cabeça atribui ao token anterior | 0.35 | 0.79 |
Leia as colunas de cima a baixo e o padrão deste capítulo aparece. O SmolLM2 é muito maior em todas as medidas de tamanho, e os dois modelos aprenderam os mesmos comportamentos básicos, copiar e prestar atenção ao token anterior. Tudo o que diz respeito ao texto próprio da loja favorece o modelo pequeno, porque é tudo o que ele aprendeu. A escolha da loja não é entre um modelo pequeno e um grande; é sobre qual tarefa cada um desempenha.
Regra prática: Coloque lado a lado todo modelo entre os quais você está escolhendo, nas medidas que importam para suas tarefas, com o mesmo texto e os mesmos testes em cada coluna. Escolha um modelo por tarefa, e não um único modelo para tudo.
O que dá errado em produção
Um modelo aberto traz consigo as escolhas de quem o criou, e elas não se anunciam:
- O texto dele não é o seu texto. O SmolLM2 se saiu muito pior nos nomes da loja do que o modelo pequeno próprio da loja, e um rótulo não ajudou. Meça qualquer modelo com o seu próprio texto antes de confiar nele nesse uso.
- O tokenizer dele não é o seu. Números por token de dois tokenizers não podem ser comparados; pontue por palavra ou por caractere, nos mesmos eventos.
- Os detalhes do modelo precisam corresponder ao código que o executa. Chaves e valores agrupados, uma base RoPE de 100,000 e embeddings amarrados estão todos na configuração do SmolLM2-360M. O Capítulo 7 mediu o que custa uma base RoPE errada: um pouco de acurácia e nenhum erro. Carregue os modelos com o código publicado por seus criadores, em uma versão fixada, ou verifique cada detalhe contra ele.
- As revisões mudam. O repositório de um modelo pode ser atualizado sob o mesmo nome. Fixe a revisão, como
recordings/open_model.pyfaz, e registre-a com cada resultado. - O primeiro token importa. A maioria das cabeças das camadas finais do SmolLM2 se apoia no primeiro token. Mantenha-o ao reduzir o contexto e nunca deixe um pipeline descartá-lo silenciosamente.
- O tamanho define a velocidade. Cada token gerado passa por todas as camadas; assim, um modelo centenas de vezes maior exige centenas de vezes a aritmética por token. Meça o tempo por token na máquina em que você vai servir, nos comprimentos de texto que vai servir, antes de prometer um tempo de resposta.
- Licença e termos acompanham o modelo. O SmolLM2 tem licença Apache 2.0; outros modelos abertos trazem outros termos. Verifique a licença do modelo e da revisão exatos antes de construir sobre eles.
O que este capítulo decidiu
- O modelo aberto do livro é o SmolLM2-360M, lido a partir de duas gravações em revisões fixadas: sua execução sobre o texto da loja e as configurações de sua família. Todos os exemplos rodam sem PyTorch e sem download, e os resultados podem ser conferidos com o que foi registrado.
- Modelos com tokenizers diferentes são comparados por palavra, sobre o mesmo texto e os mesmos eventos: as palavras de cada nome e seu fim, a partir do token inicial; as palavras de cada descrição e seu fim, dado o nome.
- No texto da loja, o modelo pequeno da loja supera o SmolLM2, 199.3 contra 54,352.8 por palavra nos nomes, e 37.0 contra 61.2 nas descrições. A caixa de busca mantém a mistura do modelo da loja e de suas contagens que o capítulo 8 escolheu.
- As cabeças são comparadas entre modelos pelas mesmas medidas, contra uma distribuição uniforme. O SmolLM2 mostra os dois padrões do capítulo 6, de forma mais acentuada: algumas cabeças que se especializam no token anterior, e muitas que concentram seu peso no primeiro token.
- Copiar de trechos anteriores de um texto é algo básico, compartilhado por um modelo de 4 camadas e outro de 32 camadas, e testado da mesma forma nos dois.
- O custo de um modelo é calculado a partir de sua configuração antes de ele ser servido: seus pesos, mais um cache de chaves e valores por texto em andamento. Entre os tamanhos do SmolLM2, as chaves e valores agrupados reduzem a cache do modelo de 360M a um terço.
Este capítulo, nesta edição
Edição 2026.11.16Exemplos aprovados em 19 de nov de 20267 de 7 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.16.