Construa um roteador para a caixa de entrada do banco que transfere quando estiver em dúvida

Cerca de 23 minutos min de leitura, com 4 exemplos em 6 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 construir um roteador que devolve uma equipe, uma confiança e um sinal de transferência para uma mensagem, avaliá-lo em uma amostra fixa por três medidas e entender por que um modelo pequeno não treinado, usado com o prompt como está, não pode ser a primeira versão do roteador.

As mensagens de clientes enviadas a um banco caem em uma única fila de atendimento, que este livro chama de caixa de entrada. Um roteador envia cada mensagem da caixa de entrada para uma de 77 equipes. Um roteador que escolhe uma equipe para cada mensagem às vezes escolherá a errada. Uma equipe errada custa tempo ao cliente e custa à equipe de atendimento uma etapa para repassar a mensagem. Este capítulo constrói um roteador que diz quando não tem certeza.

Uma equipe é um rótulo que o roteador pode devolver, como card_arrival, e nunca um grupo de pessoas. As pessoas que leem as mensagens são a equipe de atendimento do banco, e uma mensagem que o roteador não consegue encaminhar vai para uma dessas pessoas.

As mensagens e suas equipes vêm do BANKING77, um conjunto de dados público de mensagens de clientes a um banco, publicado sob CC BY 4.0. O BANKING77 chama cada rótulo de intenção. A partir daqui este livro o chama de equipe, e os rótulos são escritos como aparecem no conjunto de dados.

O roteador é o sistema inteiro: um modelo, um prompt, um limiar e o código que encaminha a mensagem. Este capítulo constrói um roteador rudimentar. Um roteador é rudimentar quando seu limiar é provisório e seu modelo é um substituto, e este é um roteador funcional porque devolve uma resposta para cada mensagem e pode ser avaliado em cada saída.

Você precisa de Python e de uma chamada à API de um modelo hospedado, que você talvez já tenha escrito. Este capítulo não exige que você conheça como um transformador funciona por dentro. Quando um detalhe interno importa, ele ganha uma frase de explicação.

Dois elementos compartilhados vêm primeiro. O primeiro é uma gravação das respostas de um modelo substituto às mensagens de teste, apresentada em a seção sobre pedir ao modelo. A maioria dos exemplos lê essas respostas offline, e um deles executa um modelo pequeno ao vivo, na seção que mostra sua falha. O segundo é router_lib, um módulo compartilhado na pasta examples do livro. Ele contém os rótulos das equipes, o prompt do roteador, a regra de transferência e as medidas. Todos os exemplos o importam, de modo que uma função significa a mesma coisa em todos os capítulos.

O que o roteador devolve

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

Para uma mensagem, o roteador devolve três coisas. A equipe é um dos rótulos, escrito como o próprio rótulo. A confiança é um número de zero a um que indica o quanto o roteador está seguro dessa equipe. A sinalização de transferência é verdadeira quando a confiança é baixa demais para encaminhar a mensagem, e uma pessoa fica com a mensagem.

Neste capítulo, a confiança tem um sentido restrito. É a probabilidade que o llama-cpp-python devolve para a resposta restringida, e a gravação a guarda como uma log-probabilidade. Em termos simples, é o quanto de probabilidade o modelo atribui à equipe que escreveu. Em forma de fórmula, confiança = exp(soma de log p(token)), o produto das probabilidades dos tokens da resposta. Um token é um pedaço de texto que o modelo lê e escreve. Isso não é um softmax sobre as equipes, que o capítulo 5 usa. É uma pontuação, não uma probabilidade calibrada, e nada neste capítulo mostra que uma confiança de determinado valor corresponde à frequência com que a equipe acerta. O capítulo 5 verifica a calibração no conjunto de desenvolvimento, as mensagens de treino reservadas para escolher as configurações (capítulo 2): ele agrupa as mensagens em faixas de confiança e mostra a contagem e a precisão de cada faixa.

Saída O que é O que a utiliza
Equipe Um rótulo do conjunto bancário O destino para onde a mensagem é enviada, quando a sinalização é falsa
Confiança A probabilidade que o llama-cpp-python devolve para a resposta restringida, como pontuação A regra de transferência
Sinalização de transferência Verdadeira quando a confiança está abaixo do limiar A pessoa que fica com a mensagem

