Da previsão à obediência a instruções
Cerca de 27 minutos min de leitura, com 9 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
- Calcule as duas perdas de treinamento à mão
- Pergunte ao modelo base e ao modelo ajustado
- Formate a requisição como o modelo foi ajustado
- Medir detalhes inventados de produtos
- Verifique se a confiança serve de alerta
- Encontre o que um contexto mais longo perde
- Adapte um modelo ao seu texto
- Revisitando a régua de comparação
- O que dá errado em produção
- O que este capítulo decidiu
Ao final deste capítulo, você será capaz de explicar como um modelo que prevê o próximo token se torna um modelo que segue pedidos, construir as duas funções de perda que realizam essa transformação e medir o que essa mudança corrige e o que não corrige. Você vai comparar um modelo base com sua versão ajustada por instrução, usando os mesmos pedidos, medir com que frequência cada um inventa um detalhe de produto, verificar se a confiança do modelo avisa quando isso acontece, e descobrir em que ponto de um contexto longo um modelo deixa de encontrar o que lhe foi fornecido.
Os nomes e as descrições de produtos da loja de móveis e artigos para casa são o texto que este livro modela, e cada modelo do livro até aqui fez apenas uma coisa: prever o próximo token de um texto semelhante ao seu texto de treinamento. O capítulo 10 usou o SmolLM2-360M, um modelo aberto treinado dessa forma com texto geral, e constatou que ele pontuou os nomes da loja muito pior, por palavra, do que o pequeno modelo próprio da loja, e as descrições também pior. As pessoas não querem uma continuação do seu texto; querem uma resposta ao seu pedido. Os modelos aprendem isso em duas etapas adicionais de treinamento.
Ajuste por instrução, ou ajuste fino supervisionado, continua o treinamento de um modelo com exemplos de pedidos pareados com boas respostas, de modo que prever o próximo token de um par desse tipo signifique responder ao pedido. Wei e colaboradores constataram que ajustar o modelo com muitas tarefas formuladas como instruções o tornou melhor em tarefas que ele nunca havia visto (Wei et al., 2022). Ajuste por preferência então treina um modelo a preferir a melhor entre duas respostas ao mesmo pedido. Ouyang e colaboradores pediram que pessoas ordenassem as respostas e treinaram com aprendizado por reforço a partir de um modelo de recompensa aprendido com essas ordenações (Ouyang et al., 2022); a Direct Preference Optimization, DPO, faz o ajuste por preferência sem modelo de recompensa, com uma função de perda simples aplicada aos próprios pares de preferência (Rafailov et al., 2023).
O SmolLM2-360M-Instruct é o modelo base do capítulo 10 após as duas etapas: ajuste fino supervisionado em conjuntos de dados públicos e curados, seguido de DPO no UltraFeedback (cartão do modelo). Os pares de preferência do UltraFeedback foram avaliados por um grande modelo de linguagem, não por pessoas (Cui et al., 2023). Este capítulo chama o SmolLM2-360M de modelo base e o SmolLM2-360M-Instruct de modelo ajustado. O script recordings/instruction_tuning.py executou ambos uma única vez, em revisões fixadas, com decodificação gulosa, de modo que cada resposta é a mais provável segundo o modelo e a execução pode ser repetida exatamente, e salvou o que eles escreveram e a probabilidade que cada modelo atribuiu a cada token que escreveu. Todas as medidas dos dois modelos vêm desses arquivos.
Calcule as duas perdas de treinamento à mão
Ambas as etapas do ajuste são treinamento, com o mesmo laço do capítulo 8; o que muda é a perda. O ajuste por instrução usa a perda usual de próximo token com uma diferença: só os tokens da resposta contam. A requisição é lida, como contexto, mas o modelo não é treinado para prevê-la, já que o objetivo é responder a requisições, não escrevê-las.
Monte um produto como uma requisição e uma resposta, com o nome como requisição e a descrição como resposta, da forma como o modelo da loja já a lê. Depois calcule a perda desse modelo sobre todos os tokens e somente sobre os tokens da resposta:
1"""Computes the store's model's loss on one product laid out as a request and a response, over every token and over2the response's tokens only. The prose's point rests on the last printed line, the average loss over the response only.3"""4import numpy as np56from lib import transformer7from lib.store import load_products89_, vocabulary, manifest = transformer.load()10index = {token: i for i, token in enumerate(vocabulary)}11# the name is unique in the validation split, so its one row is the product12product = load_products("validation").query("name == 'double chaise patio furniture cover'").iloc[0]13# the text is cut at the model's longest length, so a long description may end early14ids = transformer.product_ids(product["name"], product["description"], index, manifest["settings"]["longest"])15sep = ids.index(index[transformer.SEP]) # the name plays the request; the description, the response1617# the last position predicts nothing, since no token follows it, so its row is dropped18probabilities = transformer.softmax(transformer.forward(ids)[:-1])19# position i predicts the token at i + 1, so ids[1:] holds each position's target20# each token's loss, given the tokens before it21loss = -np.log(probabilities[np.arange(len(ids) - 1), ids[1:]])22response = np.arange(1, len(ids)) > sep # the description's tokens and its end23print("tokens predicted in the text:", len(loss))24print("tokens the instruction loss counts, the response's:", int(response.sum()))25print("average loss over every token:", f"{loss.mean():.3f}")26print("average loss over the response only:", f"{loss[response].mean():.3f}")
python instruction-loss-by-hand.pytokens predicted in the text: 96
tokens the instruction loss counts, the response's: 90
average loss over every token: 2.267
average loss over the response only: 2.132
Treinar com a perda somente sobre a resposta, em muitas requisições e respostas, ensina um modelo a produzir respostas. Para este produto, essa perda é 2.132, contra 2.267 sobre todos os tokens. A perda por instrução conta 90 dos 96 tokens que o modelo prevê: os tokens da descrição e o seu fim.
A perda do DPO trabalha com um par de respostas para uma mesma requisição, uma preferida e uma rejeitada. O DPO compara o quanto o modelo em ajuste torna cada resposta mais provável do que o modelo de referência do qual partiu, isto é, o modelo após o ajuste por instrução, e recompensa o modelo por elevar mais a resposta preferida. Com log-probabilidades log π de cada resposta sob o modelo em ajuste e log π_ref sob a referência, e um fator β que define o quanto o modelo pode se afastar:
margem = β × [(log π(preferida) − log π_ref(preferida)) − (log π(rejeitada) − log π_ref(rejeitada))]
perda = −log σ(margem)
com σ a função logística do capítulo 4 (Rafailov et al., 2023, equação 7). Log-probabilidades inventadas mantêm a aritmética à vista, então este exemplo as usa, com β = 0.1:
1"""Computes the DPO margin and loss by hand for two made-up cases, with a fixed beta. The prose's point rests on the2two loss lines, one for each case.3"""4import numpy as np56beta = 0.1 # how far the tuned model may move from the reference7print("beta:", beta)8# Each case: (preferred, rejected) under the tuned model, then (preferred, rejected) under the reference model it9# started from. Made-up numbers, to follow the arithmetic.10cases = {"tuned model favours the preferred answer more than the reference does": (-12.0, -20.0, -14.0, -18.0),11 "tuned model favours it less": (-15.0, -15.0, -14.0, -18.0)}12for label, (preferred, rejected, preferred_reference, rejected_reference) in cases.items():13 margin = beta * ((preferred - preferred_reference) - (rejected - rejected_reference))14 loss = np.log1p(np.exp(-margin)) # -log σ(margin), written so it can't overflow15 print(f"{label}, margin:", f"{margin:.2f}")16 print(f"{label}, loss:", f"{loss:.3f}")
python dpo-loss-by-hand.pybeta: 0.1
tuned model favours the preferred answer more than the reference does, margin: 0.40
tuned model favours the preferred answer more than the reference does, loss: 0.513
tuned model favours it less, margin: -0.40
tuned model favours it less, loss: 0.913
Diminuir a perda faz a probabilidade da resposta preferida subir e a da rejeitada cair, medidas em relação a onde o modelo começou. Quando o modelo em ajuste favorece a resposta preferida mais do que a referência, a margem é 0.40 e a perda 0.513; quando a favorece menos, a margem é -0.40 e a perda sobe para 0.913.
Regra prática: Mascare a requisição fora da perda quando ajustar um modelo com requisições e respostas, e mantenha as log-probabilidades do modelo de referência ao lado das do modelo em ajuste quando treinar com preferências. Ambas são pequenas mudanças em um laço que você já tem.
Pergunte ao modelo base e ao modelo ajustado
A loja precisa de descrições para produtos que não têm nenhuma, tarefa que o capítulo 9 deu ao seu próprio modelo pequeno. O modelo base, SmolLM2-360M, não pode ser questionado, apenas continuado, então recebe o início de uma listagem de produto: Product:, o nome e Description:. O modelo ajustado, SmolLM2-360M-Instruct, recebe um pedido: Write a short product description for: e o nome.
Os dois modelos partem do produto do capítulo 9, front porch welcome sign wall décor. Leia o que cada um escreveu e, depois, meça todos os 8 produtos que a gravação descreveu, cada um sem uma descrição em que se apoiar:
1"""Prints what the base and the tuned model wrote for one product with no description, then measures every such product's2text for materials its name doesn't give and for repeated four-word phrases. The prose's points rest on the last four3printed lines, the two models' invented-material counts and repeat shares.4"""5from collections import Counter67from lib import claims, recorded89# the recording's saved texts for every product, read back rather than generated again10described = recorded.read("instruction-tuning", "descriptions")11product = next(row for row in described if row["name"] == "front porch welcome sign wall décor")12print("product:", product["name"])13print("base model:", " ".join(product["base"]["text"].split()))14print("tuned model:", " ".join(product["tuned"]["text"].split()))151617def repeats(text):18 """The share of four-word phrases that repeat an earlier one in the text."""19 words = text.lower().split()20 # every window of four consecutive words, so a text of n words has n - 3 of them21 phrases = [tuple(words[i:i + 4]) for i in range(len(words) - 3)]22 # a phrase counts as repeated each time after its first appearance; max keeps a text of fewer than four words from dividing by zero23 return sum(count - 1 for count in Counter(phrases).values()) / max(len(phrases), 1)242526print("products described, none of which has a description to draw on:", len(described))27for role in ["base", "tuned"]:28 texts = [row[role]["text"] for row in described]29 # materials the text names that the product's name doesn't give: a set difference, not the text's whole list30 invented = sum(bool(claims.materials(row[role]["text"]) - claims.materials(row["name"])) for row in described)31 print(f"{role} model, descriptions that name a material the name doesn't:", f"{invented} of {len(described)}")32 print(f"{role} model, repeated four-word phrases:", f"{sum(map(repeats, texts)) / len(texts):.0%}")
python base-and-tuned.pyproduct: front porch welcome sign wall décor
base model: Front porch welcome sign wall décor The front porch is a common feature of many homes. It is a place where people can relax and enjoy the outdoors. It is also a place where people can socialize and meet new friends. The front porch is a great place to hang out with your family
tuned model: "Welcome to our front porch welcome sign wall décor, a space that brings warmth and comfort to your home. This wall is a statement piece that showcases your personality and style. With a mix of rustic and modern elements, you can create a unique and inviting atmosphere that reflects your individuality.
products described, none of which has a description to draw on: 8
base model, descriptions that name a material the name doesn't: 2 of 8
base model, repeated four-word phrases: 14%
tuned model, descriptions that name a material the name doesn't: 1 of 8
tuned model, repeated four-word phrases: 0%
O modelo base escreve sobre alpendres, The front porch is a common feature of many homes, e depois sobre relaxar e encontrar amigos. Ele continua o texto em uma direção plausível, que não é a direção de que a loja precisa. O modelo ajustado escreve algo com a forma de uma descrição de produto, a statement piece that showcases your personality and style, mas chama a placa de a space e This wall: fluente sobre um produto que não compreende. Entre os produtos, os textos do modelo base repetem 14% de suas expressões de quatro palavras, e os do modelo ajustado, 0%. A gravação não consegue dizer qual etapa do ajuste interrompeu os loops.
Nenhum dos modelos sabe nada sobre os produtos além dos nomes. O modelo base citou um material que o nome não informa em 2 of 8 descrições, e o modelo ajustado em 1 of 8; cada um desses casos veio do modelo, não dos dados da loja, como aconteceu com o modelo do capítulo 9.
Regra prática: Use um modelo ajustado quando precisar que um pedido seja seguido, e um modelo base quando precisar que um texto seja continuado no estilo do que veio antes. Não tome a fluência por conhecimento: um modelo ajustado escreve uma descrição mais bem formada a partir da mesma falta de fatos.
Formate a requisição como o modelo foi ajustado
O modelo ajustado respondeu na seção anterior porque sua requisição chegou no formato em que ele foi ajustado. O template de chat de um modelo ajustado é o formato que ele aprendeu: tokens especiais que marcam onde começam e terminam uma mensagem de sistema, as instruções colocadas antes da requisição do usuário, a própria requisição e a resposta do modelo. O modelo aprendeu a responder requisições somente nesse formato, então uma requisição em qualquer outra forma é apenas texto a ser continuado. Bibliotecas que carregam o modelo aplicam o template a partir dos arquivos do tokenizador do modelo (configuração do tokenizador).
O prompt completo do modelo ajustado, e sua resposta ao lado da que ele dá à mesma requisição como texto simples, mostram o que ele realmente leu:
1"""Prints the full prompt the tuned model read, with its chat template, and its reply with and without the template. The2prose's point rests on the last two printed lines: the same words, with and without the template.3"""4from lib import recorded56template = recorded.read("instruction-tuning", "template")7# the request is the text between the user marker and its end marker8print("request:", template["with"]["prompt"].split("<|im_start|>user\n")[1].split("<|im_end|>")[0])9print("what the tuned model reads, with its chat template:")10print(template["with"]["prompt"])11print("tuned model, with the template:", " ".join(template["with"]["text"].split()))12print("tuned model, without it:", " ".join(template["without"]["text"].split()))
python chat-template.pyrequest: Write a short product description for: front porch welcome sign wall décor
what the tuned model reads, with its chat template:
<|im_start|>system
You are a helpful AI assistant named SmolLM, trained by Hugging Face<|im_end|>
<|im_start|>user
Write a short product description for: front porch welcome sign wall décor<|im_end|>
<|im_start|>assistant
tuned model, with the template: "Welcome to our front porch welcome sign wall décor, a space that brings warmth and comfort to your home. This wall is a statement piece that showcases your personality and style. With a mix of rustic and modern elements, you can create a unique and inviting atmosphere that reflects your individuality.
tuned model, without it: .
O ajuste ensinou o modelo a seguir requisições em um formato, não requisições em geral. Com o template, a requisição fica entre <|im_start|>user e <|im_end|>, depois de uma mensagem de sistema que o template acrescenta por padrão, You are a helpful AI assistant named SmolLM, trained by Hugging Face, e antes de <|im_start|>assistant, onde começa a resposta do modelo. O modelo responde com a descrição da seção anterior. Sem o template, dadas as mesmas palavras como texto simples, o modelo ajustado escreve . e para.
A mensagem de sistema também importa: ela faz parte de toda requisição que o modelo lê, então uma diferente, como uma descrição da loja e de seu tom, pode alterar qualquer resposta. Por isso ela é uma configuração a ser escolhida e registrada, como uma configuração de decodificação no capítulo 9.
Regra prática: Sempre formate as requisições a um modelo ajustado com o template de chat próprio dele, aplicado pela biblioteca a partir dos arquivos do tokenizador do modelo, nunca montado à mão. Verifique a mensagem de sistema padrão do template, já que o modelo a lê em toda requisição, e registre o prompt completo formatado junto de cada resposta que você mantiver.
Medir detalhes inventados de produtos
Um modelo que escreve sobre um produto sem fatos precisa inventá-los. O teste mais justo lhe dá os fatos. Os dois modelos SmolLM2 recebem o nome e a descrição real de um produto e são perguntados: What material is this product made of? Answer in a few words, using only the description. O modelo ajustado recebe isso como um pedido no formato de seu template de conversa; o modelo base recebe como uma listagem a ser continuada, terminando em Question:, a pergunta, e Answer:. Se os dados do produto nomearem um material, uma boa resposta o nomeia; se não, uma boa resposta diz que a descrição não informa.
Para verificar as respostas, usa-se uma lista de palavras de materiais, de wood e metal até polyester e leather, no módulo compartilhado do livro, lib.claims. Uma resposta é sustentada se todo material que ela nomeia estiver no nome ou na descrição do produto. Uma resposta é inventada se nomeia um material que o nome e a descrição do produto não contêm. Uma resposta é recusada se diz que os dados do produto não informam, e nenhum se não nomeia material algum e não recusa. A verificação tem limites e faz julgamentos: conta madeira processada, como mdf e rubberwood, como madeira, conta brushed nickel finish como citação de níquel, e deixa passar um material que a lista não inclui. Cada resposta classificada fica registrada para quem quiser conferir. Inventar um detalhe que a entrada não sustenta é um tipo do que se chama alucinação (Ji et al., 2023), e este teste mede exatamente esse tipo.
Classifique as respostas de cada modelo para 40 produtos escolhidos ao acaso, divididos conforme os dados do produto nomeiem ou não um material. Quando os dados não nomearem nenhum, o modelo ajustado vai inventar menos materiais que o modelo base? Decida antes de olhar.
1"""Classes both models' answers to the material question, split by whether the product's name or description names a2material. The prose's point rests on the rows for products whose data names none: made up and declined.3"""4from collections import Counter56from lib import claims, recorded78asked = recorded.read("instruction-tuning", "answers")9print("products asked, each with its description given:", len(asked))10# a product's data names a material if its description or its name does: the union of the two sets11given = [bool(claims.materials(row["description"]) | claims.materials(row["name"])) for row in asked]12print("products whose name or description names a material:", sum(given))13print("products whose name and description name none:", len(given) - sum(given))14for role in ["base", "tuned"]:15 for label, keep in [("data names a material", True), ("data names none", False)]:16 rows = [row for row, named in zip(asked, given) if named == keep]17 # each answer is classed against the product's data, by the rules in lib.claims18 counts = Counter(claims.classify(row[role]["text"], row["description"], row["name"]) for row in rows)19 for kind in ["supported", "made up", "none", "declined"]:20 print(f"{role} model, {label}, {kind}:", counts[kind])
python made-up-materials.pyproducts asked, each with its description given: 40
products whose name or description names a material: 28
products whose name and description name none: 12
base model, data names a material, supported: 24
base model, data names a material, made up: 2
base model, data names a material, none: 2
base model, data names a material, declined: 0
base model, data names none, supported: 0
base model, data names none, made up: 7
base model, data names none, none: 5
base model, data names none, declined: 0
tuned model, data names a material, supported: 23
tuned model, data names a material, made up: 3
tuned model, data names a material, none: 2
tuned model, data names a material, declined: 0
tuned model, data names none, supported: 0
tuned model, data names none, made up: 8
tuned model, data names none, none: 4
tuned model, data names none, declined: 0
| Resposta | Base, dados nomeiam um material | Ajustado, dados nomeiam um material | Base, dados não nomeiam nenhum | Ajustado, dados não nomeiam nenhum |
|---|---|---|---|---|
| Sustentada | 24 | 23 | 0 | 0 |
| Inventada | 2 | 3 | 7 | 8 |
| Nenhum | 2 | 2 | 5 | 4 |
| Recusada | 0 | 0 | 0 | 0 |
Nos 12 produtos cujo nome e descrição não nomeiam nenhum material, a resposta correta é que a descrição não informa, e nenhum dos dois modelos a deu uma única vez. Os dois, na maioria das vezes, inventaram um material, e o restante das respostas não nomeou nenhum sem explicar por quê. Dos produtos, 28 têm dados que nomeiam um material, e nesses os dois modelos, na maioria, respondem a partir desses dados.
O ajuste por instruções não resolveu isso, e nesses produtos o modelo base, recebendo uma listagem a ser continuada, não se saiu pior. O pedido dizia para usar apenas a descrição; quando a descrição não tinha resposta, os modelos responderam mesmo assim, com um material que produtos como este costumam ter. Seguir a forma de uma instrução não é o mesmo que saber quando não se sabe.
Regra prática: Teste um modelo com perguntas que sua entrada não consegue responder, e não apenas com as que consegue, e conte as respostas inventadas separadamente. Verifique cada afirmação factual que um modelo faz sobre um produto contra os dados do produto, de forma automática sempre que possível, como lib.claims faz com os materiais.
Verifique se a confiança serve de alerta
A seção anterior classificou as respostas do modelo ajustado à pergunta sobre o material como apoiadas ou inventadas. Se as respostas inventadas vieram com baixa confiança, essa baixa confiança poderia sinalizá-las. Um modelo cuja confiança corresponde à frequência com que acerta é calibrado, e Guo e colegas constataram que as redes neurais profundas que estudaram muitas vezes não são: eram mais confiantes do que a sua acurácia justificava (Guo et al., 2017). A gravação salvou a probabilidade que o modelo ajustado atribuiu a cada token que escreveu, incluindo o token de fim, então é possível calcular uma confiança por token para cada resposta, como média geométrica:
confiança por token = exp((log p₁ + … + log pₙ) / n)
a exponencial da média das log-probabilidades, a mesma média que a perplexidade inverte, de modo que uma resposta curta e uma longa são medidas na mesma escala.
A confiança distingue os dois tipos? Compare a confiança do modelo ajustado nas respostas apoiadas e nas inventadas, e conte quantas de cada tipo um limiar de 0.5 por token manteria:
1"""Compares the tuned model's confidence in its supported and made-up answers to the material question, and counts what a2threshold of 0.5 per token keeps. The prose's point rests on the two average confidences and the two threshold counts.3"""4import numpy as np56from lib import claims, recorded78asked = recorded.read("instruction-tuning", "answers")9# only supported and made-up answers are compared; declined and none answers are left out10by_kind = {"supported": [], "made up": []}11for row in asked:12 kind = claims.classify(row["tuned"]["text"], row["description"], row["name"])13 if kind in by_kind:14 # the geometric mean of the token probabilities: exp of their average log-probability15 by_kind[kind].append(np.exp(np.mean(np.log(row["tuned"]["token_probabilities"]))))16for kind, confidence in by_kind.items():17 print(f"tuned model, {kind} answers:", len(confidence))18 print(f"tuned model, {kind} answers, average probability per token:", f"{np.mean(confidence):.2f}")19# a fixed cut for the comparison, not one fitted to these answers20threshold = 0.521for kind, confidence in by_kind.items():22 print(f"tuned model, {kind} answers above {threshold} per token:", f"{sum(c > threshold for c in confidence)} of {len(confidence)}")
python answer-confidence.pytuned model, supported answers: 23
tuned model, supported answers, average probability per token: 0.65
tuned model, made up answers: 11
tuned model, made up answers, average probability per token: 0.45
tuned model, supported answers above 0.5 per token: 21 of 23
tuned model, made up answers above 0.5 per token: 3 of 11
A confiança é um sinal, não um filtro: ela altera as chances e deixa passar erros confiantes. As respostas inventadas têm, em média, menor confiança: 0.45 por token contra 0.65 das apoiadas. Mas um limiar de 0.5 por token manteria 21 of 23 respostas apoiadas e ainda deixaria passar 3 of 11 respostas inventadas. Com tão poucas respostas, esses valores são indícios de direção, não taxas nas quais se possa confiar.
Regra prática: não use a confiança de um modelo sozinha para decidir se deve confiar em uma resposta. Meça como a confiança dele se relaciona com acertar nas suas próprias perguntas e, se usar um limiar, escolha-o a partir dessas medições e conte o que ele deixa passar.
Encontre o que um contexto mais longo perde
A pergunta sobre material apresentava ao modelo um produto de cada vez. O assistente de uma loja muitas vezes tem diante de si os dados de vários produtos ao mesmo tempo, como resultados de busca, uma página de categoria ou uma comparação, e precisa encontrar os detalhes do produto certo entre os demais. Liu e colaboradores descobriram que os modelos usam melhor as informações no início e no fim de um contexto longo do que as informações no meio (Liu et al., 2024).
Posicione o produto consultado entre 10 listagens de produtos: em primeiro lugar, no meio ou por último. Em seguida, pergunte ao modelo ajustado SmolLM2-360M-Instruct do que esse produto é feito. Conte as respostas que citam apenas os materiais do próprio produto, conforme lib.claims verifica, para os 14 produtos cujos dados nomeiam algum material:
1"""Counts the tuned model's answers that name only the asked product's own materials, with the product first, in the middle2or last of a context of listings. The prose's point rests on the three placement lines.3"""4from collections import defaultdict56from lib import claims, recorded78context = recorded.read("instruction-tuning", "context")9# the other listings in each context; the asked product is one more, as the first printed line shows10others = recorded.read("instruction-tuning", "manifest")["settings"]["context_others"]11print("product listings in each context:", others + 1)12results = defaultdict(list)13for row in context:14 # only products whose data names a material: a product with none gives an answer nothing to name15 if claims.materials(row["description"]) | claims.materials(row["name"]):16 # supported: every material the answer names is in the asked product's own data17 results[row["place"]].append(claims.classify(row["tuned"]["text"], row["description"], row["name"]) == "supported")18print("products asked about at each place:", len(results["first"]))19for place in ["first", "middle", "last"]:20 print(f"product placed {place}, answers that name only its own materials:", f"{sum(results[place])} of {len(results[place])}")
python answer-position.pyproduct listings in each context: 10
products asked about at each place: 14
product placed first, answers that name only its own materials: 12 of 14
product placed middle, answers that name only its own materials: 6 of 14
product placed last, answers that name only its own materials: 12 of 14
Um produto no meio é encontrado com menos frequência, o padrão que Liu e colaboradores encontraram em modelos muito maiores. Com o produto em primeiro lugar, 12 of 14 respostas citam apenas os seus materiais; em último, 12 of 14; no meio, 6 of 14. As contagens são pequenas, mas a diferença é ampla. O contexto aqui é curto, de alguns milhares de caracteres, bem dentro do limite do modelo: o meio perde detalhes muito antes de o contexto estar cheio.
Regra prática: coloque os detalhes de que um modelo mais precisa no início ou no fim do seu contexto, não no meio, e forneça a ele o mínimo possível de texto não relacionado à tarefa. Teste a recuperação a partir de um contexto mais longo em cada posição antes de confiar que um modelo encontrará detalhes entre muitos.
Adapte um modelo ao seu texto
Capítulo 10 mostrou que o modelo geral ficou muito pior que o modelo pequeno da loja nos nomes da loja, por palavra. O ajuste por instrução muda a forma como um modelo responde, não o que ele sabe sobre uma loja específica. A maneira de ensinar a um modelo geral o texto da loja é o ajuste fino (fine-tuning): continuar o treinamento com esse texto, pelo mesmo ciclo de treinamento do capítulo 8, partindo dos pesos do modelo geral em vez de pesos aleatórios.
O ajuste fino completo atualiza cada peso, o que, para um modelo de centenas de milhões de parâmetros, leva tempo e memória. O LoRA, adaptação de baixo posto (low-rank adaptation), congela os pesos do modelo e treina uma pequena correção ao lado de alguns deles. Para uma matriz de pesos que mapeia k números em d números, treina uma matriz B de d por r e uma matriz A de r por k, e soma o produto delas aos pesos: W + BA (Hu et al., 2022). Com um posto r pequeno, há muito menos o que treinar e armazenar, e Hu e colegas verificaram que ele igualou o ajuste fino completo nas tarefas que testaram.
Uma correção LoRA treinaria muito menos pesos; vamos contá-los no SmolLM2-360M, adaptando os pesos de consulta e de valor de cada camada, em dois postos, contra o ajuste fino completo. Os pesos de consulta mapeiam 960 números em 960; os pesos de valor, porque chaves e valores são agrupados, mapeiam 960 em 320:
1"""Counts what LoRA would train on SmolLM2-360M, adapting the query and value weights of every layer at two ranks, and2what full fine-tuning trains. The prose's point rests on the rank 8 lines and the full fine-tuning count.3"""4from lib import open_model56config = open_model.config("SmolLM2-360M")7width, layers = config["hidden_size"], config["num_hidden_layers"]8# keys and values share heads, so their width is the query width scaled by the ratio of key-value heads to heads9key_value_width = config["num_key_value_heads"] * width // config["num_attention_heads"]10# every parameter of the model: the full fine-tuning count, and the denominator of each share11total = open_model.parameters(config)["total"]12for rank in [8, 64]:13 # LoRA adds two small matrices beside each adapted weight: width x rank, then rank x output width.14 added = layers * (rank * (width + width) + rank * (width + key_value_width)) # on the query and value weights15 print(f"rank {rank}, parameters trained:", f"{added:,}")16 print(f"rank {rank}, share of the model's parameters:", f"{added / total:.2%}")17print("parameters trained by full fine-tuning:", f"{total:,}")
python lora-parameters.pyrank 8, parameters trained: 819,200
rank 8, share of the model's parameters: 0.23%
rank 64, parameters trained: 6,553,600
rank 64, share of the model's parameters: 1.81%
parameters trained by full fine-tuning: 361,821,120
Com posto 8, o LoRA treina 819,200 parâmetros, 0.23% do modelo, enquanto o ajuste fino completo treina todos os 361,821,120. Uma correção de posto 8 é menor que o próprio modelo pequeno da loja, e pode ser guardada e trocada por tarefa enquanto os pesos base permanecem compartilhados.
Este livro não executa o ajuste fino: nossa avaliação é que, mesmo com LoRA, sobre o texto da loja, o processador de um notebook levaria muito mais tempo do que qualquer gravação aqui. Esse é o próximo passo para uma loja que queira um modelo geral escrevendo com a sua própria voz: ajuste fino no catálogo e depois meça o resultado contra o modelo pequeno da própria loja, por palavra, como o capítulo 10 fez. O ajuste fino tem riscos próprios. Um modelo treinado no catálogo aprende as suas lacunas junto com o seu texto, como o modelo pequeno da loja aprendeu a deixar vazia a descrição de uma lâmpada no capítulo 9. E treinar com um texto único e restrito pode enfraquecer o que o modelo sabia antes; Biderman e colegas constataram que o LoRA esquece menos disso do que o ajuste fino completo (Biderman et al., 2024). Ambos são medidos da mesma forma que tudo o mais neste livro: em texto reservado para teste, antes e depois.
Regra prática: Para ensinar a um modelo geral o seu texto, faça o ajuste fino com esse texto, usando LoRA quando a memória ou o armazenamento forem limitados, e meça o resultado em texto reservado para teste do mesmo tipo. Não espere que o ajuste por instrução ou um prompt mais engenhoso forneça um conhecimento que o modelo nunca aprendeu.
Revisitando a régua de comparação
Este livro avaliou todos os modelos da mesma forma nos nomes, a partir do capítulo 3: perplexidade por token do tokenizador da loja, nos nomes de validação da loja. Os nomes de teste foram separados para que escolhas feitas olhando os nomes de validação, como as épocas mantidas e as frações de mistura, não pudessem favorecer os resultados. Esta comparação final avalia os cinco modelos entre os quais se escolheu nos 4,281 nomes de teste, com as frações de mistura escolhidas na validação:
1"""Scores the five models the book chose between on the test names, each name's tokens and its end, and prints each2model's test perplexity. The prose's point rests on the five test perplexity lines.3"""4import numpy as np56from lib import neural, transformer7from lib.names import name_tokens8from lib.ngrams import KneserNey, ngrams, padded910# The test names, untouched until now: every model scores each name's tokens and its end. The mixing shares are the11# ones chosen on the validation names, in chapters 5 and 8.12test = name_tokens("test")13counted = KneserNey(name_tokens("train"), 4)14# padded adds the start marker three times and the end marker, so each name's first tokens have a context and its end is scored15from_counts = np.array([counted.probability(c, t) for text in test for c, t in ngrams(padded(text, 4), 4)])16from_window = neural.token_probabilities(test)17_, vocabulary, _ = transformer.load()18index = {token: i for i, token in enumerate(vocabulary)}19from_transformer = []20for name in test:21 # the transformer reads the start marker, the name, then <sep>, which ends a name where the counts end with </s>22 ids = [index[transformer.START]] + [index[t] for t in name] + [index[transformer.SEP]]23 probabilities = transformer.softmax(transformer.forward(ids)[:-1])24 # position i predicts token i + 1, so ids[1:] is each token's target, the end of the name included25 from_transformer += list(probabilities[np.arange(len(ids) - 1), ids[1:]])26from_transformer = np.array(from_transformer)2728# pooled over every token of every name, not averaged per name29perplexity = lambda p: f"{np.exp(-np.log(p).mean()):.1f}"30print("test names:", f"{len(test):,}")31print("test perplexity, the 4-gram baseline:", perplexity(from_counts))32print("test perplexity, the window model:", perplexity(from_window))33# the mix averages the probabilities, not their logs: a share of 0.2 is 20% of the window model34print("test perplexity, the window model mixed with the counts, share 0.2:", perplexity(0.2 * from_window + 0.8 * from_counts))35print("test perplexity, the store's transformer:", perplexity(from_transformer))36print("test perplexity, the store's transformer mixed with the counts, share 0.5:", perplexity((from_transformer + from_counts) / 2))
python test-names.pytest names: 4,281
test perplexity, the 4-gram baseline: 22.9
test perplexity, the window model: 35.4
test perplexity, the window model mixed with the counts, share 0.2: 21.6
test perplexity, the store's transformer: 23.7
test perplexity, the store's transformer mixed with the counts, share 0.5: 18.3
As escolhas feitas na validação favoreceram muito pouco os resultados: a coluna de teste fica próxima da de validação. Lado a lado, os números contam a história do livro em uma única tabela.
| Modelo | Capítulo | Nomes de validação | Nomes de teste |
|---|---|---|---|
| Contagens de tokens isolados, um 1-grama | 3 | 687.2 | |
| Contagens de pares, um 2-grama | 3 | 46.9 | |
| Contagens de quatro tokens, o 4-grama de referência | 3 | 23.1 | 22.9 |
| O modelo de janela, uma pequena rede neural | 5 | 36.4 | 35.4 |
| O modelo de janela misturado com as contagens | 5 | 21.9 | 21.6 |
| O transformer da loja | 8 | 24.0 | 23.7 |
| O transformer da loja misturado com as contagens | 8 | 18.4 | 18.3 |
Três lições atravessam a tabela. Contar vai longe em textos curtos e formulaicos: nenhum modelo aprendido neste livro superou o 4-grama de referência só nos nomes, e as duas misturas o superaram. Um modelo aprendido se justifica por errar em lugares diferentes dos das contagens, e é por isso que cada mistura superou as duas partes que a compõem. E em textos mais longos, em que o contexto distante importa, o transformer se destacou sozinho, como o capítulo 8 mediu nas descrições. O tamanho sozinho não decidiu nada: o modelo geral do capítulo 10, centenas de vezes maior, obteve 54,352.8 por palavra nos nomes da loja, contra 199.3 do transformer da loja.
Nenhum desses números diz se um modelo é útil. A perplexidade mede o quão bem um modelo prevê textos parecidos com o seu texto de treino, que é o que o autocompletar precisa. Ela não mede se uma descrição é verdadeira, se uma resposta segue um pedido, ou se um cliente encontra o que veio buscar. Os testes deste capítulo, com materiais fictícios, confiança e o lugar de um fato em um contexto, são um primeiro passo além da perplexidade, em direção a medir o trabalho em si.
Regra prática: Mantenha uma única régua fixa para comparar modelos, com o mesmo texto, tokenizador e medida em todas as vezes, como este livro fez. Depois meça o trabalho em si, com testes feitos para ele, antes de escolher um modelo para executá-lo: uma perplexidade menor é motivo para testar um modelo, não para colocá-lo em produção.
O que dá errado em produção
Um modelo ajustado é do tipo que as pessoas podem usar sem ajuda, e suas falhas soam tão fluentes quanto seus acertos:
- Ele responde quando deveria dizer que não sabe. Os modelos SmolLM2 base e ajustado inventaram um material para a maioria dos produtos cujos dados não citavam nenhum, e nenhum dos dois jamais disse que os dados não informavam isso. Verifique cada afirmação factual contra os dados do produto antes que ela chegue a um comprador.
- Sua confiança deixa passar erros. As respostas inventadas tiveram, em média, menos confiança, mas um limiar que manteve a maioria das boas respostas ainda deixou passar 3 of 11 respostas inventadas.
- Seu formato faz parte de seu treinamento. Sem o template de chat, o modelo ajustado escreveu um ponto final. Aplique o template dos arquivos do modelo e registre o prompt completo com cada resposta.
- O meio do contexto se perde. Coloque os detalhes que importam no início ou no fim, e teste a recuperação em cada posição.
- Ele não conhece o seu texto. O ajuste por instruções ensina a forma das respostas, não o catálogo de uma loja. Faça o ajuste fino com o catálogo e meça.
- A fluência esconde lacunas. As descrições do modelo ajustado são mais bem escritas que as do modelo base e não contêm mais fatos. Julgue o texto gerado por verificações de suas afirmações, não pela forma como ele lê.
- Seu comportamento depende de sua revisão e das mensagens padrão do template. Fixe a revisão do modelo, como faz a gravação, e repita estas medições após qualquer atualização.
O que este capítulo decidiu
- O livro compara modelos base e ajustados sobre as mesmas requests, registradas uma vez em revisões fixadas e decodificadas de forma gulosa, e mede suas respostas com verificações que qualquer pessoa pode executar novamente, como
lib.claimspara materiais. - Detalhes inventados são medidos em perguntas que a entrada não consegue responder, além das que consegue. Nos produtos da loja, ambos os modelos SmolLM2 inventaram um material para a maioria dos produtos cujos dados não informavam nenhum, e nenhum dos dois se recusou uma única vez; por isso, os fatos de produto gerados são sempre verificados contra os dados do produto.
- A confiança de um modelo é um sinal, não um filtro. Ela é usada somente com um limiar medido nas perguntas da própria loja, e os erros que ela deixa passar são contados.
- Os detalhes de que um modelo precisa ficam no início ou no fim do seu contexto, nunca escondidos no meio de outros produtos.
- A perplexidade continua sendo a referência do livro para comparar modelos, sobre o mesmo texto, o mesmo tokenizador e os mesmos eventos em todas as vezes, e a tarefa para a qual cada modelo é escolhido é medida com testes construídos para essa tarefa.
- Ensinar a um modelo geral o texto da loja significa ajuste fino, medido por palavra em relação ao modelo próprio da loja; o ajuste por instruções muda a forma como um modelo responde, não o que ele sabe. Medir um modelo dentro de uma aplicação, além dos testes de próximo token deste livro, é um assunto à parte.
Este capítulo, nesta edição
Edição 2026.11.16Exemplos aprovados em 19 de nov de 20269 de 9 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.16.