Aangepaste evaluators (klassiek)

Momenteel weergeven:Foundry -portalversie - (klassiek)Overschakelen naar versie voor de nieuwe Foundry-portal

Ingebouwde evaluators bieden een eenvoudige manier om de kwaliteit van de generaties van uw toepassing te bewaken. Als u uw evaluaties wilt aanpassen, kunt u uw eigen op code gebaseerde of op prompts gebaseerde evaluators maken.

Code-based evaluators

Je hebt geen groot taalmodel nodig voor bepaalde evaluatie-metrics. Code-gebaseerde evaluators geven je de flexibiliteit om metrics te definiëren op basis van functies of aanroepbare klassen. Je kunt bijvoorbeeld je eigen code-gebaseerde evaluator bouwen door een eenvoudige Python-klasse te maken die de lengte van een antwoord berekent in answer_length.py onder de directory answer_len/, zoals in het volgende voorbeeld.

Voorbeeld van een code-gebaseerde evaluator: Antwoordlengte

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

Voer de evaluator uit op een rij data door een aanroepbare klasse te importeren:

from answer_len.answer_length import AnswerLengthEvaluator

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

Code-gebaseerde evaluatoroutput: Antwoordlengte

{"answer_length":27}

Prompt-based evaluators

Om je eigen prompt-gebaseerde grote taalmodel-evaluator of AI-ondersteunde annotator te bouwen, maak je een aangepaste evaluator op basis van een prompty-bestand .

Prompty is een bestand met de .prompty extensie voor het ontwikkelen van prompttemplates. De Prompty-asset is een markdown-bestand met een aangepaste voorpagina. De voorkant is in YAML-formaat. Het bevat metadatavelden die modelconfiguratie en verwachte invoer van de prompt definiëren.

Om de vriendelijkheid van een antwoord te meten, maak je een aangepaste evaluator genaamd FriendlinessEvaluator:

Voorbeeld van een promptgebaseerde evaluator: Vriendelijkheidsevaluator

Maak eerst een friendliness.prompty bestand aan dat de vriendelijkheidsmetriek en de beoordelingsrubriek definieert:

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

Maak vervolgens een klasse FriendlinessEvaluator aan om het prompty-bestand te laden en de uitvoer te verwerken met JSON-formaat:

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

Maak nu je eigen prompty-gebaseerde evaluator en voer die uit op een reeks data:

from friendliness.friend import FriendlinessEvaluator

friendliness_eval = FriendlinessEvaluator(model_config)

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

Prompt-gebaseerde evaluator output: Vriendelijkheidsevaluator

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

Related content

• Hoe batch-evaluatie op een dataset uit te voeren
• Hoe voer je batch-evaluatie uit op een target