Exécuter l'évaluation

Le jeu de données est prêt : construisons le pipeline lui-même. Le principe : prendre chaque cas de test, le fusionner avec le prompt, l’envoyer à Claude, puis noter la réponse. Trois petites fonctions suffisent, chacune avec une responsabilité nette.

D'après la leçon « Running the eval » (Claude Academy, Claude with Amazon Bedrock).

`run_prompt` : exécuter le prompt sur un cas

def run_prompt(test_case):
    """Fusionne le prompt et l'entrée du cas de test, puis renvoie la réponse."""
    prompt = f"""
Résous la tâche suivante :

{test_case["task"]}
"""
    messages = []
    add_user_message(messages, prompt)
    return chat(messages)

C’est la seule fonction qui connaît le contenu du prompt : pour tester une nouvelle version, c’est ici, et seulement ici, qu’on la modifie. Le prompt est minimal pour l’instant. Sans consigne de format, Claude renverra sans doute des réponses plus bavardes que nécessaire, et c’est très bien : on mesure ce point de départ avant de l’améliorer.

`run_test_case` : traiter un cas

def run_test_case(test_case):
    """Appelle run_prompt, puis note la réponse."""
    output = run_prompt(test_case)

    # À faire : la notation
    score = 10

    return {
        "output": output,
        "test_case": test_case,
        "score": score,
    }

La note est fixée à 10 pour l’instant : un bouchon assumé, que les deux leçons suivantes remplaceront. Remarquez la valeur de retour : un enregistrement qui garde ensemble l’entrée, la réponse et la note. C’est ce format qui rendra les résultats exploitables.

`run_eval` : traiter tout le jeu de données

def run_eval(dataset):
    """Appelle run_test_case pour chaque cas du jeu de données."""
    results = []
    for test_case in dataset:
        results.append(run_test_case(test_case))
    return results

Une boucle sans mystère, et c’est sa qualité : chaque étage reste simple parce qu’il ne fait qu’une chose. Le prompt, un cas, le jeu complet : trois niveaux, trois fonctions.

Lancer l’évaluation

import json

with open("dataset.json", encoding="utf-8") as f:
    dataset = json.load(f)

results = run_eval(dataset)
print(json.dumps(results, indent=2, ensure_ascii=False))

La première exécution prend du temps : chaque cas est un appel à Bedrock, les uns après les autres. Le cours officiel compte plus de 30 secondes pour un jeu complet, même avec Haiku. C’est pourquoi on garde des jeux de mise au point de taille raisonnable ; la leçon 17 montrera comment lancer plusieurs cas en parallèle.

En lisant le résultat, vous verrez pour chaque cas la réponse de Claude, souvent entourée d’explications faute de consigne de format, le cas de test d’origine et la note.

Ce qui manque

Le pipeline tourne de bout en bout : il prend les cas, les fusionne avec le prompt, recueille les réponses et les range. Il manque la notation, ce score = 10 qui ne mesure encore rien. Les deux leçons suivantes construisent les évaluateurs : d’abord par modèle, puis par code.

À vous de jouer

Votre pipeline. Faites tourner ces trois fonctions sur le jeu de données de la leçon 13. Mesurez la durée totale avec time.perf_counter() et divisez-la par le nombre de cas : c’est le coût en temps d’une évaluation, à multiplier par la taille de vos futurs jeux.

Sources officielles : Running the eval (Claude Academy) · Define success criteria and build evaluations (documentation Claude)

Points clés à retenir

Trois fonctions, trois responsabilités : run_prompt (le prompt), run_test_case (un cas), run_eval (le jeu complet).
Le prompt de départ est minimal : on mesure la base avant de l’améliorer.
Chaque résultat garde l’entrée, la réponse et la note ensemble.
Une évaluation coûte du temps et des appels : jeux de mise au point raisonnables, parallélisme ensuite.

run_prompt : exécuter le prompt sur un cas

run_test_case : traiter un cas