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 consiste à prendre chaque cas de test, à le fusionner avec notre requête, à le transmettre à Claude, puis à noter 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 avec notre modèle de requête, l'envoyons à Claude pour traitement, puis évaluons la sortie à 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 les requêtes individuelles.

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 formatage, donc Claude renverra probablement une sortie plus verbeuse que nécessaire. Nous affinerons cela plus tard à mesure que nous itérerons sur la conception de notre requête.

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 l'ensemble du pipeline.

La fonction run_eval

Cette fonction coordonne l'ensemble du processus d'évaluation :

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 traite chaque cas de test de notre jeu de données et collecte tous les résultats dans une seule liste.

Exécution de l'évaluation

Pour exécuter notre pipeline d'évaluation, nous chargeons notre jeu de données et l'exécutons via nos fonctions :

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, cela peut prendre environ 30 secondes pour traiter un jeu de données complet. Nous aborderons les techniques d'optimisation plus tard.

Examen des résultats

L'évaluation renvoie un tableau JSON structuré où chaque objet représente le résultat d'un cas de test :

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 ».

Chaque résultat contient trois informations clés :

  • output : La réponse complète de Claude
  • test_case : Le cas de test original qui a été traité
  • score : Le score d'évaluation (actuellement codé en dur)

Comme vous pouvez le voir dans la sortie, Claude génère des réponses assez verbeuses puisque nous n'avons pas encore fourni d'instructions de formatage spécifiques. C'est exactement le genre de problème que nous traiterons en affinant nos requêtes.

É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, avec des scores de 10, 4 et 9.

Ce que nous avons accompli

À ce stade, nous avons construit avec succès le pipeline d'évaluation principal. Nous pouvons prendre notre jeu de données, le traiter via Claude et collecter des résultats structurés. La principale pièce manquante est le système de notation - ce score codé en dur de 10 doit être remplacé par une logique d'évaluation réelle.

Ce pipeline représente le fondement de la plupart des systèmes d'évaluation d'IA. Bien que cela puisse sembler simple, vous venez de construire la majorité de ce qu'un pipeline d'évaluation fait réellement. La complexité réside dans les détails - de meilleures requêtes, une notation sophistiquée et des optimisations de performance.

Ensuite, nous nous plongerons dans le sujet crucial des systèmes de notation, qui transformeront nos scores codés en dur en évaluations significatives des performances de Claude.