Bewertung der leistung generativer ki in azure ai foundry: ein leitfaden für praktiker

Ich beginne mit der Erstellung einer neuen Python-Datei, oft mit einem Namen wie evaluate_genai.py. Hier importiere ich die notwendigen Module und konfiguriere den Client, um eine Verbindung zu meinem Azure AI Project herzustellen. Denken Sie daran, die Platzhalterwerte unten durch Ihre tatsächlichen Projektdetails zu ersetzen; ich speichere diese normalerweise in Umgebungsvariablen für bessere Sicherheit und Flexibilität.

import os
from azure.identity import DefaultAzureCredential
from azure.ai.project import AIProjectClient

# --- Konfiguration --- #
# Ersetzen Sie dies durch Ihre Azure AI Project-Details. Ich finde den Endpunkt normalerweise
# im Azure AI Studio-Portal unter den Projekteinstellungen.
AZURE_AI_PROJECT_ENDPOINT = os.environ.get("AZURE_AI_PROJECT_ENDPOINT", "your_project_endpoint")
# Der Name Ihres bereitgestellten Modells, das ich bewerten möchte.
EVALUATION_TARGET_DEPLOYMENT = os.environ.get("EVALUATION_TARGET_DEPLOYMENT", "your_model_deployment_name")

# DefaultAzureCredential für die Authentifizierung initialisieren
credential = DefaultAzureCredential()
print("Azure credential initialized.")

# AIProjectClient initialisieren
project_client = AIProjectClient(endpoint=AZURE_AI_PROJECT_ENDPOINT, credential=credential)
print("AIProjectClient initialized.")

# Basisordner für Ausgaben
OUTPUT_FOLDER = "./eval_outputs"
os.makedirs(OUTPUT_FOLDER, exist_ok=True)
print(f"Output folder '{OUTPUT_FOLDER}' ensured.")

Dieser Codeausschnitt importiert die erforderlichen Klassen für die Projektinteraktion und Authentifizierung. Er konfiguriert den Endpunkt für mein AI-Projekt und initialisiert AIProjectClient, der mein Haupteinstiegspunkt für die Verwaltung von Projektressourcen ist. Ich richte auch ein Ausgabeverzeichnis ein, um Ergebnisse zu speichern.

Um eine RAG-Anwendung effektiv zu bewerten, benötige ich einen Datensatz, der Prompts und den Kontext umfasst, anhand dessen die Antwort des Modells beurteilt wird. Entscheidend ist, dass die Vervollständigung des Modells nicht Teil dieser Eingabedaten ist; sie wird während der Bewertungsausführung selbst generiert.

# Dies ist ein Beispieldatensatz, den ich für die Bewertung verwenden könnte,
# der eine Frage-Antwort-Sitzung über Finanzdokumente nachbildet.
# Die 'item'-Struktur ist vom Bewertungsframework erforderlich.
data_for_evaluation = {
    "type": "file_content",
    "content": [
        {
            "item": {
                "prompt_text": "Was ist die größte finanzielle Herausforderung für NVIDIA im Jahr 2026?",
                "context_text": "Am 15. März 2026 meldete NVIDIA starke Q4 2025-Ergebnisse, hob aber potenzielle Herausforderungen im kommenden Geschäftsjahr hervor, da die Konkurrenz von Intel und AMD auf dem Markt für KI-Beschleuniger intensiver wird. Supply-Chain-Analysten stellten auch anhaltende Komplexitäten bei der Sicherstellung fortschrittlicher Fertigungskapazitäten für NVIDIAs nächste Generation von H200- und Blackwell-GPUs fest, was das Umsatzwachstum beeinträchtigen könnte."
            }
        },
        {
            "item": {
                "prompt_text": "Erklären Sie die Auswirkungen der jüngsten Zinserhöhung der EZB auf die Anleihenmärkte.",
                "context_text": "Am 2. April 2026 kündigte die Europäische Zentralbank (EZB) eine Erhöhung ihrer Leitzinsen um 25 Basispunkte an und verwies auf anhaltende Inflationsbedenken. Nach dieser Ankündigung berichteten Analysten von Bloomberg über einen starken Anstieg der Renditen 10-jähriger deutscher Bundesanleihen, was auf eine breite Neubewertung der Staatsverschuldung in der Eurozone aufgrund höherer Finanzierungskosten für Regierungen und einer verringerten Attraktivität bestehender Anleihen mit geringerer Rendite hindeutet."
            }
        }
    ]
}

