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 Supplementale 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 im großen Maßstab, beim Integrieren von Auswertungen in kontinuierliche Integrations- und Bereitstellungspipelines (CI/CD) oder beim Durchführen von Vorabbereitstellungstests. 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 Microsoft kuratierten built-in-Evaluatoren und Ihre eigenen custom evaluators. Evaluatoren werden im Evaluator-Katalog mit der gleichen projektbezogenen, rollenbasierten Zugriffssteuerung verwaltet.

Tipp

Vollständige ausführbare 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 vorab berechneter Antworten in einer JSONL-Datei. jsonl —
CSV-Datasetauswertung Bewerten Sie vorab berechnete Antworten in einer CSV-Datei. csv —
Modellzielauswertung Generieren Sie während der Laufzeit Abfragen und Antworten aus einem Modell für die Auswertung. azure_ai_target_completions azure_ai_model
Agent-Zielbewertung 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-Evaluierung Bewerten Sie die bereits in Application Insights erfassten Agentinteraktionen unter Verwendung 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 die Daten direkt in der Anfrage 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. Stellen Sie auf ein, wenn Sie eine Zielvorgabe verwenden, damit Bewertende auf generierte Antworten verweisen können.
  • azure_ai_source — Das Schema wird vom Dienst abgeleitet. Legen Sie "scenario" auf "responses" für die Agentenantwortauswertung, "traces" für die Trace-Auswertung, "synthetic_data_gen_preview" für die Auswertung synthetischer Daten (Vorschau) oder "red_team" für das Red Teaming.

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

Voraussetzungen

  • Ein Foundry-Projekt.
  • Eine Azure OpenAI-Bereitstellung mit einem GPT-Modell, das den Chatabschluss unterstützt (z. B. gpt-5-mini).
  • Azure AI User Rolle im Foundry-Projekt.
  • 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 Versionsverwaltung und Wiederverwendung in mehreren Auswertungsläufen. 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 Szenarioabschnitte verwenden file_id standardmäßig.

Datensatzauswertung

Bewerten Sie vorab berechnete 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 Auswertungen

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 der {{item.field}} Syntax an Evaluatorparameter 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 – z. B.: Wenn Ihre Daten "question" anstelle von "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}}",
        },
    },
]

Erstellung und Ausführung der Auswertung

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 ausführbares Beispiel finden Sie auf GitHub unter sample_evaluations_builtin_with_dataset_id.py. Zum Abfragen der Beendigung und zum Interpretieren der Ergebnisse lesen Sie den Abschnitt Ergebnisse abrufen.

CSV-Datasetauswertung

Bewerten Sie vorab berechnete Antworten in einer CSV-Datei mithilfe des Datenquellentyps csv. 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 Tabellenkalkulationsprogramm- 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.

Auswertung des Modellziels

Senden Sie Abfragen an ein bereitgestelltes Modell während der Laufzeitausführung, und evaluieren Sie die Antworten mithilfe des azure_ai_target_completions Datenquellentyps 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.

Nachrichtenvorlage und Ziel definieren

Die input_messages Vorlage steuert, wie Abfragen an das Modell gesendet werden. Verwenden Sie {{item.query}} zum Verweisen auf Felder aus Ihren Eingabedaten. 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 Bewertungswerkzeugen und Datenzuordnungen

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}}",
        },
    },
]

Erstellung und Ausführung der Auswertung

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 ausführungsfähiges Beispiel finden Sie unter sample_model_evaluation.py für 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 .

Nachrichtenvorlage und Ziel definieren

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 Bewertungswerkzeugen und Datenzuordnungen

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

Variable Beschreibung Zweck
{{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 Agentenbewertungen 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}}",
        },
    },
]

Erstellung und Ausführung der Auswertung

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 ausführungsfähiges Beispiel finden Sie unter sample_agent_evaluation.py für 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",
}

Erstellung und Ausführung der Auswertung

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,
)

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

Auswertung der Agentenantworten

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 Antwort-IDs aus den Interaktionen mit Agenten in den Protokollen zur Ablaufverfolgung oder in der Überwachungs-Pipeline Ihrer Anwendung sammeln. Jede Antwort-ID identifiziert eindeutig eine gespeicherte Antwort, die der Auswertungsdienst abrufen kann.

Erstellung und Ausführung der Auswertung

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 ausführungsfähiges Beispiel finden Sie unter sample_agent_response_evaluation.py für 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 eignet sich für die Auswertung des echten Produktionsdatenverkehrs nach der Bereitstellung. Sie wählen Traces aus Ihrer Überwachungspipeline aus und führen Auswertungsmodule für diese Traces aus, ohne die Anfragen erneut auszuführen.

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 Ablaufverfolgungsauswertung seine Interaktionen mit denselben Auswertern bewerten, die für Foundry-Agenten verfügbar sind

