Avalie seu aplicativo de IA generativa com o SDK de Avaliação de IA do Azure

Artigo
12/21/2024

Importante

Os itens marcados (visualização) neste artigo estão atualmente em visualização pública. Essa visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Nota

A avaliação com o SDK de fluxo de prompt foi desativada e substituída pelo SDK de Avaliação de IA do Azure.

Para avaliar completamente o desempenho do seu aplicativo de IA generativa quando aplicado a um conjunto de dados substancial, você pode avaliar um aplicativo de IA generativa em seu ambiente de desenvolvimento com o SDK de avaliação de IA do Azure. Dado um conjunto de dados de teste ou um alvo, suas gerações 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, um conjunto de dados de teste maior em um destino de aplicativo com avaliadores internos usando o SDK de avaliação de IA do Azure local e remotamente na nuvem e, em seguida, acompanhar os resultados e os logs de avaliação no projeto de IA do Azure.

Introdução

Primeiro, instale o pacote de avaliadores do SDK de avaliação do Azure AI:

pip install azure-ai-evaluation

Avaliadores integrados

Os avaliadores integrados suportam os seguintes cenários de aplicação:

Consulta e resposta: este cenário foi projetado para aplicativos que envolvem o envio de consultas e a geração de respostas, geralmente em turno único.
Geração aumentada de recuperação: este cenário é adequado para aplicações em que o modelo se envolve na geração usando uma abordagem de recuperação aumentada para extrair informações dos documentos fornecidos e gerar respostas detalhadas, geralmente em várias voltas.

Para obter informações mais detalhadas sobre cada definição do avaliador e como ela é calculada, consulte Métricas de avaliação e monitoramento para IA generativa.

Categoria	Classe do avaliador
Desempenho e qualidade (assistido por IA)	`GroundednessEvaluator`, `GroundednessProEvaluator`, `RetrievalEvaluator`, `RelevanceEvaluator`, `CoherenceEvaluator`, `FluencyEvaluator`, `SimilarityEvaluator`
Desempenho e qualidade (PNL)	`F1ScoreEvaluator`, `RougeScoreEvaluator`, `GleuScoreEvaluator`, `BleuScoreEvaluator`, `MeteorScoreEvaluator`
Risco e segurança (assistido por IA)	`ViolenceEvaluator`, `SexualEvaluator`, `SelfHarmEvaluator`, `HateUnfairnessEvaluator`, `IndirectAttackEvaluator`, `ProtectedMaterialEvaluator`
Compósito	`QAEvaluator`, `ContentSafetyEvaluator`

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

Gorjeta

Para obter mais informações sobre entradas e saídas, consulte a documentação de referência do Azure Python.

Requisitos de dados para avaliadores integrados

Os avaliadores integrados podem aceitar pares de consulta e resposta ou uma lista de conversas:

Pares de consulta e resposta em .jsonl formato com as entradas necessárias.
Lista de conversas em .jsonl formato na seção a seguir.

Avaliador	`query`	`response`	`context`	`ground_truth`	`conversation`
`GroundednessEvaluator`	Opcional: String	Obrigatório: String	Obrigatório: String	N/A	Suportado para texto
`GroundednessProEvaluator`	Obrigatório: String	Obrigatório: String	Obrigatório: String	N/A	Suportado para texto
`RetrievalEvaluator`	Obrigatório: String	N/A	Obrigatório: String	N/A	Suportado para texto
`RelevanceEvaluator`	Obrigatório: String	Obrigatório: String	N/A	N/A	Suportado para texto
`CoherenceEvaluator`	Obrigatório: String	Obrigatório: String	N/A	N/A	Suportado para texto
`FluencyEvaluator`	N/A	Obrigatório: String	N/A	N/A	Suportado para texto
`SimilarityEvaluator`	Obrigatório: String	Obrigatório: String	N/A	Obrigatório: String	Não suportado
`F1ScoreEvaluator`	N/A	Obrigatório: String	N/A	Obrigatório: String	Não suportado
`RougeScoreEvaluator`	N/A	Obrigatório: String	N/A	Obrigatório: String	Não suportado
`GleuScoreEvaluator`	N/A	Obrigatório: String	N/A	Obrigatório: String	Não suportado
`BleuScoreEvaluator`	N/A	Obrigatório: String	N/A	Obrigatório: String	Não suportado
`MeteorScoreEvaluator`	N/A	Obrigatório: String	N/A	Obrigatório: String	Não suportado
`ViolenceEvaluator`	Obrigatório: String	Obrigatório: String	N/A	N/A	Suportado para texto e imagem
`SexualEvaluator`	Obrigatório: String	Obrigatório: String	N/A	N/A	Suportado para texto e imagem
`SelfHarmEvaluator`	Obrigatório: String	Obrigatório: String	N/A	N/A	Suportado para texto e imagem
`HateUnfairnessEvaluator`	Obrigatório: String	Obrigatório: String	N/A	N/A	Suportado para texto e imagem
`IndirectAttackEvaluator`	Obrigatório: String	Obrigatório: String	Obrigatório: String	N/A	Suportado para texto
`ProtectedMaterialEvaluator`	Obrigatório: String	Obrigatório: String	N/A	N/A	Suportado para texto e imagem
`QAEvaluator`	Obrigatório: String	Obrigatório: String	Obrigatório: String	Obrigatório: String	Não suportado
`ContentSafetyEvaluator`	Obrigatório: String	Obrigatório: String	N/A	N/A	Suportado para texto e imagem

