Avaliadores personalizados (clássico)

Exibição no momento:Versão do portal - do Foundry (clássico)Alternar para a versão do novo portal do Foundry

Os avaliadores internos fornecem uma maneira fácil de monitorar a qualidade das gerações do aplicativo. Para personalizar suas avaliações, você pode criar seus próprios avaliadores baseados em código ou prompt.

Code-based evaluators

Você não precisa de um modelo de linguagem grande para certas métricas de avaliação. Avaliadores baseados em código oferecem flexibilidade para definir métricas baseadas em funções ou classes chamáveis. 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 em answer_length.py sob o diretório answer_len/, como no exemplo a seguir.

Exemplo de avaliador baseado em código: Comprimento da resposta

class AnswerLengthEvaluator:
    def __init__(self):
        pass
    # A class is made callable by implementing the special method __call__
    def __call__(self, *, answer: str, **kwargs):
        return {"answer_length": len(answer)}

Execute o avaliador em uma linha de dados importando uma classe chamável:

from answer_len.answer_length import AnswerLengthEvaluator

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

Saída do avaliador baseada em código: Comprimento da resposta

{"answer_length":27}

Prompt-based evaluators

Para construir seu próprio avaliador de grandes modelos de linguagem baseado em prompts ou anotador assistido por IA, crie um avaliador personalizado baseado em um arquivo Prompty .

Prompty é um arquivo com extensão .prompty para desenvolver templates de prompts. O ativo Prompty é um arquivo de desconto com uma matéria inicial modificada. A matéria inicial está no formato YAML. Ele contém campos de metadados que definem a configuração do modelo e as entradas esperadas do Prompty.

Para medir a amizade de uma resposta, crie um avaliador personalizado chamado FriendlinessEvaluator:

Exemplo de avaliador baseado em prompts: Avaliador de simpatia

Primeiro, crie um friendliness.prompty arquivo que defina a métrica de amizade e sua rubrica de avaliação:

---
name: Friendliness Evaluator
description: Friendliness Evaluator to measure warmth and approachability of answers.
model:
  api: chat
  configuration:
    type: azure_openai
    azure_endpoint: ${env:AZURE_OPENAI_ENDPOINT}
    azure_deployment: gpt-4o-mini
  parameters:
    model:
    temperature: 0.1
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 don't 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:

Depois, crie uma classe FriendlinessEvaluator para carregar o arquivo Prompty e processe as saídas com 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

Agora, crie seu próprio avaliador baseado em Prompty e o execute 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!")

Resultado do avaliador baseado em prompts: Avaliador de amizade

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

Related content

• Como executar avaliação em lote em um conjunto de dados
• Como executar avaliação em lote em um alvo