사람과 LLM의 판정

읽는 데 약 61분분 걸린다, 13절에 11개 예제이(가) 있음.

2026.11.10판 예제 통과 2026년 11월 19 132개 예제 중 132개 통과 변경 사항

AI로 번역함. 영어 원문을 사람이 검증함. 우리가 책을 만드는 방식

영어판 2026.11.10판을 번역한 것이다. 원문 읽기

이 장을 마치면 판정 지침을 작성하고, 카파와 가중 카파로 두 판정자가 얼마나 일치하는지 측정하고, 혼동 행렬에서 LLM 판정자의 오류를 읽고, LLM의 판정이 사람의 판정을 대신할 수 있는 곳과 그럴 수 없는 곳을 가려낼 수 있다.

이 책의 모든 점수는 판정에 기댄다. 사람들이 상점의 검색창에 입력된 질의와 그 질의에 반환된 상품을 나란히 읽고 그 쌍에 등급을 매겼다. 이 판정이 WANDS의 레이블이며, 각 레이블은 훈련받은 주석자 최대 세 명의 다수결로 정해진다. 이 레이블에는 빈틈이 있다. 테스트 질의에서 BM25의 상위 10개에는 아무도 판정하지 않은 상품이 22개 들어 있다(판정되지 않은 상품 세기). 판정에는 사람의 시간도 든다. WANDS 주석자들 사이의 일치도는 넉 달에 걸친 보정 동안 높아졌다(판정자들이 불일치하리라고 예상하라). LLM은 제시된 어떤 질의와 상품에도 등급을 매길 수 있다. 상점이 LLM에게 판정을 맡기기 전에, LLM이 상점의 판정자들과 얼마나 자주 일치하는지, 그리고 LLM의 등급이 랭커에 대해 같은 결정으로 이어지는지 알아야 한다.

LLM의 등급은 녹화본에서 나온다. recordings/llm_judgments.py이 오픈 모델 gemma4:12b-it-q4_K_M을 로컬에서 온도 0과 고정된 시드로 한 번 실행하고 그 답을 저장했으므로, 예제는 모델을 호출하지 않고 lib.recorded.llm_judgments()로 그 답을 읽는다. 이 모델을 고른 이유는 오픈 모델로서 Apache 2.0 라이선스를 따르고 로컬에서 실행되어 누구나 녹화를 다시 돌릴 수 있기 때문이다. JSON 스키마가 각 답을 세 가지 레이블 중 하나로 제한한다. 녹화에서는 두 가지 프롬프트 short와 guidelines로 각 쌍에 등급을 매겼고(판정 지침 작성하기), 쌍은 두 집합에서 가져왔다. 이 장에서는 이 집합을 풀이라고 부른다.

랭커 사이의 우열을 가르는 점수는 계속 사람의 등급에 둔다. 이 장에서 테스트 질의에 대해 계획한 비교는 3장의 세 가지이며, 짝지은 순열 검정에서 3장의 임계값 0.0167을 적용해 각 프롬프트의 LLM 등급으로 다시 채점한 것이다. 비교 대상은 BM25에 대한 의미 기반 검색, 의미 기반 검색에 대한 하이브리드, 하이브리드에 대한 재순위화된 하이브리드이다.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

Write judging guidelines

마지막으로 변경된 판: 2026.11.10판

This chapter calls whoever gives a judgment, person or LLM, a judge, and a grade is the number that stands for it. Chapter 1 defines a judgment as a person's label; this chapter widens it to an LLM's label too. Judgments depend on the instructions behind them. Judging guidelines say what each grade means, how to choose between grades, and what to do with the cases that fall between them.

WANDS published the guidelines its annotators used: eight pages, under the MIT licence (annotation guidelines). For each pair they list what a judge sees: the query, and the product's ID, name, image and web page. They define the three grades and add two notes, one asking the judge to understand the query first: "Strongly recommend google it first", and one saying to ignore misspellings and annotate the pair as written. Then they teach by example, giving a query, a product and a reason for each grade: a wire basket without dividers is partial for wire basket with dividers, one of the store's own train queries, and a salon anti-fatigue mat is irrelevant to salon chair, because the customer looks for a salon chair, not a mat. Guidelines also change as judges use them. WANDS's authors say their annotators' agreement rose over four months, and among the reasons they give are a daily routine for discussing conflicting annotations, and guidelines refined with the annotators' input (Chen et al., 2022, section 5). One web search engine's rater guidelines do the same, at 182 pages in their version of September 11, 2025 (Search Quality Rater Guidelines).

The recording's two prompts are judging guidelines for the LLM. short is WANDS's three definitions alone; guidelines keeps them and adds five rules, so print it as the recording sent it:

The guidelines prompt is the longer of the two, at 206 words against 59 for short. Its first two rules spell out WANDS's definition of partial: find the entity, then the modifiers. The accessory rule settles a case that WANDS's own labels split: for clear shower curtain, WANDS lists one set of shower curtain hooks twice, once as partial and once as irrelevant (Expect judges to disagree). The misspelling rule follows WANDS's note. The last rule has no counterpart in WANDS's guidelines, because the store's data holds no images, so the recording shows the LLM text only. Neither prompt has worked examples, which WANDS's guidelines rely on.

Working rule: Write guidelines as definitions, a procedure, a worked example with a reason for each grade, and a rule for each case your judges have disagreed on. Log disagreements and revise the guidelines when one kind keeps coming back. Give an LLM judge the same guidelines as people, plus a rule for what it can't see, and then measure what it does, because a rule you write isn't a rule the judge follows.

카파로 우연을 넘어서는 일치도 측정하기

마지막으로 변경된 판: 2026.11.10판

