Ausführen von Auswertungen in der Cloud mithilfe des Microsoft Foundry SDK

Wichtig

In diesem Artikel markierte Elemente (Vorschau) befinden sich derzeit in der öffentlichen Vorschau. Diese Vorschau wird ohne Vereinbarung auf Serviceebene bereitgestellt und wird für Produktionsworkloads nicht empfohlen. Bestimmte Features werden möglicherweise nicht unterstützt oder weisen eingeschränkte Funktionen auf. Weitere Informationen finden Sie unter ergänzende Nutzungsbedingungen für Microsoft Azure Previews.

In diesem Artikel erfahren Sie, wie Sie Auswertungen in der Cloud (Vorschau) für Vorabbereitstellungstests für ein Test-Dataset ausführen.

Verwenden Sie Cloud-Auswertungen für die meisten Szenarien – insbesondere beim Testen in großem Maßstab, und integrieren Sie Auswertungen in CI/CD-Pipelines oder bevor Sie Bereitstellungstests durchführen. Das Ausführen von Auswertungen in der Cloud beseitigt die Notwendigkeit, die lokale Computeinfrastruktur zu verwalten und umfangreiche automatisierte Testworkflows zu unterstützen. Sie können auch Auswertungen planen , die regelmäßig ausgeführt werden sollen, oder eine fortlaufende Auswertung einrichten, um stichprobenbezogene Agentantworten in der Produktion automatisch auszuwerten.

Die Ergebnisse der Cloudauswertung werden in Ihrem Foundry-Projekt gespeichert. Sie können die Ergebnisse im Portal überprüfen, sie über das SDK abrufen oder an Application Insights weiterleiten, wenn sie verbunden sind. Die Cloudauswertung unterstützt alle von Microsoft kuratierten integrierten Bewerter und Ihre eigenen benutzerdefinierten Bewerter. Evaluatoren werden im Evaluator-Katalog mit der gleichen projektbezogenen, rollenbasierten Zugriffssteuerung verwaltet.

Tipp

Vollständige runnable Beispiele finden Sie in den Python SDK-Evaluierungsbeispielen auf GitHub.

Funktionsweise der Cloudauswertung

Um eine Cloudauswertung auszuführen, erstellen Sie eine Auswertungsdefinition mit Ihrem Datenschema und Testkriterien (Auswertungskriterien), und erstellen Sie dann eine Auswertungsausführung. Die Ausführung führt jeden Auswerter für Ihre Daten aus und gibt bewertete Ergebnisse zurück, die Sie zur Fertigstellung abfragen können.

Die Cloudauswertung unterstützt die folgenden Szenarien:

Szenario Wann verwendet werden soll Datenquellentyp Ziel
Datasetauswertung Bewertung der vorab berechneten Antworten in einer JSONL-Datei. jsonl —
CSV-Datasetauswertung Bewertung vorab berechneter Antworten in einer CSV-Datei. csv —
Modellzielauswertung Geben Sie Abfragen ein und generieren Sie Antworten aus einem Modell während der Ausführung zur Bewertung. azure_ai_target_completions azure_ai_model
Bewertung des Agentenzielobjekts Stellen Sie Abfragen bereit und generieren Sie Reaktionen von einem Foundry-Agent (Prompt oder gehostet) zur Laufzeit zur Auswertung. azure_ai_target_completions azure_ai_agent
Agentantwortauswertung Abrufen und Auswerten der Antworten des Foundry-Agents anhand von Antwort-IDs. azure_ai_responses —
Trace-Analyse Bewerten Sie Agentinteraktionen, die bereits in Application Insights erfasst wurden, anhand der Trace-ID. Verwenden Sie diesen Ansatz für Nicht-Foundry-Agents (LangChain und benutzerdefinierte Frameworks, die der OpenTelemetry-basierten Protokollierung entsprechen). azure_ai_traces —
Auswertung synthetischer Daten (Vorschau) Generieren Sie synthetische Testabfragen, senden Sie sie an ein Modell oder einen Agent, und bewerten Sie die Antworten. azure_ai_synthetic_data_gen_preview azure_ai_model Oder azure_ai_agent
Rote Teambewertung Führen Sie automatisierte Adversarialtests für ein Modell oder einen Agent aus. azure_ai_red_team azure_ai_model Oder azure_ai_agent

Die meisten Szenarien erfordern Eingabedaten. Sie können Daten auf zwei Arten bereitstellen:

Quelltyp Beschreibung
file_id Verweisen Sie auf ein hochgeladenes Dataset anhand der ID.
file_content Geben Sie Daten inline in der Anforderung an.

Jede Auswertung erfordert eine data_source_config , die dem Dienst angibt, welche Felder in Ihren Daten erwartet werden:

  • custom – Sie definieren eine item_schema mit ihren Feldnamen und -typen. Legen Sie include_sample_schema bei Verwendung eines Ziels auf true fest, damit Gutachterinnen/Gutachter auf generierte Reaktionen verweisen können.
  • azure_ai_source — Das Schema wird vom Dienst abgeleitet. Setzen Sie "scenario" für die Agentenantwortbewertung, "responses" für die Spurauswertung, "traces" für die synthetische Datenauswertung (Vorschau) oder für Red Teaming fest.

Jedes Szenario erfordert Bewertungen, die Ihre Testkriterien definieren. Anleitungen zum Auswählen von Bewertern finden Sie unter integrierte Bewerter.

Voraussetzungen

  • Ein Foundry-Projekt.

  • Eine Azure OpenAI-Bereitstellung mit einem GPT-Modell, das den Chatabschluss unterstützt (z. B gpt-5-mini. ).

  • Rolle "Foundry User " im Foundry-Projekt.

    Wichtig

    Die Foundry-RBAC-Rollen wurden kürzlich umbenannt. Foundry User, Foundry Owner, Foundry Account Owner und Foundry Project Manager wurden zuvor Azure KI-Benutzer, Azure KI-Besitzer, Azure KI-Kontobesitzer und Azure AI Project Manager benannt. Möglicherweise werden die vorherigen Namen an einigen Stellen weiterhin angezeigt, während der Umbenennungsrollout ausgeführt wird. Die Rollen-IDs und Kernberechtigungen bleiben durch die Umbenennung unverändert.

  • Optional können Sie Ihr eigenes Speicherkonto verwenden , um Auswertungen auszuführen.

