Utiliser un grand modèle de langage pour noter les sorties d'autres modèles est devenu le réflexe par défaut en évaluation. Vous rédigez une grille, vous demandez à GPT-4o ou à Claude de scorer un millier de réponses, puis vous lisez un chiffre d'exactitude. C'est rapide, c'est bon marché, et cela passe à l'échelle bien au-delà de ce qu'une équipe humaine peut annoter à la main.

Cela présuppose aussi, en silence, exactement ce que vous avez le plus besoin de vérifier : que le juge est d'accord avec les humains. Un LLM comme juge qui se trompe avec assurance produit un classement à l'allure propre, mais bâti sur du sable. Avant de vous fier aux verdicts d'un juge, vous devez mesurer à quel point ils suivent le jugement humain. Cette étape de mesure, c'est la calibration, et Potato 2.6 y ajoute un flux de travail.

Cet article couvre Judge Calibration (calibration du juge) : comment il échantillonne les modèles, comment il garde la passe humaine honnête, et ce que le rapport vous dit réellement. La documentation de référence contient la liste complète des options.

Le verdict d'un juge LLM affiché à côté d'une annotation humaine, avec un kappa calculé en direct Calibration du juge en ligne dans Potato

La forme du problème

Un juge peut échouer de deux manières différentes, et vous voulez attraper les deux.

La première est le désaccord : le juge qualifie de « correct » ce qu'un humain attentif qualifierait d'« incorrect ». C'est ce que mesurent les métriques d'exactitude et d'accord.

La seconde est la mauvaise confiance : le juge se dit sûr à 95 % et a raison 60 % du temps. Un juge peut avoir une exactitude correcte tout en étant très mal calibré, ce qui compte dès l'instant où vous commencez à vous servir de sa confiance pour router le travail ou fixer des seuils. C'est ce que mesure l'erreur de calibration.

La passe de calibration de Potato est conçue pour faire ressortir les deux d'un coup.

Comment ça marche

Le flux de travail s'exécute comme une courte machine à états :

text

SETUP → GENERATING → HUMAN_CALIBRATION → REPORT → COMPLETED

Génération (Generating). Chaque modèle est interrogé k fois par élément. L'étiquette modale parmi ces k échantillons est la prédiction du modèle, et la fraction d'échantillons qui s'y accordent en est la confiance. Échantillonner k fois plutôt qu'une seule est ce qui vous donne un signal de confiance empirique, plutôt qu'un nombre que le modèle a inventé à son propre sujet. Ces résultats vont dans un stockage dédié et ne sont jamais écrits dans les données d'annotation.

Calibration humaine (Human calibration). Potato tire un échantillon aléatoire ou stratifié des éléments et l'achemine vers un ou plusieurs humains, qui les étiquettent via l'interface d'annotation habituelle, sans jamais voir les réponses du modèle.

Rapport (Report). Les métriques sont calculées sur le chevauchement entre ce que les modèles ont étiqueté et ce que les humains ont étiqueté, puis écrites sur le disque.

L'aveugle est ici le point essentiel. Comme les étiquettes du modèle vivent dans un stockage distinct et ne sont jamais injectées dans l'interface, l'humain ne peut pas en être ancré, même par accident. L'aveugle est structurel, ce n'est pas une affaire de demander aux annotateurs de détourner le regard.

Le pipeline de calibration : vote du modèle sur k échantillons, une passe humaine en aveugle et un rapport comparatif Comment Potato calibre un juge face à des étiquettes humaines en aveugle

Configuration

Une calibration de juge tient en un seul bloc de configuration. Vous écrivez le prompt du juge, listez les modèles et fixez combien de fois échantillonner chacun :

yaml

judge_calibration:
  enabled: true
  prompt: |                       # supports {text}, {labels}, {description}
    You are an impartial expert annotator. Classify the sentiment as exactly
    one of: positive, negative, neutral.
  models:
    - endpoint_type: openai        # openai | anthropic | ollama | vllm | gemini | ...
      model: gpt-4o-mini
      api_key: ${OPENAI_API_KEY}
      temperature: 0.7             # must be > 0 so the k samples vary
    - endpoint_type: ollama
      model: llama3.1:8b
      base_url: http://localhost:11434
      temperature: 0.7
  k_samples: 5                     # samples per model per item
  max_items: 1000                  # cap on items the LLMs label (null = all)
  sampling:
    strategy: stratified           # random | stratified | all
    sample_size: 200               # how many items humans blind-label
    seed: 42
  human:
    num_raters: 1                  # 1 = solo researcher; N adds human-human IAA
    gold: single                   # single | majority
  schemas: [sentiment]
  output:
    dir: judge_calibration_output

