LLM Benchmark: 60+ Testes lm-evaluation-harness [2026]
LLM Benchmark: como avaliar modelos de IA com o lm-evaluation-harness — e não cair no marketing do lançamento [2026]
Guia completo para desenvolvedores que precisam escolher um modelo de linguagem com dados próprios, hardware próprio e critérios que sobrevivem à próxima atualização do fabricante.
O gráfico de barras não é a verdade
Todo lançamento de LLM segue o mesmo roteiro. Vem um post de blog, um gráfico de barras com quatro ou cinco siglas — MMLU, GPQA, HumanEval, SWE-bench — e uma barra do novo modelo ligeiramente acima das concorrentes. A peça circula no X, no LinkedIn, em grupos de Telegram, e em 48 horas já existe uma legião de devs convencidos de que precisam migrar tudo para o modelo da vez.
Só que, em setembro de 2026, com dezenas de modelos open-source de pesos abertos disputando o mesmo espaço — das famílias Llama, Qwen, Mistral, DeepSeek, Gemma e uma infinidade de fine-tunes derivados —, a pergunta relevante deixou de ser "qual é o melhor modelo do mundo" e passou a ser "qual é o melhor modelo para o meu caso de uso, no meu hardware, com os meus dados". E essa pergunta nenhum gráfico de lançamento responde.
Este artigo faz três coisas: mostra como ler um benchmark sem comprar a narrativa do fabricante, explica o que o lm-evaluation-harness realmente mede nas suas 60+ tarefas e entrega um roteiro prático para você rodar a sua própria avaliação — inclusive criando testes sob medida para o seu domínio.
Por que o benchmark do fabricante é um documento de marketing
Isso não é acusação de má-fé. É apenas a natureza do gênero. Quando uma empresa publica números de benchmark, ela controla simultaneamente:
- Quais tarefas entram na tabela — e, mais importante, quais ficam de fora;
- Quantos exemplos few-shot são dados no prompt (o mesmo modelo pode ganhar ou perder 5 pontos percentuais dependendo de 0-shot, 5-shot ou 25-shot);
- O formato exato do prompt — um template levemente diferente muda o resultado de forma dramática em modelos pequenos;
- A versão da tarefa — MMLU não é uma coisa monolítica, e subsets revisados podem alterar rankings;
- O que conta como acerto — comparação exata de string, escolha múltipla por log-probabilidade, ou um modelo juiz avaliando texto livre? Cada método produz números distintos;
- O baseline escolhido — comparar contra a versão antiga da própria família de modelos é muito mais confortável do que comparar contra o melhor da concorrência;
- O momento da medição — números de um checkpoint intermediário, de um modelo destilado ou de uma versão com ferramentas (tool use, busca, execução de código) não são a mesma coisa que o modelo base respondendo sozinho.
Isso nos leva às quatro perguntas que desmontam quase todo benchmark de lançamento. Faça-as sempre, na ordem:
1. Quem mediu?
O número foi produzido por um laboratório independente, por um terceiro com reputação de reprodutibilidade, ou pela própria equipe que lançou o modelo? Todos os três cenários existem e são legítimos — mas apenas os dois primeiros merecem tratamento de evidência.
2. O que exatamente foi medido?
"Supera o GPT-X em raciocínio" significa o quê? Matemática de ensino médio (GSM8K)? Matemática de competição (MATH, AIME)? Raciocínio multietapa (BBH)? Conhecimento científico de nível de pós-graduação (GPQA)? São habilidades diferentes, com correlações fracas entre si. Um modelo pode dominar MMLU e fracassar em instruções simples de formatação.
3. Em qual versão da tarefa?
Benchmarks evoluem. Tarefas saturadas ganham versões mais difíceis (MMLU → MMLU-Pro, por exemplo), datasets problemáticos são corrigidos e splits são redefinidos. Se o número da tabela não cita a versão, ele é inauditável.
4. Qual era o harness?
O instrumento de medição importa. Números obtidos com o lm-evaluation-harness, com o HELM ou com scripts caseiros não são comparáveis entre si sem cuidado. A boa notícia é que o harness do EleutherAI virou, na prática, o denominador comum do ecossistema open-source — o que torna a reprodutibilidade possível.
O que é o lm-evaluation-harness
O lm-evaluation-harness é um framework de código aberto mantido pela EleutherAI que padroniza a avaliação de modelos de linguagem. A ideia central é simples e poderosa: um único comando executa dezenas de tarefas contra um modelo, com prompts, métricas e protocolos de few-shot definidos de forma versionada.
Na prática, ele resolve três problemas que atormentam quem tenta avaliar LLMs por conta própria:
- Padronização de prompt e métrica — você não inventa o formato de cada tarefa; ele já está implementado e documentado;
- Comparabilidade — se você e outra pessoa rodam a mesma tarefa, na mesma versão, no mesmo harness, os números conversam;
- Cobertura — são mais de 60 tarefas agrupadas em domínios: conhecimento geral, raciocínio, matemática, código, compreensão de leitura, seguimento de instruções, veracidade, multilinguismo e segurança.
O fluxo básico é sempre o mesmo: você aponta o harness para um modelo (local via Hugging Face Transformers, via vLLM para inferência rápida, ou por API), escolhe as tarefas, define o número de shots e as opções de execução, e recebe uma tabela de resultados com métricas por tarefa, barra de erro e tempo de execução.
As famílias de tarefas: o que cada sigla mede de verdade
Decorar siglas não serve de nada se você não sabe o que elas capturam — e o que elas deixam de fora. Um mapa mental útil:
Conhecimento enciclopédico e acadêmico
- MMLU — questões de múltipla escolha em 57 disciplinas, de matemática elementar a direito profissional. É o teste mais citado e o mais saturado: os modelos de ponta já flertam com o teto, o que reduz seu poder de discriminação.
- MMLU-Pro — versão endurecida, com mais alternativas por questão e maior exigência de raciocínio, justamente para recuperar a capacidade de separar modelos.
- ARC (Easy/Challenge) — ciências do ensino fundamental e médio, desenhado para exigir raciocínio e não recuperação de fatos.
- GPQA — perguntas de nível de pós-graduação em física, química e biologia, escritas para serem difíceis até para especialistas com acesso à internet.
Raciocínio e lógica
- BBH (Big-Bench Hard) — seleção de tarefas nas quais modelos ainda ficavam abaixo do desempenho humano médio: rastreamento de objetos, dedução lógica, navegação espacial, detecção de falácias.
- HellaSwag — completar a continuação mais plausível de uma cena cotidiana. Parece trivial, mas exige modelagem de senso comum.
- WinoGrande — resolução de ambiguidade pronominal; testa se o modelo realmente entende referências.
Matemática
- GSM8K — problemas de matemática do ensino fundamental com solução em etapas. Historicamente o primeiro grande marco de "raciocínio" dos LLMs, hoje amplamente superado.
- MATH — problemas de competição, com respostas que exigem manipulação simbólica e prova.
- AIME e correlatos — competições reais; usados como teste de teto para modelos de raciocínio estendido.
Código
- HumanEval — geração de funções Python a partir de docstrings, validadas por execução de testes unitários.
- MBPP — problemas curtos de programação, também validados por execução.
Um detalhe que quase sempre se perde: HumanEval e MBPP medem geração de funções isoladas, não engenharia de software. Para avaliar se o modelo consegue navegar um repositório, corrigir um bug e não quebrar testes existentes, o instrumento certo é outro — benchmarks de tarefas de repositório e agentes de código. Confundir os dois leva a decisões ruins de contratação de modelo.
Seguimento de instruções e veracidade
- IFEval — mede se o modelo obedece restrições verificáveis programaticamente: "responda em exatamente três parágrafos", "use JSON válido", "não use a letra e". Esse é frequentemente o benchmark mais preditivo do que importa em produção.
- TruthfulQA — mede a tendência de o modelo reproduzir equívocos populares. Atenção: a métrica pode ser manipulada por modelos que preferem dizer "não sei" a arriscar.
- Tarefas multilíngues — cobertura de raciocínio e compreensão em idiomas além do inglês, incluindo português. Se o seu produto é em PT-BR, essa é a fatia da tabela que você precisa olhar primeiro.
Mãos à obra: rodando o harness em 11 passos
O roteiro abaixo é o mesmo que aplico antes de decidir qualquer migração de modelo em produção.
Passo 1 — Defina a pergunta antes da ferramenta
Não rode "todos os benchmarks". Escreva a decisão em uma frase: "preciso de um modelo que resuma laudos técnicos em português com fidelidade factual, roda em uma GPU de 24 GB e responde em menos de 3 segundos". Essa frase define quais tarefas importam — e quais são ruído.
Passo 2 — Monte uma lista curta de candidatos
Três a cinco modelos, no máximo. Inclua sempre um baseline: um modelo que você já usa, ou um modelo pequeno e barato. Sem baseline, você não sabe se o ganho justifica o custo.
Passo 3 — Fixe o ambiente
Registre versões: do harness, do dataset, da biblioteca de inferência, do driver da GPU, do próprio modelo (hash do checkpoint, não apenas o nome do repositório). Um resultado sem versões é uma anedota.
Passo 4 — Escolha o backend de inferência
Para exploração rápida, backends otimizados de alta vazão (como vLLM) permitem rodar dezenas de tarefas em horas em vez de dias. Para reprodutibilidade exata de números de terceiros, o caminho padrão em Transformers é mais próximo do que os laboratórios publicaram. Saiba qual dos dois você está fazendo.
Passo 5 — Comece pequeno
Rode uma tarefa barata e rápida primeiro, com poucas amostras, apenas para validar que o pipeline inteiro funciona: modelo carrega, prompt é montado, métrica é calculada, resultado é salvo. Descobrir um erro de configuração depois de 18 horas de execução é doloroso.
Passo 6 — Padronize o few-shot
Escolha um protocolo (por exemplo, 5-shot para tarefas de conhecimento) e use o mesmo em todos os candidatos. Comparar 0-shot de um modelo com 25-shot de outro é o erro metodológico mais comum e mais silencioso.
Passo 7 — Rode o conjunto principal
Uma seleção equilibrada que costuma render boas decisões: conhecimento (MMLU-Pro), raciocínio (BBH), matemática (GSM8K e uma tarefa de nível superior), código (HumanEval ou MBPP), instruções (IFEval), veracidade (TruthfulQA) e multilíngue. Sete ou oito tarefas. Mais do que isso, você gasta semanas para descobrir que a decisão já estava tomada na terceira.
Passo 8 — Meça custo e latência junto com acurácia
Um modelo 3 pontos melhor em MMLU que responde 6 vezes mais devagar e custa 4 vezes mais por token pode ser a escolha errada. Registre tokens por segundo, latência p95, memória de pico e custo por mil requisições. Esses números decidem mais migrações do que qualquer ponto percentual.
Passo 9 — Verifique contaminação de dados
Pergunte-se: esse modelo foi treinado nos dados de teste? Benchmarks públicos vazam para corpora de treinamento com frequência. Um sinal de alerta clássico é desempenho excepcionalmente alto em uma tarefa e medíocre em tarefas correlatas. Se você tem acesso ao modelo, uma checagem útil é reformular as perguntas com sinônimos: se a acurácia despenca, o modelo pode estar reconhecendo o item, não resolvendo o problema.
Passo 10 — Construa seu próprio conjunto de avaliação
Aqui está o trabalho que realmente paga. Colete 100 a 300 exemplos reais do seu domínio, com respostas de referência ou critérios de aceitação. Pode ser um arquivo JSONL simples: entrada, saída esperada, e uma rubrica de avaliação. Rode esse conjunto em todos os candidatos. Na minha experiência, a correlação entre esse conjunto e os benchmarks públicos costuma ser desconfortavelmente baixa — o que significa que os benchmarks públicos são úteis para filtrar candidatos, não para escolher o vencedor.
Passo 11 — Documente e reavalie
Guarde a configuração exata, os resultados brutos e a data. Modelos são atualizados, quantizações mudam, e o harness evolui. Um painel de avaliação datado, reprodutível, vale mais do que qualquer impressão subjetiva acumulada em seis meses de uso.
As armadilhas que distorcem resultados
- Saturação de benchmark — quando todos os modelos de ponta marcam 88% em uma tarefa, ela deixou de discriminar. Migre para a versão mais difícil ou para um conjunto próprio.
- Contaminação de dados — o problema mais grave e o mais difícil de detectar. Trate qualquer número muito acima do esperado como suspeito até prova em contrário.
- Sensibilidade ao formato do prompt — pequenas variações de template podem valer vários pontos. Se o seu prompt de produção é diferente do prompt do benchmark, o número do benchmark não descreve o seu caso.
- Quantização — rodar um modelo em 4 bits para caber na sua GPU altera o desempenho. Um bom exercício é medir o mesmo modelo em duas quantizações diferentes e ver quanto você perde.
- Determinismo mal compreendido — temperatura zero não garante reprodutibilidade bit a bit em todos os backends. Rode múltiplas sementes em tarefas de geração livre.
- Média enganosa — uma média de 78% pode esconder 95% em tarefas fáceis e 40% na tarefa que importa para você. Sempre olhe a tabela por tarefa, nunca só o agregado.
Além do harness: avaliação para o que não tem resposta certa
Benchmarks clássicos funcionam bem quando existe uma resposta verificável. Mas a maior parte do valor real de um LLM em produto está em tarefas abertas: resumir, reescrever, classificar, extrair, conversar. Para isso, o harness é o ponto de partida, não o ponto final.
Três abordagens complementares:
- Avaliação por rubrica — defina critérios explícitos (fidelidade factual, completude, tom, formato) e pontue cada resposta de 1 a 5. Simples, auditável e surpreendentemente eficaz.
- LLM como juiz, com cuidado — use um modelo forte para comparar duas respostas lado a lado. Funciona bem para preferência relativa, mas exige atenção a vieses conhecidos: preferência por respostas mais longas, por texto formatado com listas e por outputs do próprio modelo juiz. Sempre valide uma amostra manualmente.
- Testes em produção — shadow deployment, comparação A/B e coleta de feedback implícito (o usuário aceitou a sugestão? editou? descartou?). É a avaliação mais cara e a mais honesta.
Conclusão: benchmarks são bússola, não veredito
O lm-evaluation-harness transformou a avaliação de LLMs de exercício artesanal em prática reproduzível. Com mais de 60 tarefas padronizadas, ele resolve o problema de comparabilidade que atormentava o ecossistema open-source há alguns anos. Mas ele não resolve — e nenhuma ferramenta resolve — a pergunta que realmente importa: este modelo funciona para o meu problema?
A resposta para essa pergunta vem de três camadas. Primeiro, desconfiança saudável dos números de lançamento: pergunte quem mediu, o que mediu, em que versão e com qual harness. Segundo, execução disciplinada do harness nos seus candidatos, com ambiente fixado, few-shot padronizado e custo e latência medidos junto com acurácia. Terceiro — e mais importante —, um conjunto de avaliação próprio, construído com dados reais do seu domínio, que nenhum fabricante pode ter preparado por você.
Fabricantes otimizam para o benchmark que vai aparecer no gráfico. Você deveria otimizar para o benchmark que aparece no seu usuário. Quando essas duas coisas coincidem, ótimo. Quando divergem, é o seu que decide.