Bewerten Sie Ihre generative KI-Anwendung lokal mit dem Azure AI Evaluation SDK (Vorschau) (klassisch)

Gilt nur für:klassisches Foundry Portal. Dieser Artikel ist für das neue Foundry-Portal nicht verfügbar. Erfahren Sie mehr über das neue Portal.

Sie können die Leistung Ihrer generativen KI-Anwendung gründlich bewerten, indem Sie sie auf ein wesentliches Dataset anwenden. Bewerten Sie die Anwendung in Ihrer Entwicklungsumgebung mit dem Azure AI Evaluation SDK.

Wenn Sie entweder ein Test-Dataset oder ein Ziel bereitstellen, werden Ihre generativen KI-Anwendungsausgaben sowohl mit mathematischen metriken als auch mit KI-unterstützten Qualitäts- und Sicherheitsbewertungen quantitativ gemessen. Integrierte oder benutzerdefinierte Bewerter können Ihnen umfassende Einblicke in die Funktionen und Einschränkungen der Anwendung bieten.

In diesem Artikel erfahren Sie, wie Sie Auswertungen für eine einzelne Datenzeile und ein größeres Testdatenset für ein Anwendungsziel ausführen. Sie verwenden integrierte Bewerter, die das Azure AI Evaluation SDK lokal verwenden. Anschließend lernen Sie, die Ergebnisse und Auswertungsprotokolle in einem Foundry-Projekt nachzuverfolgen.

Beginnen

Installieren Sie zunächst das Evaluators-Paket aus dem Azure AI Evaluation SDK:

pip install azure-ai-evaluation

Integrierte Bewerter

Integrierte Qualitäts- und Sicherheitsmetriken akzeptieren Abfrage- und Antwortpaare sowie zusätzliche Informationen für bestimmte Auswertungen.

Datenanforderungen für integrierte Auswertungen

Integrierte Auswertungen können Abfrage- und Antwortpaare, eine Liste von Unterhaltungen im JSON-Zeilenformat (JSONL) oder beides akzeptieren.

Azure OpenAI-Grader benötigen eine Vorlage, die beschreibt, wie ihre Eingabespalten in die realeingabe umgewandelt werden, die der Grader verwendet. Wenn Sie beispielsweise zwei Eingaben mit dem Namen "Abfrage " und "Antwort" und eine Als "Antwort" formatierte {{item.query}}Vorlage haben, wird nur die Abfrage verwendet. Ebenso könnten Sie {{item.conversation}} verwenden, um eine Unterhaltungseingabe zu akzeptieren, aber wie gut das System damit umgehen kann, hängt davon ab, wie Sie den Rest des Graders konfigurieren, um diese Eingabe zu erwarten.

Weitere Informationen zu Datenanforderungen für agentische Auswertungen finden Sie unter Bewerten Ihrer KI-Agents.

Einzeldrehungsunterstützung für Text

Alle integrierten Bewerter verwenden Single-Turn-Eingaben als Abfrage- und Antwortpaare in Zeichenfolgen. Zum Beispiel:

from azure.ai.evaluation import RelevanceEvaluator

query = "What is the capital of life?"
response = "Paris."

# Initialize an evaluator:
relevance_eval = RelevanceEvaluator(model_config)
relevance_eval(query=query, response=response)

Stellen Sie das Dataset im JSONL-Format dar, um Batchauswertungen mithilfe der lokalen Auswertungauszuführen oder ihr Dataset hochzuladen, um eine Cloudauswertung auszuführen. Die vorherigen Einzelgesprächsdaten, bei denen es sich um ein Abfrage- und Antwortpaar handelt, entsprechen einer Zeile eines Datasets, wie im folgenden Beispiel, das drei Zeilen zeigt:

{"query":"What is the capital/major city of France?","response":"Paris."}
{"query":"What atoms compose water?","response":"Hydrogen and oxygen."}
{"query":"What color is my shirt?","response":"Blue."}

