심사자의 오류를 사람의 평가와 대조해 측정하고, 통과율을 보정한다

읽는 데 약 36분분 걸린다, 7절에 6개 예제이(가) 있음.

2026.11.3판 예제 통과 2026년 11월 21 54개 예제 중 54개 통과 변경 사항

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

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

이 장을 마치면 심사자의 판정이 사람의 평가와 어떻게 다른지 측정하고, 그 차이를 놓침과 거짓 통과로 나누고, 관측된 통과율을 그 오류에 맞게 보정할 수 있다. 보정이 기대는 가정도 보정 결과 옆에 함께 적는다.

5장은 보정 과제의 두 번째 문구로, 그리고 심사자의 문구는 가정하지 않고 측정한다는 규칙으로 끝났다. 답변 심사자는 각 응답을 서면 기준 답안과 대조해 읽고 PASS 또는 FAIL로 표시하며, 어시스턴트의 기준선 실행에서 나온 통과율은 바로 이 심사자에게서 얻은 것이다. 심사자는 틀린 응답을 통과시키기도 하고 맞는 응답을 탈락시키기도 하므로, 이 비율은 어시스턴트에 관한 숫자인 만큼 심사자에 관한 숫자이기도 하다. 5장에서는 채점 기준을 작성하고 판정을 읽었다. 이 장에서는 그 판정이 얼마나 자주, 어느 방향으로 틀리는지, 그리고 그 사실을 알게 된 팀이 비율에 어떤 조치를 하는지를 다룬다.

사람의 평가와 그 성격

판정기는 다른 방식으로 만들어진 레이블과 대조해야만 검증할 수 있다. 이 책은 NVIDIA가 공개한 데이터셋 HelpSteer2의 사람 평가를 사용한다. 각 행에는 프롬프트 하나, 그에 대한 응답 하나, 그리고 사람이 매긴 0에서 4까지의 속성 점수 다섯 개가 들어 있다. 응답은 다른 모델이 생성한 것이다. 이 장에서는 속성 하나, 곧 정확성만 사용한다. 샘플링 코드는 이 점수를 통과 또는 실패로 바꾼다. 점수 3 또는 4는 PASS로, 0에서 2는 FAIL로 읽는다. 이 기준선은 어떤 판정기도 실행하기 전에 이 책이 정한 것이다.

HelpSteer2는 이 책의 자체 데이터가 아니다. 응답은 다른 모델에서 나왔고, 프롬프트는 범용이며, 누구도 sablefile을 위해 작성하지 않았다. 따라서 이 레이블이 측정하는 것은 답변 판정기가 답하는 질문과는 다른 질문에서 판정기가 얼마나 잘 작동하는가이다. 이 간극이 전이 가정의 주제이며, 이 장의 나머지 부분은 계속 이 문제로 돌아온다.

보정용 판정기는 그 속성 하나를 위해 작성된 루브릭을 가지고 읽는다. 루브릭은 응답에 담긴 모든 사실과 결과가 옳은지를 묻고, 5장에서 설명한 대로 길이, 어조, 문체, 서식은 무시하라고 판정기에 지시한다. 이 책의 자체 테스트 세트를 보정에 쓸 수도 있겠지만, 이 책에는 sablefile의 응답에 대한 사람 평가가 없다. 그래서 보정에는 공개된 행을 대신 사용하고, 그 대가로 전이 가정을 치른다. 데이터셋이 정확성에 대한 통과 기준선을 이 책에 제공하지는 않는다. 기준선은 이 책이 직접 정하며, 이 장의 모든 비율은 그 기준선에 비추어 읽어야 한다. 기준선이 달라지면 모든 비율이 움직이므로, 이 장을 다른 연구와 비교하려는 독자는 먼저 그 연구가 기준선을 어디에 두었는지 확인해야 한다.

보정 행은 고정된 시드로 추출한 데이터셋 검증 분할의 표본이다. 텍스트에 출력 가능한 ASCII 밖의 문자가 들어 있는 행은 추출 전에 제외했다. 추출은 각 분할에서 FAIL 행과 PASS 행을 약 45개씩 뽑으며, 프롬프트당 한 행만 남긴다. 따라서 기저율은 데이터셋에서 발견한 값이 아니라 샘플링으로 정해진 값이다. 표본은 dev와 held-out으로 나눈다. 같은 데이터셋에는 하나의 프롬프트에 대한 응답 쌍과 그 둘 사이의 사람 선호도 들어 있다. 선호 강도가 0인 쌍은 제외한다.

분할은 숫자를 어떻게 쓸 수 있는지를 결정한다. dev는 보정에 쓰는 비율을 포함해 이 책이 무엇이든 정하는 데 쓰는 분할이다. held-out은 나머지가 모두 고정된 뒤 이 장에서 한 번만 읽으며, 여기서는 held-out으로 아무것도 선택하지 않는다. held-out 수치는 이 장을 쓰기 전, 기록 확인 단계에서 처음 계산했다. 그 수치는 무엇을 고르기 위해 다시 계산하지 않고 당시 그대로 보고한다.

작업 규칙: 판정기가 답하는 질문을 위해 만들어진 레이블로 보정하거나, 그 질문과 얼마나 다른지를 본문에 밝혀라. 어떤 결과도 보기 전에 점수를 판정기의 통과 또는 실패로 바꾸는 규칙을 적어 두어라. 조정에 쓰는 분할과 한 번만 보고하는 분할을 분리해 두어라.

