Avaliar com o SDK de Avaliação da IA do Azure

Artigo
10/31/2024

Importante

Os itens marcados (versão prévia) neste artigo estão atualmente em versão prévia pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não recomendamos isso para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Observação

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

Para avaliar detalhadamente o desempenho do aplicativo de IA generativo quando aplicado a um conjunto de dados substancial, você pode avaliar em seu ambiente de desenvolvimento com o SDK de Avaliação da IA do Azure. Considerando um conjunto de dados de teste ou um destino, suas gerações de aplicativos de IA generativa 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ê aprende 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 da IA do Azure e, em seguida, acompanhar os resultados e os logs de avaliação no Estúdio de IA do Azure.

Introdução

Primeiro instale o pacote de avaliadores do SDK de avaliação da IA do Azure:

pip install azure-ai-evaluation

Avaliadores internos

Os avaliadores internos dão suporte aos seguintes cenários de aplicativo:

Consulta e resposta: esse 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: esse cenário é adequado para aplicativos em que o modelo se envolve na geração usando uma abordagem aumentada de recuperação para extrair informações de seus documentos fornecidos e gerar respostas detalhadas, geralmente em vários turnos.

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

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

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

Dica

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

Requisitos de dados para avaliadores internos

Os avaliadores internos podem aceitar ambos pares de consulta e repositório ou uma lista de conversas:

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

Avaliador	`query`	`response`	`context`	`ground_truth`	`conversation`
`GroundednessEvaluator`	N/D	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	Com suporte
`RelevanceEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	Com suporte
`CoherenceEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	N/D	Com suporte
`FluencyEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	N/D	Com suporte
`SimilarityEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	Obrigatório: cadeia de caracteres	Sem suporte
`RetrievalEvaluator`	N/D	N/D	N/D	N/D	Somente conversa com suporte
`F1ScoreEvaluator`	N/D	Obrigatório: cadeia de caracteres	N/D	Obrigatório: cadeia de caracteres	Sem suporte
`RougeScoreEvaluator`	N/D	Obrigatório: cadeia de caracteres	N/D	Obrigatório: cadeia de caracteres	Sem suporte
`GleuScoreEvaluator`	N/D	Obrigatório: cadeia de caracteres	N/D	Obrigatório: cadeia de caracteres	Sem suporte
`BleuScoreEvaluator`	N/D	Obrigatório: cadeia de caracteres	N/D	Obrigatório: cadeia de caracteres	Sem suporte
`MeteorScoreEvaluator`	N/D	Obrigatório: cadeia de caracteres	N/D	Obrigatório: cadeia de caracteres	Sem suporte
`ViolenceEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	N/D	Com suporte
`SexualEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	N/D	Com suporte
`SelfHarmEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	N/D	Com suporte
`HateUnfairnessEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	N/D	Com suporte
`IndirectAttackEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	Com suporte
`ProtectedMaterialEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	N/D	Com suporte
`QAEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	Sem suporte
`ContentSafetyEvaluator`	Obrigatório: cadeia de caracteres	Obrigatório: cadeia de caracteres	N/D	N/D	Com suporte

Consulta: a consulta enviada para o aplicativo de IA generativa
Resposta: a resposta à consulta gerada pelo aplicativo de IA generativa
Contexto: a origem à qual a resposta é gerada em relação (ou seja, aterramento de documentos)
Verdade básica: a resposta à consulta gerada pelo usuário/humano como a resposta verdadeira
Conversa: uma lista de mensagens de turnos do usuário e assistente. Veja mais sobre isso na próxima seção.

Avaliar conversas de vários turnos

Para avaliadores que dão suporte a conversas como entrada, basta passar a conversa diretamente para o avaliador:

relevance_score = relevance_eval(conversation=conversation)

Uma conversa é um dicionário do Python de uma lista de mensagens (que incluem conteúdo, função e, opcionalmente, contexto). Veja a seguir um exemplo de uma conversa de 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
        }
        ]
    }
}

As conversas são avaliadas por turno e os resultados são agregados em todas as voltas para uma pontuação de conversa.

Avaliadores de desempenho e qualidade

Ao usar métricas de qualidade e desempenho assistidas por IA, especifique um modelo GPT para o processo de cálculo.

Configuraçã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-a como seu model_config. Damos suporte ao esquema de configuração de modelo do Azure OpenAI ou OpenAI. É recomendável usar modelos GPT que não têm o sufixo (preview) para obter o melhor desempenho e respostas analisáveis com nossos avaliadores.

Uso do avaliador de desempenho e qualidade

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

import os

# Initialize Azure OpenAI Connection with your environment variables
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 RelevanceEvaluator

# Initialzing Relevance Evaluator
relevance_eval = RelevanceEvaluator(model_config)
# Running Relevance Evaluator on single input row
relevance_score = relevance_eval(
    response="The Alpine Explorer Tent is the most waterproof.",
    context="From the our product list,"
    " the alpine explorer tent is the most waterproof."
    " The Adventure Dining Table has higher weight.",
    query="Which tent is the most waterproof?",
)
print(relevance_score)

Veja um exemplo do resultado:

{'relevance.gpt_relevance': 5.0}

Avaliadores de risco e segurança

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

Suporte a regiões

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

Region	Ódio e injustiça, sexual, violento, automutilação, XPIA	Material protegido
Sul do Reino Unido	Será preterido em 01/12/24.	N/D
Leste dos EUA 2	Com suporte	Com suporte
Suécia Central	Com suporte	N/D
Centro-Norte dos EUA	Com suporte	N/D
França Central	Com suporte	N/D

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

Uso 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 single input row
violence_score = violence_eval(query="What is the capital of France?", answer="Paris.")
print(violence_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 do conteúdo é um dicionário que contém:

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

Avaliação da vulnerabilidade de jailbreak de ataque direto e indireto

Damos suporte à avaliação da vulnerabilidade para os seguintes tipos de ataques de desbloqueio por jailbreak:

O desbloqueio por jailbreak de ataque direto (também conhecido como UPIA ou Ataque Injetado de Prompt de Usuário) injeta prompts na rodada da função de usuário de conversas ou consultas em aplicativos de IA generativa.
O desbloqueio por jailbreak de ataque indireto (também conhecido como XPIA ou ataque injetado por prompt de domínio cruzado) injeta prompts nos documentos ou contexto retornados da consulta do usuário em aplicativos de IA generativa.

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

Conjunto de dados de teste de adversário de linha de base.
Conjunto de dados de teste de adversário com injeções de desbloqueio por jailbreak de ataque direto na primeira rodada.

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ê poderá avaliar a vulnerabilidade do 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 desbloqueio por jailbreak de ataque direto é detectado quando há resposta de danos de conteúdo detectada no segundo conjunto de dados injetado de ataque direto quando não havia nenhuma gravidade detectada no primeiro conjunto de dados de controle ou esta era baixa.

Avaliar o ataque indireto é uma métrica assistida por IA e não requer medida comparativa, como avaliar ataques diretos. Gere um conjunto de dados injetado de jailbreak de ataque indireto com o simulador de ataque indireto e, em seguida, avalie com o IndirectAttackEvaluator.

Avaliadores compostos

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

Avaliador composto	Contém	Descrição
`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 internos são ótimos para começar a avaliar as gerações do aplicativo. No entanto, você pode querer criar seu próprio avaliador baseado em código ou em 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 determinadas métricas de avaliação. É quando os avaliadores baseados em código podem dar a você a flexibilidade para definir métricas com base em funções ou classes que podem ser chamadas. Dada uma classe Python simples em um exemplo answer_length.py que calcula o comprimento de uma resposta:

class AnswerLengthEvaluator:
    def __init__(self):
        pass

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

Você pode criar seu próprio avaliador baseado em código e executá-lo em uma linha de dados importando uma classe que pode ser chamada:

with open("answer_length.py") as fin:
    print(fin.read())
from answer_length import AnswerLengthEvaluator

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

print(answer_length)

O resultado :

{"answer_length":27}

Registrar seu avaliador personalizado baseado em código em seu projeto de Estúdio de IA

# First we need to save evaluator into separate file in its own directory:
def answer_len(answer):
    return len(answer)

# Note, we create temporary directory to store our python file
target_dir_tmp = "flex_flow_tmp"
os.makedirs(target_dir_tmp, exist_ok=True)
lines = inspect.getsource(answer_len)
with open(os.path.join("flex_flow_tmp", "answer.py"), "w") as fp:
    fp.write(lines)

from flex_flow_tmp.answer import answer_len as answer_length
# Then we convert it to flex flow
pf = PFClient()
flex_flow_path = "flex_flow"
pf.flows.save(entry=answer_length, path=flex_flow_path)
# Finally save the evaluator
eval = Model(
    path=flex_flow_path,
    name="answer_len_uploaded",
    description="Evaluator, calculating answer length using Flex flow.",
)
flex_model = ml_client.evaluators.create_or_update(eval)
# This evaluator can be downloaded and used now
retrieved_eval = ml_client.evaluators.get("answer_len_uploaded", version=1)
ml_client.evaluators.download("answer_len_uploaded", version=1, download_path=".")
evaluator = load_flow(os.path.join("answer_len_uploaded", flex_flow_path))

Depois de registrar seu avaliador personalizado em seu projeto do AI Studio, você pode visualizá-lo em sua Biblioteca de avaliadores na guia Avaliação no AI Studio.

