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. Der Durchlauf führt jeden Evaluator für Ihre Daten aus und gibt bewertete Ergebnisse zurück, die Sie hinsichtlich der 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 Antworten von einem Foundry-Agent (Eingabeaufforderung 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 —
Ablaufverfolgungsauswertung 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. 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 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 source als das "source"-Feld in der Datenquellenkonfiguration beim Erstellen eines Laufs. 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. Informationen zum Abrufen von Abschluss- und Interpretationsergebnissen finden Sie unter "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,
        },
    },
)

Um den Abschluss zu prüfen und Ergebnisse zu interpretieren, siehe "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. Informationen zum Abrufen von Abschluss- und Interpretationsergebnissen finden Sie unter "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 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 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. Informationen zum Abrufen von Abschluss- und Interpretationsergebnissen finden Sie unter "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

Abrufen und Auswerten der Antworten des Foundry-Agents anhand von Antwort-IDs mithilfe des azure_ai_responses Datenquellentyps. 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 Interaktionen mit Agenten in den Protokollen für die Ablaufverfolgung oder der Überwachungspipeline 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. Informationen zum Abrufen von Abschluss- und Interpretationsergebnissen finden Sie unter "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äß der GenAI-Semantikkonventionen an Application Insights sendet, kann die Tracing-Auswertung ihre Interaktionen mit denselben Evaluatoren analysieren, die für Foundry-Agenten verfügbar sind.

Die Ablaufverfolgungsauswertung unterstützt zwei Modi:

  • Durch Ablaufverfolgungs-IDs – Bewerten Sie bestimmte Agentinteraktionen, indem Sie ihre operation_Id Werte aus Application Insights angeben.
  • Per Agentenfilter – Automatisches Ermitteln und Auswerten der letzten Ablaufverfolgungen für einen bestimmten Agenten, ohne Trace-IDs manuell zu erfassen.

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

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 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, 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ü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. Weitere Informationen finden Sie unter Set up 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 Agentbezeichner, der von der Ablaufverfolgungsintegration (gen_ai.agent.id Attribut) ausgegeben wird, die zum Filtern von Ablaufverfolgungen verwendet wird. Format: agent-name:version.
  • TRACE_LOOKBACK_HOURS — (Optional) Anzahl der Stunden, die beim Abfragen von Ablaufverfolgungen berücksichtigt werden sollen. Standardmäßig gilt 1.

Option A: Nach Agentfilter auswerten

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-Bereiche nach dem gen_ai.agent.id-Attribut, erfasst bis zu max_traces eindeutige Ablaufverfolgungs-IDs und wertet alle Spans dieser Verfolgungen 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 Ablaufverfolgungen Ihres Agenten 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 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 Bewertungswerkzeugen und Datenzuordnungen

Beim Auswerten von Traces extrahiert der Dienst automatisch Konversationsdaten aus den Attributen der OpenTelemetry-Spans. ** 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 Benutzerabfrage, die aus der Ablaufverfolgung extrahiert wurde.
{{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 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. Informationen zum Abrufen von Abschluss- und Interpretationsergebnissen finden Sie unter "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 Ihren prompt und optionalen Seed-Datendateien.
  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. Die Zielkomponente generiert verfügbare Antworten in {{sample.output_text}}. 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,
)

Informationen zum Abrufen von Abschluss- und Interpretationsergebnissen finden Sie unter "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 ab, 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. Alle nicht binären "Score" werden basierend auf dem "Schwellenwert" in das Feld "Label" in "pass" oder "fail" binarisiert.
  • 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 aggregierten Ergebnissen über mehrere Datenbeispiele (ein Dataset) bildet die durchschnittliche Quote der Beispiele mit einem "Pass" die Bestehensquote 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.
  • Vergewissern Sie sich, dass 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

Die Erstellung von Evaluierungsläufen ist auf Mandanten-, Abonnement- und Projektebene beschrä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 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