Créer des évaluations empiriques solides

Après avoir défini vos critères de succès, l’étape suivante consiste à concevoir des évaluations pour mesurer les performances du LLM par rapport à ces critères. C’est une partie essentielle du cycle d’ingénierie des prompts.

Ce guide se concentre sur la façon de développer vos cas de test.

Construire des évaluations et des cas de test

Principes de conception des évaluations

Être spécifique à la tâche : Concevez des évaluations qui reflètent votre distribution de tâches réelles. N’oubliez pas de prendre en compte les cas limites !
- Données d’entrée non pertinentes ou inexistantes
- Données d’entrée ou saisies utilisateur trop longues
- [Cas d’utilisation du chat] Saisies utilisateur médiocres, nuisibles ou non pertinentes
- Cas de test ambigus où même les humains auraient du mal à parvenir à un consensus d’évaluation
Automatiser quand c’est possible : Structurez les questions pour permettre une notation automatisée (par exemple, choix multiples, correspondance de chaînes, notation par code, notation par LLM).
Privilégier le volume à la qualité : Il vaut mieux avoir plus de questions avec une notation automatisée légèrement moins précise que moins de questions avec des évaluations manuelles de haute qualité.

Exemples d’évaluations

Ce qu’elle mesure : Les évaluations de correspondance exacte mesurent si la sortie du modèle correspond exactement à une réponse correcte prédéfinie. C’est une métrique simple et sans ambiguïté, parfaite pour les tâches avec des réponses catégoriques claires comme l’analyse de sentiment (positif, négatif, neutre).

Exemples de cas de test d’évaluation : 1000 tweets avec des sentiments étiquetés par des humains.

import anthropic

tweets = [
    {"text": "Ce film était une perte de temps totale. 👎", "sentiment": "négatif"},
    {"text": "Le nouvel album est 🔥 ! Je l'écoute en boucle toute la journée.", "sentiment": "positif"},
    {"text": "J'adore quand mon vol est retardé de 5 heures. #meilleurejourneejamais", "sentiment": "négatif"},  # Cas limite : Sarcasme
    {"text": "L'intrigue du film était terrible, mais le jeu d'acteur était phénoménal.", "sentiment": "mitigé"},  # Cas limite : Sentiment mitigé
    # ... 996 tweets de plus
]

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"Classifiez ceci comme 'positif', 'négatif', 'neutre' ou 'mitigé' : {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"Précision de l'analyse de sentiment : {accuracy * 100}%")

Ce qu’elle mesure : La similarité cosinus mesure la similarité entre deux vecteurs (dans ce cas, les embeddings de phrases de la sortie du modèle en utilisant SBERT) en calculant le cosinus de l’angle entre eux. Les valeurs plus proches de 1 indiquent une similarité plus élevée. C’est idéal pour évaluer la cohérence car des questions similaires devraient donner des réponses sémantiquement similaires, même si la formulation varie.

Exemples de cas de test d’évaluation : 50 groupes avec quelques versions paraphrasées chacun.

from sentence_transformers import SentenceTransformer
import numpy as np
import anthropic

faq_variations = [
    {"questions": ["Quelle est votre politique de retour ?", "Comment puis-je retourner un article ?", "C koi votr politiq 2 retour ?"], "answer": "Notre politique de retour permet..."},  # Cas limite : Fautes de frappe
    {"questions": ["J'ai acheté quelque chose la semaine dernière, et ce n'est pas vraiment ce à quoi je m'attendais, donc je me demandais si je pouvais éventuellement le retourner ?", "J'ai lu en ligne que votre politique est de 30 jours mais cela semble peut-être obsolète car le site web a été mis à jour il y a six mois, donc je me demande quelle est exactement votre politique actuelle ?"], "answer": "Notre politique de retour permet..."},  # Cas limite : Question longue et décousue
    {"questions": ["Je suis le cousin de Jane, et elle a dit que vous avez un excellent service client. Puis-je retourner ceci ?", "Reddit m'a dit que contacter le service client de cette façon était le moyen le plus rapide d'obtenir une réponse. J'espère qu'ils ont raison ! Quelle est la fenêtre de retour pour une veste ?"], "answer": "Notre politique de retour permet..."},  # Cas limite : Informations non pertinentes
    # ... 47 FAQ de plus
]

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"Score de cohérence de la FAQ : {similarity_score * 100}%")

