Dê um prompt a um modelo pequeno e restrinja suas respostas aos times

Cerca de 24 minutos min de leitura, com 5 exemplos em 7 seções.

Edição 2026.11.9 Exemplos aprovados em 20 de nov de 2026 36 de 36 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.9. Leia o original

Ao final deste capítulo, você será capaz de escrever um prompt de roteamento para um modelo aberto pequeno, restringir a resposta para que ela só possa ser o nome de um time e medir quantas dessas respostas estão certas. Você também verá por que uma resposta válida não é necessariamente uma resposta correta, e é por isso que o próximo capítulo treina um modelo em vez de pedir perguntas melhores a ele.

Um roteador precisa que toda resposta seja o nome de um time, e quando o capítulo 1 deixou um modelo pequeno responder em texto livre, o modelo não devolveu times. Este capítulo primeiro faz com que a resposta seja um time por construção. Em seguida, executa os dois modelos abertos do capítulo 3, SmolLM2-135M-Instruct e SmolLM2-360M-Instruct, com um prompt e uma restrição, e mede o que eles devolvem. O modelo de 135M é o que o capítulo 5 treina, então as contagens aqui são as que esse treinamento precisa superar.

Dois tipos de número aparecem, e o capítulo os mantém separados. Os exemplos ao vivo rodam sobre as primeiras six mensagens de test_40, as primeiras 40 mensagens da amostra fixa e as mesmas six para os dois modelos. Eles mostram o mecanismo. Six mensagens não bastam para separar dois modelos, então a comparação usa um registro: cada modelo e prompt respondeu uma vez às 200 mensagens de test_200, as primeiras 200 dessa amostra, que incluem aquelas six, e as respostas foram salvas. Ler o registro não carrega nenhum modelo, e suas contagens vêm apenas das respostas salvas e de mais nada.

O prompt, definido antes de qualquer registro

Última alteração na edição 2026.11.9

Todos os exemplos deste capítulo usam um único prompt de roteamento. Ele informa ao modelo que a mensagem vem de um banco online, pede uma equipe de suporte e somente o nome da equipe, lista as 77 equipes e termina com Team:, de modo que as próximas palavras do modelo sejam a resposta. Um modelo bruto, que não foi treinado para a tarefa, não recebe nada além disso, por isso a redação importa. Este capítulo não ajusta o prompt. Ele foi fixado antes de qualquer registro, e o manifesto do registro guarda o hash do prompt. Um prompt alterado é outro registro, e suas contagens não podem ser comparadas com as daqui.

A lista de equipes no prompt é a mesma lista usada pela restrição. A trie da próxima seção é construída a partir dos mesmos nomes de rótulo, na mesma ordem, de modo que o prompt e a restrição não podem divergir sobre quais equipes existem. A mesma dependência vale no sentido inverso. Um leitor que adicione ou renomeie uma equipe altera o prompt e, portanto, o hash do registro. As contagens deste capítulo deixam então de descrever esse prompt, e o leitor deve registrar novamente antes de comparar.

A forma bruta passa o texto do prompt de roteamento ao modelo exatamente como está. A forma de chat envolve o texto do prompt de roteamento no modelo de chat do modelo, que acrescenta um prompt de sistema padrão. Para ver o que o modelo de chat muda, execute a forma de chat nas mesmas seis mensagens:

