Julgamentos de pessoas e de LLMs
Cerca de 47 minutos min de leitura, com 11 exemplos em 13 seções.
Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros
Traduzido do livro em inglês, edição 2026.11.10. Leia o original
Nesta página
- Escreva diretrizes de julgamento
- Meça a concordância além do acaso com o kappa
- Dê crédito parcial a quase acertos com kappa ponderado
- Leia o kappa em relação à composição de rótulos
- Leia a direção dos erros do LLM
- Compare o que o LLM viu com o que os juízes viram
- Meça o quanto o prompt muda os rótulos
- Preencher pares não julgados com notas do LLM
- Verifique se as notas do LLM ordenam os rankers da mesma forma
- Refaça as comparações planejadas com notas de LLM
- Corrija escores de LLM com uma amostra humana
- O que dá errado em produção
- Decisões tomadas neste capítulo
Ao final deste capítulo, você saberá escrever diretrizes de julgamento, medir a concordância entre dois juízes com kappa e kappa ponderado, ler os erros de um juiz LLM em uma matriz de confusão e decidir onde os julgamentos de LLMs podem substituir os de pessoas e onde não podem.
Toda pontuação deste livro se apoia em julgamentos: pessoas leram uma consulta digitada na caixa de busca da loja ao lado de um produto que ela retornou, e atribuíram uma nota ao par. Esses julgamentos são os rótulos do WANDS, cada um o voto da maioria de até três anotadores treinados, e têm lacunas: nas consultas de teste, as listas dos 10 primeiros resultados do BM25 contêm 22 produtos que ninguém julgou (Contar produtos não julgados). Eles também consomem o tempo das pessoas, e a concordância entre os anotadores do WANDS subiu ao longo de quatro meses de calibração (Esperar que juízes discordem). Um LLM pode atribuir notas a qualquer consulta e produto que lhe seja apresentado. Antes que a loja permita que um LLM atue como juiz, ela precisa saber com que frequência o LLM concorda com os juízes da loja e se suas notas levariam às mesmas decisões sobre os ranqueadores.
As notas do LLM vêm de uma gravação: recordings/llm_judgments.py executou uma vez, localmente, o modelo aberto gemma4:12b-it-q4_K_M, com temperatura 0 e uma semente fixa, e salvou suas respostas; assim, os exemplos as leem por meio de lib.recorded.llm_judgments(), sem chamar o modelo. Escolhemos o modelo porque ele é aberto, sob a licença Apache 2.0, e roda localmente, de modo que qualquer pessoa pode executar a gravação novamente. Um esquema JSON limita cada resposta a um dos três rótulos. A gravação atribuiu notas a cada par com dois prompts, short e guidelines (Escrever diretrizes de julgamento), e tirou seus pares de dois conjuntos, que este capítulo chama de pools.
As pontuações que decidem entre ranqueadores continuam baseadas em notas humanas. As comparações planejadas deste capítulo, nas consultas de teste, são as três do capítulo 3, recalculadas com as notas do LLM de cada prompt, no limiar do capítulo 3, de 0.0167, para o teste de permutação pareado: recuperação semântica contra BM25, o híbrido contra a recuperação semântica, e o híbrido reordenado contra o híbrido.
Escreva diretrizes de julgamento
Este capítulo chama de juiz quem dá um julgamento, seja uma pessoa ou um LLM, e de nota o número que o representa. O capítulo 1 define um julgamento como o rótulo de uma pessoa; este capítulo amplia a definição para incluir também o rótulo de um LLM. Os julgamentos dependem das instruções por trás deles. Diretrizes de julgamento dizem o que cada nota significa, como escolher entre as notas e o que fazer com os casos que ficam entre elas.
O WANDS publicou as diretrizes que seus anotadores usaram: oito páginas, sob a licença MIT (diretrizes de anotação). Para cada par, elas listam o que um juiz vê: a consulta e o ID, o nome, a imagem e a página web do produto. Definem as três notas e acrescentam duas observações: uma pede que o juiz entenda a consulta primeiro, "Strongly recommend google it first"; outra manda ignorar erros de digitação e anotar o par como está escrito. Depois, ensinam por meio de exemplos, dando uma consulta, um produto e um motivo para cada nota: uma cesta de arame sem divisórias é parcial para wire basket with dividers, uma das consultas de trem da própria loja, e um tapete antifadiga de salão é irrelevante para salon chair, porque o cliente procura uma cadeira de salão, não um tapete. As diretrizes também mudam conforme os juízes as usam. Os autores do WANDS dizem que a concordância entre seus anotadores subiu ao longo de quatro meses, e entre as razões que apontam estão uma rotina diária para discutir anotações conflitantes e diretrizes refinadas com a contribuição dos anotadores (Chen et al., 2022, seção 5). As diretrizes para avaliadores de um mecanismo de busca na web fazem o mesmo, com 182 páginas na versão de 11 de setembro de 2025 (Diretrizes para Avaliadores de Qualidade de Busca).
Os dois prompts da gravação são diretrizes de julgamento para o LLM. short são apenas as três definições do WANDS; guidelines mantém essas definições e acrescenta cinco regras, então imprima-o como a gravação o enviou:
1"""Prints the model, the word count of each prompt and the guidelines prompt verbatim, from the recording's manifest. The prose's point rests on the rules at the end of that prompt."""2from lib.recorded import manifest34recording = manifest("llm-judgments") # the recording's model, settings and both prompts, verbatim5short, guidelines = recording["prompts"]["short"], recording["prompts"]["guidelines"]67print("model:", recording["model"])8print("what the model saw:", recording["sees"])9print("words in the short prompt:", len(short.split()))10print("words in the guidelines prompt:", len(guidelines.split()))11print()12print(guidelines)
python print-judging-guidelines.pymodel: gemma4:12b-it-q4_K_M
what the model saw: lib.store text plus attributes; no images
words in the short prompt: 59
words in the guidelines prompt: 206
You judge product search results for an online furniture and home-goods store. A shopper typed the query and was shown the product. Decide how well the product matches what the shopper asked for.
Exact: the product fully matches the search query.
Partial: the product only matches the target entity of the query, but does not satisfy the modifiers for the query.
Irrelevant: the product is not relevant to the query.
Guidelines:
- First find the target entity: the kind of product the query asks for (a sofa, a lamp, a rug).
- Then find the modifiers: everything else the query asks for, such as colour, size, material, style, brand or a feature.
- Exact needs the right kind of product and every modifier. Partial is the right kind of product with at least one modifier missing or contradicted. Irrelevant is the wrong kind of product, even when it shares words with the query, such as an accessory for the product asked for.
- Read misspelled queries as the shopper meant them.
- Judge only from the product's text and attributes. If a modifier isn't mentioned, decide from what is written, and don't assume it is met.
Query: {query}
Product:
{product}
Answer with the label in JSON.
O prompt guidelines é o mais longo dos dois, com 206 palavras contra 59 de short. Suas duas primeiras regras detalham a definição de parcial do WANDS: encontrar a entidade e depois os modificadores. A regra de acessórios resolve um caso que os próprios rótulos do WANDS dividem: para clear shower curtain, o WANDS lista o mesmo conjunto de ganchos de cortina duas vezes, uma como parcial e outra como irrelevante (Esperar que os juízes discordem). A regra de erros de digitação segue a observação do WANDS. A última regra não tem equivalente nas diretrizes do WANDS, porque os dados da loja não têm imagens, então a gravação mostra ao LLM apenas o texto. Nenhum dos prompts tem exemplos trabalhados, nos quais as diretrizes do WANDS se apoiam.
Regra prática: Escreva as diretrizes com definições, um procedimento, um exemplo trabalhado com um motivo para cada nota e uma regra para cada caso em que seus juízes discordaram. Registre as discordâncias e revise as diretrizes quando um tipo delas continuar voltando. Dê ao juiz LLM as mesmas diretrizes que dá às pessoas, mais uma regra para o que ele não consegue ver, e depois meça o que ele faz, porque uma regra que você escreve não é uma regra que o juiz segue.
Meça a concordância além do acaso com o kappa
Antes de confiar em um segundo juiz, meça com que frequência ele concorda com o primeiro. A parcela de pares em que dois juízes dão a mesma nota, a concordância observada, é o número óbvio, e ele engana. Dois juízes que avaliassem de forma independente concordariam em alguns pares por acaso, e em mais deles quando ambos usam muito um mesmo rótulo. O kappa de Cohen corrige a concordância observada pelo acaso, comparando-a com a concordância esperada se cada juiz mantivesse suas próprias proporções de rótulos, mas escolhesse de forma independente do outro. Um kappa de 1 significa concordância completa, e 0 significa "nenhuma concordância além do que seria esperado pelo acaso" (documentação do scikit-learn):
kappa = (observed - expected) / (1 - expected)
expected = sum over grades g of (share of pairs judge A gives g) × (share of pairs judge B gives g)
O pool de treino, para medir a concordância, reúne pares que pessoas julgaram para consultas de treino, distribuídos igualmente por rótulo: até 4 de cada rótulo por consulta, 550 pares no total. O pool de teste reúne os pares que um LLM avaliaria para pontuar os rankers da loja: todo produto entre os 10 primeiros dos quatro rankers do capítulo 1 para cada consulta de teste, julgado por pessoas ou não, 590 pares. Os quatro são BM25, recuperação semântica com embeddings de Snowflake/snowflake-arctic-embed-m-v1.5, o híbrido dos dois, e o híbrido reordenado pelo cross-encoder Alibaba-NLP/gte-reranker-modernbert-base. Cada medição do juiz LLM vale para o pool em que foi feita, por isso este capítulo nomeia o pool a cada vez.
A pergunta é com que frequência o LLM de a gravação avalia um par do mesmo modo que os juízes da loja. O pool de treino, com o prompt short (apenas as três definições do WANDS), responde a essa pergunta. Uma tabela 3×3 de contagens, montada à mão, dá o kappa, e o cohen_kappa_score do scikit-learn confere o resultado:
1"""Builds the 3×3 table of the store's grades against the short prompt's on the train pool, then computes observed agreement, chance agreement and kappa from it. The prose's point rests on the printed kappa by hand, which matches the scikit-learn line."""2import numpy as np3from sklearn.metrics import cohen_kappa_score45from lib.agreement import graded_pairs67pairs = graded_pairs("train") # up to 4 human-judged pairs per label per train query8# the grades are nullable integers; plain ones compare and count the way the formulas below expect9human, llm = pairs["human"].astype(int), pairs["short"].astype(int)10grades = [2, 1, 0] # exact, partial, irrelevant11counts = np.array([[((human == row) & (llm == column)).sum() for column in grades] for row in grades])12print("pairs:", counts.sum())13print("rows are the human grades 2, 1, 0 and columns the LLM's, short prompt")14print(counts)1516observed = np.trace(counts) / counts.sum() # the share of pairs on the diagonal17human_share, llm_share = counts.sum(axis=1) / counts.sum(), counts.sum(axis=0) / counts.sum()18expected = (human_share * llm_share).sum() # agreement if the two judged independently19kappa = (observed - expected) / (1 - expected)20print(f"observed agreement, short prompt: {observed:.3f}")21print(f"agreement expected by chance, short prompt: {expected:.3f}")22print(f"kappa by hand, short prompt: {kappa:.3f}")23print(f"kappa from scikit-learn, short prompt: {cohen_kappa_score(human, llm):.3f}")2425other = pairs["guidelines"].astype(int)26print(f"observed agreement, guidelines prompt: {(human == other).mean():.3f}")27print(f"kappa from scikit-learn, guidelines prompt: {cohen_kappa_score(human, other):.3f}")
python kappa-by-hand.pypairs: 550
rows are the human grades 2, 1, 0 and columns the LLM's, short prompt
[[102 85 9]
[ 22 132 46]
[ 3 42 109]]
observed agreement, short prompt: 0.624
agreement expected by chance, short prompt: 0.337
kappa by hand, short prompt: 0.432
kappa from scikit-learn, short prompt: 0.432
observed agreement, guidelines prompt: 0.633
kappa from scikit-learn, guidelines prompt: 0.454
O LLM e os juízes da loja dão a mesma nota a 0.624 dos pares de treino, e o acaso sozinho produziria 0.337. O kappa subtrai essa parcela do acaso da concordância observada e então divide pelo espaço que sobra acima do acaso, o que resulta em 0.432 para short, igual ao 0.432 do scikit-learn.
guidelines concorda com os juízes um pouco mais vezes do que short, em 0.633 dos pares, com um kappa de 0.454.
Isso é bom? Escalas que chamam um kappa de "moderado" ou "substancial" são convenções de campos específicos. O levantamento de Artstein e Poesio conclui que escolher um nível adequado de concordância para um propósito específico é "ainda pouco mais do que uma arte negra" (Artstein e Poesio, 2008).
Números publicados dão contexto, não um limiar. Os anotadores do WANDS concordaram entre si com um kappa de 0.467 nos dois primeiros meses e de 0.826 no quarto (Chen et al., 2022, Tabela 2).
Em uma amostra estratificada de pares do TREC, as avaliações compartilhadas da Text REtrieval Conference, Thomas et al. constataram que o kappa do GPT-4 em relação aos avaliadores variou de apenas 0.20 até 0.64, conforme o prompt. Dois grupos de avaliadores humanos treinados chegaram a 0.52 em documentos ad hoc do TREC que julgaram uma segunda vez (Cormack et al., 1998, conforme relatado por Thomas et al., 2024). Cada número vem de uma amostra diferente, e o kappa depende da mistura de rótulos da amostra.
Regra prática: Relate o kappa, com a concordância observada ao lado, nunca a concordância observada sozinha. Meça-o em pares que pessoas julgaram para consultas de treino, e identifique qualquer limiar usado como uma regra prática. Com mais de dois juízes ou com rótulos ausentes, use o alfa de Krippendorff, que compara a discordância observada com a discordância por acaso e lida com qualquer número de observadores e com dados incompletos (Krippendorff, 2011).
Dê crédito parcial a quase acertos com kappa ponderado
Kappa conta cada discordância do mesmo modo. As notas da loja são ordenadas: exato acima de parcial, e parcial acima de irrelevante. Classificar um produto exato como parcial é um erro menor do que classificá-lo como irrelevante. No nDCG@10 (Pontue um ranking), esse erro custa metade do ganho: uma nota em vez de duas. O kappa ponderado atribui a cada discordância um peso conforme a sua distância e compara a discordância ponderada com a discordância ponderada esperada por acaso (Artstein and Poesio, 2008, seção 2.6). Com pesos lineares, uma discordância de uma nota vale 0.5, e uma discordância de duas notas vale 1:
weighted kappa = 1 - (sum of weight × observed count) / (sum of weight × count expected by chance)
Com toda discordância ponderada por 1, a fórmula dá o kappa simples. O cohen_kappa_score do scikit-learn calcula os três tipos desse modo: peso 1 por padrão, a distância entre as notas com weights="linear", e o quadrado dessa distância com weights="quadratic" (código-fonte do scikit-learn). Escalar os pesos não muda o resultado.
Para os dois prompts, o exemplo constrói à mão os pesos lineares sobre os pares de treino sorteados uniformemente de Meça a concordância além do acaso e, em seguida, confere cada resultado com o scikit-learn:
1"""Computes linear weighted kappa by hand for both prompts on the train pool and checks each against scikit-learn. The prose's point rests on the two linear weighted kappa lines, which match scikit-learn's, and on the one-grade-apart shares beside them."""2import numpy as np3from sklearn.metrics import cohen_kappa_score, confusion_matrix45from lib.agreement import PROMPTS, graded_pairs67pairs = graded_pairs("train") # up to 4 human-judged pairs per label per train query8grades = [2, 1, 0] # exact, partial, irrelevant9cost = np.abs(np.subtract.outer(grades, grades)) / 2 # 0 on the diagonal, 0.5 one grade apart, 1 two apart10print("disagreement weights, rows and columns 2, 1, 0")11print(cost)1213for prompt in PROMPTS:14 human, llm = pairs["human"].astype(int), pairs[prompt].astype(int)15 # labels fixes the rows and columns to 2, 1, 0 in that order, not the order the grades first appear16 counts = confusion_matrix(human, llm, labels=grades) # rows human, columns LLM17 expected = np.outer(counts.sum(axis=1), counts.sum(axis=0)) / counts.sum() # counts if independent18 weighted = 1 - (cost * counts).sum() / (cost * expected).sum()19 near = cost == 0.5 # cells one grade apart20 print()21 # row 0 is exact and column 2 is irrelevant, so these two corners are the far misses22 print(f"pairs two grades apart, {prompt} prompt: {counts[0, 2] + counts[2, 0]}")23 print(f"disagreements one grade apart, share, {prompt} prompt: {counts[near].sum() / counts[cost > 0].sum():.3f}")24 print(f"one grade apart, share expected by chance, {prompt} prompt: {expected[near].sum() / expected[cost > 0].sum():.3f}")25 print(f"kappa, {prompt} prompt: {cohen_kappa_score(human, llm):.3f}")26 print(f"linear weighted kappa by hand, {prompt} prompt: {weighted:.3f}")27 print(f"linear weighted kappa from scikit-learn, {prompt} prompt: "28 f"{cohen_kappa_score(human, llm, weights='linear'):.3f}")
python weighted-kappa-by-hand.pydisagreement weights, rows and columns 2, 1, 0
[[0. 0.5 1. ]
[0.5 0. 0.5]
[1. 0.5 0. ]]
pairs two grades apart, short prompt: 12
disagreements one grade apart, share, short prompt: 0.942
one grade apart, share expected by chance, short prompt: 0.742
kappa, short prompt: 0.432
linear weighted kappa by hand, short prompt: 0.523
linear weighted kappa from scikit-learn, short prompt: 0.523
pairs two grades apart, guidelines prompt: 30
disagreements one grade apart, share, guidelines prompt: 0.851
one grade apart, share expected by chance, guidelines prompt: 0.664
kappa, guidelines prompt: 0.454
linear weighted kappa by hand, guidelines prompt: 0.531
linear weighted kappa from scikit-learn, guidelines prompt: 0.531
A ponderação eleva o kappa de short de 0.432 para 0.523, e o kappa de guidelines de 0.454 para 0.531, e os dois valores coincidem com os do scikit-learn. Ela os eleva porque a parcela de discordâncias a uma nota de distância é maior do que o acaso faria esperar: 0.942 em short, contra 0.742 esperados por acaso, e 0.851 em guidelines, contra 0.664.
Os prompts também diferem nos erros graves, os pares a duas notas de distância: 12 para short e 30 para guidelines. Saber se algum dos prompts concorda melhor é uma questão para um intervalo.
Regra prática: Para notas ordenadas, informe o kappa ponderado linear ao lado do kappa simples e conte os erros graves separadamente. Pondere cada discordância pela diferença de ganho que ela custa. Com os ganhos lineares do livro, são pesos lineares. Com ganhos exponenciais de 0, 1 e 3 (Escolha uma métrica), as diferenças são 1, 2 e 3, o que nenhuma das duas opções do scikit-learn produz; então construa essa matriz do mesmo modo que o exemplo constrói a linear.
Leia o kappa em relação à composição de rótulos
O ajuste do Kappa depende de com que frequência cada juiz usa cada rótulo, de modo que o mesmo juiz obtém um kappa diferente em uma amostra com uma composição diferente de rótulos. Quando um rótulo domina, a concordância observada pode ser alta enquanto o kappa permanece baixo. Artstein e Poesio chamam isso de problema da prevalência: "os codificadores podem concordar em uma grande proporção dos itens enquanto produzem anotações que de fato estão corretas em alto grau, e ainda assim os coeficientes de confiabilidade permanecem baixos" (Artstein e Poesio, 2008).
O registro montou o conjunto de treino de forma equilibrada, com até 4 pares de cada rótulo por consulta de treino, de modo que o conjunto contém mais pares exatos e irrelevantes do que os julgamentos da loja. Para ver o efeito disso sobre o kappa, atribua a cada par um peso de modo que o conjunto tenha a composição de rótulos de todos os julgamentos das consultas de treino, e meça novamente:
1"""Measures each prompt's agreement with the store's judges on the train pool, as drawn and reweighted to the label mix of all the train judgments. The prose's point rests on the kappa lines for each mix and on the higher-kappa lines, which change with the mix."""2import numpy as np3from sklearn.metrics import cohen_kappa_score45from lib.agreement import LABELS, PROMPTS, graded_pairs6from lib.store import load_labels, load_queries78pairs = graded_pairs("train") # drawn evenly: up to 4 pairs per label per train query9drawn = pairs["human"].value_counts(normalize=True)10labels = load_labels()11# every judged label for the train queries, not only the pairs that were drawn12natural = labels[labels["query_id"].isin(load_queries("train").index)]["grade"].value_counts(normalize=True)13top = graded_pairs("test")["human"].dropna().value_counts(normalize=True) # the rankers' top 10s, judged pairs14for grade, label in LABELS.items():15 print(f"{label} share, as drawn: {drawn[grade]:.3f}")16 print(f"{label} share, in the train judgments: {natural[grade]:.3f}")17 print(f"{label} share, judged test-pool pairs: {top[grade]:.3f}")1819# each pair counts for its label's share in the judgments divided by its share as drawn20weight = pairs["human"].map(natural / drawn).astype(float) # count each pair as if drawn in that mix21kappas = {}22for prompt in PROMPTS:23 human, llm = pairs["human"].astype(int), pairs[prompt].astype(int)24 print()25 print(f"observed agreement, {prompt} prompt, as drawn: {(human == llm).mean():.3f}")26 print(f"kappa, {prompt} prompt, as drawn: {cohen_kappa_score(human, llm):.3f}")27 print(f"observed agreement, {prompt} prompt, train judgments' mix: {np.average(human == llm, weights=weight):.3f}")28 # sample_weight counts each pair that many times; it is not the linear weights of the last section29 kappas[prompt] = cohen_kappa_score(human, llm), cohen_kappa_score(human, llm, sample_weight=weight)30 print(f"kappa, {prompt} prompt, train judgments' mix: {kappas[prompt][1]:.3f}")31print()32for position, mix in enumerate(["as drawn", "train judgments' mix"]):33 # on a tie, max returns the first prompt, short34 print(f"higher kappa, {mix}: {max(PROMPTS, key=lambda prompt: kappas[prompt][position])}")
python kappa-under-two-label-mixes.pyexact share, as drawn: 0.356
exact share, in the train judgments: 0.234
exact share, judged test-pool pairs: 0.543
partial share, as drawn: 0.364
partial share, in the train judgments: 0.613
partial share, judged test-pool pairs: 0.427
irrelevant share, as drawn: 0.280
irrelevant share, in the train judgments: 0.153
irrelevant share, judged test-pool pairs: 0.030
observed agreement, short prompt, as drawn: 0.624
kappa, short prompt, as drawn: 0.432
observed agreement, short prompt, train judgments' mix: 0.635
kappa, short prompt, train judgments' mix: 0.370
observed agreement, guidelines prompt, as drawn: 0.633
kappa, guidelines prompt, as drawn: 0.454
observed agreement, guidelines prompt, train judgments' mix: 0.573
kappa, guidelines prompt, train judgments' mix: 0.345
higher kappa, as drawn: guidelines
higher kappa, train judgments' mix: short
Parcial representa 0.364 do conjunto como foi montado, mas 0.613 dos julgamentos de treino, de modo que a reponderação conta os pares parciais com mais peso e os pares exatos e irrelevantes com menos peso.
Na composição dos julgamentos, a concordância observada de short vai de 0.624 para 0.635, e seu kappa, de 0.432 para 0.370. Para guidelines, a concordância observada vai de 0.633 para 0.573, e o kappa, de 0.454 para 0.345.
O prompt com o kappa mais alto é guidelines na amostra como foi montada, e short na composição dos julgamentos.
Números publicados carregam consigo a sua composição. O único estudo de juízes baseados em LLM sobre o WANDS que encontramos montou 5,000 pares consulta-produto distribuídos igualmente entre os três rótulos. Ele relata acurácia de 0.726 para o melhor modelo aberto, com 70 bilhões de parâmetros, até 0.837 para o melhor modelo fechado, cada um em sua melhor configuração, com 16 exemplos resolvidos recuperados para cada par (Sachdev et al., 2025, Tabela 3). Os prompts da loja não têm exemplos resolvidos. Essa acurácia é concordância observada em uma amostra equilibrada, como a do conjunto de treino, de modo que nenhum dos dois números se transfere para a composição de rótulos dos julgamentos da loja.
Os pares que a loja pedirá a um LLM para julgar são os produtos que seus rankers colocam nos seus top 10, o conjunto de teste. Entre os pares julgados, 0.543 são exatos, 0.427 parciais e 0.030 irrelevantes. Essa é uma terceira composição, e um tipo diferente de par, que Leia a direção dos erros do LLM mede.
Regra prática: Informe a composição de rótulos junto com cada kappa, e nunca compare kappas de amostras com composições diferentes, sejam suas ou publicadas. Recomendamos montar a amostra de concordância da mesma forma como você usará o juiz: se ele vai avaliar os top 10 dos seus rankers, amostre pares dos top 10 das consultas de treino.
Leia a direção dos erros do LLM
Kappa indica quanto dois juízes concordam, não como eles diferem. Uma matriz de confusão mostra como dois juízes diferem: uma tabela de contagens com uma linha para cada nota dos juízes da loja e uma coluna para cada nota do LLM, ambas na ordem exact, partial, irrelevant. Acima da diagonal, o LLM deu uma nota menor que a dos juízes da loja; abaixo dela, uma nota maior. Um juiz cujos erros ficam, em sua maioria, abaixo é tolerante, e um cujos erros ficam, em sua maioria, acima é rigoroso.
Vários estudos constatam que juízes LLM são tolerantes. Na trilha RAG do TREC 2024, que avalia geração aumentada por recuperação (respostas escritas a partir de texto recuperado), os avaliadores humanos parecem, no conjunto, mais rigorosos do que o UMBRELA, um juiz LLM de código aberto (Upadhyay et al., 2024a). Arabzadeh e Clarke relatam que o UMBRELA, construído sobre o GPT-4o (Upadhyay et al., 2024b), rotulou mais de 26% a mais de documentos como perfeitamente relevantes do que as pessoas nas trilhas Deep Learning do TREC de 2019 a 2021, 3,063 contra 2,429 (Arabzadeh and Clarke, 2025a). Yu et al. relatam que juízes LLM "dão notas de relevância inflacionadas de forma consistente" (Yu et al., 2026).
Nem todo estudo concorda. Thomas et al., com um de seus 32 prompts em uma amostra estratificada por rótulo, constataram que o LLM tinha mais probabilidade do que os avaliadores do TREC de considerar um par não relevante, 44% contra 33% (Thomas et al., 2024).
Uma matriz para cada prompt em cada conjunto mostra em que sentido o LLM erra e se essa direção se mantém ao passar dos pares de treino balanceados para os top 10 dos rankers: o conjunto de treino é sorteado igualmente por rótulo, e os pares julgados do conjunto de teste são os top 10 dos quatro rankers do capítulo 1 que um LLM avaliaria. As matrizes do conjunto de teste informam sobre as consultas de teste; elas não escolhem um prompt:
1"""Prints the confusion matrix of the store's grades against each prompt's grades, on the train pool and on the judged test pairs, with the counts of lower and higher grades. The prose's point rests on the 'stricter' line for each pool, read with the largest error printed beside it."""2import pandas as pd3from sklearn.metrics import cohen_kappa_score45from lib.agreement import LABELS, PROMPTS, graded_pairs67order = list(LABELS.values()) # rows: the store's grades; columns: the LLM's; both exact first8for pool in ["train", "test"]:9 pairs = graded_pairs(pool).dropna(subset=["human"]) # in the test pool, the pairs people judged10 human = pairs["human"].astype(int)11 print(f"\njudged pairs, {pool} pool: {len(pairs)}\nmean human grade, {pool} pool: {human.mean():.3f}")12 for prompt in PROMPTS:13 llm, name = pairs[prompt].astype(int), f"{pool} pool, {prompt} prompt"14 table = pd.crosstab(human.map(LABELS).rename("human"), llm.map(LABELS).rename(f"llm, {name}"))15 table = table.reindex(index=order, columns=order, fill_value=0)16 errors = {f"{row} called {column}": table.at[row, column] for row in order for column in order if row != column}17 # on a tie, max returns the first cell, in row order18 largest = max(errors, key=errors.get)19 print(table)20 print(f"kappa, {name}: {cohen_kappa_score(human, llm):.3f}\nmean llm grade, {name}: {llm.mean():.3f}")21 print(f"llm grade higher than human, {name}: {(llm > human).sum()}")22 print(f"llm grade lower than human, {name}: {(llm < human).sum()}")23 # a tie counts as not stricter24 print(f"stricter than the store's judges, {name}: {'yes' if (llm < human).sum() > (llm > human).sum() else 'no'}")25 print(f"largest error, {name}: {largest} ({errors[largest]})")
python llm-confusion-matrix.py
judged pairs, train pool: 550
mean human grade, train pool: 1.076
llm, train pool, short prompt exact partial irrelevant
human
exact 102 85 9
partial 22 132 46
irrelevant 3 42 109
kappa, train pool, short prompt: 0.432
mean llm grade, train pool, short prompt: 0.933
llm grade higher than human, train pool, short prompt: 67
llm grade lower than human, train pool, short prompt: 140
stricter than the store's judges, train pool, short prompt: yes
largest error, train pool, short prompt: exact called partial (85)
llm, train pool, guidelines prompt exact partial irrelevant
human
exact 118 53 25
partial 30 98 72
irrelevant 5 17 132
kappa, train pool, guidelines prompt: 0.454
mean llm grade, train pool, guidelines prompt: 0.862
llm grade higher than human, train pool, guidelines prompt: 52
llm grade lower than human, train pool, guidelines prompt: 150
stricter than the store's judges, train pool, guidelines prompt: yes
largest error, train pool, guidelines prompt: partial called irrelevant (72)
judged pairs, test pool: 564
mean human grade, test pool: 1.512
llm, test pool, short prompt exact partial irrelevant
human
exact 252 53 1
partial 57 177 7
irrelevant 2 6 9
kappa, test pool, short prompt: 0.571
mean llm grade, test pool, short prompt: 1.521
llm grade higher than human, test pool, short prompt: 65
llm grade lower than human, test pool, short prompt: 61
stricter than the store's judges, test pool, short prompt: no
largest error, test pool, short prompt: partial called exact (57)
llm, test pool, guidelines prompt exact partial irrelevant
human
exact 261 41 4
partial 76 133 32
irrelevant 3 4 10
kappa, test pool, guidelines prompt: 0.470
mean llm grade, test pool, guidelines prompt: 1.521
llm grade higher than human, test pool, guidelines prompt: 83
llm grade lower than human, test pool, guidelines prompt: 77
stricter than the store's judges, test pool, guidelines prompt: no
largest error, test pool, guidelines prompt: partial called exact (76)
No conjunto de treino, o LLM é mais rigoroso que os juízes da loja? Com short: yes. Com guidelines: yes. Com short ele atribui nota menor a 140 pares e maior a 67, e com guidelines, menor a 150 e maior a 52. O maior erro é exact called partial (85) com short, e partial called irrelevant (72) com guidelines.
No conjunto de teste, a resposta é no com short e no com guidelines. Com short, a nota do LLM é maior em 65 pares e menor em 61; com guidelines, maior em 83 e menor em 77. Sua nota média é 1.521 com short e 1.521 com guidelines, contra 1.512 para os juízes. Seus maiores erros são partial called exact (57) com short e partial called exact (76) com guidelines.
Kappa é 0.571 com short e 0.470 com guidelines, contra 0.432 e 0.454 no conjunto de treino. A direção, o maior erro e o kappa mudam todos com o conjunto, como a composição dos rótulos alerta. Compare o que o LLM viu encontra um padrão que vale para os dois conjuntos.
Nem a direção dos erros diz o que acontece com a pontuação de um ranker. Um juiz tolerante conta mais produtos como relevantes, o que eleva o precision@10 (Conte os produtos relevantes). O nDCG@10 divide por um top 10 ideal construído com as mesmas notas (Calcule a pontuação de um ranking), de modo que elevar as notas pode elevar também o ideal, e o efeito líquido pode ir para qualquer lado e diferir entre rankers. A verificação da ordem dos rankers o mede no conjunto de teste.
Regra prática: Leia a matriz de confusão antes de ler o kappa, em pares sorteados da forma como você vai usar o juiz, e nomeie a direção e o maior erro para aquele conjunto. Não leve uma direção de um conjunto para outro, e não preveja o nDCG@10 de um ranker a partir dela. Compare rankers entre si sob as mesmas notas, e nunca compare uma pontuação com notas do LLM a uma pontuação com notas humanas.
Compare o que o LLM viu com o que os juízes viram
Um juiz só pode avaliar as evidências que lhe são mostradas. Os juízes do WANDS viram a consulta e o ID, o nome, a imagem e a página web do produto, e as diretrizes de anotação lhes diziam para entender a consulta primeiro: "Recomendo fortemente pesquisar no Google primeiro". A gravação mostrava ao LLM o nome, a classe, a categoria, a descrição e os atributos de cada produto, como lib.agreement.as_the_llm_saw os escreve. A amostra da loja corta as descrições em cerca de 400 caracteres (ficha de dados) e não traz imagens, por isso a gravação enviou ao LLM apenas texto. Parte da discordância pode vir dessa lacuna, e não da qualidade do julgamento do LLM; essa é nossa inferência. Uma consequência pode ser testada: se o LLM avalia o que está escrito, deve dar uma nota mais baixa a produtos exatos cujo texto não diz o que a consulta pede, e uma nota mais alta a produtos parciais cujo texto diz.
Esta verificação parte de um par de treino e, em seguida, da consulta de teste clear shower curtain e de todos os pares exatos e parciais julgados nos dois conjuntos (a gravação). Ela procura cada palavra da consulta no que o LLM viu, dividida em palavras minúsculas da mesma forma que a verificação do capítulo 2 as divide:
1"""Checks whether the LLM's grades follow the words in each product's text, for one train pair, for the clear shower curtain products, and across both pools. The prose's point rests on the 'share graded lower' and 'share graded higher' lines, which compare pairs whose text has every query word with pairs that miss one."""2import re34from lib.agreement import PROMPTS, as_the_llm_saw, graded_pairs5from lib.store import load_products, load_queries678def words(text):9 """Lowercase word tokens, as chapter 2 matches query words against product text."""10 # runs of letters, digits and underscores, so 7qt is one word and '7 qt' is two11 return set(re.findall(r"\w+", text.lower()))121314products, queries = load_products(), load_queries()15# query 163 is a train query, and product 20718 is the pair the prose follows16print("query:", queries.at[163, "query"]) # a train query17print(as_the_llm_saw(products.loc[20718]))18print("grades from people, short, guidelines:", *graded_pairs("train").set_index(["query_id", "product_id"]).loc[(163, 20718)])1920curtains = graded_pairs("test").query("query_id == 246") # clear shower curtain: every product in a top 1021# whole words only, so 'unclear' doesn't count as saying clear22says = curtains["product_id"].map(lambda product_id: "clear" in words(as_the_llm_saw(products.loc[product_id])))23for kind, group in [("say clear", curtains[says]), ("never say clear", curtains[~says])]:24 print(f"\nclear shower curtain products that {kind}: {len(group)}")25 for column, judge in [("human", "people"), ("short", "the short prompt"), ("guidelines", "the guidelines prompt")]:26 print(f"products that {kind}, graded exact by {judge}: {(group[column] == 2).sum()}")2728for pool in ["train", "test"]:29 pairs = graded_pairs(pool).dropna(subset=["human"]) # in the test pool, the pairs people judged30 # subset: every query word appears in the text the LLM saw31 pairs["every word"] = [words(queries.at[query_id, "query"]) <= words(as_the_llm_saw(products.loc[product_id]))32 for query_id, product_id in zip(pairs["query_id"], pairs["product_id"])]33 # share of each group that the LLM grades below people (exact) or above them (partial), for each prompt34 for label, grade, every_word, direction in [("exact", 2, False, "lower"), ("exact", 2, True, "lower"),35 ("partial", 1, True, "higher"), ("partial", 1, False, "higher")]:36 group = pairs[(pairs["human"] == grade) & (pairs["every word"] == every_word)]37 kind = f"{label} {pool} pairs {'with every query word' if every_word else 'missing a query word'}"38 print(f"\n{kind}: {len(group)}")39 for prompt in PROMPTS:40 moved = group[prompt] < grade if direction == "lower" else group[prompt] > grade41 print(f"share graded {direction}, {prompt} prompt, {kind}: {moved.mean():.3f}")
python llm-grades-follow-written-words.pyquery: dual monitor stand
Name: abramowski monitor stand
Class: Desktop Organizers & Desk Pads
Category:
Description: the monitor stand riser can help !
Attributes: color: white; material: wood; style: modern; width: 23.5; height: 4.64; depth: 9.2
grades from people, short, guidelines: 2 1 1
clear shower curtain products that say clear: 9
products that say clear, graded exact by people: 5
products that say clear, graded exact by the short prompt: 7
products that say clear, graded exact by the guidelines prompt: 7
clear shower curtain products that never say clear: 9
products that never say clear, graded exact by people: 1
products that never say clear, graded exact by the short prompt: 0
products that never say clear, graded exact by the guidelines prompt: 0
exact train pairs missing a query word: 149
share graded lower, short prompt, exact train pairs missing a query word: 0.584
share graded lower, guidelines prompt, exact train pairs missing a query word: 0.483
exact train pairs with every query word: 47
share graded lower, short prompt, exact train pairs with every query word: 0.149
share graded lower, guidelines prompt, exact train pairs with every query word: 0.128
partial train pairs with every query word: 8
share graded higher, short prompt, partial train pairs with every query word: 0.875
share graded higher, guidelines prompt, partial train pairs with every query word: 0.875
partial train pairs missing a query word: 192
share graded higher, short prompt, partial train pairs missing a query word: 0.078
share graded higher, guidelines prompt, partial train pairs missing a query word: 0.120
exact test pairs missing a query word: 128
share graded lower, short prompt, exact test pairs missing a query word: 0.305
share graded lower, guidelines prompt, exact test pairs missing a query word: 0.281
exact test pairs with every query word: 178
share graded lower, short prompt, exact test pairs with every query word: 0.084
share graded lower, guidelines prompt, exact test pairs with every query word: 0.051
partial test pairs with every query word: 42
share graded higher, short prompt, partial test pairs with every query word: 0.548
share graded higher, guidelines prompt, partial test pairs with every query word: 0.667
partial test pairs missing a query word: 199
share graded higher, short prompt, partial test pairs missing a query word: 0.171
share graded higher, guidelines prompt, partial test pairs missing a query word: 0.241
Para dual monitor stand, uma consulta de treino, os juízes da loja classificaram abramowski monitor stand como exato, e os dois prompts o classificaram como parcial (2 1 1, nessa ordem); nada do que o LLM viu diz que o suporte comporta dois monitores.
Para clear shower curtain, as notas exatas do LLM acompanham a palavra. Dos 9 produtos do conjunto de teste que dizem clear em algum ponto que o LLM pôde ler, os juízes classificaram 5 como exatos, short 7 e guidelines 7. Dos 9 que nunca dizem, os juízes classificaram 1 como exatos, e short 0 e guidelines 0.
Contando nos conjuntos, o padrão se mantém. Com short, pares exatos cujo texto não contém uma palavra da consulta recebem nota mais baixa do LLM em uma proporção de 0.584 no conjunto de treino e 0.305 no conjunto de teste, contra 0.149 e 0.084 para pares exatos cujo texto tem todas as palavras.
No conjunto de teste, os que têm todas as palavras da consulta recebem nota mais alta em uma proporção de 0.548, contra 0.171 dos que não têm alguma palavra. No conjunto de teste, guidelines se divide da mesma forma: 0.281 contra 0.051 para pares exatos, e 0.667 contra 0.241 para os parciais.
Os conjuntos diferem quanto ao caso mais comum. O conjunto de treino tem 149 pares exatos que não têm uma palavra e 8 pares parciais com todas as palavras; o conjunto de teste tem 128 e 42. Segundo nossa leitura, é por isso que a direção dos erros difere entre os conjuntos. A verificação é grosseira: um plural ou um erro de grafia também conta como palavra ausente. O prompt guidelines pede os rebaixamentos: "Se um modificador não for mencionado, decida com base no que está escrito, e não presuma que ele é atendido." O prompt short não tem tal regra e também rebaixa.
Regra prática: Forneça a um juiz LLM todo campo em que seus juízes se apoiaram e que você consiga transformar em texto, como os atributos e a descrição completa, e registre o que ele não consegue ver. Antes de contar uma discordância contra o LLM, verifique se a evidência estava no que ele viu. Quando a evidência dos seus juízes for visual, meça se o LLM dá notas mais baixas aos produtos exatos, como este faz nos dois conjuntos, ou forneça-lhe as imagens, se seu modelo aceitar imagens.
Meça o quanto o prompt muda os rótulos
Um juiz LLM é um modelo e um prompt juntos. Ao longo de 42 paráfrases de um mesmo prompt, Thomas et al. encontraram kappas médios que variam de 0.50, que eles chamam de concordância moderada, até 0.72. Eles alertam que a pontuação de um único prompt é apenas um sorteio dentro da faixa que um juiz poderia atingir (Thomas et al., 2024).
Com três LLMs e 72 prompts nas coleções Deep Learning do TREC, Arabzadeh e Clarke constataram que os métodos binários e por pares foram os menos sensíveis à redação do prompt, enquanto os julgamentos de relevância graduada, do tipo que a loja usa, foram altamente sensíveis a ela (Arabzadeh and Clarke, 2025b). Nenhum prompt foi o melhor para todos os LLMs, embora o UMBRELA tenha se saído consistentemente bem nos julgamentos graduados em diferentes LLMs.
Os dois prompts compartilham suas definições, e guidelines acrescenta cinco regras a elas (Escreva diretrizes de julgamento). Cada conjunto em o registro mostra onde os prompts discordam, e o conjunto de treino mostra se é possível dizer qual prompt concorda melhor com os juízes da loja. Pares da mesma consulta não são independentes; por isso, o intervalo reamostra consultas de treino inteiras, como o bootstrap do capítulo 3 reamostra consultas:
1"""Counts where the two prompts disagree, their kappa with each other, and how far their kappas with people differ across resampled train queries. The prose's point rests on the 95% interval line, which includes 0 for this recording."""2import numpy as np3import pandas as pd4from sklearn.metrics import cohen_kappa_score56from lib.agreement import LABELS, graded_pairs7from lib.store import load_products, load_queries8910def kappa_gap(sample):11 """Kappa with people under the guidelines prompt, minus kappa under the short prompt."""12 human = sample["human"].astype(int)13 return cohen_kappa_score(human, sample["guidelines"].astype(int)) - cohen_kappa_score(human, sample["short"].astype(int))141516order = list(LABELS.values()) # exact, partial, irrelevant17for pool in ["train", "test"]:18 # the test pool includes pairs nobody judged, so these counts cover every pair19 pairs = graded_pairs(pool)20 print(f"\n{pool} pairs where the prompts disagree: {(pairs['short'] != pairs['guidelines']).sum()} of {len(pairs)}\n"21 f"kappa between the prompts, {pool} pool: {cohen_kappa_score(pairs['short'], pairs['guidelines']):.3f}")22 table = pd.crosstab(pairs["short"].map(LABELS).rename(f"short, {pool}"), pairs["guidelines"].map(LABELS).rename("guidelines"))23 table = table.reindex(index=order, columns=order, fill_value=0)24 cells = {f"{row} under short, {column} under guidelines": table.at[row, column] for row in order for column in order if row != column}25 print(f"{table}\nlargest disagreement, {pool} pool: {max(cells, key=cells.get)} ({max(cells.values())})")2627pairs, products, queries = graded_pairs("train"), load_products(), load_queries()28moved = pairs[(pairs["short"] == 1) & (pairs["guidelines"] == 0)] # partial under one prompt, irrelevant under the other29print("\n".join(f"moved train pairs judged {label} by people: {(moved['human'] == grade).sum()}" for grade, label in LABELS.items()))30# the first five queries in order, not a random sample31for query_id, product_id in moved[["query_id", "product_id"]].drop_duplicates("query_id").head(5).itertuples(index=False):32 print(f" {queries.at[query_id, 'query']:<28} {products.at[product_id, 'name'][:50]}")3334# a fixed seed, so the interval is the same on every run35rng, train_queries = np.random.default_rng(2026), pairs["query_id"].unique()36by_query = {query_id: group for query_id, group in pairs.groupby("query_id")}37# each resample draws train queries with replacement, so some repeat and others are left out38gaps = [kappa_gap(pd.concat([by_query[query_id] for query_id in rng.choice(train_queries, len(train_queries))]))39 for _ in range(2000)] # resample whole train queries40low, high = np.percentile(gaps, [2.5, 97.5])41print(f"kappa with people, guidelines minus short: {kappa_gap(pairs):.3f}\n95% interval over resampled train queries: {low:.3f} to {high:.3f}")
python prompt-disagreement.py
train pairs where the prompts disagree: 122 of 550
kappa between the prompts, train pool: 0.668
guidelines exact partial irrelevant
short, train
exact 122 4 1
partial 31 153 75
irrelevant 0 11 153
largest disagreement, train pool: partial under short, irrelevant under guidelines (75)
test pairs where the prompts disagree: 93 of 590
kappa between the prompts, test pool: 0.712
guidelines exact partial irrelevant
short, test
exact 303 11 1
partial 42 174 37
irrelevant 0 2 20
largest disagreement, test pool: partial under short, exact under guidelines (42)
moved train pairs judged exact by people: 18
moved train pairs judged partial by people: 31
moved train pairs judged irrelevant by people: 26
toddler couch fold out eulah 79 '' cotton rolled arm sofa bed
70s inspired furniture angels moroccan window curtains , oriental wavy cu
7qt slow cooker berghoff international eclipse 7 qt non-stick cove
gnome fairy garden fairy house tea pot fairy garden
wall sconce with usb port 2 piece wall sconce set
kappa with people, guidelines minus short: 0.022
95% interval over resampled train queries: -0.042 to 0.086
Os dois prompts discordam em 122 of 550 pares de treino e em 93 of 590 pares de teste, e o kappa entre eles é 0.668 no conjunto de treino e 0.712 no conjunto de teste.
A maior discordância varia de um conjunto para outro. No conjunto de treino, ela é partial under short, irrelevant under guidelines (75); no conjunto de teste, os 10 primeiros resultados dos ranqueadores, ela é partial under short, exact under guidelines (42).
Dos pares de treino que short classifica como parciais e guidelines classifica como irrelevantes, os juízes da loja classificaram 26 como irrelevantes, ficando do lado de guidelines; 31 como parciais, ficando do lado de short; e 18 como exatos. Entre os pares que mudaram, os exemplos listados são um sofá-cama para toddler couch fold out e cortinas de janela para 70s inspired furniture. O registro guarda rótulos, não justificativas; então, a partir de nomes como estes, inferimos que a mudança vem da regra guidelines, que classifica como irrelevante o tipo errado de produto.
Quanto ao kappa com os juízes da loja, guidelines fica à frente de short por 0.022, e o intervalo de 95% sobre as consultas de treino reamostradas vai de -0.042 to 0.086. Esse intervalo inclui 0; portanto, o conjunto de treino não consegue distinguir os prompts, e a loja mantém os dois.
Regra prática: Trate o prompt como parte do juiz. Registre cada palavra do prompt, exatamente como está, junto com a versão do modelo, as configurações e o esquema de resposta, como este registro faz em seu manifesto e script. Trate uma mudança de prompt como um juiz diferente, cuja concordância você mede de novo. Execute ao menos dois prompts e confie em uma conclusão tirada de notas de LLM somente quando os dois a derem. Escolha um prompt em vez de outro nos pares de treino, e somente quando o intervalo para a diferença entre eles não incluir 0.
Preencher pares não julgados com notas do LLM
Consideramos o preenchimento das lacunas nos julgamentos humanos o uso menos arriscado de um juiz LLM. Mantenha cada nota humana e use o LLM apenas para os pares que ninguém julgou, os quais uma métrica contaria como nota 0 (Contar produtos não julgados). O LLM então decide apenas o que antes era um palpite.
Dos 590 pares nos top 10 dos quatro ranqueadores do capítulo 1, 26 não foram julgados, e os top 10 do BM25 contêm 22 deles, contra 3 para a recuperação semântica e 6 para o híbrido.
Deixe cada prompt preencher esses pares, reavalie os quatro ranqueadores em nDCG@10 (Pontuar um ranking) e refaça as comparações planejadas do capítulo 3 com as notas preenchidas:
1"""Fills the pairs nobody judged with each prompt's grades, then rescores the four rankers and the planned verdicts with the filled grades. The prose's point rests on the 'that change' lines, which list the rankers and verdicts that move when the holes are filled."""2from lib.agreement import LABELS, PLANNED, PROMPTS, chapter_one_runs, fill_unjudged, graded_pairs, llm_qrels, planned_verdicts3from lib.metrics import evaluate4from lib.store import load_products, load_queries, qrels567def order(scores):8 """Rankers by mean nDCG@10 over the test queries, best first."""9 return sorted(scores, key=lambda name: scores[name].mean(), reverse=True)101112products, queries, people = load_products(), load_queries("test"), qrels("test")13runs = chapter_one_runs(products, queries)14pairs = graded_pairs("test") # every product in the top 10 of the four runs, per test query15unjudged = pairs[pairs["human"].isna()]16print(f"pairs in the test pool: {len(pairs)}\nof them, unjudged: {len(unjudged)}")17for name, run in runs.items():18 # people[query_id] holds the human judgments for a query, so a product missing from it was never judged19 missing = sum(product_id not in people[query_id] for query_id, ranking in run.items() for product_id in ranking[:10])20 print(f"unjudged products in the top 10s, {name}: {missing}")21lights = unjudged[unjudged["query_id"] == 133] # outdoor light fixtures22print(f"unjudged products for outdoor light fixtures: {len(lights)}\n"23 f"of them, with bulb in the name: {lights['product_id'].map(products['name']).str.contains('bulb').sum()}")24threshold = 0.05 / len(PLANNED) # chapter 3's rule25human = {name: evaluate(run, people)["ndcg@10"] for name, run in runs.items()} # per-query scores26print(f"order, people's grades only: {' > '.join(order(human))}")2728for prompt in PROMPTS:29 counts = ", ".join(str((unjudged[prompt] == grade).sum()) for grade in LABELS) # grades 2, 1 and 030 print(f"\nunjudged pairs graded exact, partial, irrelevant, {prompt} prompt: {counts}")31 print(f"unjudged bulbs graded irrelevant, {prompt} prompt: {(lights[prompt] == 0).sum()}")32 filled = {name: evaluate(run, fill_unjudged(people, llm_qrels(prompt)))["ndcg@10"] for name, run in runs.items()}33 print("\n".join(f"{name} ndcg@10, filled by the {prompt} prompt: {filled[name].mean():.3f}" for name in runs))34 print(f"order, filled by the {prompt} prompt: {' > '.join(order(filled))}")35 # compares the two orders place by place36 moved = [name for name, place in zip(order(filled), order(human)) if name != place]37 print(f"rankers that change place when filled, {prompt} prompt: {', '.join(moved) or 'none'}")38 changed = [pair for pair, established in planned_verdicts(filled, threshold).items()39 if established != planned_verdicts(human, threshold)[pair]]40 print(f"verdicts that change when filled, {prompt} prompt: {'; '.join(' minus '.join(pair) for pair in changed) or 'none'}")
python fill-unjudged-pairs.pypairs in the test pool: 590
of them, unjudged: 26
unjudged products in the top 10s, bm25: 22
unjudged products in the top 10s, semantic: 3
unjudged products in the top 10s, hybrid: 6
unjudged products in the top 10s, reranked: 6
unjudged products for outdoor light fixtures: 8
of them, with bulb in the name: 8
order, people's grades only: semantic > hybrid > reranked > bm25
unjudged pairs graded exact, partial, irrelevant, short prompt: 4, 17, 5
unjudged bulbs graded irrelevant, short prompt: 0
bm25 ndcg@10, filled by the short prompt: 0.754
semantic ndcg@10, filled by the short prompt: 0.833
hybrid ndcg@10, filled by the short prompt: 0.821
reranked ndcg@10, filled by the short prompt: 0.813
order, filled by the short prompt: semantic > hybrid > reranked > bm25
rankers that change place when filled, short prompt: none
verdicts that change when filled, short prompt: none
unjudged pairs graded exact, partial, irrelevant, guidelines prompt: 5, 9, 12
unjudged bulbs graded irrelevant, guidelines prompt: 7
bm25 ndcg@10, filled by the guidelines prompt: 0.745
semantic ndcg@10, filled by the guidelines prompt: 0.834
hybrid ndcg@10, filled by the guidelines prompt: 0.821
reranked ndcg@10, filled by the guidelines prompt: 0.813
order, filled by the guidelines prompt: semantic > hybrid > reranked > bm25
rankers that change place when filled, guidelines prompt: none
verdicts that change when filled, guidelines prompt: none
Os prompts discordam sobre os pares não julgados. Contados como exato, parcial e irrelevante, short os avalia como 4, 17, 5, e guidelines como 5, 9, 12. A divergência está nos produtos não julgados para outdoor light fixtures no top 10 do BM25 (Pontuar todas as consultas de teste): 8 dos 8 têm bulb no nome.
guidelines considera 7 das lâmpadas irrelevantes, e short considera 0. O capítulo 1 argumentou que uma lâmpada não é um luminário. Qual leitura os juízes da loja adotariam ninguém sabe até que eles julguem as lâmpadas.
Com as lacunas preenchidas, o BM25 marca 0.754 com short e 0.745 com guidelines, contra 0.725 apenas com as notas humanas, e a recuperação semântica marca 0.833 e 0.834, contra 0.830.
A ordem apenas com as notas humanas é semantic > hybrid > reranked > bm25. Os ranqueadores que trocam de posição quando short preenche as lacunas são none, e quando guidelines o faz, none. Os veredictos das comparações planejadas que mudam são none sob short e none sob guidelines.
Com as notas humanas, o judged@10 médio dos ranqueadores, a parcela de cada top 10 que as pessoas julgaram, vai de 0.927 para o BM25 a 0.990 para a recuperação semântica (Comparar execuções em um harness).
Quanto se pode confiar nas notas preenchidas? A evidência mais próxima são os pares julgados do mesmo pool, em que o kappa do LLM com os juízes da loja é 0.571 para short e 0.470 para guidelines. Nesses pares julgados, a nota do LLM é inferior à dos juízes em 61 pares e superior em 65 com short, e inferior em 77 e superior em 83 com guidelines (Ler a direção dos erros do LLM).
Regra prática: Preencha os pares não julgados nos top 10 dos seus ranqueadores com notas do LLM, como diagnóstico, sob todos os prompts que você executar, e reporte a pontuação preenchida ao lado da pontuação apenas humana, com o número de pares preenchidos. Se o preenchimento mudar a ordem de dois ranqueadores ou um veredicto, peça que pessoas julguem esses pares. Nunca deixe uma nota preenchida substituir uma humana.
Verifique se as notas do LLM ordenam os rankers da mesma forma
Dois conjuntos de julgamentos podem discordar em muitos rótulos e, ainda assim, ordenar sistemas de maneira semelhante. Voorhees pontuou execuções do TREC com conjuntos diferentes de julgamentos de relevância e constatou que "Foram encontradas correlações muito altas entre as ordenações dos sistemas produzidas com conjuntos diferentes de julgamentos de relevância" (Voorhees, 1998). Juízes LLM apresentam a mesma divisão. Em 42 conjuntos de rótulos de LLM para a trilha Deep Learning de 2023 do TREC, o kappa variou de cerca de 0.06 a 0.29, enquanto a correlação das ordenações dos sistemas permaneceu entre cerca de 0.83 e 0.95 (Rahmani et al., 2025, Tabela 3).
Essa correlação é o tau de Kendall. Um par de sistemas é concordante quando duas ordenações o colocam na mesma ordem relativa, e discordante quando as duas ordenações o colocam em ordens opostas. O tau é o número de pares concordantes menos o número de pares discordantes, dividido pelo total de pares, indo de 1 para a mesma ordem a −1 para a ordem inversa. O kendalltau do SciPy calcula τ_b, uma forma que também trata empates (documentação do SciPy).
Yilmaz et al. observam que rankings com tau de 0.9 ou mais costumam ser tratados como efetivamente equivalentes, ao menos empiricamente (Yilmaz et al., 2008). Sanderson e Soboroff constataram que decidir por esse limiar é menos confiável do que a área supunha (Sanderson e Soboroff, 2007).
Pontuar os quatro rankers do capítulo 1 em nDCG@10 sob notas humanas e sob as notas LLM de cada prompt mostra se o LLM ordena os rankers como as pessoas o fazem. O LLM julgou apenas o pool de teste, ou seja, os produtos presentes nos top 10 desses rankers, então um controle também pontua os rankers com notas humanas apenas para os pares do pool. Com quatro rankers há 6 pares, de modo que uma troca de par move o tau em 0.333, e o tau só pode assumir sete valores. Isso é grosseiro. Um juiz tão distante das pessoas em pares isolados ainda poderia ordenar os rankers como elas. Será que ordena? Antes de seguir, registre uma resposta:
1"""Scores the four rankers under human grades, under people's grades on the LLM's pairs as a control, and under each prompt, then counts the swapped pairs for each set. The prose's point rests on the 'swapped under' lines, read with the tau lines beside them."""2from itertools import combinations34from scipy.stats import kendalltau56from lib.agreement import chapter_one_runs, llm_qrels7from lib.metrics import evaluate8from lib.store import load_products, load_queries, qrels910products, queries, people = load_products(), load_queries("test"), qrels("test")11runs = chapter_one_runs(products, queries)12short, guidelines = llm_qrels("short"), llm_qrels("guidelines")13pooled = {query_id: {product_id: grade for product_id, grade in people[query_id].items() if product_id in short[query_id]}14 for query_id in people} # people's grades for the pairs the LLM judged, and no others15judgment_sets = {"people": people, "people on the LLM's pairs": pooled, "the short prompt": short,16 "the guidelines prompt": guidelines}17means = {name: {ranker: evaluate(run, judgments)["ndcg@10"].mean() for ranker, run in runs.items()}18 for name, judgments in judgment_sets.items()}19for name, scores in means.items():20 print(f"order under {name}: {' > '.join(sorted(scores, key=scores.get, reverse=True))}")21 for ranker, score in scores.items():22 print(f"{ranker} ndcg@10 under {name}: {score:.3f}")2324orders = [sorted(scores, key=scores.get, reverse=True) for scores in means.values()]25steady = [ranker for position, ranker in enumerate(orders[0]) if all(order[position] == ranker for order in orders)]26print(f"rankers in the same place under every set of grades: {', '.join(steady) or 'none'}")27control = means["people on the LLM's pairs"] # the same pool, human grades28for name in ["the short prompt", "the guidelines prompt"]:29 print("\n".join(f"{ranker}, {name} minus people on the LLM's pairs: {means[name][ranker] - control[ranker]:+.3f}" for ranker in runs))30# people's scores are the reference that every other set of grades is compared with31pairs, reference = list(combinations(runs, 2)), means["people"]32# one swap turns a concordant pair into a discordant one, which moves tau by 2 over the number of pairs33print(f"\npairs of rankers: {len(pairs)}\nchange in tau from one swapped pair: {2 / len(pairs):.3f}")34for name, scores in list(means.items())[1:]:35 swapped = [(first, second) for first, second in pairs # discordant: opposite signs36 if (reference[first] - reference[second]) * (scores[first] - scores[second]) < 0]37 print(f"swapped under {name}: {'; '.join(f'{first} and {second}' for first, second in swapped) or 'none'}")38 # concordant minus discordant, over all pairs; the discordant count is the number of swaps39 print(f"tau by hand, people against {name}: {(len(pairs) - 2 * len(swapped)) / len(pairs):.3f}")40 # SciPy's tau_b, which handles ties; .statistic is the tau value41 print(f"tau from scipy, people against {name}: {kendalltau(list(reference.values()), list(scores.values())).statistic:.3f}")
python kendall-tau-four-rankers.pyorder under people: semantic > hybrid > reranked > bm25
bm25 ndcg@10 under people: 0.725
semantic ndcg@10 under people: 0.830
hybrid ndcg@10 under people: 0.812
reranked ndcg@10 under people: 0.798
order under people on the LLM's pairs: semantic > hybrid > reranked > bm25
bm25 ndcg@10 under people on the LLM's pairs: 0.795
semantic ndcg@10 under people on the LLM's pairs: 0.904
hybrid ndcg@10 under people on the LLM's pairs: 0.885
reranked ndcg@10 under people on the LLM's pairs: 0.869
order under the short prompt: reranked > semantic > hybrid > bm25
bm25 ndcg@10 under the short prompt: 0.832
semantic ndcg@10 under the short prompt: 0.903
hybrid ndcg@10 under the short prompt: 0.900
reranked ndcg@10 under the short prompt: 0.906
order under the guidelines prompt: reranked > semantic > hybrid > bm25
bm25 ndcg@10 under the guidelines prompt: 0.805
semantic ndcg@10 under the guidelines prompt: 0.878
hybrid ndcg@10 under the guidelines prompt: 0.876
reranked ndcg@10 under the guidelines prompt: 0.886
rankers in the same place under every set of grades: bm25
bm25, the short prompt minus people on the LLM's pairs: +0.037
semantic, the short prompt minus people on the LLM's pairs: -0.001
hybrid, the short prompt minus people on the LLM's pairs: +0.016
reranked, the short prompt minus people on the LLM's pairs: +0.037
bm25, the guidelines prompt minus people on the LLM's pairs: +0.010
semantic, the guidelines prompt minus people on the LLM's pairs: -0.026
hybrid, the guidelines prompt minus people on the LLM's pairs: -0.008
reranked, the guidelines prompt minus people on the LLM's pairs: +0.017
pairs of rankers: 6
change in tau from one swapped pair: 0.333
swapped under people on the LLM's pairs: none
tau by hand, people against people on the LLM's pairs: 1.000
tau from scipy, people against people on the LLM's pairs: 1.000
swapped under the short prompt: semantic and reranked; hybrid and reranked
tau by hand, people against the short prompt: 0.333
tau from scipy, people against the short prompt: 0.333
swapped under the guidelines prompt: semantic and reranked; hybrid and reranked
tau by hand, people against the guidelines prompt: 0.333
tau from scipy, people against the guidelines prompt: 0.333
As notas humanas dão semantic > hybrid > reranked > bm25. O controle, as notas das pessoas nos pares do LLM, mantém essa ordem, com tau de 1.000, de modo que limitar as notas ao pool não move nenhum ranker. Ele eleva todas as pontuações, a do BM25 de 0.725 para 0.795, porque o top 10 ideal só pode conter produtos do pool.
A ordem sob short é reranked > semantic > hybrid > bm25, e sob guidelines é reranked > semantic > hybrid > bm25. short troca semantic and reranked; hybrid and reranked, e guidelines troca semantic and reranked; hybrid and reranked.
O tau para short é 0.333 calculado à mão e 0.333 pelo SciPy, e para guidelines, 0.333.
Em relação ao controle, as notas do LLM não deslocam os quatro rankers na mesma medida nem na mesma direção. Com short, o BM25 muda em +0.037, a recuperação semântica em -0.001, o híbrido em +0.016 e o híbrido com reranqueamento em +0.037. Com guidelines, as mudanças são +0.010, -0.026, -0.008 e +0.017. O juiz eleva alguns rankers e rebaixa outros, e isso os faz passar uns pelos outros.
Sob short, a recuperação semântica, o híbrido e o híbrido com reranqueamento quase empatam, com 0.903, 0.900 e 0.906. O tau ignora quão distantes dois rankers estão em pontuação, então uma troca entre quase empates conta tanto quanto uma entre o melhor ranker e o pior.
O tau também atribui o mesmo peso a uma troca no topo e a uma na base, uma fraqueza que Yilmaz et al. apontam (Yilmaz et al., 2008). Sobre as execuções do TREC que compararam, Yilmaz et al. observam que os sistemas "têm desempenho muito semelhante. Por isso, a estatística tau de Kendall pode ser afetada por esses sistemas" (Yilmaz et al., 2012).
O ranker que mantém seu lugar sob todos os conjuntos de notas é bm25. As ordenações diferem apenas entre os três rankers que as notas humanas pontuam 0.830, 0.812 e 0.798, e essas diferenças são as que nenhuma comparação planejada estabelece (Execute novamente as comparações planejadas).
Regra prática: Informe o tau sempre junto com a lista de pares trocados, nunca isoladamente. Com poucos rankers, em que uma troca move o tau em 0.333, não o compare com 0.9. Em seguida, teste se os pares trocados diferem, com as comparações planejadas sob cada conjunto de notas.
Refaça as comparações planejadas com notas de LLM
As decisões vêm de veredictos segundo a regra do livro, e não das ordenações que o tau compara. As notas de LLM teriam dado à loja os mesmos veredictos? Espere problemas no topo: Otero et al. constataram que "os julgamentos baseados em LLM são injustos ao ranquear os sistemas de melhor desempenho", com "uma taxa excessivamente alta de falsos positivos em relação a diferenças estatísticas" (Otero et al., 2025).
As três comparações planejadas do capítulo 3 usam um limiar de 0.0167 e intervalos com nível de 0.9833. Refazê-las com as notas humanas e com as notas de cada prompt sobre o conjunto de teste, acrescentando a comparação exploratória do capítulo 3 entre a híbrida reordenada e a recuperação semântica, mostra se a loja teria lançado os mesmos ranqueadores:
1"""Runs chapter 3's three planned comparisons, and the exploratory one, under human grades and under each prompt's grades on the test pool. The prose's point rests on the 'verdicts that differ' lines and the count of disagreeing checks."""2from lib.agreement import PLANNED, PROMPTS, chapter_one_runs, llm_qrels # PLANNED: chapter 3's, each stage against the last3from lib.metrics import evaluate4from lib.significance import compare, verdict5from lib.store import load_products, load_queries, qrels67EXPLORATORY = [("reranked", "semantic")] # chosen after seeing test means8threshold = 0.05 / len(PLANNED) # chapter 3's threshold, so that a verdict means the same either way9print(f"planned comparisons: {len(PLANNED)}\np-value threshold: {threshold:.4f}\ninterval level: {1 - threshold:.4f}")1011runs = chapter_one_runs(load_products(), load_queries("test"))12judgment_sets = {"people": qrels("test"), **{f"{prompt} prompt": llm_qrels(prompt) for prompt in PROMPTS}}13established, disagreements = {}, {judges: 0 for judges in judgment_sets}14for judges, judgments in judgment_sets.items():15 ndcg = {ranker: evaluate(run, judgments)["ndcg@10"] for ranker, run in runs.items()}16 for after, before in PLANNED + EXPLORATORY:17 # the interval's level matches the threshold, so each interval and p-value follow one rule18 result, name = compare(ndcg[after], ndcg[before], confidence=1 - threshold), f"{after} minus {before}, {judges}"19 print(f"\n{name}: {result['mean difference']:.3f}\n{name}, permutation p: {result['permutation p']:.3f}")20 # the exploratory comparison gets no t-test, interval or verdict21 if (after, before) in PLANNED:22 print(f"{name}, t-test p: {result['t-test p']:.3f}\n{name}, interval: {result['ci low']:.3f} to {result['ci high']:.3f}")23 checks = verdict(result, threshold)24 established[(judges, after, before)] = checks["established"]25 disagree = [check for check in ["t-test", "interval"] if not checks[f"{check} agrees"]]26 disagreements[judges] += bool(disagree)27 print(f"{name}, established: {'yes' if checks['established'] else 'no'}\n"28 f"{name}, disagrees with the permutation test: {' and '.join(disagree) or 'neither'}")2930print()31for judges, count in disagreements.items():32 print(f"planned comparisons where the t-test or interval disagrees, {judges}: {count}")33for prompt in PROMPTS:34 differ = [pair for pair in PLANNED if established[(f"{prompt} prompt", *pair)] != established[("people", *pair)]]35 print(f"verdicts that differ from people's, {prompt} prompt: {'; '.join(f'{after} minus {before}' for after, before in differ) or 'none'}")
python planned-comparisons-llm-grades.pyplanned comparisons: 3
p-value threshold: 0.0167
interval level: 0.9833
semantic minus bm25, people: 0.105
semantic minus bm25, people, permutation p: 0.001
semantic minus bm25, people, t-test p: 0.003
semantic minus bm25, people, interval: 0.047 to 0.205
semantic minus bm25, people, established: yes
semantic minus bm25, people, disagrees with the permutation test: neither
hybrid minus semantic, people: -0.018
hybrid minus semantic, people, permutation p: 0.125
hybrid minus semantic, people, t-test p: 0.123
hybrid minus semantic, people, interval: -0.048 to 0.006
hybrid minus semantic, people, established: no
hybrid minus semantic, people, disagrees with the permutation test: neither
reranked minus hybrid, people: -0.014
reranked minus hybrid, people, permutation p: 0.382
reranked minus hybrid, people, t-test p: 0.375
reranked minus hybrid, people, interval: -0.053 to 0.020
reranked minus hybrid, people, established: no
reranked minus hybrid, people, disagrees with the permutation test: neither
reranked minus semantic, people: -0.032
reranked minus semantic, people, permutation p: 0.048
semantic minus bm25, short prompt: 0.070
semantic minus bm25, short prompt, permutation p: 0.010
semantic minus bm25, short prompt, t-test p: 0.014
semantic minus bm25, short prompt, interval: 0.016 to 0.146
semantic minus bm25, short prompt, established: yes
semantic minus bm25, short prompt, disagrees with the permutation test: neither
hybrid minus semantic, short prompt: -0.002
hybrid minus semantic, short prompt, permutation p: 0.851
hybrid minus semantic, short prompt, t-test p: 0.861
hybrid minus semantic, short prompt, interval: -0.029 to 0.036
hybrid minus semantic, short prompt, established: no
hybrid minus semantic, short prompt, disagrees with the permutation test: neither
reranked minus hybrid, short prompt: 0.006
reranked minus hybrid, short prompt, permutation p: 0.727
reranked minus hybrid, short prompt, t-test p: 0.714
reranked minus hybrid, short prompt, interval: -0.029 to 0.042
reranked minus hybrid, short prompt, established: no
reranked minus hybrid, short prompt, disagrees with the permutation test: neither
reranked minus semantic, short prompt: 0.003
reranked minus semantic, short prompt, permutation p: 0.847
semantic minus bm25, guidelines prompt: 0.073
semantic minus bm25, guidelines prompt, permutation p: 0.045
semantic minus bm25, guidelines prompt, t-test p: 0.057
semantic minus bm25, guidelines prompt, interval: 0.006 to 0.183
semantic minus bm25, guidelines prompt, established: no
semantic minus bm25, guidelines prompt, disagrees with the permutation test: interval
hybrid minus semantic, guidelines prompt: -0.001
hybrid minus semantic, guidelines prompt, permutation p: 0.929
hybrid minus semantic, guidelines prompt, t-test p: 0.945
hybrid minus semantic, guidelines prompt, interval: -0.045 to 0.037
hybrid minus semantic, guidelines prompt, established: no
hybrid minus semantic, guidelines prompt, disagrees with the permutation test: neither
reranked minus hybrid, guidelines prompt: 0.010
reranked minus hybrid, guidelines prompt, permutation p: 0.657
reranked minus hybrid, guidelines prompt, t-test p: 0.609
reranked minus hybrid, guidelines prompt, interval: -0.024 to 0.076
reranked minus hybrid, guidelines prompt, established: no
reranked minus hybrid, guidelines prompt, disagrees with the permutation test: neither
reranked minus semantic, guidelines prompt: 0.009
reranked minus semantic, guidelines prompt, permutation p: 0.581
planned comparisons where the t-test or interval disagrees, people: 0
planned comparisons where the t-test or interval disagrees, short prompt: 0
planned comparisons where the t-test or interval disagrees, guidelines prompt: 1
verdicts that differ from people's, short prompt: none
verdicts that differ from people's, guidelines prompt: semantic minus bm25
| Medida | Notas | Semântica menos BM25 | Híbrida menos semântica | Reordenada menos híbrida |
|---|---|---|---|---|
| Diferença média | Humanas | 0.105 | -0.018 | -0.014 |
| Diferença média | short |
0.070 | -0.002 | 0.006 |
| Diferença média | guidelines |
0.073 | -0.001 | 0.010 |
| Intervalo | Humanas | 0.047 to 0.205 | -0.048 to 0.006 | -0.053 to 0.020 |
| Intervalo | short |
0.016 to 0.146 | -0.029 to 0.036 | -0.029 to 0.042 |
| Intervalo | guidelines |
0.006 to 0.183 | -0.045 to 0.037 | -0.024 to 0.076 |
| p de permutação | Humanas | 0.001 | 0.125 | 0.382 |
| p de permutação | short |
0.010 | 0.851 | 0.727 |
| p de permutação | guidelines |
0.045 | 0.929 | 0.657 |
| p do teste t | Humanas | 0.003 | 0.123 | 0.375 |
| p do teste t | short |
0.014 | 0.861 | 0.714 |
| p do teste t | guidelines |
0.057 | 0.945 | 0.609 |
| Estabelecido | Humanas | yes | no | no |
| Estabelecido | short |
yes | no | no |
| Estabelecido | guidelines |
no | no | no |
Se o único resultado estabelecido da loja sobrevive às notas de LLM depende do prompt. Com guidelines, o veredicto que muda é semantic minus bm25, justamente o único resultado que o capítulo 3 estabeleceu. Com short, os veredictos que diferem dos humanos são none.
O teste t ou o intervalo discorda do teste de permutação em 0 comparações planejadas com notas humanas, 0 com short e 1 com guidelines. Para a recuperação semântica menos BM25 com guidelines, a verificação que discorda é a interval.
A comparação da ordem dos ranqueadores encontrou dois pares trocados. Um, a híbrida reordenada contra a híbrida, é uma comparação planejada, e a tabela mostra que ela não é estabelecida com nenhum conjunto de notas. O outro, a híbrida reordenada contra a recuperação semântica, é a comparação exploratória. Com notas humanas, a híbrida reordenada menos a recuperação semântica é -0.032 (p de permutação 0.048). Com notas de LLM, é 0.003 com short e 0.009 com guidelines. O capítulo 3 a escolheu depois de ver as médias dos testes, por isso ela não estabelece nada em nenhum dos sentidos.
Juízes LLM também podem favorecer ranqueadores que usam LLMs: Balog et al. relatam "a primeira evidência empírica de juízes LLM exibindo viés significativo em favor de ranqueadores baseados em LLM" (Balog et al., 2025). Os ranqueadores do capítulo 1 não usam LLM, então este capítulo não consegue medir esse viés. O livro avalia os ranqueadores baseados em LLM do capítulo 8 e do capítulo 9 com notas humanas.
Regra prática: Nunca publique uma mudança apenas com base em um veredicto obtido com notas de LLM. Use as notas de LLM para decidir quais candidatos valem a pena ser julgados, e decida com base nas notas humanas. Quando dois prompts dão veredictos diferentes, o LLM não consegue decidir a comparação, e as pessoas é que devem decidir.
Corrija escores de LLM com uma amostra humana
Um caminho intermediário usa os dois tipos de notas: avalie cada consulta com o LLM, peça a pessoas que julguem uma amostra aleatória de consultas e use a amostra para corrigir o erro do LLM. Inferência assistida por predições corrige rigorosamente as predições de um modelo com uma amostra humana, com intervalos de confiança que valem "sem fazer nenhuma suposição sobre o algoritmo de aprendizado de máquina que fornece as predições" (Angelopoulos et al., 2023). Uma forma simples da ideia, para uma média, toma a média do LLM sobre todas as consultas e soma a média da amostra humana de humano menos LLM:
corrected = mean over all queries of the LLM score + mean over the human sample of (human score − LLM score)
Na avaliação de busca, Oosterhuis et al. constroem intervalos para as métricas dessa maneira, alertando que "anotações de relevância geradas não estão imunes a erros (sistemáticos)" (Oosterhuis et al., 2024). Takehi et al. deixam o LLM escolher quais pares as pessoas julgam dentro de um orçamento e, em seguida, calibram o modelo com eles (Takehi et al., 2025).
Suponha que a loja possa pagar por julgamentos humanos de 10 of 30 consultas de teste. O exemplo sorteia 2,000 conjuntos aleatórios desse tamanho e, para cada um, corrige a estimativa do LLM, em cada prompt, de duas diferenças entre os rankers do capítulo 1: recuperação semântica menos BM25, e híbrida menos recuperação semântica. Compara cada estimativa corrigida com o que a amostra humana indica por si só. Dispersão é o desvio padrão de uma estimativa ao longo dos sorteios. A simulação não escolhe nada:
1"""Draws random sets of human-judged test queries and corrects the LLM's estimate of two ranker gaps with each set. The prose's point rests on the 'smaller than the human sample's' lines, read with the correlation lines beside them."""2import numpy as np3import pandas as pd45from lib.agreement import PROMPTS, chapter_one_runs, llm_qrels6from lib.metrics import evaluate7from lib.store import load_products, load_queries, qrels89JUDGED, DRAWS = 10, 2000 # test queries people judge in each draw, and the number of draws10runs = chapter_one_runs(load_products(), load_queries("test"))11people = pd.DataFrame({ranker: evaluate(run, qrels("test"))["ndcg@10"] for ranker, run in runs.items()})12rng = np.random.default_rng(2026)13draws = [rng.choice(people.index, JUDGED, replace=False) for _ in range(DRAWS)] # which queries people judge14print(f"queries judged by people in each draw: {JUDGED} of {len(people)}\ndraws: {DRAWS:,}")1516for after, before in [("semantic", "bm25"), ("hybrid", "semantic")]:17 gap_people = people[after] - people[before] # per-query gaps under people's grades18 print(f"\n{after} minus {before}, people, all queries: {gap_people.mean():.3f}")19 # the spread: the standard deviation over the draws, with numpy's default divisor20 alone = np.std([gap_people[judged].mean() for judged in draws]) # the human sample used alone21 print(f"{after} minus {before}, human sample alone, spread: {alone:.3f}")22 for prompt in PROMPTS:23 llm = {ranker: evaluate(run, llm_qrels(prompt))["ndcg@10"] for ranker, run in runs.items()}24 gap_llm, name = llm[after] - llm[before], f"{after} minus {before}, {prompt} prompt"25 # the LLM's mean over all queries, plus the human sample's average of human minus LLM26 corrected = [gap_llm.mean() + (gap_people[judged] - gap_llm[judged]).mean() for judged in draws]27 print(f"{name}, LLM only: {gap_llm.mean():.3f}")28 print(f"{name}, corrected, mean over draws: {np.mean(corrected):.3f}")29 print(f"{name}, corrected, spread: {np.std(corrected):.3f}")30 print(f"{name}, corrected spread smaller than the human sample's: {'yes' if np.std(corrected) < alone else 'no'}")31 # corrcoef returns a 2×2 matrix; [0, 1] is the correlation between the two lists32 print(f"{name}, correlation of per-query gaps with people's: {np.corrcoef(gap_llm, gap_people)[0, 1]:.3f}")
python correct-llm-scores-with-humans.pyqueries judged by people in each draw: 10 of 30
draws: 2,000
semantic minus bm25, people, all queries: 0.105
semantic minus bm25, human sample alone, spread: 0.045
semantic minus bm25, short prompt, LLM only: 0.070
semantic minus bm25, short prompt, corrected, mean over draws: 0.104
semantic minus bm25, short prompt, corrected, spread: 0.036
semantic minus bm25, short prompt, corrected spread smaller than the human sample's: yes
semantic minus bm25, short prompt, correlation of per-query gaps with people's: 0.641
semantic minus bm25, guidelines prompt, LLM only: 0.073
semantic minus bm25, guidelines prompt, corrected, mean over draws: 0.104
semantic minus bm25, guidelines prompt, corrected, spread: 0.039
semantic minus bm25, guidelines prompt, corrected spread smaller than the human sample's: yes
semantic minus bm25, guidelines prompt, correlation of per-query gaps with people's: 0.692
hybrid minus semantic, people, all queries: -0.018
hybrid minus semantic, human sample alone, spread: 0.016
hybrid minus semantic, short prompt, LLM only: -0.002
hybrid minus semantic, short prompt, corrected, mean over draws: -0.017
hybrid minus semantic, short prompt, corrected, spread: 0.023
hybrid minus semantic, short prompt, corrected spread smaller than the human sample's: no
hybrid minus semantic, short prompt, correlation of per-query gaps with people's: 0.168
hybrid minus semantic, guidelines prompt, LLM only: -0.001
hybrid minus semantic, guidelines prompt, corrected, mean over draws: -0.017
hybrid minus semantic, guidelines prompt, corrected, spread: 0.024
hybrid minus semantic, guidelines prompt, corrected spread smaller than the human sample's: no
hybrid minus semantic, guidelines prompt, correlation of per-query gaps with people's: 0.342
Para recuperação semântica menos BM25, o LLM sozinho estima 0.070 com short, contra 0.105 com notas humanas. Corrigida, a estimativa tem média 0.104 ao longo dos sorteios, então a correção remove o viés do LLM.
Sua dispersão é 0.036, contra 0.045 apenas para a amostra humana. A dispersão corrigida é menor que a da amostra humana? yes com short e yes com guidelines. As notas do LLM para as demais consultas acrescentam informação, porque suas diferenças por consulta se correlacionam com as humanas em 0.641.
Para a recuperação híbrida menos a semântica, a dispersão corrigida é 0.023 com short e 0.024 com guidelines, contra 0.016 apenas para a amostra humana. Ela é menor que a da amostra humana? no com short e no com guidelines. As diferenças por consulta se correlacionam em 0.168 sob short.
A correção ajusta o nível de um escore, mas só reduz a incerteza onde os escores por consulta do LLM acompanham os das pessoas, e aqui eles as acompanham menos ainda, na menor das duas diferenças, aquela entre os rankers mais próximos.
Regra prática: sempre que você reportar um escore a partir de notas do LLM, peça a pessoas que julguem uma amostra aleatória de consultas e reporte a estimativa corrigida. Nessa amostra, verifique o quanto as diferenças por consulta do LLM se correlacionam com as humanas. Quando a correlação for fraca, use o orçamento para julgar mais consultas.
O que dá errado em produção
O juiz muda sem aviso. Uma loja que julga com um LLM o executa repetidas vezes, então uma versão diferente do modelo, uma quantização diferente (a precisão com que os pesos do modelo são armazenados) ou um prompt reescrito é outro juiz. O manifest.json da gravação fixa o digest do modelo e os dois prompts palavra por palavra. O esquema de respostas e o tamanho do contexto ficam em recordings/llm.py e recordings/llm_judgments.py, então registre também esses itens. Refaça a verificação de concordância sobre a mesma amostra humana sempre que qualquer um deles mudar.
Sistemas ajustados ao juiz obtêm boa pontuação nele. Clarke e Dietz construíram uma execução que explora um juiz LLM, e ela ficou "significativamente mais bem posicionada na avaliação automática (5º) do que na avaliação manual (28º)" (Clarke and Dietz, 2024). Um ranqueador ajustado com notas de LLM, ou construído sobre o mesmo LLM, precisa ter sua pontuação principal medida com notas humanas.
O texto do produto pode direcionar o juiz. Alaofi et al. constataram que juízes LLM podem ser induzidos ao erro por palavras da consulta plantadas em um texto irrelevante, e por instruções escritas nele (Alaofi et al., 2024). Um vendedor pode escrever uma descrição que fala diretamente ao juiz. Mantenha uma amostra humana em toda avaliação, para que um juiz desviado apareça como uma queda na concordância.
Calibrar no teste é ajustar no teste. Reescrever um prompt até que ele coincida com as notas humanas nas consultas de teste torna a concordância ali sem sentido. Escolha os prompts nas consultas de treino e reporte a concordância no teste.
As notas humanas também não são a verdade. Na trilha TREC Podcast, onde um LLM e um avaliador da TREC mais discordaram, Mansour et al. constataram que especialistas que reavaliavam os pares com mais frequência davam razão ao LLM (Mansour et al., 2026). Trate as notas humanas como a referência que você escolheu e leia as discordâncias antes de culpar qualquer um dos lados.
Regra prática: Fixe o juiz, mantenha uma amostra humana em toda avaliação, refaça a verificação de concordância sempre que algo mudar e nunca avalie um ranqueador com o juiz no qual você o ajustou.
Decisões tomadas neste capítulo
O repositório mantém estas decisões, a menos que um capítulo posterior apresente um motivo para revê-las.
-
Notas humanas para toda pontuação principal. As notas do LLM são um instrumento de diagnóstico: preenchem lacunas, selecionam candidatos e verificam vereditos. Os rankers baseados em LLM dos capítulos 8 e 9 são avaliados com notas humanas.
-
Todo achado sobre o juiz indica o seu conjunto. O kappa e o kappa ponderado linear, com a concordância observada ao lado, os erros distantes (previsões muito afastadas da nota humana), e a distribuição dos rótulos são medidos pelos pares de treino julgados por pessoas, e também são reportados para os pares julgados do conjunto de teste. A direção e o maior erro são lidos em cada conjunto, e somente os 10 primeiros de cada ranker dizem respeito às pontuações dos rankers.
-
Dois prompts, registrados palavra por palavra. O conjunto de treino não consegue distingui-los, por isso o repositório guarda os dois prompts e só confia numa conclusão baseada em notas do LLM quando os dois prompts a sustentam.
-
Pares não julgados preenchidos com notas do LLM como diagnóstico, reportados ao lado da pontuação apenas com notas humanas. Nas consultas de teste, o preenchimento não altera a posição de nenhum ranker nem nenhum veredito.
-
Compare pontuações apenas sob as mesmas notas. No mesmo conjunto, as notas do LLM não alteram o nDCG@10 de todos os rankers na mesma medida, nem na mesma direção, portanto uma pontuação sob notas do LLM nunca é comparada com uma sob notas humanas.
-
Tau com seus pares trocados, depois as comparações planejadas no limiar do capítulo 3. Com quatro rankers, o tau é grosseiro, e os vereditos é que decidem.
-
Uma pontuação baseada em notas do LLM vem acompanhada de uma amostra humana de consultas que a corrige, e da correlação que indica se as notas do LLM reduziram a incerteza.
-
O que o capítulo mostrou: um juiz LLM pode preencher lacunas e selecionar candidatos, mas suas notas movem os rankers de forma desigual, por isso um veredito que importa ainda precisa de notas humanas.
Este capítulo, nesta edição
Edição 2026.11.10Exemplos aprovados em 19 de nov de 202611 de 11 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.10.