Partilhar via

Execute avaliações na cloud usando o Microsoft Foundry SDK (clássico)

Observação

Este documento refere-se ao portal Microsoft Foundry (clássico).

🔍 Consulte a documentação (nova) da Microsoft Foundry para saber mais sobre o novo portal.

Importante

Os itens marcados como (pré-visualização) neste artigo estão neste momento em pré-visualização pública. Esta pré-visualização é fornecida sem um acordo de nível de serviço, e não a recomendamos para trabalhos em produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Neste artigo, aprende como executar avaliações na cloud (pré-visualização) para testes de pré-implementação num conjunto de dados de teste. O Azure AI Evaluation SDK permite-lhe executar avaliações localmente na sua máquina e na cloud. Por exemplo, execute avaliações locais em pequenos dados de teste para avaliar os seus protótipos de aplicações de IA generativa, e depois passe para testes pré-implementação para realizar avaliações num grande conjunto de dados.

Use avaliações na cloud para a maioria dos cenários — especialmente ao testar em escala, integrar avaliações em pipelines de integração contínua e entrega contínua (CI/CD), ou realizar testes pré-implementação. Executar avaliações na cloud elimina a necessidade de gerir a infraestrutura de computação local e suporta fluxos de trabalho de testes automatizados e em grande escala. Após a implantação, pode optar por avaliar continuamente os seus agentes para monitorização pós-implantação.

Quando utiliza o SDK Foundry, regista os resultados das avaliações no seu projeto Foundry para melhor observabilidade. Esta funcionalidade suporta todos os avaliadores integrados curados pela Microsoft. e os seus próprios avaliadores personalizados. Os seus avaliadores podem estar localizados na biblioteca de avaliadores e ter o mesmo âmbito de projeto, controlo de acesso baseado em funções.

Pré-requisitos

Observação

Algumas funcionalidades de avaliação têm restrições regionais. Consulte as regiões suportadas para mais detalhes.

Introdução

  1. Instale o cliente do projeto Microsoft Foundry SDK para executar avaliações na cloud:

    pip install azure-ai-projects azure-identity

  2. Defina variáveis de ambiente para os seus recursos da 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. Defina um cliente para executar avaliações na 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(),
)

Preparar os dados de entrada

# 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

Para saber mais sobre formatos de dados de entrada para avaliação de aplicações de IA generativa, veja:

Para saber mais sobre formatos de dados de entrada para avaliar agentes, consulte Avaliar agentes de IA do Azure e Avaliar outros agentes.

Especificar avaliadores

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,
    ),
}

Criar uma avaliação

Por fim, submeta a avaliação remota:

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)

Especificar avaliadores personalizados

Observação

Projetos de fundição não são suportados para esta funcionalidade. Em vez disso, utilize um projeto de hub da Foundry.

Avaliadores personalizados baseados em código

Registe os seus avaliadores personalizados no seu projeto do Azure AI Hub e obtenha os IDs do avaliador:

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)

Depois de registar o seu avaliador personalizado, veja-o no seu catálogo de avaliadores. No seu projeto Foundry, selecione Avaliação e depois selecione catálogo avaliador.

Avaliadores personalizados baseados em prompts

Use este exemplo para registrar um build personalizado FriendlinessEvaluator conforme descrito em avaliadores baseados em 'prompts':

# 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)

Depois de registar o seu avaliador personalizado, pode consultá-lo no seu catálogo de avaliadores. No seu projeto Foundry, selecione Avaliação e depois selecione catálogo avaliador.

Obtenha resultados

Solução de problemas

Conteúdo relacionado

  • Last updated on