Avalie seu aplicativo de IA generativo localmente com o SDK de Avaliação de IA do Azure (versão prévia)

Você pode avaliar minuciosamente o desempenho do aplicativo de IA generativo 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 destino, as saídas do aplicativo de IA gerativa são medidas quantitativamente com métricas baseadas em matemática e avaliadores de qualidade e segurança assistidos por IA. Os avaliadores internos ou personalizados podem fornecer insights 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 de IA do Azure localmente. Em seguida, você aprenderá a acompanhar os resultados e os logs de avaliação em um projeto do Foundry.

Introdução

Primeiro, instale o pacote de avaliadores do SDK de Avaliação de IA do Azure:

pip install azure-ai-evaluation

Avaliadores internos

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

Requisitos de dados para avaliadores internos

Os avaliadores integrados podem aceitar pares de consulta e resposta, uma lista de conversas no formato JSONL (Linhas JSON) 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 avaliador 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, é possível ter algo como {{item.conversation}} para aceitar uma entrada de conversa, mas a capacidade do sistema de lidar com isso depende de como você configurará o restante do classificador para esperar essa entrada.

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

Suporte de turno único para texto

Todos os avaliadores internos aceitam entradas de única rodada, 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 de 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 de teste de avaliação pode conter os seguintes elementos, dependendo dos requisitos de cada avaliador interno:

• Consulta: a consulta enviada para o aplicativo de IA generativo.
• Resposta: a resposta à consulta gerada pelo aplicativo de IA gerativo.
• Contexto: a origem na qual a resposta gerada se baseia. Ou seja, os documentos de fundamentação.
• Verdade básica: a resposta gerada por um usuário ou humano como a resposta verdadeira.

Para ver o que cada avaliador precisa, consulte Avaliadores.

Suporte para conversas baseadas em texto

Para avaliadores que dão suporte a conversas de texto, você pode fornecer conversation como entrada. Essa entrada inclui um dicionário Python com uma lista de messages, que inclui content, rolee opcionalmente context.

Confira a seguinte conversa de duas etapas 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 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 a primeira volta da conversa fornece query de user, contextde assistant e response de assistant válidos no formato de consulta-resposta. Em seguida, as conversas são avaliadas por turno e os resultados são agregados em todos os turnos para chegar a uma pontuação de conversa.

Para o modo de conversação, 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 de conversação, os resultados por turno são armazenados em uma lista e a média da pontuação total da conversa 'groundedness': 4.0 é calculada 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 para imagens e texto e imagem multimodal

Para avaliadores de suporte para conversas para imagem e imagem multimodal e texto, passe URLs de imagem ou imagens codificadas em Base64 em conversation.

Os cenários com suporte incluem:

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

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 os avaliadores multimodais suportam:

• Somente 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 conversa menores que 10 MB, incluindo imagens.
• URLs absolutas e imagens codificadas em Base64.
• Várias imagens em um único turno.
• Formatos de arquivo JPG/JPEG, PNG e GIF.

Configuração

Quanto aos avaliadores de qualidade assistidos por IA (exceto para visualização GroundednessProEvaluator), especifique 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 de avaliação. Oferecemos suporte aos esquemas de configuração do modelo OpenAI ou do OpenAI do Azure. Para obter o melhor desempenho e as respostas analisáveis com nossos avaliadores, recomendamos usar modelos GPT que não estão em versão prévia.

Para todos os avaliadores de risco e segurança e GroundednessProEvaluator (versão prévia), em vez de uma implantação de GPT no model_config, você deve fornecer suas informações azure_ai_project. Isso acessa o serviço de avaliação de back-end usando seu projeto do Foundry.

Solicitações para avaliadores internos assistidos por IA

Com o fim de transparência, abrimos os prompts dos nossos avaliadores de qualidade em nossa Biblioteca de Avaliadores e no repositório do SDK do Python de Avaliação de IA do Azure, exceto para Avaliadores de Segurança e GroundednessProEvaluator, alimentados pela Segurança de Conteúdo de IA do Azure. Esses prompts servem como instruções para que um modelo de linguagem execute sua tarefa de avaliação, o que requer uma definição compreensível da métrica e suas rubricas de pontuação associadas. É altamente recomendável personalizar as definições e os critérios de avaliação para as especificidades do seu cenário. Para obter mais informações, consulte Avaliadores personalizados.

Avaliadores compostos

Os avaliadores compostos são avaliadores internos 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 chat.

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

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

Etapas de configuração de pré-requisitos para projetos do Microsoft Foundry

Se esta sessão for sua primeira vez executando avaliações e registrando-a em log em seu projeto do Foundry, talvez seja necessário executar as seguintes etapas de configuração:

1. Crie e conecte sua conta de armazenamento ao projeto do Foundry no nível do recurso. Esse modelo Bicep configura e conecta uma conta de armazenamento ao seu projeto Foundry com autenticação 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 o Microsoft Entra ID, certifique-se de conceder permissões de Microsoft Identity para Storage Blob Data Owner à sua conta e ao recurso do projeto Foundry no portal do Azure.

Avaliar um conjunto de dados e registrar resultados no 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"
)

O avaliador gera resultados em um dicionário, que contém dados agregados metrics e de nível de linha e métricas. Confira a seguinte saída de exemplo:

{'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 de chave de parâmetro do avaliador para exibir os gráficos de resultados de avaliação em seu projeto do Foundry corretamente.

Formato de dados

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

{
  "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 avaliadores internos, especifique o mapeamento de palavras-chave correto na lista de parâmetros evaluators. A tabela a seguir mostra o mapeamento de palavra-chave necessário para que os resultados de seus avaliadores internos apareçam na interface do usuário quando conectados ao projeto do 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 oferecerá suporte a um target parâmetro. Esse parâmetro envia consultas a um aplicativo para coletar respostas e, em seguida, executa seus avaliadores na consulta e resposta resultantes.

Um destino pode ser qualquer classe que possa ser chamada em seu diretório. Neste exemplo, há um script askwiki.py Python com uma classe askwiki() que pode ser chamada que é definida como o destino. Se você tiver um conjunto de dados de consultas que pode enviar para o aplicativo de askwiki simples, poderá avaliar a reação das saídas. Especifique o mapeamento de coluna adequado para seus dados em "column_mapping". Use "default" para especificar o mapeamento de coluna 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 clientes de Avaliação de IA do Azure para Python
• Solucionar problemas do SDK de Avaliação de IA
• Observabilidade na IA generativa
• Executar avaliações na nuvem usando o SDK do Microsoft Foundry
• Gerar dados sintéticos e simulados para avaliação
• Confira os resultados da avaliação no portal do Foundry
• Introdução ao Foundry
• Comece com os exemplos de avaliação