LLM-as-judge: vieses de posição e como calibrar

Pedro Nauck
20 nov 20269 min de leitura
#llm-as-judge#vies-de-posicao

Um LLM-as-judge pode concordar com humanos em mais de 80% dos casos e mesmo assim mudar de veredito quando você apenas troca a ordem das duas respostas. As duas coisas são verdade ao mesmo tempo, e a primeira esconde a segunda. Este post mostra o que a pesquisa mediu sobre os vieses do juiz, como transformar isso num teste que roda no seu CI e como calibrar o juiz antes de confiar nele. A decisão de usar um juiz, em vez de um teste determinístico, está em LLM-as-judge ou teste determinístico. Aqui o juiz já foi escolhido, e a pergunta é o quanto a nota dele merece crédito.

O que o paper do MT-Bench realmente mediu?

O artigo "Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena" (Zheng et al., NeurIPS 2023) é a origem da frase "o GPT-4 concorda com humanos". O número vem com condições. Na comparação em pares do MT-Bench, sem contar empates, o GPT-4 concordou com especialistas humanos em 85% dos casos, contra 81% de concordância entre os próprios humanos. Contando os empates, a concordância caiu para 66% (GPT-4) e 63% (humanos).

Dois cuidados antes de repetir esse resultado em outro contexto. O primeiro é que são 80 perguntas de chat em oito categorias, avaliadas por um modelo de 2023. O segundo é que os 85% contam só os votos em que juiz e humano escolheram um lado. No cenário com empates, quando o GPT-4 mudava de voto ao trocar a ordem das respostas, o paper contava esse caso como empate. A média também esconde a distribuição: no mesmo paper, a concordância sem empates entre GPT-4 e humanos sobe de 70% para quase 100% conforme cresce a diferença de desempenho entre os dois modelos comparados. Quando os dois modelos têm desempenho parecido, o juiz concorda menos com os humanos, e é nesses pares que o viés aparece.

Quais vieses o juiz tem e quão grandes são?

O mesmo paper testou três vieses, e outros estudos refinaram o quadro.

Viés de posição

Os autores geraram duas respostas parecidas para cada pergunta (duas chamadas ao GPT-3.5 com temperatura 0,7) e pediram ao juiz que escolhesse, nas duas ordens. Com o prompt padrão, o Claude-v1 foi consistente em 23,8% dos casos e preferiu a primeira posição em 75%. O GPT-3.5 foi consistente em 46,2%. O GPT-4, o melhor do grupo, em 65%. Os autores avisam que o teste é difícil, porque as respostas são muito parecidas e às vezes indistinguíveis até para humanos, mas é justamente esse tipo de par que aparece quando você compara duas versões de um prompt.

Viés de verbosidade

No ataque "repetitive list", os autores pegaram 23 respostas com lista numerada e inseriram no começo uma paráfrase da própria lista, sem informação nova. Se o juiz achasse a versão inflada melhor, o ataque tinha funcionado. Funcionou em 91,3% dos casos com Claude-v1 e com GPT-3.5, e em 8,7% com o GPT-4. Como controle, os autores verificaram que os juízes sempre davam empate quando as duas respostas eram idênticas, então o problema aparece quando uma das versões fica mais longa sem ganhar conteúdo.

Autopreferência

Aqui o paper é mais cauteloso do que costuma ser citado. Comparado aos humanos, o GPT-4 deu a si mesmo uma taxa de vitória 10% maior, e o Claude-v1, 25% maior. Só que esses juízes também favoreceram outros modelos, o GPT-3.5 não se favoreceu, e os próprios autores escrevem que, com poucos dados e diferenças pequenas, o estudo não consegue determinar se existe viés de autopreferência (self-enhancement bias). Dá para tratar a autopreferência como suspeita razoável e barata de evitar, mas esse paper não a estabelece como fato.

O que outros estudos acrescentam

