Évaluer votre application IA générative localement avec le Kit de développement logiciel (SDK) Azure AI Evaluation (préversion)

Vous pouvez évaluer minutieusement les performances de votre application IA générative en l’appliquant à un jeu de données important. Évaluez l’application dans votre environnement de développement avec le Kit de développement logiciel (SDK) Azure AI Evaluation.

Lorsque vous fournissez un jeu de données de test ou une cible, vos sorties d’application IA génératives sont mesurées quantitativement avec des métriques mathématiques et des évaluateurs de qualité et de sécurité assistés par l’IA. Des évaluateurs intégrés ou personnalisés vous fournissent des aperçus complets sur les fonctionnalités et limitations de l’application.

Dans cet article, vous allez apprendre à exécuter des évaluateurs sur une seule ligne de données et un jeu de données de test plus volumineux sur une cible d’application. Vous utilisez des évaluateurs intégrés qui utilisent le Kit de développement logiciel (SDK) Azure AI Evaluation localement. Ensuite, vous apprenez à suivre les résultats et les journaux d’évaluation dans un projet Foundry.

Commencez

Tout d’abord, installez le package des évaluateurs à partir du Kit de développement logiciel (SDK) Azure AI Evaluation :

pip install azure-ai-evaluation

Évaluateurs intégrés

Les métriques de qualité et de sécurité intégrées acceptent des paires de requêtes et de réponses, ainsi que des informations supplémentaires pour des évaluateurs spécifiques.

Exigences en matière de données pour les programmes d’évaluation intégrés

Les évaluateurs intégrés peuvent accepter des paires de requêtes et de réponses, une liste de conversations au format JSON Lines (JSONL) ou les deux.

Les classateurs Azure OpenAI nécessitent un modèle qui décrit la façon dont leurs colonnes d’entrée sont transformées en entrée réelle utilisée par le gradeur. Par exemple, si vous avez deux entrées appelées requête et réponse, et un modèle mis en forme comme {{item.query}}, seule la requête est utilisée. De même, vous pourriez avoir quelque chose comme {{item.conversation}} pour accepter une entrée de conversation, mais la capacité du système à gérer cela dépend de la façon dont vous configurez le reste du classeur pour s’attendre à cette entrée.

Pour plus d’informations sur les exigences en matière de données pour les évaluateurs agentiques, consultez Évaluer vos agents IA.

Prise en charge à tour unique du texte

Tous les évaluateurs intégrés prennent des entrées à tour unique sous forme de paires requête-réponse dans des chaînes de caractères. Par exemple:

from azure.ai.evaluation import RelevanceEvaluator

query = "What is the capital of life?"
response = "Paris."

# Initialize an evaluator:
relevance_eval = RelevanceEvaluator(model_config)
relevance_eval(query=query, response=response)

Pour exécuter des évaluations par lots à l’aide d’une évaluation locale ou charger votre jeu de données pour exécuter une évaluation cloud, représentez le jeu de données au format JSONL. Les données à tour unique précédentes, qui sont une paire requête-réponse, sont équivalentes à une ligne d’un jeu de données comme l’exemple suivant, qui montre trois lignes :

{"query":"What is the capital of France?","response":"Paris."}
{"query":"What atoms compose water?","response":"Hydrogen and oxygen."}
{"query":"What color is my shirt?","response":"Blue."}

Le jeu de données de test d’évaluation peut contenir les éléments suivants, en fonction des exigences de chaque évaluateur intégré :

• Requête : requête envoyée à l’application IA générative.
• Réponse : réponse à la requête générée par l’application IA générative.
• Contexte : la source sur laquelle la réponse générée est basée. C’est-à-dire les documents de base.
• Vérité de base : la réponse générée par un utilisateur ou un humain comme réponse réelle.

Pour voir ce dont chaque évaluateur a besoin, consultez Évaluateurs.

Assistance pour les conversations textuelles

Pour les évaluateurs qui prennent en charge le texte pour les conversations, vous pouvez fournir conversation comme entrée. Cette entrée inclut un dictionnaire Python avec une liste de messages, qui inclut content, roleet éventuellement context.

Consultez la conversation à deux tour suivante dans Python :

conversation = {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": None
        }
        ]
}

Pour exécuter des évaluations par lots à l’aide d’une évaluation locale ou charger votre jeu de données pour exécuter l’évaluation cloud, vous devez représenter le jeu de données au format JSONL. La conversation précédente équivaut à une ligne de jeu de données dans un fichier JSONL comme dans l’exemple suivant :

