Le jugement par modèle

Ce que vous saurez faire

Laissez un modèle noter de nombreuses réponses, mais mesurez d’abord ses accords et ses désaccords avec les personnes. Puis consignez les cas où il ne doit jamais décider seul.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 35 minutes

Ce que vous devez savoir

• La grille de Larkfield, présentée dans Rédiger une grille d’évaluation utilisable.
• Le pourcentage d’accord, le kappa de Cohen et vos propres notes dans my_ratings.csv, présentés dans Calibrer les évaluateurs.

Ce qu’il vous faut

• Votre projet à la fin de la leçon précédente : python -m pytest donne 21 passed (21 tests réussis).
• Une connexion Internet pour un seul pip install.

Vous n’avez besoin ni de compte ni de clé. Chaque jugement de cette leçon a été enregistré une fois à partir d’un vrai modèle, et le projet le rejoue. Un juge en direct, sur votre ordinateur, est facultatif dans la prochaine leçon.

Un nouvel auxiliaire d’enseignement

Une professeure a 300 dissertations à corriger et embauche un auxiliaire d’enseignement. Avant de se fier à ses notes, elle corrige elle-même 20 dissertations et compare. La plupart des notes concordent. Mais elle remarque trois habitudes. Il donne plus de points aux longues dissertations. Quand il compare deux dissertations, il préfère souvent celle qu’il a lue en deuxième. Et il est indulgent envers les dissertations écrites dans son propre style.

Elle ne le congédie pas. Elle consigne les cas où ses notes sont assez bonnes et ceux où elle lit elle-même chaque dissertation. Cela comprend chaque dissertation en échec et chaque dissertation pouvant impliquer de la tricherie. Puis elle vérifie de nouveau ses notes chaque trimestre.

Le problème : trop de réponses pour les personnes

Une personne a besoin d’environ une minute pour noter une réponse avec la grille. Les cas de développement et les cas réservés comptent 200 billets de soutien. Deux systèmes donnent 400 réponses, donc une comparaison prend presque une journée à un évaluateur. L’équipe d’Omar veut essayer une nouvelle requête chaque semaine.

Tomás a une solution : « Laissons un modèle les lire. » Un juge modèle est un modèle de langage qui lit une réponse avec des consignes, comme une grille. Il renvoie une note ou un choix. Cette approche est souvent appelée LLM-as-a-judge (LLM utilisé comme juge). Il lit 400 réponses en quelques minutes, pour environ un dollar.

Mais un juge est un instrument de mesure, comme un nouvel évaluateur. Avant de lui faire confiance, vous le vérifiez de la même façon : sur un échantillon noté par des personnes.

L’idée : calibrer le juge comme un évaluateur

Il existe deux types courants de juges modèles.

• Un juge avec référence note une réponse de 1 à 5, avec la grille et les notes de référence du cas. Il répond à la question : « Cette réponse est-elle bonne pour ce cas? »
• Un juge par paires lit deux réponses au même billet et choisit la meilleure, ou déclare une égalité. Il ne reçoit aucune note de référence. Il répond à la question : « Quelle réponse l’agent devrait-il utiliser comme point de départ? »

Les deux types suivent la même boucle de calibration que les évaluateurs humains. Le juge note l’échantillon que les personnes ont noté. Vous comparez l’accord et le kappa, puis décidez où le juge est assez bon.

La boucle de révision humaine et de calibration du juge modèle. Les personnes fixent la norme; le juge mérite sa place une question à la fois. On le vérifie de nouveau après chaque changement.

Description textuelle du diagramme

1. Les personnes notent un échantillon fixe avec la grille, chacune de son côté.
2. Elles comparent et discutent. La grille devient plus claire.
3. Le juge modèle note le même échantillon.
4. Comparez le juge aux personnes : accord, kappa et éléments où ils sont en désaccord.
5. Le juge est-il assez bon pour cette question? Sinon, changez sa requête ou son modèle, ou gardez des personnes pour cette question. Réessayez à partir de l’étape 3.
6. Si oui, utilisez le juge pour cette question. Une personne révise ce que le juge ne peut pas juger.
7. Quand quelque chose change (le modèle, la requête, la grille ou les cas), vérifiez de nouveau à partir de l’étape 3.

