Escolha um modelo base contando quanto custa uma mensagem

Cerca de 21 minutos min de leitura, com 3 exemplos em 5 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 nomear os dois modelos base que este livro usa, carregar cada um na revisão fixada e contar quanto custa uma mensagem de roteamento em tokens e parâmetros antes de se comprometer com um modelo.

Toda mensagem na caixa de suporte do banco tem um custo para ser roteada: um modelo lê a mensagem e escolhe a equipe responsável, e o modelo de onde o roteador parte define quanto isso custa. O roteador é o sistema completo que o capítulo 1 constrói, e este capítulo escolhe o pequeno modelo aberto que fica por baixo dele. O capítulo 2 fixou as amostras com que o roteador é medido. Este capítulo escolhe primeiro pelo custo, porque o banco consegue contar quanto custa uma mensagem antes de construir qualquer coisa em torno do modelo.

Quais candidatos mantemos

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

Um modelo base é um modelo já pré-treinado em uma grande quantidade de texto, que você adapta a uma tarefa. Todos os capítulos seguintes se apoiam nesta escolha, por meio do prompt, do treinamento, da destilação e do serving, por isso vale fazê-la com base em evidências. Há muitos modelos abertos, então o livro restringe o campo com duas perguntas: o modelo consegue rodar no hardware que o banco tem, e o banco pode usar a sua licença?

Na prática, a licença vem primeiro. Ela define o que o banco pode fazer com o modelo no próprio sistema, e um modelo que o banco não pode executar não é candidato, qualquer que seja o seu tamanho. O livro registra a licença de cada modelo ao lado do seu pin, para que você veja o mesmo registro que o livro usou.

O primeiro candidato é o SmolLM2, uma família de modelos publicada no Hugging Face. O model card do modelo de 135M, na versão (commit) que este livro fixa, apresenta os três tamanhos da família em uma única frase: 135M, 360M e 1.7B parâmetros. O mesmo card indica a licença como license: apache-2.0, que os pins do livro registram para os dois modelos que ele mantém. O card também informa que os dados de treinamento do modelo de 135M somam 2 trilhões de tokens. Esses números vêm apenas do card do modelo de 135M.

O livro mantém dois dos três tamanhos. A lista abaixo os nomeia, e a tabela em seguida coloca os três lado a lado, com a licença que cada pin registra.

  • SmolLM2-135M-Instruct é o modelo central. O restante do livro o treina e o serve.
  • SmolLM2-360M-Instruct é uma comparação. O livro o carrega, conta seus parâmetros e camadas, e o usa ao lado do modelo central neste capítulo e no capítulo 4. O livro não o treina.
Modelo Papel neste livro Fixado em models.toml Licença
SmolLM2-135M-Instruct Modelo central, treinado e servido pelo restante do livro Sim Apache-2.0
SmolLM2-360M-Instruct Comparação ao lado do modelo central Sim Apache-2.0
SmolLM2 1.7B Não fixado e não executado Não Nenhuma registrada

O modelo 1.7B não está fixado no arquivo models.toml do livro, e o livro não o executa. Os exemplos do livro definem duas threads de CPU, então cada candidato precisa carregar e rodar dentro desse orçamento. Para um banco com esse orçamento, recomendamos o modelo de 135M como ponto de partida, pelas razões do restante deste capítulo.

O ponto de referência do livro é outro modelo. No caso, um modelo hospedado roteia hoje as mensagens do banco, e este livro nunca o chama. Seu substituto é o Qwen3-4B-Instruct-2507, um modelo aberto maior, cujas respostas às mensagens de teste são registradas uma única vez e depois lidas offline. O substituto é a linha de base contra a qual os candidatos são medidos, não um candidato para o roteador. O capítulo 1 o apresenta.

Regra prática: Comece pelo menor modelo da família que atenda às medidas que você definir na divisão dev, as mensagens de treinamento reservadas para a escolha (capítulo 2). Suba um tamanho somente quando o modelo menor não atingir uma medida, e apenas depois de ter medido o modelo maior nas mesmas amostras. Esta é uma regra prática. Ela vale até que as suas próprias medições digam o contrário.

Carregue cada modelo na revisão fixada

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