constrained-decode-135m-chat.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Route the first 6 messages of test_40 with the 135M model through its chat template, decoding only team names.The template adds the model's default system prompt. The prose quotes this run's accuracy line next to the raw form's, and the messages are never printed."""import os# no network: the pinned model must already be in the local cacheos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import collections  # noqa: E402import torch  # noqa: E402# two threads, so the sums add in the same order on every runtorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, so greedy decoding repeatsrouter_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"tokenizer, model = router_lib.load_model(SMALL)trie = router_lib.build_trie(tokenizer)# (text, label index) for every test row, in file order; the index is the gold teamrows = router_lib.read_rows("test")# row numbers of the first six messages of the fixed 40-message samplesample = router_lib.read_sample("test_40", 6)teams = set(router_lib.LABELS)results = []for i in sample:    # the chat template wraps the message in the model's chat format, with its default system prompt    text = router_lib.chat_prompt(tokenizer, rows[i][0])    # the template has already written the special tokens, so the tokenizer adds none    results.append(router_lib.constrained_team_text(tokenizer, model, trie, text, add_special_tokens=False))valid = [text in teams for _, text in results]# the walk's index, never the decoded text, is what countsright = [index == rows[i][1] for (index, _), i in zip(results, sample)]given = collections.Counter(text for _, text in results)# most given team; a tie in count goes to the team listed firsttop = min(given, key=lambda team: (-given[team], router_lib.LABELS.index(team)))print(f"messages: {len(sample)}")print(f"answers that are a team: {sum(valid)}/{len(sample)}")print(f"accuracy: {sum(right)}/{len(sample)} ({100 * sum(right) / len(sample):.1f}%)")print(f"distinct teams given: {len(given)}")print(f"most given team: {top}, {given[top]}/{len(sample)}")
Saídapython constrained-decode-135m-chat.py
messages: 6
answers that are a team: 6/6
accuracy: 0/6 (0.0%)
distinct teams given: 3
most given team: cancel_transfer, 3/6

O livro usa a forma bruta como padrão. A escolha foi feita antes de qualquer registro ser lido: os dois modelos da comparação são medidos com ela, de modo que a comparação é entre modelos, não entre prompts. A forma de chat foi registrada depois, como observação. Nas 200 mensagens ela acertou 11/200 (5.5%), e a forma bruta acertou 9/200 (4.5%). Uma diferença de duas mensagens em 200 não é algo que esta amostra possa mostrar em nenhum sentido, portanto não se afirma que a forma de chat ajude, nem que a forma bruta prejudique, e o padrão não é alterado por causa dessa contagem. Os nomes da trie começam com um espaço, que segue Team: na forma bruta, mas não a quebra de linha que abre a resposta no modelo de chat. A contagem de chat vale, portanto, tanto para esta trie quanto para o modelo de chat. O resultado não é evidência de que prompts brutos superem modelos de chat para modelos pequenos em geral, e uma única amostra de 200 mensagens não resolve essa questão.

Regra prática: Use o mesmo prompt para todos os modelos que você comparar, na forma que a comparação exige. Antes de adotar um modelo de chat, meça-o na mesma amostra da forma bruta, e apresente uma diferença pequena como uma diferença pequena.

Por que o texto livre falha

O capítulo 1 pediu ao modelo bruto uma única equipe, sem nenhuma restrição, e o modelo decodificou livremente: de forma gulosa, escolhendo o token de maior pontuação a cada passo, como neste capítulo, mas sem máscara sobre os tokens que ele podia escolher. O exemplo dele contou as respostas. 0/20 eram nomes de equipe, então o roteador não tinha nada para encaminhar.

Nada na própria decodificação do modelo impede que uma resposta seja uma frase, uma equipe que não está na lista ou uma grafia quase correta de uma delas. A cada passo, o decodificador pode escolher qualquer token do vocabulário, então a resposta pode tomar qualquer rumo. O substituto do capítulo 1 não mostrou essa falha, porque as respostas registradas por ele vieram de uma gramática que permitia apenas os nomes de equipe. Um modelo que roda no roteador precisa da mesma garantia vinda do próprio decodificador.

O remendo tentador é pegar o que o modelo escreveu e associá-lo ao nome de equipe mais próximo. Esse remendo é um palpite. Uma grafia quase correta pode corresponder à equipe certa ou a uma equipe errada que seja parecida em letras, e o roteador enviaria a mensagem para uma equipe que o modelo nunca nomeou. O capítulo 1 disse o que fazer em vez disso: uma resposta que não é uma equipe conta como erro, é contabilizada na amostra, e a mensagem vai para uma pessoa. Uma restrição elimina a maior parte dessas respostas antes que elas sejam escritas. A contagem continua sendo feita, para que uma restrição que deixe de valer apareça como um número e não como uma mudança silenciosa no roteamento.

Regra prática: trate uma resposta que não é uma equipe como uma rota falha. Conte essas respostas em uma amostra fixa antes que um modelo roteie qualquer coisa, e não associe uma grafia quase correta à equipe mais próxima. Restrinja a resposta no momento da decodificação e mantenha a contagem, para que uma restrição quebrada apareça como um número.