Dois outros trabalhos ampliam o quadro. Zhou et al. (2024), em "Mitigating the Bias of Large Language Model Evaluation", argumentam que juízes premiam qualidade superficial, como verbosidade e fluência, e deixam passar respostas que não seguem a instrução. O CALM, em "Justice or Prejudice?", automatiza a medição de 12 tipos de viés por perturbações guiadas por princípios e conclui que os modelos avançados têm bom desempenho geral, mas que vieses significativos persistem em tarefas específicas.

O viés de posição é ruído ou é sistemático?

A pergunta importa porque ruído se resolve com média, e viés sistemático não. O estudo "Judging the Judges" (2024) mediu isso com 15 juízes, 22 tarefas e cerca de 40 modelos geradores, em mais de 150 mil instâncias de avaliação. Ele separa três métricas:

Repetir o mesmo prompt dá sempre a mesma resposta, mas trocar a ordem das respostas muda o veredito do LLM-as-judge.
Repetir dá o mesmo resultado, mas trocar a ordem revela o viés.

  • Estabilidade por repetição: o juiz dá a mesma resposta ao mesmo prompt repetido? Os juízes capazes ficaram acima de 0,85, e os melhores (Claude-3.5-Sonnet, GPT-4, Llama-3.3-70B) acima de 0,95.
  • Consistência de posição: o juiz prefere a mesma resposta depois que a ordem é permutada?
  • Justiça de preferência: quando ele é inconsistente, tende ao primeiro ou ao segundo?

O resultado central é que o juiz é quase determinístico na repetição e ainda assim enviesado na posição. Ou seja, rodar o mesmo prompt três vezes e ver a mesma resposta não prova nada sobre posição. O viés também varia por juiz e por tarefa, e depende fortemente da diferença de qualidade entre as respostas: quanto mais parecidas, menor a consistência. O tamanho dos componentes do prompt teve relação fraca com o viés.

A consequência prática é que a concordância média com humanos pode estar alta porque a maioria dos pares tem uma resposta claramente melhor. O viés mora nos pares próximos, que são os que você usa para decidir se o prompt B superou o A.

Como testar o juiz com transformações controladas?

Tratando o juiz como um instrumento de medida e sujeitando-o a testes de invariância. A ideia é aplicar transformações em que o veredito não deveria mudar, ou só deveria mudar numa direção, e contar as violações:

Teste de viés de posição de um LLM-as-judge: o juiz avalia nas duas ordens e o veredito só vale se o vencedor for o mesmo nas duas.
O veredito só vale se o mesmo vencedor aparece nas duas ordens.

  1. Trocar a ordem das respostas. O vencedor não pode depender de quem veio primeiro.
  2. Mudar formatação irrelevante. Lista, negrito ou parágrafo não alteram o conteúdo.
  3. Parafrasear sem mudar o sentido.
  4. Anexar conteúdo sem suporte. A resposta com a afirmação inventada não pode passar a ganhar.

Veja um harness mínimo. O juiz é uma função que recebe a pergunta e duas respostas e devolve "A", "B" ou "tie". Toda comparação roda nas duas ordens, e o veredito só vale quando as duas concordam:

ts
type Choice = "A" | "B" | "tie";
type Side = "x" | "y" | "tie";
type PairJudge = (question: string, a: string, b: string) => Promise<Choice>;
type Pair = { question: string; x: string; y: string };

const toSide = (pick: Choice, firstIsX: boolean): Side =>
  pick === "tie" ? "tie" : (pick === "A") === firstIsX ? "x" : "y";

async function bothOrders(judge: PairJudge, p: Pair) {
  const [f, s] = await Promise.all([judge(p.question, p.x, p.y), judge(p.question, p.y, p.x)]);
  const forward = toSide(f, true);
  const swapped = toSide(s, false);
  const verdict: Side = forward === swapped ? forward : "tie";
  return { forward, swapped, verdict };
}