일치도와 카파

일치도는 판정자와 사람이 같은 판정을 내린 행의 비율이다. 한 판정이 우세할 때는 일치도가 오해를 부를 수 있다. 모든 응답을 통과시키는 판정자는 대부분이 PASS인 표본과 잘 일치하며, 일치도만으로는 그런 판정자와 신중한 판정자를 구별할 수 없다. 해결책은 두 판정자의 PASS 비율만으로 우연히 달성될 일치도가 얼마인지 따져 보고, 그만큼을 덜어 내는 것이다. 카파가 이 일을 한다. 통과 또는 실패를 판정하는 두 평가자에 대해, 카파는 관측된 일치도에서 우연 일치도를 뺀 값을 1에서 우연 일치도를 뺀 값으로 나눈 것이다. 이 공식은 McHugh의 카파 통계량 리뷰에 나온다. 두 평가자가 모든 행에서 일치하면 카파는 1이다.

calibration-agreement.py Python 3.12.15 · numpy 2.5.5 통과
"""How often the reference-free correctness judge agrees with the human ratings on the HelpSteer2 sample, and Cohen's kappafor the same counts, on dev, on held-out and on both together.Agreement alone reads higher than the judge's skill when most rows are one verdict, so the kappa line is the one to readagainst chance: the chance agreement printed beside it is what the judge would reach by guessing at its own PASS rate."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.calibration import agreement, chance_agreement, cohens_kappa, confusion, helpsteer2_judgmentsfrom lib.stats import pctfor label, split in (("all", None), ("dev", "dev"), ("held-out", "held-out")):    counts = confusion(helpsteer2_judgments(split))    print(f"agreement, {label}: {pct(counts.tp + counts.tn, counts.n)}")    # the chance figure is an expected rate, not a count, so it has no denominator beside it    print(f"chance agreement, {label}: {100 * chance_agreement(counts):.1f}%")    # kappa is printed with two decimals (plan section 6.5), not as a percentage    print(f"kappa, {label}: {cohens_kappa(counts):.2f}")
출력python calibration-agreement.py
agreement, all: 70.6% (127 of 180)
chance agreement, all: 50.3%
kappa, all: 0.41
agreement, dev: 71.1% (64 of 90)
chance agreement, dev: 50.2%
kappa, dev: 0.42
agreement, held-out: 70.0% (63 of 90)
chance agreement, held-out: 50.3%
kappa, held-out: 0.40

전체 행의 일치도는 70.6% (127 of 180)이다. 두 PASS 비율만으로 계산한 우연 일치도는 50.3%이다. 카파는 0.41이며, 소수점 이하 두 자리로 쓰고 퍼센트 기호를 붙이지 않는다. 카파는 비율이 아니라 자체 척도를 가진 통계량이기 때문이다. 일치도와 우연 일치도는 모두 백분율이므로 직접 비교할 수 있다. 카파는 이미 우연이 제거된 수치이므로, 우연을 넘어서는 판정자의 일치도로 읽어야 하는 것은 카파다.

카파는 −1에서 1까지의 값을 가진다. 우연 일치도 수준에서 0이고, 두 평가자가 우연이 예상하는 것보다 덜 자주 일치하면 음수가 된다. McHugh의 리뷰도 이를 언급한다.

세 수치는 순서대로 읽는다. 먼저 일치도를 읽고, 그 옆의 우연 수치를 읽은 다음, 카파를 읽는다. 일치도가 오르는데 우연 수치도 함께 오른다면, 그 상승은 판정자가 아니라 기저율에서 온 것일 수 있다.

두 분할도 같은 방식으로 읽는다. dev에서 일치도는 71.1% (64 of 90)이다. dev의 카파는 0.42이다. held-out에서 일치도는 70.0% (63 of 90)이고, 카파는 0.40이다.

기저율이 카파가 중요한 이유다. 한 판정이 행의 대부분을 차지하면 우연 일치도가 높아지고, 판정자는 두 판정을 제대로 구별하지 못하면서도 높은 일치도를 기록할 수 있다. 여기서는 추출한 표본에 PASS 행과 FAIL 행이 거의 같은 수만큼 들어 있으므로 우연 일치도가 절반 근처에 있다. dev에서 사람의 PASS 비율은 51.1% (46 of 90)이다. 표본이 한쪽으로 치우친 팀은 우연 일치도가 일치도에 가깝게 나올 것으로 예상해야 하며, 그러면 일치도가 높아 보여도 카파는 0 근처가 된다. 그러므로 카파를 먼저 읽어야 한다.

일치도는 사람의 레이블과 얼마나 가까운지를 측정하는 것이지, 응답이 옳은지를 측정하는 것이 아니다. 높은 일치도는 판정자의 판정이 사람의 판정과 맞는다는 뜻이며, 어시스턴트의 응답이 옳다는 뜻은 아니다. 카파는 일치도가 우연에서 얼마나 떨어져 있는지는 알려 주지만, 판정자가 어느 방향으로 틀리는지는 알려 주지 않는다. 그것을 알려면 다음 두 비율이 필요하다.

5장에서는 두 번째 보정 문구인 루브릭 B를 설명했다. ("calibration rubric" 표현과 통일) 보정 루브릭은 이제부터 루브릭 A라고 부르며, 거짓 주장을 하지 않는 응답은 "틀리지 않았다"고 말한다. 루브릭 B는 이를 고쳐 쓴 것으로, A에서 "틀리지 않았다"라고 한 자리에 "옳다"라고 쓰고 오해를 유발하는 점과 확신에 관한 항목을 뺀다. 루브릭 B는 dev에서만 기록되었다. 다음 예제는 같은 dev 행에서 두 문구를 나란히 놓는다.

rubric-b-agreement.py Python 3.12.15 · numpy 2.5.5 통과
"""How often the second rubric's verdicts agree with the human ratings on the HelpSteer2 sample, beside the first rubric's,on dev and on held-out, with kappa, TPR and TNR and the PASS rates of judge and humans.The second rubric was recorded on dev only, so its held-out line says so instead of printing a rate. The paired differenceis on dev alone: each dev row's agreement under rubric B minus its agreement under rubric A, bootstrapped over rows. Areply with no readable verdict is printed by row ID and left out; it is never counted as FAIL."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom dataclasses import replacefrom lib.calibration import cohens_kappa, confusion, helpsteer2_judgments, readable_verdictsfrom lib.prompts import HS2B_SHA256from lib.replay import ReplayModelfrom lib.stats import bootstrap_mean, interval_points, pctRUBRIC_B = "judge-helpsteer2-rubric-b"def report(name, split, judgments):    c = confusion(judgments)    print(f"agreement, {name}, {split}: {pct(c.tp + c.tn, c.n)}")    print(f"kappa, {name}, {split}: {cohens_kappa(c):.2f}")    print(f"TPR, {name}, {split}: {pct(c.tp, c.tp + c.fn)}")    print(f"TNR, {name}, {split}: {pct(c.tn, c.tn + c.fp)}")    print(f"judge PASS rate, {name}, {split}: {pct(c.tp + c.fp, c.n)}")    print(f"human PASS rate, {name}, {split}: {pct(c.tp + c.fn, c.n)}")def same(j):    return int(j.judge_pass == j.human_pass)base = {j.id: j for j in helpsteer2_judgments()}  # rubric A's verdicts and the human PASS for every row, by idrecorded = {item for item, _ in ReplayModel(RUBRIC_B, HS2B_SHA256).keys()}verdicts_b, unreadable = readable_verdicts(RUBRIC_B, sorted(recorded & base.keys()), HS2B_SHA256)rows_b = {i: replace(base[i], judge_pass=v == "PASS") for i, v in verdicts_b.items()}print(f"unreadable, rubric B: {len(unreadable)} of {len(recorded)} replies")for item_id, _ in unreadable:    print(f"unreadable, rubric B, row {item_id}: excluded, not counted as FAIL")for split in ("dev", "held-out"):    report("rubric A", split, [j for j in base.values() if j.split == split])    b = [j for j in rows_b.values() if j.split == split]    if b:        report("rubric B", split, b)    else:        print(f"rubric B, {split}: no readable replies recorded")dev_ids = [i for i in verdicts_b if base[i].split == "dev"]diffs = [same(rows_b[i]) - same(base[i]) for i in dev_ids]  # the same row under both rubricslo, hi = bootstrap_mean(diffs)  # level 0.95 for one comparison; seed SEED, 2,000 resamplesn = len(dev_ids)print(f"paired difference, dev: {100 * sum(diffs) / n:+.1f} points, 95% interval {interval_points(lo, hi)}, n = {n}")reading = "rubric B better" if lo > 0 else "rubric B worse" if hi < 0 else f"no difference detected at n = {n}"caveat = ", on dev only with no held-out run" if lo > 0 or hi < 0 else ""  # a dev-only difference carries its caveatprint(f"paired difference, dev, reading: {reading}{caveat}")
출력python rubric-b-agreement.py
unreadable, rubric B: 0 of 90 replies
agreement, rubric A, dev: 71.1% (64 of 90)
kappa, rubric A, dev: 0.42
TPR, rubric A, dev: 80.4% (37 of 46)
TNR, rubric A, dev: 61.4% (27 of 44)
judge PASS rate, rubric A, dev: 60.0% (54 of 90)
human PASS rate, rubric A, dev: 51.1% (46 of 90)
agreement, rubric B, dev: 74.4% (67 of 90)
kappa, rubric B, dev: 0.49
TPR, rubric B, dev: 84.8% (39 of 46)
TNR, rubric B, dev: 63.6% (28 of 44)
judge PASS rate, rubric B, dev: 61.1% (55 of 90)
human PASS rate, rubric B, dev: 51.1% (46 of 90)
agreement, rubric A, held-out: 70.0% (63 of 90)
kappa, rubric A, held-out: 0.40
TPR, rubric A, held-out: 82.6% (38 of 46)
TNR, rubric A, held-out: 56.8% (25 of 44)
judge PASS rate, rubric A, held-out: 63.3% (57 of 90)
human PASS rate, rubric A, held-out: 51.1% (46 of 90)
rubric B, held-out: no readable replies recorded
paired difference, dev: +3.3 points, 95% interval [-1.1, +7.8] points, n = 90
paired difference, dev, reading: no difference detected at n = 90