Warning: Mettez temperature > 0. Avec k_samples > 1 et une température de 0, les échantillons sont identiques, la confiance est figée à 1.0, et le rapport de calibration ne veut rien dire. Potato émet un avertissement au démarrage lorsqu'il voit cette combinaison.

Vous pouvez lister plusieurs modèles et les calibrer côte à côte, ce qui est la façon naturelle de choisir entre un juge local bon marché et un juge hébergé coûteux.

L'essayer sans clé d'API

L'exemple fourni utilise un modèle Ollama local, vous pouvez donc exécuter toute la boucle hors ligne. Démarrez Ollama, téléchargez le modèle, puis lancez :

bash

ollama pull llama3.2:3b
python potato/flask_server.py start examples/ai-assisted/judge-calibration/config.yaml -p 8000 --debug

Ouvrez http://localhost:8000/judge_calibration/admin pour configurer et exécuter, étiquetez l'échantillon en aveugle sur /annotate, puis générez le rapport et lisez-le sur /judge_calibration/report.

Ce que le rapport vous dit

Le rapport est conçu pour répondre à « dois-je faire confiance à ce juge ? » avec des chiffres que vous pouvez mettre dans une section de méthodes :

Exactitude, précision, rappel et F1 de chaque modèle face à l'étiquette de référence humaine.
κ de Cohen ventilée en paires humain↔modèle, modèle↔modèle et humain↔humain, pour voir si le juge s'accorde avec les humains autant que les humains s'accordent entre eux.
κ de Fleiss et α de Krippendorff sur l'ensemble des évaluateurs.
Erreur de calibration attendue (ECE), bacs de fiabilité et un score de Brier : la réponse au mode de défaillance de la mauvaise confiance.
Une matrice de confusion par modèle, qui raconte d'ordinaire la vraie histoire : un juge correct sur les classes faciles qui s'effondre sur une distinction difficile.

Tout est calculé sur le chevauchement : les éléments étiquetés à la fois par les modèles et par les humains, restreints à l'échantillon de calibration. La sortie atterrit sous output.dir sous la forme de llm_labels.jsonl, report.json et un report.html lisible.

Ce qu'elle prend en charge

La calibration est entièrement prise en charge sur les schémas catégoriels qu'utilisent la plupart des juges, et s'étend à des types plus ardus :

Type	Statut	Métriques
`radio` / `select`	Pris en charge	exactitude, P/R/F1, κ de Cohen/Fleiss, α de Krippendorff, ECE, confusion
`likert`	Pris en charge	ce qui précède, plus le MAE et l'α de Krippendorff ordinal
`multiselect`	Pris en charge	P/R/F1 par étiquette, Jaccard moyen, exactitude de correspondance exacte, calibration
`span`	Expérimental	P/R/F1 appariés par IoU, IoU moyen, span-F1, calibration au niveau du span

La calibration des spans regroupe les spans à décalage de caractères du juge sur les k échantillons et les apparie à la référence par intersection sur union (intersection-over-union) ; traitez ses chiffres comme indicatifs plutôt qu'exacts.

Calibration et alignement

Potato livre un second flux de travail, apparenté, qu'il est facile de confondre avec celui-ci. Judge Alignment (alignement du juge) calibre un seul juge face à un jeu de référence humain existant, affiche son verdict en ligne pendant l'annotation, et est conçu pour itérer sur une grille jusqu'à ce que l'accord grimpe.

La règle empirique : optez pour la calibration quand vous évaluez des juges candidats et voulez un chiffre de confiance empirique et en aveugle ; optez pour l'alignement quand vous avez arrêté votre choix sur un juge et que vous ajustez sa grille face à un jeu de référence fixe. Les deux sont traités ensemble dans Boucler la boucle (Closing the Loop).

Les juges LLM ne vont pas disparaître ; il y a trop à évaluer et trop peu de gens pour le faire à la main. Le but de la calibration n'est pas de remplacer le juge par des humains, mais de savoir, avec un chiffre, jusqu'où exactement on peut faire confiance au juge avant qu'un humain doive regarder.

La documentation Judge Calibration couvre chaque option, et le guide de l'accord inter-annotateurs explique en profondeur les métriques kappa et alpha.