---
title: "Avaliar um LLM antes de trocar: eval set e LLM juiz | BroadRouter"
description: "Monte um pequeno eval set com tráfego real, avalie com checagens em código e um LLM juiz sem viés, e compare qualidade, custo e latência antes de migrar."
url: https://broadrouter.com/pt/blog/evaluate-llm-before-switching/
lang: pt-BR
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/evaluate-llm-before-switching/) (atualizado em 2026-11-14).

# Como avaliar um LLM antes de trocar de provedor

Pela equipe da BroadNet Inference · 5 min de leitura · Publicado em 2026-11-14

Reúna de 50 a 200 prompts reais com resultado correto conhecido. Avalie os dois modelos primeiro com checagens em código e use um LLM juiz só onde o código não consegue decidir. Inverta a ordem das respostas para anular o viés de posição, use um juiz de uma terceira família de modelos, confira-o contra os seus próprios rótulos e defina a regra de aprovação, incluindo custo e latência, antes de rodar.

## Pontos principais

-   Monte o eval set a partir de logs reais, não de prompts inventados, e inclua os casos difíceis e os que falham.
-   Prefira checagens determinísticas (o JSON faz parse, o campo bate, o teste passa). Use um LLM juiz só para qualidades que o código não consegue verificar.
-   LLMs juízes têm viés de posição, de verbosidade e de autopreferência. Julgue cada par duas vezes com a ordem invertida.
-   Com 100 casos, uma nota de 80% tem margem de 95% de cerca de ±8 pontos. Diferenças pequenas são ruído.
-   Defina a regra de aprovação antes, incluindo custo, latência e nenhuma regressão em casos críticos.

**Nesta página**

1.  Como montar um eval set a partir de tráfego real?
2.  Quais checagens devem ser em código e quais com um juiz?
3.  O que dá errado com o LLM como juiz?
4.  Como fazer uma comparação lado a lado?
5.  Que tamanho de diferença é real?
6.  Qual deve ser a regra de decisão?
7.  Onde a BroadNet Inference se encaixa

Para avaliar um LLM antes de trocar, rode os dois modelos em 50 a 200 prompts reais com resultado correto conhecido. Avalie primeiro com checagens em código e use um LLM juiz sem viés só onde o código não consegue decidir, registre custo e latência e defina a regra de aprovação com antecedência.