dev에서는 차이가 나타나지 않았다. 루브릭 B의 일치도는 74.4% (67 of 90)이다. 같은 행에서 루브릭 A의 일치도는 71.1% (64 of 90)이다. 짝지은 차이는 +3.3 points, 95% interval [-1.1, +7.8] points, n = 90이다. 코드는 각 dev 행에 대해 문구가 사람과 일치하면 1점, 그렇지 않으면 0점을 매긴다. 짝지은 차이는 루브릭 B의 점수에서 루브릭 A의 점수를 뺀 값을 dev 행 전체에 대해 평균한 것이며, 그 구간은 이 행들에 대한 부트스트랩으로 구한다. 이 구간에 대한 예제의 판독은 no difference detected at n = 90이다.

구간이 0을 포함하므로 dev 추정치로는 루브릭 B가 더 낫다는 것이 드러나지 않는다. 루브릭 B에는 held-out 실행이 없으므로, 그 dev 추정치를 확인해 줄 두 번째 검증이 없다. 읽을 수 없는 응답은 0 of 90 replies이므로 제외된 응답은 없다.

작업 규칙: 일치도는 카파와 나란히 보고하고, 카파는 그 옆에 인쇄된 우연 수치와 견주어 읽는다. 모든 수치에 루브릭과 분할을 명시하여 두 문구가 하나로 읽히지 않게 한다. 한 문구가 더 낫다고 말하는 것은 짝지은 구간의 하한이 0보다 클 때만 하고, 그것도 held-out에서, 또는 dev에서라면 단서를 주장 옆에 붙여서만 한다. 구간이 0에 걸치면, 가진 n으로는 차이가 탐지되지 않았다고 말하고, 더 높은 점추정치를 주장으로 바꾸지 않는다.

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

