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

Você pode avaliar completamente o desempenho de seu aplicativo de IA generativa aplicando-o a um conjunto de dados substancial. Avalie o aplicativo em seu ambiente de desenvolvimento com o SDK de Avaliação de IA do Azure.

Quando você fornece um conjunto de dados de teste ou um alvo, suas saídas de aplicativos generativos de IA são medidas quantitativamente com métricas baseadas em matemática e avaliadores de qualidade e segurança assistidos por IA. Avaliadores integrados ou personalizados podem fornecer informações abrangentes sobre os recursos e limitações do aplicativo.

Neste artigo, você aprenderá a executar avaliadores em uma única linha de dados e um conjunto de dados de teste maior em um destino de aplicativo. Você usa avaliadores internos que usam o SDK de Avaliação da IA do Azure localmente. 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 integrados

As 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 integrados

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

Os avaliadores do Azure OpenAI exigem um modelo que descreva como suas colunas de entrada são transformadas na entrada real que o classificador usa. Por exemplo, se você tiver duas entradas chamadas consulta e resposta e um modelo formatado como {{item.query}}, somente a consulta será usada. Da mesma forma, você pode ter algo como {{item.conversation}} aceitar uma entrada de conversa, mas a capacidade do sistema de lidar com isso depende de como você configura o resto da grade para esperar essa entrada.

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

Suporte de turno único para texto

Todos os avaliadores integrados recebem entradas de turno único como pares de consulta e resposta em cadeias de caracteres. 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 a avaliação local ou carregar seu conjunto de dados para executar uma avaliação na nuvem, represente o conjunto de dados no formato JSONL. Os dados de turno único anteriores, que são um par de consulta e resposta, são equivalentes a uma linha de um conjunto de dados como o exemplo a seguir, que mostra três linhas:

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

O conjunto de dados do 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 pelo aplicativo de IA generativa.
• Contexto: A fonte na qual a resposta gerada se baseia. Ou seja, os documentos de fundamentação.
• Verdade fundamental: A resposta gerada por um usuário ou humano como a resposta verdadeira.

Para ver o que cada avaliador exige, consulte Avaliadores.

Suporte de conversação para texto

Para avaliadores que suportam conversas para texto, você pode fornecer conversation como entrada. Esta entrada inclui um dicionário Python com uma lista de messages, que inclui content, rolee 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 a avaliação local ou carregar seu conjunto de dados para executar a avaliação na nuvem, você precisa representar o conjunto de dados no formato JSONL. A conversação anterior é equivalente a uma linha de conjunto de dados em um arquivo JSONL como o exemplo a seguir:

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

Nossos avaliadores entendem que o primeiro turno da conversa fornece válido query de user, context de assistant, e response de assistant no formato consulta-resposta. As conversas são então avaliadas por turno e os resultados são agregados em todos os turnos para uma pontuação de conversa.

Para o modo de conversação, aqui está um exemplo de 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 outputs de conversação, os resultados por turno são armazenados numa lista e a pontuação geral da conversa 'groundedness': 4.0 é calculada como a 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 envolvendo imagens e textos multimodais, pode fornecer URLs de imagem ou imagens codificadas em Base64 em conversation.

Os cenários suportados incluem:

• Várias imagens com entrada de texto para geração de imagem ou texto.
• Entrada somente texto para gerações de imagens.
• Entrada somente 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 usuário e uma mensagem de assistente.
• Conversas que têm apenas uma mensagem do sistema.
• Cargas de dados da conversação que integram imagens e têm menos de 10 MB.
• URLs absolutos e imagens codificadas em Base64.
• Várias imagens em um único turno.
• Formatos de ficheiro JPG/JPEG, PNG e GIF.

Configurar

Para avaliadores de qualidade assistidos por IA, exceto para GroundednessProEvaluator pré-visualização, o utilizador 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 um juiz para pontuar os dados da avaliação. Damos suporte aos esquemas de configuração de modelos Azure OpenAI e OpenAI. Para obter o melhor desempenho e respostas analisáveis com nossos avaliadores de software, recomendamos o uso de modelos GPT que não estão em fase de testes.

Para todos os avaliadores de risco e segurança e GroundednessProEvaluator (pré-visualização), você deve fornecer suas informações model_config em vez de uma implantação GPT no azure_ai_project. 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 Evaluator e no repositório Azure AI Evaluation Python SDK, exceto para os Safety Evaluators e GroundednessProEvaluator, alimentados pelo Azure AI Content Safety. Esses prompts servem como instruções para um modelo de linguagem executar sua tarefa de avaliação, o que requer uma definição amigável da métrica e suas rubricas de pontuação associadas. É altamente recomendável que você personalize as definições e rubricas de classificação de acordo com as especificidades do cenário. Para obter mais informações, consulte Avaliadores personalizados.

Avaliadores compostos

Os avaliadores compostos são avaliadores integrados que combinam métricas individuais de qualidade ou segurança. Eles fornecem uma ampla gama de métricas prontas para uso tanto para pares de resposta de consulta quanto para mensagens de bate-papo.

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

Depois de verificar seus avaliadores internos ou personalizados em uma única linha de dados, você pode combinar vários avaliadores com a evaluate() API em um conjunto de dados de teste inteiro.

Passos pré-requisitos de configuração para 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 provisiona e liga uma conta de armazenamento ao seu projeto Foundry com autenticação através de chave.
2. Verifique se a conta de armazenamento conectada tem acesso a todos os projetos.
3. Se você conectou sua conta de armazenamento com a ID do Microsoft Entra, certifique-se de conceder permissões de Identidade da Microsoft para o Proprietário de Dados de Blob de Armazenamento à sua conta e ao recurso do projeto do Foundry no portal do Azure.

Avaliar num conjunto de dados e registar resultados na Foundry

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

Os resultados provenientes do avaliador são armazenados num dicionário, que contém dados e métricas agregados metrics e dados ao nível da linha. Veja o exemplo de saída a seguir:

{'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': {}}

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 no formato JSONL. Para todos os avaliadores incorporados, evaluate() requer dados no seguinte formato com os campos de entrada obrigatórios. Consulte a secção anterior sobre a introdução de dados necessária para os avaliadores incorporados. O trecho de código a seguir é um exemplo de como uma linha pode parecer:

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

Formato do parâmetro do avaliador

Ao passar os seus avaliadores incorporados, especifique o mapeamento correto de palavras-chave na lista de parâmetros evaluators. A tabela seguinte mostra o mapeamento de palavras-chave necessário para que os resultados dos seus avaliadores incorporados apareçam na interface quando ligados ao 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 sobre um alvo

Se você tiver uma lista de consultas que deseja executar e, em seguida, avaliar, a evaluate() API também oferece suporte a 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 destino pode ser qualquer classe chamável em seu diretório. Neste exemplo, há um script askwiki.py Python com uma classe askwiki() chamável que é definida como o destino. Se tiveres um conjunto de dados de consultas que podes enviar para a aplicação simples askwiki, podes avaliar a validade das saídas. Certifique-se de especificar o mapeamento de coluna adequado para seus dados no "column_mapping". Você 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 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

• Biblioteca de cliente do Azure AI Evaluation para Python
• Solucionar problemas do SDK de avaliação de IA
• Observabilidade na IA generativa
• Execute avaliações na cloud usando o Microsoft Foundry SDK
• Gerar dados sintéticos e simulados para avaliação
• Consulte os resultados das avaliações no portal da Fundição
• Comece com a Foundry
• Introdução às amostras de avaliação