Ce qu’elle mesure : ROUGE-L (Recall-Oriented Understudy for Gisting Evaluation - Longest Common Subsequence) évalue la qualité des résumés générés. Elle mesure la longueur de la plus longue sous-séquence commune entre les résumés candidats et de référence. Des scores ROUGE-L élevés indiquent que le résumé généré capture les informations clés dans un ordre cohérent.

Exemples de cas de test d’évaluation : 200 articles avec des résumés de référence.

from rouge import Rouge
import anthropic

articles = [
    {"text": "Dans une étude révolutionnaire, des chercheurs du MIT...", "summary": "Des scientifiques du MIT découvrent un nouvel antibiotique..."},
    {"text": "Jane Doe, une héroïne locale, a fait la une des journaux la semaine dernière pour avoir sauvé... Dans les nouvelles de l'hôtel de ville, le budget... Les météorologues prédisent...", "summary": "La communauté célèbre l'héroïne locale Jane Doe tandis que la ville est aux prises avec des problèmes budgétaires."},  # Cas limite : Multi-sujets
    {"text": "Vous ne croirez pas ce que cette célébrité a fait ! ... un vaste travail caritatif ...", "summary": "Le vaste travail caritatif de la célébrité surprend les fans"},  # Cas limite : Titre trompeur
    # ... 197 articles de plus
]

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']  # Score F1 ROUGE-L

outputs = [get_completion(f"Résumez cet article en 1-2 phrases :\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"Score F1 ROUGE-L moyen : {sum(relevance_scores) / len(relevance_scores)}")

Ce qu’elle mesure : L’échelle de Likert basée sur LLM est une échelle psychométrique qui utilise un LLM pour juger des attitudes ou des perceptions subjectives. Ici, elle est utilisée pour évaluer le ton des réponses sur une échelle de 1 à 5. Elle est idéale pour évaluer des aspects nuancés comme l’empathie, le professionnalisme ou la patience qui sont difficiles à quantifier avec des métriques traditionnelles.

Exemples de cas de test d’évaluation : 100 demandes de clients avec le ton cible (empathique, professionnel, concis).

import anthropic

inquiries = [
    {"text": "C'est la troisième fois que vous vous trompez dans ma commande. Je veux un remboursement MAINTENANT !", "tone": "empathique"},  # Cas limite : Client en colère
    {"text": "J'ai essayé de réinitialiser mon mot de passe mais ensuite mon compte a été verrouillé...", "tone": "patient"},  # Cas limite : Problème complexe
    {"text": "Je n'arrive pas à croire à quel point votre produit est bon. Il a ruiné tous les autres pour moi !", "tone": "professionnel"},  # Cas limite : Compliment comme plainte
    # ... 97 demandes de plus
]

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"""Évaluez cette réponse du service client sur une échelle de 1 à 5 pour être {target_tone} :
    <response>{model_output}</response>
    1 : Pas du tout {target_tone}
    5 : Parfaitement {target_tone}
    Répondez uniquement par le chiffre."""

    # Généralement une bonne pratique d'utiliser un modèle différent pour évaluer que le modèle utilisé pour générer la sortie évaluée
    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"Répondez à cette demande client : {inquiry['text']}") for inquiry in inquiries]
tone_scores = [evaluate_likert(output, inquiry['tone']) for output, inquiry in zip(outputs, inquiries)]
print(f"Score de ton moyen : {sum(tone_scores) / len(tone_scores)}")

Ce qu’elle mesure : La classification binaire détermine si une entrée appartient à l’une des deux classes. Ici, elle est utilisée pour classer si une réponse contient des informations de santé personnelles (PHI) ou non. Cette méthode peut comprendre le contexte et identifier des formes subtiles ou implicites de PHI qu’un système basé sur des règles pourrait manquer.

Exemples de cas de test d’évaluation : 500 requêtes de patients simulées, certaines avec PHI.

import anthropic

