Chargement

Exécution de l'évaluation

Leçon 1315 min
Chargement

Maintenant que notre jeu de données d'évaluation est prêt, il est temps de construire le pipeline d'évaluation principal. Cela implique de prendre chaque cas de test, de le fusionner avec notre requête, de le soumettre à Claude, puis d'évaluer les résultats.

Une requête avec un espace réservé pour une question, trois questions de test telles que « Combien font 2+2 ? », et les réponses de Claude telles que « 2 + 2 = 4 ».

Le processus d'évaluation suit un flux de travail clair : nous prenons notre jeu de données de cas de test, combinons chacun d'eux avec notre modèle de requête, l'envoyons à Claude pour traitement, puis évaluons le résultat à l'aide d'un système de notation.

Construction des fonctions principales

Le pipeline d'évaluation se compose de trois fonctions principales, chacune ayant une responsabilité spécifique. Commençons par la plus simple : la fonction qui gère l'exécution d'une requête individuelle.

La fonction run_prompt

Cette fonction prend un cas de test et le fusionne avec notre modèle de requête :

python
def run_prompt(test_case):
    """Merges the prompt and test case input, then returns the result"""
    prompt = f"""
Please solve the following task:

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

Pour l'instant, nous gardons la requête extrêmement simple. Nous n'incluons aucune instruction de mise en forme, ce qui signifie que Claude retournera probablement une sortie plus verbeuse que nécessaire. Nous affinerons cela plus tard, au fur et à mesure que nous itérerons sur notre processus d'évaluation.

La fonction run_test_case

Cette fonction orchestre l'exécution d'un cas de test unique et la notation du résultat :

python
def run_test_case(test_case):
    """Calls run_prompt, then grades the result"""
    output = run_prompt(test_case)
    
    # TODO - Notation
    score = 10
    
    return {
        "output": output,
        "test_case": test_case,
        "score": score
    }

Pour l'instant, nous utilisons un score codé en dur de 10. La logique de notation est l'endroit où nous passerons beaucoup de temps dans les sections à venir, mais cet espace réservé nous permet de tester la structure globale du pipeline.

La fonction run_eval

Il s'agit de l'orchestrateur principal qui traite l'ensemble du jeu de données :

python
def run_eval(dataset):
    """Loads the dataset and calls run_test_case with each case"""
    results = []
    
    for test_case in dataset:
        result = run_test_case(test_case)
        results.append(result)
    
    return results

Cette fonction parcourt chaque cas de test de notre jeu de données, traite chacun d'eux et rassemble tous les résultats dans une seule liste.

Exécution de l'évaluation

Pour exécuter notre pipeline d'évaluation, nous chargeons le jeu de données et appelons notre fonction principale :

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

results = run_eval(dataset)

La première fois que vous exécutez ceci, attendez-vous à ce que cela prenne un certain temps - même avec Claude Haiku, le traitement d'un jeu de données complet peut prendre plus de 30 secondes. Nous aborderons les techniques d'optimisation plus tard, mais pour l'instant, la patience est de mise.

Examen des résultats

Une fois l'évaluation terminée, vous pouvez inspecter les résultats avec une sortie JSON formatée :

python
print(json.dumps(results, indent=2))

Une requête avec un espace réservé pour une question, trois questions de test telles que « Combien font 2+2 ? », et les réponses de Claude telles que « 2 + 2 = 4 ».

La structure des résultats contient un tableau d'objets, où chaque objet représente l'exécution d'un cas de test. Vous verrez la sortie de Claude (qui tend à être assez verbeuse sans contraintes de mise en forme), la définition du cas de test d'origine, et le score.

Étape de notation du pipeline d'évaluation mise en évidence : les trois paires de questions et réponses entrent dans un système de notation, notées 10, 4 et 9.

Ce que nous avons accompli

À ce stade, nous avons implémenté avec succès le pipeline d'évaluation principal. Nous pouvons :

  • Prendre des cas de test de notre jeu de données
  • Les fusionner avec des modèles de requête
  • Obtenir des réponses de Claude
  • Collecter et organiser tous les résultats

L'élément manquant est une notation intelligente - pour l'instant, nous attribuons simplement un score fixe à chaque réponse. La prochaine étape consiste à construire des systèmes de notation capables d'évaluer réellement si les sorties de Claude sont correctes, ce qui est là où la véritable sophistication des systèmes d'évaluation entre en jeu.

Cette structure de pipeline peut sembler simple, mais elle représente le fondement sur lequel la plupart des systèmes d'évaluation d'IA sont construits. La complexité réside dans la logique de notation et l'optimisation des requêtes, pas dans l'orchestration de base de l'exécution des tests.