Het evalueren van generatieve ai-prestaties in azure ai foundry: een handleiding voor de praktijk

Ik begin met het maken van een nieuw Python-bestand, vaak iets genaamd zoals evaluate_genai.py. Dit is waar ik de benodigde modules binnenhaal en de client configureer om verbinding te maken met mijn Azure AI Project. Vergeet niet de onderstaande tijdelijke aanduidingen te vervangen door uw werkelijke projectdetails; ik sla deze meestal op in omgevingsvariabelen voor betere beveiliging en flexibiliteit.

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

# --- Configuratie --- #
# Vervang dit door uw Azure AI Project-details. Ik vind het eindpunt meestal
# in de Azure AI Studio-portal onder de instellingen van mijn project.
AZURE_AI_PROJECT_ENDPOINT = os.environ.get("AZURE_AI_PROJECT_ENDPOINT", "your_project_endpoint")
# De naam van uw geïmplementeerde model dat ik wil evalueren.
EVALUATION_TARGET_DEPLOYMENT = os.environ.get("EVALUATION_TARGET_DEPLOYMENT", "your_model_deployment_name")

# Initialiseer DefaultAzureCredential voor authenticatie
credential = DefaultAzureCredential()
print("Azure credential initialized.")

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

# Basismap voor outputs
OUTPUT_FOLDER = "./eval_outputs"
os.makedirs(OUTPUT_FOLDER, exist_ok=True)
print(f"Output folder '{OUTPUT_FOLDER}' ensured.")

Dit fragment importeert de vereiste klassen voor projectinteractie en authenticatie. Het configureert het eindpunt voor mijn AI Project en initialiseert AIProjectClient, wat mijn belangrijkste toegangspunt is voor het beheren van projectbronnen. Ik stel ook een uitvoermap in om resultaten op te slaan.

Om een RAG-toepassing effectief te evalueren, heb ik een dataset nodig die bestaat uit prompts en de context waartegen het antwoord van het model zal worden beoordeeld. Cruciaal is dat de voltooiing van het model geen deel uitmaakt van deze invoergegevens; deze wordt gegenereerd tijdens de evaluatie-uitvoering zelf.

# Dit is een voorbeeld dataset die ik zou kunnen gebruiken voor evaluatie,
# die een Q&A-sessie over financiële documenten nabootst.
# De 'item'-structuur is vereist door het evaluatiekader.
data_for_evaluation = {
    "type": "file_content",
    "content": [
        {
            "item": {
                "prompt_text": "Wat is de belangrijkste financiële uitdaging voor NVIDIA in 2026?",
                "context_text": "Op 15 maart 2026 rapporteerde NVIDIA sterke Q4 2025-inkomsten, maar benadrukte potentiële uitdagingen in het komende fiscale jaar als gevolg van intensievere concurrentie van Intel en AMD op de AI-acceleratormarkt. Supply chain-analisten merkten ook aanhoudende complexiteiten op bij het veiligstellen van geavanceerde productiecapaciteiten voor NVIDIA's volgende generatie H200 en Blackwell GPU's, wat de omzetgroei zou kunnen beïnvloeden."
            }
        },
        {
            "item": {
                "prompt_text": "Leg de impact uit van de laatste renteverhoging door de ECB op de obligatiemarkten.",
                "context_text": "Op 2 april 2026 kondigde de Europese Centrale Bank (ECB) een verhoging van 25 basispunten van haar belangrijkste rentetarieven aan, onder verwijzing naar aanhoudende inflatiebezorgdheid. Na deze aankondiging rapporteerden analisten van Bloomberg een scherpe stijging van de 10-jarige Duitse Bund-opbrengsten, wat duidt op een brede herprijsstelling van staatsschuld in de Eurozone als gevolg van hogere financieringskosten voor overheden en een verminderde aantrekkelijkheid van bestaande obligaties met een lager rendement."
            }
        }
    ]
}

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

Dit woordenboek definieert mijn evaluatiegegevensbron. Elk item bevat de prompt_text (de vraag van de gebruiker) en de context_text (de opgehaalde informatie). Het model dat ik evalueer, zal een antwoord genereren op basis van deze inputs, die de evaluators vervolgens zullen beoordelen.

In de Azure AI Project SDK definieer ik mijn evaluators als onderdeel van de testing_criteria. Ik specificeer de ingebouwde metrische naam (zoals builtin.groundedness) en koppel vervolgens de gegevensvelden van mijn dataset aan de invoer die door die evaluator wordt vereist.