Uma trie de tokens permite apenas nomes de equipes

Última alteração na edição 2026.11.9

Um modelo escreve tokens, não palavras, e o nome de uma equipe é uma sequência curta deles. build_trie em router_lib, o módulo compartilhado do livro, armazena os 77 nomes como uma trie: uma árvore cujos caminhos soletram os tokens de cada equipe, com o índice da equipe no nó onde o caminho termina. A função afirma que duas equipes terminam no mesmo nó, de modo que cada caminho nomeia uma equipe.

O decodificador percorre essa árvore enquanto escreve. No início, os tokens permitidos são o primeiro token de cada nome de equipe. Após cada token, o conjunto permitido se restringe aos filhos do nó que o decodificador alcançou. Quando um caminho terminou em uma equipe, o token de fim de resposta entra no conjunto permitido, de modo que a resposta possa parar ali. Nenhum dos 77 nomes é início de outro, portanto todo caminho termina em uma folha. O código ainda trataria um nome que fosse: nesse nó o decodificador poderia parar ou continuar pelo nome mais longo. Uma caminhada desse tipo não pode sair da lista, porque todo token que ela pode escolher leva a uma equipe.

A decodificação gulosa então escolhe, a cada passo, o token de maior pontuação entre os permitidos. O Transformers aplica a regra por meio de um callback, prefix_allowed_tokens_fn, que devolve os tokens permitidos para cada posição. O processador começa com uma máscara de menos infinito para todos os tokens, define as entradas dos tokens permitidos como zero e soma a máscara às pontuações com scores_processed = scores + mask. Todo token não permitido mantém menos infinito, de modo que a decodificação gulosa não pode escolhê-lo (transformers 5.23.0, src/transformers/generation/logits_process.py).

O substituto do Capítulo 1 obteve a mesma garantia de sua biblioteca. recordings/common.py constrói uma gramática, root ::= "card_arrival" | ..., que lista os 77 nomes como strings literais, e as gravações a aplicaram por meio do template de chat. O llama-cpp-python adiciona uma gramática ao seu amostrador antes da etapa gulosa. Em llama_cpp/llama.py, a linha sampler.add_grammar(self._model, grammar) é executada sob if grammar is not None:, e sampler.add_greedy() é executada depois dela, sob elif temp == 0.0: (llama-cpp-python v0.3.36, llama_cpp/llama.py). Assim, as respostas do substituto eram limitadas aos nomes pela biblioteca, enquanto o callback deste capítulo faz o mesmo trabalho no decodificador.

Dois detalhes desse código moldam o callback. O processador o chama como self._prefix_allowed_tokens_fn(batch_id, sent), de modo que o índice do lote vem primeiro. E uma lista vazia é um erro: o processador lança ValueError quando o callback não devolve tokens. O callback do livro, portanto, nunca devolve uma lista vazia. Quando nenhum caminho pode continuar, ele devolve o token de fim de resposta, e a resposta para ali. O token de fim de resposta é o <|im_end|> do modelo, que também é o seu token de preenchimento (id 2). O decodificador para após 32 novos tokens (max_new_tokens=32). Cada uma das 600 respostas gravadas terminou em uma equipe. Um nó sem filhos sempre contém uma equipe, e o caso de lista vazia é uma salvaguarda, não um caso que os 77 nomes produzam.

Primeiro, o modelo de 135M com a trie, nessas seis mensagens.

