Générer des jeux de données de test

Avant d’évaluer un prompt, il faut des cas sur lesquels l’évaluer. Cette leçon reprend le projet du cours officiel, un assistant qui écrit du code pour des tâches AWS, et montre comment constituer son jeu de test : quelques cas écrits à la main, le volume généré par Claude, le tout vérifié et enregistré dans un fichier.

Mise à jour du 5 novembre 2026. Le cours officiel extrait le JSON généré en préremplissant le début d’un bloc de code JSON, avec une séquence d’arrêt, sur Claude Haiku 4.5. Les modèles actuels refusent le préremplissage (erreur 400 depuis Claude 4.6) : le code utilise ici les sorties structurées de la leçon 9, avec Claude Haiku 5.5. Le schéma enveloppe la liste dans un objet {"cas": [...]}.

Le projet

L’assistant doit aider à écrire trois types de sortie pour des usages AWS : du code Python, une configuration JSON, une expression régulière. Exigence clé : rendre la sortie propre, dans l’un de ces formats, sans explication, en-tête ni conclusion. Le premier prompt, la version 1, est volontairement naïf :

prompt = f"""
Résous la tâche suivante :
{task}
"""

Deux sources de cas

Le bon réflexe est de combiner. Les cas écrits à la main sont ceux qui comptent vraiment : les bugs déjà rencontrés, les demandes tordues d’utilisateurs réels, les formats qui ont cassé en production ; aucun modèle ne les inventera. La génération apporte le volume et la diversité : trente variantes qui couvrent des angles auxquels vous n’auriez pas pensé.

dataset_manuel = [
    {"input": "Écris un script Python qui liste tous les buckets S3.", "type": "python", "context": "SDK boto3"},
    {"input": "Génère une politique IAM en JSON qui autorise la lecture d'un bucket S3.", "type": "json", "context": "AWS IAM"},
    {"input": "Écris une expression régulière qui valide un ARN AWS.", "type": "regex",
     "context": "Format arn:partition:service:region:compte:ressource"},
]

Générer avec un modèle rapide

Pour générer des données de test, le cours officiel conseille un modèle rapide et économique : la famille Haiku. Sur Google Cloud, au point de terminaison global, Claude Haiku 5.5 coûte 0,10 $ par million de tokens d’entrée, contre 2 $ pour Sonnet 5.5, et c’est le plus rapide de la gamme ; on réserve le modèle principal à l’évaluation elle-même.

import json
from anthropic import AnthropicVertex

client = AnthropicVertex(project_id="votre-projet", region="global")

SCHEMA_CAS = {
    "type": "object",
    "properties": {
        "cas": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "input": {"type": "string"},
                    "type": {"type": "string", "enum": ["python", "json", "regex"]},
                    "context": {"type": "string"},
                    "difficulty": {"type": "string", "enum": ["facile", "moyen", "difficile"]},
                },
                "required": ["input", "type", "context", "difficulty"],
                "additionalProperties": False,
            },
        }
    },
    "required": ["cas"],
    "additionalProperties": False,
}

def generate_dataset(n_cases=10, category="python"):
    """Génère n_cases cas de test pour une catégorie, avec Haiku 5.5."""
    message = client.messages.create(
        model="claude-haiku-5-5",
        max_tokens=8000,  # la réflexion compte dans ce plafond
        messages=[{
            "role": "user",
            "content": f"""Génère {n_cases} cas de test pour évaluer un assistant qui écrit du code pour des tâches AWS.

Catégorie : {category}

Pour chaque cas, fournis :
- "input" : la demande de l'utilisateur, en français ;
- "type" : le type de sortie attendu ({category}) ;
- "context" : le contexte AWS utile ;
- "difficulty" : facile, moyen ou difficile.

Privilégie des tâches qu'une seule fonction Python, un seul objet JSON ou une seule expression régulière suffit à résoudre, sans beaucoup de code.""",
        }],
        output_config={"format": {"type": "json_schema", "schema": SCHEMA_CAS}},
    )
    text = next(block.text for block in message.content if block.type == "text")
    return json.loads(text)["cas"]

La consigne finale reprend celle du cours officiel : des tâches courtes, qu’une seule fonction, un seul objet ou une seule expression suffit à résoudre. Les enum du schéma garantissent que type et difficulty ne prennent que les valeurs prévues.

dataset = list(dataset_manuel)
for categorie in ["python", "json", "regex"]:
    print(f"Génération des cas : {categorie}…")
    cas = generate_dataset(n_cases=10, category=categorie)
    dataset.extend(cas)
    print(f"  {len(cas)} cas générés")

with open("dataset.json", "w", encoding="utf-8") as f:
    json.dump(dataset, f, indent=2, ensure_ascii=False)
print(f"Jeu de test enregistré : dataset.json ({len(dataset)} cas)")

Les cas manuels n’ont pas de champ difficulty : ajoutez-le si vous voulez les compter dans les statistiques ci-dessous.

Examiner le jeu de test

Cette vérification n’est pas facultative : un jeu de test défectueux fausse toutes les évaluations qui en dépendent, et le défaut ne se voit pas, puisque les scores s’affichent normalement. Deux défauts sont fréquents avec des cas générés : des variantes presque identiques qui gonflent une catégorie, et des demandes irréalistes ou mal posées.

from collections import Counter

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

print("Par type :", Counter(cas["type"] for cas in dataset))
print("Par difficulté :", Counter(cas.get("difficulty", "?") for cas in dataset))
for cas in dataset[:5]:
    print(f"  [{cas['type']}] {cas['input'][:70]}")

Améliorer la diversité

La génération tend à l’homogénéité : demandez trente cas et vous obtiendrez trente variations autour du plus probable. Les difficultés réelles se trouvent aux extrêmes : entrée vide, texte très long, caractères spéciaux, demande ambiguë. Il faut les réclamer explicitement. Ajoutez à la consigne de génération des exigences de couverture, par exemple :

- Couvre au moins cinq services AWS différents (S3, Lambda, IAM, EC2, DynamoDB, SQS…).
- Répartis les difficultés : un tiers facile, un tiers moyen, un tiers difficile.
- Inclus au moins deux cas limites.
- Les demandes doivent être réalistes, pas génériques.

et un champ aws_service au schéma pour vérifier la répartition.

Bonnes pratiques

À vous de jouer

Votre jeu de test. Pour l’assistant de votre choix, écrivez cinq cas à la main, générez-en vingt avec Haiku 5.5, enregistrez le tout, puis relisez dix cas : combien garderiez-vous ?

Mesurer la diversité. Générez deux fois dix cas avec la consigne de base, puis avec les exigences de couverture. Comptez les services AWS distincts et les cas limites dans chaque jeu.

Sources officielles : Generating test datasets (Claude Academy) · Structured outputs et Define success criteria and build evaluations (documentation Claude) · Partner models pricing (Google Cloud : tarifs de Claude)

Points clés à retenir

• Les cas critiques s’écrivent à la main ; le volume se génère avec un modèle rapide, Haiku.
• Les sorties structurées, avec des enum, garantissent un JSON exploitable ; le préremplissage du cours officiel ne fonctionne plus sur les modèles actuels.
• Le jeu se relit avant usage, s’enregistre et se versionne.
• La diversité se demande : services, difficultés, cas limites.