AI Engineering Academy · Leçon

Mesures de génération : fidélité et pertinence des réponses

Utilisez RAGAS pour mesurer si les réponses générées sont fidèles au contexte récupéré et si elles répondent réellement à la question de l’utilisateur sans produire d’hallucinations.

Leçon 3 sur 413 étapes

Mesures de génération : fidélité et pertinence des réponses est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Mesurer l'étape de génération

Même lorsque votre système de récupération trouve les segments parfaits, l'étape de génération peut encore échouer. Le LLM peut ignorer le contexte récupéré et répondre à partir de sa mémoire paramétrique, mal interpréter ce que dit le contexte ou répondre à une question légèrement différente de celle qui a été posée. Les métriques de génération quantifient ces échecs indépendamment de la récupération afin que vous puissiez cerner et corriger chaque problème. Les deux principales métriques de génération sont la fidélité et la pertinence de la réponse.

Fidélité : définition

La fidélité mesure si chaque affirmation de la réponse générée peut être directement reliée au contexte récupéré. Une réponse fidèle n'introduit aucune information absente du contexte. La fidélité se mesure au niveau des affirmations : la réponse est décomposée en énoncés atomiques individuels, puis chacun est vérifié par rapport au contexte afin de déterminer s'il est étayé. Le score de fidélité est la proportion d'affirmations étayées.

# Faithfulness = supported_claims / total_claims

example_answer = (
    'Employees receive 15 vacation days per year. '
    'Remote work is allowed on Wednesdays and Fridays. '
    'The CEO is John Smith.'
)
example_context = (
    '15 vacation days are granted annually. '
    'Remote work is permitted on Wednesdays and Fridays.'
)

# Claim 1: 15 vacation days — SUPPORTED
# Claim 2: Remote work Wed+Fri — SUPPORTED
# Claim 3: CEO is John Smith — NOT IN CONTEXT (hallucinated)
# Faithfulness = 2/3 = 0.67

Implémenter la fidélité avec un LLM évaluateur

La façon la plus pratique de mesurer la fidélité à grande échelle consiste à utiliser un LLM puissant comme évaluateur. Demandez au LLM évaluateur de décomposer la réponse en affirmations individuelles, puis de vérifier chaque affirmation par rapport au contexte. L'évaluateur renvoie une liste d'affirmations étiquetées SUPPORTED ou UNSUPPORTED, et vous calculez la proportion de celles qui sont étayées. Cette approche permet d'effectuer des milliers d'évaluations par heure pour quelques centimes par évaluation.

import json

def evaluate_faithfulness(answer, context, llm_client):
    prompt = (
        'Task: Evaluate the faithfulness of an answer against a context.\n\n'
        f'Context:\n{context}\n\n'
        f'Answer:\n{answer}\n\n'
        'Steps:\n'
        '1. Break the answer into individual atomic claims.\n'
        '2. For each claim, check if it is supported by the context.\n'
        '3. Return JSON: {"claims": [{"text": "...", "supported": true/false}], "score": 0.0-1.0}'
    )
    response = llm_client.chat.completions.create(
        model='gpt-4o',
        response_format={'type': 'json_object'},
        messages=[{'role': 'user', 'content': prompt}]
    )
    return json.loads(response.choices[0].message.content)

Pertinence de la réponse : définition

La pertinence de la réponse mesure si la réponse générée répond réellement à la question de l’utilisateur. Une réponse très fidèle peut tout de même passer à côté du sujet — par exemple, si l’utilisateur demande « Comment réinitialiser mon mot de passe ? » et que la réponse explique en détail la politique générale de sécurité de l’entreprise sans mentionner la procédure de réinitialisation du mot de passe. La pertinence de la réponse est indépendante de la fidélité : vous pouvez être fidèle (ne dire que des choses présentes dans le contexte), mais hors sujet (ne pas répondre à la question posée).

Mesurer la pertinence des réponses

RAGAS mesure la pertinence d’une réponse à l’aide d’une technique ingénieuse de génération inversée : le LLM évaluateur génère plusieurs questions hypothétiques auxquelles la réponse générée permettrait de répondre, puis mesure la similarité entre ces questions générées et la question d’origine à l’aide de la similarité cosinus des plongements. Une forte similarité entre les questions hypothétiques générées et la question d’origine indique une forte pertinence de la réponse.

def evaluate_answer_relevance(question, answer, llm_client, embed_fn):
    # Generate hypothetical questions for this answer
    prompt = (
        f'Given this answer: "{answer}"\n\n'
        'Generate 3 questions that this answer would be a good response to.\n'
        'Return as JSON: {"questions": ["...", "...", "..."]}'
    )
    response = llm_client.chat.completions.create(
        model='gpt-4o-mini',
        response_format={'type': 'json_object'},
        messages=[{'role': 'user', 'content': prompt}]
    )
    hyp_questions = json.loads(response.choices[0].message.content)['questions']

    # Measure similarity to original question
    orig_embedding = embed_fn(question)
    hyp_embeddings = [embed_fn(q) for q in hyp_questions]
    similarities = [cosine_similarity(orig_embedding, e) for e in hyp_embeddings]
    return sum(similarities) / len(similarities)