constrained-decode-135m.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Route the first 6 messages of test_40 with the 135M model, decoding only team names, and count how many right answers that gives.The point rests on the count of answers that are team names, which the trie guarantees, and on the accuracy line, which the measurement section reads. The messages are read from the test split and are never printed."""import os# no network: the pinned model must already be in the local cacheos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import collections  # noqa: E402import torch  # noqa: E402# two threads, so the sums add in the same order on every runtorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, so greedy decoding repeatsrouter_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"tokenizer, model = router_lib.load_model(SMALL)trie = router_lib.build_trie(tokenizer)# (text, label index) for every test row, in file order; the index is the gold teamrows = router_lib.read_rows("test")# row numbers of the first six messages of the fixed 40-message samplesample = router_lib.read_sample("test_40", 6)teams = set(router_lib.LABELS)# (label index, team text); the index comes from the trie walk, not from parsing the textresults = [router_lib.constrained_team(tokenizer, model, trie, rows[i][0]) for i in sample]valid = [text in teams for _, text in results]# the walk's index, never the decoded text, is what countsright = [index == rows[i][1] for (index, _), i in zip(results, sample)]given = collections.Counter(text for _, text in results)# most given team; a tie in count goes to the team listed firsttop = min(given, key=lambda team: (-given[team], router_lib.LABELS.index(team)))print(f"messages: {len(sample)}")print(f"answers that are a team: {sum(valid)}/{len(sample)}")print(f"accuracy: {sum(right)}/{len(sample)} ({100 * sum(right) / len(sample):.1f}%)")print(f"distinct teams given: {len(given)}")print(f"most given team: {top}, {given[top]}/{len(sample)}")
Saídapython constrained-decode-135m.py
messages: 6
answers that are a team: 6/6
accuracy: 1/6 (16.7%)
distinct teams given: 3
most given team: card_arrival, 4/6

Executado sobre 6 mensagens, as respostas do modelo são nomes de equipes em todos os casos, 6/6, que é a garantia que a trie oferece. A acurácia nas mesmas mensagens é 1/6 (16.7%). A seção de medição separa esse segundo número em partes.

O roteador não lê a equipe do texto. constrained_team devolve o índice armazenado no nó onde a caminhada terminou, e o texto é decodificado apenas para que um leitor possa vê-lo. O índice é fixado pela trie, e não por um analisador que roda após o modelo. Essa é a razão pela qual a restrição vale o código: um analisador que associa texto a equipes pode falhar de maneiras que a trie não falha. Estes exemplos devolvem a equipe apenas para que ela possa ser contada. Nada neste capítulo roteia uma mensagem. Uma rota devolve uma equipe apenas por meio de handoff, que envia uma resposta incerta a uma pessoa, e os exemplos aqui não o chamam.

Regra prática: Restrinja a resposta aos rótulos com uma trie de tokens construída a partir dos nomes dos rótulos, e conte as respostas que são rótulos em uma amostra fixa. A restrição faz de toda resposta uma equipe. Ela não torna nenhuma resposta correta, por isso conte as respostas corretas como uma medida separada.

Decodifique de forma gulosa para que cada contagem se repita

Última alteração na edição 2026.11.2

Todos os exemplos aqui usam decodificação gulosa: vence o maior escore, e nada é amostrado. Isso importa para as contagens. Uma resposta amostrada seria diferente de uma execução para outra, e então nenhuma contagem impressa poderia ser conferida com uma saída registrada. Os exemplos fixam suas sementes e o float32 por meio de router_lib.setup_runtime e definem dois threads, de modo que, em uma mesma máquina, uma execução repete suas respostas. Cada exemplo chama torch.set_num_threads(2) por conta própria, no início, para que não dependa de como o seu executor foi iniciado. A saída impressa de cada exemplo é comparada com a sua saída registrada em toda execução, e uma linha alterada faz a verificação falhar.

Repetível em uma mesma máquina não é o mesmo que repetível em qualquer lugar. As notas do PyTorch 2.15.0+cpu sobre aleatoriedade dizem que resultados totalmente reprodutíveis não são garantidos entre versões, commits individuais ou plataformas. Por isso, o livro afirma repetibilidade apenas para as versões fixadas em examples/requirements.txt, no tipo de máquina em que o livro foi executado. Um leitor em outra plataforma deve esperar ter de conferir de novo as linhas registradas. Se uma linha registrada falhar ali, leia a linha alterada antes de mexer no exemplo. Uma contagem diferente de respostas certas pode vir de outra máquina, de outra versão de biblioteca ou de um prompt alterado, e cada uma dessas causas exige uma correção diferente.

Empates também precisam de uma regra fixa. A pontuação de rótulos em a última seção desempata um empate de escore pelo índice menor da equipe, por meio de sua chave de ordenação (score, -index), e a contagem da equipe mais escolhida desempata um empate de contagem pelo nome da equipe. A decodificação restrita não tem escores de equipe. Seu passo guloso toma o primeiro máximo entre os tokens permitidos, de modo que um empate ali vai para o id de token menor.

Regra prática: Use decodificação gulosa, fixe as sementes e o número de threads, e compare cada linha impressa com uma cópia registrada em toda execução. Não descreva um resultado como reprodutível além das versões e do tipo de máquina em que foi executado.

Medir as respostas restritas

Última alteração na edição 2026.11.2

Os exemplos ao vivo cobrem seis mensagens. O modelo de 135M com o prompt cru acertou 1/6 (16.7%), e o modelo de 360M acertou 0/6 (0.0%). Seis mensagens não bastam para ordenar esses modelos: uma única resposta certa é toda a diferença entre essas duas contagens. A resposta mais frequente do modelo de 135M foi card_arrival, 4/6, e a forma de chat nas mesmas seis mensagens acertou 0/6 (0.0%).

A execução com o modelo de 360M é o mesmo programa com o modelo maior.

constrained-decode-360m.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Decode team names for the first 6 messages of test_40 with the 360M model, and count how many of them are right.The prose sets its accuracy line against the 135M model's, on the same six messages. The messages are read from the test split and are never printed."""import os# no network: the pinned model must already be in the local cacheos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import collections  # noqa: E402import torch  # noqa: E402# two threads, so the sums add in the same order on every runtorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, so greedy decoding repeatsrouter_lib.setup_runtime()MEDIUM = "HuggingFaceTB/SmolLM2-360M-Instruct"tokenizer, model = router_lib.load_model(MEDIUM)trie = router_lib.build_trie(tokenizer)# (text, label index) for every test row, in file order; the index is the gold teamrows = router_lib.read_rows("test")# row numbers of the first six messages of the fixed 40-message samplesample = router_lib.read_sample("test_40", 6)teams = set(router_lib.LABELS)# (label index, team text); the index comes from the trie walk, not from parsing the textresults = [router_lib.constrained_team(tokenizer, model, trie, rows[i][0]) for i in sample]valid = [text in teams for _, text in results]# the walk's index, never the decoded text, is what countsright = [index == rows[i][1] for (index, _), i in zip(results, sample)]given = collections.Counter(text for _, text in results)# most given team; a tie in count goes to the team listed firsttop = min(given, key=lambda team: (-given[team], router_lib.LABELS.index(team)))print(f"messages: {len(sample)}")print(f"answers that are a team: {sum(valid)}/{len(sample)}")print(f"accuracy: {sum(right)}/{len(sample)} ({100 * sum(right) / len(sample):.1f}%)")print(f"distinct teams given: {len(given)}")print(f"most given team: {top}, {given[top]}/{len(sample)}")
Saídapython constrained-decode-360m.py
messages: 6
answers that are a team: 6/6
accuracy: 0/6 (0.0%)
distinct teams given: 4
most given team: card_payment_wrong_exchange_rate, 3/6