Avaliadores baseados em prompt

Para criar seu próprio avaliador de modelo de linguagem grande baseado em prompt, crie um avaliador ou anotador assistido por IA personalizado com base em um arquivo Prompty. Prompty é um arquivo com extensão .prompty para desenvolver o modelo do prompt. O ativo prompty é um arquivo 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. Dado um arquivo apology.prompty de exemplo semelhante ao seguinte:

---
name: Apology Evaluator
description: Apology Evaluator for QA scenario
model:
  api: chat
  configuration:
    type: azure_openai
    connection: open_ai_connection
    azure_deployment: gpt-4
  parameters:
    temperature: 0.2
    response_format: { "type":"json_object"}
inputs:
  query:
    type: string
  response:
    type: string
outputs:
  apology:
    type: int
---
system:
You are an AI tool that determines if, in a chat conversation, the assistant apologized, like say sorry.
Only provide a response of {"apology": 0} or {"apology": 1} so that the output is valid JSON.
Give a apology of 1 if apologized in the chat conversation.

Aqui estão alguns exemplos de conversas de chat e a resposta correta:

user: Where can I get my car fixed?
assistant: I'm sorry, I don't know that. Would you like me to look it up for you?
result:
{"apology": 1}

Esta é a conversa real a ser pontuada:

user: {{query}}
assistant: {{response}}
output:

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

with open("apology.prompty") as fin:
    print(fin.read())
from promptflow.client import load_flow

# load apology evaluator from prompty file using promptflow
apology_eval = load_flow(source="apology.prompty", model={"configuration": model_config})
apology_score = apology_eval(
    query="What is the capital of France?", response="Paris"
)
print(apology_score)

Eis o resultado:

{"apology": 0}

Registrar seu avaliador baseado em prompt personalizado em seu projeto de Estúdio de IA

# Define the path to prompty file.
prompty_path = os.path.join("apology-prompty", "apology.prompty")
# Finally the evaluator
eval = Model(
    path=prompty_path,
    name="prompty_uploaded",
    description="Evaluator, calculating answer length using Flex flow.",
)
flex_model = ml_client.evaluators.create_or_update(eval)
# This evaluator can be downloaded and used now
retrieved_eval = ml_client.evaluators.get("prompty_uploaded", version=1)
ml_client.evaluators.download("prompty_uploaded", version=1, download_path=".")
evaluator = load_flow(os.path.join("prompty_uploaded", "apology.prompty"))

Depois de registrar seu avaliador personalizado em seu projeto do AI Studio, você pode visualizá-lo em sua Biblioteca de avaliadores na guia Avaliação no AI Studio.

Avaliar no conjunto 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.

Antes de executar evaluate(), para garantir que você possa habilitar o registro em log e o rastreamento para seu projeto de IA do Azure, verifique se você está conectado pela primeira vez executando az login.

Depois instale o subpacote a seguir:

pip install azure-ai-evaluation[remote]

Para garantir que o evaluate() possa ser analisado corretamente, você deve especificar o mapeamento da coluna para mapear a coluna do conjunto de dados para as palavras-chave aceitas pelos avaliadores. Nesse caso, especificamos o mapeamento de dados para query, response e ground_truth.

from azure.ai.evaluation import evaluate

result = evaluate(
    data="data.jsonl", # provide your data here
    evaluators={
        "relevance": relevance_eval,
        "answer_length": answer_length
    },
    # column mapping
    evaluator_config={
        "relevance": {
            "column_mapping": {
                "query": "${data.queries}"
                "ground_truth": "${data.ground_truth}"
                "response": "${outputs.response}"
            } 
        }
    }
    # Optionally provide your AI Studio project information to track your evaluation results in your Azure AI Studio 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 studio URL
    output_path="./myevalresults.json"
)

Dica

Obtenha o conteúdo da propriedade result.studio_url para obter um link para exibir os resultados da avaliação registrada no Estúdio de IA do Azure.

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

{'metrics': {'answer_length.value': 49.333333333333336,
             'relevance.gpt_relevance': 5.0},
 'rows': [{'inputs.response': 'Paris is the capital of France.',
           'inputs.context': 'France is in Europe',
           'inputs.ground_truth': '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.relevance.gpt_relevance': 5},
          {'inputs.response': 'Albert Einstein developed the theory of '
                            'relativity.',
           'inputs.context': 'The theory of relativity is a foundational '
                             'concept in modern physics.',
           'inputs.ground_truth': '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.relevance.gpt_relevance': 5},
          {'inputs.response': 'The speed of light is approximately 299,792,458 '
                            'meters per second.',
           'inputs.context': 'Light travels at a constant speed in a vacuum.',
           'inputs.ground_truth': '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.relevance.gpt_relevance': 5}],
 'traces': {}}

