Cette page a été traduite par l'API Cloud Translation.

Évaluer les systèmes RAG avec Vertex AI

1. Présentation

Dans cet atelier, vous allez apprendre à créer un pipeline d'évaluation pour un système de génération augmentée par récupération (RAG). Vous allez utiliser Vertex AI Gen AI Evaluation Service pour créer des critères d'évaluation personnalisés et élaborer un cadre d'évaluation pour une tâche de questions-réponses.

Vous allez travailler avec des exemples de l'ensemble de données Stanford Question Answering Dataset (SQuAD 2.0) pour préparer des ensembles de données d'évaluation, configurer des évaluations sans référence et basées sur des références, et interpréter les résultats. À la fin de cet atelier, vous comprendrez comment évaluer les systèmes RAG et pourquoi certaines approches d'évaluation sont choisies.

Principes de base des ensembles de données

Nous allons travailler avec des exemples soigneusement conçus couvrant plusieurs domaines trouvés dans l'ensemble de données SQuAD 2.0 pour les questions/réponses :

Neurosciences : tester l'exactitude technique dans des contextes scientifiques
Histoire : évaluer la précision factuelle dans les récits historiques
Géographie : évaluation des connaissances territoriales et politiques

Cette diversité vous aide à comprendre comment les approches d'évaluation se généralisent dans différents domaines.

Références

Exemples de code : cet atelier s'appuie sur des exemples de la documentation Vertex AI Evaluation.
Ensemble de données de base : Ensemble de données de questions/réponses SQuAD 2.0
Optimiser la récupération RAG : tester, ajuster, réussir

Points abordés

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

Préparez des ensembles de données d'évaluation pour les systèmes RAG.
Implémentez une évaluation sans référence à l'aide de métriques telles que l'ancrage et la pertinence.
Appliquez une évaluation basée sur des références avec des mesures de similarité sémantique.
Créez des métriques d'évaluation personnalisées avec des rubriques de notation détaillées.
Interprétez et visualisez les résultats de l'évaluation pour choisir le modèle.

2. Configuration du projet

Compte Google

Si vous ne possédez pas encore de compte Google personnel, vous devez en créer un.

Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire.

Connectez-vous à la console Google Cloud à l'aide d'un compte Google personnel.

Activer la facturation

Utiliser 5 $de crédits Google Cloud (facultatif)

Pour suivre cet atelier, vous avez besoin d'un compte de facturation avec un certain crédit. Si vous prévoyez d'utiliser votre propre facturation, vous pouvez ignorer cette étape.

Cliquez sur ce lien et connectez-vous avec un compte Google personnel. Le résultat qui s'affiche doit ressembler à ceci :
Cliquez sur le bouton CLIQUEZ ICI POUR ACCÉDER À VOS CRÉDITS. Vous serez redirigé vers une page permettant de configurer votre profil de facturation .
Cliquez sur Confirmer. Vous êtes désormais connecté à un compte de facturation d'essai Google Cloud Platform.

Configurer un compte de facturation personnel

Si vous avez configuré la facturation à l'aide de crédits Google Cloud, vous pouvez ignorer cette étape.

Pour configurer un compte de facturation personnel, cliquez ici pour activer la facturation dans la console Cloud.

Remarques :

L'exécution de cet atelier devrait coûter moins de 1 USD en ressources Cloud.
Vous pouvez suivre les étapes à la fin de cet atelier pour supprimer les ressources et éviter ainsi que des frais supplémentaires ne vous soient facturés.
Les nouveaux utilisateurs peuvent bénéficier d'un essai sans frais pour un crédit de 300$.

Créer un projet (facultatif)

Si vous n'avez pas de projet que vous souhaitez utiliser pour cet atelier, créez-en un.

3. Qu'est-ce que la génération augmentée par récupération (RAG) ?

La génération augmentée par récupération (RAG) est une technique utilisée pour améliorer la précision factuelle et la pertinence des réponses des grands modèles de langage (LLM). Il connecte le LLM à une base de connaissances externe pour ancrer ses réponses dans des informations spécifiques et vérifiables.

Voici les étapes à suivre :

Convertir la question d'un utilisateur en représentation numérique (embedding).
Recherche dans la base de connaissances des documents avec des embeddings similaires.
Fournir ces documents pertinents comme contexte au LLM, en plus de la question d'origine, pour générer une réponse.

En savoir plus sur RAG

Pourquoi l'évaluation du RAG est-elle complexe ?

L'évaluation des systèmes RAG est différente de celle des modèles de langage traditionnels.

Le défi multicomposant : les systèmes RAG combinent trois opérations qui peuvent chacune être un point de défaillance :

Qualité de la récupération : le système a-t-il trouvé les bons documents contextuels ?
Utilisation du contexte : le modèle a-t-il utilisé efficacement les informations récupérées ?
Qualité de la génération : la réponse finale est-elle bien rédigée, utile et précise ?

Une réponse peut échouer si l'un de ces composants ne fonctionne pas comme prévu. Par exemple, le système peut récupérer le contexte approprié, mais le modèle l'ignore. Il peut également générer une réponse bien rédigée, mais incorrecte, car le contexte récupéré n'était pas pertinent.

4. Configurer votre environnement Vertex AI Workbench

