Générer des jeux de test

Le contexte

Vous construisez un assistant qui génère du code AWS : scripts Python, configurations JSON, expressions regex. Avant d’évaluer votre prompt, vous avez besoin d’un jeu de test représentatif.

Deux options, et le bon réflexe est de ne pas choisir : on combine. Les cas que vous écrivez à 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, parce qu’ils viennent de votre expérience.

Ce que la génération apporte, c’est le volume et la diversité : trente variantes qui couvrent des angles auxquels vous n’auriez pas pensé. Un bon jeu de test a les deux — une dizaine de cas issus du terrain, complétés par la machine.

Créer un dataset manuellement

Pour quelques cas critiques, l’écriture manuelle reste pertinente :

dataset_manuel = [
    {
        "input": "Écris un script Python qui liste tous les buckets S3",
        "type": "python",
        "context": "AWS SDK boto3"
    },
    {
        "input": "Génère une policy IAM JSON qui autorise la lecture S3",
        "type": "json",
        "context": "AWS IAM"
    },
    {
        "input": "Écris une regex qui valide un ARN AWS",
        "type": "regex",
        "context": "Format arn:aws:service:region:account:resource"
    }
]

Mais pour 30, 50 ou 100 cas de test, c’est impraticable. On va utiliser Claude pour générer le reste.

Générer avec Claude (Haiku pour la vitesse)

On utilise un modèle rapide et économique (Haiku) pour générer les cas de test, et on réserve le modèle principal (Sonnet) pour l’évaluation elle-même.

La fonction de génération

import anthropic
import json

client = anthropic.Anthropic()

def generate_dataset(n_cases=10, category="python"):
    """
    Génère un jeu de test de n_cases cas pour une categorie donnee.
    Utilise Haiku pour la rapidite et le cout.
    """
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=2048,
        messages=[
            {
                "role": "user",
                "content": f"""Génère {n_cases} cas de test pour evaluer un assistant qui généré du code AWS.

Categorie : {category}

Pour chaque cas, fournis :
- "input" : la requête utilisateur (en francais)
- "type" : le type de sortie attendue ({category})
- "context" : le contexte AWS pertinent
- "difficulty" : facile, moyen ou difficile

Retourne un tableau JSON."""
            },
            {
                "role": "assistant",
                "content": "```json\n"
            }
        ],
        stop_sequences=["```"]
    )

    return json.loads(response.content[0].text.strip())

Générer le dataset complet

# Générer des cas pour chaque catégorie
categories = ["python", "json", "regex"]
dataset = []

for cat in categories:
    print(f"Generation de cas pour : {cat}...")
    cas = generate_dataset(n_cases=10, category=cat)
    dataset.extend(cas)
    print(f"  -> {len(cas)} cas generes")

print(f"\nTotal : {len(dataset)} cas de test")

Sauvegarder le dataset

with open("dataset.json", "w", encoding="utf-8") as f:
    json.dump(dataset, f, indent=2, ensure_ascii=False)

print(f"Dataset sauvegarde : dataset.json ({len(dataset)} cas)")

Examiner le dataset

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 est invisible puisque les scores, eux, s’affichent normalement. Deux défauts sont fréquents avec les cas générés — des variantes quasi identiques qui gonflent artificiellement une catégorie, et des cas dont la réponse attendue est elle-même fausse.

# Charger et inspecter
with open("dataset.json", "r", encoding="utf-8") as f:
    dataset = json.load(f)

# Stats par categorie
from collections import Counter

types = Counter(cas["type"] for cas in dataset)
difficulties = Counter(cas["difficulty"] for cas in dataset)

print("Par type :")
for t, count in types.items():
    print(f"  {t}: {count}")

print("\nPar difficulte :")
for d, count in difficulties.items():
    print(f"  {d}: {count}")

# Aperçu des premiers cas
print("\nApercu :")
for cas in dataset[:3]:
    print(f"  [{cas['type']}] [{cas['difficulty']}] {cas['input'][:60]}...")

Sortie typique :

Par type :
  python: 10
  json: 10
  regex: 10

Par difficulte :
  facile: 12
  moyen: 11
  difficile: 7

Apercu :
  [python] [facile] Ecris un script qui cree un bucket S3 avec un nom specifiq...
  [python] [moyen] Ecris une fonction Lambda qui declenche une notification SN...
  [json] [facile] Genere une policy IAM qui autorise les operations de lectur...

Améliorer la diversité

L’homogénéité est le travers naturel de la génération : demandez trente cas de test et vous obtiendrez trente variations autour du cas le 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ë. Ces cas-là, il faut les réclamer explicitement, sans quoi votre évaluation ne testera que le confort.

def generate_diverse_dataset(n_cases=10, category="python"):
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=2048,
        messages=[
            {
                "role": "user",
                "content": f"""Génère {n_cases} cas de test VARIES pour un assistant AWS.

Categorie : {category}

IMPORTANT :
- Couvre au moins 5 services AWS differents (S3, Lambda, IAM, EC2, DynamoDB, SQS, SNS, CloudWatch...)
- Varie les niveaux de difficulte (1/3 facile, 1/3 moyen, 1/3 difficile)
- Inclus au moins 2 cas limites (edge cases)
- Les requetes doivent etre realistes, pas generiques

Format JSON avec : input, type, context, difficulty, aws_service"""
            },
            {
                "role": "assistant",
                "content": "```json\n"
            }
        ],
        stop_sequences=["```"]
    )

    return json.loads(response.content[0].text.strip())

Bonnes pratiques

Résumé

1. Les cas critiques se rédigent à la main
2. Le volume se génère avec Claude Haiku (rapide et pas cher)
3. La technique prefill + stop séquence garantit du JSON propre
4. Le dataset se sauvegarde en fichier pour être réutilisé
5. On vérifie toujours la qualité avant d’évaluer