Freigeben über

Schnellstart: Bewerten der Antwortqualität

In dieser Schnellstartanleitung erstellen Sie eine MSTest-App, um die Qualität einer Chatantwort aus einem OpenAI-Modell auszuwerten. Die Testanwendung verwendet die Microsoft.Extensions.AI.Evaluation-Bibliotheken.

Hinweis

In dieser Schnellstartanleitung wird die einfachste Verwendung der Auswertungs-API veranschaulicht. Insbesondere wird die Verwendung der Funktionen für das Zwischenspeichern von Antworten und die Berichterstellung nicht veranschaulicht, was wichtig ist, wenn Sie Komponententests erstellen, die als Teil einer "Offline-Auswertungspipeline" ausgeführt werden. Das in diesem Schnellstart gezeigte Szenario eignet sich für Anwendungsfälle wie die "Online"-Auswertung von KI-Antworten innerhalb von Produktionscode und das Protokollieren von Ergebnissen zu Telemetrie, wo Caching und Reporting nicht relevant sind. Ein Lernprogramm, das die Zwischenspeicherungs- und Berichterstellungsfunktionen veranschaulicht, finden Sie im Lernprogramm: Bewerten der Antwortantwort eines Modells mit Zwischenspeicherung und Berichterstellung

Voraussetzungen

Konfigurieren des KI-Diensts

Um eine Azure OpenAI Service-Instanz und ein Azure-Modell mithilfe des Azure-Portals bereitzustellen, führen Sie die Schritte im Artikel zum Erstellen und Bereitstellen einer Azure OpenAI Service-Ressource aus. Wählen Sie im Schritt "Modell bereitstellen" das gpt-4o Modell aus.

Erstellen der Test-App

Führen Sie die folgenden Schritte aus, um ein MSTest-Projekt zu erstellen, das eine Verbindung mit dem gpt-4o KI-Modell herstellt.

  1. Navigieren Sie in einem Terminalfenster zu dem Verzeichnis, in dem Sie Ihre App erstellen möchten, und erstellen Sie eine neue MSTest-App mit dem Befehl dotnet new:

    dotnet new mstest -o TestAI

  2. Navigieren Sie zum Verzeichnis TestAI, und fügen Sie Ihrer App die erforderlichen Pakete hinzu:

    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. Führen Sie die folgenden Befehle aus, um App-Geheimnisse für Ihren Azure OpenAI-Endpunkt, den Modellnamen und die Mandanten-ID hinzuzufügen:

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

    (Je nach Ihrer Umgebung ist die Mandanten-ID möglicherweise nicht erforderlich. In diesem Fall sollten Sie sie aus dem Code entfernen, der die DefaultAzureCredential instanziiert.)

  4. Öffnen Sie die neue App in Ihrem Editor der Wahl.

Hinzufügen des Test-App-Codes

  1. Benennen Sie die Datei Test1.cs in MyTests.cs um. Öffnen Sie dann die Datei und benennen Sie die Klasse in MyTests um.

  2. Fügen Sie der ChatConfiguration-Klasse die private MyTests, Chat-Nachrichten und Antworten der Teilnehmer hinzu. Das feld s_messages ist eine Liste, die zwei ChatMessage-Objekte enthält– eines weist das Verhalten des Chat-Bots an, und die andere ist die Frage des Benutzers.

    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. Fügen Sie der InitializeAsync-Klasse die MyTests Methode hinzu.

    [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);
}

    Diese Methode erledigt die folgenden Aufgaben:

  4. Fügen Sie die GetAzureOpenAIChatConfiguration-Methode hinzu, mit der die IChatClient erstellt wird, die der Evaluator für die Kommunikation mit dem Modell verwendet.

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

    string endpoint = config["AZURE_OPENAI_ENDPOINT"];
    string model = config["AZURE_OPENAI_GPT_NAME"];
    string tenantId = config["AZURE_TENANT_ID"];

    // 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. Fügen Sie eine Testmethode hinzu, um die Antwort des Modells auszuwerten.

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

    Diese Methode führt die folgenden Aktionen aus:

    • Ruft den CoherenceEvaluator dazu auf, die Kohärenz der Antwort auszuwerten. Die EvaluateAsync(IEnumerable<ChatMessage>, ChatResponse, ChatConfiguration, IEnumerable<EvaluationContext>, CancellationToken)-Methode gibt einen EvaluationResult zurück, der ein NumericMetricenthält. Ein NumericMetric enthält einen numerischen Wert, der in der Regel verwendet wird, um numerische Werte darzustellen, die in einen klar definierten Bereich fallen.
    • Ruft die Kohärenzbewertung aus dem EvaluationResult ab.
    • Überprüft die Standardinterpretation für die zurückgegebene Kohärenzmetrik. Evaluatoren können eine Standardinterpretation für die zurückgegebenen Metriken enthalten. Bei Bedarf können Sie auch die Standardinterpretation entsprechend Ihren spezifischen Anforderungen ändern.
    • Überprüft, ob keine Diagnose für die zurückgegebene Kohärenzmetrik vorhanden ist. Evaluatoren können Diagnosen für die Metriken enthalten, die sie zurückgeben, um Fehler, Warnungen oder andere außergewöhnliche Bedingungen anzugeben, die bei der Auswertung aufgetreten sind.

Ausführen des Tests/der Auswertung

Führen Sie den Test mit Ihrem bevorzugten Testworkflow aus, z. B. mithilfe des CLI-Befehls dotnet test oder über Test Explorer.

Bereinigen von Ressourcen

Wenn Sie sie nicht mehr benötigen, löschen Sie die Azure OpenAI-Ressource und die GPT-4-Modellbereitstellung.

  1. Navigieren Sie im Azure Portalzur Azure OpenAI-Ressource.
  2. Wählen Sie die Azure OpenAI-Ressource aus und wählen Sie dann Löschen.

Nächste Schritte