Valutare l'applicazione di intelligenza artificiale generativa in locale con Azure AI Evaluation SDK (anteprima)

È possibile valutare accuratamente le prestazioni dell'applicazione di intelligenza artificiale generativa applicandola a un set di dati sostanziale. Valutare l'applicazione nell'ambiente di sviluppo con Azure AI Evaluation SDK.

Quando si fornisce un set di dati di test o una destinazione, gli output generativi dell'applicazione di intelligenza artificiale vengono misurati in modo quantitativo con metriche basate su matematica e analizzatori di qualità e sicurezza assistita dall'intelligenza artificiale. I valutatori predefiniti o personalizzati possono fornire informazioni dettagliate complete sulle funzionalità e sulle limitazioni dell'applicazione.

Questo articolo illustra come eseguire valutatori su una singola riga di dati e su un set di test più grande su un target dell'applicazione. Si usano analizzatori predefiniti che usano Azure AI Evaluation SDK in locale. Si apprenderà quindi a tenere traccia dei risultati e dei log di valutazione in un progetto Foundry.

Inizia subito

Prima di tutto, installare il pacchetto analizzatori da Azure AI Evaluation SDK:

pip install azure-ai-evaluation

Valutatori predefiniti

Le metriche di qualità e sicurezza predefinite accettano coppie di query e risposte, insieme a informazioni aggiuntive per analizzatori specifici.

Requisiti dei dati per gli valutatori predefiniti

Gli analizzatori predefiniti possono accettare coppie di query e risposte, un elenco di conversazioni in formato JSON Lines (JSONL) o entrambi.

I classificatori OpenAI di Azure richiedono un modello che descrive il modo in cui le colonne di input vengono trasformate nell'input reale usato dal grader. Ad esempio, se sono presenti due input denominati query e risposta e un modello formattato come {{item.query}}, viene usata solo la query. Analogamente, si potrebbe avere qualcosa di simile a {{item.conversation}} per accettare un input di conversazione, ma la capacità del sistema di gestire ciò dipende da come si configura il resto del valutatore per aspettarsi tale input.

Per altre informazioni sui requisiti dei dati per gli analizzatori agenti, vedere Valutare gli agenti di intelligenza artificiale.

Supporto turno singolo per il testo

Tutti i valutatori predefiniti accettano input a turno singolo come coppie di query e risposta nelle stringhe. Per esempio:

from azure.ai.evaluation import RelevanceEvaluator

query = "What is the capital of life?"
response = "Paris."

# Initialize an evaluator:
relevance_eval = RelevanceEvaluator(model_config)
relevance_eval(query=query, response=response)

Per eseguire valutazioni batch usando la valutazione locale o caricare il set di dati per eseguire una valutazione cloud, rappresentare il set di dati in formato JSONL. I dati a turno singolo precedenti, ovvero una coppia di query e risposta, sono equivalenti a una riga di un set di dati come nell'esempio seguente, che mostra tre righe:

{"query":"What is the capital of France?","response":"Paris."}
{"query":"What atoms compose water?","response":"Hydrogen and oxygen."}
{"query":"What color is my shirt?","response":"Blue."}

Il set di dati di test di valutazione può contenere gli elementi seguenti, a seconda dei requisiti di ogni analizzatore predefinito:

• Query: la query inviata all'applicazione di intelligenza artificiale generativa.
• Risposta: risposta alla query generata dall'applicazione di intelligenza artificiale generativa.
• Contesto: l'origine su cui si basa la risposta generata. Cioè, i documenti di base.
• Verità di base: la risposta generata da un utente o da un umano come la vera risposta.

Per vedere cosa richiede ogni analizzatore, vedere Analizzatori.

Supporto della conversazione per il testo

Per gli analizzatori che supportano le conversazioni per il testo, è possibile fornire conversation come input. Questo input include un dizionario Python con un elenco di messages, che include content, rolee facoltativamente context.

Visualizza la seguente conversazione a due turni in Python:

conversation = {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": None
        }
        ]
}

Per eseguire valutazioni batch usando la valutazione locale o caricare il set di dati per eseguire la valutazione cloud, è necessario rappresentare il set di dati in formato JSONL. La conversazione precedente equivale a una riga di set di dati in un file JSONL come nell'esempio seguente:

{"conversation":
    {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": null
        }
        ]
    }
}

I valutatori comprendono che il primo turno della conversazione fornisce un valido query da user, context da assistant e response da assistant nel formato di query-risposta. Le conversazioni vengono quindi valutate per turno e i risultati vengono aggregati in tutti i turni per un punteggio di conversazione.

Per la modalità conversazione, ecco un esempio per GroundednessEvaluator:

# Conversation mode:
import json
import os
from azure.ai.evaluation import GroundednessEvaluator, AzureOpenAIModelConfiguration

model_config = AzureOpenAIModelConfiguration(
    azure_endpoint=os.environ.get("AZURE_ENDPOINT"),
    api_key=os.environ.get("AZURE_API_KEY"),
    azure_deployment=os.environ.get("AZURE_DEPLOYMENT_NAME"),
    api_version=os.environ.get("AZURE_API_VERSION"),
)

# Initialize the Groundedness evaluator:
groundedness_eval = GroundednessEvaluator(model_config)

conversation = {
    "messages": [
        { "content": "Which tent is the most waterproof?", "role": "user" },
        { "content": "The Alpine Explorer Tent is the most waterproof", "role": "assistant", "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight." },
        { "content": "How much does it cost?", "role": "user" },
        { "content": "$120.", "role": "assistant", "context": "The Alpine Explorer Tent is $120."}
    ]
}

# Alternatively, you can load the same content from a JSONL file.
groundedness_conv_score = groundedness_eval(conversation=conversation)
print(json.dumps(groundedness_conv_score, indent=4))

Per gli output della conversazione, i risultati per turno vengono archiviati in un elenco e il punteggio 'groundedness': 4.0 complessivo della conversazione viene mediato sui turni:

{
    "groundedness": 5.0,
    "gpt_groundedness": 5.0,
    "groundedness_threshold": 3.0,
    "evaluation_per_turn": {
        "groundedness": [
            5.0,
            5.0
        ],
        "gpt_groundedness": [
            5.0,
            5.0
        ],
        "groundedness_reason": [
            "The response accurately and completely answers the query by stating that the Alpine Explorer Tent is the most waterproof, which is directly supported by the context. There are no irrelevant details or incorrect information present.",
            "The RESPONSE directly answers the QUERY with the exact information provided in the CONTEXT, making it fully correct and complete."
        ],
        "groundedness_result": [
            "pass",
            "pass"
        ],
        "groundedness_threshold": [
            3,
            3
        ]
    }
}

Supporto della conversazione per immagini e testo e immagine multimodali

Per gli analizzatori che supportano conversazioni per immagini e immagini e testo bidirezionali, è possibile passare gli URL di immagine o le immagini con codifica Base64 in conversation.

Gli scenari supportati includono:

• Immagini multiple con input di testo per la generazione di immagini o testo.
• Input di sola testo per le generazioni di immagini.
• Input di sola immagine per la generazione di testo.

from pathlib import Path
from azure.ai.evaluation import ContentSafetyEvaluator
import base64

# Create an instance of an evaluator with image and multi-modal support.
safety_evaluator = ContentSafetyEvaluator(credential=azure_cred, azure_ai_project=project_scope)

# Example of a conversation with an image URL:
conversation_image_url = {
    "messages": [
        {
            "role": "system",
            "content": [
                {"type": "text", "text": "You are an AI assistant that understands images."}
            ],
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Can you describe this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://cdn.britannica.com/68/178268-050-5B4E7FB6/Tom-Cruise-2013.jpg"
                    },
                },
            ],
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "The image shows a man with short brown hair smiling, wearing a dark-colored shirt.",
                }
            ],
        },
    ]
}

# Example of a conversation with base64 encoded images:
base64_image = ""

