Évaluation des performances de l'IA générative dans azure ai foundry : un guide pratique

Je commence par créer un nouveau fichier Python, souvent nommé evaluate_genai.py. C'est là que j'importe les modules nécessaires et que je configure le client pour me connecter à mon projet Azure AI. N'oubliez pas de remplacer les valeurs d'espace réservé ci-dessous par les détails réels de votre projet ; je les stocke généralement dans des variables d'environnement pour une meilleure sécurité et flexibilité.

import os
from azure.identity import DefaultAzureCredential
from azure.ai.project import AIProjectClient

# --- Configuration --- #
# Remplacez par les détails de votre projet Azure AI. Je trouve généralement le point de terminaison
# dans le portail Azure AI Studio sous les paramètres de mon projet.
AZURE_AI_PROJECT_ENDPOINT = os.environ.get("AZURE_AI_PROJECT_ENDPOINT", "your_project_endpoint")
# Le nom de votre modèle déployé que je souhaite évaluer.
EVALUATION_TARGET_DEPLOYMENT = os.environ.get("EVALUATION_TARGET_DEPLOYMENT", "your_model_deployment_name")

# Initialiser DefaultAzureCredential pour l'authentification
credential = DefaultAzureCredential()
print("Azure credential initialized.")

# Initialiser AIProjectClient
project_client = AIProjectClient(endpoint=AZURE_AI_PROJECT_ENDPOINT, credential=credential)
print("AIProjectClient initialized.")

# Dossier de base pour les sorties
OUTPUT_FOLDER = "./eval_outputs"
os.makedirs(OUTPUT_FOLDER, exist_ok=True)
print(f"Output folder '{OUTPUT_FOLDER}' ensured.")

Cet extrait importe les classes requises pour l'interaction du projet et l'authentification. Il configure le point de terminaison pour mon projet AI et initialise AIProjectClient, qui est mon point d'entrée principal pour la gestion des ressources du projet. Je configure également un répertoire de sortie pour stocker les résultats.

Pour évaluer efficacement une application RAG, j'ai besoin d'un jeu de données comprenant des invites et le contexte par rapport auquel la réponse du modèle sera jugée. Il est crucial que la complétion du modèle ne fasse pas partie de ces données d'entrée ; elle est générée pendant l'exécution de l'évaluation elle-même.

# Ceci est un exemple de jeu de données que je pourrais utiliser pour l'évaluation,
# mimant une session de questions-réponses sur des documents financiers.
# La structure 'item' est requise par le cadre d'évaluation.
data_for_evaluation = {
    "type": "file_content",
    "content": [
        {
            "item": {
                "prompt_text": "Quel est le principal défi financier pour NVIDIA en 2026 ?",
                "context_text": "Le 15 mars 2026, NVIDIA a annoncé de solides résultats pour le quatrième trimestre 2025, mais a souligné des défis potentiels pour l'exercice à venir en raison d'une concurrence accrue d'Intel et d'AMD sur le marché des accélérateurs d'IA. Les analystes de la chaîne d'approvisionnement ont également noté des complexités persistantes dans la sécurisation des capacités de fabrication avancées pour les GPU H200 et Blackwell de nouvelle génération de NVIDIA, ce qui pourrait avoir un impact sur la croissance des revenus."
            }
        },
        {
            "item": {
                "prompt_text": "Expliquez l'impact de la dernière hausse des taux d'intérêt par la BCE sur les marchés obligataires.",
                "context_text": "Le 2 avril 2026, la Banque Centrale Européenne (BCE) a annoncé une augmentation de 25 points de base de ses taux d'intérêt directeurs, citant des préoccupations persistantes concernant l'inflation. Suite à cette annonce, les analystes de Bloomberg ont fait état d'une forte hausse des rendements des obligations allemandes à 10 ans, indiquant une large réévaluation de la dette souveraine dans la zone euro en raison de coûts de financement plus élevés pour les gouvernements et d'une attractivité diminuée des obligations existantes à rendement plus faible."
            }
        }
    ]
}

print(f"Prepared {len(data_for_evaluation['content'])} data points for evaluation.")

Ce dictionnaire définit ma source de données d'évaluation. Chaque item contient le prompt_text (la requête de l'utilisateur) et le context_text (les informations récupérées). Le modèle que j'évalue générera une réponse basée sur ces entrées, que les évaluateurs évalueront ensuite.

Dans le SDK Azure AI Project, je définis mes évaluateurs dans le cadre des testing_criteria. Je spécifie le nom de la métrique intégrée (comme builtin.groundedness) puis je mappe les champs de données de mon jeu de données aux entrées requises par cet évaluateur.

