Avaliadores de agentes (pré-visualização) (clássico)

A ver atualmente:Versão - portal Foundry (clássica)Mudar para a versão do novo portal da Foundry

Os agentes são assistentes de produtividade poderosos. Eles planeiam, tomam decisões e executam ações. Os agentes normalmente raciocinam com base nas intenções do utilizador nas conversas, selecionam as ferramentas corretas para satisfazer os pedidos dos utilizadores e completam tarefas de acordo com as instruções. A Microsoft Foundry suporta estes avaliadores específicos de agentes para fluxos de trabalho agentes:

• Resolução de intenções (pré-visualização)
• Precisão das chamadas de ferramenta (pré-visualização)
• Adesão à tarefa (pré-visualização)

Evaluating Azure AI agents

Os agentes emitem mensagens, e fornecer entradas normalmente requer a análise dessas mensagens para extrair informação relevante. Se estiver a criar agentes usando o Azure AI Agent Service, o serviço fornece integração nativa para avaliação que recebe diretamente as mensagens dos agentes. Para um exemplo, veja Avaliar agentes de IA.

Para além de IntentResolution, ToolCallAccuracy, e TaskAdherence, que são específicos dos fluxos de trabalho agentes, pode avaliar outros aspetos de qualidade e segurança destes fluxos usando um conjunto abrangente de avaliadores incorporados. O Foundry suporta esta lista de avaliadores para mensagens de agentes do Azure AI do nosso conversor:

• Qualidade: IntentResolution, ToolCallAccuracy, TaskAdherence, Relevance, Coherence, , e Fluency
• Segurança: CodeVulnerabilities, Violence, Self-harm, Sexual, HateUnfairness, IndirectAttack, , e ProtectedMaterials

Este artigo inclui exemplos de IntentResolution, ToolCallAccuracy, e TaskAdherence. Para exemplos de outros avaliadores com mensagens Azure agentes de IA, veja evaluating Azure AI agents.

Configuração de modelos para avaliadores assistidos por IA

Para referência, nos seguintes excertos de código, os avaliadores assistidos por IA usam uma configuração de modelo para o grande juiz de modelos de linguagem (LLM-judge):

import os
from azure.ai.evaluation import AzureOpenAIModelConfiguration
from dotenv import load_dotenv
load_dotenv()

model_config = AzureOpenAIModelConfiguration(
    azure_endpoint=os.environ["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"),
)

Suporte a modelos avaliadores

Azure AI Agent Service suporta modelos de raciocínio AzureOpenAI ou OpenAI raciocínio e modelos não raciocínios para o juiz LLM, dependendo dos avaliadores:

Para avaliações complexas que requerem raciocínio refinado, use um modelo de raciocínio forte, como 4.1-mini com um equilíbrio entre desempenho do raciocínio e eficiência de custos.

Intent resolution

IntentResolutionEvaluator Mede quão bem o sistema identifica e compreende o pedido do utilizador. Este entendimento inclui quão bem especula a intenção do utilizador, coloca perguntas para clarificar e lembra aos utilizadores finais o âmbito das suas capacidades. Uma pontuação mais alta indica melhor identificação da intenção do utilizador.

Exemplo de resolução de intenção

from azure.ai.evaluation import IntentResolutionEvaluator

intent_resolution = IntentResolutionEvaluator(model_config=model_config, threshold=3)
intent_resolution(
    query="What are the opening hours of the Eiffel Tower?",
    response="Opening hours of the Eiffel Tower are 9:00 AM to 11:00 PM."
)

Saída de resolução de intenção

A pontuação numérica utiliza uma escala de Likert (inteiro de 1 a 5), onde uma pontuação mais alta é melhor. Dado um limiar numérico (o padrão é 3), o avaliador responde a aprovação se a pontuação for maior ou igual ao limiar, ou falhar caso contrário. Usar a razão e outros campos pode ajudá-lo a perceber porque é que a pontuação é alta ou baixa.

{
    "intent_resolution": 5,
    "intent_resolution_result": "pass",
    "intent_resolution_threshold": 3,
    "intent_resolution_reason": "The response provides the opening hours of the Eiffel Tower clearly and accurately, directly addressing the user's query. It includes specific times, which fully resolves the user's request for information about the opening hours.",
}

Se construir agentes fora do Foundry Agent Service, este avaliador aceita um esquema típico para mensagens de agente. Para explorar um caderno de exemplo, consulte Resolução de Intenções.

Precisão da chamada de ferramenta

ToolCallAccuracyEvaluator mede a precisão e eficiência das chamadas de ferramenta feitas por um agente numa execução. Fornece uma pontuação de 1 a 5 com base em:

• A relevância e utilidade da ferramenta utilizada
• A correção dos parâmetros usados nas chamadas de ferramentas
• As contagens de chamadas perdidas ou excessivas

Apoio à avaliação de chamadas de ferramentas

ToolCallAccuracyEvaluator suporta a avaliação no Serviço de Agente para as seguintes ferramentas:

• File Search
• Pesquisa de IA do Azure
• Bing Grounding
• Pesquisa Personalizada do Bing
• SharePoint Grounding
• Code Interpreter
• Fabric Data Agent
• OpenAPI
• Ferramenta de Função (ferramentas definidas pelo utilizador)

Se uma ferramenta não suportada for usada na execução do agente, o avaliador faz uma passagem e explica que a avaliação das ferramentas não é suportada. Esta abordagem facilita a filtragem destes casos. Recomendamos que inclua ferramentas não suportadas como ferramentas definidas pelo utilizador para permitir a avaliação.

Exemplo de precisão das chamadas de ferramenta

