Exécuter des évaluations dans le cloud à l’aide du Kit de développement logiciel (SDK) Microsoft Foundry (classique)

Affichage actuel :Version du portail - Passer à la version du nouveau portail Foundry

Dans cet article, vous allez apprendre à exécuter des évaluations dans le cloud (préversion) pour les tests de prédéploiement sur un jeu de données de test. Le kit de développement logiciel (SDK) d’évaluation IA Azure vous permet d’exécuter des évaluations localement sur votre ordinateur et dans le cloud. Par exemple, exécutez des évaluations locales sur de petites données de test pour évaluer vos prototypes d’application IA générative, puis passez aux tests de prédéploiement pour exécuter des évaluations sur un jeu de données volumineux.

Utilisez des évaluations cloud pour la plupart des scénarios, en particulier lors de tests à grande échelle, en intégrant des évaluations dans des pipelines d’intégration continue et de livraison continue (CI/CD) ou en effectuant des tests de prédéploiement. L’exécution d’évaluations dans le cloud élimine la nécessité de gérer l’infrastructure de calcul locale et prend en charge les workflows de test automatisés à grande échelle. Après le déploiement, vous pouvez choisir d’évaluer en continu vos agents pour la surveillance après le déploiement.

Lorsque vous utilisez le Kit de développement logiciel (SDK) Foundry, il journalise les résultats d’évaluation dans votre projet Foundry pour améliorer l’observabilité. Cette fonctionnalité prend en charge tous les évaluateurs intégrés conçus par Microsoft. et vos propres évaluateurs personnalisés. Vos évaluateurs peuvent se trouver dans la bibliothèque de l’évaluateur et avoir le même contrôle d’accès en fonction du rôle.

Conditions préalables

• Un projet Foundry.
• Déploiement OpenAI Azure avec un modèle GPT qui prend en charge l’achèvement des conversations (par exemple, gpt-5-mini).
• rôle d'utilisateur Azure IA sur le projet Foundry.
• Si vous le souhaitez, vous pouvez utiliser votre propre compte de stockage pour exécuter des évaluations.

Commencez

1. Installez le client de projet du sdk Microsoft Foundry pour exécuter des évaluations dans le cloud :

   pip install azure-ai-projects azure-identity
   

2. Définissez des variables d’environnement pour vos ressources Foundry :

   import os
   
   # Required environment variables:
   endpoint = os.environ["PROJECT_ENDPOINT"] # https://<account>.services.ai.azure.com/api/projects/<project>
   model_endpoint = os.environ["MODEL_ENDPOINT"] # https://<account>.services.ai.azure.com
   model_api_key = os.environ["MODEL_API_KEY"]
   model_deployment_name = os.environ["MODEL_DEPLOYMENT_NAME"] # E.g. gpt-5-mini
   
   # Optional: Reuse an existing dataset.
   dataset_name    = os.environ.get("DATASET_NAME",    "dataset-test")
   dataset_version = os.environ.get("DATASET_VERSION", "1.0")
   

3. Définissez un client pour exécuter des évaluations dans le cloud :

   import os
   from azure.identity import DefaultAzureCredential
   from azure.ai.projects import AIProjectClient
   
   # Create the project client (Foundry project and credentials):
   project_client = AIProjectClient(
       endpoint=endpoint,
       credential=DefaultAzureCredential(),
   )
   

Préparer les données d’entrée

# Upload a local JSONL file. Skip this step if you already have a dataset registered.
data_id = project_client.datasets.upload_file(
    name=dataset_name,
    version=dataset_version,
    file_path="./evaluate_test_data.jsonl",
).id

Pour en savoir plus sur les formats de données d’entrée pour l’évaluation des applications IA génératives, consultez :

• Données à tour unique
• Données de conversation
• Données conversationnelles pour les images et les modalités multimodales

Pour en savoir plus sur les formats de données d’entrée pour l’évaluation des agents, consultez Evaluer Azure agents IA et Évaluer d’autres agents.

Spécifier des évaluateurs

from azure.ai.projects.models import (
    EvaluatorConfiguration,
    EvaluatorIds,
)

# Built-in evaluator configurations:
evaluators = {
    "relevance": EvaluatorConfiguration(
        id=EvaluatorIds.RELEVANCE.value,
        init_params={"deployment_name": model_deployment_name},
        data_mapping={
            "query": "${data.query}",
            "response": "${data.response}",
        },
    ),
    "violence": EvaluatorConfiguration(
        id=EvaluatorIds.VIOLENCE.value,
        init_params={"azure_ai_project": endpoint},
    ),
    "bleu_score": EvaluatorConfiguration(
        id=EvaluatorIds.BLEU_SCORE.value,
    ),
}

Créer une évaluation

Enfin, envoyez l’exécution de l’évaluation à distance :