A seção anterior citou dois modelos. Um nome isolado não diz qual versão dos arquivos do modelo você carrega, porque um modelo fica armazenado em um repositório de commits, e um branch como main pode avançar para um novo commit. Uma revisão fixada por um hash completo de commit identifica um único snapshot dos arquivos, e o arquivo de pins, examples/models.toml, registra o SHA-256 de cada arquivo desse snapshot, que o runtime verifica. O loader compartilhado passa o commit para a biblioteca transformers, que o livro fixa em 5.23.0, e o loader procura no arquivo o commit de cada modelo.

Para cada modelo, o arquivo traz o repositório, o commit, a licença e o SHA-256 de cada arquivo de que o modelo precisa. O cabeçalho do arquivo informa que o runtime baixa cada modelo uma vez, verifica arquivo por arquivo e depois o lê offline. O arquivo é gerado por re-check models --pin, e o cabeçalho diz para não editá-lo à mão. Assim, um leitor que altera um pin executa esse comando em vez de digitar um novo commit no arquivo. Um modelo sem pin não tem commit a ser procurado, e por isso o loader compartilhado não o carrega.

Os exemplos definem as flags offline da biblioteca antes de importá-la, de modo que um carregamento lê apenas o que o runtime já possui. O loader também define os pesos como float32 e executa a atenção na forma eager simples da biblioteca. As regras de determinismo do livro fixam esses dois pontos, de modo que cada execução de um exemplo produz os mesmos números. Se um carregamento offline falhar na máquina do leitor, compare os arquivos em disco com a lista do arquivo de pins antes de mudar qualquer outra coisa.

O exemplo também acompanha os pins pelo lado da saída. Ele imprime a contagem de parâmetros de cada modelo, de modo que uma mudança no tamanho de um modelo aparece como uma linha alterada na própria saída do livro, e todo número que o capítulo cita dessa linha muda junto. Um leitor que vê uma contagem diferente sabe qual pin deve comparar primeiro. Uma mudança de commit que mantém o mesmo tamanho não aparece ali, por isso o próprio pin continua sendo o registro.

Um exemplo carrega os dois modelos escolhidos a partir dos arquivos que o runtime baixou e verificou contra os pins, sem rede, e imprime as primeiras contagens de tamanho do livro.

load-both-models-offline.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Load the 135M and 360M SmolLM2 models at their pins, offline, and print each one's parameter count and layer count. The chapter's size claims rest on both lines; the parameter line is rounded to whole millions."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402# Seeds, deterministic algorithms and float32, set before either model loads.router_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"MEDIUM = "HuggingFaceTB/SmolLM2-360M-Instruct"def size(model):    """Return (parameter count in millions, rounded to a whole number) and the layer count."""    # parameters() yields a shared tensor once, so the tied embedding and output head count once.    total = sum(p.numel() for p in model.parameters())    return round(total / 1e6), model.config.num_hidden_layers# load_model returns (tokenizer, model). This example needs only the models._, small = router_lib.load_model(SMALL)_, medium = router_lib.load_model(MEDIUM)small_millions, small_layers = size(small)medium_millions, medium_layers = size(medium)print(f"parameters, millions, rounded: {small_millions} and {medium_millions}")print(f"layers: {small_layers} and {medium_layers}")
Saídapython load-both-models-offline.py
parameters, millions, rounded: 135 and 362
layers: 30 and 32

Um parâmetro é um dos números que o modelo aprende durante o treinamento, e uma camada é um dos blocos empilhados pelos quais um token passa. Parâmetros e camadas são os únicos dois tamanhos que este capítulo usa. O modelo de 360M é o maior dos dois. A primeira linha da saída informa a contagem de parâmetros de cada modelo, arredondada para milhões inteiros: 135 and 362. A segunda linha informa as contagens de camadas, 30 and 32, na mesma ordem. A velocidade não está entre elas, porque um tempo depende da máquina. A gravação de throughput mede o classificador e sua cópia em int8 em relação ao substituto em uma máquina identificada (capítulo 7 explica como, e capítulo 10 relata as razões). A gravação não mede o modelo de 360M.

As contagens vêm do carregamento dos modelos aqui, e não de suas fichas.