{"conversation":
    {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": null
        }
        ]
    }
}

Nos évaluateurs comprennent que le premier tour de la conversation fournit une valeur valide query à partir de user, context à partir de assistant et response à partir assistant dans le format de requête-réponse. Les conversations sont évaluées par tour et les résultats sont agrégés sur tous les tours pour produire un score de conversation.

Pour le mode conversation, voici un exemple pour GroundednessEvaluator :

# Conversation mode:
import json
import os
from azure.ai.evaluation import GroundednessEvaluator, AzureOpenAIModelConfiguration

model_config = AzureOpenAIModelConfiguration(
    azure_endpoint=os.environ.get("AZURE_ENDPOINT"),
    api_key=os.environ.get("AZURE_API_KEY"),
    azure_deployment=os.environ.get("AZURE_DEPLOYMENT_NAME"),
    api_version=os.environ.get("AZURE_API_VERSION"),
)

# Initialize the Groundedness evaluator:
groundedness_eval = GroundednessEvaluator(model_config)

conversation = {
    "messages": [
        { "content": "Which tent is the most waterproof?", "role": "user" },
        { "content": "The Alpine Explorer Tent is the most waterproof", "role": "assistant", "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight." },
        { "content": "How much does it cost?", "role": "user" },
        { "content": "$120.", "role": "assistant", "context": "The Alpine Explorer Tent is $120."}
    ]
}

# Alternatively, you can load the same content from a JSONL file.
groundedness_conv_score = groundedness_eval(conversation=conversation)
print(json.dumps(groundedness_conv_score, indent=4))

Pour les sorties de conversation, les résultats par tour sont stockés dans une liste et le score de conversation global 'groundedness': 4.0 est moyenné au fil des tours :

{
    "groundedness": 5.0,
    "gpt_groundedness": 5.0,
    "groundedness_threshold": 3.0,
    "evaluation_per_turn": {
        "groundedness": [
            5.0,
            5.0
        ],
        "gpt_groundedness": [
            5.0,
            5.0
        ],
        "groundedness_reason": [
            "The response accurately and completely answers the query by stating that the Alpine Explorer Tent is the most waterproof, which is directly supported by the context. There are no irrelevant details or incorrect information present.",
            "The RESPONSE directly answers the QUERY with the exact information provided in the CONTEXT, making it fully correct and complete."
        ],
        "groundedness_result": [
            "pass",
            "pass"
        ],
        "groundedness_threshold": [
            3,
            3
        ]
    }
}

Prise en charge des conversations multimodales combinant à la fois des images et du texte

Pour les évaluateurs qui prennent en charge les conversations impliquant des images et des contenus multimodaux image et texte, vous pouvez transmettre des URL d’image ou des images codées en Base64 dans conversation.

Les scénarios pris en charge sont les suivants :

• Plusieurs images avec du texte comme entrée pour la génération d'images ou de texte.
• Entrée de texte uniquement pour la génération d'images.
• Entrée image uniquement pour la génération de texte.

from pathlib import Path
from azure.ai.evaluation import ContentSafetyEvaluator
import base64

# Create an instance of an evaluator with image and multi-modal support.
safety_evaluator = ContentSafetyEvaluator(credential=azure_cred, azure_ai_project=project_scope)

# Example of a conversation with an image URL:
conversation_image_url = {
    "messages": [
        {
            "role": "system",
            "content": [
                {"type": "text", "text": "You are an AI assistant that understands images."}
            ],
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Can you describe this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://cdn.britannica.com/68/178268-050-5B4E7FB6/Tom-Cruise-2013.jpg"
                    },
                },
            ],
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "The image shows a man with short brown hair smiling, wearing a dark-colored shirt.",
                }
            ],
        },
    ]
}

# Example of a conversation with base64 encoded images:
base64_image = ""