Para a comparação, cada variante respondeu 200 mensagens. As contagens da gravação estão na tabela, com as mesmas mensagens em todas as linhas:

Variante em test_200 Respostas fora da lista de equipes Corretas Equipes distintas indicadas
135M, prompt cru 0/200 9/200 (4.5%) 18
135M, template de chat 0/200 11/200 (5.5%) 17
360M, prompt cru 0/200 12/200 (6.0%) 8

Este exemplo lê as contagens da tabela a partir da gravação:

prompting-on-test-200.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Aprovado
"""Compare the three prompting variants on test_200, from the recording only. No model is loaded.The chapter's table takes its three columns from the first three lines printed for each variant, and the point rests on the correct count.recordings/prompting_eval.py wrote one answer per variant and message to examples/data/recorded/prompting-eval/answers.jsonl."""import collectionsimport jsonfrom pathlib import Pathimport torch# two threads, as in the other examplestorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, as in the other examplesrouter_lib.setup_runtime()ANSWERS = Path(__file__).resolve().parent / "data" / "recorded" / "prompting-eval" / "answers.jsonl"teams = set(router_lib.LABELS)# (text, label index) for every test row, in file order; the index is the gold teamrows = router_lib.read_rows("test")# the 200 messages of the fixed sample; every variant answers all of themtotal = len(router_lib.read_sample("test_200"))by_variant = collections.defaultdict(list)with open(ANSWERS) as f:    for line in f:        answer = json.loads(line)        by_variant[answer["variant"]].append(answer)for variant in sorted(by_variant):    answers = by_variant[variant]    outside = sum(answer["team"] not in teams for answer in answers)    # answer["label"] is the team index the variant chose; rows[...][1] is the message's gold index    right = sum(answer["label"] == rows[answer["index"]][1] for answer in answers)    given = collections.Counter(answer["team"] for answer in answers)    # most given team; a tie in count goes to the team name that sorts first, not to the index    top = min(given, key=lambda team: (-given[team], team))    # the gold index becomes a team name, to compare with the most given team    gold_top = sum(router_lib.LABELS[rows[answer["index"]][1]] == top for answer in answers)    print(f"{variant} answers outside the team list: {outside}/{total}")    print(f"{variant} correct: {right}/{total} ({100 * right / total:.1f}%)")    print(f"{variant} distinct teams given: {len(given)}")    print(f"{variant} most given team: {top}, {given[top]}/{total}")    print(f"{variant} gold for most given team: {gold_top}/{total}")
Saídapython prompting-on-test-200.py
135m-chat answers outside the team list: 0/200
135m-chat correct: 11/200 (5.5%)
135m-chat distinct teams given: 17
135m-chat most given team: topping_up_by_card, 55/200
135m-chat gold for most given team: 1/200
135m-raw answers outside the team list: 0/200
135m-raw correct: 9/200 (4.5%)
135m-raw distinct teams given: 18
135m-raw most given team: card_arrival, 165/200
135m-raw gold for most given team: 0/200
360m-raw answers outside the team list: 0/200
360m-raw correct: 12/200 (6.0%)
360m-raw distinct teams given: 8
360m-raw most given team: card_payment_wrong_exchange_rate, 94/200
360m-raw gold for most given team: 4/200