True positive and true negative rates

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

Agreement and kappa say how often the judge agrees with the humans. They do not say which way it errs. The two rates that do are the true positive rate and the true negative rate. The true positive rate, TPR, is the share of human PASS rows that the judge passes. The true negative rate, TNR, is the share of human FAIL rows that the judge fails. A judge that passes too much has a high TPR and a low TNR, because its errors are false passes. A judge that fails too much is the reverse. The correction in the next section needs both rates, since each one fixes a different error.

tpr-tnr.py Python 3.12.15 · numpy 2.5.5 통과
"""The judge's true positive rate and true negative rate on the HelpSteer2 sample, with the counts beside each, on dev, onheld-out and on both together.PASS is the positive class: TPR is the share of human PASS rows the judge passes, and TNR the share of human FAIL rows itfails. The two rates are the judge's error profile; a lenient judge has a high TPR and a low TNR."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.calibration import confusion, helpsteer2_judgmentsfrom lib.stats import pct# PASS is the positive class: the rows a human rated PASS are the positives, and TPR is taken over them.print("positive class: PASS")for label, split in (("all", None), ("dev", "dev"), ("held-out", "held-out")):    counts = confusion(helpsteer2_judgments(split))    print(f"TPR, {label}: {pct(counts.tp, counts.tp + counts.fn)}")    print(f"TNR, {label}: {pct(counts.tn, counts.tn + counts.fp)}")
출력python tpr-tnr.py
positive class: PASS
TPR, all: 81.5% (75 of 92)
TNR, all: 59.1% (52 of 88)
TPR, dev: 80.4% (37 of 46)
TNR, dev: 61.4% (27 of 44)
TPR, held-out: 82.6% (38 of 46)
TNR, held-out: 56.8% (25 of 44)

Here PASS is the positive class, so TPR is taken over the human PASS rows and TNR over the human FAIL rows. Each rate prints its counts beside it, so a reader can see how many rows it rests on.

On all rows, TPR is 81.5% (75 of 92). TNR is 59.1% (52 of 88). The judge passes most of the replies that humans passed, and it also passes a fair share of the replies humans failed. The weaker of the two rates is TNR, which makes this judge lenient.

The direction matters for anyone who reads a pass rate, and it depends on where the rate sits. The pass-rate correction in the next section leaves a rate unchanged at the crossover point, p* = (1 − TNR) / (2 − TPR − TNR). Below p* the correction lowers the rate, and above p* it raises the rate. For a lenient judge, p* sits high, so a reported rate below it reads too high and a rate above it reads too low. On dev, the crossover point is 66.4% (TPR 80.4%, TNR 61.4%). Knowing where a rate sits against that point tells a team which way its reported number leans, before any correction is applied. Agreement alone would hide this. Two judges can agree with the humans to the same degree and still differ in which error they make more often, and the rates they report would differ with it.

On dev, TPR is 80.4% (37 of 46), and TNR is 61.4% (27 of 44). On held-out, TPR is 82.6% (38 of 46), and TNR is 56.8% (25 of 44). The held-out split lands close to dev on both rates, with TNR a few points lower.

Each rate is taken over one group of human labels, and each split has few enough rows that another sample could move the rates. This chapter prints no interval for TPR or TNR. Read the rates as the judge's error on this sample, not as its error in general.

Working rule: Report TPR and TNR together, with their counts, and say which way the judge errs. Take the rates a correction uses from dev alone, and quote both beside any corrected rate. Report held-out once, after the choices are made, and keep it out of every choice.

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

Correcting a pass rate

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

The observed pass rate counts two kinds of verdict: true passes the judge caught, and false passes it let through. The correction tries to undo both at once. Given the judge's TPR and TNR, it solves for the true share of passes that would produce the observed rate. The book writes it as (observed + TNR - 1) / (TPR + TNR - 1). Rogan and Gladen (1978) address the same problem for screening tests, and their abstract says that adjustments of this kind are given. The book has read only that abstract, so the formula here is the book's own statement of the correction, as its code computes it, and not a quotation from the paper.

The correction has a limit. It divides by TPR + TNR - 1. A judge whose two rates sit near what chance would give has a denominator near zero, and then small errors in either rate become large swings in the corrected rate. The book's code refuses to correct when that denominator is below 0.1, and it raises an error instead of printing a rate. The run below stays well clear of that floor. In practice a team does four things in order: measure TPR and TNR on a calibration set kept apart from the set it will correct, check that the denominator clears the floor, apply the correction to the observed rate over the readable replies, and write the transfer assumption beside the result.

corrected-pass-rate.py Python 3.12.15 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""The baseline's answer-judge pass rate over the test items the judge gave a readable verdict, corrected for the judge's errorswith TPR and TNR from dev only. The corrected rate is printed beside the observed rate and the two rates the correction uses.One judge reply has no PASS or FAIL on its first line. It is left out of the rate and printed by name, never counted as aFAIL. The TPR and TNR come from HelpSteer2, where the judge rates other models' answers without a reference. This judge readsthe answers against a written reference. The correction assumes the two error profiles transfer; nothing here tests that.The last lines apply the same correction to the calibration set itself: the rates are measured on those same rows, so thatcheck shows the arithmetic, not how well the correction generalises."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.calibration import (    confusion,    corrected_pass_rate,    crossover_pass_rate,    helpsteer2_judgments,    readable_verdicts,    tnr,    tpr,)from lib.judging import passedfrom lib.prompts import REF_SHA256from lib.stats import pctfrom lib.testset import load_itemsitems = load_items()  # all 120 items of the test set, dev and held-out togetherfound, unreadable = readable_verdicts("judge-answers-baseline", [item.id for item in items], REF_SHA256)details = "".join(f' ({item_id}, "{first}")' for item_id, first in unreadable)print(f"unreadable verdicts: {len(unreadable)}{details}")  # left out of the rate below, not counted as FAILpasses = int(passed(found).sum())  # found is keyed in sorted id orderobserved = passes / len(found)print(f"observed pass rate, readable items: {pct(passes, len(found))}")dev = confusion(helpsteer2_judgments("dev"))  # the only rows the correction's TPR and TNR may come fromprint(f"TPR, dev: {pct(dev.tp, dev.tp + dev.fn)}")print(f"TNR, dev: {pct(dev.tn, dev.tn + dev.fp)}")# Below this observed rate the correction lowers the rate; above it, the correction raises it.crossover = crossover_pass_rate(tpr(dev), tnr(dev))print(f"crossover point, dev: {100 * crossover:.1f}% (TPR {100 * tpr(dev):.1f}%, TNR {100 * tnr(dev):.1f}%)")corrected = corrected_pass_rate(observed, tpr(dev), tnr(dev))  # refused if TPR + TNR - 1 is below 0.1print(f"corrected pass rate: {100 * corrected:.1f}%")# The sanity check: the same correction on the calibration set, with rates measured on those same rows. It checks the# arithmetic, not transfer to the answers: it should return the human PASS rate, and it does by construction.calibration = confusion(helpsteer2_judgments())judge_rate = (calibration.tp + calibration.fp) / calibration.nprint(f"calibration set, judge PASS rate: {pct(calibration.tp + calibration.fp, calibration.n)}")print(f"calibration set, corrected judge PASS rate: {100 * corrected_pass_rate(judge_rate, tpr(calibration), tnr(calibration)):.1f}%")print(f"calibration set, human PASS rate: {pct(calibration.tp + calibration.fn, calibration.n)}")calibration_crossover = crossover_pass_rate(tpr(calibration), tnr(calibration))  # the same test, on the same rowsprint(f"crossover point, calibration set: {100 * calibration_crossover:.1f}% "      f"(TPR {100 * tpr(calibration):.1f}%, TNR {100 * tnr(calibration):.1f}%)")
출력python corrected-pass-rate.py
unreadable verdicts: 1 (q-0043, "VERDICT: PARTIAL")
observed pass rate, readable items: 76.5% (91 of 119)
TPR, dev: 80.4% (37 of 46)
TNR, dev: 61.4% (27 of 44)
crossover point, dev: 66.4% (TPR 80.4%, TNR 61.4%)
corrected pass rate: 90.5%
calibration set, judge PASS rate: 61.7% (111 of 180)
calibration set, corrected judge PASS rate: 51.1%
calibration set, human PASS rate: 51.1% (92 of 180)
crossover point, calibration set: 68.9% (TPR 81.5%, TNR 59.1%)

The input is the baseline's answer-judge verdicts for the test items, all 120 of them, dev and held-out together. One reply had no readable verdict, because its first line was not PASS or FAIL. The example prints it by name and leaves it out of the rate, since a reply the judge could not read is not a FAIL. Chapter 5 explains the two ways the code reads an unreadable verdict. The line for it reads 1 (q-0043, "VERDICT: PARTIAL"). Chapter 1 defines the pass rate over every item in the set. This rate is over the readable items, so it departs from that definition by the one reply left out.

The observed pass rate over the readable items is 76.5% (91 of 119). The correction uses TPR and TNR from dev, and those are the only rows it may use. Its TPR on dev is 80.4% (37 of 46). Its TNR on dev is 61.4% (27 of 44).

The corrected rate is 90.5%. The corrected rate estimates the share of sablefile's replies that a person would pass, under the book's correctness cut. It is not the judge's pass rate, which is the observed rate above, and it is not the assistant's accuracy. The estimate holds only if the judge's errors on sablefile's answers match its errors on HelpSteer2 rows. That is the transfer assumption, and the TPR and TNR above come from a reference-free judge rating other models' responses, while the answer judge checks sablefile's replies against a reference.

The corrected rate is higher than the observed rate, and the crossover point shows why. The observed rate sits above the crossover point, where the judge reads low. At that rate the judge's misses on true passes outweigh its false passes, so the correction raises it.

The result is also close to the code's ceiling. The code clips the corrected rate to the range from 0 to 1. The unclipped value passes 1 exactly when the observed rate is above TPR, because then the numerator is larger than the denominator. Here the observed rate sits under TPR by less than four points. If two of the dev PASS rows the judge passed had been failed instead, TPR would fall below the observed rate, and the corrected rate would print 100.0%.

Working rule: Correct a pass rate only with TPR and TNR measured on a calibration set. Quote both beside the corrected rate, refuse when the denominator is small, and say in the same paragraph what the correction assumes. The next section gives the interval and the one-row moves that go beside any corrected rate.

행 하나가 보정된 비율을 얼마나 움직이는가

correction-sensitivity.py Python 3.12.15 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""How much the corrected pass rate of corrected-pass-rate depends on its inputs. A 95% bootstrap interval resamples both thedev calibration rows and the readable test items, with the book's fixed seed. It prints the share of resamples that reachthe 100% cap, and the corrected rate when one dev row moves TPR or TNR up or down. Only dev rows set the correction's rates."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom dataclasses import replacefrom lib.calibration import confusion, correction_interval, corrected_pass_rate, helpsteer2_judgments, readable_verdicts, tnr, tprfrom lib.judging import passedfrom lib.prompts import REF_SHA256from lib.stats import RESAMPLES, interval_pct, pctfrom lib.testset import load_itemsitems = load_items()  # all 120 items of the test set, as in corrected-pass-ratefound, _ = readable_verdicts("judge-answers-baseline", [item.id for item in items], REF_SHA256)observed = int(passed(found).sum()) / len(found)dev_rows = helpsteer2_judgments("dev")dev = confusion(dev_rows)lo, hi, capped, refused = correction_interval(dev_rows, passed(found))  # resamples the dev rows and the readable itemsprint(f"corrected pass rate, 95% interval: {interval_pct(lo, hi)}")print(f"resamples at the 100% cap: {pct(capped, RESAMPLES)}")print(f"resamples refused, TPR + TNR - 1 below 0.1: {pct(refused, RESAMPLES)}")# One dev row moved: a human PASS row judged the other way changes TPR; a human FAIL row changes TNR.moved = {    "TPR one row higher": replace(dev, tp=dev.tp + 1, fn=dev.fn - 1),    "TPR one row lower": replace(dev, tp=dev.tp - 1, fn=dev.fn + 1),    "TNR one row higher": replace(dev, tn=dev.tn + 1, fp=dev.fp - 1),    "TNR one row lower": replace(dev, tn=dev.tn - 1, fp=dev.fp + 1),}for label, counts in moved.items():    print(f"corrected, {label}: {100 * corrected_pass_rate(observed, tpr(counts), tnr(counts)):.1f}%")
출력python correction-sensitivity.py
corrected pass rate, 95% interval: [62.1%, 100.0%]
resamples at the 100% cap: 29.5% (590 of 2000)
resamples refused, TPR + TNR - 1 below 0.1: 0.1% (2 of 2000)
corrected, TPR one row higher: 86.0%
corrected, TPR one row lower: 95.5%
corrected, TNR one row higher: 91.0%
corrected, TNR one row lower: 90.0%

예제는 개발 행과 읽을 수 있는 항목을 모두 이 책의 고정 시드로 2,000번 재표집하고, 보정된 비율의 퍼짐을 읽는다. 95% 구간은 [62.1%, 100.0%]이다. TPR과 TNR이 각각 수십 개의 개발 행에 의존하므로 구간이 넓고, 구간의 상한은 상한값(cap) 자체이다. 일부 재표집은 상한값에 도달하며, 그 비율은 29.5% (590 of 2000)이다. 분모가 0.1 미만이어서 거부된 재표집은 0.1% (2 of 2000)이고, 구간은 나머지를 대상으로 구한다.

행 하나를 옮겼을 때의 변화는 다음과 같다. 사람이 통과로 판정한 개발 행 하나를 심사자가 FAIL이 아니라 PASS로 판정했더라면(실제로는 FAIL로 판정한 경우) TPR은 한 행만큼 높아지고, 보정된 비율은 86.0%가 된다. 그러한 행 하나를 FAIL로 판정했다면 TPR은 한 행만큼 낮아지고, 보정된 비율은 95.5%이 된다. TNR의 경우, 사람은 불합격으로 판정했고 심사자가 통과로 판정한 개발 행 하나를 FAIL로 판정했다면 비율은 91.0%로 바뀌고, PASS로 판정했다면 90.0%로 바뀐다. 주의해서 볼 비율은 TPR이다. TPR은 행 하나가 답을 4~5포인트 움직이는 반면, TNR은 행 하나가 약 0.5포인트만 움직인다.

이 구간은 개발 행과 읽을 수 있는 항목의 표집에 따른 변동을 포괄한다. 전이 가정은 포괄하지 않는다. sablefile의 응답에서 오류 양상이 다른 심사자라면 재표집이 보여 주는 것보다 비율이 더 크게 움직일 수 있다.

작업 규칙: 보정된 비율은 이 책이 비율에 쓰는 부트스트랩 구간, 상한값에 도달한 재표집의 비율, 그리고 행 하나를 옮겼을 때의 변화와 함께 제시하여, 독자가 개별 행이 어디까지 영향을 주는지 볼 수 있게 한다.

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

The transfer assumption

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

The TPR and TNR above come from rows where the judge read other models' responses with no reference, under the correctness rubric, and the PASS line there is HelpSteer2 correctness of 3 or more. The answer judge reads sablefile's replies against a written reference, and a PASS there means the reply agrees with the reference, with a correct decline counting as a pass. The two judges answer different questions about what right means. The transfer assumption is that the judge's miss rate on human passes, and its pass-through rate on human fails, are the same on sablefile's replies as on the HelpSteer2 rows. Nothing in this chapter tests that. The correction holds only if the differences in input, replies, questions and PASS criterion leave the error profile unchanged. Chapter 5 sets out the difference between a judge with a reference and one without.

The last lines of the same example apply the correction to the calibration rows, with rates taken from those rows. On those rows, the judge's PASS rate is 61.7% (111 of 180). Its crossover point is 68.9% (TPR 81.5%, TNR 59.1%), and the judge's rate sits below it, so the correction lowers the rate. The corrected judge PASS rate is 51.1%. The human PASS rate is 51.1% (92 of 180).

The corrected judge rate returns the human rate. That follows from the algebra, because the rates were measured on those same rows. The check confirms that the arithmetic is right. It says nothing about whether the correction applies to sablefile, and a reader should not take it as evidence for the transfer.

The better fix is labels on the book's own replies. The book has none, because no person has rated sablefile's replies. A reader with such labels should calibrate on them, keeping a split apart from the set being corrected, as this chapter keeps dev apart from held-out. That would remove most of the transfer assumption, where the public rows only pay for it.

Working rule: Write the transfer assumption beside every corrected rate, in the same paragraph, and name the difference between the calibration judge and the judge the rate describes. Check the arithmetic on the rows the rates came from, and say that such a check does not test transfer. Until human labels on the answers the rate describes exist and have been checked against the judge, call the corrected rate an estimate that holds if the assumption does.

쌍대 보정

쌍대 판정기는 각 응답에 합격이나 불합격을 매기는 대신 두 응답을 읽고 더 나은 쪽을 고른다. 사람 쪽 기준은 한 프롬프트에 대한 두 응답 사이에서 HelpSteer2가 제공하는 선호이다. 쌍대 판정기에는 알려진 약점이 있다. 어느 응답이 A 자리에 오고 어느 응답이 B 자리에 오는지가 선택을 좌우할 수 있다. 5장은 이 책이 판정기에 각 쌍을 두 순서로 모두 묻는 이유를 설명하고, 7장은 위치 때문에 생기는 순서 변경을 분석한다. 이 절은 두 순서를 모두 센 경우에 사람의 선호와의 일치도가 어떻게 나타나는지를 다룬다. 여기서 출력하는 순서 변경 쌍의 수는 5장에서 출력한 것과 같으며, 격차를 설명하기 위해서만 여기에 보인다.

각 쌍은 두 응답과 그 사이의 사람 선호가 붙은 HelpSteer2 프롬프트이다. 동점인 쌍은 제외했으므로 모든 쌍에는 사람이 고른 쪽이 있다. 사람이 한쪽을 골랐는데 판정기가 두 응답이 같다고 답했다면, 판정기의 TIE는 불일치로 센다. 한 순서만 보면 판정기가 어느 글자를 선호했는지에 따라 비율이 달라지므로, 한 순서만 보고하는 팀은 응답의 위치에 따라 움직일 수 있는 수치를 보고하는 셈이다. 두 순서를 모두 세면 이런 자유가 사라지는 대신 수치가 낮아진다. 쌍대 판정기에는 더 엄격한 비율을 보고하고, 한 순서만 센 비율은 두 비율 사이의 격차를 보는 진단용으로만 읽을 것을 권한다.

예제를 실행하기 전에, 두 순서 모두에서 사람이 고른 응답을 골랐을 때만 맞는 것으로 세는 쌍의 점수가 어느 한 순서만 본 점수보다 높을지 낮을지 예측해 보라. 그런 다음 출력과 비교해 확인한다.

pairwise-agreement.py Python 3.12.15 · numpy 2.5.5 통과
"""How often the pairwise judge's verdict agrees with the human preference on each HelpSteer2 pair, dev and held-out apart.Three rates: the A,B order alone, the B,A order alone (both mapped back to the original responses), and both orders together,where a pair counts only when both orders pick the human's response. A flipped pair (the same letter won both times) cannever count in the last rate, so the flipped count printed beside it is the number of misses that come from position.Each single-order rate uses the pairs whose verdict in that order is readable; a TIE is judged and is not a pick, so it isa miss. The interval is the 95% percentile bootstrap over pairs of the both-orders rate."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.judging import both_orders, human_pairsfrom lib.stats import bootstrap_mean, interval_pct, pctAB = "judge-hs2-pairs-ab"BA = "judge-hs2-pairs-ba"pairs = human_pairs()  # all 150 pairs, sorted by id, each with its split and the human's pickorders = both_orders(AB, BA, list(pairs))  # both recordings read for every pair, sorted by idfor split in ("dev", "held-out"):    rows = [o for o in orders if pairs[o.pair_id].split == split]    human = {o.pair_id: pairs[o.pair_id].preferred for o in rows}    ab = [o.ab == human[o.pair_id] for o in rows if o.ab is not None]    ba = [o.ba == human[o.pair_id] for o in rows if o.ba is not None]    both = [o.ab == human[o.pair_id] and o.ba == human[o.pair_id] for o in rows if o.ab is not None and o.ba is not None]    flipped = sum(1 for o in rows if o.kind == "flipped")    print(f"agreement, A,B order, {split}: {pct(sum(ab), len(ab))}")    print(f"agreement, B,A order, {split}: {pct(sum(ba), len(ba))}")    print(f"agreement, both orders, {split}: {pct(sum(both), len(both))}; flipped pairs: {flipped}")    lo, hi = bootstrap_mean([float(hit) for hit in both])  # 95% interval over pairs, the level for one comparison    print(f"95% interval, both orders, {split}: {interval_pct(lo, hi)}")
출력python pairwise-agreement.py
agreement, A,B order, dev: 77.3% (58 of 75)
agreement, B,A order, dev: 73.3% (55 of 75)
agreement, both orders, dev: 65.3% (49 of 75); flipped pairs: 15
95% interval, both orders, dev: [53.3%, 76.0%]
agreement, A,B order, held-out: 74.7% (56 of 75)
agreement, B,A order, held-out: 76.0% (57 of 75)
agreement, both orders, held-out: 62.7% (47 of 75); flipped pairs: 19
95% interval, both orders, held-out: [52.0%, 73.3%]

