Exécuter l'évaluation

Le jeu de données est prêt ; il faut maintenant la machinerie qui va s’en servir. Un pipeline d’évaluation fait toujours la même chose, quel que soit le projet : prendre chaque cas de test, le fusionner avec le prompt à évaluer, envoyer le tout à Claude, puis noter la réponse. Plutôt qu’un gros script monolithique, nous le découpons en trois fonctions courtes — une par responsabilité — parce que c’est précisément ce découpage qui rendra le pipeline réutilisable quand vous changerez de prompt, de jeu de données ou de méthode de notation.

Les trois fonctions du pipeline

run_prompt : fusionner prompt et cas de test

def run_prompt(test_case):
    prompt = f"""
Resous la tache suivante :

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

Cette fonction est la seule qui connaisse le texte du prompt, et c’est voulu : quand vous voudrez tester une variante — ajouter des exemples, préciser le format de sortie, changer le ton — vous ne modifierez que run_prompt, et tout le reste du pipeline restera identique. C’est ce qui permet de comparer deux versions de prompt à conditions strictement égales : même jeu de données, même notation, seule l’instruction change.

run_test_case : exécuter et noter

def run_test_case(test_case):
    output = run_prompt(test_case)
    score = 10  # Placeholder - a remplacer par un vrai évaluateur
    return {
        "output": output,
        "test_case": test_case,
        "score": score
    }

Le score en dur peut surprendre — à quoi bon un évaluateur qui donne 10 à tout ? C’est une pratique de construction délibérée : on met d’abord la plomberie en place avec un score factice, on vérifie que les données circulent de bout en bout, puis on remplace le placeholder par un vrai évaluateur (par code dans deux leçons, par modèle ensuite). Si vous branchez la notation avant d’avoir validé la structure, vous déboguerez les deux en même temps sans savoir lequel casse. Remarquez aussi que la fonction retourne un dictionnaire complet — la sortie, le cas de test d’origine et le score — et pas seulement la note : au moment d’analyser les résultats, vous voudrez toujours savoir quelle entrée a produit quelle sortie.

run_eval : coordonner l’ensemble

def run_eval(dataset):
    results = []
    for test_case in dataset:
        result = run_test_case(test_case)
        results.append(result)
    return results

La coordination se réduit à une boucle : chaque cas passe dans run_test_case, les résultats s’accumulent. Cette simplicité est une qualité — c’est ici que vous grefferez plus tard les améliorations de confort (affichage de progression, exécution en parallèle, reprise sur erreur) sans toucher aux deux fonctions précédentes.

Exécution

with open("dataset.json", "r") as f:
    dataset = json.load(f)

results = run_eval(dataset)

Lancez ce script tel quel : vous obtenez une liste de dictionnaires, un par cas de test, chacun portant le texte de sortie, le cas d’origine et le score (encore factice). Prenez le temps de parcourir quelques sorties à la main dès ce premier passage — c’est le moment le moins cher pour repérer un problème évident, comme des réponses tronquées ou un format inattendu, avant d’investir dans la notation automatique.

La prochaine étape est de remplacer ce score en dur par un vrai système d’évaluation : d’abord par code, avec des critères objectifs, puis par modèle pour les critères qualitatifs.

Points clés à retenir

• Le pipeline se découpe en trois responsabilités : fusionner (run_prompt), exécuter et noter (run_test_case), coordonner (run_eval)
• Seule run_prompt connaît le texte du prompt : comparer deux variantes revient à ne changer qu’une fonction
• Le score placeholder est une étape de construction : validez la plomberie avant de brancher la vraie notation
• Chaque résultat conserve la sortie ET le cas de test d’origine — indispensable pour analyser les échecs
• Relisez quelques sorties à la main dès la première exécution : c’est le débogage le moins coûteux