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 chat de um modelo OpenAI. O aplicativo de teste usa as bibliotecas Microsoft.Extensions.AI.Evaluation.

Observação

Este início rápido demonstra o uso mais simples da API de avaliação. De maneira notável, ele não demonstra o uso da funcionalidade de cache de resposta e relatório, às quais são importantes se você estiver criando testes de unidade que são executados 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 registro de pontuações para telemetria, em que o cache e os relatórios não são relevantes. Para obter um tutorial que demonstra a funcionalidade de cache e relatório, 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 Azure OpenAI service e um modelo usando o portal Azure, conclua as etapas no artigo Criar e implantar um recurso Serviço OpenAI do Azure. Na etapa "Implantar um modelo", selecione o gpt-5 modelo.

Criar o aplicativo de teste

Conclua as etapas a seguir para criar um projeto MSTest que se conecte 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 TestAI diretório 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
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

  3. Execute os seguintes comandos para adicionar segredos do aplicativo para o ponto de extremidade, nome do modelo e ID do locatário do OpenAI do Azure:

    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, talvez você não precise da ID do locatário. Nesse caso, remova-o do código que cria uma instância do DefaultAzureCredential.)

  4. Abra o novo aplicativo em seu editor de 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 o ChatConfiguration privado e os membros de mensagem e resposta de chat à classe MyTests. O s_messages campo é uma lista que contém dois ChatMessage objetos— um instrui o comportamento do chat bot 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);
}

    Esse 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());
}

    Esse método faz o seguinte:

    • Invoca a 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. Um NumericMetric contém um valor numérico que normalmente representa pontuações numéricas que se enquadram em 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 aos seus requisitos específicos, 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 excepcionais encontradas durante a avaliação.

Executar o teste/avaliação

Execute o teste usando seu fluxo de trabalho de teste preferencial, por exemplo, usando o comando dotnet test da CLI ou por meio do Gerenciador de Testes.

Limpar os recursos

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

  1. No portal do Azure, navegue até o recurso Azure OpenAI.
  2. Selecione o recurso Azure OpenAI e selecione Delete.

Próximas etapas

  • Last updated on