Em produção, o pin responde à primeira pergunta que você faz quando um resultado muda, que é quais arquivos produziram esse resultado. Uma mudança de modelo aparece como um diff em models.toml, onde ficam o commit e os hashes dos arquivos. Quando a cópia de um modelo do leitor produz uma saída diferente da do livro, compare primeiro o commit.

Regra prática: fixe cada modelo pelo seu commit em examples/models.toml, e carregue-o com esse commit e com as flags offline. Registre as contagens de parâmetros e de camadas ao lado do pin, de modo que uma mudança no tamanho de um modelo apareça como uma linha de saída alterada, e não como uma surpresa em um capítulo posterior.

Meça o que uma mensagem custa

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

A seção anterior mostrou o que são os dois modelos. Esta seção mostra o que uma mensagem custa a eles. O custo de uma mensagem vem do que o modelo lê e do que ele escreve. O prompt do roteador contém os 77 nomes de equipe, a mensagem e um pedido pela equipe, e a lista de equipes é a mesma em todas as chamadas, então toda mensagem paga por ela.

O prompt começa com a frase "Route this customer message from an online bank to one support team." Ele pede apenas o nome da equipe, lista as equipes, depois apresenta a mensagem e termina com a palavra "Team:". Tudo nesse texto é igual de uma mensagem para a seguinte, exceto a própria mensagem, de modo que o custo de uma mensagem é o texto fixo mais o tamanho da própria mensagem.

O tokenizador transforma o texto do prompt em tokens, as unidades que um modelo lê. A contagem é feita em tokens e não em caracteres porque um modelo lê tokens. Contar exige as regras do tokenizador, mas nenhum peso, de modo que a contagem é o primeiro custo que você pode obter antes de escolher um desenho. Um classificador lê a mensagem uma vez e devolve uma pontuação para cada equipe. Um modelo generativo lê o prompt uma vez e depois escreve a resposta um token por vez, e cada token escrito é mais uma passagem pela rede. Os capítulos seguintes usam os dois desenhos.

Um exemplo conta as passagens para frente, cada uma uma chamada da rede, para uma única mensagem de teste em cada desenho. Ele usa o modelo de 135M sem adaptador. A cabeça do classificador não está treinada aqui, então só a contagem de passagens importa.

count-forward-passes.py Python 3.12.15 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Count the forward passes one test_40 message costs a classifier and a generative model, with the 135M model and no adapter. The point rests on the generative line: the model makes one pass for each token it writes, plus one for the end token."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402from transformers import AutoModelForSequenceClassification  # noqa: E402router_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"texts = [text for text, _ in router_lib.read_rows("test")]# read_sample gives row indices into the test split; index 0 is the sample's first message.message = texts[router_lib.read_sample("test_40")[0]]def count_passes(model, run):    """Return how many forward calls the model makes while run() executes."""    calls = []    # A forward hook on the whole model fires once per call to its forward, so each generation step counts.    handle = model.register_forward_hook(lambda module, args, output: calls.append(1))    run()    handle.remove()    return len(calls)tokenizer, causal = router_lib.load_model(SMALL)# SmolLM2's tokenizer sets a pad token; this line keeps the example working with one that doesn't.tokenizer.pad_token = tokenizer.pad_token or tokenizer.eos_token# The trie holds each team name's tokens, so constrained_team can write only a team name, one token per pass, then the end token.trie = router_lib.build_trie(tokenizer)# The pinned commit from models.toml, and the float32 weights and eager attention that load_model also sets.# The head is new, with one score per team (77), and untrained here; only the pass count matters.classifier = AutoModelForSequenceClassification.from_pretrained(    SMALL, revision=router_lib._pins()[SMALL], num_labels=len(router_lib.LABELS),    dtype=torch.float32, attn_implementation="eager",).eval()# The classification head finds each message's last token through this id, so the config needs it too.classifier.config.pad_token_id = tokenizer.pad_token_idclassifier_passes = count_passes(classifier, lambda: router_lib.classify(classifier, tokenizer, [message]))answers = []generative_passes = count_passes(causal, lambda: answers.append(router_lib.constrained_team(tokenizer, causal, trie, message)))# answers[0] holds (label index, label text). The text is encoded with a leading space, as the model writes it after "Team:".answer_tokens = len(tokenizer.encode(" " + answers[0][1], add_special_tokens=False))print(f"classifier forward passes: {classifier_passes}")print(f"generative forward passes: {generative_passes}")print(f"answer tokens, end token not counted: {answer_tokens}")
Saídapython count-forward-passes.py
classifier forward passes: 1
generative forward passes: 8
answer tokens, end token not counted: 7