with Path.open("Image1.jpg", "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

conversation_base64 = {
    "messages": [
        {"content": "create an image of a branded apple", "role": "user"},
        {
            "content": [{"type": "image_url", "image_url": {"url": f"data:image/jpg;base64,{base64_image}"}}],
            "role": "assistant",
        },
    ]
}

# Run the evaluation on the conversation to output the result.
safety_score = safety_evaluator(conversation=conversation_image_url)

Attualmente, l'immagine e gli analizzatori multimodali supportano:

• Solo turno singolo: una conversazione può avere un solo messaggio utente e un messaggio di assistente.
• Conversazioni con un solo messaggio di sistema.
• Pacchetti di dati di conversazione inferiori a 10 MB, incluse le immagini.
• URL assoluti e immagini con codifica Base64.
• Più immagini in un unico turno.
• Formati di file JPG/JPEG, PNG e GIF.

Configurazione

Per gli analizzatori della qualità assistita dall'intelligenza artificiale, ad eccezione dell'anteprima GroundednessProEvaluator, è necessario specificare un modello GPT (gpt-35-turbo, gpt-4, gpt-4-turbo, gpt-4o, o gpt-4o-mini) nel documento model_config. Il modello GPT funge da giudice per assegnare un punteggio ai dati di valutazione. Supportiamo sia gli schemi di configurazione del modello di Azure OpenAI che di OpenAI. Per ottenere prestazioni ottimali e risposte analizzabili con i valutatori, è consigliabile usare modelli GPT che non sono in fase di anteprima.

Per tutti i valutatori di rischi e sicurezza e GroundednessProEvaluator (anteprima), invece di una distribuzione GPT in model_config, è necessario fornire le informazioni azure_ai_project. In questo modo si accede al servizio di valutazione back-end usando il progetto Foundry.

Suggerimenti per valutatori integrati con intelligenza artificiale

Per la trasparenza, rendiamo pubblici i prompt dei valutatori di qualità nella nostra Libreria dei Valutatori e nel repository Azure AI Evaluation Python SDK, ad eccezione dei Valutatori di Sicurezza e GroundednessProEvaluator, basati su Azure AI Content Safety. Queste istruzioni servono come istruzioni per un modello linguistico per eseguire l'attività di valutazione, che richiede una definizione descrittiva della metrica e le rubriche di assegnazione dei punteggi associate. È consigliabile personalizzare le definizioni e classificare le rubriche in base alle specifiche dello scenario. Per altre informazioni, vedere Analizzatori personalizzati.

Valutatori compositi

Gli analizzatori compositi sono analizzatori predefiniti che combinano le singole metriche di qualità o sicurezza. Offrono un'ampia gamma di metriche predefinite per entrambe le coppie di risposte di query e i messaggi di chat.

Valutazione locale sui set di dati di test con evaluate()

Dopo aver controllato i valutatori predefiniti o personalizzati in una singola riga di dati, è possibile combinare più valutatori con l'API evaluate() in un intero set di dati di test.

Passaggi di configurazione dei prerequisiti per i progetti Microsoft Foundry

Se questa sessione è la prima volta che esegue valutazioni e la registrazione nel progetto Foundry, potrebbe essere necessario eseguire la procedura di configurazione seguente:

1. Crea e connetti il tuo account di archiviazione al progetto Foundry a livello di risorsa. Questo modello Bicep fornisce e connette un account di archiviazione al progetto Foundry con l'autenticazione tramite chiave.
2. Assicurarsi che l'account di archiviazione connesso abbia accesso a tutti i progetti.
3. Se l'account di archiviazione è stato connesso con Microsoft Entra ID, assicurarsi di concedere le autorizzazioni di identità Microsoft per il ruolo Proprietario dei dati dei BLOB di archiviazione sia all'account che alla risorsa del progetto Fonderia nel portale di Azure.

Valutare un set di dati e registrare i risultati in Foundry

Per garantire che l'API evaluate() possa analizzare correttamente i dati, è necessario specificare il mapping delle colonne per eseguire il mapping della colonna dal set di dati alle parole chiave accettate dagli analizzatori. In questo esempio viene specificato il mapping dei dati per query, responsee context.

from azure.ai.evaluation import evaluate

result = evaluate(
    data="data.jsonl", # Provide your data here:
    evaluators={
        "groundedness": groundedness_eval,
        "answer_length": answer_length
    },
    # Column mapping:
    evaluator_config={
        "groundedness": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${data.context}",
                "response": "${data.response}"
            } 
        }
    },
    # Optionally, provide your Foundry project information to track your evaluation results in your project portal.
    azure_ai_project = azure_ai_project,
    # Optionally, provide an output path to dump a JSON file of metric summary, row-level data, and the metric and Foundry project URL.
    output_path="./myevalresults.json"
)

Il valutatore restituisce risultati in un dizionario, che contiene dati aggregati metrics e dati e metriche a livello di riga. Vedere l'output di esempio seguente:

{'metrics': {'answer_length.value': 49.333333333333336,
             'groundedness.gpt_groundeness': 5.0, 'groundedness.groundeness': 5.0},
 'rows': [{'inputs.response': 'Paris is the capital of France.',
           'inputs.context': 'Paris has been the capital of France since '
                                  'the 10th century and is known for its '
                                  'cultural and historical landmarks.',
           'inputs.query': 'What is the capital of France?',
           'outputs.answer_length.value': 31,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'Albert Einstein developed the theory of '
                            'relativity.',
           'inputs.context': 'Albert Einstein developed the theory of '
                                  'relativity, with his special relativity '
                                  'published in 1905 and general relativity in '
                                  '1915.',
           'inputs.query': 'Who developed the theory of relativity?',
           'outputs.answer_length.value': 51,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'The speed of light is approximately 299,792,458 '
                            'meters per second.',
           'inputs.context': 'The exact speed of light in a vacuum is '
                                  '299,792,458 meters per second, a constant '
                                  "used in physics to represent 'c'.",
           'inputs.query': 'What is the speed of light?',
           'outputs.answer_length.value': 66,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'}],
 'traces': {}}

Requisiti per evaluate()

L'API evaluate() richiede un formato dati specifico e nomi di chiave dei parametri dell'analizzatore per visualizzare correttamente i grafici dei risultati della valutazione nel progetto Foundry.

Formato dei dati

L'API evaluate() accetta solo i dati in formato JSONL. Per tutti gli analizzatori predefiniti, evaluate() richiede i dati nel formato seguente con i campi di input necessari. Vedere la sezione precedente sull'input dei dati richiesto per gli analizzatori predefiniti. Il frammento di codice seguente è un esempio dell'aspetto di una riga:

{
  "query":"What is the capital of France?",
  "context":"France is in Europe",
  "response":"Paris is the capital of France.",
  "ground_truth": "Paris"
}

Formato dei parametri dell'analizzatore

Quando si passano i valutatori incorporati, specificare il mapping delle parole chiave corretto nell'elenco dei parametri evaluators. Nella tabella seguente viene illustrato il mapping delle parole chiave necessario per i risultati degli analizzatori predefiniti da visualizzare nell'interfaccia utente quando si è connessi al progetto Foundry.

Ecco un esempio di come impostare i evaluators parametri:

result = evaluate(
    data="data.jsonl",
    evaluators={
        "sexual":sexual_evaluator,
        "self_harm":self_harm_evaluator,
        "hate_unfairness":hate_unfairness_evaluator,
        "violence":violence_evaluator
    }
)

Valutazione locale su un obiettivo

Se si dispone di un elenco di query da eseguire e quindi valutate, l'API evaluate() supporta anche un target parametro. Questo parametro invia query a un'applicazione per raccogliere risposte e quindi esegue i valutatori sulla query e sulla risposta risultante.

Una destinazione può essere qualsiasi classe chiamabile nella directory. In questo esempio è presente uno script askwiki.py Python con una classe askwiki() chiamabile impostata come destinazione. Se si dispone di un set di dati di query che è possibile inviare all'app semplice askwiki, è possibile valutare la fondatezza degli output. Assicurarsi di specificare il mapping delle colonne appropriato per i dati in "column_mapping". È possibile usare "default" per specificare il mapping delle colonne per tutti gli analizzatori.

Ecco il contenuto in "data.jsonl":

{"query":"When was United States found ?", "response":"1776"}
{"query":"What is the capital of France?", "response":"Paris"}
{"query":"Who is the best tennis player of all time ?", "response":"Roger Federer"}

from askwiki import askwiki

result = evaluate(
    data="data.jsonl",
    target=askwiki,
    evaluators={
        "groundedness": groundedness_eval
    },
    evaluator_config={
        "default": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${outputs.context}",
                "response": "${outputs.response}"
            } 
        }
    }
)

Contenuto correlato

• Libreria client di valutazione dell'intelligenza artificiale di Azure per Python
• Risolvere i problemi di AI Evaluation SDK
• Osservabilità nell'intelligenza artificiale generativa
• Eseguire valutazioni nel cloud usando Microsoft Foundry SDK
• Generare dati sintetici e simulati per la valutazione
• Vedere i risultati della valutazione nel portale Foundry
• Introduzione a Foundry
• Introduzione agli esempi di valutazione