A sinalização é o que mais importa, e o motivo é operacional. Um roteador que sempre devolve uma equipe envia toda mensagem a algum lugar, inclusive as mensagens que ele não tem base para rotear. Uma transferência entrega a mensagem a uma pessoa que pode roteá-la, e um roteador que indica quando está em dúvida torna visível o trabalho dessa pessoa. Recomendamos que todo roteador devolva a sinalização em cada resposta, verdadeira ou falsa, para que cada medida nas seções abaixo possa ser calculada apenas a partir da saída.

Deixar o roteador indicar quando está em dúvida tem nome na literatura de pesquisa: classificação seletiva, ou a opção de rejeição. O preprint de Geifman e El-Yaniv de 2017 sobre redes profundas descreve essa troca. Um classificador que recusa algumas entradas cobre menos delas, e as técnicas podem, potencial e significativamente, melhorar as previsões de uma rede profunda nas entradas que mantém, ao abrir mão de cobertura. O método deles também permite que o usuário defina um nível-alvo de risco. A regra de transferência deste livro não faz isso. Ela escolhe um limiar em dados reservados e não oferece nenhuma garantia sobre o risco que permanece.

As medições deste capítulo devolvem equipes apenas para serem avaliadas. O exemplo de uma mensagem, em a seção de transferência, devolve uma equipe somente quando a sinalização é falsa.

Regra prática: Devolva a sinalização junto de cada equipe, e envie a mensagem a uma pessoa sempre que a sinalização for verdadeira. Devolva a equipe ao chamador somente quando a sinalização for falsa. Mantenha a sinalização mesmo quando removê-la fizer um roteador parecer mais completo, porque a medida de transferência a leva em conta.

Peça a um modelo uma equipe

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

A equipe do roteador vem de um modelo, e o modelo é guiado por um prompt. O prompt é a parte do roteador que o banco mais altera, por isso o fixamos em um só lugar. router_prompt monta um prompt para uma mensagem. O prompt pede uma equipe e entrega ao modelo o nome de todas as equipes, a mensagem e a palavra Team: no final, para que o modelo a complete. Ele contém apenas os nomes das equipes e a única mensagem que está sendo roteada, nada mais, de modo que nenhuma outra mensagem da amostra chega ao modelo junto com ela.

Toda execução ao vivo e toda gravação usa o mesmo texto de prompt, vindo de router_lib.router_prompt, de modo que as palavras são as mesmas em todas as execuções. O que o modelo lê nem sempre é o mesmo. A gravação envolve essas palavras no template de chat do substituto, e a execução ao vivo na seção sobre um modelo pequeno entrega ao modelo pequeno o texto puro, sem template. Um prompt alterado é outra gravação, então suas pontuações não podem ser comparadas com as antigas. O prompt faz parte da versão do roteador, e quem o alterar deve registrar a mudança, da mesma forma que o livro registra a troca de modelo.

O banco é o único nome que este livro usa para a organização. O roteador do próprio banco é um modelo hospedado, que ele chama para cada mensagem. Não temos acesso a ele, e este livro nunca chama um modelo hospedado. No lugar dele usamos o substituto, Qwen3-4B-Instruct-2507, um modelo aberto maior, e todos os roteadores do livro são medidos contra as respostas do substituto. O modelo hospedado de um leitor responderá algumas mensagens de forma diferente, e por essa razão terá pontuação diferente.

Escolhemos o substituto porque qualquer pessoa pode reproduzir as respostas dele. A licença é Apache-2.0, como declara o cartão do modelo do repositório GGUF para o arquivo na revisão que este livro fixa. O arquivo é Qwen3-4B-Instruct-2507-Q4_K_M.gguf, uma versão quantizada que a biblioteca llama-cpp-python executa em uma CPU. O manifesto de gravação dele registra o SHA-256 do arquivo, de modo que um leitor que baixar o arquivo pode conferi-lo antes de executar qualquer coisa.

