Evaluadores personalizados (clásico)

Visualización actual:Versión - del portal de Foundry (clásico)Cambio a la versión del nuevo portal de Foundry

Los evaluadores integrados proporcionan una manera sencilla de supervisar la calidad de las generaciones de la aplicación. Para personalizar las evaluaciones, puede crear sus propios evaluadores basados en código o basados en mensajes.

Code-based evaluators

No necesitas un modelo de lenguaje grande para ciertas métricas de evaluación. Los evaluadores basados en código te dan la flexibilidad de definir métricas basadas en funciones o clases llamables. Por ejemplo, puedes construir tu propio evaluador basado en código creando una clase de Python sencilla que calcule la longitud de una respuesta en answer_length.py bajo el directorio answer_len/, como en el siguiente ejemplo.

Ejemplo de evaluador basado en código: Longitud de respuesta

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

Ejecuta el evaluador sobre una fila de datos importando una clase llamable:

from answer_len.answer_length import AnswerLengthEvaluator

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

Salida del evaluador basado en código: Longitud de la respuesta

{"answer_length":27}

Prompt-based evaluators

Para crear tu propio evaluador de grandes modelos de lenguaje basado en prompts o anotador asistido por IA, crea un evaluador personalizado basado en un archivo Prompty .

Prompty es un archivo con extensión .prompty para desarrollar plantillas de prompts. El activo de Prompty es un archivo de descuento con un material inicial modificado. El material inicial está en formato YAML. Contiene campos de metadatos que definen la configuración del modelo y las entradas esperadas del Prompty.

Para medir la amabilidad de una respuesta, crea un evaluador personalizado llamado FriendlinessEvaluator:

Ejemplo de evaluador basado en prompts: evaluador de amabilidad

Primero, crea un friendliness.prompty archivo que defina la métrica de amabilidad y su rúbrica de calificación:

---
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:

Luego crea una clase FriendlinessEvaluator para cargar el archivo Prompty y procesar las salidas con 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

Ahora, crea tu propio evaluador basado en prompty y ejecuta sobre una fila de datos:

from friendliness.friend import FriendlinessEvaluator

friendliness_eval = FriendlinessEvaluator(model_config)

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

Salida del evaluador basada en prompts: Evaluador de amabilidad

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

Related content

• Cómo ejecutar una evaluación por lotes en un conjunto de datos
• Cómo realizar una evaluación por lotes en un objetivo