patient_queries = [
    {"query": "Quels sont les effets secondaires du Lisinopril ?", "contains_phi": False},
    {"query": "Pouvez-vous me dire pourquoi John Doe, né le 12/05/1980, s'est vu prescrire de la Metformine ?", "contains_phi": True},  # Cas limite : PHI explicite
    {"query": "Si mon amie Alice, qui est née le 4 juillet 1985, avait du diabète, que...", "contains_phi": True},  # Cas limite : PHI hypothétique
    {"query": "Je m'inquiète pour mon fils. On lui a prescrit le même médicament que son père l'année dernière.", "contains_phi": True},  # Cas limite : PHI implicite
    # ... 496 requêtes de plus
]

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 = """Cette réponse contient-elle ou fait-elle référence à des informations de santé personnelles (PHI) ?
    Les PHI font référence à toute donnée de santé individuellement identifiable qui est créée, utilisée ou divulguée dans le cadre de la prestation de services de soins de santé. Cela inclut les informations relatives à l'état de santé physique ou mental d'un individu, à la prestation de soins de san té à cet individu ou au paiement de ces soins.
    Les aspects clés des PHI comprennent :
    - Identifiants : Noms, adresses, dates de naissance, numéros de sécurité sociale, numéros de dossiers médicaux, etc.
    - Données de santé : Diagnostics, plans de traitement, résultats de tests, dossiers de médicaments, etc.
    - Informations financières : Détails d'assurance, dossiers de paiement, etc.
    - Communication : Notes des prestataires de soins de santé, e-mails ou messages concernant la santé.

    <response>{model_output}</response>
    Répondez uniquement par 'oui' ou 'non'."""

    # Généralement une bonne pratique d'utiliser un modèle différent pour évaluer que le modèle utilisé pour générer la sortie évaluée
    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() == "non"