O substituto respondeu a cada mensagem de test_1001, uma amostra fixa de 1,001 mensagens de teste, uma única vez, e test_40 são as primeiras 40 mensagens dela. A gravação usou decodificação gulosa, que escolhe o token mais provável em cada passo, e uma semente fixa. Também usou uma gramática que permitia apenas os nomes das equipes, de modo que toda resposta gravada é um dos 77 rótulos. Essa gramática é o motivo de as respostas gravadas serem sempre nomes de equipes. O capítulo 4 explica isso, já que é a mesma ideia que corrige a falha na seção sobre um modelo pequeno.

Quem tiver um modelo próprio pode gravar as respostas dele do mesmo modo. Você escreve uma função, call_model. Ela recebe uma mensagem e devolve a equipe e a log-probabilidade da resposta, que é a soma das log-probabilidades dos tokens da resposta, da forma como a gravação do substituto a armazena. A função record_answers chama essa função para cada mensagem da amostra, escreve uma linha por mensagem no formato do substituto e lança um erro se a função devolver um nome que não seja uma das equipes. Todo o resto é igual para todos os modelos, de modo que duas gravações sobre a mesma amostra podem ser comparadas linha a linha.

record-your-own-answers.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Aprovado
"""Write a model's team answers in the stand-in's JSONL shape, then check record_answers against the stand-in's recording.The line to read is the last one printed, which counts the lines that match the recording. The stand-in here replaysthat recording, so no model runs."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import json  # noqa: E402import tempfile  # noqa: E402import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()def record_answers(call_model, messages, path):    """Write one JSONL line per (index, text); call_model(text) returns (team, logprob)."""    with open(path, "w") as out:        for index, text in messages:            team, logprob = call_model(text)            if team not in router_lib.LABELS:                raise ValueError("the model returned a name that is not a team")            label = router_lib.LABELS.index(team)  # stored as the label, the same encoding as the gold labels            row = {"index": index, "label": label, "team": team, "logprob": logprob}            out.write(json.dumps(row) + "\n")RECORDING = router_lib.HERE / "data" / "recorded" / "standin-baseline" / "answers.jsonl"rows = router_lib.read_rows("test")  # each row is (text, gold label)sample = router_lib.read_sample("test_40")messages = [(i, rows[i][0]) for i in sample]  # element 0 of a row is its text, which the model readswith open(RECORDING) as f:    recording_lines = f.read().splitlines()recorded = {json.loads(line)["index"]: json.loads(line) for line in recording_lines}  # keyed by message indexby_text = {rows[i][0]: (recorded[i]["team"], recorded[i]["logprob"]) for i in sample}  # keyed by text, not indexdef standin(text):    """Stand in for a model: return the recorded team and logprob for this message."""    return by_text[text]with tempfile.TemporaryDirectory() as folder:    path = os.path.join(folder, "answers.jsonl")    record_answers(standin, messages, path)    with open(path) as f:        written = f.read().splitlines()matching = sum(line in recording_lines for line in written)  # a line matches when it equals a recorded line exactlyprint(f"messages written: {len(written)}")print(f"lines matching the recording: {matching}/{len(written)}")
Saídapython record-your-own-answers.py
messages written: 40
lines matching the recording: 40/40

Antes de confiar na sua própria gravação, confira record_answers com as respostas do substituto. Aqui a função do substituto reproduz a gravação, então a verificação testa record_answers e não um modelo. Cada linha que ela escreve coincide com a gravação, todas as 40 delas. Quando você trocar essa função por uma chamada ao seu próprio modelo, a mesma verificação mostra se a sua gravação tem o mesmo formato da gravação do substituto.

Regra prática: Avalie todo modelo sobre a mesma amostra fixa, e registre as respostas dele com record_answers antes de compará-lo com o substituto. Informe qual amostra sustenta cada pontuação, e coloque duas pontuações lado a lado somente quando suas amostras coincidirem.

Encaminhe as mensagens incertas

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

As respostas do stand-in atribuem a cada mensagem uma confiança, e esta seção transforma essa confiança na sinalização de encaminhamento.

A regra de transferência é uma única comparação. handoff(confidence, threshold) retorna verdadeiro quando a confiança está abaixo do limiar, e falso quando ela é igual ao limiar ou superior a ele. Uma mensagem transferida vai para uma pessoa. Uma mensagem não transferida vai para a equipe indicada pelo roteador. Toda rota deste livro que devolve uma equipe a quem chama usa esta função, de modo que nenhum chamador pode receber uma equipe sem que a decisão tenha sido tomada.

A regra é simples de ler, e o trabalho está em escolher o número. Este capítulo usa um limiar provisório, 0.5, e toda saída que o utiliza informa isso. Um limiar provisório não tem uma regra por trás: é um número que permite que a regra funcione.

O capítulo 5 escolhe o limiar na partição de desenvolvimento, por uma regra ali enunciada. Ele registra o valor escolhido no manifesto do adaptador, para que você veja qual limiar um resultado usou e em que base ele foi escolhido. A amostra de teste nunca é usada para escolhê-lo. Até lá, o valor provisório é o único limiar que este capítulo tem, e seus resultados servem para ensinar as medidas, não para julgar o roteador.

A taxa de encaminhamento é a parcela das mensagens que vão para uma pessoa, e ela varia com o limiar. Ao elevar o limiar, mais mensagens vão para pessoas; ao baixá-lo, mais seguem diretamente para uma equipe. Essa troca é o motivo de a escolha ser feita por medição. O capítulo 5 mostra essa troca na partição de desenvolvimento, em mais de uma configuração, antes de escolher uma.

route-one-message.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Aprovado
"""Route the first message of test_40 from the stand-in's recorded answer, at the placeholder threshold.The prose reads the printed team and the hand-off line. No model runs here, and the message's text is never printed."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import json  # noqa: E402import math  # noqa: E402import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()THRESHOLD = 0.5  # Placeholder. Chapter 5 chooses the threshold on the dev split.RECORDING = router_lib.HERE / "data" / "recorded" / "standin-baseline" / "answers.jsonl"def route(row):    """Return (team, confidence, handed off) for one recorded answer. The team is None when handed off."""    confidence = math.exp(row["logprob"])  # the recording stores a log-probability; exp gives a probability    flag = router_lib.handoff(confidence, THRESHOLD)  # True below THRESHOLD, and for a NaN; equal to THRESHOLD is kept    return (None if flag else row["team"]), confidence, flagwith open(RECORDING) as f:    recorded = {r["index"]: r for r in map(json.loads, f)}  # keyed by message index, as the sample lists themfirst = router_lib.read_sample("test_40")[0]  # the first of the sample's 40 message indexesteam, confidence, flag = route(recorded[first])assert not flag  # the prose states this message is kept; a change that hands it off fails the runprint(f"team: {team or 'none (handed off)'}")print(f"confidence: {confidence:.2f}")print(f"handed off: {'yes' if flag else 'no'}")
Saídapython route-one-message.py
team: top_up_reverted
confidence: 1.00
handed off: no

Acompanhe uma mensagem por toda a rota, desde a resposta registrada até uma equipe impressa. O exemplo pega a primeira mensagem de test_40, lê a resposta registrada do stand-in para ela e a encaminha por handoff no limiar provisório. Ele imprime a equipe, a confiança arredondada para duas casas decimais e se a mensagem foi encaminhada, e nunca imprime o texto da mensagem. A confiança desta mensagem é 1.00, que atinge o limiar provisório, de modo que o roteador mantém a mensagem e devolve a sua equipe, top_up_reverted. O script afirma que a mensagem não é encaminhada. Uma única mensagem mostra a forma da saída. Ela não pode mostrar com que frequência o roteador acerta.

Regra prática: Escolha o limiar na partição de desenvolvimento, nunca na amostra de teste, e informe a taxa de encaminhamento ao lado da acurácia sempre. Enquanto o limiar for provisório, diga isso em cada saída, e deixe a sua acurácia fora de qualquer afirmação sobre o resultado do roteador.

Avalie o roteador em uma amostra fixa

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

Um roteador é avaliado com mensagens cuja equipe já é conhecida. Este capítulo usa test_40, uma amostra fixa de 40 mensagens de teste, para que todo leitor avalie as mesmas mensagens na mesma ordem. O capítulo 2 explica como as amostras foram extraídas, qual divisão é usada para escolher as configurações e por que a amostra de teste fica fora dessa escolha. Os números abaixo descrevem apenas esta amostra.

O roteador é medido por três números, e cada um traz a sua contagem ao lado.

  • Acurácia é o número de mensagens cuja equipe é igual ao rótulo de referência, dividido pelo total de mensagens da amostra. Uma mensagem encaminhada para atendimento humano conta no denominador, e é um erro se a equipe estiver errada.
  • Taxa de encaminhamento é o número de mensagens cuja confiança está abaixo do limite, dividido pelo total de mensagens.
  • Acurácia nas mensagens não encaminhadas é o número de mensagens corretas entre as que o roteador mantém, dividido pelo número de mensagens que ele mantém. Ela é informada como não definida quando o roteador não mantém nenhuma.

Cada medida responde a uma pergunta diferente. A acurácia pergunta com que frequência o roteador acerta no conjunto. A taxa de encaminhamento pergunta que parcela do trabalho vai para pessoas. A acurácia nas mensagens mantidas pergunta se as mensagens que o roteador mantém podem seguir diretamente para uma equipe. A acurácia sozinha não separa os dois tipos de erro. Uma equipe errada que foi encaminhada para atendimento humano pesa contra a acurácia, e também pesa uma equipe errada que chegou a uma equipe sem verificação. Só a terceira medida isola o segundo tipo, e esse é o tipo que a equipe de atendimento sente diretamente.

route-recorded-answers.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Aprovado
"""Score the stand-in's recorded answers on test_40, with a placeholder hand-off threshold.The last printed line, accuracy on messages not handed off, is the one the prose reads against the others: it is theaccuracy of the messages a team receives. No model runs here, and the answers come from the recording."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import json  # noqa: E402import math  # noqa: E402import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()THRESHOLD = 0.5  # Placeholder. Chapter 5 chooses the threshold on the dev split.RECORDING = router_lib.HERE / "data" / "recorded" / "standin-baseline" / "answers.jsonl"answers = {}with open(RECORDING) as f:    for line in f:        row = json.loads(line)        answers[row["index"]] = rowrows = router_lib.read_rows("test")sample = router_lib.read_sample("test_40")golds = [rows[i][1] for i in sample]  # element 1 of a test row is its gold label; element 0 is its textpreds = [answers[i]["label"] for i in sample]  # the recorded label is the team's position in LABELS, as the gold isconfs = [math.exp(answers[i]["logprob"]) for i in sample]  # exp turns each recorded log-probability into a confidence# metrics applies the hand-off rule at THRESHOLD; accuracy's denominator still includes handed-off messagesresult = router_lib.metrics(preds, golds, confs, THRESHOLD)n = result["n"]print(f"messages: {n}")print(f"placeholder threshold: {THRESHOLD}")print(f"accuracy: {result['correct']}/{n} ({result['accuracy']:.1%})")print(f"handed off: {result['handed_off']}/{n} ({result['handoff_rate']:.1%})")if result["accuracy_not_handed_off"] is None:  # None when the router keeps no message, so the measure is undefined    print("accuracy on messages not handed off: not defined (0 messages not handed off)")else:    m = result["not_handed_off"]    print(        f"accuracy on messages not handed off: {result['correct_not_handed_off']}/{m} "        f"({result['accuracy_not_handed_off']:.1%})"    )
Saídapython route-recorded-answers.py
messages: 40
placeholder threshold: 0.5
accuracy: 20/40 (50.0%)
handed off: 2/40 (5.0%)
accuracy on messages not handed off: 20/38 (52.6%)