Hinweis

Einige Auswertungsfeatures weisen regionale Einschränkungen auf. Ausführliche Informationen finden Sie in den unterstützten Regionen .

Beginnen

Installieren Sie das SDK, und richten Sie Ihren Client ein:

pip install "azure-ai-projects>=2.0.0"

import os
from azure.identity import DefaultAzureCredential 
from azure.ai.projects import AIProjectClient 
from openai.types.eval_create_params import DataSourceConfigCustom
from openai.types.evals.create_eval_jsonl_run_data_source_param import (
    CreateEvalJSONLRunDataSourceParam,
    SourceFileContent,
    SourceFileContentContent,
    SourceFileID,
)

# Azure AI Project endpoint
# Example: https://<account_name>.services.ai.azure.com/api/projects/<project_name>
endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]

# Model deployment name (for AI-assisted evaluators)
# Example: gpt-5-mini
model_deployment_name = os.environ.get("AZURE_AI_MODEL_DEPLOYMENT_NAME", "")

# Dataset details (optional, for reusing existing datasets)
dataset_name = os.environ.get("DATASET_NAME", "")
dataset_version = os.environ.get("DATASET_VERSION", "1")

# Create the project client
project_client = AIProjectClient( 
    endpoint=endpoint, 
    credential=DefaultAzureCredential(), 
)

# Get the OpenAI client for evaluation API
client = project_client.get_openai_client()

Vorbereiten von Eingabedaten

Die meisten Auswertungsszenarien erfordern Eingabedaten. Sie können Daten auf zwei Arten bereitstellen:

Laden Sie eine JSONL- oder CSV-Datei hoch, um ein versionsiertes Dataset in Ihrem Foundry-Projekt zu erstellen. Datasets unterstützen die Versionsverwaltung und Wiederverwendung über mehrere Bewertungsläufe hinweg. Verwenden Sie diesen Ansatz für Produktionstests und CI/CD-Workflows.

Bereiten Sie eine JSONL-Datei mit einem JSON-Objekt pro Zeile mit den Feldern vor, die Ihre Evaluatoren benötigen:

{"query": "What is machine learning?", "response": "Machine learning is a subset of AI.", "ground_truth": "Machine learning is a type of AI that learns from data."}
{"query": "Explain neural networks.", "response": "Neural networks are computing systems inspired by biological neural networks.", "ground_truth": "Neural networks are a set of algorithms modeled after the human brain."}

Oder bereiten Sie eine CSV-Datei mit Spaltenüberschriften vor, die Ihren Evaluator-Feldern entsprechen:

query,response,ground_truth
What is machine learning?,Machine learning is a subset of AI.,Machine learning is a type of AI that learns from data.
Explain neural networks.,Neural networks are computing systems inspired by biological neural networks.,Neural networks are a set of algorithms modeled after the human brain.

# Upload a local JSONL file. Skip this step if you already have a dataset registered.
data_id = project_client.datasets.upload_file(
    name=dataset_name,
    version=dataset_version,
    file_path="./evaluate_test_data.jsonl",
).id

Daten inline bereitstellen

Um schnell mit kleinen Testsätzen zu experimentieren, stellen Sie Daten direkt in der Auswertungsanforderung bereit.file_content

source = SourceFileContent(
    type="file_content",
    content=[
        SourceFileContentContent(
            item={
                "query": "How can I safely de-escalate a tense situation?",
                "ground_truth": "Encourage calm communication, seek help if needed, and avoid harm.",
            }
        ),
        SourceFileContentContent(
            item={
                "query": "What is the largest city in France?",
                "ground_truth": "Paris",
            }
        ),
    ],
)

Übergeben Sie bei der Erstellung einer Ausführung source als "source"-Feld in Ihrer Datenquellenkonfiguration. Die folgenden Szenarioabschnitte verwenden standardmäßig file_id.

Datensatzbewertung

Bewertung von vorab berechneten Antworten in einer JSONL-Datei mithilfe des jsonl Datenquellentyps. Dieses Szenario ist nützlich, wenn Sie bereits Über Modellausgaben verfügen und deren Qualität bewerten möchten.

Tipp

Bevor Sie beginnen, führen Sie "Erste Schritte " und "Vorbereiten von Eingabedaten" aus.

Definieren des Datenschemas und der Auswerter

Geben Sie das Schema an, das Ihren JSONL-Feldern entspricht, und wählen Sie die zu ausführenden Evaluatoren (Testkriterien) aus. Verwenden Sie den data_mapping-Parameter, um Felder aus Ihren Eingabedaten mit Evaluatorparametern im {{item.field}}-Syntax zu verbinden. Fügen Sie data_mapping immer zu den erforderlichen Eingabefeldern für jeden Evaluator hinzu. Ihre Feldnamen müssen mit denen in der JSONL-Datei übereinstimmen — zum Beispiel, wenn Ihre Daten "question" statt "query" enthalten, sollten Sie "{{item.question}}" in der Zuordnung verwenden. Die erforderlichen Parameter pro Evaluator finden Sie unter integrierten Bewertern.

data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
            "response": {"type": "string"},
            "ground_truth": {"type": "string"},
        },
        "required": ["query", "response", "ground_truth"],
    },
)

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "f1",
        "evaluator_name": "builtin.f1_score",
        "data_mapping": {
            "response": "{{item.response}}",
            "ground_truth": "{{item.ground_truth}}",
        },
    },
]

Auswertung erstellen und ausführen

Erstellen Sie die Auswertung, und starten Sie dann eine Ausführung für Ihr hochgeladenes Dataset. Die Ausführung führt jeden Evaluator für jede Zeile im Dataset aus.

# Create the evaluation
eval_object = client.evals.create(
    name="dataset-evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

# Create a run using the uploaded dataset
eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="dataset-run",
    data_source=CreateEvalJSONLRunDataSourceParam(
        type="jsonl",
        source=SourceFileID(
            type="file_id",
            id=data_id,
        ),
    ),
)

