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 la performance des 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.

Construction des évaluations et des cas de test

Principes de conception des évaluations

Être spécifique à la tâche : Concevez des évaluations qui reflètent la distribution de vos 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 de chat] Saisie utilisateur médiocre, nuisible ou non pertinente
- Cas de test ambigus où même les humains auraient du mal à atteindre un consensus d’évaluation
Automatiser quand c’est possible : Structurez les questions pour permettre une notation automatisée (par ex., choix multiple, correspondance de chaînes, notation par code, notation par LLM).
Privilégier le volume à la qualité : Plus de questions avec une notation automatisée légèrement moins précise est préférable à moins de questions avec des évaluations manuelles de haute qualité notées par des humains.

Exemples d’évaluations

Ce qu’elle mesure : Les évaluations par 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 : 1000 tweets avec des sentiments étiquetés par des humains.

import anthropic

tweets = [
    {"text": "Ce film était une perte de temps totale. 👎", "sentiment": "negative"},
    {"text": "Le nouvel album est 🔥! En boucle toute la journée.", "sentiment": "positive"},
    {"text": "J'adore quand mon vol est retardé de 5 heures. #meilleurejourneedelavie", "sentiment": "negative"},  # Cas limite : Sarcasme
    {"text": "L'intrigue du film était terrible, mais le jeu d'acteur était phénoménal.", "sentiment": "mixed"},  # Cas limite : Sentiment mitigé
    # ... 996 tweets supplémentaires
]

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"Classifiez ceci comme 'positive', 'negative', 'neutral', ou '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"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 utilisant SBERT) en calculant le cosinus de l’angle entre eux. Les valeurs proches de 1 indiquent une plus grande similarité. C’est idéal pour évaluer la cohérence car des questions similaires devraient produire des réponses sémantiquement similaires, même si la formulation varie.

Exemples de cas de test : 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 ?", "Kel est votr politiq de retr ?"], "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 que j'attendais, donc je me demandais si je pourrais éventuellement le retourner ?", "J'ai lu en ligne que votre politique est de 30 jours mais cela semble peut-être périmé 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 confuse
    {"questions": ["Je suis la cousine de Jane, et elle m'a dit que vous aviez un excellent service client. Puis-je retourner ceci ?", "Reddit m'a dit que contacter le service client de cette façon était le plus rapide pour obtenir une réponse. J'espère qu'ils ont raison ! Quel est le délai de retour pour une veste ?"], "answer": "Notre politique de retour permet..."},  # Cas limite : Informations non pertinentes
    # ... 47 FAQ supplémentaires
]

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

Ce qu’elle mesure : ROUGE-L (Recall-Oriented Understudy for Gisting Evaluation - Plus longue sous-séquence commune) é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 candidat 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 : 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 les gros titres la semaine dernière pour avoir sauvé... Dans les nouvelles de la mairie, le budget... Les météorologues prévoient...", "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 ! ... travail caritatif extensif ...", "summary": "Le travail caritatif extensif d'une célébrité surprend les fans"},  # Cas limite : Titre trompeur
    # ... 197 articles supplémentaires
]

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']  # 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 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 : 100 demandes clients avec 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": "empathetic"},  # Cas limite : Client en colère
    {"text": "J'ai essayé de réinitialiser mon mot de passe mais mon compte s'est retrouvé bloqué...", "tone": "patient"},  # Cas limite : Problème complexe
    {"text": "Je n'arrive pas à croire à quel point votre produit est bon. Il a gâché tous les autres pour moi !", "tone": "professional"},  # Cas limite : Compliment comme plainte
    # ... 97 demandes supplémentaires
]

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"""É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}
    Sortie uniquement le nombre."""

    # Généralement, il est préférable d'utiliser un modèle différent pour évaluer que celui 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 moyen de ton : {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 classifier si une réponse contient des PHI ou non. Cette méthode peut comprendre le contexte et identifier des formes subtiles ou implicites de PHI que les systèmes basés sur des règles pourraient manquer.

