Avaliadores personalizados

2025-05-19

Avaliadores integrados são ótimos para começar a avaliar as gerações do seu 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. Você pode criar seu avaliador baseado em código, por exemplo, criando uma classe Python simples que calcula o comprimento de uma resposta em answer_length.py no diretório answer_len/:

Exemplo do avaliador baseado em código: comprimento da resposta

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

Em seguida, execute o avaliador em uma linha de dados importando uma classe que pode ser chamada:

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 baseado em código: comprimento da resposta

{"answer_length":27}

Avaliadores baseados em prompt

Para criar seu próprio avaliador de modelos de linguagem ampla baseado em prompts ou um anotador assistido por IA, você pode criar um avaliador 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 um cabeçalho modificado. A parte inicial 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 personalizado FriendlinessEvaluator para medir o quanto uma resposta é amigável.

Exemplo do avaliador baseado em prompt: avaliador friendliness

Primeiro, crie um friendliness.prompty arquivo que descreva a definição da métrica de friendliness e sua rubrica de classificaçã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:

Em seguida, crie uma classe FriendlinessEvaluator 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

Agora, 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!")

Saída do avaliador baseado em prompt: avaliador friendliness

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

Compartilhar via