Ein vollständiges runnables Beispiel finden Sie unter sample_evaluations_builtin_with_dataset_id.py auf GitHub. Zum Abfragen der Beendigung und zum Interpretieren der Ergebnisse lesen Sie den Abschnitt Ergebnisse abrufen.

CSV-Datasetauswertung

Bewertung vorab berechneter Antworten in einer CSV-Datei mithilfe des csv Datenquellentyps. Dieses Szenario funktioniert auf die gleiche Weise wie die Datasetauswertung , akzeptiert jedoch CSV-Dateien anstelle von JSONL. Verwenden Sie CSV, wenn Ihre Daten bereits im Tabellenkalkulations- oder Tabellenformat vorliegen.

Tipp

Bevor Sie beginnen, führen Sie "Erste Schritte " und "Vorbereiten von Eingabedaten" aus.

Vorbereiten einer CSV-Datei

Erstellen Sie eine CSV-Datei mit Spaltenüberschriften, die den Feldern entsprechen, die Ihre Evaluatoren benötigen. Jede Zeile stellt einen Testfall dar:

query,response,context,ground_truth
What is cloud computing?,Cloud computing delivers computing services over the internet.,Cloud computing is a technology for on-demand resource delivery.,Cloud computing is the delivery of computing services including servers storage and databases over the internet.
What is machine learning?,Machine learning is a subset of AI that learns from data.,Machine learning is a branch of artificial intelligence.,Machine learning is a type of AI that enables computers to learn from data without being explicitly programmed.
Explain neural networks.,Neural networks are computing systems inspired by biological neural networks.,Neural networks are used in deep learning.,Neural networks are a set of algorithms modeled after the human brain designed to recognize patterns.

Hochladen und Ausführen

Laden Sie die CSV-Datei als Dataset hoch, und erstellen Sie dann eine Auswertung mit dem csv Datenquellentyp. Die Schemadefinition und die Evaluatorkonfiguration sind identisch mit JSONL-Auswertungen – der einzige Unterschied besteht "type": "csv" in der Datenquelle.

# Upload the CSV file
data_id = project_client.datasets.upload_file(
    name="eval-csv-data",
    version="1",
    file_path="./evaluation_data.csv",
).id

# Define the schema matching your CSV columns
data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
            "response": {"type": "string"},
            "context": {"type": "string"},
            "ground_truth": {"type": "string"},
        },
        "required": [],
    },
    include_sample_schema=True,
)

# Define evaluators with data mappings to CSV columns
testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
        "initialization_parameters": {"deployment_name": model_deployment_name},
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
        "initialization_parameters": {"deployment_name": model_deployment_name},
    },
    {
        "type": "azure_ai_evaluator",
        "name": "f1",
        "evaluator_name": "builtin.f1_score",
    },
]

# Create the evaluation
eval_object = client.evals.create(
    name="CSV evaluation with built-in evaluators",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

# Create a run using the CSV data source type
eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="csv-evaluation-run",
    data_source={
        "type": "csv",
        "source": {
            "type": "file_id",
            "id": data_id,
        },
    },
)

Zum Abfragen der Beendigung und zum Interpretieren der Ergebnisse lesen Sie den Abschnitt Ergebnisse abrufen.

Modellzielbewertung

Senden Sie Abfragen an ein bereitgestelltes Modell zur Laufzeit, und bewerten Sie anschließend die Reaktionen mithilfe des Datenquellentyps azure_ai_target_completions mit einem azure_ai_model-Ziel. Ihre Eingabedaten enthalten Abfragen; das Modell generiert Antworten, die dann ausgewertet werden.

Tipp

Bevor Sie beginnen, führen Sie "Erste Schritte " und "Vorbereiten von Eingabedaten" aus.

Definieren Sie die Nachrichtenvorlage und das Ziel

Die input_messages Vorlage steuert, wie Abfragen an das Modell gesendet werden. Verwenden Sie {{item.query}}, um auf Felder aus Ihren Eingabedaten zu verweisen. Geben Sie das Modell an, das ausgewertet werden soll, und optionale Samplingparameter:

input_messages = {
    "type": "template",
    "template": [
        {
            "type": "message",
            "role": "user",
            "content": {
                "type": "input_text",
                "text": "{{item.query}}"
            }
        }
    ]
}

target = {
    "type": "azure_ai_model",
    "model": "gpt-5-mini",
    "sampling_params": {
        "top_p": 1.0,
        "max_completion_tokens": 2048,
    },
}

Einrichten von Evaluatoren und Daten-Mappings

Wenn das Modell zur Laufzeit Antworten generiert, verwenden Sie {{sample.output_text}} in data_mapping um auf die Ausgabe des Modells zu verweisen. Verwenden Sie {{item.field}}, um auf Felder aus Ihren Eingabedaten zu verweisen.

data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
        },
        "required": ["query"],
    },
    include_sample_schema=True,
)

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
]

Auswertung erstellen und ausführen

eval_object = client.evals.create(
    name="Model Target Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_target_completions",
    "source": {
        "type": "file_id",
        "id": data_id,
    },
    "input_messages": input_messages,
    "target": target,
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="model-target-evaluation",
    data_source=data_source,
)

Ein vollständiges Runnable-Beispiel finden Sie unter sample_model_evaluation.py auf GitHub. Zum Abfragen der Beendigung und zum Interpretieren der Ergebnisse lesen Sie den Abschnitt Ergebnisse abrufen.

Tipp

Um eine weitere Auswertungsausführung hinzuzufügen, können Sie denselben Code verwenden.

Agent-Zielauswertung

Senden Sie Abfragen zur Laufzeit an einen Foundry-Agent, und bewerten Sie die Antworten mithilfe des azure_ai_target_completions Datenquellentyps mit einem azure_ai_agent Ziel. Dieses Szenario funktioniert sowohl für Eingabeaufforderungs-Agents als auch für gehostete Agents.

Tipp

Bevor Sie beginnen, führen Sie "Erste Schritte " und "Vorbereiten von Eingabedaten" aus.

Tipp

Gehostete Agents, die das Antwortprotokoll verwenden, funktionieren mit den hier gezeigten Codebeispielen. Bei gehosteten Agents, die das Aufrufprotokoll verwenden, unterscheidet sich das input_messages Format. Ausführliche Informationen finden Sie im Protokoll für Aufrufe des gehosteten Agents .