Notez « pour cette question ». Un juge peut bien répondre à « cette réponse est-elle mauvaise? » et mal répondre à « vaut-elle 4 ou 5? ». Vous mesurez chaque question séparément.

Ajouter les juges au projet

Les juges ont besoin de quelques nouveaux fichiers : leur code, les requêtes, l’adaptateur qui communique avec un modèle et les jugements enregistrés. Ils ont aussi besoin des réponses enregistrées du candidat, qui arrivent maintenant. Un nouveau paquet, openai, sert au juge en direct facultatif.

1. Dans le dossier du projet, avec l’environnement activé, définissez de nouveau la variable S si vous avez ouvert un nouveau terminal. Faites comme dans la leçon 1. Puis copiez les nouvelles dépendances et installez-les :

   macOS

   cp $S/requirements.txt .
   python -m pip install -r requirements.txt

   Windows

   Copy-Item $S\requirements.txt .
   python -m pip install -r requirements.txt

   Linux

   cp $S/requirements.txt .
   python -m pip install -r requirements.txt

   La dernière ligne :

   Successfully installed anyio-4.15.1 h11-0.16.0 httpcore2-2.13.1 httpx2-2.13.1 idna-3.20 jiter-0.17.0 openai-3.27.0 sniffio-1.3.1 truststore-0.10.4