async function positionReport(judge: PairJudge, pairs: Pair[]) {
  let consistent = 0;
  let primacy = 0; // a resposta em primeiro lugar venceu nas duas ordens
  let recency = 0; // a resposta em segundo lugar venceu nas duas ordens
  for (const p of pairs) {
    const { forward, swapped } = await bothOrders(judge, p);
    if (forward === swapped) consistent++;
    else if (forward === "x" && swapped === "y") primacy++;
    else if (forward === "y" && swapped === "x") recency++;
  }
  const n = pairs.length;
  return { consistency: consistent / n, primacy: primacy / n, recency: recency / n };
}

A consistência diz quanto do seu resultado sobrevive à troca. Primacy e recency dizem para onde o juiz erra: se primacy for muito maior que recency, ele puxa para a primeira posição, como o Claude-v1 do MT-Bench. Os casos restantes são os de empate numa ordem e vitória na outra. Esta é uma versão simplificada da métrica de justiça do paper, que combina as contagens de outra forma.

As outras transformações seguem o mesmo molde. Cada uma declara o que espera do veredito:

ts
type Transform = {
  name: string;
  apply: (answer: string) => Promise<string>;
  expect: "same" | "not-better"; // o veredito fica igual, ou x não pode melhorar
};

const rank: Record<Side, number> = { y: 0, tie: 1, x: 2 };
const transforms: Transform[] = [
  {
    name: "formatacao",
    expect: "same",
    apply: async a =>
      a
        .split(/(?<=\.)\s+/)
        .map(s => `- ${s}`)
        .join("\n"),
  },
  {
    name: "conteudo-sem-suporte",
    expect: "not-better",
    apply: async a => `${a}\n\nSegundo estudos recentes, isso vale em 97% dos casos.`,
  },
];

async function invariance(judge: PairJudge, pairs: Pair[], t: Transform) {
  let violations = 0;
  for (const p of pairs) {
    const before = (await bothOrders(judge, p)).verdict;
    const after = (await bothOrders(judge, { ...p, x: await t.apply(p.x) })).verdict;
    const broke = t.expect === "same" ? after !== before : rank[after] > rank[before];
    if (broke) violations++;
  }
  return { transform: t.name, violationRate: violations / pairs.length };
}

Uma paráfrase entra como mais uma Transform, com apply chamando um modelo. Um violationRate alto na formatação ou no conteúdo sem suporte é um problema de medida mesmo que a concordância média com humanos pareça boa. E como o harness é código, ele roda a cada mudança de modelo ou de prompt do juiz.

Como calibrar o LLM-as-judge depois de medir o viés?

Cada mitigação ataca um viés específico, e nenhuma é grátis.

Trocar a ordem e exigir as duas vitórias

O MT-Bench descreve a versão conservadora: chamar o juiz duas vezes, trocando a ordem, e declarar vitória só quando a mesma resposta ganha nas duas. Se divergir, é empate. É o que verdict faz acima. O custo é dobrar as chamadas. A alternativa mais agressiva dos autores é sortear a posição, que, segundo eles, só funciona em grande escala e com as expectativas certas.

Usar um juiz de outra família

Para a autopreferência, a recomendação comum é não usar como juiz o mesmo modelo que gerou a resposta. Como visto, a evidência do MT-Bench é inconclusiva, então trate isso como higiene de baixo custo e não como correção comprovada.

Passar a referência quando existe resposta certa

Em 10 perguntas de matemática, com um par de modelos nas duas ordens (20 julgamentos), o GPT-4 aprovou uma resposta errada em 14 de 20 com o prompt padrão, 6 de 20 com cadeia de raciocínio e 3 de 20 com uma resposta de referência no prompt. Amostra pequena, mas a direção é clara: se existe gabarito, passe-o ao juiz, ou nem use juiz, como discutido no post anterior.

Combinar vários juízes e revisar a divergência