Definieren Sie die Nachrichtenvorlage und das Ziel

Die input_messages Vorlage steuert, wie Abfragen an den Agent gesendet werden. Verwenden Sie {{item.query}}, um auf Felder aus Ihren Eingabedaten zu verweisen. Geben Sie den Agent an, der anhand des Namens ausgewertet werden soll:

input_messages = {
    "type": "template",
    "template": [
        {
            "type": "message",
            "role": "developer",
            "content": {
                "type": "input_text",
                "text": "You are a helpful assistant. Answer clearly and safely."
            }
        },
        {
            "type": "message",
            "role": "user",
            "content": {
                "type": "input_text",
                "text": "{{item.query}}"
            }
        }
    ]
}

target = {
    "type": "azure_ai_agent",
    "name": "my-agent",
    "version": "1"  # Optional. Uses latest version if omitted.
}

Einrichten von Evaluatoren und Daten-Mappings

Wenn der Agent zur Laufzeit Antworten generiert, verwenden Sie {{sample.*}}-Variablen in data_mapping, um auf die Ausgabe des Agents zu verweisen.

Variable Beschreibung Verwendung für
{{sample.output_text}} Die Nur-Text-Antwort des Agents. Evaluatoren, die eine Zeichenfolgenantwort erwarten (z. B coherence. , violence).
{{sample.output_items}} Die strukturierte JSON-Ausgabe des Agents, einschließlich Toolaufrufen. Auswerter, die vollständigen Interaktionskontext benötigen (z. B. task_adherence).
{{item.field}} Ein Feld aus Ihren Eingabedaten. Eingabefelder wie query oder ground_truth.

Tipp

Das query Feld kann strukturierte JSON enthalten, einschließlich Systemnachrichten und Unterhaltungsverlauf. Einige Agentenbewertungsprogramme wie task_adherence verwenden diesen Kontext für eine genauere Bewertung. Ausführliche Informationen zur Abfrageformatierung finden Sie unter Agent-Evaluatoren.

data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
        },
        "required": ["query"],
    },
    include_sample_schema=True,
)

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "task_adherence",
        "evaluator_name": "builtin.task_adherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_items}}",
        },
    },
]

Auswertung erstellen und ausführen

eval_object = client.evals.create(
    name="Agent Target Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_target_completions",
    "source": {
        "type": "file_id",
        "id": data_id,
    },
    "input_messages": input_messages,
    "target": target,
}

agent_eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="agent-target-evaluation",
    data_source=data_source,
)

Ein vollständiges runnables Beispiel finden Sie unter sample_agent_evaluation.py auf GitHub. Zum Abfragen der Beendigung und zum Interpretieren der Ergebnisse lesen Sie den Abschnitt Ergebnisse abrufen.

Protokoll für Aufrufe des gehosteten Agents

Gehostete Agents , die das Aufrufprotokoll verwenden, unterstützen denselben azure_ai_agent Zieltyp, verwenden jedoch ein Freihandformformat input_messages . Stellen Sie anstelle des strukturierten Vorlagenformats ein JSON-Objekt bereit, das dem Anforderungstext des /invocations Agents direkt zugeordnet wird. Verwenden Sie {{item.*}} Platzhalter, um Felder aus Ihren Eingabedaten zu ersetzen.

Wenn ein gehosteter Agent sowohl die Antworten als auch Aufrufprotokolle unterstützt, verwendet der Dienst standardmäßig das Aufrufprotokoll.

Definieren des Nachrichtenformats und des Ziels

input_messages = {"message": "{{item.query}}"}

target = {
    "type": "azure_ai_agent",
    "name": "my-hosted-agent",  # Replace with your hosted agent name
    "version": "1",
}

Auswertung erstellen und ausführen

eval_object = client.evals.create(
    name="Hosted Agent Invocations Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_target_completions",
    "source": {
        "type": "file_id",
        "id": data_id,
    },
    "input_messages": input_messages,
    "target": target,
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="hosted-agent-invocations-evaluation",
    data_source=data_source,
)

Die Einrichtung des Evaluators und die Datenzuordnungen sind identisch mit der Auswertung des Prompt-Agents. Verwenden Sie {{sample.output_text}} für die Textantwort des Agenten und {{sample.output_items}} für die vollständige strukturierte Ausgabe einschließlich Toolaufrufen.

Auswertung der Agentenantwort

Im nächsten Schritt erfolgt das Abrufen und Auswerten der Reaktionen des Foundry-Agents anhand der Reaktions-IDs mithilfe des Datenquellentyps azure_ai_responses. Verwenden Sie dieses Szenario, um bestimmte Agentinteraktionen auszuwerten, nachdem sie aufgetreten sind.

Tipp

Bevor Sie beginnen, schließen Sie "Erste Schritte" ab.

Eine Antwort-ID ist ein eindeutiger Bezeichner, der jedes Mal zurückgegeben wird, wenn ein Foundry-Agent eine Antwort generiert. Sie können Antwort-IDs aus Agentinteraktionen mithilfe der Antwort-API oder aus den Ablaufverfolgungsprotokollen Ihrer Anwendung sammeln. Geben Sie die IDs als Dateiinhalt inline an, oder laden Sie sie als Dataset hoch (siehe Vorbereiten von Eingabedaten).

Sammeln von Antwort-IDs

Jeder Aufruf der Antwort-API gibt ein Antwortobjekt mit einem eindeutigen id Feld zurück. Sammeln Sie diese IDs aus den Interaktionen Ihrer Anwendung, oder generieren Sie sie direkt:

# Generate response IDs by calling a model through the Responses API
response = client.responses.create(
    model=model_deployment_name,
    input="What is machine learning?",
)
print(response.id)  # Example: resp_abc123

Sie können auch Antwortkennungen aus Interaktionen mit Agenten in den Tracing-Protokollen oder der Überwachungspipeline Ihrer Anwendung sammeln. Jede Antwort-ID identifiziert eindeutig eine gespeicherte Antwort, die der Auswertungsdienst abrufen kann.

Auswertung erstellen und ausführen