Exemples de cas de test : 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, 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 supplémentaires
]

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 = """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 fourniture de services de santé. Cela inclut les informations relatives à l'état de santé physique ou mentale d'un individu, la fourniture de soins de santé à cet individu, ou le paiement de ces soins.
    Les aspects clés des PHI incluent :
    - 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, emails ou messages concernant la santé.

    <response>{model_output}</response>
    Sortie uniquement 'oui' ou 'non'."""

    # Généralement, il est préférable d'utiliser un modèle différent pour évaluer que celui 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 de 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 fourniture de services de santé. Cela inclut les informations relatives à l'état de santé physique ou mentale d'un individu, la fourniture de soins de santé à cet individu, ou le 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 : 100 conversations multi-tours avec des questions dépendantes du contexte.

import anthropic

conversations = [
    [
        {"role": "user", "content": "Je viens d'avoir un nouveau spitz nain !"},
        {"role": "assistant", "content": "Félicitations pour votre nouveau compagnon à fourrure ! Est-ce votre premier chien ?"},
        {"role": "user", "content": "Oui, c'est le cas. Je l'ai appelée Luna."},
        {"role": "assistant", "content": "Luna est un très joli nom ! En tant que nouveau propriétaire de chien, vous devez avoir des questions. Que souhaitez-vous savoir sur les soins à apporter à Luna ?"},
        ...
        {"role": "user", "content": "Que devrais-je savoir sur les soins à apporter à un chien de cette race spécifique ?"}  # Cas limite : S'appuie sur le contexte de beaucoup 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. Hé, c'était quand l'anniversaire de Scout déjà ?"},  # Cas limite : Changement brusque de sujet
        {"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 ces détails spécifiques. Il se concentre plutôt 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, c'est vrai. Eh bien, pouvez-vous suggérer une recette de gâteau traditionnel du Sud ?"}  # Cas limite : Autre changement de sujet
    ],
    # ... 98 conversations supplémentaires
]

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"""Évaluez sur une échelle de 1-5 à quel point cette réponse utilise bien le contexte de la conversation :
    <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
    Sortie uniquement le nombre et rien d'autre."""

    # Généralement, il est préférable d'utiliser un modèle différent pour évaluer que celui 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 manuellement ! Demandez à Claude de vous aider à en générer davantage à partir d’un ensemble de base de cas de test exemples.

Si vous ne savez pas quelles méthodes d’évaluation pourraient être utiles pour évaluer vos critères de succès, vous pouvez aussi réfléchir avec Claude !

Noter les évaluations

Lors du choix de la 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 aussi 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 mettez à 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 sortir que ‘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 écartez le raisonnement. Cela augmente la performance d’évaluation, particulièrement pour les tâches nécessitant un jugement complexe.

import anthropic

def build_grader_prompt(answer, rubric):
    return f"""Notez cette réponse basée sur la rubrique :
    <rubric>{rubric}</rubric>
    <answer>{answer}</answer>
    Réfléchissez à votre raisonnement dans des balises <thinking>, puis sortez 'correct' ou 'incorrect' dans 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": "Est-ce que 42 est la réponse à la vie, l'univers et tout 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-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"Score : {grades.count('correct') / len(grades) * 100}%")

Prochaines étapes

Réfléchir aux évaluations

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

Livre de recettes d'évaluations

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

Commencer

En savoir plus sur Claude

Construire avec Claude

Tester et évaluer

Administration

Centre juridique

Ressources

Créer des évaluations empiriques solides

Construction des évaluations et des cas de test

Principes de conception des évaluations

Exemples d’évaluations

Noter les évaluations

Conseils pour la notation basée sur LLM

Prochaines étapes

Réfléchir aux évaluations

Livre de recettes d'évaluations

Commencer

En savoir plus sur Claude

Construire avec Claude

Tester et évaluer

Administration

Centre juridique

Ressources

​Construction des évaluations et des cas de test

​Principes de conception des évaluations

​Exemples d’évaluations

​Noter les évaluations

​Conseils pour la notation basée sur LLM

​Prochaines étapes

Réfléchir aux évaluations

Livre de recettes d'évaluations

Construction des évaluations et des cas de test

Principes de conception des évaluations

Exemples d’évaluations

Noter les évaluations

Conseils pour la notation basée sur LLM

Prochaines étapes