print(f"Prepared {len(data_for_evaluation['content'])} data points for evaluation.")

Dieses Dictionary definiert meine Bewertungsdatenquelle. Jedes item enthält den prompt_text (die Benutzeranfrage) und den context_text (die abgerufenen Informationen). Das von mir bewertete Modell generiert eine Antwort basierend auf diesen Eingaben, die die Evaluatoren dann bewerten.

Im Azure AI Project SDK definiere ich meine Evaluatoren als Teil der testing_criteria. Ich gebe den Namen der integrierten Metrik (wie builtin.groundedness) an und ordne dann die Datenfelder aus meinem Datensatz den für diesen Evaluator erforderlichen Eingaben zu.

# Ich definiere hier die Evaluatoren. Diese nutzen grundlegende GPT-Modelle,
# die in meinem Azure AI Project bereitgestellt werden. Das 'data_mapping' verbindet
# meine Dataset-Spalten mit den erwarteten Eingaben des Evaluators.
testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "groundedness_eval",
        "evaluator_name": "builtin.groundedness",
        "data_mapping": {
            "question": "{{item.prompt_text}}",
            "context": "{{item.context_text}}",
            "answer": "{{target.response}}" # 'target.response' ist die vom Modell generierte Antwort
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "relevance_eval",
        "evaluator_name": "builtin.relevance",
        "data_mapping": {
            "question": "{{item.prompt_text}}",
            "answer": "{{target.response}}"
        },
    }
]

print(f"Configured {len(testing_criteria)} AI-assisted evaluators.")

Hier richte ich eine Liste von Dictionaries ein, die jeweils einen Evaluator konfigurieren. evaluator_name spezifiziert die Metrik, und data_mapping verwendet eine Template-Syntax, um Eingaben zu verbinden. {{item.prompt_text}} und {{item.context_text}} beziehen sich auf Felder in meinem Datensatz, während {{target.response}} ein spezieller Platzhalter für die vom zu bewertenden Modell generierte Vervollständigung ist. Ich beziehe mich oft auf die Azure-Dokumentation zu Bewertungsmetriken für die genauen Zuordnungen.

Nachdem meine Daten und Evaluatoren definiert sind, besteht der nächste Schritt darin, ein Bewertungsobjekt zu erstellen und dann einen Lauf auszulösen. Dies ist ein asynchroner Prozess, der von Azure AI verwaltet wird. Ich starte dies typischerweise und überwache dann den Fortschritt im Portal.

# Ich hole den OpenAI-Client vom Projektclient, um mit Bewertungen zu interagieren.
openai_client = project_client.get_openai_client()

print("Creating evaluation object...")
eval_object = openai_client.evals.create(
    name="Financial QA Evaluation",
    testing_criteria=testing_criteria, # type: ignore
)
print(f"Evaluation object created (id: {eval_object.id}).")

# Ich definiere die Datenquelle und das Zielmodell, das bewertet werden soll.
data_source = {
    "type": "azure_ai_target_completions",
    "source": data_for_evaluation,
    "input_messages": {
        "type": "template",
        "template": [
            {
                "type": "message",
                "role": "user",
                "content": [
                    {"type": "input_text", "text": "Context: {{item.context_text}}\n\nQuestion: {{item.prompt_text}}"}
                ]
            }
        ],
    },
    "target": {
        "type": "azure_ai_model_deployment",
        "name": EVALUATION_TARGET_DEPLOYMENT
    },
}

print("Starting evaluation run...")
# Hinweis: Dieser Vorgang verursacht Kosten basierend auf der Token-Nutzung der zugrunde liegenden LLMs.
# Anfang 2026 könnten repräsentative Kosten etwa
# 0,01 € pro 1.000 Eingabe-Tokens und 0,03 € pro 1.000 Ausgabe-Tokens betragen. (Umrechnung von 1 $ \u2248 0,92 €)

eval_run = openai_client.evals.runs.create(
    eval_id=eval_object.id,
    name="financial_qa_eval_202604",
    data_source=data_source # type: ignore
)

