Generer des jeux de test

Le contexte

Vous construisez un assistant qui genere du code AWS : scripts Python, configurations JSON, expressions regex. Avant d’evaluer votre prompt, vous avez besoin d’un jeu de test representatif.

Deux options : le creer manuellement (long et fastidieux) ou le generer avec Claude (rapide et diversifie).

Creer un dataset manuellement

Pour quelques cas critiques, l’ecriture manuelle reste pertinente :

dataset_manuel = [
    {
        "input": "Ecris un script Python qui liste tous les buckets S3",
        "type": "python",
        "context": "AWS SDK boto3"
    },
    {
        "input": "Genere une policy IAM JSON qui autorise la lecture S3",
        "type": "json",
        "context": "AWS IAM"
    },
    {
        "input": "Ecris 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 generer le reste.

Generer avec Claude (Haiku pour la vitesse)

On utilise un modele rapide et economique (Haiku) pour generer les cas de test, et on reserve le modele principal (Sonnet) pour l’evaluation elle-meme.

La fonction de generation

import anthropic
import json

client = anthropic.Anthropic()

def generate_dataset(n_cases=10, category="python"):
    """
    Genere 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-20250514",
        max_tokens=2048,
        messages=[
            {
                "role": "user",
                "content": f"""Genere {n_cases} cas de test pour evaluer un assistant qui genere du code AWS.

Categorie : {category}

Pour chaque cas, fournis :
- "input" : la requete 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())

Generer le dataset complet

# Generer des cas pour chaque categorie
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

Avant d’utiliser le dataset, verifiez sa qualite :

# 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}")

# Apercu 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...

Ameliorer la diversite

Si le dataset est trop homogene, ajoutez des contraintes dans le prompt de generation :

def generate_diverse_dataset(n_cases=10, category="python"):
    response = client.messages.create(
        model="claude-haiku-4-20250514",
        max_tokens=2048,
        messages=[
            {
                "role": "user",
                "content": f"""Genere {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

Resume

1. Les cas critiques se redigent a la main
2. Le volume se genere avec Claude Haiku (rapide et pas cher)
3. La technique prefill + stop sequence garantit du JSON propre
4. Le dataset se sauvegarde en fichier pour etre reutilise
5. On verifie toujours la qualite avant d’evaluer