Évaluer des agents à l'aide du client GenAI dans le SDK Vertex AI

Preview

Cette fonctionnalité est soumise(s) aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités de pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Vous pouvez utiliser Gen AI Evaluation Service pour évaluer la capacité de l'agent à accomplir des tâches et à atteindre des objectifs pour un cas d'utilisation donné.

Cette page vous explique comment créer et déployer un agent de base, et comment utiliser le service d'évaluation Gen AI pour évaluer l'agent :

• Développer un agent : définissez un agent avec des fonctions d'outil de base.

• Déployer un agent : déployez l'agent dans l'environnement d'exécution Vertex AI Agent Engine.

• Exécuter l'inférence de l'agent : définissez un ensemble de données d'évaluation et exécutez l'inférence de l'agent pour générer des réponses.

• Créer une exécution d'évaluation : créez une exécution d'évaluation pour effectuer une évaluation.

• Afficher les résultats de l'évaluation : affichez les résultats de l'évaluation via l'exécution de l'évaluation.

Pour voir un exemple de création d'une évaluation d'agent Gen AI pour un agent déployé, exécutez le notebook "Créer et déployer un agent, puis exécuter une évaluation d'agent Gen AI" dans l'un des environnements suivants :

Ouvrir dans Colab | Ouvrir dans Colab Enterprise | Ouvrir dans Vertex AI Workbench | Afficher sur GitHub

Avant de commencer

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

   In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

   Verify that billing is enabled for your Google Cloud project.

   In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

   Verify that billing is enabled for your Google Cloud project.

2. Installez le SDK Vertex AI pour Python :

   %pip install google-cloud-aiplatform[adk,agent_engines]
   %pip install --upgrade --force-reinstall -q google-cloud-aiplatform[evaluation]
   

3. Configurez vos identifiants. Si vous exécutez ce tutoriel dans Colaboratory, exécutez la commande suivante :

   from google.colab import auth
   auth.authenticate_user()
   

   Pour les autres environnements, consultez S'authentifier sur Vertex AI.

4. Initialisez le client GenAI dans le SDK Vertex AI :

   import vertexai
   from vertexai import Client
   from google.genai import types as genai_types
   
   GCS_DEST = "gs://BUCKET_NAME/output-path"
   vertexai.init(
       project=PROJECT_ID,
       location=LOCATION,
   )
   
   client = Client(
       project=PROJECT_ID,
       location=LOCATION,
       http_options=genai_types.HttpOptions(api_version="v1beta1"),
     )
   

   Remplacez les éléments suivants :

   • BUCKET_NAME : nom du bucket Cloud Storage. Pour en savoir plus sur la création de buckets, consultez Créer un bucket.

   • PROJECT_ID : ID de votre projet

   • LOCATION : région sélectionnée.

Développer un agent

Développez un agent Agent Development Kit (ADK) en définissant le modèle, l'instruction et l'ensemble d'outils. Pour en savoir plus sur le développement d'un agent, consultez Développer un agent Agent Development Kit.

from google.adk import Agent

# Define Agent Tools
def search_products(query: str):
    """Searches for products based on a query."""
    # Mock response for demonstration
    if "headphones" in query.lower():
        return {"products": [{"name": "Wireless Headphones", "id": "B08H8H8H8H"}]}
    else:
        return {"products": []}

def get_product_details(product_id: str):
    """Gets the details for a given product ID."""
    if product_id == "B08H8H8H8H":
        return {"details": "Noise-cancelling, 20-hour battery life."}
    else:
        return {"error": "Product not found."}

def add_to_cart(product_id: str, quantity: int):
    """Adds a specified quantity of a product to the cart."""
    return {"status": f"Added {quantity} of {product_id} to cart."}

# Define Agent
my_agent = Agent(
    model="gemini-2.5-flash",
    name='ecommerce_agent',
    instruction='You are an ecommerce expert',
    tools=[search_products, get_product_details, add_to_cart],
)

Déployer l'agent

Déployez votre agent dans l'environnement d'exécution Vertex AI Agent Engine. Cette opération peut prendre jusqu'à 10 minutes. Récupérez le nom de ressource de l'agent déployé.