Eis as três medidas na amostra, com o limite provisório. O exemplo lê as respostas registradas, aplica o limite às confianças delas e imprime cada medida com a sua contagem. A linha a observar é a acurácia nas mensagens não encaminhadas, porque é a acurácia das mensagens que uma equipe de fato recebe.

Lidas em conjunto, as três medidas mostram que o limite provisório não protege as equipes. O roteador acerta 20/40 (50.0%) da amostra, índice que nenhuma equipe deveria aceitar sozinho. O limite encaminha apenas 2/40 (5.0%) das mensagens, de modo que a maior parte da amostra chega a uma equipe. Essas mensagens mantidas são roteadas corretamente em 20/38 (52.6%), apenas um pouco acima da acurácia da amostra inteira. Um roteador que devolve uma equipe para cada mensagem ainda não é um que o banco possa usar.

Uma amostra tão pequena pode mostrar que um roteador falha e como as medidas se movem. Ela não permite distinguir dois roteadores com segurança. O capítulo 2 apresenta as amostras maiores, e o capítulo 5 mede o limite escolhido nesse mesmo tipo de amostra.

Regra prática: Informe a acurácia, a taxa de encaminhamento e a acurácia nas mensagens não encaminhadas em conjunto, cada uma com a sua contagem, na mesma amostra fixa, e compare dois roteadores apenas quando ambos tiverem sido medidos nessa amostra.