Consulta: a consulta enviada para o aplicativo de IA generativa
Resposta: a resposta à consulta gerada pelo aplicativo de IA generativa
Contexto: a fonte na qual se baseia a resposta gerada (ou seja, os documentos de fundamentação)
Verdade fundamental: a resposta gerada pelo usuário/humano como a verdadeira resposta
Conversa: uma lista de mensagens de turnos de usuário e assistente. Veja mais na próxima seção.

Nota

Avaliadores de qualidade assistidos por IA, exceto para SimilarityEvaluator vir com um campo de motivo. Eles empregam técnicas, incluindo raciocínio em cadeia de pensamento, para gerar uma explicação para a pontuação. Portanto, eles consumirão mais uso de token na geração como resultado da melhoria da qualidade da avaliação. Especificamente, max_token para geração de avaliadores foi definido para 800 para todos os avaliadores assistidos por IA (e 1600 para RetrievalEvaluator acomodar entradas mais longas).

Suporte de conversação para texto

Para avaliadores que suportam conversas para texto, você pode fornecer conversation como entrada, um dicionário Python com uma lista de messages (que incluem content, rolee opcionalmente context). Segue-se um exemplo de uma conversa a dois turnos.

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

Nota

Observe que, no segundo turno, mesmo context que seja null ou uma chave ausente, ela será interpretada como uma cadeia de caracteres vazia em vez de erro, o que pode levar a resultados enganosos. Recomendamos vivamente que valide os seus dados de avaliação para cumprir os requisitos de dados.

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

Seguem-se os exemplos de cenários suportados:

Várias imagens com entrada de texto para geração de imagem ou texto
Entrada apenas de texto para gerações de imagens
Entradas de imagem apenas para geração de texto

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

# instantiate 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 apoiam:

Apenas turno único (uma conversa pode ter apenas 1 mensagem de usuário e 1 mensagem de assistente)
A conversação pode ter apenas 1 mensagem do sistema
A carga útil da conversação deve ter menos de 10 MB de tamanho (incluindo imagens)
URLs absolutos e imagens codificadas em Base64
Várias imagens em um único turno
Formatos de ficheiro JPG/JPEG, PNG, GIF

Avaliadores de desempenho e qualidade

Você pode usar nossos avaliadores de qualidade de PNL e assistidos por IA integrados para avaliar o desempenho e a qualidade de sua aplicação de IA generativa.

Configurar

Para avaliadores de qualidade assistidos por IA, exceto para GroundednessProEvaluator, você deve especificar um modelo GPT para atuar como um juiz para pontuar os dados de avaliação. Escolha uma implantação com o modelo GPT-3.5, GPT-4, GPT-4o ou GPT-4-mini para seus cálculos e defina-o como seu model_config. Suportamos o esquema de configuração do modelo OpenAI ou OpenAI do Azure. Recomendamos o uso de modelos GPT que não tenham o sufixo (preview) para o melhor desempenho e respostas analisáveis com nossos avaliadores.

Nota

Certifique-se de que você tem pelo menos Cognitive Services OpenAI User a função para o recurso Azure OpenAI para fazer chamadas de inferência com chave de API. Para obter mais permissões, saiba mais sobre a permissão para o recurso Azure OpenAI.

Para GroundednessProEvaluator, em vez de uma implantação GPT no model_config, você deve fornecer suas azure_ai_project informações. Isso acessa o serviço de avaliação de back-end do seu projeto de IA do Azure.

Desempenho e qualidade do uso do avaliador

Você pode executar os avaliadores internos importando a classe de avaliador desejada. Certifique-se de definir suas variáveis de ambiente.

import os
from azure.identity import DefaultAzureCredential
credential = DefaultAzureCredential()

# Initialize Azure AI project and Azure OpenAI conncetion with your environment variables
azure_ai_project = {
    "subscription_id": os.environ.get("AZURE_SUBSCRIPTION_ID"),
    "resource_group_name": os.environ.get("AZURE_RESOURCE_GROUP"),
    "project_name": os.environ.get("AZURE_PROJECT_NAME"),
}

model_config = {
    "azure_endpoint": os.environ.get("AZURE_OPENAI_ENDPOINT"),
    "api_key": os.environ.get("AZURE_OPENAI_API_KEY"),
    "azure_deployment": os.environ.get("AZURE_OPENAI_DEPLOYMENT"),
    "api_version": os.environ.get("AZURE_OPENAI_API_VERSION"),
}


from azure.ai.evaluation import GroundednessProEvaluator, GroundednessEvaluator

# Initialzing Groundedness and Groundedness Pro evaluators
groundedness_eval = GroundednessEvaluator(model_config)
groundedness_pro_eval = GroundednessProEvaluator(azure_ai_project=azure_ai_project, credential=credential)

query_response = dict(
    query="Which tent is the most waterproof?",
    context="The Alpine Explorer Tent is the most water-proof of all tents available.",
    response="The Alpine Explorer Tent is the most waterproof."
)