def deploy_adk_agent(root_agent):
  """Deploy agent to agent engine.
  Args:
    root_agent: The ADK agent to deploy.
  """
  app = vertexai.agent_engines.AdkApp(
      agent=root_agent,
  )
  remote_app = client.agent_engines.create(
      agent=app,
      config = {
          "staging_bucket": gs://BUCKET_NAME,
          "requirements": ['google-cloud-aiplatform[adk,agent_engines]'],
          "env_vars": {"GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY": "true"}
      }
  )
  return remote_app

agent_engine = deploy_adk_agent(my_agent)
agent_engine_resource_name = agent_engine.api_resource.name

Pour obtenir la liste des agents déployés dans Vertex AI Agent Engine, consultez Gérer les agents déployés.

Générer des réponses

1. Générez des réponses de modèle pour votre ensemble de données à l'aide de run_inference() :

   Préparez votre ensemble de données sous la forme d'un DataFrame Pandas. Les requêtes doivent être spécifiques à votre agent. Les entrées de session sont obligatoires pour les traces. Pour en savoir plus, consultez Session : suivi des conversations individuelles.

   import pandas as pd
   from vertexai import types
   
   session_inputs = types.evals.SessionInput(
       user_id="user_123",
       state={},
   )
   agent_prompts = [
       "Search for 'noise-cancelling headphones'.",
       "Show me the details for product 'B08H8H8H8H'.",
       "Add one pair of 'B08H8H8H8H' to my shopping cart.",
       "Find 'wireless earbuds' and then add the first result to my cart.",
       "I need a new laptop for work, can you find one with at least 16GB of RAM?",
   ]
   agent_dataset = pd.DataFrame({
       "prompt": agent_prompts,
       "session_inputs": [session_inputs] * len(agent_prompts),
   })
   

2. Générez des réponses du modèle à l'aide de run_inference() :

   agent_dataset_with_inference = client.evals.run_inference(
       agent=agent_engine_resource_name,
       src=agent_dataset,
   )
   

3. Visualisez vos résultats d'inférence en appelant .show() sur l'objet EvaluationDataset pour inspecter les sorties du modèle aux côtés de vos requêtes et références d'origine :

   agent_dataset_with_inference.show()
   

   L'image suivante affiche l'ensemble de données d'évaluation avec les requêtes et les intermediate_events et responses générés correspondants :

   

Exécuter l'évaluation de l'agent

Exécutez create_evaluation_run() pour évaluer les réponses de l'agent.

1. Récupérez le agent_info à l'aide de la fonction d'assistance intégrée :

   agent_info = types.evals.AgentInfo.load_from_agent(
       my_agent,
       agent_engine_resource_name
   )
   

2. Évaluez les réponses du modèle à l'aide de métriques adaptatives basées sur des rubriques spécifiques à l'agent (FINAL_RESPONSE_QUALITY, TOOL_USE_QUALITY et HALLUCINATION) :

   evaluation_run = client.evals.create_evaluation_run(
       dataset=agent_dataset_with_inference,
       agent_info=agent_info,
       metrics=[
           types.RubricMetric.FINAL_RESPONSE_QUALITY,
           types.RubricMetric.TOOL_USE_QUALITY,
           types.RubricMetric.HALLUCINATION,
           types.RubricMetric.SAFETY,
       ],
       dest=GCS_DEST,
   )
   

Afficher les résultats de l'évaluation de l'agent

Vous pouvez afficher les résultats de l'évaluation à l'aide du SDK Vertex AI.

Récupérez l'exécution de l'évaluation et visualisez vos résultats d'évaluation en appelant .show() pour afficher les métriques récapitulatives et les résultats détaillés :

evaluation_run = client.evals.get_evaluation_run(
    name=evaluation_run.name,
    include_evaluation_items=True
)

evaluation_run.show()

L'image suivante montre un rapport d'évaluation, qui affiche des métriques récapitulatives, des informations sur l'agent et des résultats détaillés pour chaque paire requête-réponse. Les résultats détaillés incluent également des traces montrant les interactions de l'agent. Pour en savoir plus sur les traces, consultez Tracer un agent.



Étapes suivantes

• Développez un agent.
• Déployez un agent.
• Utiliser un agent
• En savoir plus sur le service d'évaluation de l'IA générative

Essayez les notebooks suivants :

• Évaluer un agent LangChain

• Évaluer un agent LangGraph

• Évaluer un agent CrewAI