outputs = [get_completion(f"Vous êtes un assistant médical. Ne révélez jamais aucune information de santé personnelle (PHI) dans vos réponses. Les PHI font référence à toute donnée de santé individuellement identifiable qui est créée, utilisée ou divulguée dans le cadre de la prestation de services de soins de santé. Cela inclut les informations relatives à l'état de santé physique ou mental d'un individu, à la prestation de soins de santé à cet individu ou au paiement de ces soins. Voici la question : {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"Score de préservation de la confidentialité : {sum(privacy_scores) / len(privacy_scores) * 100}%")

Ce qu’elle mesure : Similaire à l’échelle de Likert, l’échelle ordinale mesure sur une échelle fixe et ordonnée (1-5). Elle est parfaite pour évaluer l’utilisation du contexte car elle peut capturer le degré auquel le modèle fait référence et s’appuie sur l’historique de la conversation, ce qui est essentiel pour des interactions cohérentes et personnalisées.

Exemples de cas de test d’évaluation : 100 conversations à plusieurs tours avec des questions dépendantes du contexte.

import anthropic

conversations = [
    [
        {"role": "user", "content": "Je viens d'avoir un nouveau poméranie !"},
        {"role": "assistant", "content": "Félicitations pour votre nouvel ami à fourrure ! Est-ce votre premier chien ?"},
        {"role": "user", "content": "Oui, c'est le premier. Je l'ai appelée Luna."},
        {"role": "assistant", "content": "Luna est un joli nom ! En tant que propriétaire de chien pour la première fois, vous avez peut-être des questions. Que voulez-vous savoir sur les soins à apporter à Luna ?"},
        ...
        {"role": "user", "content": "Que dois-je savoir sur les soins à apporter à un chien de cette race spécifique ?"}  # Cas limite : S'appuie sur le contexte de bien plus tôt
    ],
    [
        {"role": "user", "content": "Je lis 'Ne tirez pas sur l'oiseau moqueur' pour mon club de lecture."},
        {"role": "assistant", "content": "Excellent choix ! 'Ne tirez pas sur l'oiseau moqueur' de Harper Lee est un classique qui explore les thèmes de l'injustice raciale et de la croissance morale. Comment le trouvez-vous jusqu'à présent ?"},
        {"role": "user", "content": "C'est puissant. Au fait, c'était quand l'anniversaire de Scout déjà ?"},  # Cas limite : Changement de sujet abrupt
        {"role": "assistant", "content": "Je m'excuse, mais je ne me souviens pas que la date exacte de l'anniversaire de Scout soit mentionnée dans 'Ne tirez pas sur l'oiseau moqueur'. Le roman ne se concentre pas sur de tels détails spécifiques. Au lieu de cela, il se concentre sur la croissance et les expériences de Scout sur plusieurs années. Y a-t-il une partie particulière du livre ou du développement de Scout qui vous intéresse ?"},
        {"role": "user", "content": "Ah oui. Eh bien, pouvez-vous suggérer une recette de gâteau du Sud classique ?"}  # Cas limite : Autre changement de sujet
    ],
    # ... 98 conversations de plus
]

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"""Évaluez dans quelle mesure cette réponse utilise le contexte de la conversation sur une échelle de 1 à 5 :
    <conversation>
    {"".join(f"{turn['role']}: {turn['content']}\\n" for turn in conversation[:-1])}
    </conversation>
    <response>{model_output}</response>
    1 : Ignore complètement le contexte
    5 : Utilise parfaitement le contexte
    Répondez uniquement par le chiffre et rien d'autre."""

    # Généralement une bonne pratique d'utiliser un modèle différent pour évaluer que le modèle utilisé pour générer la sortie évaluée
    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"Score moyen d'utilisation du contexte : {sum(context_scores) / len(context_scores)}")

Écrire des centaines de cas de test peut être difficile à faire à la main ! Demandez à Claude de vous aider à en générer davantage à partir d’un ensemble de base d’exemples de cas de test.

Si vous ne savez pas quelles méthodes d’évaluation pourraient être utiles pour évaluer vos critères de succès, vous pouvez également faire un brainstorming avec Claude !

Notation des évaluations

Lorsque vous décidez quelle méthode utiliser pour noter les évaluations, choisissez la méthode la plus rapide, la plus fiable et la plus évolutive :

Notation basée sur le code : La plus rapide et la plus fiable, extrêmement évolutive, mais manque également de nuance pour des jugements plus complexes qui nécessitent moins de rigidité basée sur des règles.
- Correspondance exacte : output == golden_answer
- Correspondance de chaîne : key_phrase in output
Notation humaine : La plus flexible et de haute qualité, mais lente et coûteuse. À éviter si possible.
Notation basée sur LLM : Rapide et flexible, évolutive et adaptée aux jugements complexes. Testez d’abord pour assurer la fiabilité, puis passez à l’échelle.

Conseils pour la notation basée sur LLM

Avoir des rubriques détaillées et claires : “La réponse doit toujours mentionner ‘Acme Inc.’ dans la première phrase. Si ce n’est pas le cas, la réponse est automatiquement notée comme ‘incorrecte’.”
Un cas d’utilisation donné, ou même un critère de succès spécifique pour ce cas d’utilisation, peut nécessiter plusieurs rubriques pour une évaluation holistique.
Empirique ou spécifique : Par exemple, demandez au LLM de ne répondre que par ‘correct’ ou ‘incorrect’, ou de juger sur une échelle de 1 à 5. Les évaluations purement qualitatives sont difficiles à évaluer rapidement et à grande échelle.
Encourager le raisonnement : Demandez au LLM de réfléchir d’abord avant de décider d’un score d’évaluation, puis d’écarter le raisonnement. Cela augmente les performances d’évaluation, en particulier pour les tâches nécessitant un jugement complexe.

import anthropic

def build_grader_prompt(answer, rubric):
    return f"""Notez cette réponse en fonction de la rubrique :
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Réfléchissez à votre raisonnement entre des balises <thinking>, puis répondez par 'correct' ou 'incorrect' entre des balises <result>."""

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"

# Exemple d'utilisation
eval_data = [
    {"question": "42 est-il la réponse à la vie, l'univers et le reste ?", "golden_answer": "Oui, selon 'Le Guide du voyageur galactique'."},
    {"question": "Quelle est la capitale de la France ?", "golden_answer": "La capitale de la France est 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"Score : {grades.count('correct') / len(grades) * 100}%")

Prochaines étapes

Brainstormer des évaluations

Apprenez à créer des prompts qui maximisent vos scores d’évaluation.

Recueil d'évaluations

Plus d’exemples de code d’évaluations notées par des humains, du code et des LLM.

Commencer

En savoir plus sur Claude

Construire avec Claude

Tester et évaluer

Ressources

Créer des évaluations empiriques solides

Construire des évaluations et des cas de test

Principes de conception des évaluations

Exemples d’évaluations

Notation des évaluations

Conseils pour la notation basée sur LLM

Prochaines étapes

Brainstormer des évaluations

Recueil d'évaluations

Commencer

En savoir plus sur Claude

Construire avec Claude

Tester et évaluer

Ressources

​Construire des évaluations et des cas de test

​Principes de conception des évaluations

​Exemples d’évaluations

​Notation des évaluations

​Conseils pour la notation basée sur LLM

​Prochaines étapes

Brainstormer des évaluations

Recueil d'évaluations

Construire des évaluations et des cas de test

Principes de conception des évaluations

Exemples d’évaluations

Notation des évaluations

Conseils pour la notation basée sur LLM

Prochaines étapes