Nenhuma linha se aproxima de um roteador, embora a restrição valha em todas elas: nenhuma resposta de nenhuma linha está fora da lista de equipes. A linha de 360M com prompt cru tem o maior número de respostas corretas, 12/200 (6.0%), e nenhuma linha supera outra por mais de algumas mensagens.

Equipes distintas, sozinhas, enganam. A linha de 135M com prompt cru indica 18 equipes distintas, contra 8 da linha de 360M com prompt cru, mas a maior parte das respostas da linha de 135M vai para uma única equipe, card_arrival, 165/200, enquanto a equipe mais indicada na linha de 360M com prompt cru recebe apenas card_payment_wrong_exchange_rate, 94/200.

Para ler uma linha, comece pela primeira coluna. Se ela não for zero, a restrição não se sustentou, e as outras duas colunas não significam nada até que isso seja corrigido. A segunda coluna é a que importa para o roteamento: ela conta as mensagens cuja equipe é o rótulo correto, em relação à amostra inteira, com as respostas erradas contadas como erradas. A terceira coluna indica quantas equipes a variante usa, no total. Uma variante que indica apenas algumas equipes ou está chutando algumas equipes populares ou aprendeu algo restrito, e a contagem não diz qual dos dois. Uma contagem alta também não descarta a concentração, como mostra a linha de 135M com prompt cru. Quem executar as mesmas três contagens em uma amostra das suas próprias mensagens obtém uma comparação com os seus dados, com o mesmo significado em cada coluna.

O modelo de 360M é o maior dos dois, e o capítulo 3 contou o quanto ele é maior. A tabela mostra o que esse custo compra com este prompt e esta restrição: 12/200 (6.0%) corretas, contra 9/200 (4.5%) do modelo de 135M na mesma forma crua. São algumas mensagens a mais para um modelo maior, e o capítulo não considera isso uma razão para pagar pelo tamanho extra.

O livro não calcula intervalo para essas contagens, e uma diferença de algumas mensagens em 200 pode vir da amostra; por isso, a tabela sustenta uma única afirmação: as três variantes são próximas, e nenhuma delas é um roteador. Quem quiser escolher entre dois prompts deve executar os dois em uma amostra das suas próprias mensagens e contar as mesmas três coisas.