# Je définis les évaluateurs ici. Ceux-ci exploitent les modèles GPT fondamentaux
# provisionnés dans mon projet Azure AI. Le 'data_mapping' connecte
# les colonnes de mon jeu de données aux entrées attendues de l'évaluateur.
testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "groundedness_eval",
        "evaluator_name": "builtin.groundedness",
        "data_mapping": {
            "question": "{{item.prompt_text}}",
            "context": "{{item.context_text}}",
            "answer": "{{target.response}}" # 'target.response' est la réponse générée par le modèle
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "relevance_eval",
        "evaluator_name": "builtin.relevance",
        "data_mapping": {
            "question": "{{item.prompt_text}}",
            "answer": "{{target.response}}"
        },
    }
]

print(f"Configured {len(testing_criteria)} AI-assisted evaluators.")

Ici, je configure une liste de dictionnaires, chacun configurant un évaluateur. evaluator_name spécifie la métrique, et data_mapping utilise une syntaxe de modèle pour câbler les entrées. {{item.prompt_text}} et {{item.context_text}} font référence à des champs de mon jeu de données, tandis que {{target.response}} est un espace réservé spécial pour la complétion générée par le modèle en évaluation. Je me réfère souvent à la documentation Azure sur les métriques d'évaluation pour les mappages exacts.

Avec mes données et mes évaluateurs définis, l'étape suivante consiste à créer un objet d'évaluation puis à déclencher une exécution. Il s'agit d'un processus asynchrone géré par Azure AI. Je le lance généralement et je surveille ensuite sa progression dans le portail.

# J'obtiens le client OpenAI du client de projet pour interagir avec les évaluations.
openai_client = project_client.get_openai_client()

print("Creating evaluation object...")
eval_object = openai_client.evals.create(
    name="Financial QA Evaluation",
    testing_criteria=testing_criteria, # type: ignore
)
print(f"Evaluation object created (id: {eval_object.id}).")

# Je définis la source de données et le modèle cible à évaluer.
data_source = {
    "type": "azure_ai_target_completions",
    "source": data_for_evaluation,
    "input_messages": {
        "type": "template",
        "template": [
            {
                "type": "message",
                "role": "user",
                "content": [
                    {"type": "input_text", "text": "Context: {{item.context_text}}\n\nQuestion: {{item.prompt_text}}"}
                ]
            }
        ],
    },
    "target": {
        "type": "azure_ai_model_deployment",
        "name": EVALUATION_TARGET_DEPLOYMENT
    },
}

print("Starting evaluation run...")
# Remarque : Cette opération entraînera des coûts basés sur l'utilisation des jetons des LLM sous-jacents.
# Début 2026, un coût représentatif pourrait être d'environ
# 0,01 € par 1k jetons d'entrée et 0,03 € par 1k jetons de sortie. (Utilisation de 1 $ \u2248 0,92 € de conversion)

eval_run = openai_client.evals.runs.create(
    eval_id=eval_object.id,
    name="financial_qa_eval_202604",
    data_source=data_source # type: ignore
)

print(f"Evaluation run created and is in progress (id: {eval_run.id}).")
print("Monitor the run status and view results in the Azure AI Foundry portal.")

La fonction evals.create enregistre ma définition d'évaluation, et evals.runs.create démarre l'exécution réelle. Elle utilise l'eval_id de l'étape précédente, un name lisible par l'homme pour l'exécution (qui apparaît dans le portail), et un objet data_source. Cet objet indique à Azure les données d'entrée, comment les formater en une invite pour le modèle, et quel modèle déployé (target) je souhaite évaluer. L'ensemble de l'exécution se déroule en arrière-plan sur Azure.

Une fois l'exécution de l'évaluation terminée dans le portail Azure AI Foundry, je peux télécharger les résultats sous forme de fichier JSONL pour une analyse détaillée. Je navigue généralement vers la section "Évaluations" de mon projet AI dans le portail, je trouve mon exécution (financial_qa_eval_202604), puis je télécharge le fichier evaluation_results.jsonl dans mon dossier eval_outputs. À partir de là, j'utilise Python pour analyser les résultats en utilisant pandas pour la manipulation des données et tabulate pour un formatage markdown propre.

import pandas as pd
import json

# Cette étape suppose que j'ai téléchargé les résultats depuis le portail.
results_path = os.path.join(OUTPUT_FOLDER, "evaluation_results.jsonl")

try:
    # Le fichier de résultats contient un objet JSON par ligne.
    with open(results_path, 'r') as f:
        lines = f.readlines()

    # Chaque ligne a une structure complexe ; je dois extraire les parties pertinentes.
    parsed_results = []
    for line in lines:
        data = json.loads(line)
        # Extraire les données d'entrée et les métriques d'évaluation.
        # La structure exacte peut varier ; j'inspecte généralement mon fichier JSONL en premier.
        result_item = data.get('item', {})
        metrics = data.get('metrics', {})

        parsed_results.append({
            'prompt_text': result_item.get('prompt_text'),
            'completion_text': data.get('response'), # La réponse générée
            'groundedness_score': metrics.get('groundedness_eval.groundedness'),
            'relevance_score': metrics.get('relevance_eval.relevance')
        })

    results_df = pd.DataFrame(parsed_results)

    print("\n--- Résultats détaillés par instance (2 premières lignes) ---")
    print(results_df.head(2).to_markdown(index=False))

    # Exemple : Calculer et afficher les métriques agrégées.
    print("\n--- Résultats d'évaluation agrégés ---")
    print(f"  Groundedness moyenne : {results_df['groundedness_score'].mean():.2f}")
    print(f"  Pertinence moyenne : {results_df['relevance_score'].mean():.2f}")

except FileNotFoundError:
    print(f"\nAnalyse ignorée : Impossible de trouver '{results_path}'. Veuillez d'abord le télécharger depuis le portail Azure AI Foundry.")

Ce script lit le fichier JSONL téléchargé ligne par ligne, analyse la structure JSON complexe pour extraire l'invite d'entrée, la complétion générée par le modèle et les scores pour chaque métrique. Je charge ensuite ces données dans un DataFrame Pandas, ce qui facilite l'analyse et l'agrégation.

Bien que le SDK me donne un contrôle programmatique, je compte toujours beaucoup sur le portail Azure AI Foundry. Il offre une interface utilisateur centralisée pour surveiller mes exécutions d'évaluation, ce qui est particulièrement utile pour la surveillance opérationnelle.

1. Naviguer vers Azure AI Foundry : Connectez-vous au portail Azure AI Studio.
2. Localiser mon projet : Sélectionnez votre projet Azure AI.
3. Trouver les exécutions d'évaluation : Naviguez vers la section "Évaluations". Je devrais voir une liste d'évaluations et de leurs exécutions, y compris financial_qa_eval_202604.
4. Examiner les métriques et les détails : En cliquant sur mon exécution d'évaluation, j'obtiens les métriques agrégées, les résultats détaillés par instance et les visualisations des performances. C'est l'interface principale pour suivre les tendances des métriques comme la groundedness et la pertinence au fil du temps.

• Moindre privilège : Je m'assure toujours que tout principal de service ou identité gérée utilisé par mes pipelines d'évaluation n'a que les autorisations nécessaires, rien de plus.
• Protection des données : Le chiffrement des jeux de données d'évaluation au repos et en transit est non négociable. J'implémente également l'anonymisation des données pour toute donnée sensible.
• Identités gérées : Pour les charges de travail de production, j'utilise exclusivement les identités gérées Azure pour l'authentification aux services Azure. Cela simplifie la gestion des informations d'identification et améliore la sécurité.

• Traitement par lots : Le cadre d'évaluation est intrinsèquement conçu pour traiter efficacement les jeux de données par lots, donc je l'exploite.
• Choix de l'évaluateur : Bien que GPT-4 offre un raisonnement supérieur, j'ai constaté qu'il peut être plus coûteux et plus lent. Pour les évaluations à grande échelle où le coût et la latence sont des préoccupations, j'opte souvent pour GPT-3.5 Turbo si sa qualité est acceptable pour la tâche.

• Pipelines Azure Machine Learning : L'intégration de ma logique d'évaluation dans les pipelines Azure Machine Learning permet une exécution automatisée et évolutive dans les flux de travail MLOps.
• Déploiement régional : Pour mes projets européens, je déploie toujours les ressources Azure AI dans des régions européennes telles que westeurope ou northeurope afin de minimiser la latence pour les utilisateurs basés dans l'UE et de garantir la conformité à la résidence des données.

• Alertes : La configuration d'alertes Azure Monitor sur les métriques d'évaluation clés est cruciale. Par exemple, je pourrais déclencher une alerte si le score moyen de groundedness tombe en dessous d'un seuil prédéfini.
• Tableaux de bord : Je crée des tableaux de bord personnalisés, soit dans Azure AI Foundry, soit dans Azure Monitor, pour visualiser les tendances des métriques d'évaluation au fil du temps. Cela m'aide à repérer rapidement les régressions.
• Surveillance des coûts : La surveillance continue du coût associé à mes appels LLM pour l'évaluation est vitale. J'établis des budgets et des alertes de coûts pour éviter les dépenses imprévues.

• Azure AI Foundry fournit une plateforme robuste pour l'évaluation programmatique des modèles d'IA générative, cruciale pour les applications RAG.
• Le SDK azure.ai.project permet de définir des critères d'évaluation, de connecter des jeux de données et de déclencher des exécutions d'évaluation directement depuis Python.
• Les métriques clés telles que la groundedness et la pertinence sont automatiquement évaluées à l'aide d'évaluateurs assistés par l'IA hébergés au sein du projet Azure AI.
• La surveillance des résultats dans le portail Azure AI Foundry et l'intégration de l'analyse dans les pipelines CI/CD sont essentielles pour maintenir la qualité du modèle.
• La surveillance des coûts d'utilisation des LLM pendant les évaluations est essentielle pour gérer les dépenses, avec des coûts typiques d'environ 0,01 € par 1k jetons d'entrée et 0,03 € par 1k jetons de sortie (en utilisant 1 $ \u2248 0,92 €).