BroadRouter

Como avaliar um LLM antes de trocar de provedor

Pela equipe da BroadNet Inference · 5 min de leitura · Publicado em

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.

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?

  1. Puxe de 300 a 1.000 requisições recentes dos seus logs de uso, 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 é 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:

  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 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.
  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 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.

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.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity