Valutazione delle prestazioni dell'ia generativa in azure ai foundry: una guida pratica

Inizio creando un nuovo file Python, spesso chiamato qualcosa come evaluate_genai.py. È qui che importo i moduli necessari e configuro il client per connettersi al mio progetto Azure AI. Ricorda di sostituire i valori segnaposto di seguito con i dettagli effettivi del tuo progetto; di solito li memorizzo nelle variabili d'ambiente per una migliore sicurezza e flessibilità.

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

# --- Configurazione --- #
# Sostituire con i dettagli del tuo progetto Azure AI. Di solito trovo l'endpoint
# nel portale di Azure AI Studio sotto le impostazioni del mio progetto.
AZURE_AI_PROJECT_ENDPOINT = os.environ.get("AZURE_AI_PROJECT_ENDPOINT", "your_project_endpoint")
# Il nome del tuo modello distribuito che voglio valutare.
EVALUATION_TARGET_DEPLOYMENT = os.environ.get("EVALUATION_TARGET_DEPLOYMENT", "your_model_deployment_name")

# Inizializza DefaultAzureCredential per l'autenticazione
credential = DefaultAzureCredential()
print("Azure credential initialized.")

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

# Cartella di base per gli output
OUTPUT_FOLDER = "./eval_outputs"
os.makedirs(OUTPUT_FOLDER, exist_ok=True)
print(f"Output folder '{OUTPUT_FOLDER}' ensured.")

Questo snippet importa le classi richieste per l'interazione del progetto e l'autenticazione. Configura l'endpoint per il mio progetto AI e inizializza AIProjectClient, che è il mio principale punto di ingresso per la gestione delle risorse del progetto. Imposto anche una directory di output per archiviare i risultati.

Per valutare efficacemente un'applicazione RAG, ho bisogno di un dataset comprendente prompt e il contesto rispetto al quale verrà giudicata la risposta del modello. È fondamentale che il completamento del modello non faccia parte di questi dati di input; viene generato durante l'esecuzione della valutazione stessa.

# Questo è un esempio di dataset che potrei usare per la valutazione,
# che simula una sessione di domande e risposte su documenti finanziari.
# La struttura 'item' è richiesta dal framework di valutazione.
data_for_evaluation = {
    "type": "file_content",
    "content": [
        {
            "item": {
                "prompt_text": "Qual è la principale sfida finanziaria per NVIDIA nel 2026?",
                "context_text": "Il 15 marzo 2026, NVIDIA ha riportato forti guadagni nel quarto trimestre 2025, ma ha evidenziato potenziali sfide nel prossimo anno fiscale a causa dell'intensificarsi della concorrenza da parte di Intel e AMD nel mercato degli acceleratori AI. Gli analisti della catena di approvvigionamento hanno anche notato persistenti complessità nell'assicurare capacità di produzione avanzate per le GPU H200 e Blackwell di prossima generazione di NVIDIA, il che potrebbe influire sulla crescita dei ricavi."
            }
        },
        {
            "item": {
                "prompt_text": "Spiegare l'impatto dell'ultimo aumento dei tassi di interesse da parte della BCE sui mercati obbligazionari.",
                "context_text": "Il 2 aprile 2026, la Banca Centrale Europea (BCE) ha annunciato un aumento di 25 punti base dei suoi tassi di interesse chiave, citando persistenti preoccupazioni per l'inflazione. In seguito a questo annuncio, gli analisti di Bloomberg hanno riportato un forte aumento dei rendimenti dei Bund tedeschi a 10 anni, indicando una generale riprezzatura del debito sovrano nell'Eurozona a causa di maggiori costi di finanziamento per i governi e una minore attrattiva delle obbligazioni esistenti a rendimento inferiore."
            }
        }
    ]
}

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

Questo dizionario definisce la mia origine dati di valutazione. Ogni item contiene il prompt_text (la query dell'utente) e il context_text (le informazioni recuperate). Il modello che sto valutando genererà una risposta basata su questi input, che gli valutatori valuteranno in seguito.

Nell'SDK di Azure AI Project, definisco i miei valutatori come parte dei testing_criteria. Specifio il nome della metrica incorporata (come builtin.groundedness) e quindi mappo i campi dati dal mio dataset agli input richiesti da tale valutatore.

# Definisco qui gli valutatori. Questi sfruttano i modelli GPT fondamentali
# forniti all'interno del mio progetto Azure AI. Il 'data_mapping' collega
# le colonne del mio dataset agli input attesi dall'evaluatore.
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' è la risposta generata dal modello
        },
    },
    {
        "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.")

Qui sto impostando un elenco di dizionari, ciascuno configurando un valutatore. evaluator_name specifica la metrica, e data_mapping utilizza una sintassi di template per collegare gli input. {{item.prompt_text}} e {{item.context_text}} si riferiscono ai campi nel mio dataset, mentre {{target.response}} è un segnaposto speciale per il completamento generato dal modello in valutazione. Mi riferisco spesso alla documentazione di Azure sulle metriche di valutazione per i mapping esatti.

Una volta definiti i miei dati e i miei valutatori, il passo successivo è creare un oggetto di valutazione e quindi avviare un'esecuzione. Questo è un processo asincrono gestito da Azure AI. Di solito lo avvio e poi monitoro il suo progresso nel portale.

# Ottengo il client OpenAI dal client di progetto per interagire con le valutazioni.
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}).")

# Definisco la fonte di dati e il modello di destinazione da valutare.
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...")
# Nota: questa operazione comporterà costi basati sull'utilizzo dei token dei LLM sottostanti.
# All'inizio del 2026, un costo rappresentativo potrebbe essere di circa
# 0,01 € per 1k token di input e 0,03 € per 1k token di output. (Utilizzo di 1 $ \u2248 0,92 € di conversione)

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

La funzione evals.create registra la mia definizione di valutazione e evals.runs.create avvia l'esecuzione effettiva. Utilizza l'eval_id del passaggio precedente, un name leggibile dall'uomo per l'esecuzione (che appare nel portale) e un oggetto data_source. Questo oggetto indica ad Azure i dati di input, come formattarli in un prompt per il modello e quale modello distribuito (target) voglio valutare. L'intera esecuzione viene eseguita in background su Azure.

Una volta completata l'esecuzione della valutazione nel portale Azure AI Foundry, posso scaricare i risultati come file JSONL per un'analisi dettagliata. Di solito navigo alla sezione "Valutazioni" nel mio progetto AI nel portale, trovo la mia esecuzione (financial_qa_eval_202604) e quindi scarico il file evaluation_results.jsonl nella mia cartella eval_outputs. Da lì, utilizzo Python per analizzare i risultati utilizzando pandas per la manipolazione dei dati e tabulate per una formattazione markdown pulita.

import pandas as pd
import json

# Questo passaggio presuppone che io abbia scaricato i risultati dal portale.
results_path = os.path.join(OUTPUT_FOLDER, "evaluation_results.jsonl")

try:
    # Il file dei risultati contiene un oggetto JSON per riga.
    with open(results_path, 'r') as f:
        lines = f.readlines()

    # Ogni riga ha una struttura complessa; devo estrarre le parti pertinenti.
    parsed_results = []
    for line in lines:
        data = json.loads(line)
        # Estrai dati di input e metriche di valutazione.
        # La struttura esatta può variare; di solito ispeziono prima il mio file JSONL.
        result_item = data.get('item', {})
        metrics = data.get('metrics', {})

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

    results_df = pd.DataFrame(parsed_results)

    print("\n--- Risultati dettagliati per istanza (prime 2 righe) ---")
    print(results_df.head(2).to_markdown(index=False))

    # Esempio: calcola e visualizza le metriche aggregate.
    print("\n--- Risultati di valutazione aggregati ---")
    print(f"  Groundedness media: {results_df['groundedness_score'].mean():.2f}")
    print(f"  Rilevanza media: {results_df['relevance_score'].mean():.2f}")

except FileNotFoundError:
    print(f"\nAnalisi saltata: impossibile trovare '{results_path}'. Scaricalo prima dal portale di Azure AI Foundry.")

Questo script legge il file JSONL scaricato riga per riga, analizza la complessa struttura JSON per estrarre il prompt di input, il completamento generato dal modello e i punteggi per ogni metrica. Quindi carico questi dati in un DataFrame Pandas, il che rende l'analisi e l'aggregazione semplici.

Sebbene l'SDK mi dia il controllo programmatico, mi affido ancora molto al portale Azure AI Foundry. Offre un'interfaccia utente centralizzata per monitorare le mie esecuzioni di valutazione, il che è particolarmente utile per la supervisione operativa.

1. Naviga in Azure AI Foundry : Accedi al portale Azure AI Studio.
2. Individua il mio progetto : Seleziona il tuo progetto Azure AI.
3. Trova le esecuzioni di valutazione : Naviga alla sezione "Valutazioni". Dovrei vedere un elenco di valutazioni e delle loro esecuzioni, inclusa financial_qa_eval_202604.
4. Rivedi metriche e dettagli : Cliccando sulla mia esecuzione di valutazione mi vengono mostrate le metriche aggregate, i risultati dettagliati per istanza e le visualizzazioni delle prestazioni. È l'interfaccia principale per monitorare le tendenze nelle metriche come la fondatezza e la pertinenza nel tempo.

• Minimo privilegio : Mi assicuro sempre che qualsiasi service principal o identità gestita utilizzata dalle mie pipeline di valutazione abbia solo le autorizzazioni necessarie, niente di più.
• Protezione dei dati : La crittografia dei set di dati di valutazione a riposo e in transito non è negoziabile. Implemento anche l'anonimizzazione dei dati per qualsiasi dato sensibile.
• Identità gestite : Per i carichi di lavoro di produzione, utilizzo esclusivamente le identità gestite di Azure per l'autenticazione ai servizi Azure. Ciò semplifica la gestione delle credenziali e migliora la sicurezza.

• Elaborazione batch : Il framework di valutazione è intrinsecamente progettato per elaborare set di dati in batch in modo efficiente, quindi ne sfrutto le capacità.
• Scelta dell'evaluatore : Mentre GPT-4 offre un ragionamento superiore, ho scoperto che può essere più costoso e lento. Per valutazioni su larga scala in cui i costi e la latenza sono preoccupazioni, spesso opto per GPT-3.5 Turbo se la sua qualità è accettabile per il compito.

• Pipeline di Azure Machine Learning : L'integrazione della mia logica di valutazione nelle pipeline di Azure Machine Learning consente un'esecuzione automatizzata e scalabile nei flussi di lavoro MLOps.
• Distribuzione regionale : Per i miei progetti europei, distribuisco sempre le risorse di Azure AI in regioni europee come westeurope o northeurope per ridurre al minimo la latenza per gli utenti basati nell'UE e garantire la conformità alla residenza dei dati.

• Avvisi : La configurazione di avvisi di Azure Monitor sulle metriche di valutazione chiave è fondamentale. Ad esempio, potrei attivare un avviso se il punteggio medio di fondatezza scende al di sotto di una soglia predefinita.
• Dashboard : Creo dashboard personalizzati, sia in Azure AI Foundry che in Azure Monitor, per visualizzare le tendenze nelle metriche di valutazione nel tempo. Questo mi aiuta a individuare rapidamente le regressioni.
• Monitoraggio dei costi : Il monitoraggio continuo dei costi associati alle mie chiamate LLM per la valutazione è vitale. Stabilisco budget e avvisi di costo per prevenire spese impreviste eccessive.

• Azure AI Foundry fornisce una piattaforma robusta per la valutazione programmatica dei modelli di intelligenza artificiale generativa, cruciale per le applicazioni RAG.
• L'SDK azure.ai.project consente di definire i criteri di valutazione, collegare i set di dati e attivare le esecuzioni di valutazione direttamente da Python.
• Le metriche chiave come Groundedness e Relevance vengono automaticamente valutate utilizzando valutatori assistiti dall'IA ospitati all'interno del progetto Azure AI.
• Il monitoraggio dei risultati nel portale di Azure AI Foundry e l'integrazione dell'analisi nelle pipeline CI/CD sono essenziali per mantenere la qualità del modello.
• Il monitoraggio dei costi dell'utilizzo dei LLM durante le valutazioni è fondamentale per gestire le spese, con costi tipici di circa 0,01 € per 1k token di input e 0,03 € per 1k token di output (utilizzando 1 $ \u2248 0,92 €).