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

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 Bewertungen bieten Ihnen umfassende Erkenntnisse in die Funktionen und Einschränkungen der Anwendung.

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.

Loslegen

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

pip install azure-ai-evaluation

Integrierte Evaluatoren

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 erfordern eine Vorlage, die beschreibt, wie ihre Eingabespalten in die echte Eingabe 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 z. B. mit {{item.conversation}} eine Unterhaltungseingabe akzeptieren, aber ob das System diese behandeln kann, hängt davon ab, wie Sie den restlichen Bewerter (Grader) zur Annahme dieser Eingabe konfigurieren.

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

Einteilige Unterstütztung für Text

Alle integrierten Auswerter verwenden einteilige Eingaben als Abfrage-Antwort-Paare in Zeichenfolgen. 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. Das folgende Beispiel zeigt drei solcher Zeilen:

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

Der Evaluierungstestdatensatz kann je nach den Anforderungen der einzelnen integrierten Evaluatoren 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 jeder Evaluator erfordert, finden Sie unter "Evaluatoren".

Unterhaltung unterstützt für Text

Für Evaluatoren, die Gespräche anhand von 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 einschließt.

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 Evaluatoren verstehen, dass der erste Wechsel der Unterhaltung gültige query aus user, context aus assistant und response aus assistant im Abfrageantwortformat bereitstellt. Unterhaltungen werden dann pro Wechsel ausgewertet, und die Ergebnisse werden für eine Unterhaltungsbewertung über alle Wechsel aggregiert.

Für den Unterhaltungsmodus ist hier 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 Unterhaltungsausgaben werden Ergebnisse pro Wechsel in einer Liste gespeichert, und die Gesamtunterhaltungsbewertung 'groundedness': 4.0 wird über die Wechsel 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 Kommunikation mit Bildern und multimodalem Text und Bild

Für Auswerter, die Unterhaltungen für Bild sowie multimodale Bild- und Textinhalte unterstützen, können Sie Bild-URLs oder Base64-codierte Bilder in conversation übergeben.

Zu den unterstützten Szenarien gehören:

• Mehrere Bilder mit der Möglichkeit zur Bild- oder Textgenerierung über Texteingabe.
• 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 einzelner Durchlauf: Eine Unterhaltung kann nur eine Benutzernachricht und eine Assistentennachricht enthalten.
• Unterhaltungen mit nur einer Systemnachricht.
• Konversationseinheiten, 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 ein GPT-Modell (GroundednessProEvaluator, gpt-35-turbo, gpt-4, gpt-4-turbo oder gpt-4o) in Ihrem gpt-4o-mini angeben, mit Ausnahme der model_config Vorschau. Das GPT-Modell fungiert als Richter, um die Auswertungsdaten zu bewerten. Wir unterstützen sowohl Azure OpenAI- als auch 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.

Bei allen Risiko- und Sicherheitsauswertern und bei GroundednessProEvaluator (Vorschau) müssen Sie anstelle einer GPT-Bereitstellung in model_config Ihre azure_ai_project-Informationen angeben. Dadurch wird über Ihr Foundry-Projekt auf den Back-End-Auswertungsdienst zugegriffen.

Anweisungen für KI-unterstützte integrierte Bewertungstools

Um mehr Transparenz zu schaffen, legen wir die Aufforderungen unserer Qualitätsauswerter in unserer Evaluator-Bibliothek und im Azure AI Evaluation Python SDK-Repository offen, mit Ausnahme der Safety Evaluators und des GroundednessProEvaluator, der von Azure KI Inhaltssicherheit unterstützt wird. 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 Benotungsrubriken an Ihre spezifischen Szenarioanforderungen anzupassen. Weitere Informationen finden Sie unter "Benutzerdefinierte Auswertungen".

Zusammengesetzte Evaluatoren

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

Lokale Bewertung für Testdatasets mithilfe von evaluate()

Nachdem Sie die integrierten oder benutzerdefinierten Bewertungen bei einer einzelnen Datenzeile überprüft haben, können Sie mehrere Bewertungen mit der evaluate()-API für ein gesamtes Testdataset kombinieren.

Erforderliche Einrichtungsschritte für Microsoft Foundry-Projekte

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 der Microsoft Entra-ID verbunden haben, stellen Sie sicher, dass Sie Microsoft Identity-Berechtigungen für den Besitzer von Speicher-Blob-Daten für Ihr Konto und die Foundry-Projektressource in Azure-Portal erteilen.

Bewerten auf einem Datensatz und Ergebnisse in 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, responseund contextangegeben.

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 die Ergebnisse in Form eines Wörterbuchs aus, das sowohl aggregierte metrics- als auch Zeilenebenendaten 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 of France.',
           'inputs.context': 'Paris has been the capital of France since '
                                  'the 10th century and is known for its '
                                  'cultural and historical landmarks.',
           'inputs.query': 'What is the capital 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 für die Evaluator-Parameter, um die Auswertungsergebniskurven 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 of France?",
  "context":"France is in Europe",
  "response":"Paris is the capital of France.",
  "ground_truth": "Paris"
}

Evaluator-Parameterformat

Wenn Sie Ihre integrierten Auswerter übergeben, geben Sie in der evaluators-Parameterliste die richtige Keyword-Zuordnung an. In der folgenden Tabelle ist die erforderliche Schlüsselwortzuordnung dargestellt, damit die Ergebnisse Ihrer eingebauten Auswertungen in der Benutzeroberfläche erscheinen, wenn sie in Ihrem Foundry-Projekt protokolliert werden.

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, die Sie in die einfache askwiki-App senden können, können Sie die Fundamentiertheit der Ausgaben evaluieren. Stellen Sie sicher, dass Sie die richtige Spaltenzuordnung für Ihre Daten angeben."column_mapping" Sie können "default" verwenden, um die Spaltenzuordnung für alle Bewerter anzugeben.

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

{"query":"When was United States found ?", "response":"1776"}
{"query":"What is the capital 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
• Ausführen von Auswertungen 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