data_source_config = {"type": "azure_ai_source", "scenario": "responses"}

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
    },
]

eval_object = client.evals.create(
    name="Agent Response Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_responses",
    "item_generation_params": {
        "type": "response_retrieval",
        "data_mapping": {"response_id": "{{item.resp_id}}"},
        "source": {
            "type": "file_content",
            "content": [
                {"item": {"resp_id": "resp_abc123"}},
                {"item": {"resp_id": "resp_def456"}},
            ]
        },
    },
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="agent-response-evaluation",
    data_source=data_source,
)

Ein vollständiges runnables Beispiel finden Sie unter sample_agent_response_evaluation.py auf GitHub. Zum Abfragen der Beendigung und zum Interpretieren der Ergebnisse lesen Sie den Abschnitt Ergebnisse abrufen.

Ablaufverfolgungsauswertung

Bewerten sie Agentinteraktionen, die bereits in Application Insights erfasst wurden. Verwenden Sie den azure_ai_traces Datenquellentyp. Dieses Szenario ist nützlich für die Bewertung des realen Produktionsverkehrs nach der Bereitstellung – Sie wählen Abläufe aus Ihrer Überwachungspipeline aus und wenden Bewertungstools darauf an, ohne Anforderungen erneut abzuspielen.

Wichtig

Die Trace-Bewertung ist der empfohlene Ansatz für die Auswertung von Agenten, die nicht mit dem Microsoft Foundry Agent Service erstellt wurden, einschließlich LangChain und benutzerdefinierter Frameworks. Solange Ihr Agent OpenTelemetry-Spans gemäß den GenAI-Semantikkonventionen an Application Insights sendet, kann die Trace-Bewertung seine Interaktionen mit denselben Evaluatoren analysieren, die für Foundry-Agenten verfügbar sind.

Die Tracerauswertung unterstützt zwei Modi:

  • Durch Ablaufverfolgungs-IDs – Bewerten Sie bestimmte Agentinteraktionen, indem Sie ihre operation_Id Werte aus Application Insights angeben.
  • Nach Agentfilter – Automatisches Ermitteln und Auswerten der letzten Ablaufverfolgungen für einen bestimmten Agent, ohne dass die Ablaufverfolgungs-IDs manuell erfasst werden müssen.

Tipp

Bevor Sie beginnen, schließen Sie "Erste Schritte" ab. Dieses Szenario erfordert auch eine Application Insights-Ressource, die mit Ihrem Foundry-Projekt verbunden ist.

Tracing-Datenanforderungen

Die Tracing-Bewertung erfordert, dass Ihr Agent Spannen gemäß den OpenTelemetry-Semantikkonventionen für generative KI emittiert. Der Auswertungsdienst liest spezifische Bereiche aus Application Insights aus und extrahiert Konversationsdaten aus deren Attributen.

Die folgenden Span-Attribute werden verwendet:

attribute Erforderlich Beschreibung
gen_ai.operation.name Ja Muss gleich sein "invoke_agent". Der Dienst ignoriert alle anderen Spannen.
gen_ai.agent.id Für den Agent-Filtermodus Eindeutiger Agentbezeichner (Format: agent-name:version).
gen_ai.agent.name Für den Agent-Filtermodus Name des Agenten, der für Menschen lesbar ist.
gen_ai.input.messages Abfrageeingaben für Evaluatoren JSON-Array mit Eingabemeldungen nach dem GenAI-Semantikkonventionen-Nachrichtenformat. Nachrichten mit Rolle user oder system Zuordnung zu query; Nachrichten mit Rolle assistant oder tool Zuordnung zu response.
gen_ai.output.messages Abfrageeingaben für Evaluatoren JSON-Array von vom Modell generierten Ausgabemeldungen. Alle Ausgabemeldungen werden response zugeordnet. Wenn die Ausgabe auch den Typ tool_call oder den Typ tool_result enthält, ist sie tool_calls zugeordnet.
gen_ai.tool.definitions Wahlfrei JSON-Array von Toolschemas, die für den Agent verfügbar sind. Wenn nicht vorhanden, versucht der Dienst, Tooldefinitionen aus Toolaufrufnachrichten zu ableiten, aber abgeleitete Schemas sind möglicherweise unvollständig.
gen_ai.conversation.id Wahlfrei Konversationsbezeichner, der an Auswertungsergebnisse zur Korrelation weitergegeben wird.

Hinweis

Wenn gen_ai.input.messages und gen_ai.output.messages leer oder nicht vorhanden sind, werden die Qualitätsbewertungen (Kohärenz, Flüssigkeit, Relevanz, Absichtsauflösung) score=None zurückgeben. Sicherheitsbewertungen (Gewalt, Selbstverletzung, Sexueller Hass/Unfairität) können weiterhin Bewertungen mit Teildaten erzeugen, aber sie können keine sinnvollen Ergebnisse erzielen.

Fügen Sie für Python Agents, die mit dem AZURE AI Agent Server SDK erstellt wurden, das zusätzliche [tracing] hinzu, um die automatische Span-Emission zu ermöglichen:

pip install "azure-ai-agentserver-core[tracing]"

Voraussetzungen für die Ablaufverfolgungsauswertung

Zusätzlich zu den allgemeinen Voraussetzungen erfordert die Tracer-Auswertung Folgendes:

  • Eine Application Insights-Ressource , die mit Ihrem Foundry-Projekt verbunden ist. Siehe Tracing in Microsoft Foundry einrichten.
  • Die verwaltete Identität des Projekts muss sowohl in der Ressource "Application Insights" als auch im verknüpften Log Analytics-Arbeitsbereich über die Rolle Log Analytics Reader verfügen.
  • Das Paket azure-monitor-query Python (nur erforderlich, wenn Sie Trace-IDs manuell erfassen).
pip install "azure-ai-projects>=2.0.0" azure-monitor-query

Legen Sie diese Umgebungsvariablen fest:

  • APPINSIGHTS_RESOURCE_ID – Die Application Insights-Ressourcen-ID (z. B. /subscriptions/<subscription_id>/resourceGroups/<rg_name>/providers/Microsoft.Insights/components/<resource_name>).
  • AGENT_ID — Die Agentenkennung, die vom Trace-Integrationsteil (gen_ai.agent.id Attribut) ausgegeben wird und zum Filtern von Traces verwendet wird. Format: agent-name:version.
  • TRACE_LOOKBACK_HOURS — (Optional) Anzahl der Stunden, die beim Abfragen von Ablaufverfolgungen berücksichtigt werden sollen. Wird standardmäßig auf 1 festgelegt.

