Évaluer les Performances de Claude : Guide des Evals

Pourquoi Évaluer Claude ?

L'IA est probabiliste — la même requête peut produire des résultats différents. Les évaluations vous permettent de :

1. →Mesurer la qualité des réponses de manière objective
2. →Comparer des prompts pour trouver la meilleure formulation
3. →Valider les changements de modèle sans surprise en production
4. →Détecter les régressions lors des mises à jour d'API
5. →Justifier les décisions auprès des stakeholders avec des données

Les 3 Types d'Évaluations

1. Évaluations Automatisées

Des scores calculés par du code — rapides, reproductibles, pas de jugement humain nécessaire.

import json
import re

def eval_exact_match(response, expected):
    """Vérifie une correspondance exacte."""
    return response.strip().lower() == expected.strip().lower()

def eval_contains(response, keywords):
    """Vérifie que la réponse contient les mots-clés."""
    response_lower = response.lower()
    return all(kw.lower() in response_lower for kw in keywords)

def eval_json_schema(response, required_fields):
    """Vérifie que la réponse est un JSON valide avec les champs requis."""
    try:
        data = json.loads(response)
        return all(field in data for field in required_fields)
    except json.JSONDecodeError:
        return False

def eval_regex(response, pattern):
    """Vérifie que la réponse matche un pattern regex."""
    return bool(re.search(pattern, response))

# Exemples d'utilisation
assert eval_exact_match("Paris", "Paris")
assert eval_contains("Python est un langage interprété", ["python", "langage"])
assert eval_json_schema('{"name": "Alice", "age": 30}', ["name", "age"])
assert eval_regex("Le prix est de 29.99€", r"\d+\.\d{2}€")

2. Évaluations Humaines

Des annotateurs humains évaluent les réponses selon des critères définis. Le gold standard en termes de qualité.

Process recommandé :

1. →Créez un guide d'annotation avec des exemples pour chaque score
2. →Formez 2-3 annotateurs sur les critères
3. →Faites évaluer chaque réponse par 2 annotateurs minimum
4. →Calculez l'accord inter-annotateurs (Kappa de Cohen)
5. →Résolvez les désaccords par discussion

3. Évaluations Model-Graded

Un LLM évalue les réponses d'un autre LLM. Scalable et rapide, avec un bon proxy de l'évaluation humaine.

import anthropic

client = anthropic.Anthropic()

def model_graded_eval(question, response, criteria):
    """Utilise Claude pour évaluer une réponse."""
    eval_prompt = f"""Évalue cette réponse selon les critères donnés.

Question posée : {question}
Réponse à évaluer : {response}

Critères d'évaluation :
{criteria}

Retourne un JSON avec :
- "score": note de 1 à 5
- "reasoning": justification en 2-3 phrases
- "issues": liste des problèmes identifiés (ou liste vide)
"""
    
    eval_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": eval_prompt}]
    )
    
    return json.loads(eval_response.content[0].text)

# Utilisation
result = model_graded_eval(
    question="Quels sont les avantages de TypeScript sur JavaScript ?",
    response="TypeScript ajoute le typage statique, ce qui réduit les bugs...",
    criteria="""
    - Précision technique (les affirmations sont-elles correctes ?)
    - Complétude (les avantages principaux sont-ils couverts ?)
    - Exemples (des exemples concrets sont-ils donnés ?)
    """
)
print(f"Score: {result['score']}/5")
print(f"Raison: {result['reasoning']}")

Concevoir des Cas de Test

Structure d'un Cas de Test

test_case = {
    "id": "tc-001",
    "category": "extraction",
    "input": "Marie Dupont, 35 ans, développeuse chez TechCorp à Lyon.",
    "expected_output": {
        "name": "Marie Dupont",
        "age": 35,
        "job": "développeuse",
        "company": "TechCorp",
        "city": "Lyon"
    },
    "eval_method": "json_schema",
    "tags": ["extraction", "structured_output"]
}

Catégories de Cas de Test

Script d'Évaluation Complet

import anthropic
import json
from datetime import datetime

client = anthropic.Anthropic()