from azure.ai.evaluation import ToolCallAccuracyEvaluator

tool_call_accuracy = ToolCallAccuracyEvaluator(model_config=model_config, threshold=3)

# provide the agent response with tool calls 
tool_call_accuracy(
    query="What timezone corresponds to 41.8781,-87.6298?",
    response=[
    {
        "createdAt": "2025-04-25T23:55:52Z",
        "run_id": "run_DmnhUGqYd1vCBolcjjODVitB",
        "role": "assistant",
        "content": [
            {
                "type": "tool_call",
                "tool_call_id": "call_qi2ug31JqzDuLy7zF5uiMbGU",
                "name": "azure_maps_timezone",
                "arguments": {
                    "lat": 41.878100000000003,
                    "lon": -87.629800000000003
                }
            }
        ]
    },    
    {
        "createdAt": "2025-04-25T23:55:54Z",
        "run_id": "run_DmnhUGqYd1vCBolcjjODVitB",
        "tool_call_id": "call_qi2ug31JqzDuLy7zF5uiMbGU",
        "role": "tool",
        "content": [
            {
                "type": "tool_result",
                "tool_result": {
                    "ianaId": "America/Chicago",
                    "utcOffset": None,
                    "abbreviation": None,
                    "isDaylightSavingTime": None
                }
            }
        ]
    },
    {
        "createdAt": "2025-04-25T23:55:55Z",
        "run_id": "run_DmnhUGqYd1vCBolcjjODVitB",
        "role": "assistant",
        "content": [
            {
                "type": "text",
                "text": "The timezone for the coordinates 41.8781, -87.6298 is America/Chicago."
            }
        ]
    }
    ],   
    tool_definitions=[
                {
                    "name": "azure_maps_timezone",
                    "description": "local time zone information for a given latitude and longitude.",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "lat": {
                                "type": "float",
                                "description": "The latitude of the location."
                            },
                            "lon": {
                                "type": "float",
                                "description": "The longitude of the location."
                            }
                        }
                    }
                }
    ]
)

# alternatively, provide the tool calls directly without the full agent response
tool_call_accuracy(
    query="How is the weather in Seattle?",
    tool_calls=[{
                    "type": "tool_call",
                    "tool_call_id": "call_CUdbkBfvVBla2YP3p24uhElJ",
                    "name": "fetch_weather",
                    "arguments": {
                        "location": "Seattle"
                    }
                }],
    tool_definitions=[{
                    "id": "fetch_weather",
                    "name": "fetch_weather",
                    "description": "Fetches the weather information for the specified location.",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "location": {
                                "type": "string",
                                "description": "The location to fetch weather for."
                            }
                        }
                    }
                }
    ]
)

Saída de precisão da chamada de ferramenta

A pontuação numérica está numa escala de Likert (inteiro de 1 a 5). Uma pontuação mais alta é melhor. Dado um limiar numérico (por defeito 3), o avaliador também apresenta aprovação se a pontuação >= limiar, ou reprovação caso contrário. Use os campos de detalhe de razão e chamada de ferramenta para perceber porque é que a pontuação é alta ou baixa.

{
    "tool_call_accuracy": 5,
    "tool_call_accuracy_result": "pass",
    "tool_call_accuracy_threshold": 3,
    "details": {
        "tool_calls_made_by_agent": 1,
        "correct_tool_calls_made_by_agent": 1,
        "per_tool_call_details": [
            {
                "tool_name": "fetch_weather",
                "total_calls_required": 1,
                "correct_calls_made_by_agent": 1,
                "correct_tool_percentage": 100%,
                "tool_call_errors": 0,
                "tool_call_success_result": "pass"
            }
        ],
        "excess_tool_calls": {
            "total": 0,
            "details": []
        },
        "missing_tool_calls": {
            "total": 0,
            "details": []
        }
    }
}

Se construir agentes fora do Azure AI Agent Service, este avaliador aceita um esquema típico para mensagens de agente. Para um caderno de exemplo, veja Precisão das Chamadas de Ferramentas.

Task adherence

Em vários sistemas de IA orientados a tarefas, como os sistemas agentes, é importante avaliar se o agente mantém o caminho para completar uma tarefa em vez de fazer passos ineficientes ou fora do âmbito. TaskAdherenceEvaluator Mede quão bem a resposta de um agente cumpre as suas tarefas atribuídas, de acordo com a instrução da tarefa e as ferramentas disponíveis. A instrução da tarefa é extraída da mensagem do sistema e da consulta do utilizador. Uma pontuação mais alta indica melhor adesão à instrução do sistema para resolver a tarefa.

Exemplo de adesão a tarefas

from azure.ai.evaluation import TaskAdherenceEvaluator

task_adherence = TaskAdherenceEvaluator(model_config=model_config)
task_adherence(
        query="What are the best practices for maintaining a healthy rose garden during the summer?",
        response="Make sure to water your roses regularly and trim them occasionally."                         
)

Resultado da adesão à tarefa

O avaliador indica aprovação ou reprovação caso contrário. Use o campo razão para compreender a razão por trás da pontuação

{
    "task_adherence_result": "fail",
    "task_adherence_reason": "The response partially addresses the query by mentioning relevant practices but lacks critical details and depth, making it insufficient for a comprehensive understanding of maintaining a rose garden in summer."
}

Se estiver a construir agentes fora do Azure AI Agent Service, este avaliador aceita um esquema típico para mensagens de agente. Para um caderno de exemplo, consulte Adesão a Tarefas.

Related content

• Como executar uma avaliação em lote num conjunto de dados
• Como executar a avaliação em lote num alvo
• Como realizar uma avaliação de agentes