O custo de um modelo generativo cresce com a sua resposta, e o de um classificador não. Para esta mensagem, o classificador faz 1 passagem. O modelo generativo faz 8 passagens, uma para cada um dos 7 tokens de sua resposta e uma para o token de fim.

Um segundo exemplo conta os tokens do prompt do roteador para cada uma das 40 mensagens da amostra de teste fixa, usando o tokenizador do modelo de 135M. Ele não executa nenhum modelo.

count-prompt-tokens.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Aprovado
"""Count the router prompt's tokens for each message in test_40, with the 135M model's tokenizer. No model runs. The point rests on the mean line: a day's prompt cost is the mean, not the median, times the number of messages."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)import router_lib  # noqa: E402from transformers import AutoTokenizer  # noqa: E402router_lib.setup_runtime()SMALL = "HuggingFaceTB/SmolLM2-135M-Instruct"# Only the tokenizer is read from the pinned commit; no weights load.tokenizer = AutoTokenizer.from_pretrained(SMALL, revision=router_lib._pins()[SMALL])texts = [text for text, _ in router_lib.read_rows("test")]# read_sample gives row indices into the test split, in the order the sample lists them.messages = [texts[i] for i in router_lib.read_sample("test_40")]# router_prompt builds the same prompt the router sends. encode keeps its default, so any special tokens are counted too.counts = sorted(len(tokenizer.encode(router_lib.router_prompt(message))) for message in messages)# The median of an even count is the lower of the two middle values, so it is a whole number of tokens.median = counts[(len(counts) - 1) // 2]total = sum(counts)mean = round(total / len(counts))print(f"messages: {len(counts)}")print(f"prompt tokens min: {counts[0]}")print(f"prompt tokens median: {median}")print(f"prompt tokens max: {counts[-1]}")print(f"prompt tokens total: {total}")print(f"prompt tokens mean, rounded: {mean}")
Saídapython count-prompt-tokens.py
messages: 40
prompt tokens min: 580
prompt tokens median: 585
prompt tokens max: 614
prompt tokens total: 23493
prompt tokens mean, rounded: 587

Os prompts diferem apenas nas suas mensagens, porque a lista de equipes é o mesmo texto em todos os prompts. Assim, a variação vai de 580 tokens para o prompt mais curto até 614 para o mais longo, com mediana de 585 tokens. A mediana é o menor dos dois valores do meio, de modo que é um número inteiro de tokens.

Em produção, a contagem muda quando a lista de equipes muda. Acrescentar uma equipe acrescenta o seu nome a todos os prompts, de modo que toda mensagem passa a custar mais a partir desse dia. Refaça a contagem após cada alteração na lista, e mantenha a lista na mesma ordem, para que o restante do prompt não mude junto.

Para transformar a contagem em um número para um dia, use a média, e não a mediana, porque os tokens de prompt de um dia são a soma de seus prompts. As 40 mensagens da amostra totalizam 23493 tokens, uma média de 587 tokens cada. Aqui a média está acima da mediana, então multiplicar a mediana pela contagem de mensagens subestimaria os tokens do prompt. Multiplique a média pelo número de mensagens que o roteador trata naquele dia para obter os tokens de prompt que ele lê, antes de contar a saída. O lado da saída depende do desenho, e os desenhos aparecem nos capítulos seguintes.

Esta seção dá apenas contagens. O tempo que uma mensagem leva é tarefa da gravação, como a etapa de carregamento observou.

Regra prática: Conte os tokens do prompt com o tokenizador do modelo que você vai executar, antes de escolher um desenho, e conte de novo sempre que o prompt mudar. A contagem pertence a esse tokenizador, de modo que uma contagem feita com o tokenizador de outro modelo responde a outra pergunta.

Por que 135M é o núcleo

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

As seções anteriores deram ao modelo de 135M o seu lugar: ele é menor e é o modelo que o restante do livro treina e serve. Esta seção apresenta as razões dessa escolha e indica onde a escolha ainda não está comprovada.

Há duas maneiras amplas de fazer um modelo pequeno encaminhar uma mensagem. Uma é perguntar a um modelo, no prompt, qual equipe escolher. A outra é treinar um modelo com mensagens rotuladas. Bucher e Martini compararam modelos do tipo BERT ajustados (fine-tuned) com grandes modelos hospedados, como ChatGPT e Claude Opus, usados com prompt zero-shot, em um pré-print de 2024. O resumo deles afirma que os modelos pequenos ajustados superam os grandes com prompt, de forma consistente e significativa (arXiv:2406.08660v2). A comparação opõe modelos pequenos ajustados a grandes com prompt, e não pequenos contra pequenos, e vem de um único pré-print. O livro a toma como razão para medir primeiro um modelo pequeno ajustado. Não a toma como prova de que o modelo ajustado vence na caixa de entrada.

As duas concepções também falham de maneiras diferentes, e a contagem de custos não mostra isso. Um modelo generativo escreve a resposta como texto, então o texto pode ser uma cadeia de caracteres que não corresponde a nenhuma das 77 equipes. Um classificador atribui uma pontuação a cada uma das 77 equipes, então a resposta é sempre uma delas, e a pontuação é o que a regra de encaminhamento lê para enviar a uma pessoa as mensagens sobre as quais o modelo não está seguro. O capítulo 4 restringe a resposta generativa aos 77 nomes, e o capítulo 5 treina o classificador.

As razões de custo se apoiam nas contagens da etapa de carregamento. Pelas duas contagens que ela imprimiu, o modelo de 135M é o menor: 135 and 362 milhões de parâmetros e 30 and 32 camadas, com o valor do 135M em primeiro lugar em cada par. O cartão do modelo de 135M o descreve como leve o bastante para rodar no próprio dispositivo e capaz em uma ampla gama de tarefas. Os exemplos do livro são a evidência das contagens, e o cartão é a evidência da descrição.

O cartão também limita o que o modelo deve fazer: "Estes modelos devem ser usados como ferramentas de apoio, e não como fontes definitivas de informação." Essa ressalva está de acordo com o desenho do roteador. Um modelo deste tamanho é um assistente para a equipe de atendimento, e uma mensagem sobre a qual ele não está seguro vai para uma pessoa. O capítulo 1 apresenta esse encaminhamento.

Este capítulo não mostra que o modelo de 135M atende às medidas. O capítulo 4 executa os dois modelos sobre as mesmas mensagens, que é a comparação de que esta seção carece. O capítulo 5 treina o modelo de 135M com as mensagens rotuladas e o mede na divisão dev contra as medidas definidas no capítulo 2. Até lá, a escolha se apoia nas contagens de custo e no estudo citado acima.

Três coisas mudariam esta escolha, e cada uma é decidida por uma medição, e não por argumentação. Se o modelo de 135M não atingir uma medida da divisão dev depois do ajuste, o próximo passo é treinar o de 360M com as mesmas linhas de treinamento, medi-lo do mesmo modo e comparar os dois na divisão dev. Se o modelo de 135M atingir as medidas da divisão dev, mas encaminhar mais mensagens do que a equipe de atendimento consegue atender, a alavanca é o limiar de encaminhamento. O capítulo 5 define esse limiar na divisão dev, junto com a taxa de encaminhamento que ele custa. Se o banco passar a encaminhar um conjunto diferente de mensagens, a escolha recomeça, pois as medidas deste capítulo descrevem as mensagens bancárias e nenhuma outra.

A escolha tem um custo que você deve pesar, e este capítulo não o mede. Ele não informa nem o tempo de carregamento nem o tempo de execução de nenhum dos dois modelos, e a regra prática da primeira seção exige essa medição antes de a escolha ser definitiva. Este capítulo faz a escolha de forma provisória, e os capítulos seguintes ou a confirmam ou a substituem pelas mesmas medidas.

Regra prática: Ajuste primeiro o modelo menor e meça-o na divisão dev contra as medidas que você definiu antes de olhar a divisão de teste. Mantenha o modelo maior como comparação até que o menor deixe de atingir uma medida na divisão dev, e não troque de modelo na divisão de teste.

O que um modelo maior exigiria

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

A seção anterior escolheu o modelo menor e deixou em aberto a questão do maior, o SmolLM2-360M-Instruct. Esta seção expõe o que essa questão exige e o que o livro sabe e não sabe a respeito.

Um modelo maior não é automaticamente melhor para uma tarefa restrita. Um estudo publicado pela primeira vez em 2024, e aceito na EMNLP 2025, compara ajuste fino, ajuste por instruções, prompting e aprendizado em contexto (in-context learning) em oito modelos de linguagem e oito tarefas de classificação de texto. Seu resumo conclui que modelos maiores não oferecem, de forma consistente, melhor desempenho nem menor variância (arXiv:2402.12819v4). É um único estudo, e o livro o usa para justificar a medição do modelo maior, não para descartá-lo.

A questão em aberto é se o 360M, treinado com a mesma receita do 135M, superaria as medidas no conjunto dev por uma margem que compense o custo extra. O livro não treina o 360M, por isso não sabe. Ele não mediu o tempo de treinamento nem a memória que uma execução com o 360M exigiria nas duas threads de CPU usadas pelos exemplos do livro. O capítulo 4 usa o 360M como comparação sobre os mesmos prompts.

Um leitor que queira essa resposta pode seguir o mesmo caminho que o livro seguiu. O 360M já está fixado e carrega offline, como mostra a etapa de carregamento. Conte os tokens do prompt do roteador com o tokenizador do 360M e, em seguida, treine o modelo com as mesmas linhas de treinamento usadas para o 135M. Cada etapa é uma mudança separada, e a comparação permanece sobre os mesmos dados, de modo que os dois resultados podem ser colocados lado a lado na divisão dev.

O maior modelo da família, o 1.7B, exigiria ainda mais. O livro não o fixa e não faz nenhuma afirmação sobre ele.

O custo por mensagem de um modelo maior surge com cada mensagem que ele atende, e o livro não mede esse custo para o 360M. A etapa de carregamento já mostra o quanto o 360M é maior antes de alguém treiná-lo, com 135 and 362 milhões de parâmetros e 30 and 32 camadas, sendo a cifra do 135M a primeira de cada par. A gravação throughput no capítulo 7 mede o classificador e sua cópia int8 contra o substituto em uma máquina identificada, e o 360M não está nela.

As decisões tomadas neste capítulo, para o leitor conferir com as necessidades do seu próprio banco:

  • O modelo principal é o SmolLM2-135M-Instruct, e a comparação é o SmolLM2-360M-Instruct.
  • Os dois modelos carregam nos commits em examples/models.toml, offline, pelo carregador compartilhado.
  • O custo do prompt do roteador é contado em tokens com o tokenizador do modelo 135M, e nenhum modelo é executado para essa contagem.
  • Nenhuma cifra de tempo ou de memória aparece neste capítulo. Essas virão depois, de uma medição em uma máquina identificada.
  • O 360M não é treinado neste livro.

A lição a levar adiante é que um estudo publicado pode afirmar que um modelo maior talvez não ajude, e apenas a sua própria medição, sobre as suas próprias amostras, diz se ele ajuda.

Regra prática: Antes de escolher um modelo maior, treine-o com a mesma receita que usou para o menor e meça-o sobre as mesmas amostras de dev e de teste, na sua própria máquina. Julgue-o pelas suas medidas e pelo que custa executá-lo nessa máquina, e não por uma pontuação publicada.

Este capítulo, nesta edição

Edição 2026.11.9Exemplos aprovados em 20 de nov de 20263 de 3 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 3 de 10: Escolha um modelo base contando quanto custa uma mensagem

  1. Quais candidatos mantemos
  2. Carregue cada modelo na revisão fixada
  3. Meça o que uma mensagem custa
  4. Por que 135M é o núcleo
  5. O que um modelo maior exigiria

Voltar ao topoTodos os capítulos