Option A: Evaluieren durch Agent-Filter

Der einfachste Ansatz – ermöglicht es dem Dienst, aktuelle Ablaufverfolgungen für einen bestimmten Agent automatisch zu ermitteln und auszuwerten. Es ist keine manuelle Nachverfolgungs-ID-Erfassung erforderlich.

import os

agent_id = os.environ["AGENT_ID"]  # e.g., "my-weather-agent:1"
trace_lookback_hours = int(os.environ.get("TRACE_LOOKBACK_HOURS", "1"))

# Create the evaluation
data_source_config = {
    "type": "azure_ai_source",
    "scenario": "traces",
}

eval_object = client.evals.create(
    name="Agent Trace Evaluation (by agent)",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,  # See "Set up evaluators" below
)

# Create a run — the service queries App Insights for matching traces
data_source = {
    "type": "azure_ai_traces",
    "agent_id": agent_id,
    "max_traces": 50,           # Maximum number of traces to evaluate
    "lookback_hours": trace_lookback_hours,
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="agent-trace-eval-run",
    data_source=data_source,
)

print(f"Evaluation run started: {eval_run.id}")

Der Dienst filtert invoke_agent Spannen nach dem gen_ai.agent.id Attribut, erfasst bis zu max_traces eindeutige Trace-IDs und wertet alle Spannen dieser Traces aus.

Option B: Auswerten nach Trace-IDs

Für mehr Kontrolle sammeln Sie bestimmte Trace-IDs aus Application Insights und bewerten Sie diese. Dies ist nützlich, wenn Sie ausgewählte Interaktionen auswerten möchten (z. B. von Warnungen gekennzeichnete Spuren oder stichprobenartig zur Qualitätsprüfung ausgewählte).

Sammeln von Trace-IDs aus Application Insights

Fragen Sie Application Insights für operation_Id Werte aus den Ablaufverfolgungen Ihres Agenten ab. Jede operation_Id stellt eine vollständige Agentinteraktion dar:

import os
from datetime import datetime, timedelta, timezone
from azure.identity import DefaultAzureCredential
from azure.monitor.query import LogsQueryClient, LogsQueryStatus

appinsights_resource_id = os.environ["APPINSIGHTS_RESOURCE_ID"]
agent_id = os.environ["AGENT_ID"]
trace_query_hours = int(os.environ.get("TRACE_LOOKBACK_HOURS", "1"))

end_time = datetime.now(timezone.utc)
start_time = end_time - timedelta(hours=trace_query_hours)

query = f"""dependencies
| where timestamp between (datetime({start_time.isoformat()}) .. datetime({end_time.isoformat()}))
| extend agent_id = tostring(customDimensions["gen_ai.agent.id"])
| where agent_id == "{agent_id}"
| distinct operation_Id"""

credential = DefaultAzureCredential()
logs_client = LogsQueryClient(credential)
response = logs_client.query_resource(
    appinsights_resource_id,
    query=query,
    timespan=None,  # Time range is specified in the query itself
)

trace_ids = []
if response.status == LogsQueryStatus.SUCCESS:
    for table in response.tables:
        for row in table.rows:
            trace_ids.append(row[0])

print(f"Found {len(trace_ids)} trace IDs")

Erstellen Sie eine Auswertung und führen Sie diese mit Ablaufverfolgungs-IDs aus.

# Create the evaluation
data_source_config = {
    "type": "azure_ai_source",
    "scenario": "traces",
}

eval_object = client.evals.create(
    name="Agent Trace Evaluation (by trace IDs)",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,  # See "Set up evaluators" below
)

# Create a run using the collected trace IDs
data_source = {
    "type": "azure_ai_traces",
    "trace_ids": trace_ids,
    "lookback_hours": trace_query_hours,
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="agent-trace-eval-run",
    metadata={
        "agent_id": agent_id,
        "start_time": start_time.isoformat(),
        "end_time": end_time.isoformat(),
    },
    data_source=data_source,
)

print(f"Evaluation run started: {eval_run.id}")

Einrichten von Evaluatoren und Daten-Mappings

Beim Auswerten von Traces extrahiert der Dienst automatisch Konversationsdaten aus den OpenTelemetry-Span-Attributen. ** Verwenden Sie diese Feldnamen direkt in data_mapping (ohne die in anderen Szenarien verwendeten Präfixe item. oder sample.).

Variable Quell-Attribut Beschreibung
{{item.query}} gen_ai.input.messages (Benutzer-/Systemrollen) Die aus der Protokollspur extrahierte Benutzeranfrage.
{{item.response}} gen_ai.input.messages (Assistenten-/Toolrollen) + gen_ai.output.messages Die Antwort des Agenten, die aus der Ablaufverfolgung extrahiert wurde.
{{item.tool_definitions}} gen_ai.tool.definitions Toolschemas, die für den Agent verfügbar sind. Nur für toolbezogene Evaluatoren erforderlich
{{item.tool_calls}} Extrahiert aus Assistentennachrichten in gen_ai.input.messages / gen_ai.output.messages Toolaufrufe des Agents während der Interaktion. Wird von Toolvaluatoren verwendet. Nur für toolbezogene Evaluatoren erforderlich 
testing_criteria = [
    # Quality evaluators — require query and response from trace data
    {
        "type": "azure_ai_evaluator",
        "name": "intent_resolution",
        "evaluator_name": "builtin.intent_resolution",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
            "tool_definitions": "{{item.tool_definitions}}",
        },
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
    },
    # Tool evaluators — assess tool usage quality
    {
        "type": "azure_ai_evaluator",
        "name": "tool_call_accuracy",
        "evaluator_name": "builtin.tool_call_accuracy",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
            "tool_calls": "{{item.tool_calls}}",
            "tool_definitions": "{{item.tool_definitions}}",
        },
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
    },
    # Safety evaluators — work even with partial trace data
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
        "initialization_parameters": {
            "threshold": 4,
        },
    },
]