Commençons par lancer un nouvel environnement de notebook dans lequel nous exécuterons le code nécessaire à l'évaluation des systèmes RAG.

Accédez à la page "API et services" de la console Cloud.
Cliquez sur Activer pour l'API Vertex AI.

Accéder à Vertex AI Workbench

Dans la console Google Cloud, accédez à Vertex AI en cliquant sur le menu de navigation ☰ > Vertex AI > Workbench.
Créez une instance Workbench.
Nommez l'instance Workbench evaluation-workbench.
Sélectionnez votre région et votre zone si ces valeurs ne sont pas déjà définies.
Cliquez sur Créer.
Attendez que l'atelier soit configuré. Cette opération peut prendre quelques minutes.
Une fois le workbench provisionné, cliquez sur Ouvrir JupyterLab.
Dans l'atelier, créez un notebook Python3.

Pour en savoir plus sur les fonctionnalités de cet environnement, consultez la documentation officielle de Vertex AI Workbench.

Installer le SDK d'évaluation Vertex AI

Installons maintenant le SDK d'évaluation spécialisé qui fournit les outils d'évaluation du RAG.

Dans la première cellule de votre notebook, ajoutez et exécutez l'instruction d'importation ci-dessous (MAJ+ENTRÉE) pour installer le SDK Vertex AI (avec les composants d'évaluation).
```
%pip install --upgrade --user --quiet google-cloud-aiplatform[evaluation]
```
Cette commande installe le SDK Vertex AI avec des extensions d'évaluation qui incluent :
- EvalTask : classe principale pour exécuter des évaluations
- MetricPromptTemplateExamples : métriques d'évaluation prédéfinies
- PointwiseMetric : framework permettant de créer des métriques personnalisées
- notebook_utils : outils de visualisation pour l'analyse des résultats
Important : Après l'installation, vous devrez redémarrer le noyau pour utiliser les nouveaux packages. Dans la barre de menu en haut de la fenêtre JupyterLab, accédez à Noyau > Redémarrer le noyau.

5. Initialiser le SDK et importer des bibliothèques

Avant de pouvoir créer le pipeline d'évaluation, vous devez configurer votre environnement. Cela implique de configurer les détails de votre projet, d'initialiser le SDK Vertex AI pour vous connecter à Google Cloud et d'importer les bibliothèques Python spécialisées que vous utiliserez pour l'évaluation.

Définissez les variables de configuration pour votre tâche d'évaluation. Dans une nouvelle cellule, ajoutez et exécutez le code suivant pour définir vos PROJECT_ID, LOCATION et un nom EXPERIMENT afin d'organiser cette exécution.

import vertexai

PROJECT_ID = "YOUR PROJECT ID"
LOCATION = "YOUR LOCATION"  # @param {type:"string"}
EXPERIMENT = "rag-eval-01"  # @param {type:"string"}

if not PROJECT_ID or PROJECT_ID == "[your-project-id]":
    raise ValueError("Please set your PROJECT_ID")

Initialisez le SDK Vertex AI. Dans une nouvelle cellule, ajoutez et exécutez le code suivant.
```
vertexai.init(project=PROJECT_ID, location=LOCATION)
```
Cette étape authentifie votre notebook et le connecte à votre projet Google Cloud.
Importez les classes nécessaires à partir du SDK d'évaluation en exécutant le code suivant dans la cellule suivante :
```
import pandas as pd
from vertexai.evaluation import EvalTask, MetricPromptTemplateExamples, PointwiseMetric
from vertexai.preview.evaluation import notebook_utils
```
Voici un récapitulatif de chaque importation :
- pandas : pour créer et gérer des données dans des DataFrames.
- EvalTask : classe principale qui exécute un job d'évaluation.
- MetricPromptTemplateExamples : fournit l'accès aux métriques d'évaluation prédéfinies de Google.
- PointwiseMetric : framework permettant de créer vos propres métriques personnalisées.
- notebook_utils : ensemble d'outils permettant de visualiser les résultats.

6. Préparer votre ensemble de données d'évaluation

Un ensemble de données bien structuré est à la base de toute évaluation fiable. Pour les systèmes RAG, votre ensemble de données doit comporter deux champs clés pour chaque exemple :

Requête : il s'agit de l'entrée totale fournie au modèle de langage. Vous devez combiner la question de l'utilisateur avec le contexte récupéré par votre système RAG (prompt = User Question + Retrieved Context). Cela permet au service d'évaluation de savoir quelles informations le modèle a utilisées pour créer sa réponse.
response : il s'agit de la réponse finale produite par votre modèle RAG.

Pour obtenir des résultats statistiquement fiables, nous vous recommandons d'utiliser un ensemble de données d'environ 100 exemples. Pour cet atelier, vous utiliserez un petit ensemble de données afin de vous montrer comment procéder.

Créons les ensembles de données. Vous commencerez par une liste de questions et le retrieved_contexts d'un système RAG. Vous définirez ensuite deux ensembles de réponses : l'un provenant d'un modèle qui semble performant (generated_answers_by_rag_a) et l'autre d'un modèle peu performant (generated_answers_by_rag_b).

Enfin, vous combinerez ces éléments dans deux DataFrames pandas, eval_dataset_rag_a et eval_dataset_rag_b, en suivant la structure décrite ci-dessus.

Dans une nouvelle cellule, ajoutez et exécutez le code suivant pour définir les questions et les deux ensembles de generated_answers.

questions = [
    "Which part of the brain does short-term memory seem to rely on?",
    "What provided the Roman senate with exuberance?",
    "What area did the Hasan-jalalians command?",
]

generated_answers_by_rag_a = [
    "frontal lobe and the parietal lobe",
    "The Roman Senate was filled with exuberance due to successes against Catiline.",
    "The Hasan-Jalalians commanded the area of Syunik and Vayots Dzor.",
]

generated_answers_by_rag_b = [
    "Occipital lobe",
    "The Roman Senate was subdued because they had food poisoning.",
    "The Galactic Empire commanded the state of Utah.",
]

Cela définit les composants de base de votre ensemble de données : les questions, les longs passages de contexte récupérés par un système RAG pour chaque question et les réponses générées par deux modèles différents (un modèle A très performant et un modèle B peu performant).

Définissez les retrieved_contexts. Ajoutez et exécutez le code suivant dans une nouvelle cellule.

retrieved_contexts = [
    "Short-term memory is supported by transient patterns of neuronal communication, dependent on regions of the frontal lobe (especially dorsolateral prefrontal cortex) and the parietal lobe. Long-term memory, on the other hand, is maintained by more stable and permanent changes in neural connections widely spread throughout the brain. The hippocampus is essential (for learning new information) to the consolidation of information from short-term to long-term memory, although it does not seem to store information itself. Without the hippocampus, new memories are unable to be stored into long-term memory, as learned from patient Henry Molaison after removal of both his hippocampi, and there will be a very short attention span. Furthermore, it may be involved in changing neural connections for a period of three months or more after the initial learning.",
    "In 62 BC, Pompey returned victorious from Asia. The Senate, elated by its successes against Catiline, refused to ratify the arrangements that Pompey had made. Pompey, in effect, became powerless. Thus, when Julius Caesar returned from a governorship in Spain in 61 BC, he found it easy to make an arrangement with Pompey. Caesar and Pompey, along with Crassus, established a private agreement, now known as the First Triumvirate. Under the agreement, Pompey's arrangements would be ratified. Caesar would be elected consul in 59 BC, and would then serve as governor of Gaul for five years. Crassus was promised a future consulship.",
    "The Seljuk Empire soon started to collapse. In the early 12th century, Armenian princes of the Zakarid noble family drove out the Seljuk Turks and established a semi-independent Armenian principality in Northern and Eastern Armenia, known as Zakarid Armenia, which lasted under the patronage of the Georgian Kingdom. The noble family of Orbelians shared control with the Zakarids in various parts of the country, especially in Syunik and Vayots Dzor, while the Armenian family of Hasan-Jalalians controlled provinces of Artsakh and Utik as the Kingdom of Artsakh.",
]

Maintenant que vous disposez de tous les composants bruts, vous allez les combiner dans les DataFrames pandas structurés requis par le service d'évaluation.

Dans une nouvelle cellule, ajoutez et exécutez le code suivant pour créer eval_dataset_rag_a et eval_dataset_rag_b.

eval_dataset_rag_a = pd.DataFrame(
    {
    "prompt": [
            "Answer the question: " + question + " Context: " + item
            for question, item in zip(questions, retrieved_contexts)
    ],
    "response": generated_answers_by_rag_a,
    }
)

eval_dataset_rag_b = pd.DataFrame(
    {
    "prompt": [
            "Answer the question: " + question + " Context: " + item
            for question, item in zip(questions, retrieved_contexts)
    ],
    "response": generated_answers_by_rag_b,
    }
)

Exécutez le code suivant dans une nouvelle cellule pour afficher les premières lignes de l'ensemble de données pour le modèle A.
```
eval_dataset_rag_a
```
C'est une bonne pratique pour s'assurer qu'il a été créé correctement.

7. Sélectionner et créer des métriques

Maintenant que les ensembles de données sont prêts, vous pouvez décider comment mesurer les performances. Vous pouvez utiliser une ou plusieurs métriques pour évaluer votre modèle. Chaque métrique évalue un aspect spécifique de la réponse du modèle, comme son exactitude factuelle ou sa pertinence.

Vous pouvez utiliser une combinaison de deux types de métriques :

Métriques prédéfinies : métriques prêtes à l'emploi fournies par le SDK pour les tâches d'évaluation courantes.
Métriques personnalisées : métriques que vous définissez pour tester les qualités pertinentes pour votre cas d'utilisation.

Dans cette section, vous allez explorer les métriques prédéfinies disponibles pour RAG.

Explorer les métriques prédéfinies

Le SDK inclut plusieurs métriques intégrées pour évaluer les systèmes de réponse aux questions. Ces métriques utilisent un modèle de langage comme "évaluateur" pour évaluer les réponses de votre modèle en fonction d'un ensemble d'instructions.

Dans une nouvelle cellule, ajoutez et exécutez le code suivant pour afficher la liste complète des noms de métriques prédéfinis :
```
MetricPromptTemplateExamples.list_example_metric_names()
```
Cette commande génère une liste des métriques disponibles que vous pouvez utiliser immédiatement.
Pour comprendre le fonctionnement de ces métriques, vous pouvez inspecter leurs modèles d'invite sous-jacents. Dans une nouvelle cellule, ajoutez et exécutez le code suivant pour afficher les instructions données au LLM évaluateur pour la métrique question_answering_quality.
```
# See the prompt example for one of the pointwise metrics
print(MetricPromptTemplateExamples.get_prompt_template("question_answering_quality"))
```

8. Création de métriques personnalisées

En plus des métriques prédéfinies, vous pouvez créer des métriques personnalisées pour évaluer des critères spécifiques à votre cas d'utilisation. Pour créer une métrique personnalisée, vous devez rédiger un modèle de requête qui indique au LLM évaluateur comment noter une réponse.

Pour créer une métrique personnalisée, vous devez suivre deux étapes :

Définissez le modèle de prompt : chaîne contenant vos instructions pour le LLM évaluateur. Un bon modèle inclut un rôle clair, des critères d'évaluation, une grille de notation et des espaces réservés tels que {prompt} et {response}.
Instanciez un objet PointwiseMetric : vous encapsulez la chaîne de modèle d'invite dans cette classe et donnez un nom à votre métrique.

Vous allez créer deux métriques personnalisées pour évaluer la pertinence et l'utilité des réponses du système RAG.

Définissez le modèle de prompt pour la métrique de pertinence. Ce modèle fournit une grille d'évaluation détaillée pour le LLM évaluateur. Dans une nouvelle cellule, ajoutez et exécutez le code suivant :

relevance_prompt_template = """
You are a professional writing evaluator. Your job is to score writing responses according to pre-defined evaluation criteria.

You will be assessing relevance, which measures the ability to respond with relevant information when given a prompt.

You will assign the writing response a score from 5, 4, 3, 2, 1, following the rating rubric and evaluation steps.

## Criteria
Relevance: The response should be relevant to the instruction and directly address the instruction.

## Rating Rubric
5 (completely relevant): Response is entirely relevant to the instruction and provides clearly defined information that addresses the instruction's core needs directly.
4 (mostly relevant): Response is mostly relevant to the instruction and addresses the instruction mostly directly.
3 (somewhat relevant): Response is somewhat relevant to the instruction and may address the instruction indirectly, but could be more relevant and more direct.
2 (somewhat irrelevant): Response is minimally relevant to the instruction and does not address the instruction directly.
1 (irrelevant): Response is completely irrelevant to the instruction.

## Evaluation Steps
STEP 1: Assess relevance: is response relevant to the instruction and directly address the instruction?
STEP 2: Score based on the criteria and rubrics.

Give step by step explanations for your scoring, and only choose scores from 5, 4, 3, 2, 1.


# User Inputs and AI-generated Response
## User Inputs
### Prompt
{prompt}

## AI-generated Response
{response}
"""

Définissez le modèle de requête pour la métrique d'utilité en utilisant la même approche. Ajoutez et exécutez le code suivant dans une nouvelle cellule :

helpfulness_prompt_template = """
You are a professional writing evaluator. Your job is to score writing responses according to pre-defined evaluation criteria.

You will be assessing helpfulness, which measures the ability to provide important details when answering a prompt.

You will assign the writing response a score from 5, 4, 3, 2, 1, following the rating rubric and evaluation steps.

## Criteria
Helpfulness: The response is comprehensive with well-defined key details. The user would feel very satisfied with the content in a good response.

## Rating Rubric
5 (completely helpful): Response is useful and very comprehensive with well-defined key details to address the needs in the instruction and usually beyond what explicitly asked. The user would feel very satisfied with the content in the response.
4 (mostly helpful): Response is very relevant to the instruction, providing clearly defined information that addresses the instruction's core needs.  It may include additional insights that go slightly beyond the immediate instruction.  The user would feel quite satisfied with the content in the response.
3 (somewhat helpful): Response is relevant to the instruction and provides some useful content, but could be more relevant, well-defined, comprehensive, and/or detailed. The user would feel somewhat satisfied with the content in the response.
2 (somewhat unhelpful): Response is minimally relevant to the instruction and may provide some vaguely useful information, but it lacks clarity and detail. It might contain minor inaccuracies. The user would feel only slightly satisfied with the content in the response.
1 (unhelpful): Response is useless/irrelevant, contains inaccurate/deceptive/misleading information, and/or contains harmful/offensive content. The user would feel not at all satisfied with the content in the response.

## Evaluation Steps
STEP 1: Assess comprehensiveness: does the response provide specific, comprehensive, and clearly defined information for the user needs expressed in the instruction?
STEP 2: Assess relevance: When appropriate for the instruction, does the response exceed the instruction by providing relevant details and related information to contextualize content and help the user better understand the response.
STEP 3: Assess accuracy: Is the response free of inaccurate, deceptive, or misleading information?
STEP 4: Assess safety: Is the response free of harmful or offensive content?

Give step by step explanations for your scoring, and only choose scores from 5, 4, 3, 2, 1.


# User Inputs and AI-generated Response
## User Inputs
### Prompt
{prompt}

## AI-generated Response
{response}
"""

Instanciez des objets PointwiseMetric pour vos deux métriques personnalisées. Cela encapsule vos modèles de requêtes dans des composants réutilisables pour la tâche d'évaluation. Ajoutez et exécutez le code suivant dans une nouvelle cellule :

relevance = PointwiseMetric(
    metric="relevance",
    metric_prompt_template=relevance_prompt_template,
)

helpfulness = PointwiseMetric(
    metric="helpfulness",
    metric_prompt_template=helpfulness_prompt_template,
)

Deux nouvelles métriques réutilisables (relevance et helpfulness) sont désormais disponibles pour votre job d'évaluation.

9. Exécuter le job d'évaluation

Maintenant que les ensembles de données et les métriques sont prêts, vous pouvez exécuter l'évaluation. Pour ce faire, vous allez créer un objet EvalTask pour chaque ensemble de données que vous souhaitez tester.

Un EvalTask regroupe les composants d'une exécution d'évaluation :

dataset : DataFrame contenant vos requêtes et vos réponses.
metrics : liste des métriques par rapport auxquelles vous souhaitez obtenir un score.
experiment : le test Vertex AI dans lequel enregistrer les résultats, ce qui vous aide à suivre et à comparer les exécutions.

Créez un EvalTask pour chaque modèle. Cet objet regroupe l'ensemble de données, les métriques et le nom du test. Ajoutez et exécutez le code suivant dans une nouvelle cellule pour configurer les tâches :

rag_eval_task_rag_a = EvalTask(
    dataset=eval_dataset_rag_a,
    metrics=[
        "question_answering_quality",
        relevance,
        helpfulness,
        "groundedness",
        "safety",
        "instruction_following",
    ],
    experiment=EXPERIMENT,
)

rag_eval_task_rag_b = EvalTask(
    dataset=eval_dataset_rag_b,
    metrics=[
        "question_answering_quality",
        relevance,
        helpfulness,
        "groundedness",
        "safety",
        "instruction_following",
    ],
    experiment=EXPERIMENT,
)

Vous avez maintenant configuré deux objets EvalTask, un pour chaque ensemble de réponses du modèle. La liste metrics que vous avez fournie illustre une fonctionnalité clé du service d'évaluation : les métriques prédéfinies (par exemple, safety) et les objets PointwiseMetric personnalisés.

Une fois les tâches configurées, exécutez-les en appelant la méthode .evaluate(). Les tâches sont alors envoyées au backend Vertex AI pour traitement, ce qui peut prendre plusieurs minutes. Dans une nouvelle cellule, ajoutez et exécutez le code suivant :
```
result_rag_a = rag_eval_task_rag_a.evaluate()
result_rag_b = rag_eval_task_rag_b.evaluate()
```

Une fois l'évaluation terminée, les résultats sont stockés dans les objets result_rag_a et result_rag_b, prêts à être analysés dans la section suivante.

10. Analyser les résultats

Les résultats de l'évaluation sont désormais disponibles. Les objets result_rag_a et result_rag_b contiennent des scores agrégés et des explications détaillées pour chaque ligne. Dans cette tâche, vous allez analyser ces résultats à l'aide des fonctions d'assistance de notebook_utils.

Afficher les résumés agrégés

Pour obtenir une vue d'ensemble, utilisez la fonction d'assistance display_eval_result() pour afficher le score moyen de chaque métrique. Dans une nouvelle cellule, ajoutez et exécutez le code suivant pour afficher le résumé du modèle A :
```
notebook_utils.display_eval_result(
    title="Model A Eval Result", eval_result=result_rag_a
)
```

Répétez l'opération pour le modèle B. Ajoutez et exécutez ce code dans une nouvelle cellule :

notebook_utils.display_eval_result(
    title="Model B Eval Result",
    eval_result=result_rag_b,
)

Visualiser les résultats de l'évaluation

Les graphiques peuvent faciliter la comparaison des performances des modèles. Vous utiliserez deux types de visualisations :

Graphique radar : affiche la "forme" des performances globales de chaque modèle. Plus la forme est grande, meilleures sont les performances globales.
Graphique à barres : pour une comparaison directe et côte à côte de chaque métrique.

Ces visualisations vous aideront à comparer les modèles sur des qualités subjectives telles que la pertinence, l'ancrage et l'utilité.

Pour préparer le tracé, combinez les résultats dans une seule liste de tuples. Chaque tuple doit contenir un nom de modèle et l'objet de résultat correspondant. Dans une nouvelle cellule, ajoutez et exécutez le code suivant :
```
eval_results = []
eval_results.append(("Model A", result_rag_a))
eval_results.append(("Model B", result_rag_b))
```

Générez maintenant un graphique radar pour comparer les modèles pour toutes les métriques à la fois. Ajoutez et exécutez le code suivant dans une nouvelle cellule :

notebook_utils.display_radar_plot(
    eval_results,
    metrics=[
    "question_answering_quality",
    "safety",
    "groundedness",
    "instruction_following",
    "relevance",
    "helpfulness",
    ],
)

Plus la forme est grande, meilleures sont les performances globales.

Pour une comparaison plus directe de chaque métrique, générez un graphique à barres. Dans une nouvelle cellule, ajoutez et exécutez le code suivant :

notebook_utils.display_bar_plot(
    eval_results,
    metrics=[
    "question_answering_quality",
    "safety",
    "groundedness",
    "instruction_following",
    "relevance",
    "helpfulness",
    ],
)

Cette visualisation permet de voir facilement l'écart de performances entre les deux modèles.

Les visualisations montreront clairement que les performances du modèle A (la grande forme sur le graphique radar et les grandes barres sur le graphique à barres) sont supérieures à celles du modèle B.

Afficher une explication détaillée pour une instance individuelle

Les scores agrégés indiquent les performances globales. Pour comprendre pourquoi un modèle a fonctionné d'une certaine manière, vous devez examiner les explications détaillées générées par le LLM évaluateur pour chaque exemple.

La fonction d'assistance display_explanations() vous permet d'inspecter les résultats individuels. Pour afficher la répartition détaillée du deuxième exemple (num=2) des résultats du modèle A, ajoutez et exécutez le code suivant dans une nouvelle cellule :
```
notebook_utils.display_explanations(result_rag_a, num=2)
```
Vous pouvez également utiliser cette fonction pour filtrer une métrique spécifique dans tous les exemples. Cela est utile pour déboguer une zone spécifique de mauvaises performances. Pour comprendre pourquoi le modèle B a obtenu de si mauvais résultats pour la métrique groundedness, ajoutez et exécutez le code suivant dans une nouvelle cellule :
```
notebook_utils.display_explanations(result_rag_b, metrics=["groundedness"])
```
Cela fournit des commentaires spécifiques sur les points faibles du modèle, ce qui est essentiel pour l'améliorer de manière itérative.

11. Évaluation référencée à l'aide d'une "réponse idéale"

Auparavant, vous avez effectué une évaluation sans référence, où la réponse du modèle était jugée uniquement en fonction du prompt. Cette méthode est utile, mais l'évaluation est subjective.

Vous allez maintenant utiliser l'évaluation référencée. Cette méthode ajoute une "réponse idéale" (également appelée réponse de référence) à l'ensemble de données. La comparaison de la réponse du modèle à une réponse de vérité terrain fournit une mesure plus objective des performances. Cela vous permet de mesurer :

Exactitude factuelle : la réponse du modèle correspond-elle aux faits de la réponse de référence ?
Similarité sémantique : la réponse du modèle a-t-elle la même signification que la réponse de référence ?
Exhaustivité : la réponse du modèle contient-elle toutes les informations clés de la réponse de référence ?

Préparer l'ensemble de données référencé

Pour effectuer une évaluation référencée, vous devez ajouter une "réponse idéale" à chaque exemple de votre ensemble de données.

Commençons par définir une liste golden_answers. La comparaison des réponses de référence avec celles du modèle A montre la valeur de cette méthode :

Question 1 (Brain) : la réponse générée et la réponse de référence sont identiques. Le modèle A est correct.
Question 2 (Sénat) : les réponses sont sémantiquement similaires, mais formulées différemment. Une bonne métrique devrait le reconnaître.
Question 3 (Hasan-Jalalians) : la réponse du modèle A est factuellement incorrecte selon le contexte. golden_answer expose cette erreur.

Dans une nouvelle cellule, définissez la liste des golden_answers.

golden_answers = [
    "frontal lobe and the parietal lobe",
    "Due to successes against Catiline.",
    "The Hasan-Jalalians commanded the area of Artsakh and Utik.",
]

Créez les DataFrames d'évaluation référencés en exécutant ce code dans la cellule suivante :

referenced_eval_dataset_rag_a = pd.DataFrame(
    {
        "prompt": [
            "Answer the question: " + question + " Context: " + item
            for question, item in zip(questions, retrieved_contexts)
        ],
        "response": generated_answers_by_rag_a,
        "reference": golden_answers,
    }
)

referenced_eval_dataset_rag_b = pd.DataFrame(
    {
        "prompt": [
            "Answer the question: " + question + " Context: " + item
            for question, item in zip(questions, retrieved_contexts)
        ],
        "response": generated_answers_by_rag_b,
        "reference": golden_answers,
    }
)

Ce code combine les réponses parfaites avec les variables existantes que vous avez créées précédemment.

Les ensembles de données sont maintenant prêts pour l'évaluation référencée.

Créer une métrique référencée personnalisée

Vous pouvez également créer des métriques personnalisées pour l'évaluation référencée. Le processus est similaire, mais le modèle de requête inclut désormais l'espace réservé {reference} pour la réponse idéale.

Avec une réponse "correcte" définitive, vous pouvez utiliser une notation binaire plus stricte (par exemple, 1 pour correct, 0 pour incorrect) pour mesurer l'exactitude factuelle. Créons une métrique question_answering_correctness qui implémente cette logique.

Définissez le modèle de requête. Dans une nouvelle cellule, ajoutez et exécutez le code suivant :

question_answering_correctness_prompt_template = """
You are a professional writing evaluator. Your job is to score writing responses according to pre-defined evaluation criteria.

You will be assessing question answering correctness, which measures the ability to correctly answer a question.

You will assign the writing response a score from 1, 0, following the rating rubric and evaluation steps.

### Criteria:
Reference claim alignment: The response should contain all claims from the reference and should not contain claims that are not present in the reference.

### Rating Rubric:
1 (correct): The response contains all claims from the reference and does not contain claims that are not present in the reference.
0 (incorrect): The response does not contain all claims from the reference, or the response contains claims that are not present in the reference.

### Evaluation Steps:
STEP 1: Assess the response' correctness by comparing with the reference according to the criteria.
STEP 2: Score based on the rubrics.

Give step by step explanations for your scoring, and only choose scores from 1, 0.


# User Inputs and AI-generated Response
## User Inputs
### Prompt
{prompt}

## Reference
{reference}

## AI-generated Response
{response}

"""

Ce modèle demande au LLM évaluateur de comparer strictement la {réponse} du modèle à la {référence} de la réponse idéale, en lui attribuant la note 1 (correct) ou 0 (incorrect).

Encapsulez la chaîne du modèle d'invite dans un objet PointwiseMetric. Cela donne un nom formel à votre métrique et en fait un composant réutilisable pour le job d'évaluation. Ajoutez et exécutez le code suivant dans une nouvelle cellule :
```
question_answering_correctness = PointwiseMetric(
    metric="question_answering_correctness",
    metric_prompt_template=question_answering_correctness_prompt_template,
)
```

Vous disposez désormais d'une métrique personnalisée référencée pour une vérification stricte des faits.

12. Exécuter l'évaluation référencée

Vous allez maintenant configurer le job d'évaluation avec les ensembles de données référencés et la nouvelle métrique. Vous utiliserez à nouveau la classe EvalTask.

La liste des métriques combine désormais votre métrique personnalisée basée sur un modèle avec les métriques basées sur des calculs. L'évaluation référencée permet d'utiliser des métriques traditionnelles basées sur des calculs qui effectuent des comparaisons mathématiques entre le texte généré et le texte de référence. Vous en utiliserez trois courants :

exact_match : le score est de 1 uniquement si la réponse générée est identique à la réponse de référence, et de 0 dans le cas contraire.
bleu : métrique de précision. Elle mesure le nombre de mots de la réponse générée qui figurent également dans la réponse de référence.
rouge : métrique de rappel. Il mesure le nombre de mots de la réponse de référence qui sont repris dans la réponse générée.

Configurez le job d'évaluation avec les ensembles de données référencés et le nouveau mélange de métriques. Dans une nouvelle cellule, ajoutez et exécutez le code suivant pour créer les objets EvalTask :

referenced_answer_eval_task_rag_a = EvalTask(
    dataset=referenced_eval_dataset_rag_a,
    metrics=[
    question_answering_correctness,
    "rouge",
    "bleu",
    "exact_match",
    ],
    experiment=EXPERIMENT,
)

referenced_answer_eval_task_rag_b = EvalTask(
    dataset=referenced_eval_dataset_rag_b,
    metrics=[
    question_answering_correctness,
    "rouge",
    "bleu",
    "exact_match",
    ],
    experiment=EXPERIMENT,
)

Exécutez l'évaluation référencée en appelant la méthode .evaluate(). Ajoutez et exécutez ce code dans une nouvelle cellule :

referenced_result_rag_a = referenced_answer_eval_task_rag_a.evaluate()
referenced_result_rag_b = referenced_answer_eval_task_rag_b.evaluate()

13. Analyser les résultats référencés

L'évaluation est terminée. Dans cette tâche, vous allez analyser les résultats pour mesurer l'exactitude factuelle des modèles en comparant leurs réponses aux réponses de référence.

Afficher les résultats récapitulatifs

Analysez les résultats récapitulatifs de l'évaluation référencée. Dans une nouvelle cellule, ajoutez et exécutez le code suivant pour afficher les tableaux récapitulatifs des deux modèles :
```
notebook_utils.display_eval_result(
    title="Model A Eval Result",
    eval_result=referenced_result_rag_a,
)
notebook_utils.display_eval_result(
    title="Model B Eval Result",
    eval_result=referenced_result_rag_b,
)
```
Vous remarquerez que le modèle A est performant pour votre métrique personnalisée question_answering_correctness, mais qu'il obtient un score plus faible pour exact_match. Cela met en évidence la valeur des métriques basées sur des modèles, qui peuvent reconnaître la similarité sémantique, et pas seulement le texte identique.

Visualiser les résultats pour les comparer

Les visualisations peuvent rendre plus évidente la différence de performances entre les deux modèles. Commencez par combiner les résultats dans une seule liste pour le tracé, puis générez les graphiques radar et à barres.

Combinez les résultats d'évaluation référencés dans une seule liste pour le tracé. Ajoutez et exécutez le code suivant dans une nouvelle cellule :

referenced_eval_results = []
referenced_eval_results.append(("Model A", referenced_result_rag_a))
referenced_eval_results.append(("Model B", referenced_result_rag_b))

Générez un graphique radar pour visualiser les performances de chaque modèle pour le nouvel ensemble de métriques. Ajoutez et exécutez ce code dans une nouvelle cellule :

notebook_utils.display_radar_plot(
    referenced_eval_results,
    metrics=[
        "question_answering_correctness",
        "rouge",
        "bleu",
        "exact_match",
    ],
)

Créez un graphique à barres pour une comparaison directe côte à côte. Vous verrez ainsi les performances de chaque modèle pour les différentes métriques. Ajoutez et exécutez le code suivant dans une nouvelle cellule :

notebook_utils.display_bar_plot(
    referenced_eval_results,
    metrics=[
        "question_answering_correctness",
        "rouge",
        "bleu",
        "exact_match",
    ],
)

Ces visualisations confirment que le modèle A est beaucoup plus précis et factuel que le modèle B par rapport aux réponses de référence.

14. De la pratique à la production

Vous avez exécuté avec succès un pipeline d'évaluation complet pour un système RAG. Cette dernière section résume les principaux concepts stratégiques que vous avez appris et fournit un cadre pour appliquer ces compétences à des projets concrets.

Bonnes pratiques en production

Pour appliquer les compétences acquises dans cet atelier à un environnement de production réel, tenez compte des quatre pratiques clés suivantes :

Automatiser avec CI/CD : intégrez votre suite d'évaluation dans un pipeline CI/CD (par exemple, Cloud Build, GitHub Actions). Exécutez automatiquement des évaluations sur les modifications de code pour détecter les régressions et bloquer les déploiements si les scores de qualité sont inférieurs à vos normes.
Faites évoluer vos ensembles de données : un ensemble de données statique devient obsolète. Contrôlez les versions de vos ensembles de tests "en or" (à l'aide de Git LFS ou de Cloud Storage) et ajoutez en permanence de nouveaux exemples difficiles en échantillonnant des requêtes utilisateur réelles (anonymisées).
Évaluez le récupérateur, et pas seulement le générateur : une bonne réponse est impossible sans le bon contexte. Implémentez une étape d'évaluation distincte pour votre système de récupération à l'aide de métriques telles que le taux de réussite (le bon document a-t-il été trouvé ?) et le rang réciproque moyen (MRR) (le bon document était-il bien classé ?).
Surveillez les métriques au fil du temps : exportez les scores récapitulatifs de vos exécutions d'évaluation vers un service tel que Google Cloud Monitoring. Créez des tableaux de bord pour suivre les tendances de qualité et configurez des alertes automatiques pour être averti en cas de baisse significative des performances.

Matrice de méthodologie d'évaluation avancée

Le choix de la bonne approche d'évaluation dépend de vos objectifs spécifiques. Cette matrice résume quand utiliser chaque méthode.

Approche d'évaluation	Meilleurs cas d'utilisation	Principaux avantages	Limites
Sans référence	Surveillance de la production, évaluation continue	Pas besoin de réponses parfaites, évalue la qualité subjective	Plus coûteux, risque de biais de l'évaluateur
Basé sur une référence	Comparaison de modèles, benchmarking	Mesure objective, calcul plus rapide	Nécessite des réponses parfaites, peut passer à côté de l'équivalence sémantique
Métriques personnalisées	Évaluation spécifique à un domaine	Adapté aux besoins de l'entreprise	Nécessite une validation, frais de développement
Approche hybride	Systèmes de production complets	Le meilleur de toutes les approches	Complexité élevée, optimisation des coûts nécessaire

Informations techniques clés

Gardez ces principes fondamentaux à l'esprit lorsque vous créez et évaluez vos propres systèmes RAG :

L'ancrage est essentiel pour la RAG : cette métrique permet de distinguer de manière cohérente les systèmes RAG de haute qualité de ceux de basse qualité, ce qui la rend essentielle pour la surveillance de la production.
Plusieurs métriques pour une robustesse accrue : aucune métrique ne capture à elle seule tous les aspects de la qualité du RAG. Une évaluation complète nécessite plusieurs dimensions d'évaluation.
Les métriques personnalisées apportent une valeur ajoutée significative : les critères d'évaluation spécifiques à un domaine capturent souvent des nuances que les métriques génériques ne prennent pas en compte, ce qui améliore la précision de l'évaluation.
La rigueur statistique permet d'avoir confiance dans les résultats : des tailles d'échantillon appropriées et des tests de signification transforment l'évaluation, qui n'est plus une simple devinette, en un outil fiable d'aide à la décision.

Cadre de décision pour le déploiement en production

Utilisez ce framework par étapes comme guide pour les futurs déploiements de systèmes RAG :

Phase 1 : Développement : utilisez l'évaluation basée sur des références avec des ensembles de test connus pour comparer et sélectionner des modèles.
Phase 2 : Préproduction : effectuez une évaluation complète combinant les deux approches pour valider la préparation à la production.
Phase 3 : Production : implémentez la surveillance sans référence pour une évaluation continue de la qualité sans réponses de référence.
Phase 4 : Optimisation : utilisez les insights d'évaluation pour améliorer les modèles et le système de récupération.

15. Conclusion

Félicitations ! Vous avez terminé l'atelier.

Cet atelier fait partie du parcours de formation "IA prête pour la production avec Google Cloud".

Explorez le programme complet pour combler le fossé entre le prototype et la production.
Partagez votre progression avec le hashtag ProductionReadyAI.

Récapitulatif

Vous avez appris à :

Effectuez une évaluation sans référence pour évaluer la qualité d'une réponse en fonction du contexte récupéré.
Effectuez une évaluation référencée en ajoutant une "réponse idéale" pour mesurer l'exactitude factuelle.
Utilisez un mélange de métriques prédéfinies et personnalisées pour les deux approches.
Utilisez à la fois des métriques basées sur un modèle (comme question_answering_quality) et des métriques basées sur des calculs (rouge, bleu, exact_match).
Analysez et visualisez les résultats pour comprendre les points forts et les points faibles d'un modèle.

Cette approche d'évaluation vous aide à créer des applications d'IA générative plus fiables et précises.