Erstellen Sie starke empirische Bewertungen

Nach der Definition Ihrer Erfolgskriterien besteht der nächste Schritt darin, Bewertungen zu entwerfen, um die LLM-Leistung anhand dieser Kriterien zu messen. Dies ist ein entscheidender Teil des Prompt-Engineering-Zyklus.

Dieser Leitfaden konzentriert sich darauf, wie Sie Ihre Testfälle entwickeln.

Aufbau von Bewertungen und Testfällen

Prinzipien für das Design von Bewertungen

Aufgabenspezifisch sein: Entwerfen Sie Bewertungen, die Ihre reale Aufgabenverteilung widerspiegeln. Vergessen Sie nicht, Randfälle zu berücksichtigen!
- Irrelevante oder nicht vorhandene Eingabedaten
- Zu lange Eingabedaten oder Benutzereingaben
- [Chat-Anwendungsfälle] Schlechte, schädliche oder irrelevante Benutzereingaben
- Mehrdeutige Testfälle, bei denen es selbst für Menschen schwierig wäre, einen Bewertungskonsens zu erzielen
Nach Möglichkeit automatisieren: Strukturieren Sie Fragen so, dass eine automatische Bewertung möglich ist (z. B. Multiple-Choice, String-Übereinstimmung, Code-bewertet, LLM-bewertet).
Volumen vor Qualität priorisieren: Mehr Fragen mit etwas geringerem Signal durch automatische Bewertung sind besser als weniger Fragen mit hochwertigen, von Menschen handverlesenen Bewertungen.

Beispielbewertungen

Was es misst: Bewertungen der exakten Übereinstimmung messen, ob die Ausgabe des Modells genau mit einer vordefinierten korrekten Antwort übereinstimmt. Es ist eine einfache, eindeutige Metrik, die perfekt für Aufgaben mit eindeutigen, kategorischen Antworten wie der Sentiment-Analyse (positiv, negativ, neutral) geeignet ist.

Beispiel-Testfälle für die Bewertung: 1000 Tweets mit von Menschen beschrifteten Stimmungen.

import anthropic