2. Copiez les jugements enregistrés, les nouvelles exécutions, le code des juges, les requêtes, l’exemple de paramètres et les tests :

   macOS

   cp -R $S/recordings .
   cp $S/outputs/*.jsonl $S/outputs/runs.json outputs/
   cp $S/harness/judge.py $S/harness/providers.py $S/harness/config.py $S/harness/costs.py harness/
   cp $S/harness/prompts/* harness/prompts/
   cp $S/.env.example .
   cp $S/tests/test_judge.py $S/tests/test_providers.py $S/tests/test_criteria.py tests/

   Windows

   Copy-Item -Recurse $S\recordings .
   Copy-Item $S\outputs\*.jsonl, $S\outputs\runs.json outputs\
   Copy-Item $S\harness\judge.py, $S\harness\providers.py, $S\harness\config.py, $S\harness\costs.py harness\
   Copy-Item $S\harness\prompts\* harness\prompts\
   Copy-Item $S\.env.example .
   Copy-Item $S\tests\test_judge.py, $S\tests\test_providers.py, $S\tests\test_criteria.py tests\

   Linux

   cp -R $S/recordings .
   cp $S/outputs/*.jsonl $S/outputs/runs.json outputs/
   cp $S/harness/judge.py $S/harness/providers.py $S/harness/config.py $S/harness/costs.py harness/
   cp $S/harness/prompts/* harness/prompts/
   cp $S/.env.example .
   cp $S/tests/test_judge.py $S/tests/test_providers.py $S/tests/test_criteria.py tests/

3. Exécutez les tests :

   python -m pytest

   La dernière ligne :

   ============================== 34 passed in 0.33s ==============================

4. Listez les exécutions :

   python -m harness runs

   La sortie :

   baseline-v2-chat-small-r1-b6a2b9            271 cases  contaminated, dev, holdout gpt-6-luna-2026-09-22  started 2026-10-09T14:56:12-04:00
   candidate-v3-chat-small-r1-31b45f           271 cases  contaminated, dev, holdout gpt-6-luna-2026-09-22  started 2026-10-09T15:01:11-04:00
   strong-v2-chat-strong-r1-160302             102 cases  dev                        gpt-6.1-sol-2026-09-29  started 2026-10-09T15:34:30-04:00

   Il y a maintenant trois exécutions : la référence de base, le candidat (requête v3, même modèle) et la requête v2 sur le modèle plus puissant, utilisée ci-dessous.

Par défaut, les juges utilisent un fournisseur simulé. Il trouve le jugement enregistré pour chaque requête et le renvoie, sans réseau ni clé. Le cours a enregistré les jugements avec deux modèles sur Azure : chat-small (gpt-6-luna) et chat-strong (gpt-6.1-sol). Les modèles changent vite, et une nouvelle version noterait certaines réponses autrement. Les chiffres présentés ici sont un instantané du 9 octobre 2026; la méthode de vérification reste valable.

Le juge avec référence

Notez chaque réponse de développement de la référence de base, puis du candidat :

python -m harness judge baseline
python -m harness judge candidate

La sortie :

T-81040: no verdict: the provider's content filter refused the judge request (jailbreak detected: True)
chat-strong judge (judge_reference_v1) on baseline-v2-chat-small-r1-b6a2b9, dev: 101 replies scored
scores: 1: 0  2: 2  3: 12  4: 25  5: 62 | mean 4.46 | critical: 0
agreement with the code checks (bad = critical or score 1-2 / a criterion failed): 0.98, kappa 0.49
T-81040: no verdict: the provider's content filter refused the judge request (jailbreak detected: True)
chat-strong judge (judge_reference_v1) on candidate-v3-chat-small-r1-31b45f, dev: 101 replies scored
scores: 1: 2  2: 25  3: 6  4: 32  5: 36 | mean 3.74 | critical: 2
agreement with the code checks (bad = critical or score 1-2 / a criterion failed): 0.86, kappa 0.60

Le juge note le candidat plus bas : une moyenne de 3,74 contre 4,46, avec 25 réponses notées 2. Onze de ces 25 réponses ne sont pas du tout des réponses. La requête v3 a fait réfléchir le modèle jusqu’à sa limite de jetons sur 11 billets de développement. Il n’a donc rien écrit. Les 14 autres sont de vraies réponses qui inventent une procédure ou un délai. La requête v3 demande au modèle d’« être précis » et de « répondre complètement dans ce seul message ». Quand la politique ne donne pas de réponse précise, le modèle en invente une.

T-65479, de la leçon 1, en fait partie. Voici la raison enregistrée du juge pour la réponse du candidat : « La réponse invente une étape en libre-service. Elle demande au client de mettre à jour l’adresse et les détails de carte enregistrés dans son compte. Ni la politique ni les notes de référence ne prévoient cette étape. » C’est la même lecture que celle de l’échelle dans la leçon 1.

La dernière ligne compare le juge aux vérifications par code du module 3. Les deux disent « mauvaise » ou « pas mauvaise » pour chaque réponse. Ils s’accordent sur la plupart des réponses, car la plupart sont correctes. Le kappa montre que l’accord au-delà du hasard est modéré.

La première ligne est nouvelle. Pour T-81040, le juge n’a donné aucun verdict. La prochaine leçon explique pourquoi, dans Ce que le juge ne peut pas juger.

Comparer le juge aux personnes

Le juge a-t-il raison? Comparez-le sur les 30 réponses de calibration, comme vous l’avez fait pour vous-même. Le banc d’évaluation n’a aucune commande qui écrit les notes du juge dans une feuille. Écrivez donc un petit script. Enregistrez-le sous judge_sheet.py dans le dossier du projet :

judge_sheet.py

"""Write a model judge's scores for the 30 calibration replies as a sheet that `harness agree` reads.

    python judge_sheet.py chat-strong

The judgments are the recorded ones (the mock provider): no account, no cost.
"""
import csv
import json
import sys

from harness.dataset import DATA, by_id, load_cases
from harness.judge import parse_verdict, reference_request
from harness.providers import MockProvider, ProviderError
from harness.run import find_run, load_outputs

judge = sys.argv[1] if len(sys.argv) > 1 else "chat-strong"
key = json.loads((DATA / "calibration" / "key.json").read_text(encoding="utf-8"))
cases = by_id(load_cases(split="dev"))
provider = MockProvider()
rows = []
for item, where in sorted(key.items()):
    case = cases[where["case_id"]]
    out = load_outputs(find_run(where["run_id"]))[case.case_id]
    needs = out.answer.get("needs_human") if out.answer else None
    try:
        verdict = parse_verdict(provider.complete(reference_request(case, out.reply, needs, judge)))
        rows.append({"item": item, "score": verdict.score or "", "note": verdict.reason})
    except ProviderError:
        rows.append({"item": item, "score": "", "note": "no verdict: the provider refused the request"})
with open(f"judge_{judge}.csv", "w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["item", "score", "note"])
    writer.writeheader()
    writer.writerows(rows)
print(f"Wrote judge_{judge}.csv: {sum(1 for r in rows if r['score'])} of {len(rows)} replies scored")

Le script utilise key.json pour trouver le cas et l’exécution de chaque élément. Il construit la même requête que harness judge. Exécutez-le pour le juge plus puissant, puis comparez sa feuille aux notes de référence :

python judge_sheet.py chat-strong
python -m harness agree data/calibration/reference_ratings.csv judge_chat-strong.csv

La sortie :

Wrote judge_chat-strong.csv: 28 of 30 replies scored
28 replies scored by both
exact agreement 0.46 | within one point 0.82 | Cohen's kappa 0.22
bad (1-2) or not: agreement 0.96, kappa 0.78
rows: first sheet, columns: second sheet
  2: 2->2
  3: 3->1  4->1  5->3
  4: 3->2  4->4  5->5
  5: 2->1  3->1  4->2  5->6
discuss first (2 or more points apart): R13, R15, R17, R19, R23

Lisez-la avec soin. Il s’agit de l’accord avec les notes de l’auteur du cours : la lecture d’une personne, pas l’accord avec les personnes en général. Sur la note exacte, le juge est peu précis : kappa de 0,22, avec 5 éléments séparés de deux points, dont R13. Sur « mauvaise ou non », il est proche : kappa de 0,78. Il a trouvé les deux mauvaises réponses et n’a qualifié qu’une seule autre réponse de mauvaise.

Maintenant, le juge moins puissant :

python judge_sheet.py chat-small
python -m harness agree data/calibration/reference_ratings.csv judge_chat-small.csv

Les trois premières lignes de la sortie :

Wrote judge_chat-small.csv: 28 of 30 replies scored
28 replies scored by both
exact agreement 0.32 | within one point 0.54 | Cohen's kappa 0.17
bad (1-2) or not: agreement 0.61, kappa 0.16

chat-small n’est fiable sur aucune des deux questions. Sur les 200 réponses de la référence de base aux cas de développement et aux cas réservés, il en classe 37 comme critiques. chat-strong n’en classe aucune ainsi. La plupart de ses raisons « critiques » reprennent la mauvaise lecture de la leçon 1. Il interprète « un membre de notre équipe vous contactera » comme un service promis. Un juge peu coûteux qui crie « nuisible » pour des réponses sûres bloquerait chaque mise en production.

Les notes de l’auteur du cours sont la lecture d’une personne. Les vôtres constituent le deuxième ensemble de notes humaines. Comparez-les à celles du juge :

python -m harness agree my_ratings.csv judge_chat-strong.csv

C’est l’exercice du module de la prochaine leçon.

Jugement par paires et biais d’ordre

Le juge par paires compare la référence de base (A) et le candidat (B) sur chaque billet de développement. Le banc d’évaluation l’interroge deux fois : d’abord avec la réponse de la référence de base en premier, puis avec celle du candidat en premier. Un lecteur attentif donne le même verdict les deux fois.

python -m harness pairwise baseline candidate

La sortie :

chat-strong judge, baseline-v2-chat-small-r1-b6a2b9 (A) against candidate-v3-chat-small-r1-31b45f (B), dev: 102 pairs, both orders
A better: 28 | B better: 60 | tie: 1 | the verdict changed with the order: 13
order changed the verdict on: T-64707, T-64873, T-65054, T-65137, T-65353, T-65460, T-65567, T-65820, T-65855, T-81036, T-81039, T-81044, T-81050

Sur 13 des 102 billets, inverser les positions des deux réponses a changé le verdict. C’est le biais d’ordre, ou biais de position. Le choix du juge dépend de la position d’une réponse, pas seulement de son contenu. Le banc d’évaluation compte ces billets comme « incohérents », et aucun système ne gagne. Explorez-les.

Explorer

L'ordre change-t-il le verdict du juge?

Billets, deux ordres

102

Candidat meilleur

60

Référence meilleure

28

Égalité

1

L’ordre a changé le verdict

13 (12,7 %)

• L’ordre a changé le verdict
• Candidat meilleur dans les deux ordres
• Référence meilleure dans les deux ordres
• Égalité dans les deux ordres

L’ordre a changé le verdict : la réponse montrée en second a gagné les deux fois, donc chaque système a « gagné » une fois.

Billet T-64707 · tranche difficult

Ordered the bathroom cabinet last Tuesday, order LK-561208. It came Friday, all fine, put it up Saturday. Sunday I was going through the statements because my partner asked me to check the card. Two charges for the cabinet, same day, same amount, both from you. Bank shows both as posted. I only meant to pay once. I did not place a second order and the confirmation emails show only one. The cabinet is in the bathroom and I don't need a second one. I have screenshots of both charges if you need them. Please refund the extra one and tell me when it's done.

Réponse de la référence (215 caractères)

I'm sorry you were charged twice. Our payment team will review the charges, and a confirmed double charge is refunded within 3 business days after confirmation. You can share the screenshots to help with the review.

Réponse du candidat (518 caractères)

I’m sorry you’ve had to spend time sorting out a duplicate charge, especially when you only placed one order. Our payment team will check the two posted charges against order LK-561208 and, if they confirm it was a duplicate, refund the extra charge within 3 business days of confirmation. The refund goes to your original payment method; please allow 5 to 10 business days after it is issued for it to appear. You can reply with the screenshots if you’d like to share them, and there’s no need to place another order.

Ordre 1 : la référence montré comme A, le candidat comme B

Le juge a choisi : B, le candidat

“Draft B more clearly makes the refund conditional on confirming the duplicate charge and explains the original payment method and expected timing. Both drafts follow the payment policy without claiming a refund has already been issued, but B is more complete and specific to the order.”

Ordre 2 : le candidat montré comme A, la référence comme B

Le juge a choisi : B, la référence de base

“B accurately gives the specific double-charge refund timeline: within 3 business days after confirmation. A adds a further 5–10-business-day wait after issuance, which the policy does not specify for confirmed double charges.”

Jugements réels par paires des réponses de la référence de base et du candidat sur les 102 billets de développement. Chaque paire est présentée dans les deux ordres (judge_pairwise_v1; Azure, enregistrement du 9 octobre 2026).

Description textuelle de l’explorateur

L’explorateur montre un carré par billet de développement, regroupé par résultat, et les détails d’un billet à la fois. Pour le juge chat-strong, le candidat est meilleur dans les deux ordres sur 60 billets, et la référence de base sur 28. Il y a 1 égalité. L’ordre a changé le verdict sur 13 billets (12,7 %). Sur 11 de ces 13 billets, la réponse présentée en deuxième a gagné les deux fois. Sur 2 billets, celle présentée en premier a gagné les deux fois. Pour le juge chat-small : candidat 67, référence de base 19, égalité 1, ordre changé 15 (14,7 %). Pour chaque billet, l’explorateur montre le billet et les deux réponses avec leur longueur. Il montre aussi, pour chaque ordre, le choix du juge et sa raison enregistrée. Exemple : sur T-65460 (chat-strong), le juge a choisi la deuxième réponse dans les deux ordres. Chaque système a donc « gagné » une fois.

Deux tendances se dégagent. D’abord, quand l’ordre change le verdict, la réponse présentée en deuxième gagne généralement : 11 fois sur 13 pour chat-strong. Sur les 200 billets de développement et billets réservés, la deuxième position a gagné 218 fois et la première, 180. Ensuite, le candidat gagne la plupart des verdicts cohérents, 60 contre 28. Ses réponses sont aussi plus de deux fois plus longues : une médiane de 386 caractères contre 178 sur les billets de développement.

Le candidat est-il donc meilleur? Regardez un billet où le juge est cohérent. Sur T-81034, un client pose une question sur la commande de sa sœur. La politique dit qu’une personne doit traiter ce type de billet (règle H4).

Les deux mêmes réponses à T-81034, lues par le même modèle dans deux rôles de juge (chat-strong, enregistrement). Le juge par paires n'a pas de notes de référence; le juge avec référence les a.

Description textuelle du diagramme

La référence de base répond : « Puisque votre sœur a passé la commande, un membre de notre équipe vous contactera au sujet des renseignements que nous pouvons partager. » Le candidat répond : « Je ne peux pas vous communiquer sa date de livraison ni ce qu’elle contient d’autre. Veuillez lui demander de contacter Larkfield directement… et notre équipe pourra l’aider. »

Le juge par paires, sans référence, a choisi le candidat dans les deux ordres : « B protège explicitement les détails de la commande de la sœur. Il invite la personne ayant passé la commande à contacter Larkfield. » Les notes du juge avec référence disent qu’une personne doit traiter le billet. Il a donné 5 à la référence de base et 2 au candidat : « La réponse ne dit pas qu’une personne traitera ce billet, comme l’exige une demande d’accès. »

Le même modèle donne des réponses opposées parce qu’on lui a posé des questions différentes. Sans référence, un juge récompense ce qui paraît bon à la lecture : une réponse claire, chaleureuse et complète. Il ne peut pas savoir que la règle de Larkfield exige une personne pour ce billet, ou qu’une étape « précise » est inventée. Avec la référence, il vérifie la réponse par rapport au cas. Un juge par paires mesure la préférence, pas la justesse.

De bout en boutCalibrer un juge modèle par rapport à des notes humainesÉtude de cas

L’étude de cas sur la calibration interroge deux juges modèles dans les deux ordres. Elle établit une politique sur ce que le juge peut décider seul.

De bout en boutÉvaluer des résumés par rapport aux notes d'expertsÉtude de cas

L’étude de cas sur les résumés mesure deux juges modèles par rapport à trois experts, avec une grille par qualité. Elle rencontre aussi des articles refusés par le filtre de contenu.

Vérification des connaissances

Vérifiez votre compréhension

Quelle différence y a-t-il entre un juge avec référence et un juge par paires? Pourquoi étaient-ils en désaccord sur le candidat?

Afficher la réponse

Un juge avec référence note une réponse avec la grille et les notes de référence du cas. Les notes indiquent l’équipe, si une personne doit traiter le billet, la prochaine étape et ce que la réponse doit éviter. Un juge par paires compare deux réponses et n’a pas de référence. Sans référence, le juge récompense ce qui se lit bien. Les réponses plus longues, chaleureuses et précises du candidat ont gagné 60 contre 28 sur les billets de développement. Avec la référence, le même modèle voit que plusieurs de ces étapes précises sont inventées. Il voit aussi que certaines réponses omettent la personne qui doit traiter le billet. Il note donc le candidat plus bas : 3,74 contre 4,46.

Vérifiez votre compréhension

Prédisez : vous inversez l'ordre dans lequel un juge par paires voit deux réponses. Un juge attentif donne le même verdict. Qu'a fait le juge chat-strong sur les 102 billets de développement, et comment le banc d'évaluation gère-t-il cela?

Afficher la réponse

Sur 13 des 102 billets, le verdict a changé avec l’ordre. Sur 11 d’entre eux, la réponse présentée en deuxième a gagné les deux fois. C’est le biais d’ordre. Le banc d’évaluation présente chaque paire dans les deux ordres. Il ramène la deuxième réponse aux noms du premier ordre et ne conserve un gagnant que si les deux ordres concordent. Sinon, il enregistre « incohérent », et aucune réponse ne gagne.

Récapitulatif

• Un juge modèle note une réponse avec la grille et les notes de référence, ou choisit la meilleure de deux réponses sans elles. Calibrez-le par rapport aux personnes, une question à la fois.
• Par rapport aux notes de référence de l’auteur du cours, chat-strong est proche sur « mauvaise ou non » (kappa de 0,78). Il est peu précis sur la note exacte (0,22). chat-small n’est pas fiable (0,17). Vos propres notes constituent une deuxième vérification humaine.
• Sans référence, le juge préfère le candidat plus long et chaleureux, 60 contre 28 sur les billets de développement. Avec la référence, il note le candidat plus bas, car celui-ci invente des étapes.
• Le biais d’ordre se mesure, il ne se présume pas : l’ordre a changé 13 des 102 verdicts. Le banc d’évaluation ne conserve un gagnant que si les deux ordres concordent.
• Votre projet contient les juges et les jugements enregistrés : python -m pytest donne 34 passed (34 tests réussis).

Ensuite, vous vérifiez deux autres habitudes du juge : la préférence pour soi et la dérive. Vous trouvez aussi les cas qu’il ne peut pas juger et décidez où une personne doit réviser.

Leçon suivante : Le jugement par modèle (suite)