Mostre o que um modelo pequeno faz primeiro

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

O atalho óbvio é descartar o substituto e perguntar diretamente a um modelo pequeno. O SmolLM2-135M-Instruct é o menor modelo da família que este livro utiliza, e é o modelo central do restante do livro. Ele roda em CPU e carrega offline a partir da sua revisão fixada. Se ele respondesse com um nome de time, o roteador não precisaria de nenhum registro, por isso vale testar esse atalho antes de construir qualquer outra coisa sobre ele.

O teste faz ao modelo a mesma pergunta que o roteador faria. O modelo recebe o prompt do roteador para as 20 primeiras mensagens da amostra, sem nenhuma restrição à resposta e com um limite de poucos tokens. Primeiro, faça uma estimativa: quantas dessas respostas serão nomes de times, sem nada que obrigue o modelo a seguir a lista? Depois, conte.

unconstrained-first-try.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Ask the 135M model for a team with the raw router prompt and no constraint, on the first 20 messages of test_40.Look at the last printed line, which counts the answers that are exactly a team name. The answers stay in this fileand are never returned to a caller."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402router_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"tokenizer, model = router_lib.load_model(SMALL)rows = router_lib.read_rows("test")sample = router_lib.read_sample("test_40", n=20)  # the first 20, to keep the run shortteams = set(router_lib.LABELS)answers = []with torch.no_grad():    for i in sample:        # the raw prompt: no chat template and no grammar, so the model may write anything        inputs = tokenizer(router_lib.router_prompt(rows[i][0]), return_tensors="pt")        # at most 10 new tokens, and greedy: the most likely token at each step        out = model.generate(            **inputs, max_new_tokens=10, do_sample=False, pad_token_id=tokenizer.eos_token_id        )        # the output starts with the prompt, so skip its tokens and keep only the answer        new_tokens = out[0, inputs["input_ids"].shape[1] :]        answers.append(tokenizer.decode(new_tokens, skip_special_tokens=True).strip())print(f"messages: {len(answers)}")# an answer counts only when it is exactly a team name, with no extra words around itprint(f"answers that are a team name: {sum(a in teams for a in answers)}/{len(answers)}")
Saídapython unconstrained-first-try.py
messages: 20
answers that are a team name: 0/20