print(f"Evaluation run created and is in progress (id: {eval_run.id}).")
print("Monitor the run status and view results in the Azure AI Foundry portal.")

Die Funktion evals.create registriert meine Bewertungsdefinition, und evals.runs.create startet den eigentlichen Lauf. Sie verwendet die eval_id aus dem vorherigen Schritt, einen menschenlesbaren name für den Lauf (der im Portal angezeigt wird) und ein data_source-Objekt. Dieses Objekt teilt Azure die Eingabedaten mit, wie diese in einen Prompt für das Modell formatiert werden und welches bereitgestellte Modell (target) ich bewerten möchte. Der gesamte Lauf wird im Hintergrund auf Azure ausgeführt.

Sobald der Bewertungslauf im Azure AI Foundry-Portal abgeschlossen ist, kann ich die Ergebnisse als JSONL-Datei für eine detaillierte Analyse herunterladen. Ich navigiere normalerweise zum Abschnitt „Evaluierungen“ in meinem AI-Projekt im Portal, finde meinen Lauf (financial_qa_eval_202604) und lade dann die Datei evaluation_results.jsonl in meinen eval_outputs-Ordner herunter. Von dort aus verwende ich Python, um die Ergebnisse mit pandas zur Datenmanipulation und tabulate zur sauberen Markdown-Formatierung zu analysieren.

import pandas as pd
import json

# Dieser Schritt setzt voraus, dass ich die Ergebnisse aus dem Portal heruntergeladen habe.
results_path = os.path.join(OUTPUT_FOLDER, "evaluation_results.jsonl")

try:
    # Die Ergebnisdatei enthält ein JSON-Objekt pro Zeile.
    with open(results_path, 'r') as f:
        lines = f.readlines()

    # Jede Zeile hat eine komplexe Struktur; ich muss die relevanten Teile extrahieren.
    parsed_results = []
    for line in lines:
        data = json.loads(line)
        # Eingabedaten und Bewertungsmetriken extrahieren.
        # Die genaue Struktur kann variieren; ich inspiziere normalerweise zuerst meine JSONL-Datei.
        result_item = data.get('item', {})
        metrics = data.get('metrics', {})

        parsed_results.append({
            'prompt_text': result_item.get('prompt_text'),
            'completion_text': data.get('response'), # Die generierte Antwort
            'groundedness_score': metrics.get('groundedness_eval.groundedness'),
            'relevance_score': metrics.get('relevance_eval.relevance')
        })

    results_df = pd.DataFrame(parsed_results)

    print("\n--- Detaillierte Pro-Instanz-Ergebnisse (erste 2 Zeilen) ---")
    print(results_df.head(2).to_markdown(index=False))

    # Beispiel: Aggregierte Metriken berechnen und anzeigen.
    print("\n--- Aggregierte Bewertungsergebnisse ---")
    print(f"  Durchschnittliche Groundedness: {results_df['groundedness_score'].mean():.2f}")
    print(f"  Durchschnittliche Relevanz: {results_df['relevance_score'].mean():.2f}")

except FileNotFoundError:
    print(f"\nAnalyse übersprungen: '{results_path}' konnte nicht gefunden werden. Bitte laden Sie es zuerst aus dem Azure AI Foundry-Portal herunter.")

Dieses Skript liest die heruntergeladene JSONL-Datei Zeile für Zeile, analysiert die komplexe JSON-Struktur, um den Eingabeprompt, die vom Modell generierte Vervollständigung und die Bewertungen für jede Metrik zu extrahieren. Ich lade diese Daten dann in ein Pandas DataFrame, was die Analyse und Aggregation vereinfacht.

Obwohl das SDK mir die programmgesteuerte Kontrolle gibt, verlasse ich mich immer noch stark auf das Azure AI Foundry-Portal. Es bietet eine zentralisierte Benutzeroberfläche zur Überwachung meiner Bewertungsläufe, was besonders nützlich für die operative Übersicht ist.

