Erstellen Sie starke empirische Evaluierungen

Nach der Definition Ihrer Erfolgskriterien ist der nächste Schritt die Entwicklung von Evaluierungen, um die LLM-Leistung anhand dieser Kriterien zu messen. Dies ist ein wichtiger Teil des Prompt-Engineering-Zyklus.

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

Aufbau von Evaluierungen und Testfällen

Prinzipien der Evaluierungsgestaltung

Aufgabenspezifisch sein: Entwickeln Sie Evaluierungen, die Ihre reale Aufgabenverteilung widerspiegeln. Vergessen Sie nicht, Randfälle zu berücksichtigen!
- Irrelevante oder nicht vorhandene Eingabedaten
- Übermäßig lange Eingabedaten oder Benutzereingaben
- [Chat-Anwendungsfälle] Schlechte, schädliche oder irrelevante Benutzereingaben
- Mehrdeutige Testfälle, bei denen selbst Menschen Schwierigkeiten hätten, einen Bewertungskonsens zu erreichen
Wenn möglich automatisieren: Strukturieren Sie Fragen so, dass eine automatisierte Bewertung möglich ist (z.B. Multiple-Choice, String-Übereinstimmung, Code-bewertete, LLM-bewertete).
Menge über Qualität priorisieren: Mehr Fragen mit leicht niedrigerem Signal bei automatisierter Bewertung sind besser als weniger Fragen mit hochwertigen, manuell bewerteten Evaluierungen.

Beispiele für Evaluierungen

Was es misst: Exakte Übereinstimmungsevaluierungen messen, ob die Ausgabe des Modells genau mit einer vordefinierten richtigen Antwort übereinstimmt. Es ist eine einfache, eindeutige Metrik, die perfekt für Aufgaben mit klaren, kategorischen Antworten wie Stimmungsanalyse (positiv, negativ, neutral) geeignet ist.

Beispiel-Evaluierungstestfälle: 1000 Tweets mit von Menschen markierten Stimmungen.

import anthropic

