Avalie localmente a sua aplicação de IA generativa com o Azure AI Evaluation SDK (pré-visualização) (clássico)

Aplica-se apenas a:Portal Foundry (clássico). Este artigo não está disponível para o novo portal da Foundry. Saiba mais sobre o novo portal.

Pode avaliar minuciosamente o desempenho da sua aplicação de IA generativa aplicando-a a um conjunto de dados substancial. Avalie a aplicação no seu ambiente de desenvolvimento com o Azure AI Evaluation SDK.

Quando fornece um conjunto de dados de teste ou um alvo, os resultados da sua aplicação de IA generativa são medidos quantitativamente tanto com métricas baseadas em matemática como com avaliadores de qualidade e segurança assistidos por IA. Avaliadores integrados ou personalizados podem fornecer-lhe uma visão completa das capacidades e limitações da aplicação.

Neste artigo, aprende a executar avaliadores numa única linha de dados e num conjunto de dados de teste maior num destino de aplicação. Utiliza-se avaliadores incorporados que utilizam localmente o Azure AI Evaluation SDK. Depois, aprende a acompanhar os resultados e registos de avaliação num projeto Foundry.

Introdução

Primeiro, instale o pacote avaliators a partir do Azure AI Evaluation SDK:

pip install azure-ai-evaluation

Avaliadores incorporados

Métricas de qualidade e segurança incorporadas aceitam pares de consulta e resposta, juntamente com informações adicionais para avaliadores específicos.

Requisitos de dados para avaliadores incorporados

Os avaliadores incorporados podem aceitar pares de consulta e resposta, uma lista de conversas em formato JSON Lines (JSONL), ou ambos.

Azure os avaliadores da OpenAI precisam de um modelo que descreva como as suas colunas de entrada são transformadas na entrada real que o avaliador utiliza. Por exemplo, se tiver duas entradas chamadas consulta e resposta, e um modelo formatado como {{item.query}}, apenas a consulta é usada. De forma semelhante, podes ter algo como {{item.conversation}} para aceitar uma entrada de conversa, no entanto, a capacidade do sistema para lidar com isso depende de como configuras o resto do sistema avaliador para esperar essa entrada.

Para mais informações sobre os requisitos de dados para avaliadores agentes, consulte Avaliar os seus agentes de IA.

Suporte de texto por turno único

Todos os avaliadores incorporados recebem entradas de uma volta como pares de consulta e resposta em cadeias. Por exemplo:

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)

Para executar avaliações em lote usando avaliação local ou carregar o seu conjunto de dados para executar uma avaliação na cloud, represente o conjunto de dados em formato JSONL. Os dados anteriores de um único turno, que são um par de consulta e resposta, são equivalentes a uma linha de um conjunto de dados como o exemplo seguinte, que mostra três linhas:

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

O conjunto de dados de teste de avaliação pode conter os seguintes elementos, dependendo dos requisitos de cada avaliador incorporado:

• Consulta: A consulta enviada para a aplicação de IA generativa.
• Resposta: A resposta à consulta gerada pela aplicação de IA generativa.
• Contexto: A fonte em que se baseia a resposta gerada. Ou seja, os documentos de fundamento.
• Verdade fundamental: A resposta gerada por um utilizador ou humano como a resposta verdadeira.

Para saber o que cada avaliador exige, veja Avaliadores incorporados.

Suporte de conversação para texto

Para avaliadores que apoiam conversas por texto, poderá fornecer conversation como entrada. Esta entrada inclui um dicionário Python com uma lista de messages, que inclui content, role e, opcionalmente, context.

Veja a seguinte conversa de dois turnos em 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
        }
        ]
}

Para executar avaliações em lote usando avaliação local ou carregar o seu conjunto de dados para executar a avaliação na cloud, precisa de representar o conjunto de dados em formato JSONL. A conversa anterior é equivalente a uma linha de conjunto de dados num ficheiro JSONL, como o seguinte exemplo:

{"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
        }
        ]
    }
}

Os nossos avaliadores compreendem que o primeiro turno da conversa fornece válido query de user, context de assistant, e response de assistant no formato de consulta-resposta. As conversas são então avaliadas por turno e os resultados são agregados ao longo de todas as rodadas para obter uma pontuação de conversa.

Para o modo conversa, aqui está um exemplo para 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))

Para os resultados das conversas, os resultados por turno são armazenados numa lista e a pontuação 'groundedness': 4.0 global da conversa é feita em média ao longo dos turnos:

{
    "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
        ]
    }
}

Suporte de conversação para imagens e texto e imagem multimodais

Para avaliadores que suportam conversas para imagem e imagem multimodais e texto, pode passar URLs de imagem ou imagens codificadas em Base64 em conversation.

Cenários suportados incluem:

• Múltiplas imagens com entrada de texto para geração de imagem ou de texto.
• Entrada apenas de texto para gerações de imagens.
• Entrada apenas de imagem para geração de texto.

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)

Atualmente, os avaliadores de imagem e multimodais suportam:

• Apenas turno único: uma conversa pode ter apenas uma mensagem de utilizador e uma mensagem de assistente.
• Conversas que têm apenas uma mensagem do sistema.
• Cargas úteis de conversa com menos de 10 MB, incluindo imagens.
• URLs absolutos e imagens codificadas em Base64.
• Múltiplas imagens num só turno.
• Formatos de ficheiro JPG/JPEG, PNG e GIF.

Configuração

Para avaliadores de qualidade assistidos por IA, exceto para pré-visualização GroundednessProEvaluator, deve especificar um modelo GPT (gpt-35-turbo, gpt-4, gpt-4-turbo, gpt-4o, ou gpt-4o-mini) no seu model_config. O modelo GPT atua como juiz para pontuar os dados de avaliação. Suportamos tanto os esquemas de configuração de modelos OpenAI da Azure como os modelos OpenAI. Para obter o melhor desempenho e respostas analisáveis com os nossos avaliadores, recomendamos a utilização de modelos GPT que não estejam em pré-visualização.

Para todos os avaliadores de risco e segurança e GroundednessProEvaluator (pré-visualização), em vez de uma implementação do GPT em model_config, deve fornecer a sua azure_ai_project informação. Isto acede ao serviço de avaliação de back-end utilizando o seu projeto Foundry.

Sugestões para avaliadores integrados assistidos por IA

Para transparência, disponibilizamos os prompts dos nossos avaliadores de qualidade na nossa Biblioteca de Avaliadores e no repositório Azure AI Evaluation Python SDK, exceto para os Safety Evaluators e GroundednessProEvaluator, alimentados por Segurança de conteúdo de IA do Azure. Estes prompts servem como instruções para que um modelo de linguagem realize a sua tarefa de avaliação, que requer uma definição amigável para o humano da métrica e das respetivas rubricas de pontuação. Recomendamos vivamente que personalize as definições e os critérios de avaliação para as especificidades do seu cenário. Para mais informações, consulte Avaliadores personalizados.

Avaliadores compostos

Os avaliadores compostos são avaliadores incorporados que combinam métricas individuais de qualidade ou segurança. Fornecem uma vasta gama de métricas logo de início para pares de respostas de consulta ou mensagens de chat.

Avaliação local em conjuntos de dados de teste utilizando evaluate()

Depois de verificares os teus avaliadores incorporados ou personalizados numa única linha de dados, podes combinar múltiplos avaliadores com a evaluate() API num conjunto de dados de teste completo.

Passos para configuração prévia de projetos Microsoft Foundry

Se esta sessão for a sua primeira vez a executar avaliações e a logar no seu projeto Foundry, poderá precisar de fazer os seguintes passos de configuração:

1. Crie e ligue a sua conta de armazenamento ao seu projeto Foundry ao nível dos recursos. Este modelo Bicep configura e conecta uma conta de armazenamento ao seu projeto Foundry utilizando autenticação por chave.
2. Certifique-se de que a conta de armazenamento ligada tem acesso a todos os projetos.
3. Se tiver ligado a sua conta de armazenamento ao Microsoft Entra ID, garanta que concede as permissões de identidade da Microsoft para Storage Blob Data Owner tanto à sua conta como ao recurso do projeto Foundry no Portal do Azure.

Realizar uma avaliação sobre um conjunto de dados e registar os resultados na Foundry

Para garantir que a evaluate() API consegue analisar corretamente os dados, deve especificar o mapeamento de colunas para mapear a coluna do conjunto de dados para palavras-chave que os avaliadores aceitam. Este exemplo especifica o mapeamento de dados para query, response, e 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"
)

O avaliador produz resultados num dicionário, que contém dados agregados metrics e ao nível das linhas, bem como métricas. Veja o seguinte exemplo de saída:

{'metrics': {'answer_length.value': 49.333333333333336,
             'groundedness.gpt_groundeness': 5.0, 'groundedness.groundeness': 5.0},
 'rows': [{'inputs.response': 'Paris is the capital/major city of France.',
           'inputs.context': 'Paris has been the capital/major city of France since '
                                  'the 10th century and is known for its '
                                  'cultural and historical landmarks.',
           'inputs.query': 'What is the capital/major city 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': {}}

Requisitos para evaluate()

A evaluate() API requer um formato de dados específico e nomes-chave dos parâmetros do avaliador para mostrar corretamente os gráficos de resultados de avaliação no seu projeto Foundry.

Formato dos dados

A evaluate() API aceita apenas dados em formato JSONL. Para todos os avaliadores incorporados, evaluate() requer dados no formato seguinte com os campos de entrada necessários. Consulte a secção anterior sobre a entrada de dados necessária para avaliadores incorporados. O seguinte excerto de código é um exemplo de como pode ser uma linha:

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

Formato do parâmetro avaliador

Ao passar os seus avaliadores incorporados, especifique a correspondência de palavras-chave correta na lista de parâmetros evaluators. A tabela seguinte mostra o mapeamento de palavras-chave necessário para que os resultados dos seus avaliadores integrados apareçam na interface de utilizador quando registados no seu projeto Foundry.

Aqui está um exemplo de como definir os evaluators parâmetros:

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

Avaliação local no destino

Se tiver uma lista de consultas que quer executar e depois avaliar, a evaluate() API também suporta um target parâmetro. Este parâmetro envia consultas para uma aplicação para recolher respostas e depois executa os seus avaliadores sobre a consulta e resposta resultantes.

Um alvo pode ser qualquer classe chamável no seu diretório. Neste exemplo, existe um script Python askwiki.py com uma classe chamável askwiki() definida como alvo. Se tiver um conjunto de dados de consultas que pode enviar para a aplicação simples askwiki, pode avaliar a fundamentação dos resultados. Certifique-se de especificar o mapeamento correto de colunas para os seus dados em "column_mapping". Pode usar "default" para especificar o mapeamento de colunas para todos os avaliadores.

Aqui está o conteúdo em "data.jsonl":

{"query":"When was United States found ?", "response":"1776"}
{"query":"What is the capital/major city 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}"
            } 
        }
    }
)

Conteúdo relacionado

• Azure biblioteca de cliente de avaliação de IA para Python
• Resolução de Problemas do SDK de Avaliação de IA
• Observabilidade em IA generativa
• Execute avaliações na cloud usando o SDK Microsoft Foundry
• Gerar dados sintéticos e simulados para avaliação
• Consulte os resultados das avaliações no portal da Fundição
• Comece com a Foundry
• Comece com amostras de avaliação