Une fois que vous avez créé un ensemble de données d'évaluation, l'étape suivante consiste à définir les métriques utilisées pour mesurer les performances du modèle. Les modèles d'IA générative peuvent créer des applications pour un large éventail de tâches. Le service d'évaluation de l'IA générative utilise un framework axé sur les tests qui transforme l'évaluation, passant de notes subjectives à des résultats objectifs et exploitables.
Pour en savoir plus sur les types de métriques, consultez la section Métriques d'évaluation de la page de présentation de Gen AI Evaluation Service.
Métrique de qualité générale
Vous pouvez accéder aux rubriques adaptatives via le SDK. Nous vous recommandons de commencer par définir GENERAL_QUALITY comme valeur par défaut.
GENERAL_QUALITY génère un ensemble de rubriques couvrant diverses tâches telles que le respect des instructions, la mise en forme, le ton et le style, en fonction de la requête saisie. Vous pouvez combiner la génération de rubriques avec la validation dans la ligne de code suivante :
from vertexai import types
eval_result = client.evals.evaluate(
dataset=eval_dataset,
metrics=[
types.RubricMetric.GENERAL_QUALITY,
],
)
Vous pouvez générer des grilles d'évaluation séparément (pour les examiner ou les réutiliser dans différents modèles et agents) avant de les utiliser pour évaluer les réponses du modèle :
from vertexai import types
# Use GENERAL_QUALITY recipe to generate rubrics, and store them
# as a rubric group named "general_quality_rubrics".
data_with_rubrics = client.evals.generate_rubrics(
src=eval_dataset_df,
rubric_group_name="general_quality_rubrics",
predefined_spec_name=types.RubricMetric.GENERAL_QUALITY,
)
# Specify the group of rubrics to use for the evaluation.
eval_result = client.evals.evaluate(
dataset=data_with_rubrics,
metrics=[types.RubricMetric.GENERAL_QUALITY(
rubric_group_name="general_quality_rubrics",
)],
)
Vous pouvez également guider GENERAL_QUALITY avec le langage naturel guidelines pour que la génération de la grille d'évaluation se concentre sur les critères qui vous importent le plus. Le service d'évaluation de l'IA générative génère ensuite des rubriques couvrant à la fois ses tâches par défaut et les consignes que vous spécifiez.
from vertexai import types
eval_result = client.evals.evaluate(
dataset=eval_dataset,
metrics=[
types.RubricMetric.GENERAL_QUALITY(
metric_spec_parameters={
"guidelines": "The response must maintain a professional tone and must not provide financial advice."
}
)
],
)
Métriques de qualité ciblées
Si vous devez évaluer un aspect plus ciblé de la qualité du modèle, vous pouvez utiliser des métriques qui génèrent des rubriques axées sur un domaine spécifique. Exemple :
from vertexai import types
eval_result = client.evals.evaluate(
dataset=eval_dataset,
metrics=[
types.RubricMetric.TEXT_QUALITY,
types.RubricMetric.INSTRUCTION_FOLLOWING,
],
)
Le service d'évaluation de l'IA générative propose les types de rubriques adaptatives suivants :
INSTRUCTION_FOLLOWING: mesure dans quelle mesure la réponse respecte les contraintes et instructions spécifiques du prompt.TEXT_QUALITY: se concentre spécifiquement sur la qualité linguistique de la réponse, en évaluant la fluidité, la cohérence et la grammaire.
Conversation multitours
multi_turn_general_quality: évalue la qualité globale de la conversation dans un dialogue multitour.multi_turn_text_quality: évalue la qualité du texte des réponses dans un dialogue multitour.
Évaluation des agents
final_response_reference_free: évalue la qualité de la réponse finale d'un agent sans avoir besoin d'une réponse de référence.final_response_quality: utilise des rubriques adaptatives pour évaluer la qualité de la réponse finale d'un agent en fonction de sa configuration et de l'utilisation des outils.hallucination: évalue si les réponses textuelles d'un agent sont ancrées en fonction de la configuration de l'agent et de l'utilisation des outils.tool_use_quality: évalue l'exactitude des appels de fonction effectués par l'agent pour répondre à une requête utilisateur.
Pour en savoir plus sur les rubriques adaptatives ciblées, consultez Détails sur les rubriques adaptatives.
Grilles statiques
Une grille statique applique un ensemble fixe de consignes de notation à chaque exemple de votre ensemble de données. Cette approche basée sur les scores est utile lorsque vous devez mesurer les performances par rapport à un benchmark cohérent pour toutes les requêtes.
Par exemple, la grille statique suivante évalue la qualité du texte sur une échelle de 1 à 5 :
5: (Very good). Exceptionally clear, coherent, fluent, and concise. Fully adheres to instructions and stays grounded.
4: (Good). Well-written, coherent, and fluent. Mostly adheres to instructions and stays grounded. Minor room for improvement.
3: (Ok). Adequate writing with decent coherence and fluency. Partially fulfills instructions and may contain minor ungrounded information. Could be more concise.
2: (Bad). Poorly written, lacking coherence and fluency. Struggles to adhere to instructions and may include ungrounded information. Issues with conciseness.
1: (Very bad). Very poorly written, incoherent, and non-fluent. Fails to follow instructions and contains substantial ungrounded information. Severely lacking in conciseness.
Le service d'évaluation de l'IA générative fournit les métriques de grille statique suivantes :
GROUNDING: vérifie la factualité et la cohérence par rapport à un texte source fourni (vérité terrain). Cette métrique est essentielle pour les systèmes RAG.SAFETY: évalue si la réponse du modèle enfreint les règles de sécurité, par exemple en cas d'incitation à la haine ou de contenu dangereux.
Vous pouvez également utiliser des modèles de requêtes de métriques tels que FLUENCY.
from vertexai import types
eval_result = client.evals.evaluate(
dataset=eval_dataset,
metrics=[
types.RubricMetric.SAFETY,
types.RubricMetric.GROUNDING,
types.RubricMetric.FLUENCY,
],
)
Personnaliser des rubriques statiques
Si vous avez des besoins très spécifiques, vous pouvez créer votre propre grille statique. Cette méthode offre un contrôle maximal, mais vous devez concevoir soigneusement l'invite d'évaluation pour obtenir des résultats cohérents et fiables. Nous vous recommandons d'utiliser des consignes avec GENERAL_QUALITY avant de personnaliser des grilles statiques.
# Define a custom metric to evaluate language simplicity
simplicity_metric = types.LLMMetric(
name='language_simplicity',
prompt_template=types.MetricPromptBuilder(
instruction="Evaluate the story's simplicity for a 5-year-old.",
criteria={
"Vocabulary": "Uses simple words.",
"Sentences": "Uses short sentences.",
},
rating_scores={
"5": "Excellent: Very simple, ideal for a 5-year-old.",
"4": "Good: Mostly simple, with minor complex parts.",
"3": "Fair: Mix of simple and complex; may be challenging for a 5-year-old.",
"2": "Poor: Largely too complex, with difficult words/sentences.",
"1": "Very Poor: Very complex, unsuitable for a 5-year-old."
}
)
)
eval_result = client.evals.evaluate(
dataset=eval_dataset,
metrics=[
simplicity_metric
],
)
Métriques issues de calculs
Les métriques basées sur le calcul utilisent des algorithmes déterministes pour évaluer la réponse d'un modèle en la comparant à une réponse de référence. Elles nécessitent une vérité terrain dans votre ensemble de données et sont idéales pour les tâches où une réponse "correcte" est bien définie.
Recall-Oriented Understudy for Gisting Evaluation (rouge_l, rouge_1) : mesure le chevauchement des n-grammes (séquences de mots contigus) entre la réponse du modèle et un texte de référence. Il est couramment utilisé pour évaluer la synthèse de texte.
Bilingual Evaluation Understudy (BLEU) : mesure la similitude d'une réponse par rapport à un texte de référence de haute qualité en comptant les n-grammes correspondants. Il s'agit de la métrique standard pour la qualité de la traduction, mais elle peut également être utilisée pour d'autres tâches de génération de texte.
Correspondance exacte (exact_match) : mesure le pourcentage de réponses identiques à la réponse de référence. Cela est utile pour les questions-réponses basées sur des faits ou les tâches pour lesquelles il n'existe qu'une seule réponse correcte.
from vertexai import types
eval_result = client.evals.evaluate(
dataset=eval_dataset,
metrics=[
types.Metric(name='bleu'),
types.Metric(name='rouge_l'),
types.Metric(name='exact_match')
],
)
Métrique de fonction personnalisée
Vous pouvez également implémenter une logique d'évaluation personnalisée en transmettant une fonction Python personnalisée au paramètre custom_function. Le service d'évaluation de l'IA générative exécute cette fonction pour chaque ligne de votre ensemble de données.
# Define a custom function to check for the presence of a keyword
def contains_keyword(instance: dict) -> dict:
keyword = "magic"
response_text = instance.get("response", "")
score = 1.0 if keyword in response_text.lower() else 0.0
return {"score": score}
keyword_metric = types.Metric(
name="keyword_check",
custom_function=contains_keyword
)
eval_result = client.evals.evaluate(
dataset=eval_dataset,
metrics=[keyword_metric]
)
Métrique de fonction personnalisée à distance
En plus d'exécuter une logique d'évaluation personnalisée en local, vous pouvez implémenter une logique d'évaluation personnalisée qui s'exécute de manière sécurisée dans un environnement de bac à sable distant. Cela est utile lorsque vous souhaitez intégrer l'évaluation à votre workflow d'ajustement de modèle ou lorsque vous avez un scénario spécifique à l'utilisateur qui n'est pas couvert par les métriques d'évaluation existantes. Pour ce faire, vous pouvez transmettre un extrait de code Python sous forme de chaîne au paramètre remote_custom_function de la classe Metric. Le service d'évaluation de l'IA générative exécute cette fonction à distance pour chaque ligne de votre ensemble de données.
import pandas as pd
from vertexai import types
code_snippet = """
def evaluate(instance):
if instance['response'] == instance['reference']:
return 1.0
return 0.0
"""
custom_metric = types.Metric(
name="my_custom_code_metric",
remote_custom_function=code_snippet,
)
prompts_df = pd.DataFrame(
{
"prompt": ["What is 2+2?", "What is 3+3?"],
"response": ["4", "5"],
"reference": ["4", "6"],
}
)
eval_dataset = types.EvaluationDataset(
eval_dataset_df=prompts_df,
candidate_name="test_model",
)
evaluation_result = client.evals.evaluate(
dataset=eval_dataset,
metrics=[custom_metric],
)
Entrées d'instance d'évaluation
La fonction evaluate accepte un dictionnaire instance comme argument. instance représente l'instance d'évaluation, et tous les champs renseignés dans EvaluationInstance sont disponibles pour la fonction en tant que instance[field_name]. Voici les champs disponibles :
prompt: requête utilisateur envoyée au modèle.response: résultat généré par le modèle.reference: vérité terrain utilisée pour effectuer une comparaison avec la réponse.rubric_groups: groupes nommés de rubriques associés à la requête.other_data: autres données utilisées pour remplir les espaces réservés en fonction de leur clé.agent_eval_data: données spécifiques aux évaluations des agents, telles que les configurations et les traces des agents.
Contraintes techniques
- Environnement d'exécution : le code personnalisé s'exécute dans un environnement de bac à sable sans accès au réseau.
- Limite de temps d'exécution : l'exécution de la notation est limitée à une minute.
- Limite de mémoire : la taille totale du code importé, combinée à toutes les données chargées lors de l'exécution, ne doit pas dépasser 1,5 Go.
Les packages tiers suivants sont disponibles au moment de l'exécution :
altair
chess
cv2
deepdiff
editdistance
jsonschema
matplotlib
mpmath
nltk
numpy
pandas
pdfminer
pydantic
rdkit
reportlab
scipy
seaborn
sklearn
sqlparse
statsmodels
striprtf
sympy
tabulate