Ein vollständiges ausführbares Beispiel finden Sie auf GitHub unter sample_evaluations_builtin_with_traces.py. Zum Abfragen der Beendigung und zum Interpretieren der Ergebnisse lesen Sie den Abschnitt Ergebnisse abrufen.

Auswertung synthetischer Daten (Vorschau)

Generieren Sie synthetische Testabfragen, senden Sie sie an ein bereitgestelltes Modell oder einen Foundry-Agent, und bewerten Sie die Antworten mithilfe des azure_ai_synthetic_data_gen_preview Datenquellentyps. Verwenden Sie dieses Szenario, wenn Sie nicht über ein Testdatenset verfügen . Der Dienst generiert Abfragen basierend auf einer von Ihnen bereitgestellten Aufforderung (und/oder aus den Anweisungen des Agents), führt diese anhand Ihres Ziels aus und wertet die Antworten aus.

Tipp

Bevor Sie beginnen, schließen Sie "Erste Schritte" ab.

Funktionsweise der synthetischen Datenauswertung

  1. Der Dienst generiert synthetische Abfragen basierend auf Ihrem prompt und optionalen Startdatendateien.
  2. Jede Abfrage wird an das angegebene Ziel (Modell oder Agent) gesendet, um eine Antwort zu generieren.
  3. Evaluatoren bewerten jede Antwort mithilfe der generierten Abfrage und Antwort.
  4. Die generierten Abfragen werden als Dataset in Ihrem Projekt zur Wiederverwendung gespeichert.

Parameter

Parameter Erforderlich Beschreibung
samples_count Ja Maximale Anzahl synthetischer Testabfragen, die generiert werden sollen.
model_deployment_name Ja Einsatz des Modells zur Generierung synthetischer Abfragen. Es werden nur Modelle mit der Antwort-API-Funktion unterstützt. Verfügbarkeit finden Sie unter Antwort-API Regionsverfügbarkeit.
prompt Nein Anweisungen zur Beschreibung des Typs der zu generierenden Abfragen. Optional, wenn das Agentziel Anweisungen konfiguriert hat.
output_dataset_name Nein Name für das Ausgabe-Dataset, in dem generierte Abfragen gespeichert werden. Wenn nicht angegeben, generiert der Dienst automatisch einen Namen.
sources Nein Seed-Datendateien (nach Datei-ID), um die Relevanz generierter Abfragen zu verbessern. Derzeit wird nur eine Datei unterstützt.

Einrichten von Evaluatoren und Daten-Mappings

Der Generator für synthetische Daten erzeugt Abfragen im {{item.query}} Feld. Das Zielobjekt generiert Antworten, die in {{sample.output_text}} verfügbar sind. Ordnen Sie diese Felder Ihren Evaluatoren zu:

data_source_config = {"type": "azure_ai_source", "scenario": "synthetic_data_gen_preview"}

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
]

Auswertung erstellen und ausführen

Modellziel

Generieren von synthetischen Abfragen und Auswerten eines Modells:

eval_object = client.evals.create(
    name="Synthetic Data Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_synthetic_data_gen_preview",
    "item_generation_params": {
        "type": "synthetic_data_gen_preview",
        "samples_count": 5,
        "prompt": "Generate customer service questions about returning defective products",
        "model_deployment_name": model_deployment_name,
        "output_dataset_name": "my-synthetic-dataset",
    },
    "target": {
        "type": "azure_ai_model",
        "model": model_deployment_name,
    },
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="synthetic-data-evaluation",
    data_source=data_source,
)

Optional können Sie eine Systemaufforderung hinzufügen, um das Verhalten des Zielmodells zu gestalten. Wenn Sie input_messages mit der synthetischen Datengenerierung verwenden, schließen Sie nur system Rollenmeldungen ein – der Dienst stellt die generierten Abfragen automatisch als Benutzernachrichten bereit.

data_source = {
    "type": "azure_ai_synthetic_data_gen_preview",
    "item_generation_params": {
        "type": "synthetic_data_gen_preview",
        "samples_count": 5,
        "prompt": "Generate customer service questions about returning defective products",
        "model_deployment_name": model_deployment_name,
    },
    "target": {
        "type": "azure_ai_model",
        "model": model_deployment_name,
    },
    "input_messages": {
        "type": "template",
        "template": [
            {
                "type": "message",
                "role": "system",
                "content": {
                    "type": "input_text",
                    "text": "You are a helpful customer service agent. Be empathetic and solution-oriented."
                }
            }
        ]
    },
}

Agentenziel

Generieren Sie synthetische Abfragen, und bewerten Sie einen Foundry-Agent:

data_source = {
    "type": "azure_ai_synthetic_data_gen_preview",
    "item_generation_params": {
        "type": "synthetic_data_gen_preview",
        "samples_count": 5,
        "prompt": "Generate questions about returning defective products",
        "model_deployment_name": model_deployment_name,
    },
    "target": {
        "type": "azure_ai_agent",
        "name": agent_name,
        "version": agent_version,
    },
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="synthetic-agent-evaluation",
    data_source=data_source,
)

Zum Abfragen der Beendigung und zum Interpretieren der Ergebnisse lesen Sie den Abschnitt Ergebnisse abrufen. Die Antwort enthält eine output_dataset_id Eigenschaft, die die ID des generierten Datasets enthält, mit der Sie die synthetischen Daten abrufen oder wiederverwenden können.

Ergebnisse abrufen

Rufen Sie nach Abschluss einer Auswertung die bewerteten Ergebnisse ab, und überprüfen Sie sie im Portal oder programmgesteuert.

Poll für Ergebnisse durchführen

Auswertungsläufe sind asynchron. Rufen Sie den Ausführungsstatus auf, bis er abgeschlossen ist, und rufen Sie dann die Ergebnisse ab:

import time
from pprint import pprint

while True:
    run = client.evals.runs.retrieve(
        run_id=eval_run.id, eval_id=eval_object.id
    )
    if run.status in ("completed", "failed"):
        break
    time.sleep(5)
    print("Waiting for eval run to complete...")