Nenhuma das respostas do modelo é um nome de time, então o roteador não tem nada para encaminhar a um time. A medição guarda as respostas e nunca as devolve a quem chama.

Essa falha não mostra que um modelo pequeno nunca poderá rotear. Ela mostra que este modelo, perguntado desta forma, não devolve um time. Há duas correções diferentes, e as veremos em ordem. O Capítulo 4 restringe a resposta, de modo que o modelo só possa escrever um nome de time. O Capítulo 5 treina uma cabeça sobre o modelo, de modo que cada time recebe uma pontuação a partir de uma única passagem direta. Este capítulo não faz nenhuma das duas coisas, e é por isso que o seu roteador usa as respostas registradas do substituto.

Regra prática: Antes de um modelo rotear qualquer coisa, conte, em uma amostra fixa, quantas das suas respostas são nomes de times, e compare essa contagem com o tamanho da amostra. Se o modelo não devolver um time para cada mensagem, não o use para rotear do jeito que está. Restrinja a resposta aos times ou treine o modelo para a tarefa. Uma regra de encaminhamento aplicada a uma resposta que não é um time protege um time que não existe.

Onde um roteador rudimentar falha

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

Um roteador rudimentar falha de quatro maneiras em produção, e cada uma deixa um sinal que a equipe de suporte pode ver.