from azure.ai.projects.models import (
    Evaluation,
    InputDataset
)

# Create an evaluation with the dataset and evaluators specified.
evaluation = Evaluation(
    display_name="Cloud evaluation",
    description="Evaluation of dataset",
    data=InputDataset(id=data_id),
    evaluators=evaluators,
)

# Run the evaluation.
evaluation_response = project_client.evaluations.create(
    evaluation,
    headers={
        "model-endpoint": model_endpoint,
        "api-key": model_api_key,
    },
)

print("Created evaluation:", evaluation_response.name)
print("Status:", evaluation_response.status)

Spécifier des évaluateurs personnalisés

Évaluateurs personnalisés basés sur du code

Inscrivez vos évaluateurs personnalisés dans votre projet Azure AI Hub et récupérez les ID de l’évaluateur :

from azure.ai.ml import MLClient
from azure.ai.ml.entities import Model
from promptflow.client import PFClient

# Define ml_client to register the custom evaluator.
ml_client = MLClient(
       subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"],
       resource_group_name=os.environ["AZURE_RESOURCE_GROUP"],
       workspace_name=os.environ["AZURE_PROJECT_NAME"],
       credential=DefaultAzureCredential()
)

# Load the evaluator from the module.
from answer_len.answer_length import AnswerLengthEvaluator

# Convert it to an evaluation flow, and save it locally.
pf_client = PFClient()
local_path = "answer_len_local"
pf_client.flows.save(entry=AnswerLengthEvaluator, path=local_path)

# Specify the evaluator name that appears in the evaluator catalog.
evaluator_name = "AnswerLenEvaluator"

# Register the evaluator to the evaluator catalog.
custom_evaluator = Model(
    path=local_path,
    name=evaluator_name,
    description="Evaluator calculating answer length.",
)
registered_evaluator = ml_client.evaluators.create_or_update(custom_evaluator)
print("Registered evaluator id:", registered_evaluator.id)
# Registered evaluators have versioning. You can always reference any version available.
versioned_evaluator = ml_client.evaluators.get(evaluator_name, version=1)
print("Versioned evaluator id:", registered_evaluator.id)

Après avoir inscrit votre évaluateur personnalisé, affichez-le dans votre catalogue d’évaluateurs. Dans votre projet Foundry, sélectionnez Évaluation, puis sélectionnez catalogue d’évaluateurs.

Évaluateurs personnalisés basés sur des invites

Utilisez cet exemple pour enregistrer un FriendlinessEvaluator personnalisé tel que décrit dans les évaluateurs basés sur les invites :

# Import your prompt-based custom evaluator.
from friendliness.friend import FriendlinessEvaluator

# Define your deployment.
model_config = dict(
    azure_endpoint=os.environ.get("AZURE_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_DEPLOYMENT_NAME"),
    api_version=os.environ.get("AZURE_API_VERSION"),
    api_key=os.environ.get("AZURE_API_KEY"), 
    type="azure_openai"
)

# Define ml_client to register the custom evaluator.
ml_client = MLClient(
       subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"],
       resource_group_name=os.environ["AZURE_RESOURCE_GROUP"],
       workspace_name=os.environ["AZURE_PROJECT_NAME"],
       credential=DefaultAzureCredential()
)

# # Convert the evaluator to evaluation flow and save it locally.
local_path = "friendliness_local"
pf_client = PFClient()
pf_client.flows.save(entry=FriendlinessEvaluator, path=local_path) 

# Specify the evaluator name that appears in the evaluator catalog.
evaluator_name = "FriendlinessEvaluator"

# Register the evaluator to the evaluator catalog.
custom_evaluator = Model(
    path=local_path,
    name=evaluator_name,
    description="prompt-based evaluator measuring response friendliness.",
)
registered_evaluator = ml_client.evaluators.create_or_update(custom_evaluator)
print("Registered evaluator id:", registered_evaluator.id)
# Registered evaluators have versioning. You can always reference any version available.
versioned_evaluator = ml_client.evaluators.get(evaluator_name, version=1)
print("Versioned evaluator id:", registered_evaluator.id)

Après avoir inscrit votre évaluateur personnalisé, vous pouvez l’afficher dans votre catalogue d’évaluateurs. Dans votre projet Foundry, sélectionnez Évaluation, puis sélectionnez catalogue d’évaluateurs.

Obtenir les résultats

Dépannage

Contenu connexe

• Évaluer vos applications IA génératives localement
• Surveiller vos applications IA génératives
• En savoir plus sur la simulation de jeux de données de test pour l’évaluation
• Voir les résultats de l’évaluation dans le portail Foundry
• Commencer avec Foundry
• Commencez avec les échantillons d’évaluation
• Documentation de référence sur l’API REST