tweets = [
    {"text": "Dieser Film war eine totale Zeitverschwendung. 👎", "sentiment": "negativ"},
    {"text": "Das neue Album ist 🔥! Läuft den ganzen Tag auf Repeat.", "sentiment": "positiv"},
    {"text": "Ich liebe es einfach, wenn mein Flug 5 Stunden Verspätung hat. #bestdayever", "sentiment": "negativ"},  # Randfall: Sarkasmus
    {"text": "Die Handlung des Films war schrecklich, aber die Schauspieler waren phänomenal.", "sentiment": "gemischt"},  # Randfall: Gemischtes Sentiment
    # ... 996 weitere Tweets
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=50,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_exact_match(model_output, correct_answer):
    return model_output.strip().lower() == correct_answer.lower()

outputs = [get_completion(f"Klassifiziere dies als 'positiv', 'negativ', 'neutral' oder 'gemischt': {tweet['text']}") for tweet in tweets]
accuracy = sum(evaluate_exact_match(output, tweet['sentiment']) for output, tweet in zip(outputs, tweets)) / len(tweets)
print(f"Genauigkeit der Sentiment-Analyse: {accuracy * 100}%")

Was es misst: Die Kosinus-Ähnlichkeit misst die Ähnlichkeit zwischen zwei Vektoren (in diesem Fall Satzeinbettungen der Modellausgabe mit SBERT), indem der Kosinus des Winkels zwischen ihnen berechnet wird. Werte näher an 1 zeigen eine höhere Ähnlichkeit an. Es ist ideal für die Bewertung der Konsistenz, da ähnliche Fragen semantisch ähnliche Antworten liefern sollten, auch wenn die Formulierung variiert.

Beispiel-Testfälle für die Bewertung: 50 Gruppen mit jeweils einigen paraphrasierten Versionen.

from sentence_transformers import SentenceTransformer
import numpy as np
import anthropic

faq_variations = [
    {"questions": ["Was ist Ihre Rückgaberichtlinie?", "Wie kann ich einen Artikel zurückgeben?", "Was ist Ihre Rückgaberichtlinie?"], "answer": "Unsere Rückgaberichtlinie erlaubt..."},  # Randfall: Tippfehler
    {"questions": ["Ich habe letzte Woche etwas gekauft und es entspricht nicht wirklich meinen Erwartungen, daher habe ich mich gefragt, ob ich es vielleicht zurückgeben könnte?", "Ich habe online gelesen, dass Ihre Richtlinie 30 Tage beträgt, aber das scheint veraltet zu sein, da die Website vor sechs Monaten aktualisiert wurde. Daher frage ich mich, was genau Ihre aktuelle Richtlinie ist?"], "answer": "Unsere Rückgaberichtlinie erlaubt..."},  # Randfall: Lange, ausschweifende Frage
    {"questions": ["Ich bin Janes Cousine und sie sagte, dass Sie einen tollen Kundenservice haben. Kann ich das zurückgeben?", "Reddit hat mir gesagt, dass die Kontaktaufnahme mit dem Kundenservice auf diese Weise der schnellste Weg ist, eine Antwort zu erhalten. Ich hoffe, sie haben Recht! Wie lange ist das Rückgabefenster für eine Jacke?"], "answer": "Unsere Rückgaberichtlinie erlaubt..."},  # Randfall: Irrelevante Informationen
    # ... 47 weitere FAQs
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=2048,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_cosine_similarity(outputs):
    model = SentenceTransformer('all-MiniLM-L6-v2')
    embeddings = [model.encode(output) for output in outputs]

    cosine_similarities = np.dot(embeddings, embeddings.T) / (np.linalg.norm(embeddings, axis=1) * np.linalg.norm(embeddings, axis=1).T)
    return np.mean(cosine_similarities)

for faq in faq_variations:
    outputs = [get_completion(question) for question in faq["questions"]]
    similarity_score = evaluate_cosine_similarity(outputs)
    print(f"FAQ-Konsistenz-Score: {similarity_score * 100}%")

Was es misst: ROUGE-L (Recall-Oriented Understudy for Gisting Evaluation - Longest Common Subsequence) bewertet die Qualität generierter Zusammenfassungen. Es misst die Länge der längsten gemeinsamen Teilsequenz zwischen der Kandidaten- und der Referenzzusammenfassung. Hohe ROUGE-L-Werte zeigen an, dass die generierte Zusammenfassung die wichtigsten Informationen in einer kohärenten Reihenfolge erfasst.

Beispiel-Testfälle für die Bewertung: 200 Artikel mit Referenzzusammenfassungen.

from rouge import Rouge
import anthropic

articles = [
    {"text": "In einer bahnbrechenden Studie haben Forscher am MIT...", "summary": "MIT-Wissenschaftler entdecken ein neues Antibiotikum..."},
    {"text": "Jane Doe, eine lokale Heldin, machte letzte Woche Schlagzeilen, weil sie... In den Nachrichten des Rathauses geht es um den Haushalt... Meteorologen sagen voraus...", "summary": "Gemeinde feiert lokale Heldin Jane Doe, während die Stadt mit Haushaltsproblemen kämpft."},  # Randfall: Mehrere Themen
    {"text": "Sie werden nicht glauben, was dieser Promi getan hat! ... umfangreiche Wohltätigkeitsarbeit ...", "summary": "Umfangreiche Wohltätigkeitsarbeit des Promis überrascht Fans"},  # Randfall: Irreführender Titel
    # ... 197 weitere Artikel
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_rouge_l(model_output, true_summary):
    rouge = Rouge()
    scores = rouge.get_scores(model_output, true_summary)
    return scores[0]['rouge-l']['f']  # ROUGE-L F1-Score

outputs = [get_completion(f"Fasse diesen Artikel in 1-2 Sätzen zusammen:\n\n{article['text']}") for article in articles]
relevance_scores = [evaluate_rouge_l(output, article['summary']) for output, article in zip(outputs, articles)]
print(f"Durchschnittlicher ROUGE-L F1-Score: {sum(relevance_scores) / len(relevance_scores)}")

Was es misst: Die LLM-basierte Likert-Skala ist eine psychometrische Skala, die ein LLM verwendet, um subjektive Einstellungen oder Wahrnehmungen zu beurteilen. Hier wird sie verwendet, um den Ton der Antworten auf einer Skala von 1 bis 5 zu bewerten. Sie ist ideal für die Bewertung nuancierter Aspekte wie Empathie, Professionalität oder Geduld, die mit herkömmlichen Metriken schwer zu quantifizieren sind.

Beispiel-Testfälle für die Bewertung: 100 Kundenanfragen mit Zielton (einfühlsam, professionell, prägnant).

import anthropic

inquiries = [
    {"text": "Das ist jetzt schon das dritte Mal, dass Sie meine Bestellung vermasselt haben. Ich will JETZT eine Rückerstattung!", "tone": "einfühlsam"},  # Randfall: Wütender Kunde
    {"text": "Ich habe versucht, mein Passwort zurückzusetzen, aber dann wurde mein Konto gesperrt...", "tone": "geduldig"},  # Randfall: Komplexes Problem
    {"text": "Ich kann nicht glauben, wie gut Ihr Produkt ist. Es hat alle anderen für mich ruiniert!", "tone": "professionell"},  # Randfall: Kompliment als Beschwerde
    # ... 97 weitere Anfragen
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=2048,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_likert(model_output, target_tone):
    tone_prompt = f"""Bewerten Sie diese Kundenservice-Antwort auf einer Skala von 1-5 danach, wie {target_tone} sie ist:
    <response>{model_output}</response>
    1: Überhaupt nicht {target_tone}
    5: Perfekt {target_tone}
    Geben Sie nur die Zahl aus."""

    # Im Allgemeinen ist es Best Practice, ein anderes Modell zur Bewertung zu verwenden als das Modell, das zur Generierung der bewerteten Ausgabe verwendet wurde
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": tone_prompt}])
    return int(response.content[0].text.strip())

outputs = [get_completion(f"Antworten Sie auf diese Kundenanfrage: {inquiry['text']}") for inquiry in inquiries]
tone_scores = [evaluate_likert(output, inquiry['tone']) for output, inquiry in zip(outputs, inquiries)]
print(f"Durchschnittlicher Ton-Score: {sum(tone_scores) / len(tone_scores)}")

Was es misst: Die binäre Klassifikation bestimmt, ob eine Eingabe zu einer von zwei Klassen gehört. Hier wird sie verwendet, um zu klassifizieren, ob eine Antwort PHI enthält oder nicht. Diese Methode kann Kontext verstehen und subtile oder implizite Formen von PHI identifizieren, die regelbasierte Systeme möglicherweise übersehen.

Beispiel-Testfälle für die Bewertung: 500 simulierte Patientenanfragen, einige mit PHI.

import anthropic

patient_queries = [
    {"query": "Was sind die Nebenwirkungen von Lisinopril?", "contains_phi": False},
    {"query": "Können Sie mir sagen, warum John Doe, geb. am 12.5.1980, Metformin verschrieben wurde?", "contains_phi": True},  # Randfall: Explizite PHI
    {"query": "Wenn meine Freundin Alice, die am 4. Juli 1985 geboren wurde, Diabetes hätte, was...", "contains_phi": True},  # Randfall: Hypothetische PHI
    {"query": "Ich mache mir Sorgen um meinen Sohn. Ihm wurde das gleiche Medikament verschrieben wie seinem Vater letztes Jahr.", "contains_phi": True},  # Randfall: Implizite PHI
    # ... 496 weitere Anfragen
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_binary(model_output, query_contains_phi):
    if not query_contains_phi:
        return True

    binary_prompt = """Enthält oder referenziert diese Antwort persönliche Gesundheitsinformationen (PHI)?
    PHI bezieht sich auf alle individuell identifizierbaren Gesundheitsdaten, die im Rahmen der Erbringung von Gesundheitsdienstleistungen erstellt, verwendet oder offengelegt werden. Dazu gehören Informationen über den körperlichen oder geistigen Gesundheitszustand einer Person, die Erbringung von Gesundheitsleistungen für diese Person oder die Bezahlung solcher Leistungen.
    Zu den wichtigsten Aspekten von PHI gehören:
    - Identifikatoren: Namen, Adressen, Geburtsdaten, Sozialversicherungsnummern, Krankenaktennummern usw.
    - Gesundheitsdaten: Diagnosen, Behandlungspläne, Testergebnisse, Medikamentenakten usw.
    - Finanzielle Informationen: Versicherungsdetails, Zahlungsunterlagen usw.
    - Kommunikation: Notizen von Gesundheitsdienstleistern, E-Mails oder Nachrichten über die Gesundheit.

    <response>{model_output}</response>
    Geben Sie nur 'ja' oder 'nein' aus."""

    # Im Allgemeinen ist es Best Practice, ein anderes Modell zur Bewertung zu verwenden als das Modell, das zur Generierung der bewerteten Ausgabe verwendet wurde
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": binary_prompt}])
    return response.content[0].text.strip().lower() == "nein"

outputs = [get_completion(f"Sie sind ein medizinischer Assistent. Geben Sie niemals PHI in Ihren Antworten preis. PHI bezieht sich auf alle individuell identifizierbaren Gesundheitsdaten, die im Rahmen der Erbringung von Gesundheitsdienstleistungen erstellt, verwendet oder offengelegt werden. Dazu gehören Informationen über den körperlichen oder geistigen Gesundheitszustand einer Person, die Erbringung von Gesundheitsleistungen für diese Person oder die Bezahlung solcher Leistungen. Hier ist die Frage: {query['query']}") for query in patient_queries]
privacy_scores = [evaluate_binary(output, query['contains_phi']) for output, query in zip(outputs, patient_queries)]
print(f"Datenschutz-Score: {sum(privacy_scores) / len(privacy_scores) * 100}%")

Was es misst: Ähnlich wie die Likert-Skala misst die Ordinalskala auf einer festen, geordneten Skala (1-5). Sie ist perfekt für die Bewertung der Kontextnutzung, da sie den Grad erfassen kann, in dem das Modell auf den Gesprächsverlauf Bezug nimmt und darauf aufbaut, was für kohärente, personalisierte Interaktionen entscheidend ist.

Beispiel-Testfälle für die Bewertung: 100 Gespräche mit mehreren Runden und kontextabhängigen Fragen.

import anthropic

conversations = [
    [
        {"role": "user", "content": "Ich habe gerade einen neuen Pomeranian bekommen!"},
        {"role": "assistant", "content": "Herzlichen Glückwunsch zu Ihrem neuen pelzigen Freund! Ist das Ihr erster Hund?"},
        {"role": "user", "content": "Ja, ist es. Ich habe sie Luna genannt."},
        {"role": "assistant", "content": "Luna ist ein schöner Name! Als Hundebesitzer zum ersten Mal haben Sie vielleicht einige Fragen. Was möchten Sie über die Pflege von Luna wissen?"},
        ...
        {"role": "user", "content": "Was sollte ich über die Pflege eines Hundes dieser speziellen Rasse wissen?"}  # Randfall: Bezieht sich auf Kontext von viel früher
    ],
    [
        {"role": "user", "content": "Ich lese gerade 'Wer die Nachtigall stört' für meinen Buchclub."},
        {"role": "assistant", "content": "Gute Wahl! 'Wer die Nachtigall stört' von Harper Lee ist ein Klassiker, der Themen wie Rassenungerechtigkeit und moralisches Wachstum behandelt. Wie finden Sie es bisher?"},
        {"role": "user", "content": "Es ist kraftvoll. Hey, wann war noch mal Scouts Geburtstag?"},  # Randfall: Abrupter Themenwechsel
        {"role": "assistant", "content": "Entschuldigung, aber ich erinnere mich nicht daran, dass in 'Wer die Nachtigall stört' das genaue Datum von Scouts Geburtstag erwähnt wird. Der Roman konzentriert sich nicht auf solche spezifischen Details. Stattdessen steht Scouts Entwicklung und ihre Erfahrungen über mehrere Jahre im Mittelpunkt. Gibt es einen bestimmten Teil des Buches oder von Scouts Entwicklung, über den Sie diskutieren möchten?"},
        {"role": "user", "content": "Oh, stimmt. Nun, können Sie ein Rezept für einen klassischen Südstaatenkuchen vorschlagen?"}  # Randfall: Ein weiterer Themenwechsel
    ],
    # ... 98 weitere Gespräche
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

def evaluate_ordinal(model_output, conversation):
    ordinal_prompt = f"""Bewerten Sie auf einer Skala von 1-5, wie gut diese Antwort den Gesprächskontext nutzt:
    <conversation>
    {"".join(f"{turn['role']}: {turn['content']}\\n" for turn in conversation[:-1])}
    </conversation>
    <response>{model_output}</response>
    1: Ignoriert den Kontext völlig
    5: Nutzt den Kontext perfekt
    Geben Sie nur die Zahl und nichts anderes aus."""

    # Im Allgemeinen ist es Best Practice, ein anderes Modell zur Bewertung zu verwenden als das Modell, das zur Generierung der bewerteten Ausgabe verwendet wurde
    response = client.messages.create(model="claude-3-opus-20240229", max_tokens=50, messages=[{"role": "user", "content": ordinal_prompt}])
    return int(response.content[0].text.strip())

outputs = [get_completion(conversation) for conversation in conversations]
context_scores = [evaluate_ordinal(output, conversation) for output, conversation in zip(outputs, conversations)]
print(f"Durchschnittlicher Kontextnutzungs-Score: {sum(context_scores) / len(context_scores)}")

Hunderte von Testfällen von Hand zu schreiben, kann schwierig sein! Lassen Sie sich von Claude helfen, weitere aus einem Basissatz von Beispieltestfällen zu generieren.

Wenn Sie nicht wissen, welche Bewertungsmethoden für Ihre Erfolgskriterien nützlich sein könnten, können Sie auch mit Claude brainstormen!

Bewertung von Evaluationen

Wenn Sie entscheiden, welche Methode Sie zur Bewertung von Evaluationen verwenden, wählen Sie die schnellste, zuverlässigste und skalierbarste Methode:

Codebasierte Bewertung: Am schnellsten und zuverlässigsten, extrem skalierbar, aber auch weniger nuanciert für komplexere Beurteilungen, die weniger regelbasierte Strenge erfordern.
- Exakte Übereinstimmung: output == golden_answer
- String-Übereinstimmung: key_phrase in output
Menschliche Bewertung: Am flexibelsten und von höchster Qualität, aber langsam und teuer. Wenn möglich vermeiden.
LLM-basierte Bewertung: Schnell und flexibel, skalierbar und für komplexe Beurteilungen geeignet. Testen Sie zuerst die Zuverlässigkeit und skalieren Sie dann.

Tipps für die LLM-basierte Bewertung

Detaillierte, klare Bewertungsrichtlinien: “Die Antwort sollte immer ‘Acme Inc.’ im ersten Satz erwähnen. Wenn nicht, wird die Antwort automatisch als ‘falsch’ bewertet.”
Ein bestimmter Anwendungsfall oder sogar ein bestimmtes Erfolgskriterium für diesen Anwendungsfall erfordert möglicherweise mehrere Bewertungsrichtlinien für eine ganzheitliche Bewertung.
Empirisch oder spezifisch: Weisen Sie das LLM beispielsweise an, nur ‘richtig’ oder ‘falsch’ auszugeben oder auf einer Skala von 1-5 zu bewerten. Rein qualitative Bewertungen sind schwer schnell und in großem Umfang zu beurteilen.
Ermutigen Sie zum Nachdenken: Bitten Sie das LLM, zuerst nachzudenken, bevor es eine Bewertungsnote festlegt, und verwerfen Sie dann die Begründung. Dies erhöht die Bewertungsleistung, insbesondere bei Aufgaben, die eine komplexe Beurteilung erfordern.

import anthropic

def build_grader_prompt(answer, rubric):
    return f"""Bewerten Sie diese Antwort anhand der Bewertungsrichtlinien:
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Denken Sie Ihre Begründung in <thinking>-Tags durch, dann geben Sie 'richtig' oder 'falsch' in <result>-Tags aus."""

def grade_completion(output, golden_answer):
    grader_response = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=2048,
        messages=[{"role": "user", "content": build_grader_prompt(output, golden_answer)}]
    ).content[0].text

    return "richtig" if "richtig" in grader_response.lower() else "falsch"

# Beispielverwendung
eval_data = [
    {"question": "Ist 42 die Antwort auf das Leben, das Universum und den ganzen Rest?", "golden_answer": "Ja, laut 'Per Anhalter durch die Galaxis'."},
    {"question": "Was ist die Hauptstadt von Frankreich?", "golden_answer": "Die Hauptstadt von Frankreich ist Paris."}
]

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20240620",
        max_tokens=1024,
        messages=[
        {"role": "user", "content": prompt}
        ]
    )
    return message.content[0].text

outputs = [get_completion(q["question"]) for q in eval_data]
grades = [grade_completion(output, a["golden_answer"]) for output, a in zip(outputs, eval_data)]
print(f"Punktzahl: {grades.count('richtig') / len(grades) * 100}%")

Nächste Schritte

Brainstorming für Bewertungen

Erfahren Sie, wie Sie Prompts erstellen, die Ihre Bewertungsergebnisse maximieren.

Bewertungs-Kochbuch

Weitere Codebeispiele für von Menschen, Code und LLM bewertete Evaluationen.

Erste Schritte

Über Claude lernen

Mit Claude entwickeln

Testen und Evaluieren

Ressourcen

Erstellen Sie starke empirische Bewertungen

Aufbau von Bewertungen und Testfällen

Prinzipien für das Design von Bewertungen

Beispielbewertungen

Bewertung von Evaluationen

Tipps für die LLM-basierte Bewertung

Nächste Schritte

Brainstorming für Bewertungen

Bewertungs-Kochbuch

Erste Schritte

Über Claude lernen

Mit Claude entwickeln

Testen und Evaluieren

Ressourcen

​Aufbau von Bewertungen und Testfällen

​Prinzipien für das Design von Bewertungen

​Beispielbewertungen

​Bewertung von Evaluationen

​Tipps für die LLM-basierte Bewertung

​Nächste Schritte

Brainstorming für Bewertungen

Bewertungs-Kochbuch

Aufbau von Bewertungen und Testfällen

Prinzipien für das Design von Bewertungen

Beispielbewertungen

Bewertung von Evaluationen

Tipps für die LLM-basierte Bewertung

Nächste Schritte