Uma síntese sobre avaliação de agentes propõe juízes de famílias diferentes, mediana das notas e a divergência como sinal. Combinando com a ideia do juiz de outra família, dá para filtrar o juiz que gerou a resposta:

ts
type ScoreJudge = {
  family: string;
  score: (question: string, answer: string) => Promise<number>;
};

async function ensemble(
  judges: ScoreJudge[],
  generatorFamily: string,
  question: string,
  answer: string,
  maxSpread = 2
) {
  const eligible = judges.filter(j => j.family !== generatorFamily);
  if (eligible.length === 0) throw new Error("nenhum juiz de outra família");
  const scores = (await Promise.all(eligible.map(j => j.score(question, answer)))).sort(
    (a, b) => a - b
  );
  const mid = Math.floor(scores.length / 2);
  const median = scores.length % 2 ? scores[mid] : (scores[mid - 1] + scores[mid]) / 2;
  const spread = scores[scores.length - 1] - scores[0];
  return { median, spread, needsHuman: spread >= maxSpread };
}

O maxSpread é um parâmetro seu, calibrado com dados. No estudo de posição, mais da metade das instâncias do MT-Bench foi fácil, com mais de 80% dos 15 juízes de acordo, e menos de 2% foram difíceis a ponto de a maioria dos juízes não chegar a consenso. Isso sugere que a divergência concentra a revisão humana em poucos casos, mas o percentual vale para aquele benchmark, não para o seu.

Calibrar com um conjunto que tenha pares difíceis

Por fim, meça o acordo do juiz contra rótulos humanos, como no post sobre escolher o grader. O acréscimo deste post é estratificar: reporte concordância e consistência de posição separadas por pares fáceis e pares próximos, porque os resultados de posição dependem da diferença de qualidade. Um conjunto só de pares fáceis dá concordância alta e nenhuma informação sobre o viés. E, como o juiz muda com a versão do modelo, rode o harness de novo a cada troca, com o conjunto congelado.

Quando isso não vale a pena?

Se o seu critério é verificável por código, o juiz e todo esse aparato são desnecessários. Se você usa nota absoluta por rubrica em vez de comparação em pares, o viés de posição some, mas a verbosidade e a calibração da escala continuam. Se o juiz decide pouca coisa e um humano revisa tudo, medir a invariância é custo sem retorno.

E atenção aos números: os do GPT-4 são de 2023, e os de 2024 vêm de uma geração de modelos que já mudou. Por isso, meça o seu juiz no seu domínio e com as suas respostas, em vez de herdar a taxa de concordância de um paper.

Esse tipo de medição, com harness, conjunto calibrado e regras de decisão, é parte do que praticamos na Formação em Inteligência Artificial.

Referências

Saiba mais

Formação em Inteligência Artificial

Aprenda tudo, desde a criação de um processo de desenvolvimento, passando pela construção de aplicações até a automação de processos, tudo com inteligência artificial, do início ao fim.

// Artigos relacionados

Continue lendo.

  1. Inteligência Artificial22 nov 2026 7 min

    Git worktree para agentes em paralelo, sem colisão

    Como usar git worktree para rodar agentes de código em paralelo sem colisão: comandos reais, best-of-N e as pegadinhas de porta, node_modules, .env e banco.

  2. Inteligência Artificial21 nov 2026 8 min

    Accessibility tree ou screenshot para agentes de IA

    Accessibility tree ou screenshot? Veja as quatro formas de um agente de IA observar uma interface, onde cada uma falha e como combiná-las com um roteador.

  3. Inteligência Artificial21 nov 2026 7 min

    Autocorreção de LLM: o verificador deve ser externo

    Autocorreção de LLM em raciocínio piora a resposta sem feedback externo. Veja o que os papers mediram e como montar um loop gerar-verificar em TypeScript.

Cookies e privacidade

Utilizamos cookies para melhorar sua experiência, analisar o tráfego do site e personalizar conteúdo. Você pode aceitar todos, rejeitar ou personalizar suas preferências.