with Path.open("Image1.jpg", "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

conversation_base64 = {
    "messages": [
        {"content": "create an image of a branded apple", "role": "user"},
        {
            "content": [{"type": "image_url", "image_url": {"url": f"data:image/jpg;base64,{base64_image}"}}],
            "role": "assistant",
        },
    ]
}

# Run the evaluation on the conversation to output the result.
safety_score = safety_evaluator(conversation=conversation_image_url)

Actuellement, les évaluateurs d'image et multimodaux prennent en charge :

• Un seul tour : une conversation ne peut avoir qu’un seul message utilisateur et un seul message d’assistant.
• Conversations qui n’ont qu’un seul message système.
• Charges utiles de conversation inférieures à 10 Mo, y compris les images.
• URL absolues et images codées en Base64.
• Plusieurs images à un seul tour.
• Formats de fichiers JPG/JPEG, PNG et GIF.

Configurer

Pour les évaluateurs de qualité assistés par l’IA, à l’exception de l’aperçu GroundednessProEvaluator, vous devez spécifier un modèle GPT (gpt-35-turbo, gpt-4, gpt-4-turbo, gpt-4o ou gpt-4o-mini) dans votre model_config. Le modèle GPT agit en tant que juge pour noter les données d’évaluation. Nous prenons en charge les schémas de configuration des modèles Azure OpenAI et OpenAI. Pour obtenir les meilleures performances et analyser les réponses avec nos évaluateurs, nous vous recommandons d’utiliser des modèles GPT qui ne sont pas en préversion.

Pour tous les évaluateurs de risque et de sécurité et GroundednessProEvaluator (préversion), au lieu d’un déploiement GPT dans model_config, vous devez fournir vos informations azure_ai_project. Cela accède au service d’évaluation back-end à l’aide de votre projet Foundry.

Requêtes pour les évaluateurs intégrés assistés par l’IA

Pour plus de transparence, nous publions en open source les invites de nos évaluateurs de qualité dans notre Evaluator Library et dans le référentiel Azure AI Evaluation Python SDK, à l’exception des évaluateurs de sécurité et de GroundednessProEvaluator, alimentés par Azure AI Sécurité du Contenu. Ces invites servent d’instructions pour un modèle de langage pour effectuer leur tâche d’évaluation, ce qui nécessite une définition conviviale de la métrique et de ses rubriques de notation associées. Nous vous recommandons vivement de personnaliser les définitions et les rubriques de notation en fonction de vos spécificités de scénario. Pour plus d’informations, consultez Évaluateurs personnalisés.

Évaluateurs composites

Les évaluateurs composites sont des évaluateurs intégrés qui combinent des mesures de qualité ou de sécurité individuelles. Ils fournissent un large éventail de métriques directement prêtes à l’emploi pour les deux paires de réponses de requête ou les messages de conversation.

Évaluation locale sur les jeux de données de test à l’aide de evaluate()

Une fois que vous avez vérifié vos évaluateurs intégrés ou personnalisés sur une seule ligne de données, vous pouvez combiner plusieurs évaluateurs avec l’API evaluate() sur un jeu de données de test entier.

Étapes de configuration requise pour les projets Microsoft Foundry

Si cette session est la première fois que vous exécutez des évaluations et que vous la journalisez dans votre projet Foundry, vous devrez peut-être effectuer les étapes de configuration suivantes :

1. Créez et connectez votre compte de stockage à votre projet Foundry au niveau de la ressource. Ce modèle bicep provisionne et connecte un compte de stockage à votre projet Foundry avec l’authentification par clé.
2. Vérifiez que le compte de stockage connecté a accès à tous les projets.
3. Si vous avez connecté votre compte de stockage avec Microsoft Entra ID, assurez-vous d’autoriser Microsoft Identity pour le Propriétaire des données blob du stockage sur votre compte et sur la ressource du projet Foundry dans le Portail Azure.

Évaluer sur un jeu de données et consigner les résultats dans Foundry

Pour vous assurer que l’API evaluate() peut analyser correctement les données, vous devez spécifier le mappage de colonnes pour mapper la colonne du jeu de données aux mots clés acceptés par les évaluateurs. Cet exemple spécifie le mappage de données pour query, responseet context.

from azure.ai.evaluation import evaluate

result = evaluate(
    data="data.jsonl", # Provide your data here:
    evaluators={
        "groundedness": groundedness_eval,
        "answer_length": answer_length
    },
    # Column mapping:
    evaluator_config={
        "groundedness": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${data.context}",
                "response": "${data.response}"
            } 
        }
    },
    # Optionally, provide your Foundry project information to track your evaluation results in your project portal.
    azure_ai_project = azure_ai_project,
    # Optionally, provide an output path to dump a JSON file of metric summary, row-level data, and the metric and Foundry project URL.
    output_path="./myevalresults.json"
)

L’évaluateur génère un dictionnaire, qui contient des metrics d’agrégation ainsi que des données et des métriques au niveau des lignes. Consultez l’exemple de sortie suivant :

