Avaliadores personalizados (clássico)

A ver atualmente:Versão - portal Foundry (clássica)Mudar para a versão do novo portal da Foundry

Os avaliadores integrados fornecem uma forma fácil de monitorizar a qualidade das gerações da sua aplicação. Para personalizar as suas avaliações, pode criar os seus próprios avaliadores baseados em código ou em prompts.

Code-based evaluators

Não precisas de um modelo de linguagem grande para certas métricas de avaliação. Os avaliadores baseados em código dão-lhe flexibilidade para definir métricas baseadas em funções ou classes chamáveis. Pode construir o seu próprio avaliador baseado em código, por exemplo, criando uma classe Python simples que calcule o comprimento de uma resposta em answer_length.py sob o diretório answer_len/, como no exemplo seguinte.

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 numa 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 o seu próprio avaliador de grandes modelos de linguagem baseado em prompts ou anotador assistido por IA, crie um avaliador personalizado baseado num ficheiro Prompty .

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

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

Exemplo de avaliador baseado em prompts: Avaliador de cordialidade

Primeiro, crie um friendliness.prompty ficheiro que defina a métrica de amizade e a 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 ficheiro 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 o seu próprio avaliador baseado em Prompty e execute-o numa 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 uma avaliação em lote num conjunto de dados
• Como executar a avaliação em lote num alvo