두 번째 평가자를 신뢰하기 전에, 그 평가자가 첫 번째 평가자와 얼마나 자주 일치하는지 측정한다. 두 평가자가 같은 등급을 준 쌍의 비율인 관측 일치도는 가장 눈에 띄는 수치이지만, 실제보다 좋게 보이게 한다. 서로 독립적으로 추측하는 두 평가자도 일부 쌍에서는 우연히 일치하며, 두 평가자가 모두 하나의 레이블을 자주 사용하면 더 많은 쌍에서 일치한다. **코언의 카파(Cohen's kappa)**는 각 평가자가 자신의 레이블 비율은 유지하되 상대와 독립적으로 레이블을 고른다고 할 때 기대되는 일치도와 관측 일치도를 비교하여, 관측 일치도를 우연에 대해 보정한다. 카파가 1이면 완전히 일치한다는 뜻이고, 0이면 "우연으로 기대되는 수준을 넘는 일치가 없다"는 뜻이다(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)

일치도를 측정하기 위한 **학습 풀(train pool)**은 학습 질의에 대해 사람이 판정한 쌍을 레이블별로 고르게 뽑아 담고 있다. 질의마다 레이블당 최대 4개이며, 모두 합쳐 550개 쌍이다. **테스트 풀(test pool)**은 상점의 랭커를 채점하기 위해 LLM이 등급을 매길 쌍을 담고 있다. 각 테스트 질의에 대해 1장의 네 가지 랭커가 상위 10위 안에 올린 모든 상품이 대상이며, 사람이 판정했는지는 따지지 않고 590개 쌍이다. 네 랭커는 BM25, Snowflake/snowflake-arctic-embed-m-v1.5의 임베딩을 사용하는 의미 기반 검색, 둘을 섞은 하이브리드, 그리고 하이브리드를 크로스 인코더 Alibaba-NLP/gte-reranker-modernbert-base로 재순위화한 것이다. LLM 평가자에 대한 각 측정값은 그것을 측정한 풀에서만 성립하므로, 이 장에서는 매번 풀의 이름을 밝힌다.

문제는 녹화본의 LLM이 얼마나 자주 상점의 평가자들과 같은 방식으로 쌍에 등급을 매기는가이다. short 프롬프트(WANDS의 세 가지 정의만 담은 프롬프트)를 사용한 학습 풀이 이에 답한다. 직접 만든 3×3 개수 표로 카파를 구하고, scikit-learn의 cohen_kappa_score로 결과를 확인한다.

kappa-by-hand.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.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."""import numpy as npfrom sklearn.metrics import cohen_kappa_scorefrom lib.agreement import graded_pairspairs = graded_pairs("train")                     # up to 4 human-judged pairs per label per train query# the grades are nullable integers; plain ones compare and count the way the formulas below expecthuman, llm = pairs["human"].astype(int), pairs["short"].astype(int)grades = [2, 1, 0]                                # exact, partial, irrelevantcounts = np.array([[((human == row) & (llm == column)).sum() for column in grades] for row in grades])print("pairs:", counts.sum())print("rows are the human grades 2, 1, 0 and columns the LLM's, short prompt")print(counts)observed = np.trace(counts) / counts.sum()                          # the share of pairs on the diagonalhuman_share, llm_share = counts.sum(axis=1) / counts.sum(), counts.sum(axis=0) / counts.sum()expected = (human_share * llm_share).sum()                          # agreement if the two judged independentlykappa = (observed - expected) / (1 - expected)print(f"observed agreement, short prompt: {observed:.3f}")print(f"agreement expected by chance, short prompt: {expected:.3f}")print(f"kappa by hand, short prompt: {kappa:.3f}")print(f"kappa from scikit-learn, short prompt: {cohen_kappa_score(human, llm):.3f}")other = pairs["guidelines"].astype(int)print(f"observed agreement, guidelines prompt: {(human == other).mean():.3f}")print(f"kappa from scikit-learn, guidelines prompt: {cohen_kappa_score(human, other):.3f}")
출력python kappa-by-hand.py
pairs: 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

LLM과 상점의 평가자들은 학습 쌍의 0.624에서 같은 등급을 주었으며, 우연만으로는 0.337가 나올 것으로 기대된다. 카파는 관측 일치도에서 이 우연 비율을 빼고, 우연을 넘어 남은 여지로 나눈다. 그 결과 short의 카파는 0.432이며, 이는 scikit-learn의 0.432와 같다.

guidelines는 short보다 평가자들과 조금 더 자주 일치하여, 쌍의 0.633에서 일치하고 카파는 0.454이다.

이 정도면 좋은 것일까? 카파를 "보통"이나 "상당한" 수준이라 부르는 척도는 특정 분야의 관례일 뿐이다. Artstein과 Poesio의 조사는 특정 목적에 맞는 적절한 일치도 수준을 고르는 일이 "여전히 일종의 비법(black art)에 불과하다"고 밝힌다(Artstein and Poesio, 2008).

공개된 수치는 기준선이 아니라 맥락을 제공한다. WANDS의 주석자들은 처음 두 달에는 카파 0.467로, 넷째 달에는 0.826으로 서로 일치했다(Chen et al., 2022, Table 2).

Text REtrieval Conference(TREC)의 공동 평가에서 층화 추출한 쌍의 표본을 두고, Thomas 등은 평가자에 대한 GPT-4의 카파가 프롬프트에 따라 낮게는 0.20에서 높게는 0.64까지 나온다는 것을 발견했다. 훈련된 사람 평가자 두 집단은 TREC ad hoc 문서를 두 번째로 판정했을 때 0.52에 도달했다(Cormack et al., 1998, as reported by Thomas et al., 2024). 각 수치는 서로 다른 표본에서 나온 것이며, 카파는 표본의 레이블 구성에 따라 달라진다.

작업 규칙: 카파를 보고하되 관측 일치도를 함께 적고, 관측 일치도만 단독으로 보고하지 않는다. 학습 질의에 대해 사람이 판정한 쌍에서 측정하고, 사용하는 임계값에는 경험칙이라는 점을 밝힌다. 평가자가 둘보다 많거나 레이블이 누락된 경우에는 크리펜도르프의 알파를 사용한다. 이는 관측 불일치와 우연에 의한 불일치를 비교하며, 관측자 수에 관계없이 불완전한 데이터도 다룰 수 있다(Krippendorff, 2011).

가중 카파로 근접 오답에 부분 점수를 준다

마지막으로 변경된 판: 2026.11.8판

카파는 모든 불일치를 똑같이 센다. 그러나 상점의 등급은 순서가 있어서 정확이 부분보다 높고 부분이 무관보다 높으며, 정확한 상품을 부분으로 판정하는 것은 무관으로 판정하는 것보다 작은 오류다. nDCG@10(Score one ranking)에서도 이 오류는 이득을 절반만 잃게 한다. 두 등급이 아니라 한 등급만큼의 차이이기 때문이다. 가중 카파는 각 불일치에 등급 간 거리에 따른 가중치를 주고, 가중된 불일치를 우연히 기대되는 가중된 불일치와 비교한다(Artstein and Poesio, 2008, section 2.6). 선형 가중치에서는 한 등급 차이의 불일치가 0.5, 두 등급 차이의 불일치가 1의 가중치를 갖는다.

weighted kappa = 1 - (sum of weight × observed count) / (sum of weight × count expected by chance)

모든 불일치의 가중치를 1로 두면 이 식은 일반 카파가 된다. scikit-learn의 cohen_kappa_score는 세 종류를 모두 이 방식으로 계산한다. 기본값은 가중치 1이고, weights="linear"는 등급 간 거리를, weights="quadratic"는 그 거리의 제곱을 가중치로 쓴다(scikit-learn source). 가중치의 크기를 일정한 비율로 바꿔도 결과는 달라지지 않는다.

예제는 두 프롬프트 모두에 대해, Measure agreement beyond chance에서 쓴 균등하게 추출한 훈련 쌍으로 선형 가중치를 직접 만들고, 각 결과를 scikit-learn의 결과와 대조한다.

weighted-kappa-by-hand.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.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."""import numpy as npfrom sklearn.metrics import cohen_kappa_score, confusion_matrixfrom lib.agreement import PROMPTS, graded_pairspairs = graded_pairs("train")                     # up to 4 human-judged pairs per label per train querygrades = [2, 1, 0]                                # exact, partial, irrelevantcost = np.abs(np.subtract.outer(grades, grades)) / 2    # 0 on the diagonal, 0.5 one grade apart, 1 two apartprint("disagreement weights, rows and columns 2, 1, 0")print(cost)for prompt in PROMPTS:    human, llm = pairs["human"].astype(int), pairs[prompt].astype(int)    # labels fixes the rows and columns to 2, 1, 0 in that order, not the order the grades first appear    counts = confusion_matrix(human, llm, labels=grades)                       # rows human, columns LLM    expected = np.outer(counts.sum(axis=1), counts.sum(axis=0)) / counts.sum()   # counts if independent    weighted = 1 - (cost * counts).sum() / (cost * expected).sum()    near = cost == 0.5                                                         # cells one grade apart    print()    # row 0 is exact and column 2 is irrelevant, so these two corners are the far misses    print(f"pairs two grades apart, {prompt} prompt: {counts[0, 2] + counts[2, 0]}")    print(f"disagreements one grade apart, share, {prompt} prompt: {counts[near].sum() / counts[cost > 0].sum():.3f}")    print(f"one grade apart, share expected by chance, {prompt} prompt: {expected[near].sum() / expected[cost > 0].sum():.3f}")    print(f"kappa, {prompt} prompt: {cohen_kappa_score(human, llm):.3f}")    print(f"linear weighted kappa by hand, {prompt} prompt: {weighted:.3f}")    print(f"linear weighted kappa from scikit-learn, {prompt} prompt: "          f"{cohen_kappa_score(human, llm, weights='linear'):.3f}")
출력python weighted-kappa-by-hand.py
disagreement 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

가중치를 적용하면 short의 카파는 0.432에서 0.523로, guidelines의 카파는 0.454에서 0.531로 올라가며, 두 값 모두 scikit-learn의 값과 일치한다. 불일치가 우연으로 기대되는 것보다 더 자주 한 등급 차이에 놓이기 때문에 값이 올라간다. short는 불일치 중 한 등급 차이의 비율이 0.942인 데 반해 우연으로 기대되는 비율은 0.742이고, guidelines는 0.851인 데 반해 0.664이다.

두 프롬프트는 큰 오답, 곧 두 등급 차이가 나는 쌍의 수에서도 다르다. short는 12, guidelines는 30이다. 어느 한 프롬프트의 일치도가 더 높은지는 구간으로 답해야 할 문제다.

작업 규칙: 순서가 있는 등급에는 일반 카파와 함께 선형 가중 카파를 보고하고, 큰 오답은 따로 센다. 각 불일치에는 그로 인한 이득 차이만큼 가중치를 준다. 이 책의 선형 이득에서는 선형 가중치가 이에 해당한다. 이득이 0, 1, 3인 지수 이득(Choose a metric)에서는 차이가 1, 2, 3이 되는데, scikit-learn의 두 옵션 어느 것도 이를 주지 않으므로, 예제가 선형 행렬을 만든 방식대로 그 행렬을 직접 만든다.

레이블 구성에 비추어 카파를 읽기

마지막으로 변경된 판: 2026.11.8판

카파의 보정은 각 평가자가 각 레이블을 얼마나 자주 쓰는지에 따라 달라진다. 따라서 같은 평가자라도 레이블 구성이 다른 표본에서는 다른 카파를 얻는다. 한 레이블이 우세하면 관찰된 일치도는 높아도 카파는 낮게 유지될 수 있다. Artstein과 Poesio는 이를 유병률 문제(prevalence problem)라고 부른다. "코더들이 항목의 높은 비율에서 일치하고 그 주석이 실제로 높은 수준으로 정확한데도, 신뢰도 계수는 여전히 낮을 수 있다"(Artstein and Poesio, 2008).

기록은 train 풀을 균등하게 추출했다. train 질의마다 레이블별로 최대 4개의 쌍을 뽑았으므로, 이 풀에는 저장소의 판정보다 exact 쌍과 irrelevant 쌍이 더 많다. 이것이 카파에 어떤 영향을 주는지 보려면, 풀의 레이블 구성이 모든 train 질의의 판정이 가진 구성과 같아지도록 각 쌍에 가중치를 주고 다시 측정한다.

kappa-under-two-label-mixes.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.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."""import numpy as npfrom sklearn.metrics import cohen_kappa_scorefrom lib.agreement import LABELS, PROMPTS, graded_pairsfrom lib.store import load_labels, load_queriespairs = graded_pairs("train")                     # drawn evenly: up to 4 pairs per label per train querydrawn = pairs["human"].value_counts(normalize=True)labels = load_labels()# every judged label for the train queries, not only the pairs that were drawnnatural = labels[labels["query_id"].isin(load_queries("train").index)]["grade"].value_counts(normalize=True)top = graded_pairs("test")["human"].dropna().value_counts(normalize=True)    # the rankers' top 10s, judged pairsfor grade, label in LABELS.items():    print(f"{label} share, as drawn: {drawn[grade]:.3f}")    print(f"{label} share, in the train judgments: {natural[grade]:.3f}")    print(f"{label} share, judged test-pool pairs: {top[grade]:.3f}")# each pair counts for its label's share in the judgments divided by its share as drawnweight = pairs["human"].map(natural / drawn).astype(float)            # count each pair as if drawn in that mixkappas = {}for prompt in PROMPTS:    human, llm = pairs["human"].astype(int), pairs[prompt].astype(int)    print()    print(f"observed agreement, {prompt} prompt, as drawn: {(human == llm).mean():.3f}")    print(f"kappa, {prompt} prompt, as drawn: {cohen_kappa_score(human, llm):.3f}")    print(f"observed agreement, {prompt} prompt, train judgments' mix: {np.average(human == llm, weights=weight):.3f}")    # sample_weight counts each pair that many times; it is not the linear weights of the last section    kappas[prompt] = cohen_kappa_score(human, llm), cohen_kappa_score(human, llm, sample_weight=weight)    print(f"kappa, {prompt} prompt, train judgments' mix: {kappas[prompt][1]:.3f}")print()for position, mix in enumerate(["as drawn", "train judgments' mix"]):    # on a tie, max returns the first prompt, short    print(f"higher kappa, {mix}: {max(PROMPTS, key=lambda prompt: kappas[prompt][position])}")
출력python kappa-under-two-label-mixes.py
exact 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

partial은 추출된 그대로의 풀에서 0.364를 차지하지만 train 판정에서는 0.613를 차지한다. 그래서 가중치를 다시 주면 partial 쌍은 더 무겁게, exact 쌍과 irrelevant 쌍은 더 가볍게 계산된다.

판정의 구성에서 short의 관찰된 일치도는 0.624에서 0.635로, 카파는 0.432에서 0.370로 바뀐다. guidelines의 경우 관찰된 일치도는 0.633에서 0.573로, 카파는 0.454에서 0.345으로 바뀐다.

카파가 더 높은 프롬프트는 추출된 그대로에서는 guidelines이고, 판정의 구성에서는 short이다.

공개된 수치에는 그 수치의 구성이 따라다닌다. 우리가 찾은 WANDS 대상 LLM 판정자 연구는 하나뿐이며, 이 연구는 질의-상품 쌍 5,000개를 세 레이블에 걸쳐 균등하게 추출했다. 이 연구가 보고하는 정확도는, 각각의 최적 설정에서 쌍마다 16개의 풀이 예시를 검색해 쓴 경우, 700억 개 매개변수를 가진 최고의 오픈 모델이 0.726이고 최고의 폐쇄 모델이 0.837이다(Sachdev et al., 2025, Table 3). 저장소의 프롬프트에는 풀이 예시가 없다. 이 정확도는 train 풀의 경우와 마찬가지로 균형 잡힌 표본에서 관찰된 일치도이므로, 두 수치 모두 저장소 판정의 레이블 구성으로는 옮겨 적용할 수 없다.

저장소가 LLM에 판정을 맡기게 될 쌍은 랭커가 상위 10개에 올린 상품, 즉 test 풀이다. 판정된 쌍 가운데 exact는 0.543, partial은 0.427, irrelevant는 0.030이다. 이것은 세 번째 구성이며 쌍의 성격도 다른데, 이는 LLM 오류의 방향 읽기에서 측정한다.

작업 규칙: 모든 카파와 함께 레이블 구성을 보고하고, 구성이 다른 표본에서 나온 카파끼리는 직접 구한 것이든 공개된 것이든 비교하지 않는다. 일치도 표본은 판정자를 쓸 방식대로 추출하기를 권한다. 판정자가 랭커의 상위 10개를 채점할 것이라면, train 질의의 상위 10개에서 쌍을 표본으로 뽑는다.

LLM 오류의 방향 읽기

마지막으로 변경된 판: 2026.11.10판

카파는 두 판정자가 얼마나 일치하는지를 말해 줄 뿐, 어떻게 다른지는 말해 주지 않는다. 두 판정자가 어떻게 다른지는 혼동 행렬(confusion matrix)이 보여 준다. 혼동 행렬은 개수를 담은 표로, 행은 스토어의 등급마다, 열은 LLM의 등급마다 하나씩 두며 둘 다 exact, partial, irrelevant 순으로 놓는다. 대각선 위쪽은 LLM이 스토어의 판정자보다 낮은 등급을 준 경우이고, 아래쪽은 더 높은 등급을 준 경우이다. 오류가 주로 아래쪽에 있는 판정자는 관대(lenient)하고, 주로 위쪽에 있는 판정자는 엄격(strict)하다.

여러 연구에서 LLM 판정자는 관대한 것으로 나타난다. 검색 증강 생성(검색된 텍스트로 답변을 작성하는 방식)을 평가하는 TREC 2024 RAG 트랙에서는 사람 평가자가 오픈 소스 LLM 판정자인 UMBRELA보다 전반적으로 더 엄격해 보인다(Upadhyay et al., 2024a). Arabzadeh와 Clarke는 GPT-4o를 기반으로 한 UMBRELA(Upadhyay et al., 2024b)가 2019년부터 2021년까지의 TREC Deep Learning 트랙 전체에서 사람보다 26% 넘게 많은 문서를 완전히 관련 있다고 표시했다고 보고한다. 그 수는 3,063개 대 2,429개이다(Arabzadeh and Clarke, 2025a). Yu et al.은 LLM 판정자가 "일관되게 부풀려진 관련성 점수를 준다"고 보고한다(Yu et al., 2026).

모든 연구가 이에 동의하는 것은 아니다. Thomas et al.은 32개의 프롬프트 중 하나를 레이블별로 층화한 표본에 적용했을 때, LLM이 TREC 평가자보다 쌍을 관련 없음으로 판정할 가능성이 더 높다는 것을 발견했다. 그 비율은 44% 대 33%이다(Thomas et al., 2024).

각 풀에서 프롬프트마다 행렬을 만들어 보면 LLM이 어느 쪽으로 틀리는지, 그리고 그 방향이 균형 잡힌 train 쌍에서 랭커의 상위 10개로 옮겨 가도 유지되는지 알 수 있다. train 풀은 레이블별로 고르게 뽑은 것이고, test 풀에서 판정되는 쌍은 1장의 네 랭커가 낸 상위 10개 가운데 LLM이 등급을 매길 쌍이다. test 풀의 행렬은 test 질의에 대해 보고할 뿐, 프롬프트를 고르는 데 쓰이지 않는다.

llm-confusion-matrix.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.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."""import pandas as pdfrom sklearn.metrics import cohen_kappa_scorefrom lib.agreement import LABELS, PROMPTS, graded_pairsorder = list(LABELS.values())                     # rows: the store's grades; columns: the LLM's; both exact firstfor pool in ["train", "test"]:    pairs = graded_pairs(pool).dropna(subset=["human"])                    # in the test pool, the pairs people judged    human = pairs["human"].astype(int)    print(f"\njudged pairs, {pool} pool: {len(pairs)}\nmean human grade, {pool} pool: {human.mean():.3f}")    for prompt in PROMPTS:        llm, name = pairs[prompt].astype(int), f"{pool} pool, {prompt} prompt"        table = pd.crosstab(human.map(LABELS).rename("human"), llm.map(LABELS).rename(f"llm, {name}"))        table = table.reindex(index=order, columns=order, fill_value=0)        errors = {f"{row} called {column}": table.at[row, column] for row in order for column in order if row != column}        # on a tie, max returns the first cell, in row order        largest = max(errors, key=errors.get)        print(table)        print(f"kappa, {name}: {cohen_kappa_score(human, llm):.3f}\nmean llm grade, {name}: {llm.mean():.3f}")        print(f"llm grade higher than human, {name}: {(llm > human).sum()}")        print(f"llm grade lower than human, {name}: {(llm < human).sum()}")        # a tie counts as not stricter        print(f"stricter than the store's judges, {name}: {'yes' if (llm < human).sum() > (llm > human).sum() else 'no'}")        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)

train 풀에서 LLM은 스토어의 판정자보다 엄격한가? short에서는 yes이다. guidelines에서는 yes이다. short에서는 140개 쌍에 더 낮은 등급을, 67개 쌍에 더 높은 등급을 주고, guidelines에서는 150개에 더 낮은 등급을, 52개에 더 높은 등급을 준다. 가장 큰 오류는 short에서 exact called partial (85)이고, guidelines에서 partial called irrelevant (72)이다.

test 풀에서의 답은 short에서 no이고 guidelines에서 no이다. short에서 LLM의 등급은 65개 쌍에서 더 높고 61개 쌍에서 더 낮다. guidelines에서는 83개에서 더 높고 77개에서 더 낮다. LLM의 평균 등급은 short에서 1.521, guidelines에서 1.521이며, 판정자의 평균 등급은 1.512이다. 가장 큰 오류는 short에서 partial called exact (57), guidelines에서 partial called exact (76)이다.

카파는 test 풀에서 short일 때 0.571, guidelines일 때 0.470이고, train 풀에서는 각각 0.432과 0.454이다. 레이블 구성이 경고하듯이 방향, 가장 큰 오류, 카파는 모두 풀에 따라 달라진다. LLM이 본 것을 비교하라에서는 두 풀에 모두 들어맞는 한 가지 패턴을 찾아낸다.

또한 오류의 방향만으로는 랭커의 점수가 어떻게 되는지 알 수 없다. 관대한 판정자는 더 많은 상품을 관련 있다고 세므로 precision@10이 올라간다(관련 상품 세기). nDCG@10은 같은 등급으로 만든 이상적인 상위 10개로 나누므로(하나의 랭킹 채점하기), 등급이 올라가면 이상적인 값도 함께 올라갈 수 있다. 그래서 순효과는 어느 쪽으로도 나타날 수 있고 랭커마다 다를 수 있다. 랭커 순서 점검에서 test 풀을 대상으로 이를 측정한다.

작업 규칙: 카파를 읽기 전에 혼동 행렬을 먼저 읽는다. 이때 판정자를 쓸 방식대로 뽑은 쌍을 사용하고, 그 풀에 대한 방향과 가장 큰 오류를 명시한다. 한 풀의 방향을 다른 풀로 가져가지 않으며, 이를 근거로 랭커의 nDCG@10을 예측하지도 않는다. 랭커끼리는 같은 등급 아래에서 비교하고, LLM 등급으로 낸 점수를 사람 등급으로 낸 점수와 비교해서는 안 된다.

LLM이 본 것과 평가자가 본 것 비교하기

마지막으로 변경된 판: 2026.11.8판

평가자는 자신에게 주어진 근거만 평가할 수 있다. WANDS의 평가자는 질의와 상품의 ID, 이름, 이미지, 웹 페이지를 보았고, 지침은 질의를 먼저 이해하라고 안내했다. "Strongly recommend google it first"(평가 지침)라는 문구가 그것이다. 녹화본은 LLM에게 각 상품의 이름, 클래스, 카테고리, 설명, 속성을 lib.agreement.as_the_llm_saw가 적어 내는 형태로 보여 주었다. 스토어의 표본은 설명을 약 400자로 자르며(데이터 카드) 이미지는 담고 있지 않으므로, 녹화본은 LLM에게 텍스트만 보냈다. 일부 불일치는 LLM의 평가 능력보다 이러한 차이에서 비롯되었을 수 있다. 이는 우리의 추론이다. 이 추론에서 검증할 수 있는 결과가 하나 있다. LLM이 적힌 내용을 기준으로 평가한다면, 텍스트가 질의의 요구를 말하지 않는 exact 상품에는 더 낮은 등급을 주고, 텍스트가 그것을 말하는 partial 상품에는 더 높은 등급을 주어야 한다.

이 검사는 훈련 질의 한 쌍과 테스트 질의 clear shower curtain, 그리고 두 풀에서 평가된 모든 exact 및 partial 쌍을 대상으로 한다(녹화본). 검사는 LLM이 본 내용에서 질의의 각 단어를 찾는다. 이때 2장의 검사와 같은 방식으로 내용을 소문자 단어로 나눈다.

llm-grades-follow-written-words.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.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."""import refrom lib.agreement import PROMPTS, as_the_llm_saw, graded_pairsfrom lib.store import load_products, load_queriesdef words(text):    """Lowercase word tokens, as chapter 2 matches query words against product text."""    # runs of letters, digits and underscores, so 7qt is one word and '7 qt' is two    return set(re.findall(r"\w+", text.lower()))products, queries = load_products(), load_queries()# query 163 is a train query, and product 20718 is the pair the prose followsprint("query:", queries.at[163, "query"])                              # a train queryprint(as_the_llm_saw(products.loc[20718]))print("grades from people, short, guidelines:", *graded_pairs("train").set_index(["query_id", "product_id"]).loc[(163, 20718)])curtains = graded_pairs("test").query("query_id == 246")      # clear shower curtain: every product in a top 10# whole words only, so 'unclear' doesn't count as saying clearsays = curtains["product_id"].map(lambda product_id: "clear" in words(as_the_llm_saw(products.loc[product_id])))for kind, group in [("say clear", curtains[says]), ("never say clear", curtains[~says])]:    print(f"\nclear shower curtain products that {kind}: {len(group)}")    for column, judge in [("human", "people"), ("short", "the short prompt"), ("guidelines", "the guidelines prompt")]:        print(f"products that {kind}, graded exact by {judge}: {(group[column] == 2).sum()}")for pool in ["train", "test"]:    pairs = graded_pairs(pool).dropna(subset=["human"])                     # in the test pool, the pairs people judged    # subset: every query word appears in the text the LLM saw    pairs["every word"] = [words(queries.at[query_id, "query"]) <= words(as_the_llm_saw(products.loc[product_id]))                           for query_id, product_id in zip(pairs["query_id"], pairs["product_id"])]    # share of each group that the LLM grades below people (exact) or above them (partial), for each prompt    for label, grade, every_word, direction in [("exact", 2, False, "lower"), ("exact", 2, True, "lower"),                                                ("partial", 1, True, "higher"), ("partial", 1, False, "higher")]:        group = pairs[(pairs["human"] == grade) & (pairs["every word"] == every_word)]        kind = f"{label} {pool} pairs {'with every query word' if every_word else 'missing a query word'}"        print(f"\n{kind}: {len(group)}")        for prompt in PROMPTS:            moved = group[prompt] < grade if direction == "lower" else group[prompt] > grade            print(f"share graded {direction}, {prompt} prompt, {kind}: {moved.mean():.3f}")
출력python llm-grades-follow-written-words.py
query: 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

훈련 질의인 dual monitor stand에서 스토어의 평가자는 abramowski monitor stand를 exact로 판정했고, 두 프롬프트는 모두 이를 partial로 판정했다(2 1 1, 이 순서대로). LLM이 본 내용 중에는 이 스탠드가 모니터 두 대를 지탱한다고 말하는 것이 없다.

clear shower curtain에서는 LLM의 exact 판정이 해당 단어를 따른다. LLM이 읽을 수 있는 곳에 clear가 적혀 있는 테스트 풀 상품 9개 가운데, 평가자는 5개를 exact로 판정했고, short 프롬프트는 7개를, guidelines 프롬프트는 7개를 exact로 판정했다. 그 단어가 어디에도 없는 9개 가운데, 평가자는 1개를 exact로 판정했고, short 프롬프트는 0개를, guidelines 프롬프트는 0개를 exact로 판정했다.

풀 전체로 세어도 같은 양상이 나타난다. short 프롬프트에서 텍스트에 질의 단어가 빠진 exact 쌍은 LLM에게 더 낮은 등급을 받은 비율이 훈련 풀에서 0.584, 테스트 풀에서 0.305이다. 텍스트에 모든 단어가 있는 exact 쌍은 각각 0.149과 0.084이다.

테스트 풀에서 텍스트에 질의 단어가 모두 있는 쌍이 더 높은 등급을 받은 비율은 0.548이고, 단어가 빠진 쌍은 0.171이다. 테스트 풀에서 guidelines 프롬프트도 같은 식으로 갈린다. exact 쌍에서는 0.281 대 0.051이고, partial 쌍에서는 0.667 대 0.241이다.

두 풀은 어느 경우가 흔한지에서 다르다. 훈련 풀에는 단어가 빠진 exact 쌍이 149개, 모든 단어가 있는 partial 쌍이 8개 있다. 테스트 풀에는 각각 128개와 42개가 있다. 우리의 해석으로는 이것이 오류 방향이 두 풀에서 다른 이유이다. 이 검사는 거친 편이다. 복수형이나 철자 오류도 단어가 빠진 것으로 센다. guidelines 프롬프트는 이러한 등급 하향을 요구한다. "If a modifier isn't mentioned, decide from what is written, and don't assume it is met." short 프롬프트에는 그러한 규칙이 없지만, 마찬가지로 등급을 낮춘다.

작업 규칙: 평가자가 근거로 삼은 필드 가운데 텍스트로 바꿀 수 있는 것은 모두 LLM 평가자에게 주어라. 속성과 전체 설명이 그 예이다. LLM이 볼 수 없는 것은 적어 두어라. 불일치를 LLM의 잘못으로 세기 전에, 그 근거가 LLM이 본 내용 안에 있었는지 확인하라. 평가자의 근거가 시각적이라면, 이 사례가 두 풀에서 보여 주듯 LLM이 exact 상품에 더 낮은 등급을 주는지 측정하라. 사용하는 모델이 이미지를 받는다면 이미지를 주어도 된다.

프롬프트가 레이블을 얼마나 바꾸는지 측정하라

마지막으로 변경된 판: 2026.11.8판

LLM 판정자는 모델과 프롬프트가 함께 이루는 것이다. Thomas 등은 하나의 프롬프트를 바꿔 쓴 42개 변형에서 평균 kappa가 0.50에서 0.72까지 퍼진다는 것을 발견했다. 0.50은 이들이 보통 수준의 일치라고 부르는 값이다. 이들은 어느 한 프롬프트의 점수가 판정자가 도달할 수 있는 범위에서 뽑은 하나의 표본일 뿐이라고 경고한다(Thomas et al., 2024).

Arabzadeh와 Clarke는 TREC Deep Learning 컬렉션에서 세 개의 LLM과 72개의 프롬프트를 비교하여, 이진 방식과 쌍별 방식이 프롬프트 문구에 가장 덜 민감한 반면, 이 상점이 쓰는 종류인 등급형 관련성 판정은 문구에 매우 민감하다는 것을 발견했다(Arabzadeh and Clarke, 2025b). 모든 LLM에서 가장 좋은 단일 프롬프트는 없었지만, UMBRELA는 여러 LLM에 걸쳐 등급형 평가에서 일관되게 좋은 성능을 보였다.

두 프롬프트는 정의를 공유하며, guidelines는 그 위에 규칙 다섯 개를 더한다(판정 지침 작성하기). 기록의 각 풀은 두 프롬프트가 어디에서 엇갈리는지 보여 주며, 학습 풀은 어느 프롬프트가 상점의 판정자와 더 잘 일치하는지 가려낼 수 있는지를 보여 준다. 같은 질의에서 나온 쌍은 서로 독립이 아니므로, 3장의 부트스트랩이 질의를 단위로 재표집하듯 구간 추정도 학습 질의 전체를 단위로 재표집한다.

prompt-disagreement.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.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."""import numpy as npimport pandas as pdfrom sklearn.metrics import cohen_kappa_scorefrom lib.agreement import LABELS, graded_pairsfrom lib.store import load_products, load_queriesdef kappa_gap(sample):    """Kappa with people under the guidelines prompt, minus kappa under the short prompt."""    human = sample["human"].astype(int)    return cohen_kappa_score(human, sample["guidelines"].astype(int)) - cohen_kappa_score(human, sample["short"].astype(int))order = list(LABELS.values())                     # exact, partial, irrelevantfor pool in ["train", "test"]:    # the test pool includes pairs nobody judged, so these counts cover every pair    pairs = graded_pairs(pool)    print(f"\n{pool} pairs where the prompts disagree: {(pairs['short'] != pairs['guidelines']).sum()} of {len(pairs)}\n"          f"kappa between the prompts, {pool} pool: {cohen_kappa_score(pairs['short'], pairs['guidelines']):.3f}")    table = pd.crosstab(pairs["short"].map(LABELS).rename(f"short, {pool}"), pairs["guidelines"].map(LABELS).rename("guidelines"))    table = table.reindex(index=order, columns=order, fill_value=0)    cells = {f"{row} under short, {column} under guidelines": table.at[row, column] for row in order for column in order if row != column}    print(f"{table}\nlargest disagreement, {pool} pool: {max(cells, key=cells.get)} ({max(cells.values())})")pairs, products, queries = graded_pairs("train"), load_products(), load_queries()moved = pairs[(pairs["short"] == 1) & (pairs["guidelines"] == 0)]          # partial under one prompt, irrelevant under the otherprint("\n".join(f"moved train pairs judged {label} by people: {(moved['human'] == grade).sum()}" for grade, label in LABELS.items()))# the first five queries in order, not a random samplefor query_id, product_id in moved[["query_id", "product_id"]].drop_duplicates("query_id").head(5).itertuples(index=False):    print(f"  {queries.at[query_id, 'query']:<28} {products.at[product_id, 'name'][:50]}")# a fixed seed, so the interval is the same on every runrng, train_queries = np.random.default_rng(2026), pairs["query_id"].unique()by_query = {query_id: group for query_id, group in pairs.groupby("query_id")}# each resample draws train queries with replacement, so some repeat and others are left outgaps = [kappa_gap(pd.concat([by_query[query_id] for query_id in rng.choice(train_queries, len(train_queries))]))        for _ in range(2000)]                                               # resample whole train querieslow, high = np.percentile(gaps, [2.5, 97.5])print(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

두 프롬프트는 학습 쌍 122 of 550개와 테스트 쌍 93 of 590개에서 엇갈리며, 두 프롬프트 사이의 kappa는 학습 풀에서 0.668, 테스트 풀에서 0.712이다.

가장 큰 불일치는 풀마다 다르다. 학습 풀에서는 partial under short, irrelevant under guidelines (75)이고, 랭커들의 상위 10개로 이루어진 테스트 풀에서는 partial under short, exact under guidelines (42)이다.

short가 부분 일치로, guidelines가 무관으로 판정한 학습 쌍 가운데 상점의 판정자는 26개를 무관으로 판정하여 guidelines의 편을 들었고, 31개를 부분 일치로 판정하여 short의 편을 들었으며, 18개를 정확 일치로 판정했다. 예제가 나열하는 이동한 쌍에는 toddler couch fold out에 대한 소파 베드와 70s inspired furniture에 대한 창문 커튼이 있다. 기록에는 이유가 아니라 레이블만 남아 있으므로, 이런 이름으로부터 이 이동이 엉뚱한 종류의 제품을 무관으로 판정하는 guidelines의 규칙에서 비롯된다고 추론한다.

상점의 판정자와의 kappa에서 guidelines는 short보다 0.022만큼 앞서며, 재표집한 학습 질의에 대한 95% 구간은 -0.042 to 0.086이다. 이 구간은 0을 포함하므로 학습 풀은 두 프롬프트를 구별하지 못하며, 상점은 둘 다 유지한다.

작업 규칙: 프롬프트를 판정자의 일부로 취급하라. 이 기록이 매니페스트와 스크립트에서 하듯, 모든 프롬프트를 모델 버전, 설정, 응답 스키마와 함께 한 단어도 바꾸지 않고 기록하라. 프롬프트가 바뀌면 다른 판정자로 취급하고 일치도를 다시 측정하라. 프롬프트를 최소 두 개 실행하고, 두 프롬프트가 모두 같은 결론을 낼 때에만 LLM 등급에서 나온 결론을 신뢰하라. 한 프롬프트를 다른 프롬프트보다 선택할 때에는 학습 쌍을 기준으로 하고, 둘의 차이에 대한 구간이 0을 제외할 때에만 선택하라.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

Fill unjudged pairs with LLM grades

마지막으로 변경된 판: 2026.11.8판

We consider filling the holes in the human judgments the least risky use of an LLM judge. Keep every human grade, and use the LLM only for pairs nobody judged, which a metric would otherwise count as grade 0 (Count unjudged products). The LLM then decides only what was a guess before.

Of the 590 pairs in the top 10s of chapter 1's four rankers, 26 are unjudged, and BM25's top 10s hold 22 of them, against 3 for semantic retrieval and 6 for the hybrid.

Let each prompt fill them, rescore the four rankers on nDCG@10 (Score one ranking), and rerun chapter 3's planned comparisons on the filled grades:

fill-unjudged-pairs.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.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."""from lib.agreement import LABELS, PLANNED, PROMPTS, chapter_one_runs, fill_unjudged, graded_pairs, llm_qrels, planned_verdictsfrom lib.metrics import evaluatefrom lib.store import load_products, load_queries, qrelsdef order(scores):    """Rankers by mean nDCG@10 over the test queries, best first."""    return sorted(scores, key=lambda name: scores[name].mean(), reverse=True)products, queries, people = load_products(), load_queries("test"), qrels("test")runs = chapter_one_runs(products, queries)pairs = graded_pairs("test")                      # every product in the top 10 of the four runs, per test queryunjudged = pairs[pairs["human"].isna()]print(f"pairs in the test pool: {len(pairs)}\nof them, unjudged: {len(unjudged)}")for name, run in runs.items():    # people[query_id] holds the human judgments for a query, so a product missing from it was never judged    missing = sum(product_id not in people[query_id] for query_id, ranking in run.items() for product_id in ranking[:10])    print(f"unjudged products in the top 10s, {name}: {missing}")lights = unjudged[unjudged["query_id"] == 133]                             # outdoor light fixturesprint(f"unjudged products for outdoor light fixtures: {len(lights)}\n"      f"of them, with bulb in the name: {lights['product_id'].map(products['name']).str.contains('bulb').sum()}")threshold = 0.05 / len(PLANNED)                                            # chapter 3's rulehuman = {name: evaluate(run, people)["ndcg@10"] for name, run in runs.items()}            # per-query scoresprint(f"order, people's grades only: {' > '.join(order(human))}")for prompt in PROMPTS:    counts = ", ".join(str((unjudged[prompt] == grade).sum()) for grade in LABELS)        # grades 2, 1 and 0    print(f"\nunjudged pairs graded exact, partial, irrelevant, {prompt} prompt: {counts}")    print(f"unjudged bulbs graded irrelevant, {prompt} prompt: {(lights[prompt] == 0).sum()}")    filled = {name: evaluate(run, fill_unjudged(people, llm_qrels(prompt)))["ndcg@10"] for name, run in runs.items()}    print("\n".join(f"{name} ndcg@10, filled by the {prompt} prompt: {filled[name].mean():.3f}" for name in runs))    print(f"order, filled by the {prompt} prompt: {' > '.join(order(filled))}")    # compares the two orders place by place    moved = [name for name, place in zip(order(filled), order(human)) if name != place]    print(f"rankers that change place when filled, {prompt} prompt: {', '.join(moved) or 'none'}")    changed = [pair for pair, established in planned_verdicts(filled, threshold).items()               if established != planned_verdicts(human, threshold)[pair]]    print(f"verdicts that change when filled, {prompt} prompt: {'; '.join(' minus '.join(pair) for pair in changed) or 'none'}")
출력python fill-unjudged-pairs.py
pairs 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

The prompts disagree about the unjudged pairs. Counted as exact, partial and irrelevant, short grades them 4, 17, 5, and guidelines 5, 9, 12. They part on the unjudged products for outdoor light fixtures in BM25's top 10 (Score every test query): 8 of the 8 have bulb in their names.

guidelines calls 7 of the bulbs irrelevant, and short calls 0. Chapter 1 argued that a bulb isn't a light fixture. Which reading the store's judges would take, nobody knows until they judge the bulbs.

With the holes filled, BM25 scores 0.754 with short and 0.745 with guidelines, against 0.725 on human grades alone, and semantic retrieval scores 0.833 and 0.834, against 0.830.

The order on human grades alone is semantic > hybrid > reranked > bm25. The rankers that change place when short fills the holes are none, and when guidelines does, none. The planned comparisons' verdicts that change are none under short and none under guidelines.

Under human grades, the rankers' mean judged@10, the share of each top 10 that people judged, runs from 0.927 for BM25 to 0.990 for semantic retrieval (Compare runs in a harness).

How far can the filled grades be trusted? The closest evidence is the judged pairs of the same pool, where the LLM's kappa with the store's judges is 0.571 for short and 0.470 for guidelines. On those judged pairs, its grade is lower than the judges' on 61 pairs and higher on 65 with short, and lower on 77 and higher on 83 with guidelines (Read the direction of the LLM's errors).

Working rule: Fill the unjudged pairs in your rankers' top 10s with LLM grades as a diagnostic, under every prompt you run, and report the filled score beside the human-only one with the number of pairs filled. If filling changes the order of two rankers or a verdict, have people judge those pairs. Never let a filled grade replace a human one.

LLM 등급이 순위기를 같은 순서로 배열하는지 확인하기

마지막으로 변경된 판: 2026.11.10판

두 판정 집합은 많은 레이블에서 서로 어긋나면서도 시스템의 순위는 비슷하게 매길 수 있다. Voorhees는 서로 다른 관련성 판정 집합으로 TREC 실행 결과를 채점했고, "서로 다른 관련성 판정 집합을 사용해 만든 시스템 순위 사이에서 매우 높은 상관이 나타났다"고 보고했다(Voorhees, 1998). LLM 판정자에서도 같은 분리가 나타난다. TREC 2023 Deep Learning 트랙의 LLM 레이블 42개 집합에서 kappa는 약 0.06에서 0.29까지 나타났지만, 시스템 순위의 상관은 약 0.83에서 0.95 사이에 머물렀다(Rahmani et al., 2025, Table 3).

이 상관이 Kendall의 tau이다. 두 순서가 한 시스템 쌍을 같은 방향으로 놓으면 그 쌍은 일치(concordant)하고, 서로 반대 방향으로 놓으면 불일치(discordant)한다. tau는 일치 쌍의 수에서 불일치 쌍의 수를 뺀 값을 전체 쌍의 수로 나눈 것이며, 순서가 같으면 1, 정반대이면 −1이다. SciPy의 kendalltau는 동점도 처리하는 형태인 τ_b를 계산한다(SciPy documentation).

Yilmaz et al.은 tau가 0.9 이상인 순위는, 적어도 경험적으로는, 사실상 동등하게 취급되는 경우가 많다고 설명한다(Yilmaz et al., 2008). Sanderson과 Soboroff는 이런 임계값으로 판단하는 방식이 이 분야에서 가정해 온 것보다 신뢰하기 어렵다는 점을 발견했다(Sanderson and Soboroff, 2007).

1장의 네 순위기를 사람의 등급과 각 프롬프트의 LLM 등급으로 nDCG@10에서 채점하면, LLM이 순위기를 사람처럼 배열하는지 알 수 있다. LLM은 테스트 풀, 곧 그 순위기들의 상위 10개에 든 상품만 판정했다. 따라서 통제 실험으로 풀의 쌍에 대해서만 사람의 등급으로도 순위기를 채점한다. 순위기가 네 개이면 쌍은 6개이므로 한 쌍이 뒤바뀌면 tau는 0.333만큼 움직이고, tau가 가질 수 있는 값은 일곱 가지뿐이다. 이는 거친 척도이다. 개별 쌍에서 사람과 이만큼 떨어진 판정자도 순위기는 사람과 같은 순서로 배열할 수 있다. 과연 그럴까? 먼저 답을 정하고 시작하자.

kendall-tau-four-rankers.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.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."""from itertools import combinationsfrom scipy.stats import kendalltaufrom lib.agreement import chapter_one_runs, llm_qrelsfrom lib.metrics import evaluatefrom lib.store import load_products, load_queries, qrelsproducts, queries, people = load_products(), load_queries("test"), qrels("test")runs = chapter_one_runs(products, queries)short, guidelines = llm_qrels("short"), llm_qrels("guidelines")pooled = {query_id: {product_id: grade for product_id, grade in people[query_id].items() if product_id in short[query_id]}          for query_id in people}                 # people's grades for the pairs the LLM judged, and no othersjudgment_sets = {"people": people, "people on the LLM's pairs": pooled, "the short prompt": short,                 "the guidelines prompt": guidelines}means = {name: {ranker: evaluate(run, judgments)["ndcg@10"].mean() for ranker, run in runs.items()}         for name, judgments in judgment_sets.items()}for name, scores in means.items():    print(f"order under {name}: {' > '.join(sorted(scores, key=scores.get, reverse=True))}")    for ranker, score in scores.items():        print(f"{ranker} ndcg@10 under {name}: {score:.3f}")orders = [sorted(scores, key=scores.get, reverse=True) for scores in means.values()]steady = [ranker for position, ranker in enumerate(orders[0]) if all(order[position] == ranker for order in orders)]print(f"rankers in the same place under every set of grades: {', '.join(steady) or 'none'}")control = means["people on the LLM's pairs"]                              # the same pool, human gradesfor name in ["the short prompt", "the guidelines prompt"]:    print("\n".join(f"{ranker}, {name} minus people on the LLM's pairs: {means[name][ranker] - control[ranker]:+.3f}" for ranker in runs))# people's scores are the reference that every other set of grades is compared withpairs, reference = list(combinations(runs, 2)), means["people"]# one swap turns a concordant pair into a discordant one, which moves tau by 2 over the number of pairsprint(f"\npairs of rankers: {len(pairs)}\nchange in tau from one swapped pair: {2 / len(pairs):.3f}")for name, scores in list(means.items())[1:]:    swapped = [(first, second) for first, second in pairs                # discordant: opposite signs               if (reference[first] - reference[second]) * (scores[first] - scores[second]) < 0]    print(f"swapped under {name}: {'; '.join(f'{first} and {second}' for first, second in swapped) or 'none'}")    # concordant minus discordant, over all pairs; the discordant count is the number of swaps    print(f"tau by hand, people against {name}: {(len(pairs) - 2 * len(swapped)) / len(pairs):.3f}")    # SciPy's tau_b, which handles ties; .statistic is the tau value    print(f"tau from scipy, people against {name}: {kendalltau(list(reference.values()), list(scores.values())).statistic:.3f}")
출력python kendall-tau-four-rankers.py
order 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

사람의 등급은 semantic > hybrid > reranked > bm25을(를) 낳는다. 통제 실험인 LLM의 쌍에 대한 사람의 등급도 이 순서를 유지하며 tau는 1.000이므로, 등급을 풀로 한정해도 움직이는 순위기는 없다. 다만 모든 점수는 올라간다. BM25는 0.725에서 0.795가 된다. 이상적인 상위 10개에는 풀에 든 상품만 들어갈 수 있기 때문이다.

short의 순서는 reranked > semantic > hybrid > bm25이고, guidelines의 순서는 reranked > semantic > hybrid > bm25이다. short은(는) semantic and reranked; hybrid and reranked을(를) 맞바꾸고, guidelines은(는) semantic and reranked; hybrid and reranked을(를) 맞바꾼다.

short의 tau는 직접 계산하면 0.333이고 SciPy로 계산하면 0.333이며, guidelines의 tau는 SciPy로 계산하면 0.333이다.

통제 실험과 비교하면 LLM 등급은 네 순위기를 같은 양만큼, 같은 방향으로 움직이지 않는다. short에서는 BM25가 +0.037, 의미 기반 검색이 -0.001, 하이브리드가 +0.016, 재순위화한 하이브리드가 +0.037만큼 변한다. guidelines에서는 변화가 +0.010, -0.026, -0.008, +0.017이다. 판정자는 일부 순위기의 점수를 올리고 다른 순위기의 점수를 내리며, 그 결과 순위기들이 서로를 추월한다.

short에서는 의미 기반 검색, 하이브리드, 재순위화한 하이브리드가 각각 0.903, 0.900, 0.906로 거의 동점이다. tau는 두 순위기의 점수가 얼마나 떨어져 있는지를 무시하므로, 거의 동점인 순위기 사이의 뒤바뀜도 최고와 최저 순위기 사이의 뒤바뀜과 똑같이 센다.

또한 tau는 상위에서의 뒤바뀜과 하위에서의 뒤바뀜을 똑같이 취급하는데, Yilmaz et al.이 이 약점을 지적했다(Yilmaz et al., 2008). Yilmaz et al.은 자신들이 비교한 TREC 실행 결과에 대해 시스템들이 "성능이 매우 비슷하다. 따라서 Kendall의 τ 통계량이 이러한 시스템들의 영향을 받을 수 있다"고 말한다(Yilmaz et al., 2012).

모든 등급 집합에서 자리를 지키는 순위기는 bm25이다. 순서는 사람의 등급이 0.830, 0.812, 0.798로 채점한 세 순위기 사이에서만 다르며, 이 격차는 계획된 어떤 비교로도 입증되지 않는다(계획된 비교 다시 실행하기).

작업 규칙: tau는 결코 단독으로 보고하지 말고 뒤바뀐 쌍의 목록과 함께 보고한다. 순위기가 몇 개뿐이어서 한 쌍이 뒤바뀔 때 tau가 0.333만큼 움직인다면, tau를 0.9와 견주어 해석하지 않는다. 그런 다음 각 등급 집합에서의 계획된 비교로 뒤바뀐 쌍의 점수가 실제로 다른지 검정한다.

LLM 점수로 계획된 비교 다시 수행하기

마지막으로 변경된 판: 2026.11.8판

결정은 이 책의 규칙에 따른 판정에서 나오며, 타우가 비교하는 순서에서 나오지 않는다. LLM 점수를 썼다면 상점은 같은 판정을 얻었을까? 상위권에서 문제가 생길 것으로 예상할 수 있다. Otero 등은 "LLM 기반 판단은 상위 성능 시스템의 순위를 매기는 데 공정하지 않다"고 하였고, "통계적 차이에 대한 거짓 양성 비율이 매우 높다"고 보고하였다(Otero et al., 2025).

3장의 계획된 비교 세 가지는 임계값 0.0167과 0.9833 수준의 구간을 사용한다. 테스트 풀에서 사람의 점수와 각 프롬프트의 점수로 이 비교를 다시 수행하고, 3장의 탐색적 비교인 재순위화한 하이브리드와 시맨틱 검색의 비교를 더하면, 상점이 같은 랭커를 출시했을지 알 수 있다.

planned-comparisons-llm-grades.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.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."""from lib.agreement import PLANNED, PROMPTS, chapter_one_runs, llm_qrels   # PLANNED: chapter 3's, each stage against the lastfrom lib.metrics import evaluatefrom lib.significance import compare, verdictfrom lib.store import load_products, load_queries, qrelsEXPLORATORY = [("reranked", "semantic")]                                           # chosen after seeing test meansthreshold = 0.05 / len(PLANNED)                   # chapter 3's threshold, so that a verdict means the same either wayprint(f"planned comparisons: {len(PLANNED)}\np-value threshold: {threshold:.4f}\ninterval level: {1 - threshold:.4f}")runs = chapter_one_runs(load_products(), load_queries("test"))judgment_sets = {"people": qrels("test"), **{f"{prompt} prompt": llm_qrels(prompt) for prompt in PROMPTS}}established, disagreements = {}, {judges: 0 for judges in judgment_sets}for judges, judgments in judgment_sets.items():    ndcg = {ranker: evaluate(run, judgments)["ndcg@10"] for ranker, run in runs.items()}    for after, before in PLANNED + EXPLORATORY:        # the interval's level matches the threshold, so each interval and p-value follow one rule        result, name = compare(ndcg[after], ndcg[before], confidence=1 - threshold), f"{after} minus {before}, {judges}"        print(f"\n{name}: {result['mean difference']:.3f}\n{name}, permutation p: {result['permutation p']:.3f}")        # the exploratory comparison gets no t-test, interval or verdict        if (after, before) in PLANNED:            print(f"{name}, t-test p: {result['t-test p']:.3f}\n{name}, interval: {result['ci low']:.3f} to {result['ci high']:.3f}")            checks = verdict(result, threshold)            established[(judges, after, before)] = checks["established"]            disagree = [check for check in ["t-test", "interval"] if not checks[f"{check} agrees"]]            disagreements[judges] += bool(disagree)            print(f"{name}, established: {'yes' if checks['established'] else 'no'}\n"                  f"{name}, disagrees with the permutation test: {' and '.join(disagree) or 'neither'}")print()for judges, count in disagreements.items():    print(f"planned comparisons where the t-test or interval disagrees, {judges}: {count}")for prompt in PROMPTS:    differ = [pair for pair in PLANNED if established[(f"{prompt} prompt", *pair)] != established[("people", *pair)]]    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.py
planned 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
측정값 점수 시맨틱 − BM25 하이브리드 − 시맨틱 재순위화 − 하이브리드
평균 차이 사람 0.105 -0.018 -0.014
평균 차이 short 0.070 -0.002 0.006
평균 차이 guidelines 0.073 -0.001 0.010
구간 사람 0.047 to 0.205 -0.048 to 0.006 -0.053 to 0.020
구간 short 0.016 to 0.146 -0.029 to 0.036 -0.029 to 0.042
구간 guidelines 0.006 to 0.183 -0.045 to 0.037 -0.024 to 0.076
순열 p 사람 0.001 0.125 0.382
순열 p short 0.010 0.851 0.727
순열 p guidelines 0.045 0.929 0.657
t-검정 p 사람 0.003 0.123 0.375
t-검정 p short 0.014 0.861 0.714
t-검정 p guidelines 0.057 0.945 0.609
확립 여부 사람 yes no no
확립 여부 short yes no no
확립 여부 guidelines no no no

상점에서 유일하게 확립된 결과가 LLM 점수에서도 유지되는지는 프롬프트에 따라 달라진다. guidelines에서는 달라지는 판정이 semantic minus bm25이며, 이는 3장에서 확립된 유일한 결과이다. short에서는 사람의 판정과 다른 판정이 none이다.

t-검정이나 구간이 순열 검정과 일치하지 않는 계획된 비교는 사람 점수에서 0개, short에서 0개, guidelines에서 1개이다. guidelines에서 시맨틱 검색 − BM25의 경우, 일치하지 않는 검사는 interval이다.

랭커의 순서 비교에서는 순서가 뒤바뀐 쌍이 두 개 나왔다. 하나는 재순위화한 하이브리드와 하이브리드의 쌍으로, 계획된 비교이며 표에서 보듯 어떤 점수 집합에서도 확립되지 않는다. 다른 하나는 재순위화한 하이브리드와 시맨틱 검색의 쌍으로, 탐색적 비교이다. 사람 점수에서 재순위화한 하이브리드 − 시맨틱 검색은 -0.032이다(순열 p 0.048). LLM 점수에서는 short일 때 0.003, guidelines일 때 0.009이다. 3장은 테스트 평균을 본 뒤에 이 비교를 골랐으므로, 어느 쪽이든 아무것도 확립하지 못한다.

LLM 판정자는 LLM을 쓰는 랭커를 선호할 수도 있다. Balog 등은 "LLM 판정자가 LLM 기반 랭커에 유의미한 편향을 보인다는 최초의 실증적 증거"를 보고한다(Balog et al., 2025). 1장의 랭커는 LLM을 쓰지 않으므로, 이 장에서는 그 편향을 측정할 수 없다. 이 책은 8장과 9장의 LLM 기반 랭커를 사람 점수로 평가한다.

작업 규칙: LLM 점수의 판정만으로 변경을 출시하지 않는다. LLM 점수는 판정할 가치가 있는 후보를 가리는 데 쓰고, 결정은 사람 점수로 내린다. 두 프롬프트가 서로 다른 판정을 내놓으면 LLM은 그 비교를 결정할 수 없으며, 사람이 결정해야 한다.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

Correct LLM scores with a human sample

마지막으로 변경된 판: 2026.11.10판

A middle path uses both kinds of grades: grade every query with the LLM, have people judge a random sample of queries, and use the sample to correct the LLM's error. Prediction-powered inference rigorously corrects a model's predictions with a human sample, with confidence intervals that hold "without making any assumptions on the machine-learning algorithm that supplies the predictions" (Angelopoulos et al., 2023). A simple form of the idea, for a mean, takes the LLM's mean over every query and adds the human sample's average of human minus LLM:

corrected = mean over all queries of the LLM score + mean over the human sample of (human score − LLM score)

In search evaluation, Oosterhuis et al. build metric intervals this way, warning that "generated relevance annotations are not immune to (systematic) errors" (Oosterhuis et al., 2024). Takehi et al. let the LLM pick which pairs people judge under a budget, then calibrate it on them (Takehi et al., 2025).

Suppose the store could afford human judgments for 10 of 30 test queries. The example draws 2,000 random sets of that size and, for each, corrects the LLM's estimate, under each prompt, of two gaps between chapter 1's rankers: semantic retrieval minus BM25, and the hybrid minus semantic retrieval, and compares each corrected estimate with what the human sample says on its own. Spread is an estimate's standard deviation over the draws. The simulation chooses nothing:

correct-llm-scores-with-humans.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.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."""import numpy as npimport pandas as pdfrom lib.agreement import PROMPTS, chapter_one_runs, llm_qrelsfrom lib.metrics import evaluatefrom lib.store import load_products, load_queries, qrelsJUDGED, DRAWS = 10, 2000                          # test queries people judge in each draw, and the number of drawsruns = chapter_one_runs(load_products(), load_queries("test"))people = pd.DataFrame({ranker: evaluate(run, qrels("test"))["ndcg@10"] for ranker, run in runs.items()})rng = np.random.default_rng(2026)draws = [rng.choice(people.index, JUDGED, replace=False) for _ in range(DRAWS)]    # which queries people judgeprint(f"queries judged by people in each draw: {JUDGED} of {len(people)}\ndraws: {DRAWS:,}")for after, before in [("semantic", "bm25"), ("hybrid", "semantic")]:    gap_people = people[after] - people[before]                        # per-query gaps under people's grades    print(f"\n{after} minus {before}, people, all queries: {gap_people.mean():.3f}")    # the spread: the standard deviation over the draws, with numpy's default divisor    alone = np.std([gap_people[judged].mean() for judged in draws])                # the human sample used alone    print(f"{after} minus {before}, human sample alone, spread: {alone:.3f}")    for prompt in PROMPTS:        llm = {ranker: evaluate(run, llm_qrels(prompt))["ndcg@10"] for ranker, run in runs.items()}        gap_llm, name = llm[after] - llm[before], f"{after} minus {before}, {prompt} prompt"        # the LLM's mean over all queries, plus the human sample's average of human minus LLM        corrected = [gap_llm.mean() + (gap_people[judged] - gap_llm[judged]).mean() for judged in draws]        print(f"{name}, LLM only: {gap_llm.mean():.3f}")        print(f"{name}, corrected, mean over draws: {np.mean(corrected):.3f}")        print(f"{name}, corrected, spread: {np.std(corrected):.3f}")        print(f"{name}, corrected spread smaller than the human sample's: {'yes' if np.std(corrected) < alone else 'no'}")        # corrcoef returns a 2×2 matrix; [0, 1] is the correlation between the two lists        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.py
queries 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

For semantic retrieval minus BM25, the LLM alone estimates 0.070 with short, against 0.105 on human grades. Corrected, the estimate averages 0.104 over the draws, so the correction removes the LLM's bias.

Its spread is 0.036, against 0.045 for the human sample alone. Is the corrected spread smaller than the human sample's? yes with short and yes with guidelines. The LLM's grades for the other queries add information, because its per-query gaps correlate with the human ones at 0.641.

For the hybrid minus semantic retrieval, the corrected spread is 0.023 with short and 0.024 with guidelines, against 0.016 for the human sample alone. Is it smaller than the human sample's? no with short and no with guidelines. The per-query gaps correlate at 0.168 under short.

The correction fixes the level of a score, but narrows the uncertainty only where the LLM's per-query scores track people's, and here they track them least, on the closer of the two gaps.

Working rule: Whenever you report a score from LLM grades, have people judge a random sample of queries and report the corrected estimate. On that sample, check how well the LLM's per-query gaps correlate with the human ones. When they correlate weakly, spend the budget on judging more queries.

운영 환경에서 잘못되는 것들

마지막으로 변경된 판: 2026.11.8판

심판이 예고 없이 바뀐다. LLM으로 판정하는 저장소는 LLM을 거듭 실행하므로, 모델 버전이나 양자화(모델 가중치를 저장하는 정밀도), 또는 표현을 바꾼 프롬프트가 달라지면 다른 심판이 된다. 녹화본의 manifest.json은 모델의 다이제스트와 두 프롬프트를 한 단어도 빠짐없이 고정한다. 답변 스키마와 컨텍스트 길이는 recordings/llm.py와 recordings/llm_judgments.py에 있으므로 이 둘도 함께 기록한다. 이 가운데 무엇이든 바뀔 때마다 동일한 사람 표본으로 일치도 검사를 다시 실행한다.

심판에 맞춰 조정한 시스템은 그 심판에게서 점수가 높게 나온다. Clarke와 Dietz는 LLM 심판을 악용하는 실행 결과를 만들었고, 그 결과는 "수동 평가(28위)보다 자동 평가(5위)에서 유의하게 더 높은 순위"를 기록했다(Clarke and Dietz, 2024). LLM이 매긴 등급으로 조정했거나 같은 LLM을 기반으로 만든 랭커는 대표 점수를 사람이 매긴 등급으로 내야 한다.

상품 텍스트가 심판을 유도할 수 있다. Alaofi 등은 LLM 심판이 관련 없는 텍스트에 심어 둔 질의어와 그 안에 적어 넣은 지시에 속을 수 있음을 발견했다(Alaofi et al., 2024). 판매자는 심판에게 말을 거는 설명을 쓸 수 있다. 심판이 잘못 이끌리면 일치도 하락으로 드러나도록, 모든 평가에 사람 표본을 남겨 둔다.

테스트로 보정하는 것은 테스트로 조정하는 것이다. 테스트 질의에서 사람의 등급과 맞을 때까지 프롬프트의 표현을 고치면, 그 질의에서의 일치도는 의미가 없어진다. 프롬프트는 학습 질의로 고르고, 일치도는 테스트 질의에서 보고한다.

사람의 등급도 진실은 아니다. TREC Podcast 트랙에서 LLM과 TREC 평가자의 판정이 가장 크게 갈린 쌍을 전문가가 다시 판정했을 때, 전문가는 LLM의 손을 더 자주 들어 주었다고 Mansour 등은 밝혔다(Mansour et al., 2026). 사람의 등급은 자신이 선택한 기준일 뿐이라고 보고, 어느 한쪽을 탓하기 전에 불일치 사례를 읽어 본다.

작업 규칙: 심판을 고정하고, 모든 평가에 사람 표본을 남기고, 무엇이든 바뀌면 일치도를 다시 측정하며, 랭커를 조정할 때 쓴 심판으로 그 랭커를 채점하지 않는다.

이 장이 내린 결정

마지막으로 변경된 판: 2026.11.8판

저장소는 이후의 장이 이유를 제시하지 않는 한 이 결정들을 유지한다.

  • 모든 대표 점수에는 사람의 등급을 쓴다. LLM 등급은 진단 용도로, 빈칸을 채우고 후보를 거르고 판정을 확인하는 데 쓴다. 8장과 9장의 LLM 기반 랭커는 사람의 등급으로 점수를 매긴다.
  • 심사자에 관한 모든 발견은 어느 풀에서 얻었는지 밝힌다. 카파와 선형 가중 카파, 그 옆의 관측 일치도, 크게 빗나간 사례, 레이블 구성은 사람이 판정한 학습 쌍에서 측정하며, 테스트 풀의 판정된 쌍에 대해서도 보고한다. 방향과 가장 큰 오차는 각 풀에서 따로 읽고, 랭커 점수에 대해서는 랭커의 상위 10개만 말해 준다.
  • 프롬프트 두 개를 한 단어도 바꾸지 않고 기록한다. 학습 풀로는 둘을 구별할 수 없으므로 저장소는 둘 다 보관하고, 두 프롬프트가 모두 같은 결론을 낼 때만 LLM 등급에서 나온 결론을 신뢰한다.
  • 판정되지 않은 쌍은 진단용으로 LLM 등급을 채워 넣고, 사람 등급만 쓴 점수 옆에 함께 보고한다. 테스트 질의에서는 채워 넣어도 어떤 랭커의 순위도, 어떤 판정도 바뀌지 않는다.
  • 점수는 같은 등급 아래에서만 비교한다. 같은 풀에서도 LLM 등급은 랭커마다 nDCG@10을 같은 크기로, 같은 방향으로 움직이지 않는다. 따라서 LLM 등급으로 낸 점수를 사람 등급으로 낸 점수와 맞대어 비교하지 않는다.
  • 타우는 뒤바뀐 쌍과 함께 보고하고, 그다음 3장의 문턱값으로 계획된 비교를 한다. 랭커가 네 개뿐이면 타우는 거친 지표이므로 판정은 비교가 결정한다.
  • LLM 등급으로 낸 점수에는 사람 표본이 따른다. 표본 질의로 점수를 보정하고, LLM의 등급이 불확실성을 좁혔는지 알려 주는 상관을 함께 제시한다.
  • 이 장이 보여 준 것: LLM 심사자는 빈칸을 채우고 후보를 거를 수 있다. 그러나 그 등급은 랭커마다 고르지 않게 움직이므로, 중요한 판정에는 여전히 사람의 등급이 필요하다.

이 판의 이 장

2026.11.10판예제 통과 2026년 11월 19이 장에서 11개 예제개 중 11개가 통과한다

영어판 2026.11.10판을 번역한 것이다.

이 절 인용

형식

각 형식은 이 번역이 따르는 영문 원서를 출처로 표기한다.

모든 형식은 이 판을 명시한다. 링크는 현재 판을 열며, 여기서 절의 제목은 본문이 마지막으로 바뀐 시점을 알려 준다. 접근 날짜와 검색 날짜는 이 자료를 여는 날짜다.

이 페이지의 내용

11장 중 4장: 사람과 LLM의 판정

  1. Write judging guidelines
  2. 카파로 우연을 넘어서는 일치도 측정하기
  3. 가중 카파로 근접 오답에 부분 점수를 준다
  4. 레이블 구성에 비추어 카파를 읽기
  5. LLM 오류의 방향 읽기
  6. LLM이 본 것과 평가자가 본 것 비교하기
  7. 프롬프트가 레이블을 얼마나 바꾸는지 측정하라
  8. Fill unjudged pairs with LLM grades
  9. LLM 등급이 순위기를 같은 순서로 배열하는지 확인하기
  10. LLM 점수로 계획된 비교 다시 수행하기
  11. Correct LLM scores with a human sample
  12. 운영 환경에서 잘못되는 것들
  13. 이 장이 내린 결정

맨 위로 돌아가기전체 장