1. Navigieren Sie zu Azure AI Foundry : Melden Sie sich beim Azure AI Studio Portal an.
2. Mein Projekt lokalisieren : Wählen Sie Ihr Azure AI Projekt aus.
3. Bewertungsläufe finden : Navigieren Sie zum Abschnitt „Bewertungen“. Ich sollte eine Liste der Bewertungen und ihrer Läufe sehen, einschließlich financial_qa_eval_202604.
4. Metriken und Details überprüfen : Durch Klicken auf meinen Bewertungslauf werden mir aggregierte Metriken, detaillierte Ergebnisse pro Instanz und Visualisierungen der Leistung angezeigt. Dies ist die primäre Schnittstelle zur Verfolgung von Trends bei Metriken wie Groundedness und Relevanz im Laufe der Zeit.

• Geringstes Privileg : Ich stelle immer sicher, dass jeder Dienstprinzipal oder jede verwaltete Identität, die von meinen Bewertungspipelines verwendet wird, nur die notwendigen Berechtigungen hat, nichts mehr.
• Datenschutz : Die Verschlüsselung von Bewertungsdatensätzen im Ruhezustand und während der Übertragung ist nicht verhandelbar. Ich implementiere auch die Datenanonymisierung für alle sensiblen Daten.
• Verwaltete Identitäten : Für Produktions-Workloads verwende ich ausschließlich Azure Managed Identities zur Authentifizierung bei Azure-Diensten. Dies vereinfacht die Verwaltung von Anmeldeinformationen und erhöht die Sicherheit.

• Stapelverarbeitung : Das Bewertungsframework ist von Natur aus so konzipiert, dass es Datensätze effizient in Stapeln verarbeitet, daher nutze ich dies.
• Evaluator-Auswahl : Obwohl GPT-4 eine überlegene Argumentation bietet, habe ich festgestellt, dass es teurer und langsamer sein kann. Für groß angelegte Bewertungen, bei denen Kosten und Latenz eine Rolle spielen, entscheide ich mich oft für GPT-3.5 Turbo, wenn seine Qualität für die Aufgabe akzeptabel ist.

• Azure Machine Learning Pipelines : Die Integration meiner Bewertungslogik in Azure Machine Learning Pipelines ermöglicht eine automatisierte, skalierbare Ausführung in MLOps-Workflows.
• Regionale Bereitstellung : Für meine europäischen Projekte stelle ich Azure AI-Ressourcen immer in europäischen Regionen wie westeurope oder northeurope bereit, um die Latenz für EU-Benutzer zu minimieren und die Einhaltung der Datenresidenz zu gewährleisten.

• Alarmierung : Das Einrichten von Azure Monitor-Warnungen für wichtige Bewertungsmetriken ist entscheidend. Zum Beispiel könnte ich eine Warnung auslösen, wenn der durchschnittliche Groundedness-Score unter einen vordefinierten Schwellenwert fällt.
• Dashboarding : Ich erstelle benutzerdefinierte Dashboards, entweder in Azure AI Foundry oder Azure Monitor, um Trends in Bewertungsmetriken im Zeitverlauf zu visualisieren. Dies hilft mir, Regressionen schnell zu erkennen.
• Kostenüberwachung : Die kontinuierliche Überwachung der Kosten, die mit meinen LLM-Aufrufen für die Bewertung verbunden sind, ist von entscheidender Bedeutung. Ich lege Budgets und Kostenwarnungen fest, um unerwartete Mehrausgaben zu vermeiden.

• Azure AI Foundry bietet eine robuste Plattform für die programmgesteuerte Bewertung generativer KI-Modelle, die für RAG-Anwendungen entscheidend ist.
• Das azure.ai.project-SDK ermöglicht das Definieren von Bewertungskriterien, das Verbinden von Datensätzen und das Auslösen von Bewertungsläufen direkt aus Python.
• Wichtige Metriken wie Groundedness und Relevanz werden automatisch mithilfe von KI-gestützten Evaluatoren bewertet, die innerhalb des Azure AI Project gehostet werden.
• Die Überwachung der Ergebnisse im Azure AI Foundry-Portal und die Integration der Analyse in CI/CD-Pipelines sind unerlässlich, um die Modellqualität aufrechtzuerhalten.
• Die Kostenüberwachung der LLM-Nutzung während der Bewertungen ist entscheidend, um die Ausgaben zu verwalten, mit typischen Kosten von etwa 0,01 € pro 1.000 Eingabe-Tokens und 0,03 € pro 1.000 Ausgabe-Tokens (unter Verwendung von 1 $ \u2248 0,92 €).