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, são uma base URL e um ID de modelo. O checklist de migração cobre essa parte, e o checklist para escolher provedor 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 servem para montar uma lista curta. Um pequeno conjunto de 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?
- Puxe de 300 a 1.000 requisições recentes dos seus logs de uso, depois de anonimizá-las.
- Agrupe por tipo de tarefa: extração, classificação, resumo, resposta de chat, edição de código, tool call.
- 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.
- 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”).
- 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.
- 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 é 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:
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.
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:
- Nenhuma regressão em nenhum caso marcado como crítico.
- Taxa de aprovação geral não menor que a do modelo atual por mais que a margem de erro.
- Latência p95 dentro do seu orçamento; veja TTFT vs throughput para saber como medir.
- 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.
- 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 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, GLM 5.3 e 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, 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 lista o que testar. Os preços lado a lado estão na página de comparação.