# Ik definieer hier de evaluators. Deze maken gebruik van fundamentele GPT-modellen
# die zijn ingericht binnen mijn Azure AI Project. De 'data_mapping' verbindt
# mijn datasetkolommen met de verwachte invoer van de evaluator.
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' is het gegenereerde antwoord van het model
        },
    },
    {
        "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 stel ik een lijst met woordenboeken in, elk voor het configureren van een evaluator. evaluator_name specificeert de metriek, en data_mapping gebruikt een sjabloonsyntaxis om inputs te verbinden. {{item.prompt_text}} en {{item.context_text}} verwijzen naar velden in mijn dataset, terwijl {{target.response}} een speciale placeholder is voor de voltooiing die wordt gegenereerd door het te evalueren model. Ik raadpleeg vaak de Azure-documentatie over evaluatiemetrieken voor de exacte mappings.

Met mijn gegevens en evaluatoren gedefinieerd, is de volgende stap het maken van een evaluatieobject en vervolgens het activeren van een run. Dit is een asynchroon proces dat wordt beheerd door Azure AI. Ik start dit meestal en volg vervolgens de voortgang ervan in de portal.

# Ik haal de OpenAI client van de project client om te interageren met evaluaties.
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}).")

# Ik definieer de gegevensbron en het doelmodel dat moet worden geëvalueerd.
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...")
# Opmerking: deze bewerking brengt kosten met zich mee op basis van het tokengebruik van de onderliggende LLM's.
# Begin 2026 kunnen de representatieve kosten ongeveer
# 0,01 € per 1k invoertokens en 0,03 € per 1k uitvoertokens bedragen. (Gebruik van $1 \u2248 €0,92 conversie)

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.")

De functie evals.create registreert mijn evaluatiedefinitie, en evals.runs.create start de daadwerkelijke run. Het gebruikt de eval_id van de vorige stap, een menselijk leesbare name voor de run (die verschijnt in de portal), en een data_source object. Dit object vertelt Azure over de invoergegevens, hoe deze te formatteren in een prompt voor het model, en welk geïmplementeerd model (target) ik wil evalueren. De hele run wordt op de achtergrond op Azure uitgevoerd.

Zodra de evaluatie-uitvoering is voltooid in de Azure AI Foundry-portal, kan ik de resultaten downloaden als een JSONL-bestand voor gedetailleerde analyse. Ik navigeer meestal naar de sectie "Evaluaties" in mijn AI Project in de portal, zoek mijn run (financial_qa_eval_202604) en download vervolgens het bestand evaluation_results.jsonl naar mijn eval_outputs-map. Van daaruit gebruik ik Python om de resultaten te parseren en te analyseren met behulp van pandas voor gegevensmanipulatie en tabulate voor schone markdown-opmaak.

import pandas as pd
import json

# Deze stap gaat ervan uit dat ik de resultaten uit de portal heb gedownload.
results_path = os.path.join(OUTPUT_FOLDER, "evaluation_results.jsonl")

try:
    # Het resultatenbestand bevat één JSON-object per regel.
    with open(results_path, 'r') as f:
        lines = f.readlines()

    # Elke regel heeft een complexe structuur; ik moet de relevante delen extraheren.
    parsed_results = []
    for line in lines:
        data = json.loads(line)
        # Extract input data and evaluation metrics.
        # De exacte structuur kan variëren; ik inspecteer meestal eerst mijn JSONL-bestand.
        result_item = data.get('item', {})
        metrics = data.get('metrics', {})

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

    results_df = pd.DataFrame(parsed_results)

    print("\n--- Gedetailleerde per-instantie resultaten (eerste 2 rijen) ---")
    print(results_df.head(2).to_markdown(index=False))

    # Voorbeeld: Bereken en toon geaggregeerde metrische gegevens.
    print("\n--- Geaggregeerde evaluatieresultaten ---")
    print(f"  Gemiddelde groundedness: {results_df['groundedness_score'].mean():.2f}")
    print(f"  Gemiddelde relevantie: {results_df['relevance_score'].mean():.2f}")

except FileNotFoundError:
    print(f"\nAnalyse overgeslagen: Kon '{results_path}' niet vinden. Download het eerst uit de Azure AI Foundry portal.")

Dit script leest het gedownloade JSONL-bestand regel voor regel, parseert de complexe JSON-structuur om de invoerprompt, de gegenereerde voltooiing van het model en de scores voor elke metriek te extraheren. Ik laad deze gegevens vervolgens in een Pandas DataFrame, wat analyse en aggregatie eenvoudig maakt.