A trie verifica a forma da resposta e nada além disso. Ela não lê a mensagem além do prompt e não sabe qual equipe está certa. Qualquer equipe que esteja na lista é permitida em cada passo em que o seu nome ainda possa ser escrito; portanto, a escolha do decodificador entre elas é a escolha do modelo, e a máscara apenas decide quais equipes podem ser escritas.

Eis uma resposta válida e errada, descrita apenas pelas equipes, já que as mensagens nunca são citadas neste livro. Uma mensagem de teste cuja equipe correta é card_not_working recebeu card_arrival da linha de 135M com prompt cru, uma equipe da lista; por isso, a restrição a deixou passar, e a contagem de respostas fora da lista continua em zero.

A lição que os resultados sustentam é que a decodificação restrita faz com que toda resposta seja uma equipe, mas uma resposta válida não é uma resposta certa. A restrição apenas remove respostas que não são equipes. Ela não escolhe uma equipe melhor, e a mudança de prompt também não. O capítulo 5 é o próximo passo: ele treina uma camada de saída (head) com as mensagens rotuladas e mede se o modelo treinado roteia melhor na mesma amostra.

Em produção, a falha não aparece como erro. A contagem de respostas que não são equipes continua em zero, então uma verificação que observa apenas essa contagem permanece verde. Só uma contagem de respostas corretas em uma amostra fixa e rotulada revela o problema.

O custo recai sobre as pessoas que recebem a mensagem. Uma equipe válida e errada envia a mensagem para o destino errado, onde os profissionais de suporte veem uma solicitação que não é deles e precisam encontrar a equipe certa e transferi-la, o que é o mesmo trabalho que um repasse cria, sem nenhum sinal na mensagem de que ela foi roteada de forma errada. Um roteador que não consegue dizer quando está em dúvida não oferece a essas pessoas nada em que agir. A decodificação restrita também não devolve pontuação para as outras 76 equipes; por isso, uma regra de repasse construída sobre ela não teria pontuações por equipe para comparar.

Regra prática: Informe a contagem de respostas corretas ao lado da contagem de respostas válidas, em uma mesma amostra fixa, para cada variante que você comparar. Um roteador cujas respostas são todas válidas ainda pode errar na maioria das mensagens, e só a segunda contagem mostra isso.

Por que um prior não é um roteador

Última alteração na edição 2026.11.9

A decodificação restrita devolve uma resposta e nenhuma pontuação. A pontuação por rótulos dá a cada time uma pontuação. Para cada time, a pontuação por rótulos soma a log-probabilidade dos tokens do time depois do prompt, em que a log-probabilidade é o logaritmo da probabilidade que o modelo atribui a um token. O time com maior soma é o time principal do modelo para a mensagem.

Rode-a em três mensagens e leia o time principal de cada uma:

label-scoring-prior.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Score every team for the first 3 messages of test_40 with the 135M model, by the summed log-probability of its tokens.This shows the model's prior, the team it favours before any fine-tuning. The point rests on the most frequent top team and how many messages it tops. The messages are never printed."""import os# no network: the pinned model must already be in the local cacheos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import collections  # noqa: E402import torch  # noqa: E402# two threads, so the sums add in the same order on every runtorch.set_num_threads(2)import router_lib  # noqa: E402# seeds 0 for random and torch, deterministic algorithms and float32, so greedy decoding repeatsrouter_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"tokenizer, model = router_lib.load_model(SMALL)rows = router_lib.read_rows("test")# row numbers of the first three messages of the fixed 40-message samplesample = router_lib.read_sample("test_40", 3)# each team's token ids, padded to the longest name, built once for all messagestable = router_lib.label_token_table(tokenizer)tops = []for i in sample:    scores = router_lib.label_scores(tokenizer, model, table, rows[i][0])    # index of the highest-scoring team; a tie goes to the lower index    tops.append(max(range(len(scores)), key=lambda k: (scores[k], -k)))counts = collections.Counter(tops)# most frequent top team; a tie in count goes to the lower indexbest = min(counts, key=lambda k: (-counts[k], k))print(f"messages: {len(sample)}")print(f"distinct top teams: {len(counts)}")print(f"most frequent top team name: {router_lib.LABELS[best]}")print(f"most frequent top team: {counts[best]} of {len(sample)}")
Saídapython label-scoring-prior.py
messages: 3
distinct top teams: 1
most frequent top team name: card_arrival
most frequent top team: 3 of 3