A mudança no código é pequena: com uma [API compatível com a OpenAI](https://broadrouter.com/pt/glossary/openai-compatible-api/), são uma [base URL](https://broadrouter.com/pt/glossary/base-url/) e um ID de modelo. O [checklist de migração](https://broadrouter.com/pt/blog/openai-compatible-api-migration-checklist/) cobre essa parte, e o [checklist para escolher provedor](https://broadrouter.com/pt/blog/choose-llm-api-provider-checklist/) cobre preço, limites e privacidade. A parte difícil é saber se o novo modelo é tão bom quanto o atual **nas suas tarefas**. Rankings públicos não respondem isso; [o Artificial Analysis e suas alternativas](https://broadrouter.com/pt/blog/artificial-analysis-alternatives/) servem para montar uma lista curta. Um pequeno conjunto de [eval](https://broadrouter.com/pt/glossary/eval/) montado a partir do seu próprio tráfego responde, com um ou dois dias de trabalho.

## Como montar um eval set a partir de tráfego real?

1.  **Puxe de 300 a 1.000 requisições recentes** dos seus [logs de uso](https://broadrouter.com/pt/blog/llm-api-usage-logging/), depois de anonimizá-las.
2.  **Agrupe por tipo de tarefa**: extração, classificação, resumo, resposta de chat, edição de código, tool call.
3.  **Amostre de 10 a 40 por tipo**, mais nos tipos de alto volume ou alto risco. Inclua prompts longos, entradas em outros idiomas além do inglês e os casos de que os usuários reclamaram.
4.  **Escreva o resultado esperado** de cada um: um valor exato, um schema, um teste que precisa passar ou uma rubrica curta (“menciona o prazo de reembolso; nenhuma política inventada”).
5.  **Marque os casos críticos.** Um total de nota fiscal errado ou uma instrução vazada não é a mesma coisa que um tom um pouco pior.
6.  **Congele o conjunto** no controle de versão. Adicione casos quando achar falhas novas; nunca apague casos para fazer um modelo parecer melhor.

## Quais checagens devem ser em código e quais com um juiz?

Use para cada caso a checagem confiável mais barata:

| Tarefa | Checagem | Precisa de juiz? |
| --- | --- | --- |
| Extração de JSON | Faz parse, schema valida, campos batem com o esperado | Não |
| Classificação | O rótulo bate com o esperado | Não |
| Edição de código | Os testes passam | Não |
| Tool call | Função certa, argumentos validam | Não |
| Resumo | Contém os fatos exigidos; nenhum fato ausente da fonte | Às vezes |
| Resposta de chat, tom, utilidade | Rubrica | Sim |

Checagens determinísticas são gratuitas, repetíveis e impossíveis de bajular, então leve o máximo de casos possível para checagens em código.

## O que dá errado com o LLM como juiz?

Um [LLM como juiz](https://broadrouter.com/pt/glossary/llm-as-judge/) é um modelo que avalia as respostas de outros modelos segundo uma rubrica. O estudo do MT-Bench (Zheng et al.) concluiu que juízes fortes concordaram com as preferências humanas mais de 80% das vezes, mais ou menos o quanto humanos concordam entre si. O mesmo artigo apontou os vieses que você precisa contornar no desenho do teste:

| Viés | O que acontece | Mitigação |
| --- | --- | --- |
| Posição | Prefere a primeira (ou a segunda) resposta mostrada | Julgue cada par duas vezes, com a ordem invertida; conte vitória só se as duas concordarem |
| Verbosidade | Prefere respostas mais longas | Rubrica que premia correção e concisão; limite o tamanho no prompt |
| Autopreferência | Prefere respostas no próprio estilo | Juiz de uma família de modelos diferente dos dois candidatos |
| Raciocínio fraco | Deixa passar erros de matemática ou de código | Use checagens em código nesses casos |

Mais duas regras da prática. **Fixe o juiz**: mesma versão de modelo, mesmo prompt, temperatura 0, durante toda a comparação. E **calibre o juiz**: rotule você mesmo de 30 a 50 pares, rode o juiz neles e só confie se ele concordar com você na maioria das vezes. O guia de evaluators da Arize dá o mesmo conselho (“Collect 20–100 examples”, tradução: “Reúna de 20 a 100 exemplos”, com rótulos humanos) e recomenda rótulos categóricos, como pass/fail, em vez de escalas numéricas amplas.

## Como fazer uma comparação lado a lado?

Rode os dois candidatos em todos os casos, esconda do juiz quem é quem, inverta a ordem e registre custo e tempo:

```python
import os, random, time, json
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
A, B = "broadnet/deepseek-v4.1-flash", "broadnet/qwen3.8-27b"
JUDGE = "broadnet/glm-5.3"  # a third family, pinned

def run(model, case):
    t0 = time.perf_counter()
    r = client.chat.completions.create(model=model, messages=case["messages"], max_tokens=4000, temperature=0)
    return {"text": r.choices[0].message.content or "", "usage": r.usage.model_dump(),
            "secs": time.perf_counter() - t0}

def judge(case, first, second):
    prompt = (f"Task:\n{case['task']}\n\nRubric:\n{case['rubric']}\n\n"
              f"Answer 1:\n{first}\n\nAnswer 2:\n{second}\n\n"
              'Reply with JSON only: {"winner": 1 or 2 or 0 for tie, "reason": "..."}')
    r = client.chat.completions.create(model=JUDGE, temperature=0, max_tokens=2000,
                                       response_format={"type": "json_object"},
                                       messages=[{"role": "user", "content": prompt}])
    return int(json.loads(r.choices[0].message.content or "{}").get("winner", 0))

def compare(case):
    a, b = run(A, case), run(B, case)
    if case.get("check"):                       # deterministic first
        return {"a_ok": case["check"](a["text"]), "b_ok": case["check"](b["text"]), "a": a, "b": b}
    w1 = judge(case, a["text"], b["text"])      # A shown first
    w2 = judge(case, b["text"], a["text"])      # B shown first
    winner = "A" if (w1, w2) == (1, 2) else "B" if (w1, w2) == (2, 1) else "tie"
    return {"winner": winner, "a": a, "b": b}
```

A regra de inversão faz com que um modelo só vença quando o juiz o prefere nas duas posições; qualquer desacordo conta como empate. A proporção de desacordos também é útil: uma taxa alta indica que o juiz ou a rubrica estão vagos demais. Repare no `max_tokens=4000`: em modelos de raciocínio, o pensamento conta para o limite, e um teto baixo gera respostas vazias que parecem falhas. Veja [por que modelos de raciocínio devolvem respostas vazias](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).

## Que tamanho de diferença é real?

Notas de avaliação são amostras. Para uma taxa de aprovação p em n casos, o erro padrão é √(p × (1 − p) ÷ n), e a margem de 95% é cerca do dobro disso.

| Casos | Taxa de aprovação | Margem de 95% |
| --- | --- | --- |
| 50 | 80% | cerca de ±11 pontos |
| 100 | 80% | cerca de ±8 pontos |
| 200 | 80% | cerca de ±6 pontos |
| 400 | 80% | cerca de ±4 pontos |

Então um modelo com 82% contra 79% em 100 casos não provou ser melhor. Olhe as **diferenças caso a caso**: quais casos passaram de aprovado para reprovado? Isso diz mais que os totais, e em casos críticos uma única virada pode decidir a troca.

## Qual deve ser a regra de decisão?

Escreva a regra antes de rodar a avaliação, para que o resultado não a distorça. Um modelo prático:

1.  Nenhuma regressão em nenhum caso marcado como crítico.
2.  Taxa de aprovação geral não menor que a do modelo atual por mais que a margem de erro.
3.  Latência p95 dentro do seu orçamento; veja [TTFT vs throughput](https://broadrouter.com/pt/blog/llm-latency-ttft-throughput/) para saber como medir.
4.  Custo por caso bem-sucedido menor, ou maior só num valor que você já concordou que compensa pela qualidade. Calcule a diferença mensal com a [calculadora de custo de API de LLM](https://broadrouter.com/tools/llm-api-cost-calculator/).
5.  Um período em shadow: mande uma parte do tráfego real para o novo modelo, registre os dois e compare antes de virar a chave.

O mesmo eval set é o ponto de partida se você está pensando num modelo personalizado: [antes do fine-tuning](https://broadrouter.com/pt/blog/fine-tuning-readiness/) explica quando prompts e retrieval bastam.

## Onde a BroadNet Inference se encaixa

A BroadNet Inference serve várias famílias de modelos atrás de um único endpoint compatível com a OpenAI, incluindo [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) e [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/), então os candidatos e um juiz de outra família podem rodar pelo mesmo cliente e pela mesma chave. Toda resposta traz o uso de tokens para comparar custos, e contas novas começam com $5 de crédito; sem recarga, esse crédito só roda o [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/), então preveja uma pequena recarga para comparar os modelos maiores. Ela não inclui um harness de avaliação nem ferramentas de juiz hospedadas; você mesmo roda o código acima. Para cargas em árabe, [como escolher um LLM para árabe](https://broadrouter.com/pt/blog/choosing-an-llm-for-arabic/) lista o que testar. Os preços lado a lado estão na [página de comparação](https://broadrouter.com/compare/).

Ferramentas gratuitas sobre o tema (em inglês)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Eval (avaliação de LLM)](https://broadrouter.com/pt/glossary/eval/)

Uma eval (abreviação de evaluation, avaliação) é um teste repetível de um modelo de linguagem ou de um prompt: um conjunto fixo de entradas, uma descrição de como é uma boa saída e um avaliador (código, uma pessoa ou outro modelo) que pontua cada saída, para que versões possam ser comparadas.

[LLM-as-a-judge (LLM como juiz)](https://broadrouter.com/pt/glossary/llm-as-judge/)

LLM-as-a-judge é um método de avaliação em que um modelo de linguagem avalia saídas de outros modelos, dando nota a uma única resposta com base em uma rubrica ou escolhendo a melhor de duas. Aproxima o julgamento humano a um custo bem menor, mas tem vieses conhecidos, como favorecer a primeira resposta ou a mais longa.

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Base URL (URL base)](https://broadrouter.com/pt/glossary/base-url/)

A base URL é o endereço raiz fixo de uma API, como https://api.example.com/v1, que um cliente coloca antes de cada caminho de endpoint, como /chat/completions. Nos SDKs compatíveis com a OpenAI, trocar a base URL, junto com a chave de API e o ID do modelo, aponta o mesmo código para outro provedor.

[Crédito pré-pago (prepaid credit)](https://broadrouter.com/pt/glossary/prepaid-credit/)

Crédito pré-pago é dinheiro adicionado a uma conta de API antes do uso. Cada requisição desconta o próprio custo do saldo e, quando o saldo acaba, as requisições cobradas por uso param até você fazer uma recarga. Ele limita o gasto ao que você já pagou.

[Throughput (vazão)](https://broadrouter.com/pt/glossary/throughput/)

Throughput, ou vazão, no serving de LLMs, é a quantidade total de trabalho que um sistema conclui por unidade de tempo em todas as requisições simultâneas, geralmente medida em tokens de saída ou requisições por segundo. É diferente da velocidade por stream, que é a rapidez com que uma única requisição recebe seus tokens.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[API compatível com a OpenAI](https://broadrouter.com/pt/glossary/openai-compatible-api/)

Uma API compatível com a OpenAI é uma API HTTP que aceita os mesmos formatos de requisição e de resposta da API da OpenAI, como POST /v1/chat/completions, de modo que SDKs e ferramentas da OpenAI podem usá-la trocando só a base URL, a chave de API e o nome do modelo.

## Perguntas frequentes

### Quantos exemplos preciso num eval set de LLM?

Cinquenta bastam para pegar regressões grandes; 200, para ver diferenças de uns 5 a 10 pontos. Cobertura importa mais que tamanho, então inclua todos os tipos de tarefa e os casos de falha que você já conhece.

### LLM como juiz é confiável?

Em parte. No estudo do MT-Bench, juízes fortes concordaram com as preferências humanas mais de 80% das vezes, mais ou menos o quanto humanos concordam entre si. Mas também mostraram viés de posição, de verbosidade e de autovalorização, então corrija esses vieses e confira por amostragem.

### O modelo juiz pode ser o mesmo modelo que está sendo testado?

Não. Juízes tendem a favorecer respostas parecidas com as suas. Use um juiz de outra família de modelos e mantenha-o fixo numa única versão durante toda a comparação.

### O que é viés de posição na avaliação de LLMs?

O juiz prefere a resposta que aparece primeiro, ou em segundo, independentemente da qualidade. Corrija julgando cada par duas vezes com a ordem invertida e contando vitória só quando as duas ordens concordam.

### Devo comparar custo e latência na mesma avaliação?

Sim. Registre tokens e tempo de cada chamada da avaliação. Um modelo que tira dois pontos a mais com o triplo do custo ou da latência pode continuar sendo a troca errada.

## Continue lendo

-   [Como escolher um provedor de API de LLM: checklist de 20 pontos](https://broadrouter.com/pt/blog/choose-llm-api-provider-checklist/)
-   [Migrar para uma API compatível com a OpenAI: checklist de migração](https://broadrouter.com/pt/blog/openai-compatible-api-migration-checklist/)
-   [Como escolher uma API de LLM para árabe: o que testar](https://broadrouter.com/pt/blog/choosing-an-llm-for-arabic/)
-   [Log de uso de API de LLM: custo por usuário e recurso, sem PII](https://broadrouter.com/pt/blog/llm-api-usage-logging/)
-   [Latência de LLM: TTFT, tokens por segundo e tempo de ponta a ponta](https://broadrouter.com/pt/blog/llm-latency-ttft-throughput/)
-   [Antes do fine-tuning: defina o problema a resolver](https://broadrouter.com/pt/blog/fine-tuning-readiness/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)
-   [Guia: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-evaluate-llm-before-switching&utm_content=page-cta) ·

**Fontes**

-   [Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena, arXiv 2306.05685 (consultado em 2026-11-14)](https://arxiv.org/abs/2306.05685)
-   [Documentação da Arize, boas práticas para evaluators (consultada em 2026-11-14)](https://arize.com/docs/ax/concepts/evaluators/evaluator-best-practices)
-   [Referência da API da BroadNet Inference (consultada em 2026-11-14) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-evaluate-llm-before-switching&utm_content=sources)
-   [Preços da BroadNet Inference legíveis por máquina, pricing.json (consultados em 2026-11-14) (em inglês)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-evaluate-llm-before-switching&utm_content=sources)
