Quando um modelo pequeno é a escolha errada
Cerca de 26 minutos min de leitura, com 5 exemplos em 6 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.9. Leia o original
Ao final deste capítulo, você saberá dizer onde um roteador pequeno ainda perde para o substituto e onde se espera que um modelo hospedado tenha melhor desempenho. Também saberá calcular o custo mensal de cada opção a partir de entradas que você declara com suas datas, encontrar o volume a partir do qual uma máquina própria se torna a rota mais barata, e nomear os requisitos que decidem a questão antes de qualquer custo.
Um roteador pequeno pode superar um modelo maior na maior parte de um conjunto de mensagens e, ainda assim, ser a escolha errada para algumas mensagens, algumas equipes ou alguns volumes. A caixa de suporte do banco (capítulo 1) tem 77 equipes. Ao longo de nove capítulos, este livro construiu para ela uma cabeça classificadora, serviu a cabeça com uma rota que encaminha as mensagens incertas e com verificações que versionam o roteador e enviam os seus encaminhamentos a uma pessoa, e testou um aluno destilado e uma cópia int8, medindo ambos sem publicar nenhum dos dois. Os capítulos que medem o roteador o comparam com o substituto (capítulo 1).
Onde o modelo pequeno ainda perde
O capítulo 2 definiu a pontuação do substituto como linha de base. Esta seção coloca o roteador ao lado dela, sobre as mesmas mensagens: todas as 1001 mensagens de test_1001, a amostra fixa da qual vêm todas as amostras dos capítulos (capítulo 2). O roteador é o classificador banking77-lora-v1, executado ao vivo.
1"""The router and the stand-in on all 1,001 messages of test_1001, the committed test order. The prose rests on the2lines for the router's wrong answers sent as answers and for the messages the stand-in gets right and the router wrong.3The stand-in's answers are recorded; the router runs live on 2 threads, and its first 200 messages are the test_200 sample."""45import os67os.environ["HF_HUB_OFFLINE"] = "1"8os.environ["TRANSFORMERS_OFFLINE"] = "1"910import torch # noqa: E4021112torch.set_num_threads(2)1314import router_lib # noqa: E4021516router_lib.setup_runtime()17# Runs the router live on the sample and reads the stand-in's answers from its recording, then scores both.18c = router_lib.compare_router_and_standin("test_1001")19n = c["messages"]20print(f"messages on test_1001: {n}")21print(f"router banking77-lora-v1 correct: {c['router_correct']}/{n} ({c['router_correct'] / n:.1%})")22print(f"stand-in correct: {c['standin_correct']}/{n} ({c['standin_correct'] / n:.1%})")23print(f"router handed off: {c['handed_off']}/{n} ({c['handed_off'] / n:.1%})")24print(f"right for the stand-in, wrong for the router: {c['standin_right_router_wrong']}/{n}")25print(f"of those, handed off by the router: {c['of_those_handed_off']}/{c['standin_right_router_wrong']}")26print(f"wrong for the router and sent as an answer: {c['router_wrong_sent']}/{n} ({c['router_wrong_sent'] / n:.1%})")27print(f"right for the router, wrong for the stand-in: {c['router_right_standin_wrong']}/{n}")
python router-on-test-1001.pymessages on test_1001: 1001
router banking77-lora-v1 correct: 847/1001 (84.6%)
stand-in correct: 560/1001 (55.9%)
router handed off: 146/1001 (14.6%)
right for the stand-in, wrong for the router: 48/1001
of those, handed off by the router: 22/48
wrong for the router and sent as an answer: 76/1001 (7.6%)
right for the router, wrong for the stand-in: 335/1001
No conjunto completo, o roteador está à frente, com acerto em 847/1001 (84.6%) contra os 560/1001 (55.9%) do substituto, que é a linha de base do capítulo 2. Ainda assim, o substituto acerta e o roteador erra em 48/1001 mensagens. O roteador encaminha algumas dessas, para que uma pessoa as veja, e as demais chegam ao chamador como respostas erradas. A discordância inversa, em que o roteador acerta e o substituto erra, tem sua própria contagem na saída.
A contagem que mais importa para a caixa de entrada é a das respostas erradas que o roteador envia ao chamador: 76/1001 (7.6%). São mensagens que ele manteve, porque a confiança delas ultrapassou o limiar. O capítulo 5 escolheu esse limiar na partição de desenvolvimento, e o capítulo 9 explica para onde vai o que o roteador encaminha, que é uma pessoa.
1"""Where the router still loses: test_200 scored for the router and the stand-in. The prose rests on the count of2messages the stand-in gets right and the router wrong, and on the wrong answers the router sends as answers.3The stand-in's answers are recorded; the router runs live on 2 threads."""45import os67os.environ["HF_HUB_OFFLINE"] = "1"8os.environ["TRANSFORMERS_OFFLINE"] = "1"910import json # noqa: E4021112import torch # noqa: E40213torch.set_num_threads(2)1415import router_lib # noqa: E4021617router_lib.setup_runtime()18ADAPTER = router_lib.HERE / "data" / "recorded" / "lora-full"19# The threshold chapter 5 chose on dev, as the adapter's manifest records it.20threshold = json.loads((ADAPTER / "manifest.json").read_text())["handoff_threshold"]21# Keyed by test row index, not by position in the sample, so each lookup uses the sample's row numbers.22answers = router_lib.standin_rows()23test = router_lib.read_rows("test") # (text, label index) per row24sample = router_lib.read_sample("test_200")25golds = [test[i][1] for i in sample] # index 1 is the gold team, as an index26standin_preds = [answers[i]["label"] for i in sample] # the label is the team's index, the same form as the gold label27tokenizer, model = router_lib.load_classifier(ADAPTER / "adapter")28preds, confs = router_lib.classify(model, tokenizer, [test[i][0] for i in sample])29n = len(sample)30router_right = [p == g for p, g in zip(preds, golds)]31standin_right = [p == g for p, g in zip(standin_preds, golds)]32handed_off = [router_lib.handoff(c, threshold) for c in confs] # true below the threshold; a NaN confidence is handed off too33lost = [i for i in range(n) if standin_right[i] and not router_right[i]]34sent_wrong = sum(not r and not h for r, h in zip(router_right, handed_off)) # wrong and not handed off: what a caller receives35print(f"messages on test_200: {n}")36print(f"router banking77-lora-v1 correct: {sum(router_right)}/{n} ({sum(router_right) / n:.1%})")37print(f"stand-in correct: {sum(standin_right)}/{n} ({sum(standin_right) / n:.1%})")38print(f"router threshold from manifest: {threshold:.2f}")39print(f"router handed off: {sum(handed_off)}/{n} ({sum(handed_off) / n:.1%})")40print(f"right for the stand-in, wrong for the router: {len(lost)}/{n} ({len(lost) / n:.1%})")41print(f"of those, handed off by the router: {sum(handed_off[i] for i in lost)}/{len(lost)}")42print(f"wrong for the router and sent as an answer: {sent_wrong}/{n} ({sent_wrong / n:.1%})")43print(f"right for the router, wrong for the stand-in: {sum(r and not s for r, s in zip(router_right, standin_right))}/{n}")
python where-the-router-still-loses.pymessages on test_200: 200
router banking77-lora-v1 correct: 172/200 (86.0%)
stand-in correct: 109/200 (54.5%)
router threshold from manifest: 0.63
router handed off: 33/200 (16.5%)
right for the stand-in, wrong for the router: 6/200 (3.0%)
of those, handed off by the router: 3/6
wrong for the router and sent as an answer: 11/200 (5.5%)
right for the router, wrong for the stand-in: 69/200
test_200 são as primeiras 200 mensagens de test_1001, um prefixo que o script de contagem verifica; por isso essas contagens fazem parte da execução completa e não são uma segunda amostra. Nelas, o substituto acerta e o roteador erra em 6/200 (3.0%) mensagens, e o roteador encaminha 3/6 dessas.
O encaminhamento retém as respostas erradas. O roteador envia 11/200 (5.5%) respostas erradas nessas 200 mensagens. Nas mensagens que mantém, sua precisão é de 156/167 (93.4%), e 33/200 (16.5%) das 200 vão para uma pessoa.
Forçar um modelo pequeno a escolher na lista de equipes faz com que toda resposta seja uma equipe, mas isso não torna a resposta certa. O capítulo 4 pediu aos dois modelos menores uma equipe desse modo. A tabela mostra a contagem de cada variante com prompt nas 200 mensagens de test_200:
| Variante com prompt | Acertos em test_200 |
|---|---|
| SmolLM2-135M-Instruct, prompt bruto | 9/200 (4.5%) |
| SmolLM2-135M-Instruct, modelo de chat | 11/200 (5.5%) |
| SmolLM2-360M-Instruct, prompt bruto | 12/200 (6.0%) |
O modelo 135M bruto deu uma resposta com mais frequência que qualquer outra (card_arrival, 165/200), e essa equipe é a equipe correta de 0/200 das mensagens. Um modelo que se apoia em uma única resposta é um prior, não um roteador. O capítulo 4 mostra por que um prompt não consegue compensar um modelo desse tamanho.
O substituto também falha em padrões. Em todas as 1001 mensagens, suas respostas nunca nomeiam 4 das 77 equipes, de modo que toda mensagem cuja equipe correta é uma delas vai para outra equipe. Duas confusões empatam como seu erro mais comum. A mais clara é a equipe Refund_not_showing_up, que é respondida como request_refund em 13/13 de suas mensagens. Um par assim é onde um conjunto rotulado precisa ser lido antes que qualquer modelo seja confiável nele, e o capítulo 2 lista os pares de cada candidato.
Um aluno copia seu professor, inclusive os erros dele. O capítulo 6 destilou as respostas do substituto em um aluno. O professor concordou com o rótulo correto em 549/1000 (54.9%) das linhas de treinamento que rotulou, de modo que o aluno aprendeu com rótulos errados quase na metade das vezes. O aluno chegou a 69/200 (34.5%) em test_200, e a mesma receita treinada com os rótulos corretos das mesmas linhas chegou a 77/200 (38.5%).
O aluno também fica abaixo de seu professor, que chegou a 109/200 (54.5%) em test_200, e abaixo do controle com rótulos corretos, por uma diferença que esta amostra não consegue resolver (capítulo 6). O aluno acerta onde o controle erra em 24/200 mensagens, e o controle acerta onde o aluno erra em 32/200.
Uma equipe nova é outro ponto em que o modelo pequeno perde. Uma cabeça de classificação tem uma saída para cada equipe em que foi treinada, de modo que uma equipe sem saída não pode ser roteada por ela. Acrescentar uma exige mensagens rotuladas dessa equipe, uma rodada de treinamento com a receita do capítulo 5 e as verificações do capítulo 9 antes que o roteador envie uma mensagem para ela. Se uma mudança de prompt poderia acrescentar uma equipe nova é uma questão que o leitor deve testar. Este livro não mediu um modelo hospedado, e a tabela mais adiante neste capítulo deixa a questão em aberto.
Em conjunto, os modelos pequenos fizeram três coisas: um modelo com prompt se apoiou em uma única resposta, um aluno copiou os erros de seu professor, e uma equipe sem saída não pôde ser roteada. Nenhuma delas é uma falha da aritmética do roteador. O substituto fez mais uma coisa: nunca nomeou 4 equipes e confundiu um par. Isso é do substituto, não de nenhuma das opções. Um limiar mais alto troca as 11/200 (5.5%) respostas erradas do roteador em test_200 por encaminhamentos (capítulo 5), mas não dá saída a nenhuma equipe e não corrige nem os erros do professor nem os do substituto. Cada caso muda o que o chamador vê: uma equipe errada, uma mensagem encaminhada ou nenhuma equipe.
Regra prática: Antes de rotear com um modelo pequeno, execute-o e o modelo hospedado sobre a mesma amostra fixa. Conte as mensagens que cada um acerta e o outro erra, e as respostas erradas que chegariam ao chamador. Conte as respostas de um modelo com prompt contra a lista de equipes, e conte com que frequência sua resposta mais comum é a equipe correta. Não roteie para uma equipe que não tenha mensagens rotuladas próprias, e não treine um aluno com os rótulos de um professor antes de ter contado com que frequência o professor concorda com os rótulos corretos.
Calcule a conta e a máquina
Um modelo hospedado é pago por mensagem. A conta mensal de um modelo hospedado é o número de mensagens vezes o custo de uma mensagem, e uma mensagem custa seus tokens de entrada ao preço de entrada mais seus tokens de saída ao preço de saída. Uma tabela de preços escrita por milhão de tokens dá o preço por token quando dividida por um milhão. Uma mensagem de roteamento é longa do lado da entrada, porque o prompt e a mensagem são ambos contados, e curta do lado da saída, porque a resposta é um único nome de equipe.
Uma máquina é paga esteja ela ocupada ou não. A conta mensal de uma máquina é suas horas vezes sua taxa horária. O número de mensagens que uma máquina consegue rotear em um mês é sua vazão, em mensagens por segundo, vezes os segundos de um mês, vezes sua utilização, que é a fração do mês em que ela está ocupada. O custo por mensagem da máquina depende, portanto, de quantas mensagens ela roteia, e a comparação precisa de um volume antes de dar uma resposta.
As três fórmulas abaixo valem para qualquer par de opções.
hosted cost per month = messages × (input tokens × input price + output tokens × output price)
machine cost per month = hours × machine cost per hour
machine capacity per month = messages per second × seconds per month × utilisation
Cada entrada precisa de um valor, e cada preço precisa de uma data e de uma fonte. O livro não cita nenhum preço de provedor hospedado, porque não tem nenhum com fonte e data que um leitor possa verificar. Leia a página de preços do seu provedor no dia em que você executar a comparação, e escreva o preço, sua data e seu endereço ao lado do número.
Os tokens de entrada também precisam de um tokenizador. A contagem de um provedor hospedado pode diferir da contagem de um modelo aberto para o mesmo texto, e este livro não mediu nenhuma. O prompt de roteamento é o que um modelo hospedado receberia para cada mensagem: a lista de 77 nomes de equipe e a mensagem, como router_prompt a monta. O exemplo mensal conta esse prompt com o tokenizador de SmolLM2-135M-Instruct, que dá 587 tokens por mensagem, e o exemplo rotula essa contagem como um substituto da do provedor.
A vazão é a entrada que uma gravação precisa fornecer, porque depende da máquina. A gravação nomeia sua máquina e salva as taxas que mediu. Em a cloud machine with 4 vCPUs and 15 GiB of memory, com 4 threads, o substituto roteou 0.32 mensagens por segundo com uma mensagem por chamada. O classificador do roteador, banking77-lora-v1, em float32, roteou 19.0 mensagens por segundo com o mesmo tamanho de chamada. Sua taxa em lotes de 16 também consta na saída.
Somente o par de uma mensagem por chamada é comparável diretamente. O classificador em lotes de 16 recebe 16 mensagens em uma única passagem direta, e o substituto recebe uma mensagem por chamada com seu prompt completo de roteamento. Assim, a razão em lotes de 104.0 mistura tamanho do modelo com processamento em lote, e este capítulo não a usa para a comparação. A comparação usa a razão de uma mensagem por chamada, de 60.8. Cada cópia recebeu uma passagem cronometrada sobre as 200 mensagens de test_200, após um aquecimento de uma mensagem, com a tokenização dentro do intervalo cronometrado. As razões vêm de taxas sem arredondamento, por isso não são exatamente o quociente das taxas impressas.
1"""The throughput rates and ratios as recorded, and the machine they were measured on. The prose rests on the2one-per-call ratio line, the like-for-like comparison; the batched lines differ in call size. Reads the recording only; no model runs."""34import json56import router_lib78folder = router_lib.HERE / "data" / "recorded" / "throughput"9ratios = json.loads((folder / "ratios.json").read_text())10rates = router_lib.recorded_rates()11manifest = json.loads((folder / "manifest.json").read_text())1213print(f"machine: {manifest['machine'].split(', ')[0]}") # the machine's description is cut at its first comma, which keeps the name and drops the rest14print(f"threads: {manifest['settings']['n_threads']}")15print(f"messages on test_200: {ratios['messages']}")16print(f"stand-in rate, one per call (messages a second): {rates['standin_one_message_per_call']}")17print(f"classifier fp32 rate, one per call (messages a second): {rates['classifier_fp32_one_message_per_call']}")18print(f"classifier fp32 rate, batches of 16 (messages a second): {rates['classifier_fp32_batches_of_16']}")19print(f"classifier int8 rate, batches of 16 (messages a second): {rates['classifier_int8_batches_of_16']}")20# Each ratio is computed from unrounded rates, so it is not the quotient of the printed rates.21print(f"fp32 over stand-in, one per call, throughput ratio: {ratios['classifier_fp32_one_at_a_time_over_standin']}")22print(f"fp32 over stand-in, batches of 16, throughput ratio: {ratios['classifier_fp32_over_standin']}")23print(f"int8 over stand-in, batches of 16, throughput ratio: {ratios['classifier_int8_over_standin']}")24print(f"int8 over fp32, batches of 16, throughput ratio: {ratios['classifier_int8_over_fp32']}")25print(f"predictions agreeing, fp32 and int8: {ratios['agreement_fp32_int8']}/{ratios['messages']}")
python cost-ratio-from-recording.pymachine: a cloud machine with 4 vCPUs and 15 GiB of memory
threads: 4
messages on test_200: 200
stand-in rate, one per call (messages a second): 0.32
classifier fp32 rate, one per call (messages a second): 19.0
classifier fp32 rate, batches of 16 (messages a second): 33.0
classifier int8 rate, batches of 16 (messages a second): 29.0
fp32 over stand-in, one per call, throughput ratio: 60.8
fp32 over stand-in, batches of 16, throughput ratio: 104.0
int8 over stand-in, batches of 16, throughput ratio: 91.8
int8 over fp32, batches of 16, throughput ratio: 0.9
predictions agreeing, fp32 and int8: 200/200
Nesta máquina, com essa contagem de threads, a cópia int8 não foi mais rápida que a float32. Sua razão sobre a float32 em lotes de 16 é 0.9. O capítulo 7 disse que menos bytes não resolvem a velocidade, e esta gravação mede a velocidade. As duas cópias concordaram em 200/200 previsões. A gravação foi feita com essa contagem de threads, e o orçamento de serviço deste livro são dois vCPUs, então as taxas de um leitor devem vir de uma gravação na sua própria máquina, com a sua contagem de threads.
A conta precisa de uma taxa para o roteador, e a gravação fornece uma: o classificador com uma mensagem por chamada, cronometrado como o substituto foi. A rota trata uma mensagem por requisição, por isso a conta usa essa taxa. Um leitor a substitui por uma taxa medida na sua própria máquina.
1"""The monthly bill for a hosted model and for the router on one machine, from inputs the reader sets. The hosted bill,2the machine's bill and the cheaper-route line are the point the prose rests on. The prices, volume, machine cost3and utilisation are example values, not published prices; the token counts are live and the router's rate is recorded."""45import os67os.environ["HF_HUB_OFFLINE"] = "1"8os.environ["TRANSFORMERS_OFFLINE"] = "1"910import torch # noqa: E4021112torch.set_num_threads(2)1314import router_lib # noqa: E4021516router_lib.setup_runtime()17inputs = router_lib.bill_inputs_recorded()18test = router_lib.read_rows("test")19messages = [test[i][0] for i in router_lib.read_sample("test_200")] # index 0 is the text; the label is index 12021# The hosted prompt, counted with the 135M model's tokenizer as a stand-in for the provider's.22input_tokens = router_lib.router_prompt_tokens(messages)23# Prices are per million tokens, hence the division at the end.24per_message = (input_tokens * inputs["price_per_million_input_tokens"]25 + inputs["output_tokens_per_message"] * inputs["price_per_million_output_tokens"]) / 1_000_00026hosted_month = inputs["messages_per_month"] * per_message2728machine_month = inputs["machine_cost_per_hour"] * inputs["hours_per_month"]29capacity = inputs["router_messages_per_second"] * 3600 * inputs["hours_per_month"] * inputs["utilisation"]3031print(f"example input, messages per month: {inputs['messages_per_month']}")32print(f"example input, price per million input tokens, USD: {inputs['price_per_million_input_tokens']}")33print(f"example input, price per million output tokens, USD: {inputs['price_per_million_output_tokens']}")34print(f"example input, output tokens per message: {inputs['output_tokens_per_message']}")35print(f"example input, machine cost per hour, USD: {inputs['machine_cost_per_hour']}")36print(f"example input, hours per month: {inputs['hours_per_month']}")37print(f"example input, utilisation: {inputs['utilisation']}")38print(f"recorded input, router messages per second, one per call: {inputs['router_messages_per_second']}")39print(f"input tokens per message, hosted prompt (counted with SmolLM2-135M-Instruct, a stand-in tokenizer): {input_tokens}")40print(f"example hosted price per message (example prices), USD: {per_message:.6f}")41print(f"example hosted bill per month (example prices), USD: {hosted_month:.2f}")42print(f"example machine bill per month (example cost per hour), USD: {machine_month:.2f}")43print(f"machine capacity per month (recorded rate, example utilisation): {capacity:.0f}")44print(f"example machine cost per message at capacity (example cost per hour), USD: {machine_month / capacity:.6f}")45print(f"example volume within machine capacity: {'yes' if inputs['messages_per_month'] <= capacity else 'no'}") # above capacity, one machine cannot carry the volume and this bill does not hold46print(f"example values, cheaper route at the input volume: {'hosted' if hosted_month < machine_month else 'machine'}")
python monthly-bill-from-labelled-inputs.pyexample input, messages per month: 100000
example input, price per million input tokens, USD: 1.0
example input, price per million output tokens, USD: 4.0
example input, output tokens per message: 6
example input, machine cost per hour, USD: 0.4
example input, hours per month: 730
example input, utilisation: 0.5
recorded input, router messages per second, one per call: 19.0
input tokens per message, hosted prompt (counted with SmolLM2-135M-Instruct, a stand-in tokenizer): 587
example hosted price per message (example prices), USD: 0.000611
example hosted bill per month (example prices), USD: 61.10
example machine bill per month (example cost per hour), USD: 292.00
machine capacity per month (recorded rate, example utilisation): 24966000
example machine cost per message at capacity (example cost per hour), USD: 0.000012
example volume within machine capacity: yes
example values, cheaper route at the input volume: hosted
Com estas entradas de exemplo, a rota hospedada é a mais barata. A conta hospedada é de 61.10 USD por mês para o volume de exemplo, e uma máquina própria custa 292.00 USD por mês, qualquer que seja o volume.
Com a taxa gravada e a utilização de exemplo, a máquina consegue rotear 24966000 mensagens por mês, e em capacidade total seu custo por mensagem é de 0.000012 USD. O volume de exemplo de 100000 mensagens por mês fica bem abaixo dessa capacidade, e a seção de ponto de equilíbrio encontra onde as duas contas se cruzam. O custo por hora nestas entradas serve à máquina gravada; uma máquina de dois vCPUs precisa da sua própria taxa gravada.
Cada entrada desta conta pode deixar de ser verdadeira. Os preços mudam, então um preço lido em um mês é um fato sobre aquele mês. A utilização aqui é uma suposição sobre um tráfego que ainda não aconteceu, e o volume de uma caixa de entrada muda com os produtos que o banco vende e com os eventos que enchem sua fila. Uma máquina que ficou ociosa metade do mês em um trimestre pode estar ocupada o tempo todo no seguinte. Por isso, faça a conta novamente a cada mês, com o volume real, o preço na sua data e a utilização que a máquina mediu. Uma comparação feita uma única vez é o registro do mês em que foi feita.
Regra prática: Compare as duas contas com entradas que você verificou e com uma máquina que você precificou. Escreva cada preço com sua fonte e a data em que você o leu. Conte os tokens de entrada com o tokenizador do modelo hospedado com que você compara, e tire a vazão de uma gravação na máquina que você compraria. Onde um valor for um exemplo, diga isso ao lado dele, e substitua-o antes de decidir.
Mantenha os dados dentro do banco
Esta seção não é uma comparação de custos, e nenhum dos números deste livro a decide. Cada mensagem que a caixa de entrada recebe é um texto de cliente. Quando um modelo hospedado responde a ela, o texto sai das máquinas do banco e vai para as do provedor. Para cada mensagem, uma chamada hospedada envia o texto da mensagem e a lista de 77 nomes de equipe. O banco pode não querer isso, por razões próprias: os dados de seus clientes, seus contratos, suas regras sobre quem pode ler o quê. Essas razões valem mesmo quando a conta hospedada é menor.
As mensagens deste livro são as mensagens públicas do BANKING77, portanto as execuções do próprio livro não mostram nada sobre privacidade. O requisito pertence ao banco, e só o banco pode dizer se ele se aplica.
Um modelo pequeno que permanece nas máquinas do banco atende ao requisito pelo lugar onde roda. O roteador, seus pesos e seus registros ficam sob os controles do banco, e as verificações de versionamento e de arquivos do capítulo 9 valem para cada adaptador que a rota carrega. Uma cópia derivada, como a cópia int8, não tem manifesto nem fixação de versão próprios, então precisa dos dois antes de atender. Permanecer dentro também tem um custo próprio, que não é uma conta. O banco opera a máquina, mantém-na atualizada e mantém em funcionamento as verificações da rota, inclusive o encaminhamento que permanece na rota, qualquer que seja a mudança (capítulo 8).
Uma conta é um número que varia com o volume, o preço e a data. Um requisito não varia. Por isso, defina primeiro o requisito e depois compare apenas as opções que o atendem. Um modelo pequeno que roda nas máquinas do banco é uma dessas opções. Um modelo aberto maior que roda ali é outra. O modelo substituto é uma delas, e nesta máquina ele roteou 0.32 mensagens por segundo, uma por chamada, contra 19.0 do classificador. Essa diferença é o seu custo medido em vazão, 60.8 vezes, e não um custo em dinheiro. Se nenhuma opção atende ao requisito no volume que a caixa de entrada espera, a comparação de custos não tem o que decidir. Um modelo pequeno que atende ao requisito ainda precisa passar nas contagens de precisão e de encaminhamentos da primeira seção, e atender ao requisito não o dispensa delas.
Regra prática: Defina o requisito de dados antes do custo. Registre-o por escrito como um requisito, com as pessoas que são seus responsáveis, e não o conte como economia nem como custo. Quando as mensagens precisarem permanecer nas máquinas do banco, escolha um modelo que rode ali e, então, conte sua precisão e seus encaminhamentos como na primeira seção deste capítulo.
Escolha com uma tabela
As perguntas acima não são todas sobre custo, e a maioria delas pode ser respondida antes que alguém rode uma gravação. A tabela abaixo coloca as perguntas lado a lado. Para cada uma, ela mostra como é um roteador pequeno, como é um modelo hospedado e o que contar na sua caixa de entrada.
| Pergunta | Roteador pequeno | Modelo hospedado | O que medir |
|---|---|---|---|
| As mensagens precisam ficar nas máquinas do banco? | Atende: roda nas máquinas do banco | Não atende: o texto vai para o provedor | Requisito, não uma contagem: decida primeiro |
| Cada resposta precisa ser uma equipe? | Sim, por uma cabeça de classificação ou por decodificação restrita (capítulo 4) | Só se um prompt e uma verificação mantiverem a resposta na lista | Respostas fora da lista de equipes, em uma amostra fixa |
| Com que frequência a lista de equipes muda? | Uma nova equipe exige mensagens rotuladas e uma rodada de treinamento (capítulo 9) | Se uma mudança no prompt basta: uma pergunta a testar | As mensagens rotuladas e os passos que uma nova equipe leva para ser roteada |
| Quantas mensagens por mês? | Uma conta mensal fixa, até a sua capacidade | Uma conta por mensagem, crescendo com o volume | O número de mensagens do ponto de equilíbrio na última seção |
| Quantas mensagens rotuladas cada equipe tem? | Suficientes para treinar e para testar cada equipe (capítulo 2) | Poucas ou nenhuma, para um prompt | Mensagens rotuladas por equipe, contadas na divisão de treinamento |
| A tarefa precisa de texto aberto ou de conhecimento amplo? | Limitado à lista de equipes, e suas respostas em texto aberto falharam no primeiro teste deste livro | Uma pergunta a testar | Acurácia na mesma amostra fixa, com sua contagem |
A tabela é uma lista do que contar, não uma pontuação. Leia as linhas em ordem: primeiro o requisito da primeira linha, depois a lista de equipes, depois o volume, porque cada uma pode encerrar a questão antes que a próxima seja feita. Na última coluna, uma célula que começa com "Requisito" nomeia uma decisão que vem antes das contagens. Toda outra célula nomeia uma contagem, feita na sua amostra, com o denominador impresso. A linha de texto aberto se apoia no primeiro teste do capítulo 4: as respostas sem restrição do modelo de 135M foram nomes de equipes em 0/20 mensagens.
Regra prática: Responda cada linha a partir da sua caixa de entrada antes de escolher. Onde uma linha pede uma contagem, faça-a em uma amostra fixa e imprima o denominador. Onde uma linha nomeia um requisito, deixe o requisito decidir antes que as contagens decidam, e escreva-o na decisão como requisito.
Conheça o ponto de equilíbrio
O ponto de equilíbrio é o volume em que a conta mensal do modelo hospedado e a da máquina ficam iguais. Abaixo dele, o modelo hospedado custa menos com as entradas que você definiu. Acima dele, a máquina custa menos, desde que o volume esteja dentro da capacidade da máquina. A conta da máquina é paga esteja ela ocupada ou ociosa, por isso o ponto de equilíbrio divide essa conta pelo preço por mensagem do modelo hospedado:
mensagens de equilíbrio por mês = conta mensal da máquina ÷ preço por mensagem do modelo hospedado
A fórmula não subtrai o custo por mensagem da máquina do preço do modelo hospedado. O custo por mensagem da máquina na capacidade máxima é a sua conta fixa dividida pela capacidade, e essa conta já é contada uma vez no numerador. Subtrair o mesmo custo de novo contaria a máquina duas vezes. A fórmula também só vale dentro da capacidade. Acima dela, uma máquina não consegue atender o volume, e a conta é refeita para uma segunda máquina, com a sua própria conta e a sua própria capacidade.
1"""The monthly volume at which one machine's bill equals the hosted bill for the router's prompts. The break-even line2is the point the prose rests on, and it holds only inside the capacity line, which the last line checks. The prices and3the machine's cost are example values, as in the bill; the router's rate is recorded on the machine."""45import math6import os78os.environ["HF_HUB_OFFLINE"] = "1"9os.environ["TRANSFORMERS_OFFLINE"] = "1"1011import torch # noqa: E4021213torch.set_num_threads(2)1415import router_lib # noqa: E4021617router_lib.setup_runtime()18inputs = router_lib.bill_inputs_recorded() # example prices and cost per hour, with the router's rate from the recording19test = router_lib.read_rows("test") # (text, label index) for every test row, in file order20messages = [test[i][0] for i in router_lib.read_sample("test_200")] # index 0 is the text; the label is index 12122# Mean count of the whole router prompt, team list included, with SmolLM2-135M's tokenizer.23input_tokens = router_lib.router_prompt_tokens(messages)24# Prices are per million tokens, hence the division at the end.25per_message = (input_tokens * inputs["price_per_million_input_tokens"]26 + inputs["output_tokens_per_message"] * inputs["price_per_million_output_tokens"]) / 1_000_00027machine_month = inputs["machine_cost_per_hour"] * inputs["hours_per_month"]28capacity = inputs["router_messages_per_second"] * 3600 * inputs["hours_per_month"] * inputs["utilisation"]2930# The machine's bill is the same each month up to its capacity, so the hosted bill31# equals it at messages = machine bill / hosted price per message.32# Rounded up: the first whole message count at which the machine is no dearer.33breakeven = math.ceil(machine_month / per_message)3435print(f"input tokens per message, hosted prompt (counted with SmolLM2-135M-Instruct, a stand-in tokenizer): {input_tokens}")36print(f"example hosted price per message (example prices), USD: {per_message:.6f}")37print(f"example machine bill per month (example cost per hour), USD: {machine_month:.2f}")38print(f"machine capacity per month (recorded rate, example utilisation): {capacity:.0f}")39print(f"example break-even messages per month (example prices and cost per hour): {breakeven}")40print(f"break-even within machine capacity: {'yes' if breakeven <= capacity else 'no'}")
python break-even-from-recorded-ratio.pyinput tokens per message, hosted prompt (counted with SmolLM2-135M-Instruct, a stand-in tokenizer): 587
example hosted price per message (example prices), USD: 0.000611
example machine bill per month (example cost per hour), USD: 292.00
machine capacity per month (recorded rate, example utilisation): 24966000
example break-even messages per month (example prices and cost per hour): 477906
break-even within machine capacity: yes
Com os valores do exemplo, a conta da máquina de 292.00 USD se equilibra em 477906 mensagens por mês. Essa quantidade fica dentro da capacidade da máquina de 24966000 mensagens por mês (a verificação mostra yes). Essa capacidade usa a taxa registrada de uma chamada por vez com a utilização do exemplo.
O ponto de equilíbrio não depende da taxa, apenas da conta e do preço do modelo hospedado. O volume de 100000 mensagens por mês fica bem abaixo dele, por isso a conta do modelo hospedado é a menor.
Um ponto de custo não é uma decisão, e a caixa de entrada ainda decide o restante. Ele só responde à pergunta de custo depois que o requisito de manter os dados dentro do prédio estiver resolvido. Se as mensagens precisarem permanecer internas, a questão é qual modelo pequeno atende às contagens de precisão e de encaminhamento, e o ponto de equilíbrio mostra quanto essa máquina custa em comparação com um modelo hospedado em cada volume. Se o requisito permitir um modelo hospedado, e o volume estiver abaixo do ponto de equilíbrio, o modelo hospedado é a rota de menor custo com os preços do exemplo. Acima do ponto de equilíbrio, a máquina é a rota de menor custo, desde que o volume esteja dentro da sua capacidade e que as respostas erradas do roteador que chegam a quem enviou a mensagem sejam números que a equipe de suporte possa aceitar. Os encaminhamentos vão para uma pessoa, qualquer que seja a conta: nas primeiras 200 mensagens, o roteador encaminha 33/200 (16.5%) delas.
Regra prática: Calcule o ponto de equilíbrio com a conta da sua máquina e com o preço do modelo hospedado que você levantou, anotando ao lado desse preço a data e a fonte. Confira se o volume que você espera está dentro da capacidade que você mediu na sua máquina antes de ler o ponto de equilíbrio como economia. Acima dessa capacidade, considere uma segunda máquina e calcule novamente. Leia o ponto de equilíbrio como um ponto de custo, não como uma decisão. Os requisitos e as contagens de precisão das seções anteriores continuam decidindo se o roteador entra em produção.
As decisões que este livro tomou para a caixa de entrada
Nos conjuntos e nas máquinas que o livro nomeia, estes são os números que pesam sobre a caixa de entrada. Cada um traz o capítulo que o calcula.
- Acurácia. Em todo o
test_1001, o roteador acerta 847/1001 (84.6%), e o modelo substituto, 560/1001 (55.9%) (capítulo 2). O roteador passa o restante para uma pessoa, e 76/1001 (7.6%) respostas erradas ainda chegam a um cliente. Essa é a contagem que a equipe de atendimento precisa aceitar antes de o roteador entrar em produção. - Velocidade. Na máquina registrada, com uma mensagem por chamada, o classificador processou 19.0 mensagens por segundo, contra 0.32 do modelo substituto, uma razão de 60.8 (capítulo 7 explica como a velocidade é medida). A cópia int8 não deu motivo de velocidade para ser servida: sua razão sobre float32 em lotes de 16 foi 0.9. Por isso, o adaptador em float32 continua sendo o que a rota serve (capítulo 8).
- Custo. Com as entradas de exemplo, 100000 mensagens por mês custam 61.10 USD no lado hospedado e 292.00 USD em uma máquina própria. O ponto de equilíbrio é 477906 mensagens por mês, dentro de uma capacidade de 24966000. Estes são preços e custo por hora de exemplo; substitua-os pelos seus, cada um com sua data e fonte, antes de ler o ponto de equilíbrio como uma decisão.
- A exigência sobre os dados. Se as mensagens precisarem permanecer nas máquinas do banco, o modelo hospedado fica de fora, e a escolha se dá entre as opções que rodam ali. Resolva isso primeiro, como diz a seção sobre manter os dados dentro das instalações.
- Onde o modelo pequeno não é a escolha. Uma equipe sem mensagens rotuladas não tem saída na cabeça de classificação, e uma equipe nova precisa dos passos do capítulo 9. Respostas de texto livre falharam no primeiro teste deste livro (capítulo 4). Espera-se que um modelo hospedado se saia melhor em texto livre e conhecimento amplo, o que é uma questão a testar. E, com um volume abaixo do ponto de equilíbrio, onde um modelo hospedado é permitido, o modelo hospedado é a rota mais barata pelos preços de exemplo.
- O que foi aprendido. A exigência sobre os dados e a lista de equipes decidem quais opções restam. Só depois disso a conta escolhe entre elas.
O veredito para a caixa de entrada. Se as mensagens precisarem permanecer nas máquinas do banco, e cada equipe tiver mensagens rotuladas, a escolha é um roteador pequeno na própria máquina do banco, desde que o volume esteja acima do ponto de equilíbrio pelos preços do próprio banco e dentro da capacidade da máquina. A passagem para uma pessoa permanece na rota, qualquer que seja o resultado da conta. Conte as respostas erradas que chegam a um cliente na amostra do próprio banco antes de colocar o sistema em produção.
Regra prática: Refaça esta lista a partir da sua caixa de entrada, com os seus números, antes de escolher. Um veredito que não venha das suas contagens, datas e exigências não é o veredito do livro para a sua caixa de entrada.
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.