Partilhar via

Guia de início rápido: avaliar a qualidade da resposta

Neste início rápido, você cria um aplicativo MSTest para avaliar a qualidade de uma resposta de bate-papo de um modelo OpenAI. O aplicativo de teste usa as bibliotecas Microsoft.Extensions.AI.Evaluation .

Observação

Este guia de início rápido demonstra o uso mais simples da API de avaliação. Notavelmente, não demonstra a utilização do cache de resposta nem da funcionalidade de relatórios, que são importantes se estiver a criar testes unitários que correm como parte de um pipeline de avaliação "offline". O cenário mostrado neste início rápido é adequado em casos de uso, como a avaliação "online" de respostas de IA dentro do código de produção e o registo de pontuações em telemetria, onde a cache e os relatórios não são relevantes. Para obter um tutorial que demonstra a funcionalidade de cache e relatórios, consulte Tutorial: Avaliar a resposta de um modelo com cache de resposta e relatórios

Pré-requisitos

Configurar o serviço de IA

Para provisionar um serviço e um modelo do Azure OpenAI usando o portal do Azure, conclua as etapas no artigo Criar e implantar um recurso do Serviço OpenAI do Azure. Na etapa "Implantar um modelo", selecione o modelo gpt-5.

Criar o aplicativo de teste

Complete os passos seguintes para criar um projeto MSTest que se ligue a um modelo de IA.

  1. Em uma janela de terminal, navegue até o diretório onde você deseja criar seu aplicativo e crie um novo aplicativo MSTest com o dotnet new comando:

    dotnet new mstest -o TestAI

  2. Navegue até o diretório TestAI e adicione os pacotes necessários ao seu aplicativo:

    dotnet add package Azure.AI.OpenAI
dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.AI.Abstractions
dotnet add package Microsoft.Extensions.AI.Evaluation
dotnet add package Microsoft.Extensions.AI.Evaluation.Quality
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

  3. Execute os seguintes comandos para adicionar segredos de aplicação para o seu endpoint Azure OpenAI e o ID do inquilino:

    dotnet user-secrets init
dotnet user-secrets set AZURE_OPENAI_ENDPOINT <your-Azure-OpenAI-endpoint>
dotnet user-secrets set AZURE_TENANT_ID <your-tenant-ID>

    (Dependendo do seu ambiente, o ID do locatário pode não ser necessário. Nesse caso, remova-o do código que instancia o DefaultAzureCredential.)

  4. Abra o novo aplicativo no editor de sua escolha.

Adicionar o código do aplicativo de teste

  1. Renomeie o arquivo Test1.cs para MyTests.cs e, em seguida, abra o arquivo e renomeie a classe para MyTests.

  2. Adicione os membros da mensagem privada ChatConfiguration e do bate-papo e da resposta à MyTests classe. O s_messages campo é uma lista que contém dois ChatMessage objetos: um instrui o comportamento do bot de bate-papo e o outro é a pergunta do usuário.

    private static ChatConfiguration? s_chatConfiguration;
private static IList<ChatMessage> s_messages = [
    new ChatMessage(
        ChatRole.System,
        """
        You're an AI assistant that can answer questions related to astronomy.
        Keep your responses concise and try to stay under 100 words.
        Use the imperial measurement system for all measurements in your response.
        """),
    new ChatMessage(
        ChatRole.User,
        "How far is the planet Venus from Earth at its closest and furthest points?")];
private static ChatResponse s_response = new();

  3. Adicione o InitializeAsync método à MyTests classe.

    [ClassInitialize]
public static async Task InitializeAsync(TestContext _)
{
    /// Set up the <see cref="ChatConfiguration"/>,
    /// which includes the <see cref="IChatClient"/> that the
    /// evaluator uses to communicate with the model.
    s_chatConfiguration = GetAzureOpenAIChatConfiguration();

    var chatOptions =
        new ChatOptions
        {
            Temperature = 0.0f,
            ResponseFormat = ChatResponseFormat.Text
        };

    // Fetch the response to be evaluated
    // and store it in a static variable.
    s_response = await s_chatConfiguration.ChatClient.GetResponseAsync(s_messages, chatOptions);
}

    Este método realiza as seguintes tarefas:

  4. Adicione o GetAzureOpenAIChatConfiguration método, que cria o IChatClient que o avaliador usa para se comunicar com o modelo.

    private static ChatConfiguration GetAzureOpenAIChatConfiguration()
{
    IConfigurationRoot config = new ConfigurationBuilder().AddUserSecrets<MyTests>().Build();

    string endpoint = config["AZURE_OPENAI_ENDPOINT"];
    string tenantId = config["AZURE_TENANT_ID"];
    string model = "gpt-5";

    // Get a chat client for the Azure OpenAI endpoint.
    AzureOpenAIClient azureClient =
        new(
            new Uri(endpoint),
            new DefaultAzureCredential(new DefaultAzureCredentialOptions() { TenantId = tenantId }));
    IChatClient client = azureClient.GetChatClient(deploymentName: model).AsIChatClient();

    return new ChatConfiguration(client);
}

  5. Adicione um método de teste para avaliar a resposta do modelo.

    [TestMethod]
public async Task TestCoherence()
{
    IEvaluator coherenceEvaluator = new CoherenceEvaluator();
    EvaluationResult result = await coherenceEvaluator.EvaluateAsync(
        s_messages,
        s_response,
        s_chatConfiguration);

    /// Retrieve the score for coherence from the <see cref="EvaluationResult"/>.
    NumericMetric coherence = result.Get<NumericMetric>(CoherenceEvaluator.CoherenceMetricName);

    // Validate the default interpretation
    // for the returned coherence metric.
    Assert.IsFalse(coherence.Interpretation!.Failed);
    Assert.IsTrue(coherence.Interpretation.Rating is EvaluationRating.Good or EvaluationRating.Exceptional);

    // Validate that no diagnostics are present
    // on the returned coherence metric.
    Assert.IsFalse(coherence.ContainsDiagnostics());
}

    Este método faz o seguinte:

    • Invoca o CoherenceEvaluator para avaliar a coerência da resposta. O EvaluateAsync(IEnumerable<ChatMessage>, ChatResponse, ChatConfiguration, IEnumerable<EvaluationContext>, CancellationToken) método retorna um EvaluationResult que contém um NumericMetric. A NumericMetric contém um valor numérico que normalmente é usado para representar pontuações numéricas que estão dentro de um intervalo bem definido.
    • Recupera a pontuação de coerência do EvaluationResult.
    • Valida a interpretação padrão para a métrica de coerência retornada. Os avaliadores podem incluir uma interpretação padrão para as métricas que retornam. Você também pode alterar a interpretação padrão para atender às suas necessidades específicas, se necessário.
    • Valida que nenhum diagnóstico está presente na métrica de coerência retornada. Os avaliadores podem incluir diagnósticos nas métricas que retornam para indicar erros, avisos ou outras condições excecionais encontradas durante a avaliação.

Executar o teste/avaliação

Execute o teste usando seu fluxo de trabalho de teste preferido, por exemplo, usando o comando dotnet test CLI ou através do Test Explorer.

Limpeza de recursos

Se você não precisar mais deles, exclua o recurso OpenAI do Azure e a implantação do modelo GPT-4.

  1. No portal Azure, navegue até ao recurso Azure OpenAI.
  2. Selecione o recurso Azure OpenAI e, em seguida, selecione Excluir.

Próximos passos

  • Last updated on