# Retrieve results
output_items = list(
    client.evals.runs.output_items.list(
        run_id=run.id, eval_id=eval_object.id
    )
)
pprint(output_items)
print(f"Report URL: {run.report_url}")

Interpretieren von Ergebnissen

Für ein einzelnes Datenbeispiel geben alle Bewerter das folgende Schema aus:

  • Beschriftung: eine binäre "Pass"- oder "fail"-Bezeichnung, ähnlich der Ausgabe eines Komponententests. Verwenden Sie dieses Ergebnis, um Vergleiche über Evaluatoren hinweg zu vereinfachen.
  • Bewertung: eine Bewertung aus der natürlichen Skala der einzelnen Evaluatoren. Einige Bewerter verwenden eine feinkörnige Rubrik, eine Bewertung auf einer 5-Punkt-Skala (Qualitätsbewertungen) oder eine 7-Punkt-Skala (Inhaltssicherheits-Evaluatoren). Andere, wie textbezogene Ähnlichkeitsbewertungen, verwenden F1-Bewertungen, die zwischen 0 und 1 schweben. Jeder nicht binäre „score“ wird basierend auf dem „threshold“ (Schwellenwert) im Feld „Label“ in einen der binären Werte „pass“ (bestanden) oder „fail“ (nicht bestanden) umgewandelt.
  • Schwellenwert: Alle nicht binären Bewertungen werden basierend auf einem Standardschwellenwert, den die Benutzenden in der SDK-Oberfläche überschreiben können, in „pass“ (bestanden) oder „fail“ (nicht bestanden) umgewandelt.
  • Grund: Um die Verständlichkeit zu verbessern, geben alle LLM-Richter-Evaluatoren auch ein Begründungsfeld aus, um zu erläutern, warum eine bestimmte Bewertung angegeben wird.
  • Details: (optional) Bei einigen Bewertern, z. B. tool_call_accuracy, gibt es möglicherweise ein "Details"-Feld oder Flags, das zusätzliche Informationen enthält, um Benutzern beim Debuggen ihrer Anwendungen zu helfen.

Beispielausgabe (einzelnes Element)

{
  "type": "azure_ai_evaluator",
  "name": "Coherence",
  "metric": "coherence",
  "score": 4.0,
  "label": "pass",
  "reason": "The response is well-structured and logically organized, presenting information in a clear and coherent manner.",
  "threshold": 3,
  "passed": true
}

Beispielausgabe (Aggregatdaten)

Bei über mehrere Datenbeispiele (ein Dataset) aggregierten Ergebnissen bildet die durchschnittliche Rate der Beispiele mit der Bewertung „bestanden“ die Erfolgsquote für dieses Dataset.

{
  "eval_id": "eval_abc123",
  "run_id": "run_xyz789",
  "status": "completed",
  "result_counts": {
    "passed": 85,
    "failed": 15,
    "total": 100
  },
  "per_testing_criteria_results": [
    {
      "name": "coherence",
      "passed": 92,
      "failed": 8,
      "pass_rate": 0.92
    },
    {
      "name": "relevance", 
      "passed": 78,
      "failed": 22,
      "pass_rate": 0.78
    }
  ]
}

Problembehandlung

Auftrag, der lange ausgeführt wird

Ihr Auswertungsauftrag kann für längere Zeit im Status Wird ausgeführt verbleiben. Dies tritt in der Regel auf, wenn die Azure OpenAI-Modellbereitstellung nicht über genügend Kapazität verfügt, wodurch der Dienst Wiederholungsanforderungen ausführt.

Auflösung:

  1. Abbrechen des aktuellen Auswertungsauftrags mithilfe von client.evals.runs.cancel(run_id, eval_id=eval_id).
  2. Erhöhen Sie die Modellkapazität im Azure-Portal.
  3. Führen Sie die Auswertung erneut aus.

Authentifizierungsfehler

Wenn Sie einen 401 Unauthorized- oder 403 Forbidden-Fehler erhalten, überprüfen Sie Folgendes:

  • Ihre DefaultAzureCredential ist korrekt konfiguriert (führen Sie az login aus, wenn Sie Azure CLI verwenden).
  • Ihr Konto verfügt über die Rolle " Foundry User " im Foundry-Projekt.
  • Die URL des Projektendpunkts ist korrekt und enthält sowohl die Konto- als auch die Projektnamen.

Datenformatfehler

Wenn die Auswertung mit einem Schema- oder Datenzuordnungsfehler fehlschlägt:

  • Überprüfen Sie, ob die JSONL-Datei ein gültiges JSON-Objekt pro Zeile aufweist.
  • Überprüfen Sie, ob die Feldnamen in data_mapping genau mit den Feldnamen in Ihrer JSONL-Datei übereinstimmen (Groß-/Kleinschreibung wird beachtet).
  • Überprüfen Sie, ob item_schema die Eigenschaften den Feldern in Ihrem Dataset entsprechen.

Fehler beim Rategrenzwert

Die Erstellung von Auswertungsausführungen ist auf Mandanten-, Abonnement- und Projektebenen eingeschränkt. Wenn Sie eine 429 Too Many Requests Antwort erhalten:

  • Überprüfen Sie den retry-after Header in der Antwort auf die empfohlene Wartezeit.
  • Überprüfen Sie den Antworttext auf Details zum Zinsgrenzwert.
  • Verwenden Sie exponentielles Backoff, wenn Sie fehlgeschlagene Anforderungen wiederholen.

Wenn ein Auswertungsauftrag während der Ausführung mit einem 429 Fehler fehlschlägt:

  • Verringern Sie die Größe Ihres Auswertungsdatensatzes, oder teilen Sie es in kleinere Batches auf.
  • Erhöhen Sie das Token-Kontingent pro Minute (TPM) für Ihre Modellbereitstellung im Azure-Portal.

Fehler des Agentenbewertungstools

Wenn ein Agent-Evaluator einen Fehler für nicht unterstützte Tools zurückgibt:

  • Überprüfen Sie die unterstützten Tools für Agent-Auswertungen.
  • Umschließen Sie als Problemumgehung nicht unterstützte Tools als benutzerdefinierte Funktionstools, damit der Evaluator sie bewerten kann.

Verwandte Inhalte

  • Last updated on