Rappel du contexte : avons-nous récupéré suffisamment d’informations ?

Le rappel du contexte mesure si le contexte récupéré contient suffisamment d’informations pour répondre correctement à la question. Il vérifie la réponse de référence phrase par phrase : chaque phrase peut-elle être attribuée à l’un des segments récupérés ? Un rappel du contexte élevé signifie que le récupérateur a trouvé tout ce qui était nécessaire. Un rappel faible signifie que des informations essentielles manquaient dans les segments récupérés ; le LLM ne peut donc pas répondre correctement, même avec une génération parfaite.

def evaluate_context_recall(ground_truth_answer, retrieved_contexts, llm_client):
    prompt = (
        f'Ground truth answer:\n{ground_truth_answer}\n\n'
        f'Retrieved context:\n{",".join(retrieved_contexts)}\n\n'
        'For each sentence in the ground truth answer, determine if it '
        'can be attributed to the retrieved context.\n'
        'Return JSON: {"sentences": [{"text": "...", "in_context": true/false}], "recall": 0.0-1.0}'
    )
    response = llm_client.chat.completions.create(
        model='gpt-4o',
        response_format={'type': 'json_object'},
        messages=[{'role': 'user', 'content': prompt}]
    )
    return json.loads(response.choices[0].message.content)

Précision du contexte : les segments récupérés sont-ils pertinents ?

La précision du contexte mesure si les segments récupérés sont réellement utiles pour répondre à la question. Une précision élevée signifie que les segments récupérés sont étroitement pertinents. Une faible précision signifie que de nombreux segments récupérés sont du bruit hors sujet que le LLM doit lire puis écarter, ce qui augmente le risque de confusion. La précision du contexte se mesure en vérifiant quels segments récupérés ont réellement été utilisés ou cités dans la réponse générée.

def evaluate_context_precision(question, answer, retrieved_contexts, llm_client):
    precision_scores = []
    for i, context in enumerate(retrieved_contexts, 1):
        prompt = (
            f'Question: {question}\n\n'
            f'Context chunk {i}: {context}\n\n'
            f'Answer: {answer}\n\n'
            'Was this context chunk useful in generating the answer? '
            'Return JSON: {"useful": true/false, "reason": "..."}'
        )
        response = llm_client.chat.completions.create(
            model='gpt-4o-mini',
            response_format={'type': 'json_object'},
            messages=[{'role': 'user', 'content': prompt}]
        )
        result = json.loads(response.choices[0].message.content)
        precision_scores.append(1.0 if result['useful'] else 0.0)
    return sum(precision_scores) / len(precision_scores)

Utiliser RAGAS pour toutes les métriques à la fois

La bibliothèque RAGAS implémente les quatre métriques RAG principales — précision du contexte, rappel du contexte, fidélité et pertinence de la réponse — au sein d’un même cadre. Elle gère en interne les appels au LLM évaluateur. Transmettez-lui un jeu de données contenant les questions, les réponses générées, les contextes récupérés et les réponses de référence, puis recevez un rapport complet des scores. RAGAS prend également en charge l’évaluation asynchrone, ce qui vous permet d’évaluer des centaines d’exemples en parallèle.

from ragas import evaluate
from ragas.metrics import (
    faithfulness, answer_relevancy,
    context_precision, context_recall
)
from datasets import Dataset

# Build evaluation dataset
eval_samples = [
    {
        'question': item['question'],
        'answer': item['generated_answer'],
        'contexts': item['retrieved_texts'],
        'ground_truth': item['expected_answer']
    }
    for item in test_results
]

eval_dataset = Dataset.from_list(eval_samples)
results = evaluate(eval_dataset,
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall]
)
results.to_pandas().to_csv('eval_results.csv', index=False)

Diagnostiquer les problèmes grâce aux combinaisons de métriques

La combinaison des métriques révèle des problèmes précis du système. Faible fidélité + forte précision du contexte → le LLM ignore le contexte et hallucine (corrigez le prompt). Faible rappel du contexte + forte fidélité → le récupérateur ne trouve pas certains segments essentiels, mais le LLM rapporte fidèlement ce qu’il a trouvé (corrigez le découpage ou les plongements). Faible pertinence de la réponse + forte fidélité → les segments récupérés sont liés au sujet de manière indirecte et le LLM les décrit fidèlement, mais il ne répond pas à la question (améliorez le filtrage de la récupération ou la réécriture de la requête).