Die Ablaufverfolgungsauswertung unterstützt zwei Modi:

  • Nach Trace-IDs — Bewerten Sie spezifische Agenteninteraktionen, indem Sie deren operation_Id Werte aus Application Insights angeben.
  • Nach Agent-Filter — Ermitteln und bewerten Sie automatisch aktuelle Ablaufverfolgungen für einen bestimmten Agenten, ohne Ablaufverfolgungs-IDs manuell zu sammeln

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.

Ablaufverfolgungsdatenanforderungen

Die Ablaufverfolgungsauswertung erfordert, dass Ihr Agent Spans gemäß den OpenTelemetry-Semantikkonventionen für generative KI emittiert. Dabei liest der Auswertungsdienst invoke_agentspans aus Application Insights und extrahiert Konversationsdaten aus deren Attributen.

Die folgenden Span-Attribute werden verwendet:

Attribut 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 von 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 Für Abfragen von Auswertungsmodulen 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, mappt sie auf tool_calls
gen_ai.tool.definitions Optional 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 Optional Konversationsbezeichner, der für die Korrelation mit Auswertungsergebnissen übergeben 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ür Python-Agenten, die mit dem Azure AI Agent Server SDK erstellt wurden, fügen Sie das [tracing] Extra hinzu, um die automatische Spann-Emission zu aktivieren:

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

Voraussetzungen für die Trace-Evaluierung

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

  • Eine Application Insights-Ressource , die mit Ihrem Foundry-Projekt verbunden ist. Siehe Einrichten von Tracing in Microsoft Foundry.
  • 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 — Der vom Tracing-Agent emittierte Bezeichner (gen_ai.agent.id Attribut), der zum Filtern von Traces verwendet wird Format: agent-name:version.
  • TRACE_LOOKBACK_HOURS — (Optional) Anzahl der Stunden für die Rückverfolgung bei Abfrage von Spuren. Standardmäßig gilt 1.

Option A: Evaluierung nach Agentfilter

Der einfachste Ansatz — die Dienste neuere Spuren für einen bestimmten Agenten automatisch erkennen und auswerten lassen. 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 Spans nach dem gen_ai.agent.id Attribut, stichprobenartig bis zu max_traces eindeutige Trace-IDs und wertet alle Spans aus diesen Traces aus

Option B: Auswerten nach Ablaufverfolgungs-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

Application Insights für operation_Id Werte aus den Traces Ihres Agents abfragen. 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 sie mit Trace-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 Bewertungswerkzeugen und Datenzuordnungen

Bei der Trace-Evaluierung extrahiert der Dienst automatisch Kommunikationsdaten 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 Abfrage des Benutzers wird aus dem Tracing extrahiert.
{{item.response}} gen_ai.input.messages (Assistenten-/Toolrollen) + gen_ai.output.messages Die Antwort des Agenten, extrahiert aus der Ablaufverfolgung.
{{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 Bewertende 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 Bereitstellung des Modells zum Generieren synthetischer Abfragen. Es werden nur Modelle mit der Antwort-API-Funktion unterstützt. Verfügbarkeit finden Sie unter Verfügbarkeit der Response-API in verschiedenen Regionen.
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 Bewertungswerkzeugen und Datenzuordnungen

Der Generator für synthetische Daten erzeugt Abfragen im {{item.query}} Feld. Das Ziel 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}}",
        },
    },
]

Erstellung und Ausführung der Auswertung

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 synthetischer 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."
                }
            }
        ]
    },
}

Ziel des Agenten

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.

Umfrage durchführen, um Ergebnisse zu erhalten

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 der Benutzer in der SDK-Erfahrung außer Kraft setzen kann, auf "Bestanden" oder "Nicht bestanden" binarisiert.
  • 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 (Aggregat)

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

Job, der lange läuft

Ihr Auswertungsauftrag verbleibt möglicherweise für einen längeren Zeitraum im Status Läuft. Dies tritt in der Regel auf, wenn die Azure OpenAI-Modellbereitstellung nicht über genügend Kapazität verfügt, was dazu führt, dass der Dienst Anforderungen erneut versucht.

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 bitte Folgendes:

  • Ihr DefaultAzureCredential ist ordnungsgemäß konfiguriert (führen Sie az login aus, wenn Sie Azure CLI verwenden).
  • Ihr Konto verfügt über die Rolle Azure AI 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 bei der Ratenbegrenzung

Für die Erstellung von Auswertungsausführungen gelten auf Mandanten-, Abonnement- und Projektebene Ratenlimits. 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 die Token-pro-Minute-Quote (TPM) für die Modellbereitstellung im Azure-Portal.

Fehler des Agent-Evaluator-Tools

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