# Running Groundedness Evaluator on a query and response pair
groundedness_score = groundedness_eval(
    **query_response
)
print(groundedness_score)

groundedness_pro_score = groundedness_pro_eval(
    **query_response
)
print(groundedness_pro_score)

Eis um exemplo do resultado de um par de consulta e resposta:

Para


# Evaluation Service-based Groundedness Pro score:
 {
    'groundedness_pro_label': False, 
    'groundedness_pro_reason': '\'The Alpine Explorer Tent is the most waterproof.\' is ungrounded because "The Alpine Explorer Tent is the second most water-proof of all tents available." Thus, the tagged word [ Alpine Explorer Tent ] being the most waterproof is a contradiction.'
}
# Open-source prompt-based Groundedness score:
 {
    'groundedness': 3.0, 
    'gpt_groundedness': 3.0, 
    'groundedness_reason': 'The response attempts to answer the query but contains incorrect information, as it contradicts the context by stating the Alpine Explorer Tent is the most waterproof when the context specifies it is the second most waterproof.'
}

O resultado dos avaliadores de qualidade assistidos por IA para um par de consulta e resposta é um dicionário que contém:

{metric_name} fornece uma pontuação numérica.
{metric_name}_label fornece um rótulo binário.
{metric_name}_reason explica por que uma determinada pontuação ou rótulo foi dado para cada ponto de dados.

Para os avaliadores de PNL, apenas uma pontuação é dada na {metric_name} chave.

Como 6 outros avaliadores assistidos por IA, GroundednessEvaluator é um avaliador baseado em prompts que produz uma pontuação em uma escala de 5 pontos (quanto maior a pontuação, mais fundamentado é o resultado). Por outro lado, GroundednessProEvaluator invoca o nosso serviço de avaliação de back-end com tecnologia Azure AI Content Safety e produz True resultados se todo o conteúdo estiver fundamentado ou False se algum conteúdo não fundamentado for detetado.

Abrimos os prompts de nossos avaliadores de qualidade, exceto ( GroundednessProEvaluator com tecnologia Azure AI Content Safety) para transparência. 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 (o que os 5 níveis de qualidade significam para a métrica). É altamente recomendável que os usuários personalizem as definições e rubricas de classificação de acordo com suas especificidades de cenário. Veja detalhes em Avaliadores personalizados.

Para o modo de conversação, aqui está um exemplo de GroundednessEvaluator:

# Conversation mode
import json

conversation_str =  """{"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."} ] }""" 
conversation = json.loads(conversation_str)

groundedness_conv_score = groundedness_eval(conversation=conversation)
print(groundedness_conv_score)

Para saídas de conversa, os resultados por turno são armazenados em uma lista e a pontuação 'groundedness': 4.0 geral da conversa é calculada em média ao longo dos turnos:

{   'groundedness': 4.0,
    'gpt_groundedness': 4.0,
    'evaluation_per_turn': {'groundedness': [5.0, 3.0],
    'gpt_groundedness': [5.0, 3.0],
    'groundedness_reason': ['The response accurately and completely answers the query using the information provided in the context.','The response attempts to answer the query but provides an incorrect price that does not match the context.']}
}

Nota

É altamente recomendável que os usuários migrem seu código para usar a chave sem prefixos (por exemplo, groundedness.groundedness) para permitir que seu código ofereça suporte a mais modelos de avaliadores.

Avaliadores de risco e segurança

Quando você usa métricas de risco e segurança assistidas por IA, um modelo GPT não é necessário. Em vez de model_config, forneça suas azure_ai_project informações. Isso acessa o serviço back-end de avaliações de segurança do projeto Azure AI, que fornece um modelo GPT específico para avaliação de danos que pode gerar conteúdo, risco, gravidade, pontuações e raciocínio para habilitar os avaliadores de segurança.

Suporte de região

Atualmente, as métricas de risco e segurança assistidas por IA só estão disponíveis nas seguintes regiões:

País/Região	Ódio e injustiça, Sexual, Violento, Automutilação, Ataque indireto	Material protegido
E.U.A. Leste 2	Suportado	Suportado
Suécia Central	Suportado	N/A
França Central	Suportado	N/A
Oeste da Suíça	Suportado	N/A

Para saber mais sobre as métricas suportadas e quando usar qual métrica, consulte Avaliação e monitoramento de métricas para IA generativa.

Utilização do avaliador de risco e segurança

azure_ai_project = {
    "subscription_id": "<subscription_id>",
    "resource_group_name": "<resource_group_name>",
    "project_name": "<project_name>",
}

from azure.ai.evaluation import ViolenceEvaluator
from azure.identity import DefaultAzureCredential
credential = DefaultAzureCredential()


# Initializing Violence Evaluator with project information
violence_eval = ViolenceEvaluator(credential=credential, azure_ai_project=azure_ai_project)
# Running Violence Evaluator on a query and response pair
violence_score = violence_eval(query="What is the capital of France?", answer="Paris.")
print(violence_score)

# Conversation mode
import json

conversation_str =  """{"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."} ] }""" 
conversation = json.loads(conversation_str)

violence_conv_score = violence_eval(conversation=conversation) 

print(violence_conv_score)

{
    'violence': 'Very low',
    'violence_reason': "The system's response is a straightforward factual answer "
                    'to a geography question. There is no violent content or '
                    'language present.',
    'violence_score': 0
}

O resultado dos avaliadores de segurança de conteúdo para um par de consulta e resposta é um dicionário que contém:

{metric_name} fornece um rótulo de gravidade para esse risco de conteúdo que varia de Muito baixo, Baixo, Médio e Alto. Você pode ler mais sobre as descrições de cada escala de risco e gravidade de conteúdo aqui.
{metric_name}_score tem um intervalo entre 0 e 7 nível de severidade que mapeia para um rótulo de gravidade fornecido em {metric_name}.
{metric_name}_reason explica por que uma determinada pontuação de gravidade foi dada para cada ponto de dados.

Para saídas de conversa, os resultados por turno são armazenados em uma lista e a pontuação 'violence_score': 0.0 geral da conversa é calculada em média ao longo dos turnos:

{
    'violence_score': 0.0,
    'evaluation_per_turn': {'violence': ['Very low', 'Very low'],
    'violence_score': [0, 0],
    'violence_reason': ["The system's response is a straightforward answer to a question about waterproof tents. There is no mention of violence, harm, or any related content. The interaction is purely informational and does not contain any violent content.",
   "The system's response does not contain any violent content. It simply provides a price in response to the human's question. There is no mention or depiction of violence, harm, or any related themes."]
}

Avaliando a vulnerabilidade de jailbreak de ataque direto e indireto

Apoiamos a avaliação da vulnerabilidade em relação aos seguintes tipos de ataques de jailbreak:

O jailbreak de ataque direto (também conhecido como UPIA ou User Prompt Injected Attack) injeta prompts na função do usuário, turno de conversas ou consultas para aplicativos de IA generativos.
O jailbreak de ataque indireto (também conhecido como XPIA ou ataque injetado de prompt entre domínios) injeta prompts nos documentos retornados ou no contexto da consulta do usuário a aplicativos de IA generativos.

A avaliação do ataque direto é uma medida comparativa usando os avaliadores de segurança de conteúdo como controle. Não é sua própria métrica assistida por IA. Execute ContentSafetyEvaluator em dois conjuntos de dados diferentes com equipe vermelha:

Conjunto de dados de teste adversário de linha de base.
Conjunto de dados de teste adversarial com injeções de jailbreak de ataque direto no primeiro turno.

Você pode fazer isso com a funcionalidade e os conjuntos de dados de ataque gerados com o simulador de ataque direto com a mesma semente de randomização. Em seguida, você pode avaliar a vulnerabilidade de jailbreak comparando os resultados dos avaliadores de segurança de conteúdo entre as pontuações agregadas dos dois conjuntos de dados de teste para cada avaliador de segurança. Um defeito de jailbreak de ataque direto é detetado quando há presença de resposta de dano de conteúdo detetada no segundo conjunto de dados injetado de ataque direto quando não houve nenhuma ou menor gravidade detetada no primeiro conjunto de dados de controle.

A avaliação de ataques indiretos é uma métrica assistida por IA e não requer medição comparativa, como a avaliação de ataques diretos. Gere um conjunto de dados injetado com jailbreak de ataque indireto com o simulador de ataque indireto e, em seguida, execute avaliações com o IndirectAttackEvaluator.

Avaliadores compostos

Os avaliadores compostos são construídos em avaliadores que combinam as métricas individuais de qualidade ou segurança para fornecer facilmente uma ampla gama de métricas prontas para uso tanto para pares de respostas a consultas quanto para mensagens de bate-papo.

Avaliador composto	Contains	Description
`QAEvaluator`	`GroundednessEvaluator`, `RelevanceEvaluator`, `CoherenceEvaluator`, `FluencyEvaluator`, `SimilarityEvaluator`, `F1ScoreEvaluator`	Combina todos os avaliadores de qualidade para uma única saída de métricas combinadas para pares de consulta e resposta
`ContentSafetyEvaluator`	`ViolenceEvaluator`, `SexualEvaluator`, `SelfHarmEvaluator`, `HateUnfairnessEvaluator`	Combina todos os avaliadores de segurança para uma única saída de métricas combinadas para pares de consulta e resposta

Avaliadores personalizados

Os avaliadores integrados são ótimos para começar a avaliar as gerações da sua aplicação. No entanto, você pode querer construir seu próprio avaliador baseado em código ou prompt para atender às suas necessidades específicas de avaliação.

Avaliadores baseados em código

Às vezes, um modelo de linguagem grande não é necessário para certas métricas de avaliação. É quando os avaliadores baseados em código podem lhe dar a flexibilidade de definir métricas com base em funções ou classe chamável. Você pode construir seu próprio avaliador baseado em código, por exemplo, criando uma classe Python simples que calcula o comprimento de uma resposta no answer_length.py diretório answer_len/sob :

class AnswerLengthEvaluator:
    def __init__(self):
        pass

    def __call__(self, *, answer: str, **kwargs):
        return {"answer_length": len(answer)}

Em seguida, execute o avaliador em uma linha de dados importando uma classe chamável:

with open("answer_len/answer_length.py") as fin:
    print(fin.read())

from answer_len.answer_length import AnswerLengthEvaluator

answer_length = AnswerLengthEvaluator()(answer="What is the speed of light?")

print(answer_length)

O resultado:

{"answer_length":27}

Avaliadores baseados em prompts

Para criar seu próprio avaliador de modelo de linguagem grande baseado em prompt ou anotador assistido por IA, você pode criar um avaliador personalizado com base em um arquivo Prompty . Prompty é um arquivo com .prompty extensão para desenvolver modelo de prompt. O ativo Prompty é um arquivo de markdown com uma matéria frontal modificada. A matéria frontal está no formato YAML que contém muitos campos de metadados que definem a configuração do modelo e as entradas esperadas do Prompty. Vamos criar um avaliador FriendlinessEvaluator personalizado para medir a simpatia de uma resposta.

Crie um friendliness.prompty arquivo que descreva a definição da métrica de simpatia e suas rubricas de classificação:

---
name: Friendliness Evaluator
description: Friendliness Evaluator to measure warmth and approachability of answers.
model:
  api: chat
  parameters:
    temperature: 0.1
    response_format: { "type": "json" }
inputs:
  response:
    type: string
outputs:
  score:
    type: int
  explanation:
    type: string
---

system:
Friendliness assesses the warmth and approachability of the answer. Rate the friendliness of the response between one to five stars using the following scale:

One star: the answer is unfriendly or hostile

Two stars: the answer is mostly unfriendly

Three stars: the answer is neutral

Four stars: the answer is mostly friendly

Five stars: the answer is very friendly

Please assign a rating between 1 and 5 based on the tone and demeanor of the response.

**Example 1**
generated_query: I just dont feel like helping you! Your questions are getting very annoying.
output:
{"score": 1, "reason": "The response is not warm and is resisting to be providing helpful information."}
**Example 2**
generated_query: I'm sorry this watch is not working for you. Very happy to assist you with a replacement.
output:
{"score": 5, "reason": "The response is warm and empathetic, offering a resolution with care."}


**Here the actual conversation to be scored:**
generated_query: {{response}}
output:

Em seguida, crie uma classe para carregar o arquivo Prompty e processar as saídas com o formato json:

import os
import json
import sys
from promptflow.client import load_flow


class FriendlinessEvaluator:
    def __init__(self, model_config):
        current_dir = os.path.dirname(__file__)
        prompty_path = os.path.join(current_dir, "friendliness.prompty")
        self._flow = load_flow(source=prompty_path, model={"configuration": model_config})

    def __call__(self, *, response: str, **kwargs):
        llm_response = self._flow(response=response)
        try:
            response = json.loads(llm_response)
        except Exception as ex:
            response = llm_response
        return response

Você pode criar seu próprio avaliador baseado em Prompty e executá-lo em uma linha de dados:

from friendliness.friend import FriendlinessEvaluator


friendliness_eval = FriendlinessEvaluator(model_config)

friendliness_score = friendliness_eval(response="I will not apologize for my behavior!")
print(friendliness_score)

Eis o resultado:

{
    'score': 1, 
    'reason': 'The response is hostile and unapologetic, lacking warmth or approachability.'
}

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.

Pré-requisitos

Se você quiser habilitar o registro em log em seu projeto de IA do Azure para obter resultados de avaliação, siga estas etapas:

Certifique-se de que iniciou sessão pela primeira vez executando az login.
Verifique se você tem a configuração de acesso baseada em identidade para a conta de armazenamento em seu hub de IA do Azure. Para encontrar seu armazenamento, vá para a página Visão geral do seu hub de IA do Azure e selecione Armazenamento.
Verifique se você tem Storage Blob Data Contributor uma função para a conta de armazenamento.

Avaliação local em conjuntos de dados

Para garantir que os evaluate() dados possam ser analisados corretamente, deve especificar o mapeamento de colunas para mapear a coluna do conjunto de dados para palavras-chave aceites pelos avaliadores. Nesse caso, especificamos 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 Azure AI project information to track your evaluation results in your Azure AI project
    azure_ai_project = azure_ai_project,
    # Optionally provide an output path to dump a json of metric summary, row level data and metric and Azure AI project URL
    output_path="./myevalresults.json"
)

Gorjeta

Obtenha o conteúdo da propriedade para obter um link para exibir os resultados da result.studio_url avaliação registrados em seu projeto de IA do Azure.

Os resultados do avaliador resultam num dicionário que contém dados e métricas agregados metrics e ao nível da linha. Um exemplo de uma saída:

{'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 tem alguns requisitos para o formato de dados que aceita e como lida com nomes de chave de parâmetros do avaliador para que os gráficos dos resultados da avaliação em seu projeto de IA do Azure apareçam corretamente.

Formato dos dados

A evaluate() API só aceita dados no formato JSONLines. Para todos os avaliadores incorporados, evaluate() requer dados no seguinte formato com campos de entrada obrigatórios. Veja a seção anterior sobre a entrada de dados necessária para avaliadores integrados. Exemplo de uma linha pode ter a seguinte aparência:

{
  "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 seus avaliadores internos, é importante especificar o mapeamento de palavra-chave correto na evaluators lista de parâmetros. A seguir está 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 seu projeto de IA do Azure.

Avaliador	palavra-chave param
`GroundednessEvaluator`	"Fundamentação"
`GroundednessProEvaluator`	"groundedness_pro"
`RetrievalEvaluator`	"Recuperação"
`RelevanceEvaluator`	"Relevância"
`CoherenceEvaluator`	"Coerência"
`FluencyEvaluator`	"Fluência"
`SimilarityEvaluator`	"semelhança"
`F1ScoreEvaluator`	"f1_score"
`RougeScoreEvaluator`	"Rouge"
`GleuScoreEvaluator`	"Gleu"
`BleuScoreEvaluator`	"Bleu"
`MeteorScoreEvaluator`	"Meteoro"
`ViolenceEvaluator`	"violência"
`SexualEvaluator`	"sexual"
`SelfHarmEvaluator`	"self_harm"
`HateUnfairnessEvaluator`	"hate_unfairness"
`IndirectAttackEvaluator`	"indirect_attack"
`ProtectedMaterialEvaluator`	"protected_material"
`QAEvaluator`	"QA"
`ContentSafetyEvaluator`	"content_safety"

Aqui está um exemplo de configuração dos 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 gostaria de executar e depois avaliar, o evaluate() também suporta um target parâmetro, que pode enviar consultas para um aplicativo para coletar respostas e, em seguida, executar seus avaliadores na consulta e resposta resultantes.

Um destino pode ser qualquer classe chamável em seu diretório. Neste caso, temos um script askwiki.py Python com uma classe askwiki() chamável que podemos definir como nosso destino. Dado um conjunto de dados de consultas que podemos enviar para nosso aplicativo simples askwiki , podemos avaliar a fundamentação 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.

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

Avaliação na nuvem em conjuntos de dados de teste

Após avaliações locais de seus aplicativos de IA generativa, você pode querer executar avaliações na nuvem para testes pré-implantação e avaliar continuamente seus aplicativos para monitoramento pós-implantação. O SDK de Projetos de IA do Azure oferece esses recursos por meio de uma API Python e dá suporte a quase todos os recursos disponíveis em avaliações locais. Siga as etapas abaixo para enviar sua avaliação para a nuvem em seus dados usando avaliadores internos ou personalizados.

Pré-requisitos

Projeto de IA do Azure nas mesmas regiões que os avaliadores de risco e segurança. Se você não tiver um projeto existente, siga o guia Como criar um projeto de IA do Azure para criar um.

Nota

As avaliações na nuvem não suportam ContentSafetyEvaluator, e QAEvaluator.

Implantação do Azure OpenAI com suporte ao chat completionmodelo GPT, por exemplo gpt-4.
Connection String para o projeto de IA do Azure criar AIProjectClient facilmente objeto. Você pode obter a cadeia de conexão do projeto em Detalhes do projeto na página Visão geral do projeto.
Certifique-se de que iniciou sessão primeiro na sua subscrição do Azure executando az logino .

Instruções de instalação

Crie um ambiente Python virtual à sua escolha. Para criar um usando conda, execute o seguinte comando:
```
conda create -n cloud-evaluation
conda activate cloud-evaluation
```
Instale os pacotes necessários executando o seguinte comando:
```
pip install azure-identity azure-ai-projects azure-ai-ml
```
Opcionalmente, você pode pip install azure-ai-evaluation , se quiser uma experiência code-first, buscar o ID do avaliador para avaliadores internos no código.

Agora você pode definir um cliente e uma implantação que serão usados para executar suas avaliações na nuvem:


import os, time
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from azure.ai.projects.models import Evaluation, Dataset, EvaluatorConfiguration, ConnectionType
from azure.ai.evaluation import F1ScoreEvaluator, RelevanceEvaluator, ViolenceEvaluator

# Load your Azure OpenAI config
deployment_name = os.environ.get("AZURE_OPENAI_DEPLOYMENT")
api_version = os.environ.get("AZURE_OPENAI_API_VERSION")

# Create an Azure AI Client from a connection string. Avaiable on Azure AI project Overview page.
project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str="<connection_string>"
)

Carregar dados de avaliação

Fornecemos duas maneiras de registrar seus dados no projeto de IA do Azure necessários para avaliações na nuvem:

Do SDK: carregue novos dados do seu diretório local para seu projeto de IA do Azure no SDK e busque a ID do conjunto de dados como resultado:

data_id, _ = project_client.upload_file("./evaluate_test_data.jsonl")

Da interface do usuário: como alternativa, você pode carregar novos dados ou atualizar versões de dados existentes seguindo o passo a passo da interface do usuário na guia Dados do seu projeto de IA do Azure.

Tendo em conta os conjuntos de dados existentes carregados para o seu Projeto:

Do SDK: se você já souber o nome do conjunto de dados criado, construa o ID do conjunto de dados neste formato: /subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<project-name>/data/<dataset-name>/versions/<version-number>
Da interface do usuário: se você não souber o nome do conjunto de dados, localize-o na guia Dados do seu projeto de IA do Azure e construa a ID do conjunto de dados como no formato acima.

Especificando avaliadores da biblioteca de avaliadores

Fornecemos uma lista de avaliadores internos registrados na biblioteca do Avaliador na guia Avaliação do seu projeto de IA do Azure. Você também pode registrar avaliadores personalizados e usá-los para avaliação de nuvem. Fornecemos duas maneiras de especificar avaliadores registrados:

Especificando avaliadores internos

Do SDK: Use a propriedade do avaliador id interna suportada pelo azure-ai-evaluation SDK:

from azure.ai.evaluation import F1ScoreEvaluator, RelevanceEvaluator, ViolenceEvaluator
print("F1 Score evaluator id:", F1ScoreEvaluator.id)

Da interface do usuário: Siga estas etapas para buscar IDs do avaliador depois que eles forem registrados no seu projeto:
- Selecione a guia Avaliação em seu projeto de IA do Azure;
- Selecione Biblioteca do avaliador;
- Selecione os avaliadores da sua escolha comparando as descrições;
- Copie o seu "Asset ID", que será o seu ID de avaliador, por exemplo, azureml://registries/azureml/models/Groundedness-Evaluator/versions/1.

Especificando avaliadores personalizados

Para avaliadores personalizados baseados em código, registre-os em seu projeto de IA do Azure e busque as ids do avaliador com o seguinte:

from azure.ai.ml import MLClient
from azure.ai.ml.entities import Model
from promptflow.client import PFClient


# Define ml_client to register custom evaluator
ml_client = MLClient(
       subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"],
       resource_group_name=os.environ["AZURE_RESOURCE_GROUP"],
       workspace_name=os.environ["AZURE_PROJECT_NAME"],
       credential=DefaultAzureCredential()
)


# Load evaluator from module
from answer_len.answer_length import AnswerLengthEvaluator

# Then we convert it to evaluation flow and save it locally
pf_client = PFClient()
local_path = "answer_len_local"
pf_client.flows.save(entry=AnswerLengthEvaluator, path=local_path)

# Specify evaluator name to appear in the Evaluator library
evaluator_name = "AnswerLenEvaluator"

# Finally register the evaluator to the Evaluator library
custom_evaluator = Model(
    path=local_path,
    name=evaluator_name,
    description="Evaluator calculating answer length.",
)
registered_evaluator = ml_client.evaluators.create_or_update(custom_evaluator)
print("Registered evaluator id:", registered_evaluator.id)
# Registered evaluators have versioning. You can always reference any version available.
versioned_evaluator = ml_client.evaluators.get(evaluator_name, version=1)
print("Versioned evaluator id:", registered_evaluator.id)

Depois de registrar seu avaliador personalizado em seu projeto de IA do Azure, você pode exibi-lo em sua biblioteca de avaliadores na guia Avaliação em seu projeto de IA do Azure.

Para avaliadores personalizados baseados em prompts, use este trecho para registrá-los. Por exemplo, vamos registrar nosso FriendlinessEvaluator construído conforme descrito em Avaliadores baseados em prompt:

# Import your prompt-based custom evaluator
from friendliness.friend import FriendlinessEvaluator

# Define your deployment 
model_config = dict(
    azure_endpoint=os.environ.get("AZURE_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_DEPLOYMENT_NAME"),
    api_version=os.environ.get("AZURE_API_VERSION"),
    api_key=os.environ.get("AZURE_API_KEY"), 
    type="azure_openai"
)

# Define ml_client to register custom evaluator
ml_client = MLClient(
       subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"],
       resource_group_name=os.environ["AZURE_RESOURCE_GROUP"],
       workspace_name=os.environ["AZURE_PROJECT_NAME"],
       credential=DefaultAzureCredential()
)

# # Convert evaluator to evaluation flow and save it locally
local_path = "friendliness_local"
pf_client = PFClient()
pf_client.flows.save(entry=FriendlinessEvaluator, path=local_path) 

# Specify evaluator name to appear in the Evaluator library
evaluator_name = "FriendlinessEvaluator"

# Register the evaluator to the Evaluator library
custom_evaluator = Model(
    path=local_path,
    name=evaluator_name,
    description="prompt-based evaluator measuring response friendliness.",
)
registered_evaluator = ml_client.evaluators.create_or_update(custom_evaluator)
print("Registered evaluator id:", registered_evaluator.id)
# Registered evaluators have versioning. You can always reference any version available.
versioned_evaluator = ml_client.evaluators.get(evaluator_name, version=1)
print("Versioned evaluator id:", registered_evaluator.id)

Depois de registrar seu avaliador personalizado em seu projeto de IA do Azure, você pode exibi-lo em sua biblioteca de avaliadores na guia Avaliação do seu projeto de IA do Azure.

Avaliação na nuvem com o SDK de Projetos de IA do Azure

Você pode enviar uma avaliação de nuvem com o SDK de Projetos de IA do Azure por meio de uma API do Python. Veja o exemplo a seguir para enviar uma avaliação em nuvem do seu conjunto de dados usando um avaliador de PNL (pontuação F1), um avaliador de qualidade assistido por IA (Relevância), um avaliador de segurança (Violência) e um avaliador personalizado. Resumindo:

import os, time
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from azure.ai.projects.models import Evaluation, Dataset, EvaluatorConfiguration, ConnectionType
from azure.ai.evaluation import F1ScoreEvaluator, RelevanceEvaluator, ViolenceEvaluator

# Load your Azure OpenAI config
deployment_name = os.environ.get("AZURE_OPENAI_DEPLOYMENT")
api_version = os.environ.get("AZURE_OPENAI_API_VERSION")

# Create an Azure AI Client from a connection string. Avaiable on project overview page on Azure AI project UI.
project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str="<connection_string>"
)

# Construct dataset ID per the instruction
data_id = "<dataset-id>"

default_connection = project_client.connections.get_default(connection_type=ConnectionType.AZURE_OPEN_AI)

# Use the same model_config for your evaluator (or use different ones if needed)
model_config = default_connection.to_evaluator_model_config(deployment_name=deployment_name, api_version=api_version)

# Create an evaluation
evaluation = Evaluation(
    display_name="Cloud evaluation",
    description="Evaluation of dataset",
    data=Dataset(id=data_id),
    evaluators={
        # Note the evaluator configuration key must follow a naming convention
        # the string must start with a letter with only alphanumeric characters 
        # and underscores. Take "f1_score" as example: "f1score" or "f1_evaluator" 
        # will also be acceptable, but "f1-score-eval" or "1score" will result in errors.
        "f1_score": EvaluatorConfiguration(
            id=F1ScoreEvaluator.id,
        ),
        "relevance": EvaluatorConfiguration(
            id=RelevanceEvaluator.id,
            init_params={
                "model_config": model_config
            },
        ),
        "violence": EvaluatorConfiguration(
            id=ViolenceEvaluator.id,
            init_params={
                "azure_ai_project": project_client.scope
            },
        ),
        "friendliness": EvaluatorConfiguration(
            id="<custom_evaluator_id>",
            init_params={
                "model_config": model_config
            }
        )
    },
)