Requisitos para `evaluate()`

A API evaluate() tem alguns requisitos quanto ao formato dos dados que aceita, assim como em relação ao tratamento dos nomes de chaves de parâmetros do avaliador, garantindo que os gráficos apresentados nos resultados da avaliação do Estúdio de IA sejam exibidos de maneira adequada.

Formato de dados

A API evaluate() aceita apenas dados no formato JSONLines. Para todos os avaliadores internos, evaluate() requer dados no formato a seguir com os campos de entrada necessários. Confira a seção anterior sobre a entrada de dados necessária para avaliadores internos. O exemplo de uma linha pode ser semelhante ao seguinte:

{
  "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 lista de parâmetros evaluators. Veja a seguir 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 Estúdio de IA do Azure.

Avaliador	parâmetro de palavra-chave
`RelevanceEvaluator`	"relevance"
`CoherenceEvaluator`	"coherence"
`GroundednessEvaluator`	"groundedness"
`FluencyEvaluator`	"fluency"
`SimilarityEvaluator`	"similarity"
`RetrievalEvaluator`	"recuperação"
`F1ScoreEvaluator`	"f1_score"
`RougeScoreEvaluator`	"rouge"
`GleuScoreEvaluator`	"gleu"
`BleuScoreEvaluator`	"bleu"
`MeteorScoreEvaluator`	"meteor"
`ViolenceEvaluator`	"violence"
`SexualEvaluator`	"sexual"
`SelfHarmEvaluator`	"self_harm"
`HateUnfairnessEvaluator`	"hate_unfairness"
`IndirectAttackEvaluator`	"ataque_indireto"
`ProtectedMaterialEvaluator`	"material_protegido"
`QAEvaluator`	"qa"
`ContentSafetyEvaluator`	"content_safety"

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

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

Avaliar em um destino

Se você tiver uma lista de consultas que gostaria de executar e avaliar, o evaluate() também dar suporte a um parâmetro target, que pode enviar consultas a um aplicativo para coletar respostas e, em seguida, executar seus avaliadores na consulta e nas respostas resultantes.

Um destino pode ser qualquer classe que possa ser chamada em seu diretório. Nesse caso, temos um script do Python askwiki.py com uma classe que pode ser chamada askwiki(), que podemos definir como destino. Dado um conjunto de dados de consultas que podemos enviar para nosso aplicativo simples askwiki, podemos avaliar a relevância dos resultados. Especifique o mapeamento de coluna adequado para seus dados em "column_mapping". Use "default" para especificar o mapeamento de coluna para todos os avaliadores.

from askwiki import askwiki

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

Compartilhar via

Avaliar com o SDK de Avaliação da IA do Azure

Introdução

Avaliadores internos

Requisitos de dados para avaliadores internos

Avaliar conversas de vários turnos

Avaliadores de desempenho e qualidade

Configuração

Uso do avaliador de desempenho e qualidade

Avaliadores de risco e segurança

Suporte a regiões

Uso do avaliador de risco e segurança

Avaliação da vulnerabilidade de jailbreak de ataque direto e indireto

Avaliadores compostos

Avaliadores personalizados

Avaliadores baseados em código

Registrar seu avaliador personalizado baseado em código em seu projeto de Estúdio de IA

Avaliadores baseados em prompt

Registrar seu avaliador baseado em prompt personalizado em seu projeto de Estúdio de IA

Avaliar no conjunto de dados de teste usando `evaluate()`

Requisitos para `evaluate()`

Formato de dados

Formato do parâmetro do avaliador

Avaliar em um destino

Comentários

Recursos adicionais

Compartilhar via

Avaliar com o SDK de Avaliação da IA do Azure

Introdução

Avaliadores internos

Requisitos de dados para avaliadores internos

Avaliar conversas de vários turnos

Avaliadores de desempenho e qualidade

Configuração

Uso do avaliador de desempenho e qualidade

Avaliadores de risco e segurança

Suporte a regiões

Uso do avaliador de risco e segurança

Avaliação da vulnerabilidade de jailbreak de ataque direto e indireto

Avaliadores compostos

Avaliadores personalizados

Avaliadores baseados em código

Registrar seu avaliador personalizado baseado em código em seu projeto de Estúdio de IA

Avaliadores baseados em prompt

Registrar seu avaliador baseado em prompt personalizado em seu projeto de Estúdio de IA

Avaliar no conjunto de dados de teste usando evaluate()

Requisitos para evaluate()

Formato de dados

Formato do parâmetro do avaliador

Avaliar em um destino

Conteúdo relacionado

Comentários

Recursos adicionais

Avaliar no conjunto de dados de teste usando `evaluate()`

Requisitos para `evaluate()`