Das Auswertungstestdatensatz kann je nach den Anforderungen der einzelnen integrierten Bewertungsfunktionen die folgenden Elemente enthalten:

• Abfrage: Die an die generative KI-Anwendung gesendete Abfrage.
• Antwort: Die Antwort auf die Abfrage, die von der generativen KI-Anwendung generiert wird.
• Kontext: Die Quelle, auf der die generierte Antwort basiert. Das heißt, die Grundlagendokumente.
• Grundwahrheit: Die Antwort, die von einem Benutzer oder Menschen als wahre Antwort generiert wurde.

Informationen dazu, was für jeden Evaluator erforderlich ist, finden Sie unter "Integrierte Auswertungen".

Konversationsunterstützung für Text

Für Evaluatoren, die Konversationen für Text unterstützen, können Sie conversation als Eingabe bereitstellen. Diese Eingabe enthält ein Python Wörterbuch mit einer Liste von messages, die content, role und optional context enthält.

Sehen Sie sich die folgende zweistufige Unterhaltung in Python an:

conversation = {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": None
        }
        ]
}

Um Batchauswertungen mithilfe der lokalen Auswertung auszuführen oder Ihr Dataset hochzuladen, um die Cloudauswertung auszuführen, müssen Sie das Dataset im JSONL-Format darstellen. Die vorherige Unterhaltung entspricht einer Datensatzzeile in einer JSONL-Datei wie im folgenden Beispiel:

{"conversation":
    {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": null
        }
        ]
    }
}

Unsere Bewerter verstehen, dass der erste Schritt der Unterhaltung gültig query von user, context von assistant und response von assistant im Abfrage-Antwort-Format liefert. Unterhaltungen werden dann pro Gesprächsbeitrag ausgewertet, und die Ergebnisse werden über alle Beiträge für eine Gesprächsbewertung aggregiert.

Im Konversationsmodus gibt es ein Beispiel für GroundednessEvaluator:

# Conversation mode:
import json
import os
from azure.ai.evaluation import GroundednessEvaluator, AzureOpenAIModelConfiguration

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

# Initialize the Groundedness evaluator:
groundedness_eval = GroundednessEvaluator(model_config)

conversation = {
    "messages": [
        { "content": "Which tent is the most waterproof?", "role": "user" },
        { "content": "The Alpine Explorer Tent is the most waterproof", "role": "assistant", "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight." },
        { "content": "How much does it cost?", "role": "user" },
        { "content": "$120.", "role": "assistant", "context": "The Alpine Explorer Tent is $120."}
    ]
}

# Alternatively, you can load the same content from a JSONL file.
groundedness_conv_score = groundedness_eval(conversation=conversation)
print(json.dumps(groundedness_conv_score, indent=4))

Bei Konversationsausgaben werden die Ergebnisse pro Schritt in einer Liste gespeichert, und die Gesamtbewertung der Unterhaltung 'groundedness': 4.0 wird über die Schritte gemittelt.

{
    "groundedness": 5.0,
    "gpt_groundedness": 5.0,
    "groundedness_threshold": 3.0,
    "evaluation_per_turn": {
        "groundedness": [
            5.0,
            5.0
        ],
        "gpt_groundedness": [
            5.0,
            5.0
        ],
        "groundedness_reason": [
            "The response accurately and completely answers the query by stating that the Alpine Explorer Tent is the most waterproof, which is directly supported by the context. There are no irrelevant details or incorrect information present.",
            "The RESPONSE directly answers the QUERY with the exact information provided in the CONTEXT, making it fully correct and complete."
        ],
        "groundedness_result": [
            "pass",
            "pass"
        ],
        "groundedness_threshold": [
            3,
            3
        ]
    }
}

Unterstützung für die Konversation mit Bildern und multimodalen Texten und Bildern

Für Evaluatoren, die Interaktionen für Bild und multimodale Bild- und Textinhalte unterstützen, können Sie Bild-URLs oder base64-codierte Bilder in conversation übermitteln.

Zu den unterstützten Szenarien gehören:

• Mehrere Bilder mit Texteingabe zur Bild- oder Textgenerierung.
• Nur Texteingabe für Bildgenerationen.
• Nur Bildeingabe für die Textgenerierung.

from pathlib import Path
from azure.ai.evaluation import ContentSafetyEvaluator
import base64

# Create an instance of an evaluator with image and multi-modal support.
safety_evaluator = ContentSafetyEvaluator(credential=azure_cred, azure_ai_project=project_scope)

# Example of a conversation with an image URL:
conversation_image_url = {
    "messages": [
        {
            "role": "system",
            "content": [
                {"type": "text", "text": "You are an AI assistant that understands images."}
            ],
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Can you describe this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://cdn.britannica.com/68/178268-050-5B4E7FB6/Tom-Cruise-2013.jpg"
                    },
                },
            ],
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "The image shows a man with short brown hair smiling, wearing a dark-colored shirt.",
                }
            ],
        },
    ]
}

# Example of a conversation with base64 encoded images:
base64_image = ""

with Path.open("Image1.jpg", "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

conversation_base64 = {
    "messages": [
        {"content": "create an image of a branded apple", "role": "user"},
        {
            "content": [{"type": "image_url", "image_url": {"url": f"data:image/jpg;base64,{base64_image}"}}],
            "role": "assistant",
        },
    ]
}

# Run the evaluation on the conversation to output the result.
safety_score = safety_evaluator(conversation=conversation_image_url)

Derzeit unterstützen die Bild- und multimodalen Evaluatoren:

• Nur einzelne Gesprächsrunde: Eine Unterhaltung kann nur eine Benutzernachricht und eine Assistent-Nachricht enthalten.
• Unterhaltungen mit nur einer Systemnachricht.
• Nutzlasten von Unterhaltungen, die kleiner als 10 MB sind, einschließlich Bilder.
• Absolute URLs und Base64-codierte Bilder.
• Mehrere Bilder in einer einzigen Drehung.
• JPG/JPEG-, PNG- und GIF-Dateiformate.

Einrichten

Für KI-unterstützte Qualitätsbewertungen müssen Sie mit Ausnahme der GroundednessProEvaluator Vorschau ein GPT-Modell (gpt-35-turbo, gpt-4, gpt-4-turbo, gpt-4o oder gpt-4o-mini) in Ihrem model_config angeben. Das GPT-Modell fungiert als Richter, um die Auswertungsdaten zu bewerten. Wir unterstützen beide Azure OpenAI- oder OpenAI-Modellkonfigurationsschemas. Für die beste Leistung und analysierbare Antworten mit unseren Evaluatoren empfehlen wir die Verwendung von GPT-Modellen, die nicht in der Vorschau sind.

Für alle Risiko- und Sicherheitsevaluatoren und GroundednessProEvaluator (Vorschau) müssen Sie Ihre azure_ai_project Informationen bereitstellen, anstatt eine GPT-Bereitstellung in model_config anzugebenazure_ai_project. Dadurch wird über Ihr Foundry-Projekt auf den Back-End-Auswertungsdienst zugegriffen.

Eingabeaufforderungen für KI-unterstützte eingebaute Bewertungsfunktionen

Zur Transparenz stellen wir die Eingabeaufforderungen unserer Qualitätsprüfer in unserer Evaluator-Bibliothek und im Azure AI Evaluation Python SDK-Repository zur Verfügung, mit Ausnahme der Safety Evaluators und GroundednessProEvaluator, die von Azure KI Inhaltssicherheit unterstützt werden. Diese Eingabeaufforderungen dienen als Anweisungen für ein Sprachmodell, um ihre Auswertungsaufgabe auszuführen, die eine menschliche Definition der Metrik und der zugehörigen Bewertungsrubrik erfordert. Wir empfehlen dringend, die Definitionen und Benotungsrichtlinien an Ihre spezifischen Szenarien anzupassen. Weitere Informationen finden Sie unter "Benutzerdefinierte Auswertungen".

Zusammengesetzte Bewerter

Zusammengesetzte Bewerter sind integrierte Bewerter, die einzelne Qualitäts- oder Sicherheitsmetriken kombinieren. Sie bieten von Haus aus eine breite Palette von Metriken für sowohl Abfrage-Antwort-Paare als auch Chatnachrichten.

Lokale Auswertung der Test-Datensätze unter Verwendung von evaluate()

Nachdem Sie Ihre integrierten oder benutzerdefinierten Bewerter in einer einzelnen Datenzeile überprüft haben, können Sie mehrere Auswertungen mit der evaluate() API für ein gesamtes Test-Dataset kombinieren.

Voraussetzungen für die Einrichtung von Microsoft Foundry-Projekten

Wenn diese Sitzung zum ersten Mal Auswertungen ausführt und sie in Ihrem Foundry-Projekt protokolliert, müssen Sie möglicherweise die folgenden Setupschritte ausführen:

1. Erstellen und verbinden Sie Ihr Speicherkonto mit Ihrem Foundry-Projekt auf Ressourcenebene. Diese Bicep-Vorlage stellt ein Speicherkonto mit Ihrem Foundry-Projekt mit schlüsselauthentifizierung her und verbindet es.
2. Stellen Sie sicher, dass das verbundene Speicherkonto Zugriff auf alle Projekte hat.
3. Wenn Sie Ihr Speicherkonto mit Microsoft Entra ID verbunden haben, müssen Sie Microsoft Identity-Berechtigungen für Storage Blob Data Owner sowohl für Ihr Konto als auch für die Foundry-Projektressource im Azure-Portal erteilen.

Bewerten eines Datensatzes und Ergebnisse auf Foundry protokollieren

Um sicherzustellen, dass die evaluate() API die Daten korrekt analysieren kann, müssen Sie die Spaltenzuordnung angeben, um die Spalte aus dem Dataset schlüsselwörtern zuzuordnen, die von den Evaluatoren akzeptiert werden. In diesem Beispiel wird die Datenzuordnung für query, response und context spezifiziert.

from azure.ai.evaluation import evaluate

result = evaluate(
    data="data.jsonl", # Provide your data here:
    evaluators={
        "groundedness": groundedness_eval,
        "answer_length": answer_length
    },
    # Column mapping:
    evaluator_config={
        "groundedness": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${data.context}",
                "response": "${data.response}"
            } 
        }
    },
    # Optionally, provide your Foundry project information to track your evaluation results in your project portal.
    azure_ai_project = azure_ai_project,
    # Optionally, provide an output path to dump a JSON file of metric summary, row-level data, and the metric and Foundry project URL.
    output_path="./myevalresults.json"
)