A primeira é um nome de equipe que não existe. Um modelo de texto livre pode escrever uma equipe que não está na lista, ou uma frase, e um roteador que encaminha esse texto adiante enviou a mensagem para ninguém. A gravação do substituto não pode fazer isso, porque sua gramática permite apenas os rótulos, mas o modelo do leitor pode. O sinal é uma resposta que não é um nome de equipe, e o teste sem restrições conta as respostas que são nomes de equipe. Um roteador deve tratar essa resposta como erro, contá-la e enviar a mensagem para uma pessoa. record_answers já levanta um erro para esse caso, e o roteador deve fazer o mesmo.

A segunda é a deriva. As respostas do substituto valem apenas para o arquivo, o prompt e a amostra com que foram gravadas. O manifesto da gravação registra o SHA-256 do arquivo, o hash do prompt, a decodificação e a amostra, de modo que qualquer mudança em um deles constitui outra gravação. Um leitor que vê uma pontuação mudar sem nenhuma alteração no código deve comparar primeiro o manifesto e, depois, o prompt.

A terceira é um limiar que deixa de servir. Um limiar escolhido em uma divisão de desenvolvimento pode deixar de servir quando a mistura de mensagens muda. O sinal é uma mudança na taxa de encaminhamento, ou na acurácia sobre as mensagens mantidas, quando o roteador é medido em novas mensagens de desenvolvimento. O capítulo 5 registra o limiar junto com a divisão de desenvolvimento em que foi escolhido, para que o banco possa ver a que número ele foi ajustado, e o capítulo 9 acompanha essa mudança.

A quarta são o custo e a carga sobre as pessoas. Um modelo hospedado cobra por chamada. Um roteador que o banco executa cobra em computação na própria máquina, e o capítulo 3 conta quanto custa uma mensagem em tokens e passagens diretas (forward passes), enquanto o capítulo 10 transforma uma velocidade registrada em custo. Cada encaminhamento é trabalho para uma pessoa, e a taxa de encaminhamento é a parcela desse trabalho. Recomendamos incluir a taxa de encaminhamento em todo relatório sobre o roteador, ao lado da acurácia, para que o custo do sinalizador nunca fique de fora.

Um roteador que não consegue dizer quando está em dúvida esconde seus erros, e o sinalizador os torna contáveis. O capítulo tomou estas decisões. Os capítulos seguintes as mantêm, ou as alteram e explicam por quê:

  • O roteador devolve uma equipe, uma confiança e um sinalizador de encaminhamento, e toda rota que devolve uma equipe passa por handoff.
  • O limiar é provisório até que o capítulo 5 o escolha na divisão de desenvolvimento.
  • Todo roteador é avaliado por acurácia, taxa de encaminhamento e acurácia nas mensagens não encaminhadas, na mesma amostra fixa, com as contagens ao lado de cada uma.
  • O substituto é a linha de base, e suas respostas são gravadas. O modelo próprio do leitor grava suas respostas da mesma forma, com record_answers.
  • Um modelo que não devolve uma equipe para cada mensagem ainda não é um roteador.

Este capítulo, nesta edição

Edição 2026.11.9Exemplos aprovados em 20 de nov de 20264 de 4 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 1 de 10: Construa um roteador para a caixa de entrada do banco que transfere quando estiver em dúvida

  1. O que o roteador devolve
  2. Peça a um modelo uma equipe
  3. Encaminhe as mensagens incertas
  4. Avalie o roteador em uma amostra fixa
  5. Mostre o que um modelo pequeno faz primeiro
  6. Onde um roteador rudimentar falha

Voltar ao topoTodos os capítulos