AI Engineering Academy · Leçon

Le modèle du LLM évaluateur

Comprenez comment inviter un LLM performant à noter ou comparer des sorties selon des critères tels que l’exactitude, l’utilité et le ton, et pourquoi cette approche passe mieux à l’échelle qu’une évaluation humaine.

Leçon 1 sur 413 étapes

Le modèle du LLM évaluateur est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Pourquoi l’évaluation automatisée est nécessaire

Évaluer manuellement les sorties des LLM est lent et coûteux. Une équipe d’évaluateurs humains peut examiner quelques centaines de sorties par semaine, tandis qu’un système en production en génère des milliers par jour. Le LLM en tant qu’évaluateur utilise un modèle linguistique puissant pour évaluer à grande échelle la qualité des sorties d’autres LLM, ce qui permet les tests automatisés de régression et la surveillance continue de la qualité sans devoir recruter une armée d’annotateurs.

L’idée centrale : un LLM en évalue un autre

Dans le modèle du LLM en tant qu’évaluateur, vous envoyez à un modèle évaluateur (généralement GPT-4o ou Claude) une invite système définissant les critères d’évaluation, la question d’origine, la réponse du modèle et, éventuellement, une réponse de référence. L’évaluateur renvoie un score numérique, une étiquette ou un classement. Cette méthode fonctionne, car les modèles de pointe comprennent suffisamment bien des notions de qualité telles que l’exactitude, l’utilité et la cohérence.

JUDGE_SYSTEM_PROMPT = '''
You are an expert evaluator of AI-generated responses.
Given a question and an AI-generated answer, score the answer on:
- Correctness (0-5): Is the information factually accurate?
- Completeness (0-5): Does it fully address the question?
- Clarity (0-5): Is it easy to understand?
Return a JSON object with scores and a brief rationale.
'''

Rédiger une invite pour l’évaluateur

Une bonne invite d’évaluation précise des grilles explicites avec des définitions de scores, plutôt que des termes vagues comme « bon » ou « mauvais ». Définissez concrètement ce que signifient les scores 5, 3 et 1 pour chaque critère. Fournissez la question, la réponse évaluée et, éventuellement, une réponse de référence. Demandez un raisonnement avant le score (chaîne de pensée) afin de réduire les notations arbitraires.

def build_judge_prompt(question: str, answer: str, reference: str = None) -> str:
    ref_section = f'Reference answer:\n{reference}\n\n' if reference else ''
    return f'''
Question: {question}

{ref_section}Answer to evaluate:
{answer}

Score this answer on correctness (1-5) where:
5 = Completely accurate, no factual errors
3 = Mostly accurate with minor errors
1 = Contains significant factual errors

First explain your reasoning, then provide the score as JSON:
{{"correctness": <1-5>, "rationale": "..."}}
'''

Appeler le modèle évaluateur

Appelez le modèle évaluateur avec votre invite d’évaluation. Analysez la réponse JSON pour en extraire les scores. Utilisez toujours des sorties structurées ou le mode JSON afin de garantir que l’évaluateur renvoie des données analysables. Utiliser le même modèle à la fois pour le système testé et pour l’évaluateur peut introduire un biais : préférez un modèle différent ou, au minimum, une configuration différente pour l’évaluateur.

from pydantic import BaseModel
import instructor
from openai import OpenAI

class JudgeScore(BaseModel):
    correctness: int
    completeness: int
    clarity: int
    rationale: str

judge_client = instructor.from_openai(OpenAI())

def judge(question: str, answer: str) -> JudgeScore:
    return judge_client.chat.completions.create(
        model='gpt-4o',  # Use stronger judge than the model being tested
        response_model=JudgeScore,
        messages=[
            {'role': 'system', 'content': JUDGE_SYSTEM_PROMPT},
            {'role': 'user', 'content': build_judge_prompt(question, answer)}
        ]
    )

Évaluation sans référence ou avec référence