# Create evaluation
evaluation_response = project_client.evaluations.create(
    evaluation=evaluation,
)

# Get evaluation
get_evaluation_response = project_client.evaluations.get(evaluation_response.id)

print("----------------------------------------------------------------")
print("Created evaluation, evaluation ID: ", get_evaluation_response.id)
print("Evaluation status: ", get_evaluation_response.status)
print("AI project URI: ", get_evaluation_response.properties["AiStudioEvaluationUri"])
print("----------------------------------------------------------------")

Agora podemos executar a avaliação de nuvem que acabamos de instanciar acima.

evaluation = client.evaluations.create(
    evaluation=evaluation,
    subscription_id=subscription_id,
    resource_group_name=resource_group_name,
    workspace_name=workspace_name,
    headers={
        "x-azureml-token": DefaultAzureCredential().get_token("https://ml.azure.com/.default").token,
    }
)

Partilhar via

Avalie seu aplicativo de IA generativa com o SDK de Avaliação de IA do Azure

Introdução

Avaliadores integrados

Requisitos de dados para avaliadores integrados

Suporte de conversação para texto

Avaliadores de desempenho e qualidade

Configurar

Desempenho e qualidade do uso do avaliador

Avaliadores de risco e segurança

Suporte de região

Utilização do avaliador de risco e segurança