Antes de qualquer treinamento, o modelo coloca um mesmo time em primeiro lugar para todas as mensagens: card_arrival lidera 3 of 3 mensagens. Esse time é o prior do modelo, e três mensagens são poucas para dizer mais sobre ele.

Se o time principal é o mesmo para todas as mensagens, a pontuação é o prior do modelo e diz pouco sobre qualquer mensagem específica. A gravação de 200 mensagens mostra o mesmo prior na decodificação restrita: card_arrival, 165/200, o time favorito da linha 135M raw, é o time gold de 0/200 mensagens da amostra.

A soma favorece nomes curtos. Cada token do nome de um time acrescenta uma log-probabilidade, que nunca é maior que zero, de modo que um time com mais tokens tem mais termos para puxar seu total para baixo. O exemplo soma os termos sem dividir pelo comprimento, e o capítulo não afirma corrigir isso. Quem usa a pontuação por rótulos deve conferir os times principais contra uma amostra com rótulos gold antes de confiar neles.

A pontuação por rótulos dá, de fato, uma pontuação para cada time, que é o que uma regra de transferência precisa. Cada mensagem é pontuada contra todos os 77 nomes de times, que o código pontua em um só lote depois que o prompt roda uma vez. O capítulo 5 obtém uma pontuação para cada time a partir de uma única passagem direta por uma cabeça treinada com mensagens rotuladas. A pontuação por rótulos é a ponte deste capítulo até aquele: ela mostra que o modelo já tem pontuações por time, e que, antes do treinamento, elas dizem pouco sobre a mensagem.

Regra prática: Use a pontuação por rótulos para ver qual time um modelo favorece antes do treinamento, e não para rotear. Não roteie mensagens com um modelo com prompt deste tamanho nesta tarefa; a gravação de 200 mensagens é a evidência. Treine uma cabeça com as mensagens rotuladas, como faz o capítulo 5.

O que este capítulo decidiu

Última alteração na edição 2026.11.2

As regras deste capítulo se limitam a estes dois modelos, este prompt e esta restrição, sobre as 200 mensagens da gravação. Um modelo maior, um prompt diferente ou uma amostra mais longa podem alterar as contagens, e o livro não testou nenhum deles nessa amostra. O que o capítulo estabelece é mais restrito: com o prompt bruto e a trie, um modelo deste porte devolve equipes válidas e poucas respostas certas, e a contagem de respostas certas é o número que você deve acompanhar.

Cada decisão é testada em sua própria seção: o prompt na primeira, a trie em sua seção e a decodificação gulosa em sua seção, e as duas contagens na seção de medição. Quem alterar qualquer uma delas deve registrar novamente os resultados antes de comparar, como diz a primeira seção. Uma restrição torna válida toda resposta, e somente o treinamento pode torná-la correta.

Este capítulo tomou estas decisões:

  • O prompt do roteador é a forma bruta, e os dois modelos da comparação o utilizam.
  • A decodificação restrita usa uma trie de tokens sobre os 77 nomes de equipes, com decodificação gulosa e sementes fixas.
  • Cada variante é relatada com sua contagem de respostas válidas e sua contagem de respostas certas, sobre uma mesma amostra fixa.
  • Os exemplos ao vivo mostram como cada parte funciona, e somente a gravação de 200 mensagens compara modelos.

Este capítulo, nesta edição

Edição 2026.11.9Exemplos aprovados em 20 de nov de 20265 de 5 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.9.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 4 de 10: Dê um prompt a um modelo pequeno e restrinja suas respostas aos times

  1. O prompt, definido antes de qualquer registro
  2. Por que o texto livre falha
  3. Uma trie de tokens permite apenas nomes de equipes
  4. Decodifique de forma gulosa para que cada contagem se repita
  5. Medir as respostas restritas
  6. Por que um prior não é um roteador
  7. O que este capítulo decidiu

Voltar ao topoTodos os capítulos