Il existe deux modes d’évaluation par un LLM. L’évaluation sans référence demande à l’évaluateur d’évaluer la qualité sans réponse de vérité terrain — ce qui est utile lorsqu’une telle réponse n’existe pas, par exemple dans une discussion ouverte. L’évaluation avec référence fournit une réponse de référence faisant autorité et demande si la réponse du modèle lui correspond — ce qui convient mieux aux questions factuelles dont la réponse correcte est connue. Utilisez l’évaluation avec référence lorsque vous disposez d’un ensemble de test étiqueté.

# Reference-free: good for open-ended generation
judge_result = judge(question='What is machine learning?', answer=model_answer)

# Reference-based: better for factual QA
judge_result = judge(
    question='What year was Python created?',
    answer=model_answer,
    reference='Python was created by Guido van Rossum and released in 1991.'
)

Maîtriser les biais de l’évaluateur

Les évaluateurs LLM présentent des biais connus : ils préfèrent les réponses plus longues (biais de verbosité), les réponses au ton assuré et les réponses qui correspondent au style de leurs données d’apprentissage. Réduisez le biais de verbosité en pénalisant explicitement la longueur inutile dans votre grille. Réduisez le biais de position lors d’une comparaison par paires en randomisant la réponse affichée en premier, puis en faisant la moyenne des scores obtenus dans les deux ordres.

# Anti-verbosity note in rubric:
ANTI_VERBOSITY_CLAUSE = '''
Note: A concise, accurate answer should score higher than a long,
rambling answer that happens to contain the correct information.
Do not reward length for its own sake.
'''

# Position-debiasing for pairwise comparison:
async def debiased_pairwise(q, a, b):
    score_ab = await compare(q, answer_a=a, answer_b=b)
    score_ba = await compare(q, answer_a=b, answer_b=a)
    # A wins if it wins in both orderings
    a_wins = (score_ab == 'A' and score_ba == 'B')
    return 'A' if a_wins else 'B' if (score_ab == 'B' and score_ba == 'A') else 'tie'

Regrouper les évaluations pour accélérer le traitement

Exécutez les évaluations de l’évaluateur en parallèle afin d’évaluer rapidement de grands ensembles de test. Avec asyncio et un sémaphore, vous pouvez évaluer des centaines de sorties par minute. Prévoyez un budget de limite de débit distinct pour les appels à l’évaluateur (ils consomment eux aussi des jetons) et envisagez d’utiliser un modèle évaluateur plus petit, mais toujours capable, comme GPT-4o-mini pour les critères qui ne nécessitent pas un raisonnement approfondi, en réservant GPT-4o aux critères les plus importants.

import asyncio

async def batch_judge(qa_pairs: list, concurrency: int = 20) -> list:
    sem = asyncio.Semaphore(concurrency)

    async def judge_one(item):
        async with sem:
            return await async_judge(item['question'], item['answer'])

    return await asyncio.gather(
        *[judge_one(item) for item in qa_pairs],
        return_exceptions=True
    )

Regrouper les scores de l’évaluateur

Après l’évaluation d’un ensemble de test, regroupez les scores sous forme de statistiques récapitulatives : moyenne, médiane et pourcentage de réponses dépassant un seuil de qualité (par exemple, exactitude ≥ 4). Comparez ces agrégats entre les versions du modèle ou les variantes de l’invite. Une baisse de plus de 5 % du taux de réponses dépassant le seuil doit déclencher un examen avant le déploiement de la nouvelle version.

import statistics

def summarize_judge_results(scores: list) -> dict:
    correctness = [s.correctness for s in scores if isinstance(s, JudgeScore)]
    return {
        'n': len(correctness),
        'mean_correctness': round(statistics.mean(correctness), 2),
        'median_correctness': statistics.median(correctness),
        'pct_above_4': round(100 * sum(1 for s in correctness if s >= 4) / len(correctness), 1)
    }

Comparer les versions d’un LLM avec un évaluateur

Utilisez le modèle du LLM en tant qu’évaluateur pour comparer deux versions de votre système, par exemple avant et après une modification de l’invite. Exécutez les deux versions sur le même ensemble de questions de test, évaluez toutes les sorties et calculez le taux de victoire : le pourcentage de cas où la version B obtient un score supérieur à celui de la version A. Un taux de victoire supérieur à 55 % sur plus de 100 échantillons est généralement assez significatif sur le plan statistique pour justifier la mise en production de la nouvelle version.