def run_eval_suite(test_cases, model, system_prompt, eval_fn):
    """Exécute une suite d'évaluations complète."""
    results = []
    passed = 0
    
    for tc in test_cases:
        # Appel à Claude
        response = client.messages.create(
            model=model,
            max_tokens=1024,
            system=system_prompt,
            messages=[{"role": "user", "content": tc["input"]}]
        )
        
        output = response.content[0].text
        
        # Évaluation
        score = eval_fn(output, tc["expected_output"])
        passed += 1 if score else 0
        
        results.append({
            "id": tc["id"],
            "input": tc["input"],
            "expected": tc["expected_output"],
            "actual": output,
            "passed": score,
            "tokens": response.usage.input_tokens + response.usage.output_tokens
        })
    
    # Rapport
    total = len(test_cases)
    print(f"\n{'='*50}")
    print(f"Résultats : {passed}/{total} ({passed/total*100:.1f}%)")
    print(f"Modèle : {model}")
    print(f"Date : {datetime.now().isoformat()}")
    print(f"{'='*50}")
    
    # Cas échoués
    failed = [r for r in results if not r["passed"]]
    if failed:
        print(f"\n❌ {len(failed)} cas échoués :")
        for r in failed[:5]:
            print(f"  - {r['id']}: attendu '{r['expected']}', reçu '{r['actual'][:100]}...'")
    
    return results

# Exécution
test_cases = [
    {"id": "tc-001", "input": "Quelle est la capitale de la France ?", "expected_output": "Paris"},
    {"id": "tc-002", "input": "Quelle est la capitale de l'Allemagne ?", "expected_output": "Berlin"},
    {"id": "tc-003", "input": "Quelle est la capitale du Japon ?", "expected_output": "Tokyo"},
]

results = run_eval_suite(
    test_cases=test_cases,
    model="claude-sonnet-4-20250514",
    system_prompt="Réponds uniquement avec le nom de la ville, sans phrase.",
    eval_fn=lambda output, expected: expected.lower() in output.lower()
)

A/B Testing de Prompts

Comparez systématiquement deux versions d'un prompt pour identifier la meilleure.

def ab_test_prompts(test_cases, prompt_a, prompt_b, model, eval_fn):
    """Compare deux prompts sur les mêmes cas de test."""
    results_a = run_eval_suite(test_cases, model, prompt_a, eval_fn)
    results_b = run_eval_suite(test_cases, model, prompt_b, eval_fn)
    
    score_a = sum(1 for r in results_a if r["passed"]) / len(results_a)
    score_b = sum(1 for r in results_b if r["passed"]) / len(results_b)
    
    tokens_a = sum(r["tokens"] for r in results_a)
    tokens_b = sum(r["tokens"] for r in results_b)
    
    print(f"\n📊 Résultats A/B Test")
    print(f"{'Métrique':<20} {'Prompt A':<15} {'Prompt B':<15} {'Gagnant':<10}")
    print(f"{'─'*60}")
    print(f"{'Score':<20} {score_a:.1%}{'':>9} {score_b:.1%}{'':>9} {'A' if score_a > score_b else 'B'}")
    print(f"{'Tokens total':<20} {tokens_a:<15} {tokens_b:<15} {'A' if tokens_a < tokens_b else 'B'}")
    
    return {"prompt_a": score_a, "prompt_b": score_b}

# Exemple
ab_test_prompts(
    test_cases=test_cases,
    prompt_a="Tu es un assistant géographie. Réponds avec le nom de la ville uniquement.",
    prompt_b="Réponds en un seul mot : le nom de la capitale demandée.",
    model="claude-sonnet-4-20250514",
    eval_fn=lambda output, expected: expected.lower() in output.lower()
)

Outil d'Évaluation de la Console Anthropic

La console Anthropic offre un outil d'évaluation intégré avec une interface graphique.

Fonctionnalités

Workflow dans la Console

1. →Créer un Eval Set : Ajoutez vos cas de test (input + expected output)
2. →Configurer le Scoring : Choisissez votre méthode d'évaluation
3. →Lancer l'Eval : Sélectionnez le modèle et le prompt
4. →Analyser les Résultats : Visualisez les scores, identifiez les échecs
5. →Itérer : Modifiez le prompt et relancez

Benchmarking entre Modèles

Comparez les performances de différents modèles Claude sur votre cas d'usage spécifique.

models = [
    "claude-haiku-3-5-20241022",
    "claude-sonnet-4-20250514",
    "claude-opus-4-20250918"
]

for model in models:
    print(f"\n📊 Évaluation de {model}")
    run_eval_suite(test_cases, model, system_prompt, eval_fn)

Erreurs Courantes dans les Evals

Pour aller plus loin

• →Évaluations avec Promptfoo : guide pratique — Implémentez un framework d'évaluation complet avec Promptfoo
• →Détection des hallucinations et biais IA — Techniques pour identifier et prévenir les erreurs des modèles