두 순서를 모두 세면 일치도는 어느 한 순서만 센 경우보다 낮고, 그 격차는 순서가 바뀐 쌍에서 나온다. dev에서 A,B 순서만으로는 77.3% (58 of 75)이다. B,A 순서만으로는 73.3% (55 of 75)이다. 두 순서를 모두 세면 더 엄격한 비율인 65.3% (49 of 75); flipped pairs: 15이 된다.

세미콜론 뒤의 수는 순서가 바뀐 쌍의 수이며, 예제의 출력에는 flipped로 표시된다. 5장이 정의하는 순서 변경 쌍은 판정이 응답이 아니라 위치를 따른 쌍이다. 순서 변경 쌍은 두 순서 모두 맞힘 비율에 결코 들어갈 수 없으므로, 거기서는 하나하나가 불일치이다.

held-out 분할에서도 같은 양상이 나타난다. A,B 순서는 74.7% (56 of 75), B,A 순서는 76.0% (57 of 75), 두 순서를 모두 세면 62.7% (47 of 75); flipped pairs: 19이다.

쌍을 단위로 한 두 순서 모두 맞힘 비율의 구간은 dev에서 [53.3%, 76.0%]이다. held-out에서는 [52.0%, 73.3%]이다. 각 분할의 쌍 수가 적기 때문에 이 구간은 넓다. 유효한 해석은 이 양상 자체이다. 위치에 따라 선택을 바꾸는 판정기는 어느 한 순서만으로는 사람과 일치한다고 읽을 수 없다.