Hoewel de SDK me programmatische controle geeft, vertrouw ik nog steeds sterk op de Azure AI Foundry-portal. Het biedt een gecentraliseerde gebruikersinterface voor het bewaken van mijn evaluatieruns, wat bijzonder nuttig is voor operationeel toezicht.

1. Navigeer naar Azure AI Foundry : Meld u aan bij de Azure AI Studio portal.
2. Mijn project lokaliseren : Selecteer uw Azure AI Project.
3. Evaluatieruns vinden : Navigeer naar de sectie "Evaluaties". Ik zou een lijst met evaluaties en hun runs moeten zien, inclusief financial_qa_eval_202604.
4. Metrieken en details bekijken : Door op mijn evaluatierun te klikken, krijg ik geaggregeerde metrieken, gedetailleerde per-instantie resultaten en visualisaties van de prestaties te zien. Het is de primaire interface voor het volgen van trends in metrieken zoals groundedness en relevantie over tijd.

• Minste bevoegdheid : Ik zorg er altijd voor dat elk service principal of beheerde identiteit dat wordt gebruikt door mijn evaluatiepijplijnen alleen de noodzakelijke machtigingen heeft, niets meer.
• Gegevensbescherming : Het versleutelen van evaluatiedatasets in rust en tijdens transport is niet onderhandelbaar. Ik implementeer ook gegevensanonimisering voor alle gevoelige gegevens.
• Beheerde identiteiten : Voor productieworkloads gebruik ik uitsluitend Azure Managed Identities voor authenticatie bij Azure-services. Dit vereenvoudigt het beheer van referenties en verbetert de beveiliging.

• Batchverwerking : Het evaluatiekader is inherent ontworpen om datasets efficiënt in batches te verwerken, dus daar maak ik gebruik van.
• Keuze van evaluator : Hoewel GPT-4 superieure redenering biedt, heb ik gemerkt dat het duurder en trager kan zijn. Voor grootschalige evaluaties waarbij kosten en latentie een rol spelen, kies ik vaak voor GPT-3.5 Turbo als de kwaliteit ervan acceptabel is voor de taak.

• Azure Machine Learning Pipelines : Het integreren van mijn evaluatielogica in Azure Machine Learning-pipelines maakt geautomatiseerde, schaalbare uitvoering in MLOps-workflows mogelijk.
• Regionale implementatie : Voor mijn Europese projecten implementeer ik Azure AI-bronnen altijd in Europese regio's zoals westeurope of northeurope om de latentie voor EU-gebruikers te minimaliseren en te zorgen voor naleving van de gegevenslocatie.

• Waarschuwingen : Het instellen van Azure Monitor-waarschuwingen voor belangrijke evaluatiemetrieken is cruciaal. Ik zou bijvoorbeeld een waarschuwing kunnen activeren als de gemiddelde groundedness-score onder een vooraf gedefinieerde drempel daalt.
• Dashboarding : Ik maak aangepaste dashboards, zowel in Azure AI Foundry als in Azure Monitor, om trends in evaluatiemetrieken over tijd te visualiseren. Dit helpt me snel regressies op te sporen.
• Kostenbewaking : Het continu bewaken van de kosten die gepaard gaan met mijn LLM-aanroepen voor evaluatie is van vitaal belang. Ik stel budgetten en kostenwaarschuwingen in om onverwachte overschrijdingen te voorkomen.

• Azure AI Foundry biedt een robuust platform voor programmatische evaluatie van generatieve AI-modellen, cruciaal voor RAG-toepassingen.
• De azure.ai.project SDK maakt het mogelijk om evaluatiecriteria te definiëren, datasets te verbinden en evaluatieruns rechtstreeks vanuit Python te activeren.
• Belangrijke metrieken zoals groundedness en relevantie worden automatisch beoordeeld met behulp van AI-ondersteunde evaluatoren die binnen het Azure AI Project worden gehost.
• Het bewaken van resultaten in de Azure AI Foundry-portal en het integreren van analyse in CI/CD-pijplijnen zijn essentieel voor het handhaven van de modelkwaliteit.
• Kostenbewaking van LLM-gebruik tijdens evaluaties is cruciaal om de uitgaven te beheren, met typische kosten van ongeveer 0,01 € per 1k invoertokens en 0,03 € per 1k uitvoertokens (met behulp van $1 \u2248 €0,92).