async def ab_compare(test_questions: list, version_a, version_b) -> dict:
    a_wins = b_wins = ties = 0
    for q in test_questions:
        answer_a = await version_a.answer(q)
        answer_b = await version_b.answer(q)
        winner = await debiased_pairwise(q, answer_a, answer_b)
        if winner == 'A': a_wins += 1
        elif winner == 'B': b_wins += 1
        else: ties += 1
    total = len(test_questions)
    return {'a_win_rate': a_wins/total, 'b_win_rate': b_wins/total, 'tie_rate': ties/total}

Étalonner les scores de l’évaluateur par rapport aux humains

Validez votre évaluateur en comparant ses scores à ceux d’évaluateurs humains sur un ensemble d’étalonnage de 50 à 200 exemples. Calculez la corrélation de Pearson entre les scores de l’évaluateur et ceux des humains. Une corrélation supérieure à 0,7 indique que l’évaluateur est fiable. Si la corrélation est faible, examinez l’invite de l’évaluateur pour déterminer où il diverge des humains, puis ajoutez des exemples ou des précisions à la grille. Ne déployez jamais un évaluateur sans étalonnage.

from scipy.stats import pearsonr

def calibrate_judge(human_scores: list, judge_scores: list) -> dict:
    corr, p_value = pearsonr(human_scores, judge_scores)
    mean_abs_error = sum(abs(h - j) for h, j in zip(human_scores, judge_scores)) / len(human_scores)
    return {
        'pearson_r': round(corr, 3),
        'p_value': round(p_value, 4),
        'mean_abs_error': round(mean_abs_error, 2),
        'reliable': corr >= 0.7
    }

Quand ne pas utiliser le LLM en tant qu’évaluateur

Le LLM en tant qu’évaluateur ne convient pas à tous les scénarios d’évaluation. Évitez-le lorsque le critère exige une expertise que le modèle évaluateur ne possède pas (exactitude d’un diagnostic médical, conformité juridique), lorsque vous avez besoin d’une évaluation juridiquement défendable (un examen humain est alors requis), lorsque vous évaluez un modèle plus performant que l’évaluateur (celui-ci ne peut pas évaluer de manière fiable une sortie qu’il ne pourrait pas produire) ou lorsque le budget d’évaluation est trop limité pour couvrir le coût supplémentaire des appels d’API. Dans ces cas, utilisez une évaluation humaine ou des métriques déterministes.

# Appropriate uses of LLM-as-judge:
# YES: General helpfulness, clarity, tone, factual accuracy (general knowledge)
# YES: Code correctness for common languages
# YES: Translation quality comparison
# YES: Content safety classification
#
# NOT appropriate:
# NO: Medical/legal/financial accuracy (needs domain expert)
# NO: Evaluating GPT-4o with GPT-4o (same capability ceiling)
# NO: Formal compliance audits (non-deterministic judge)
# NO: Streaming quality at individual token level

Vérification rapide

Vérifiez votre compréhension du modèle d’évaluation du LLM en tant qu’évaluateur.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que le LLM en tant qu’évaluateur utilise un modèle puissant pour évaluer la qualité à grande échelle à l’aide de grilles explicites, que les modes sans référence et avec référence conviennent à différents scénarios d’évaluation, et que l’étalonnage par rapport aux évaluations humaines vérifie la fiabilité de votre évaluateur avant son utilisation en production. Nous allons maintenant mettre en œuvre des stratégies d’évaluation point par point et par paires.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
30
Leçons
120

Questions Fréquemment Posées

La leçon « Le modèle du LLM évaluateur » est-elle gratuite ?

Oui — le texte complet de « Le modèle du LLM évaluateur » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Le modèle du LLM évaluateur » ?

Comprenez comment inviter un LLM performant à noter ou comparer des sorties selon des critères tels que l’exactitude, l’utilité et le ton, et pourquoi cette approche passe mieux à l’échelle qu’une év… Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Le modèle du LLM évaluateur » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Le modèle du LLM évaluateur
  2. Évaluation point par point et par paires
  3. Étalonner les modèles évaluateurs par rapport aux humains
  4. Construire un pipeline d’évaluation continue
← Retour à AI Engineering Academy