Notation par modèle

Notre pipeline tourne, mais son score = 10 provisoire ne mesure rien. Place au vrai juge : les évaluateurs fournissent des signaux objectifs sur la qualité des sorties — un évaluateur prend la sortie du modèle et renvoie un retour mesurable, généralement un nombre entre 1 et 10. C’est la pièce qui transforme des réponses collectées en métrique exploitable.

Types d’évaluateurs

Trois approches principales pour noter les sorties, aux forces complémentaires :

Le code est rapide, gratuit et parfaitement reproductible — mais aveugle à tout ce qui ne se vérifie pas mécaniquement. L’humain juge tout, à un coût qui interdit les itérations fréquentes. L’évaluateur modèle occupe le milieu : il apprécie des qualités subjectives à un prix qui permet de noter des centaines de sorties — c’est lui que cette leçon implémente.

Définir les critères d’évaluation

Avant d’implémenter quoi que ce soit, définissez des critères clairs. Pour notre prompt de génération de code AWS :

• Format : renvoyer uniquement du Python, JSON ou Regex sans explication
• Syntaxe valide : le code produit doit avoir une syntaxe correcte
• Respect de la tâche : la réponse doit traiter directement la tâche de l’utilisateur

Le partage du travail se dessine déjà : les deux premiers critères conviennent aux évaluateurs code — un parseur tranche mieux qu’un jugement —, le troisième est mieux adapté aux évaluateurs modèle grâce à leur flexibilité : « la réponse traite-t-elle la demande ? » exige de comprendre les deux.

Implémenter un évaluateur modèle

L’évaluateur est lui-même un appel à Claude, avec les techniques d’extraction que vous connaissez :

def grade_by_model(test_case, output):
    eval_prompt = """
    Vous etes un expert en revue de code. Evaluez cette solution generee par l'IA.

    Tache : {task}
    Solution : {solution}

    Fournissez votre évaluation sous forme d'objet JSON structure avec :
    - "strengths" : tableau de 1 a 3 points forts
    - "weaknesses" : tableau de 1 a 3 points a ameliorer
    - "reasoning" : explication concise de votre évaluation
    - "score" : un nombre entre 1 et 10
    """

    messages = []
    add_user_message(messages, eval_prompt)
    add_assistant_message(messages, "```json")

    eval_text = chat(messages, stop_sequences=["```"])
    return json.loads(eval_text)

Le prompt d’évaluation donne un rôle (expert en revue de code), fournit la tâche et la solution, et impose un format de sortie JSON — extrait proprement par le pré-remplissage et la séquence d’arrêt. Point clé, validé par l’expérience : demandez des forces, des faiblesses et un raisonnement en plus du score. Sans ce contexte, les modèles tendent à donner des scores médiocres autour de 6, quoi qu’ils lisent — obligé d’argumenter d’abord, le juge fonde sa note sur son analyse, et la distribution des scores devient réellement discriminante.

Intégrer l’évaluateur

Le bouchon score = 10 cède sa place :

def run_test_case(test_case):
    output = run_prompt(test_case)

    model_grade = grade_by_model(test_case, output)
    score = model_grade["score"]
    reasoning = model_grade["reasoning"]

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

Chaque enregistrement conserve désormais le raisonnement du juge à côté de la note — précieux au moment d’analyser les échecs : le score dit « 4 », le raisonnement dit pourquoi 4.

Calculer le score moyen

from statistics import mean

def run_eval(dataset):
    results = []

    for test_case in dataset:
        result = run_test_case(test_case)
        results.append(result)

    average_score = mean([result["score"] for result in results])
    print(f"Score moyen : {average_score}")

    return results

Ce score moyen est votre métrique concrète et objective pour suivre la performance des prompts au fil du temps : chaque version du prompt reçoit son chiffre, chaque modification se compare à la précédente. Le pipeline est complet — la prochaine leçon lui ajoutera la notation par code, pour couvrir les critères mécaniques.

Points clés à retenir

• Trois familles d’évaluateurs : code (mécanique, gratuit), modèle (qualitatif, scalable), humain (riche, coûteux)
• Affectez chaque critère au bon évaluateur : format et syntaxe au code, pertinence au modèle
• Exigez forces, faiblesses et raisonnement avec la note — un juge qui argumente note juste
• Sortie JSON par pré-remplissage + séquence d’arrêt, prête pour json.loads
• La moyenne des scores devient la métrique de suivi de toutes vos itérations de prompt