Évaluer les agents d'IA générative

Une fois que vous avez créé et évalué votre modèle d'IA générative, vous pouvez l'utiliser pour créer un agent, comme un chatbot. Le service d'évaluation de l'IA générative vous permet de mesurer la capacité de votre agent à accomplir des tâches et à atteindre des objectifs pour votre cas d'utilisation.

Présentation

Vous disposez des options suivantes pour évaluer votre agent :

• Évaluation de la réponse finale : évaluez la sortie finale d'un agent (s'il a atteint ou non son objectif).

• Évaluation de la trajectoire : évaluez le chemin (séquence d'appels d'outils) emprunté par l'agent pour obtenir la réponse finale.

Avec le service d'évaluation de l'IA générative, vous pouvez déclencher l'exécution d'un agent et obtenir des métriques pour l'évaluation de la trajectoire et de la réponse finale dans une seule requête du SDK Vertex AI.

Agents acceptés

Le service d'évaluation de l'IA générative est compatible avec les catégories d'agents suivantes :

Définir des métriques pour l'évaluation des agents

Définissez vos métriques pour l'évaluation de la réponse finale ou de la trajectoire :

Évaluation de la réponse finale

L'évaluation des réponses finales suit le même processus que l'évaluation des réponses du modèle. Pour en savoir plus, consultez Définir vos métriques d'évaluation.

Évaluation de la trajectoire

Les métriques suivantes vous aident à évaluer la capacité du modèle à suivre la trajectoire attendue :

De plus, les deux métriques de performances des agents suivantes sont ajoutées aux résultats de l'évaluation par défaut. Vous n'avez pas besoin de les spécifier dans EvalTask.

Préparer votre ensemble de données pour l'évaluation de l'agent

Préparez votre ensemble de données pour l'évaluation de la réponse finale ou de la trajectoire.

Le schéma de données pour l'évaluation des réponses finales est semblable à celui de l'évaluation des réponses du modèle.

Pour l'évaluation de trajectoire basée sur le calcul, votre ensemble de données doit fournir les informations suivantes :

Exemples d'ensembles de données d'évaluation

Les exemples suivants montrent des ensembles de données pour l'évaluation des trajectoires. Notez que reference_trajectory est obligatoire pour toutes les métriques, à l'exception de trajectory_single_tool_use.

reference_trajectory = [
# example 1
[
  {
    "tool_name": "set_device_info",
    "tool_input": {
        "device_id": "device_2",
        "updates": {
            "status": "OFF"
        }
    }
  }
],
# example 2
[
    {
      "tool_name": "get_user_preferences",
      "tool_input": {
          "user_id": "user_y"
      }
  },
  {
      "tool_name": "set_temperature",
      "tool_input": {
          "location": "Living Room",
          "temperature": 23
      }
    },
  ]
]

predicted_trajectory = [
# example 1
[
  {
    "tool_name": "set_device_info",
    "tool_input": {
        "device_id": "device_3",
        "updates": {
            "status": "OFF"
        }
    }
  }
],
# example 2
[
    {
      "tool_name": "get_user_preferences",
      "tool_input": {
          "user_id": "user_z"
      }
    },
    {
      "tool_name": "set_temperature",
      "tool_input": {
          "location": "Living Room",
          "temperature": 23
      }
    },
  ]
]

eval_dataset = pd.DataFrame({
    "predicted_trajectory": predicted_trajectory,
    "reference_trajectory": reference_trajectory,
})

Importer votre ensemble de données d'évaluation

Vous pouvez importer votre ensemble de données dans les formats suivants:

• Fichier JSONL ou CSV stocké dans Cloud Storage

• Table BigQuery

• DataFrame Pandas

Le service d'évaluation de l'IA générative fournit des exemples d'ensembles de données publics pour vous montrer comment évaluer vos agents. Le code suivant montre comment importer les ensembles de données publics à partir d'un bucket Cloud Storage :

# dataset name to be imported
dataset = "on-device" # Alternatives: "customer-support", "content-creation"

# copy the tools and dataset file
!gcloud storage cp gs://cloud-ai-demo-datasets/agent-eval-datasets/{dataset}/tools.py .
!gcloud storage cp gs://cloud-ai-demo-datasets/agent-eval-datasets/{dataset}/eval_dataset.json .

# load the dataset examples
import json

eval_dataset = json.loads(open('eval_dataset.json').read())

# run the tools file
%run -i tools.py

où dataset est l'un des ensembles de données publics suivants :