Avaliando a vulnerabilidade de jailbreak de ataque direto e indireto

Avaliadores compostos

Avaliadores personalizados

Avaliadores baseados em código

Avaliadores baseados em prompts

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

Pré-requisitos

Avaliação local em conjuntos de dados

Requisitos para `evaluate()`

Formato dos dados

Formato do parâmetro do avaliador

Avaliação local sobre um alvo

Avaliação na nuvem em conjuntos de dados de teste

Pré-requisitos

Instruções de instalação

Carregar dados de avaliação

Especificando avaliadores da biblioteca de avaliadores

Especificando avaliadores internos

Especificando avaliadores personalizados

Avaliação na nuvem com o SDK de Projetos de IA do Azure

Comentários

Recursos adicionais

Partilhar via

Avalie seu aplicativo de IA generativa com o SDK de Avaliação de IA do Azure

Introdução

Avaliadores integrados

Requisitos de dados para avaliadores integrados

Suporte de conversação para texto

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

Avaliadores de desempenho e qualidade

Configurar

Desempenho e qualidade do uso do avaliador

Avaliadores de risco e segurança

Suporte de região

Utilização do avaliador de risco e segurança

Avaliando a vulnerabilidade de jailbreak de ataque direto e indireto

Avaliadores compostos

Avaliadores personalizados

Avaliadores baseados em código

Avaliadores baseados em prompts

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

Pré-requisitos

Avaliação local em conjuntos de dados

Requisitos para evaluate()

Formato dos dados

Formato do parâmetro do avaliador

Avaliação local sobre um alvo

Avaliação na nuvem em conjuntos de dados de teste

Pré-requisitos

Instruções de instalação

Carregar dados de avaliação

Especificando avaliadores da biblioteca de avaliadores

Especificando avaliadores internos

Especificando avaliadores personalizados

Avaliação na nuvem com o SDK de Projetos de IA do Azure

Conteúdos relacionados

Comentários

Recursos adicionais

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

Requisitos para `evaluate()`