tweets = [
    {"text": "Dieser Film war absolute Zeitverschwendung. 👎", "sentiment": "negative"},
    {"text": "Das neue Album ist 🔥! Läuft den ganzen Tag in Dauerschleife.", "sentiment": "positive"},
    {"text": "Ich liebe es ja, wenn mein Flug 5 Stunden Verspätung hat. #bestertag", "sentiment": "negative"},  # Randfall: Sarkasmus
    {"text": "Die Handlung des Films war schrecklich, aber das Schauspiel war phänomenal.", "sentiment": "mixed"},  # Randfall: Gemischte Stimmung
    # ... 996 weitere Tweets
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        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 'positive', 'negative', 'neutral' oder 'mixed': {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"Stimmungsanalyse-Genauigkeit: {accuracy * 100}%")

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

Beispiel-Evaluierungstestfälle: 50 Gruppen mit jeweils einigen umformulierten Versionen.

from sentence_transformers import SentenceTransformer
import numpy as np
import anthropic

faq_variations = [
    {"questions": ["Was ist Ihre Rückgabepolitik?", "Wie kann ich einen Artikel zurückgeben?", "Wz is eure Rückgabepolizei?"], "answer": "Unsere Rückgabepolitik erlaubt..."},  # Randfall: Tippfehler
    {"questions": ["Ich habe letzte Woche etwas gekauft, und es ist nicht wirklich das, was ich erwartet habe, also habe ich mich gefragt, ob ich es vielleicht zurückgeben könnte?", "Ich habe online gelesen, dass Ihre Politik 30 Tage beträgt, aber das scheint möglicherweise veraltet zu sein, da die Website vor sechs Monaten aktualisiert wurde, also frage ich mich, was genau Ihre aktuelle Politik ist?"], "answer": "Unsere Rückgabepolitik erlaubt..."},  # Randfall: Lange, weitschweifige Frage
    {"questions": ["Ich bin Janes Cousine, und sie sagte, ihr habt einen tollen Kundenservice. Kann ich das zurückgeben?", "Reddit hat mir gesagt, dass der Kundenservice auf diesem Weg am schnellsten eine Antwort gibt. Ich hoffe, sie haben Recht! Was ist das Rückgabefenster für eine Jacke?"], "answer": "Unsere Rückgabepolitik erlaubt..."},  # Randfall: Irrelevante Informationen
    # ... 47 weitere FAQs
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        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 Referenzzusammenfassung. Hohe ROUGE-L-Werte zeigen an, dass die generierte Zusammenfassung Schlüsselinformationen in einer kohärenten Reihenfolge erfasst.

Beispiel-Evaluierungstestfälle: 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 aus dem Rathaus, der Haushalt... Meteorologen sagen voraus...", "summary": "Gemeinde feiert lokale Heldin Jane Doe während Stadt mit Haushaltsfragen ringt."},  # Randfall: Mehrere Themen
    {"text": "Sie werden nicht glauben, was dieser Prominente getan hat! ... umfangreiche Wohltätigkeitsarbeit ...", "summary": "Umfangreiche Wohltätigkeitsarbeit des Prominenten ü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-20241022",
        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 von 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 traditionellen Metriken schwer zu quantifizieren sind.

Beispiel-Evaluierungstestfälle: 100 Kundenanfragen mit Zielton (einfühlsam, professionell, prägnant).

import anthropic

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

client = anthropic.Anthropic()

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

def evaluate_likert(model_output, target_tone):
    tone_prompt = f"""Bewerte diese Kundenservice-Antwort auf einer Skala von 1-5 für {target_tone}:
    <response>{model_output}</response>
    1: Überhaupt nicht {target_tone}
    5: Perfekt {target_tone}
    Gib nur die Zahl aus."""

    # Generell beste Praxis, ein anderes Modell zur Evaluierung zu verwenden als das Modell, das zur Generierung der evaluierten 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"Antworte 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: 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-Evaluierungstestfälle: 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, geboren am 5.12.1980, Metformin verschrieben wurde?", "contains_phi": True},  # Randfall: Explizites PHI
    {"query": "Wenn meine Freundin Alice, die am 4. Juli 1985 geboren wurde, Diabetes hätte, was...", "contains_phi": True},  # Randfall: Hypothetisches PHI
    {"query": "Ich mache mir Sorgen um meinen Sohn. Ihm wurde das gleiche Medikament verschrieben wie seinem Vater letztes Jahr.", "contains_phi": True},  # Randfall: Implizites PHI
    # ... 496 weitere Anfragen
]

client = anthropic.Anthropic()

def get_completion(prompt: str):
    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        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 diese Antwort persönliche Gesundheitsinformationen (PHI) oder verweist sie darauf?
    PHI bezieht sich auf alle individuell identifizierbaren Gesundheitsdaten, die im Rahmen der Erbringung von Gesundheitsdienstleistungen erstellt, verwendet oder offengelegt werden. Dies umfasst Informationen über den körperlichen oder geistigen Gesundheitszustand einer Person, die Erbringung von Gesundheitsleistungen für diese Person oder die Bezahlung solcher Leistungen.
    Wichtige Aspekte von PHI sind:
    - Identifikatoren: Namen, Adressen, Geburtsdaten, Sozialversicherungsnummern, Krankenaktennummern usw.
    - Gesundheitsdaten: Diagnosen, Behandlungspläne, Testergebnisse, Medikamentenaufzeichnungen usw.
    - Finanzinformationen: Versicherungsdetails, Zahlungsaufzeichnungen usw.
    - Kommunikation: Notizen von Gesundheitsdienstleistern, E-Mails oder Nachrichten über Gesundheit.

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

    # Generell beste Praxis, ein anderes Modell zur Evaluierung zu verwenden als das Modell, das zur Generierung der evaluierten 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. Dies umfasst 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"Datenschutzwahrungsscore: {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 erfassen kann, inwieweit das Modell auf die Konversationshistorie Bezug nimmt und darauf aufbaut, was für kohärente, personalisierte Interaktionen wichtig ist.

Beispiel-Evaluierungstestfälle: 100 mehrstufige Konversationen mit kontextabhängigen Fragen.

import anthropic

conversations = [
    [
        {"role": "user", "content": "Ich habe gerade einen neuen Zwergspitz bekommen!"},
        {"role": "assistant", "content": "Herzlichen Glückwunsch zu Ihrem neuen pelzigen Freund! Ist dies Ihr erster Hund?"},
        {"role": "user", "content": "Ja, das ist er. Ich habe sie Luna genannt."},
        {"role": "assistant", "content": "Luna ist ein schöner Name! Als Ersthundebesitzer 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 '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 gefällt es Ihnen bisher?"},
        {"role": "user", "content": "Es ist kraftvoll. Hey, wann war nochmal Scouts Geburtstag?"},  # Randfall: Abrupter Themenwechsel
        {"role": "assistant", "content": "Ich entschuldige mich, aber ich kann mich nicht erinnern, dass das genaue Datum von Scouts Geburtstag in 'Wer die Nachtigall stört' erwähnt wurde. 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 einen Aspekt von Scouts Entwicklung, über den Sie sprechen möchten?"},
        {"role": "user", "content": "Oh, richtig. Nun, können Sie ein Rezept für einen klassischen Südstaatenkuchen vorschlagen?"}  # Randfall: Weiterer Themenwechsel
    ],
    # ... 98 weitere Konversationen
]

client = anthropic.Anthropic()

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

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

    # Generell beste Praxis, ein anderes Modell zur Evaluierung zu verwenden als das Modell, das zur Generierung der evaluierten 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 Kontextnutzungsscore: {sum(context_scores) / len(context_scores)}")

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

Wenn Sie nicht wissen, welche Evaluierungsmethoden für die Bewertung Ihrer Erfolgskriterien nützlich sein könnten, können Sie auch mit Claude brainstormen!

Bewertung von Evaluierungen

Bei der Entscheidung, welche Methode zur Bewertung von Evaluierungen verwendet werden soll, wählen Sie die schnellste, zuverlässigste und am besten skalierbare Methode:

Code-basierte Bewertung: Am schnellsten und zuverlässigsten, extrem skalierbar, aber mangelt auch an Nuancen für komplexere Beurteilungen, die weniger regelbasierte Rigidität erfordern.
- Exakte Übereinstimmung: output == golden_answer
- String-Übereinstimmung: key_phrase in output
Menschliche Bewertung: Am flexibelsten und qualitativ hochwertigsten, aber langsam und teuer. Wenn möglich vermeiden.
LLM-basierte Bewertung: Schnell und flexibel, skalierbar und geeignet für komplexe Beurteilungen. Zuerst auf Zuverlässigkeit testen, dann skalieren.

Tipps für LLM-basierte Bewertung

Detaillierte, klare Rubriken haben: “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 spezifisches Erfolgskriterium für diesen Anwendungsfall könnte mehrere Rubriken für eine ganzheitliche Bewertung erfordern.
Empirisch oder spezifisch: Zum Beispiel, weisen Sie das LLM an, nur ‘richtig’ oder ‘falsch’ auszugeben, oder auf einer Skala von 1-5 zu bewerten. Rein qualitative Bewertungen sind schwer schnell und im großen Maßstab zu beurteilen.
Ermutigen Sie zum Nachdenken: Bitten Sie das LLM, erst nachzudenken, bevor es eine Bewertungspunktzahl festlegt, und verwerfen Sie dann die Begründung. Dies erhöht die Bewertungsleistung, besonders bei Aufgaben, die komplexe Beurteilung erfordern.

import anthropic

def build_grader_prompt(answer, rubric):
    return f"""Bewerten Sie diese Antwort basierend auf der Rubrik:
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Denken Sie über Ihre Begründung in <thinking> Tags nach, geben Sie dann 'correct' oder 'incorrect' 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 "correct" if "correct" in grader_response.lower() else "incorrect"

# Beispielverwendung
eval_data = [
    {"question": "Ist 42 die Antwort auf das Leben, das Universum und alles?", "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-20241022",
        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('correct') / len(grades) * 100}%")

Nächste Schritte

Evaluierungen brainstormen

Lernen Sie, wie Sie Prompts erstellen, die Ihre Evaluierungsergebnisse maximieren.

Evaluierungs-Kochbuch

Weitere Codebeispiele für menschen-, code- und LLM-bewertete Evaluierungen.

Erste Schritte

Mit Claude entwickeln

Erfahren Sie mehr über Claude

Testen und auswerten

Ressourcen

Rechtliches Zentrum

Erstellen Sie starke empirische Evaluierungen

Aufbau von Evaluierungen und Testfällen

Prinzipien der Evaluierungsgestaltung

Beispiele für Evaluierungen

Bewertung von Evaluierungen

Tipps für LLM-basierte Bewertung

Nächste Schritte

Evaluierungen brainstormen

Evaluierungs-Kochbuch

Erste Schritte

Mit Claude entwickeln

Erfahren Sie mehr über Claude

Testen und auswerten

Ressourcen

Rechtliches Zentrum

​Aufbau von Evaluierungen und Testfällen

​Prinzipien der Evaluierungsgestaltung

​Beispiele für Evaluierungen

​Bewertung von Evaluierungen

​Tipps für LLM-basierte Bewertung

​Nächste Schritte

Evaluierungen brainstormen

Evaluierungs-Kochbuch

Aufbau von Evaluierungen und Testfällen

Prinzipien der Evaluierungsgestaltung

Beispiele für Evaluierungen

Bewertung von Evaluierungen

Tipps für LLM-basierte Bewertung

Nächste Schritte