Viés 4: leniência

Peça uma nota de 1 a 5 e observe a distribuição. Ela vai se empilhar em 4 e 5.

Um juiz que dá 4,2 de média para tudo não separa nada. O problema não é o modelo ser otimista — é a rubrica não ter âncoras negativas concretas.

Compare:

# rubrica fraca
1 = ruim, 3 = ok, 5 = excelente

# rubrica com âncoras
5 = factualmente correta, completa, sem informação não solicitada
4 = correta e completa, com alguma informação irrelevante
3 = correta mas incompleta: omite um ponto que a pergunta pedia
2 = parcialmente incorreta: contém ao menos uma afirmação falsa
1 = majoritariamente incorreta, ou não responde à pergunta

A versão com âncoras espalha a distribuição porque cada nota tem um critério verificável — "contém ao menos uma afirmação falsa" é observável; "ruim" não é.

Monitore a distribuição como parte do eval:

def check_distribution(scores: list[float]) -> dict:
    from collections import Counter
    dist = Counter(round(s) for s in scores)
    total = len(scores)
    top_heavy = (dist[4] + dist[5]) / total
    return {
        "distribuicao": {k: round(v / total, 3) for k, v in sorted(dist.items())},
        "concentracao_no_topo": round(top_heavy, 3),
        "suspeito": top_heavy > 0.80,      # juiz não está discriminando
    }

Viés 5: formato

Markdown bem formatado, listas numeradas e negrito aumentam a nota independentemente do conteúdo. O juiz lê apresentação e conclui competência.

A correção depende do que você está avaliando:

import re

def normalize_for_judging(text: str) -> str:
    """Remove pistas de formatação quando o alvo é conteúdo, não apresentação."""
    text = re.sub(r"\*\*(.+?)\*\*", r"\1", text)      # negrito
    text = re.sub(r"^#{1,6}\s+", "", text, flags=re.M)  # cabeçalhos
    text = re.sub(r"^\s*[-*]\s+", "", text, flags=re.M) # marcadores
    text = re.sub(r"\n{2,}", "\n", text)
    return text.strip()

Se o formato faz parte do que você mede — resposta ao usuário final, por exemplo —, não normalize. Avalie em duas dimensões separadas, com rubricas distintas para conteúdo e apresentação, e nunca em uma nota única que mistura as duas.

Viés 6: auto-consistência — o que não tem correção completa

O mesmo juiz, o mesmo par, a mesma rubrica, duas execuções: respostas diferentes.

Isso não é viés no sentido dos anteriores. É variância, e ela estabelece um teto para o quanto você pode confiar em qualquer número que o juiz produza.

Meça antes de confiar:

def self_consistency(judge, samples, n: int = 3) -> dict:
    """Mesmo juiz, mesma entrada, n execuções."""
    agreements = []
    for s in samples:
        verdicts = [judge.compare(s.question, s.a, s.b) for _ in range(n)]
        most_common = max(set(verdicts), key=verdicts.count)
        agreements.append(verdicts.count(most_common) / n)
    return {
        "consistencia_media": round(mean(agreements), 3),
        "casos_instaveis": sum(1 for a in agreements if a < 0.67),
    }

Temperatura zero reduz a variância, mas não a elimina. A mitigação prática é votação por maioria de três execuções, aceitando o custo de triplicar.

E existe um uso melhor para a inconsistência do que descartá-la: casos instáveis são casos difíceis. Se o juiz não consegue decidir duas vezes igual, aquele exemplo é um excelente candidato a rotulagem humana. Use a instabilidade como fila de triagem, não como ruído.

O desenho que sobrevive aos seis

@dataclass
class JudgeConfig:
    model: str
    temperature: float = 0.0
    rubric: str = ANCHORED_RUBRIC
    swap_positions: bool = True
    normalize_format: bool = True
    votes: int = 3
    max_length_correlation: float = 0.4

def evaluate(config: JudgeConfig, cases: list[Case]) -> EvalReport:
    judge = get_judge(config.model)
    results = []

    for case in cases:
        a = normalize_for_judging(case.answer_a) if config.normalize_format else case.answer_a
        b = normalize_for_judging(case.answer_b) if config.normalize_format else case.answer_b

        votes = [compare_pairwise(judge, case.question, a, b) for _ in range(config.votes)]
        verdict = majority(votes)
        results.append(Result(case=case, verdict=verdict, unanimous=len(set(votes)) == 1))

    report = EvalReport(results)
    report.validate(
        max_tie_rate=0.25,
        max_length_corr=config.max_length_correlation,
        min_human_agreement=0.75,
    )
    return report

O método validate é o que impede o relatório de mentir em silêncio. Se a taxa de empates estourou, se a correlação com comprimento é alta, ou se a concordância com humanos caiu, o eval falha em vez de publicar um número bonito.

Quando não usar juiz LLM

Sejamos concretos sobre os limites:

• Quando existe verdade verificável. Se dá para rodar o teste, executar o código ou comparar com o gabarito, faça isso. Juiz LLM para saída determinística é substituir certeza por estimativa.
• Quando a decisão é irreversível. Moderação que bane conta, aprovação de crédito, triagem clínica. Juiz é sinal, não autoridade.
• Quando você está comparando os dois melhores modelos que existem. Não sobra juiz elegível sem auto-preferência.
• Quando a rubrica não passa no teste humano. Se dois especialistas discordam sobre o critério, o juiz vai apenas automatizar a confusão.

Checklist

• A concordância juiz-humano foi medida em ≥50 casos rotulados.
• A concordância humano-humano foi medida e usada como teto.
• Comparações par a par rodam nas duas ordens.
• Divergência entre ordens vira empate, não voto.
• A taxa de empates é monitorada (alerta acima de ~25%).
• A correlação entre comprimento e nota é calculada.
• O juiz não é da mesma família dos modelos avaliados.
• A rubrica tem âncoras verificáveis, não adjetivos.
• A distribuição de notas é inspecionada contra concentração no topo.
• O formato é normalizado, ou avaliado em dimensão separada.
• A auto-consistência foi medida com execuções repetidas.
• Casos instáveis viram fila de rotulagem humana.
• O relatório falha automaticamente quando os limiares estouram.

Conclusão

LLM-as-a-Judge é uma ferramenta boa com uma documentação implícita ruim. Ela é adotada como se fosse um medidor, quando na verdade é um avaliador com preferências — e preferências não desaparecem com mais amostras.

Cinco dos seis vieses têm correção mecânica: trocar posições, controlar comprimento, escolher juiz de outra família, ancorar a rubrica, normalizar formato. Nenhuma delas é cara. Todas são mensuráveis.

O sexto — auto-consistência — não tem correção completa, e é por isso que a calibração contra humanos não é opcional. Sem saber a concordância do seu juiz com pessoas do seu domínio, você não tem um eval automático. Você tem um gerador de números com aparência de rigor.

A pergunta que resume tudo: se o seu juiz aprovasse uma resposta ruim, você descobriria? Se a resposta depende de alguém reparar por acaso, o eval ainda não está pronto.

Leituras relacionadas

• Seu eval de domínio em um dia
• Contract testing para APIs de LLM
• Versionamento de decisões de IA

Os vieses descritos são efeitos reportados de forma consistente na literatura de avaliação com LLMs. Os limiares sugeridos — 25% de empates, r de 0,4, 0,75 de concordância — são pontos de partida operacionais, não constantes: recalibre com o seu domínio e a sua rubrica.