Der Evaluator gibt Ergebnisse in einem Dictionary aus, das aggregierte metrics-Daten sowie Zeilenebenen-Daten und Metriken enthält. Sehen Sie sich die folgende Beispielausgabe an:

{'metrics': {'answer_length.value': 49.333333333333336,
             'groundedness.gpt_groundeness': 5.0, 'groundedness.groundeness': 5.0},
 'rows': [{'inputs.response': 'Paris is the capital/major city of France.',
           'inputs.context': 'Paris has been the capital/major city of France since '
                                  'the 10th century and is known for its '
                                  'cultural and historical landmarks.',
           'inputs.query': 'What is the capital/major city of France?',
           'outputs.answer_length.value': 31,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'Albert Einstein developed the theory of '
                            'relativity.',
           'inputs.context': 'Albert Einstein developed the theory of '
                                  'relativity, with his special relativity '
                                  'published in 1905 and general relativity in '
                                  '1915.',
           'inputs.query': 'Who developed the theory of relativity?',
           'outputs.answer_length.value': 51,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'The speed of light is approximately 299,792,458 '
                            'meters per second.',
           'inputs.context': 'The exact speed of light in a vacuum is '
                                  '299,792,458 meters per second, a constant '
                                  "used in physics to represent 'c'.",
           'inputs.query': 'What is the speed of light?',
           'outputs.answer_length.value': 66,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'}],
 'traces': {}}

Anforderungen für evaluate()

Die evaluate() API erfordert ein bestimmtes Datenformat und Schlüsselnamen des Evaluator-Parameters, um die Auswertungsergebnisse-Diagramme in Ihrem Foundry-Projekt korrekt anzuzeigen.

Datenformat

Die evaluate() API akzeptiert nur Daten im JSONL-Format. Für alle integrierten Bewerter evaluate() sind Daten im folgenden Format mit den erforderlichen Eingabefeldern erforderlich. Weitere Informationen finden Sie im vorherigen Abschnitt zu den erforderlichen Dateneingaben für integrierte Auswertungen. Der folgende Codeausschnitt ist ein Beispiel dafür, wie eine Zeile aussehen kann:

{
  "query":"What is the capital/major city of France?",
  "context":"France is in Europe",
  "response":"Paris is the capital/major city of France.",
  "ground_truth": "Paris"
}

Das Evaluator-Parameterformat

Wenn Sie Ihre integrierten Evaluatoren angeben, geben Sie die richtige Schlüsselwortzuordnung in der evaluators Parameterliste an. In der folgenden Tabelle ist die Zuordnung von Schlüsselwörtern aufgeführt, die erforderlich ist, damit die Ergebnisse Ihrer integrierten Auswertungen in der Benutzeroberfläche angezeigt werden, wenn sie in Ihrem Foundry-Projekt protokolliert sind.

Hier ist ein Beispiel zum Festlegen der evaluators Parameter:

result = evaluate(
    data="data.jsonl",
    evaluators={
        "sexual":sexual_evaluator,
        "self_harm":self_harm_evaluator,
        "hate_unfairness":hate_unfairness_evaluator,
        "violence":violence_evaluator
    }
)

Lokale Auswertung für ein Ziel

Wenn Sie über eine Liste von Abfragen verfügen, die Sie ausführen und dann auswerten möchten, unterstützt die evaluate() API auch einen target Parameter. Dieser Parameter sendet Abfragen an eine Anwendung, um Antworten zu sammeln, und führt dann Ihre Auswertungen für die resultierende Abfrage und Antwort aus.

Ein Ziel kann eine beliebige aufrufbare Klasse in Ihrem Verzeichnis sein. In diesem Beispiel gibt es ein Python Skript askwiki.py mit einer aufrufbaren Klasse askwiki(), die als Ziel festgelegt ist. Wenn Sie über ein Dataset mit Abfragen verfügen, das Sie mit der einfachen askwiki App senden können, können Sie die Fundiertheit der Ausgaben auswerten. Stellen Sie sicher, dass Sie die richtige Spaltenzuordnung für Ihre Daten angeben."column_mapping" Sie können die "default" Spaltenzuordnung für alle Bewerter angeben.

Hier finden Sie den Inhalt in "data.jsonl":

{"query":"When was United States found ?", "response":"1776"}
{"query":"What is the capital/major city of France?", "response":"Paris"}
{"query":"Who is the best tennis player of all time ?", "response":"Roger Federer"}

from askwiki import askwiki

result = evaluate(
    data="data.jsonl",
    target=askwiki,
    evaluators={
        "groundedness": groundedness_eval
    },
    evaluator_config={
        "default": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${outputs.context}",
                "response": "${outputs.response}"
            } 
        }
    }
)

Verwandte Inhalte

• Azure AI Evaluation-Clientbibliothek für Python
• Behandeln von Problemen mit dem AI Evaluation SDK
• Beobachtbarkeit in generativer KI
• Auswerten in der Cloud mithilfe des Microsoft Foundry SDK
• Generieren synthetischer und simulierter Daten für die Auswertung
• Anzeigen von Auswertungsergebnissen im Gießereiportal
• Erste Schritte mit Foundry
• Erste Schritte mit Auswertungsbeispielen