# Diagnostic matrix
diagnostics = [
    {
        'condition': 'Low faithfulness + High context precision',
        'cause': 'LLM ignoring context, answering from parametric memory',
        'fix': 'Strengthen system prompt: "Answer ONLY from the provided context"'
    },
    {
        'condition': 'Low context recall + High faithfulness',
        'cause': 'Retriever missing relevant chunks',
        'fix': 'Improve chunking strategy, embedding model, or increase top-k'
    },
    {
        'condition': 'Low answer relevance + High context recall',
        'cause': 'Retrieved context is off-topic; LLM is answering wrong question',
        'fix': 'Add query rewriting or improve metadata filters'
    }
]

Évaluation humaine pour l’étalonnage

Les métriques fondées sur le LLM comme évaluateur sont corrélées au jugement humain, mais ne lui correspondent pas parfaitement. Étalonnez vos métriques automatisées en demandant à 3 évaluateurs humains de noter un échantillon aléatoire de 50 sorties sur la fidélité et la pertinence de la réponse, selon une échelle de 1 à 5. Calculez l’accord entre le LLM évaluateur et la note humaine moyenne. Si le LLM attribue systématiquement des notes trop élevées ou trop faibles par rapport aux humains, appliquez un facteur de correction. Des métriques automatisées étalonnées vous donnent l’assurance que l’amélioration des scores reflète une amélioration réelle de la qualité.

from scipy.stats import spearmanr

def calibrate_judge_vs_humans(samples):
    '''samples: [{"llm_score": 0.9, "human_score": 4.2}, ...]'''
    llm_scores = [s['llm_score'] for s in samples]
    human_scores = [s['human_score'] / 5.0 for s in samples]  # normalize to 0-1

    correlation, pvalue = spearmanr(llm_scores, human_scores)
    print(f'LLM-Human Spearman correlation: {correlation:.3f} (p={pvalue:.4f})')

    mean_llm = sum(llm_scores) / len(llm_scores)
    mean_human = sum(human_scores) / len(human_scores)
    bias = mean_llm - mean_human
    print(f'LLM bias vs humans: {bias:+.3f}')
    return correlation, bias

Définir les objectifs des métriques pour la mise en production

Avant de déployer un système RAG en production, définissez des seuils minimaux pour les métriques que le système doit atteindre. Les objectifs courants en production sont les suivants : fidélité > 0,90 (moins de 10 % des affirmations de la réponse sont des hallucinations), pertinence de la réponse > 0,80 (au moins 80 % des réponses répondent réellement à la question), précision du contexte > 0,60 (la plupart des segments récupérés sont pertinents) et rappel du contexte > 0,75 (la plupart des faits essentiels sont disponibles dans le contexte récupéré). Les systèmes qui n’atteignent pas ces seuils ne doivent pas être déployés sans amélioration supplémentaire.

PRODUCTION_THRESHOLDS = {
    'faithfulness': 0.90,
    'answer_relevancy': 0.80,
    'context_precision': 0.60,
    'context_recall': 0.75
}

def check_production_readiness(metrics):
    ready = True
    print('Production readiness check:')
    for metric, threshold in PRODUCTION_THRESHOLDS.items():
        score = metrics.get(metric, 0)
        status = 'PASS' if score >= threshold else 'FAIL'
        print(f'  {metric}: {score:.2f} (>= {threshold}) -> {status}')
        if status == 'FAIL':
            ready = False
    print(f'Overall: {"READY" if ready else "NOT READY"}')
    return ready

Vérification rapide

Vérifiez votre compréhension des concepts d’ingénierie de l’IA présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris : la fidélité comme métrique au niveau des affirmations, qui vérifie que chaque énoncé de la réponse est étayé par le contexte récupéré ; la pertinence de la réponse comme métrique mesurant si la réponse traite effectivement la question ; le rappel et la précision du contexte pour mesurer la qualité de la récupération du point de vue de la génération ; et la bibliothèque RAGAS pour l’évaluation automatisée de plusieurs métriques. Ensuite, nous réunirons toutes ces métriques dans un dispositif d’évaluation automatisé que vous pourrez exécuter à chaque modification.

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 « Mesures de génération : fidélité et pertinence des réponses » est-elle gratuite ?

Oui — le texte complet de « Mesures de génération : fidélité et pertinence des réponses » 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 « Mesures de génération : fidélité et pertinence des réponses » ?

Utilisez RAGAS pour mesurer si les réponses générées sont fidèles au contexte récupéré et si elles répondent réellement à la question de l’utilisateur sans produire d’hallucinations. 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 3 sur 4.

Combien de temps prend la leçon « Mesures de génération : fidélité et pertinence des réponses » ?

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. Pourquoi l’évaluation est importante dans RAG
  2. Mesures de récupération : taux de réussite, MRR et NDCG
  3. Mesures de génération : fidélité et pertinence des réponses
  4. Construire un banc d’évaluation automatisé
← Retour à AI Engineering Academy