• "on-device" pour un Assistant pour la maison sur l'appareil, qui contrôle les appareils de la maison. L'agent vous aide à répondre à des requêtes telles que "Programme la climatisation de la chambre pour qu'elle soit allumée entre 23h et 8h, et éteinte le reste du temps".

• "customer-support" pour parler à un agent de l'assistance client. L'agent vous aide à répondre à des questions telles que "Pouvez-vous annuler les commandes en attente et escalader les demandes d'assistance ouvertes ?"

• "content-creation" pour un agent spécialisé dans la création de contenus marketing. L'agent aide à répondre à des requêtes telles que "Reprogramme la campagne X pour qu'elle soit diffusée une seule fois sur le réseau social Y avec un budget réduit de 50 %, uniquement le 25 décembre 2024".

Exécuter l'évaluation de l'agent

Exécutez une évaluation pour la trajectoire ou l'évaluation de la réponse finale :

Pour l'évaluation des agents, vous pouvez combiner des métriques d'évaluation des réponses et des métriques d'évaluation des trajectoires, comme dans le code suivant :

single_tool_use_metric = TrajectorySingleToolUse(tool_name='tool_name')

eval_task = EvalTask(
    dataset=EVAL_DATASET,
    metrics=[
        "rouge_l_sum",
        "bleu",
        custom_trajectory_eval_metric, # custom computation-based metric
        "trajectory_exact_match",
        "trajectory_precision",
        single_tool_use_metric,
        response_follows_trajectory_metric # llm-based metric
    ],
)
eval_result = eval_task.evaluate(
    runnable=RUNNABLE,
)

Personnalisation des métriques

Vous pouvez personnaliser une métrique basée sur un grand modèle linguistique pour l'évaluation de trajectoires à l'aide d'une interface de modèle ou à partir de zéro. Pour en savoir plus, consultez la section sur les métriques basées sur un modèle. Voici un exemple de modèle :

response_follows_trajectory_prompt_template = PointwiseMetricPromptTemplate(
    criteria={
        "Follows trajectory": (
            "Evaluate whether the agent's response logically follows from the "
            "sequence of actions it took. Consider these sub-points:\n"
            "  - Does the response reflect the information gathered during the trajectory?\n"
            "  - Is the response consistent with the goals and constraints of the task?\n"
            "  - Are there any unexpected or illogical jumps in reasoning?\n"
            "Provide specific examples from the trajectory and response to support your evaluation."
        )
    },
    rating_rubric={
        "1": "Follows trajectory",
        "0": "Does not follow trajectory",
    },
    input_variables=["prompt", "predicted_trajectory"],
)

response_follows_trajectory_metric = PointwiseMetric(
    metric="response_follows_trajectory",
    metric_prompt_template=response_follows_trajectory_prompt_template,
)

Vous pouvez également définir une métrique personnalisée basée sur le calcul pour l'évaluation de la trajectoire ou de la réponse comme suit :

def essential_tools_present(instance, required_tools = ["tool1", "tool2"]):
    trajectory = instance["predicted_trajectory"]
    tools_present = [tool_used['tool_name'] for tool_used in trajectory]
    if len(required_tools) == 0:
      return {"essential_tools_present": 1}
    score = 0
    for tool in required_tools:
      if tool in tools_present:
        score += 1
    return {
        "essential_tools_present": score/len(required_tools),
    }

custom_trajectory_eval_metric = CustomMetric(name="essential_tools_present", metric_function=essential_tools_present)

Afficher et interpréter les résultats

Pour l'évaluation de la trajectoire ou de la réponse finale, les résultats de l'évaluation s'affichent comme suit :

Les résultats de l'évaluation contiennent les informations suivantes :

Protocole Agent2Agent (A2A)

Si vous créez un système multi-agents, nous vous recommandons vivement de consulter le protocole A2A. Le protocole A2A est une norme ouverte qui permet une communication et une collaboration fluides entre les agents d'IA, quels que soient leurs frameworks sous-jacents. Il a été donné par Google Cloud à la Linux Foundation en juin 2025. Pour utiliser les SDK A2A ou essayer les exemples, consultez le dépôt GitHub.

Étapes suivantes

Essayez les notebooks d'évaluation d'agent suivants :

• Évaluer un agent Langraph

• Évaluer un agent CrewAI

• Évaluer un agent Langchain avec Agent Engine

• Évaluer un agent LangGraph avec Agent Engine

• Évaluer un agent CrewAI avec Agent Engine