{'metrics': {'answer_length.value': 49.333333333333336,
             'groundedness.gpt_groundeness': 5.0, 'groundedness.groundeness': 5.0},
 'rows': [{'inputs.response': 'Paris is the capital of France.',
           'inputs.context': 'Paris has been the capital of France since '
                                  'the 10th century and is known for its '
                                  'cultural and historical landmarks.',
           'inputs.query': 'What is the capital of France?',
           'outputs.answer_length.value': 31,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'Albert Einstein developed the theory of '
                            'relativity.',
           'inputs.context': 'Albert Einstein developed the theory of '
                                  'relativity, with his special relativity '
                                  'published in 1905 and general relativity in '
                                  '1915.',
           'inputs.query': 'Who developed the theory of relativity?',
           'outputs.answer_length.value': 51,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'The speed of light is approximately 299,792,458 '
                            'meters per second.',
           'inputs.context': 'The exact speed of light in a vacuum is '
                                  '299,792,458 meters per second, a constant '
                                  "used in physics to represent 'c'.",
           'inputs.query': 'What is the speed of light?',
           'outputs.answer_length.value': 66,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'}],
 'traces': {}}

Exigences relatives à evaluate()

L’API evaluate() nécessite un format de données spécifique et des noms de clés d’évaluateur pour afficher correctement les graphiques de résultats d’évaluation dans votre projet Foundry.

Format des données

L’API evaluate() accepte uniquement les données au format JSONL. Pour tous les évaluateurs intégrés, evaluate() nécessite des données au format suivant avec les champs d’entrée requis. Consultez la section précédente sur l’entrée de données requise pour les évaluateurs intégrés. L’extrait de code suivant est un exemple de ce qu’une ligne peut ressembler :

{
  "query":"What is the capital of France?",
  "context":"France is in Europe",
  "response":"Paris is the capital of France.",
  "ground_truth": "Paris"
}

Format des paramètres de l'évaluateur

Lorsque vous transmettez vos évaluateurs intégrés, spécifiez le mappage de mots clés approprié dans la liste de paramètres evaluators. Le tableau suivant présente le mappage de mots clés requis pour les résultats de vos évaluateurs intégrés pour apparaître dans l’interface utilisateur lorsque vous êtes connecté à votre projet Foundry.

Voici un exemple de comment définir les paramètres evaluators :

result = evaluate(
    data="data.jsonl",
    evaluators={
        "sexual":sexual_evaluator,
        "self_harm":self_harm_evaluator,
        "hate_unfairness":hate_unfairness_evaluator,
        "violence":violence_evaluator
    }
)

Évaluation locale sur une cible

Si vous avez une liste de requêtes que vous souhaitez exécuter, puis évaluez, l’API evaluate() prend également en charge un target paramètre. Ce paramètre envoie des requêtes à une application pour collecter des réponses, puis exécute vos évaluateurs sur la requête et la réponse résultantes.

Une cible peut être n’importe quelle classe pouvant être appelée dans votre répertoire. Dans cet exemple, il existe un script askwiki.py Python avec une classe askwiki() pouvant être appelée définie comme cible. Si vous disposez d’un jeu de données de requêtes que vous pouvez envoyer dans l'application askwiki simple, vous pouvez évaluer la pertinence des sorties. Veillez à spécifier le mappage de colonnes approprié pour vos données dans "column_mapping". Vous pouvez utiliser "default" pour spécifier le mappage de colonnes pour tous les évaluateurs.

Voici le contenu dans "data.jsonl":

{"query":"When was United States found ?", "response":"1776"}
{"query":"What is the capital of France?", "response":"Paris"}
{"query":"Who is the best tennis player of all time ?", "response":"Roger Federer"}

from askwiki import askwiki

result = evaluate(
    data="data.jsonl",
    target=askwiki,
    evaluators={
        "groundedness": groundedness_eval
    },
    evaluator_config={
        "default": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${outputs.context}",
                "response": "${outputs.response}"
            } 
        }
    }
)

Contenu connexe

• Bibliothèque de client Azure AI Evaluation pour Python
• Résoudre les problèmes liés au Kit de développement logiciel (SDK) d'évaluation de l'IA
• Observabilité dans l’IA générative
• Exécuter des évaluations dans le cloud à l’aide du Kit de développement logiciel (SDK) Microsoft Foundry
• Générer des données synthétiques et simulées pour l’évaluation
• Voir les résultats de l’évaluation dans le portail Foundry
• Prise en main de Foundry
• Bien démarrer avec des exemples d’évaluation