이 장을 마치면 독자는 우연을 넘어서는 판정기의 일치도, 이 표본에서의 누락과 잘못된 통과, 그리고 전이 가정을 옆에 적은 보정된 통과율을 측정할 수 있다. 이 측정은 sablefile의 응답이 아니라 공개된 행에 근거하며, 두 순서로 센 쌍대 판정기도 여전히 위치 때문에 쌍을 잃는다. 7장은 이 책 자체의 기록에서 판정기가 드러내는 한계를 위치부터 시작해 시험하며, 독자가 판정을 언제 그만 신뢰해야 하는지 배우는 곳이다.

작업 규칙: 판정기가 두 응답을 비교할 때는 두 순서로 모두 실행하고, 두 방향으로 센 일치도를 순서 변경 쌍과 함께 보고한다. 한 순서만 센 비율을 판정기가 사람과 일치하는 정도로 읽어서는 안 된다. 쌍을 단위로 한 구간을 보고하고, 순서 변경 쌍은 위치 때문에 치르는 비용이므로 불일치로 센다고 밝힌다.

이 판의 이 장

2026.11.3판예제 통과 2026년 11월 21이 장에서 6개 예제개 중 6개가 통과한다

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

이 절 인용

형식

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

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

이 페이지의 내용

11장 중 6장: 심사자의 오류를 사람의 평가와 대조해 측정하고, 통과율을 보정한다

  1. 사람의 평가와 그 성격
  2. 일치도와 카파
  3. True positive and true negative rates
  4. Correcting a pass rate
  5. 행 하나가 보정된 비율을 얼마나 움직이는가
  6. The transfer assumption
  7. 쌍대 보정

맨 위로 돌아가기전체 장