Évaluateurs personnalisés (classique)

Affichage actuel :Version du portail - Foundry (classique)Passer à la version du nouveau portail Foundry

Les évaluateurs intégrés offrent un moyen simple de surveiller la qualité des générations de votre application. Pour personnaliser vos évaluations, vous pouvez créer vos propres évaluateurs basés sur du code ou à l’invite.

Code-based evaluators

Vous n’avez pas besoin d’un grand modèle de langage pour certaines métriques d’évaluation. Les évaluateurs basés sur le code vous offrent la flexibilité de définir des métriques basées sur des fonctions ou des classes appelables. Vous pouvez par exemple créer votre propre évaluateur basé sur le code en créant une classe Python simple qui calcule la longueur d’une réponse en answer_length.py sous le répertoire answer_len/, comme dans l’exemple suivant.

Exemple d’évaluateur basé sur le code : Longueur de la réponse

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

Exécutez l’évaluateur sur une ligne de données en important une classe appelable :

from answer_len.answer_length import AnswerLengthEvaluator

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

Sortie de l’évaluateur basée sur le code : Longueur de la réponse

{"answer_length":27}

Prompt-based evaluators

Pour créer votre propre évaluateur de grands modèles de langage basé sur des prompts ou un annotateur assisté par IA, créez un évaluateur personnalisé basé sur un fichier Prompty .

Prompty est un fichier avec l’extension .prompty pour développer des modèles de prompts. L’asset Prompty est un fichier à prix réduit avec un dossier de couverture modifié. Le contenu de la première page est au format YAML. Il contient des champs de métadonnées qui définissent la configuration du modèle et les entrées attendues du prompty.

Pour mesurer la convivialité d’une réponse, créez un évaluateur personnalisé nommé FriendlinessEvaluator:

Exemple d’évaluateur basé sur des prompts : évaluateur de la convivialité

Tout d’abord, créez un friendliness.prompty fichier qui définit la métrique d’amitié et sa grille d’évaluation :

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

Ensuite, créez une classe FriendlinessEvaluator pour charger le fichier Prompty et traitez les sorties au format 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

Maintenant, créez votre propre évaluateur basé sur Prompty et exécutez-le sur une ligne de données :

from friendliness.friend import FriendlinessEvaluator

friendliness_eval = FriendlinessEvaluator(model_config)

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

Sortie de l’évaluateur basée sur des prompts : évaluateur d’amitié

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

Related content

• Comment exécuter une évaluation par lots sur un jeu de données
• Comment effectuer une évaluation par lots sur une cible