Test A/B des prompts
På denna sida
Leçon mise à jour le 3 novembre 2026 sur la base de la documentation OpenAI :
temperatureettop_pne sont acceptés qu’avec un effort de raisonnement denone, alors que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifierreasoning={"effort": "none"}(API Responses) oureasoning_effort="none"(Chat Completions). Sources : Using GPT-6 · GPT-5.6 Terra.
Test A/B des prompts
Le test A/B des prompts te permet de comparer objectivement deux versions d’un prompt en utilisant du trafic réel. Au lieu de choisir un prompt sur la base de ton intuition, tu mesures lequel produit les meilleurs résultats selon tes indicateurs métier. C’est l’étape obligatoire entre le prototypage et la mise en production.
Principe
Le trafic entrant est réparti aléatoirement entre deux (ou plusieurs) variantes de prompts. Chaque réponse est évaluée selon des critères prédéfinis, et la variante gagnante est déployée sur 100 % du trafic.
La force de cette méthode réside dans le fait que les deux variantes affrontent le même trafic, dans les mêmes conditions et au même moment. Toutes les sources externes de variation — saisonnalité, incidents réseau, arrivée d’une nouvelle catégorie de requêtes — affectent les deux groupes de manière égale et s’annulent dans la comparaison. Un test séquentiel ne peut garantir cela : exécuter l’ancien prompt pendant une semaine et le nouveau la semaine suivante t’empêche de savoir si l’amélioration vient de ta réécriture ou du calendrier.
Cadre de test A/B
La classe PromptExperiment a trois responsabilités. assign_variant décide quelle variante sert une requête donnée, run exécute l’appel et journalise le résultat, et get_stats agrège les données.
L’attribution mérite une note. Lorsqu’un user_id est fourni, elle est déterministe, calculée à partir d’un hachage de la paire expérience-utilisateur. Le même utilisateur reste dans le même groupe d’un appel à l’autre. Cette continuité n’est pas un raffinement théorique : un client qui reçoit une réponse chaleureuse puis, trois minutes plus tard, une réponse sèche à son suivi pensera qu’il s’agit d’un bug, et son insatisfaction polluera les deux variantes.
Chaque exécution enregistre l’entrée, la sortie, les jetons consommés et l’horodatage. Ces jetons ne sont pas là pour la décoration : une variante peut gagner en qualité tout en doublant la longueur de la réponse, et _estimate_cost traduit cet écart en dollars pour te permettre de faire un compromis éclairé.
import random
import json
from datetime import datetime
from openai import OpenAI
client = OpenAI()
class PromptExperiment:
"""Cadre de test A/B pour les prompts."""
def __init__(self, name: str, variants: dict[str, dict]):
"""
variants = {
"control": {"system_prompt": "...", "model": "gpt-5.6-terra",
"temperature": 0.3},
"variant_a": {"system_prompt": "...", "model": "gpt-5.6-terra",
"temperature": 0.1},
}
"""
self.name = name
self.variants = variants
self.results = {v: [] for v in variants}
def assign_variant(self, user_id: str = None) -> str:
"""Attribue une variante (persistante par user_id si fourni)."""
if user_id:
# Attribution déterministe par utilisateur
hash_val = hash(f"{self.name}:{user_id}") % 100
keys = sorted(self.variants.keys())
split = 100 // len(keys)
for i, key in enumerate(keys):
if hash_val < (i + 1) * split:
return key
return keys[-1]
return random.choice(list(self.variants.keys()))
def run(self, input_text: str, user_id: str = None,
schema: dict = None) -> dict:
"""Exécute le prompt avec la variante attribuée."""
variant_name = self.assign_variant(user_id)
variant = self.variants[variant_name]
kwargs = {
"model": variant["model"],
"instructions": variant["system_prompt"],
"input": input_text,
"temperature": variant.get("temperature", 0.3)
}
if schema:
kwargs["text"] = {
"format": {
"type": "json_schema",
"name": "response",
"schema": schema,
"strict": True
}
}
response = client.responses.create(**kwargs)
result = {
"variant": variant_name,
"input": input_text,
"output": response.output_text,
"tokens_input": response.usage.input_tokens,
"tokens_output": response.usage.output_tokens,
"timestamp": datetime.now().isoformat()
}
self.results[variant_name].append(result)
return result
def get_stats(self) -> dict:
"""Calcule les statistiques par variante."""
stats = {}
for variant, results in self.results.items():
if not results:
continue
tokens_in = [r["tokens_input"] for r in results]
tokens_out = [r["tokens_output"] for r in results]
stats[variant] = {
"count": len(results),
"avg_tokens_input": sum(tokens_in) / len(tokens_in),
"avg_tokens_output": sum(tokens_out) / len(tokens_out),
"total_cost_estimate": self._estimate_cost(
sum(tokens_in), sum(tokens_out)
)
}
return stats
def _estimate_cost(self, tokens_in: int,
tokens_out: int) -> float:
"""Estime le coût en USD."""
return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000
Métriques d’évaluation
Les métriques dépendent de ton cas d’usage, et deux familles couvrent la plupart des scénarios. Lorsque la tâche a une réponse correcte — classer un ticket, extraire un champ — l’évaluation se résume à une comparaison avec une étiquette de référence. C’est le rôle de evaluer_classification. Note un choix instructif ici : les échecs d’analyse sont traités comme des prédictions vides plutôt que de lever une exception, car une variante qui produit un JSON invalide doit être pénalisée dans le score, et non faire planter la mesure.
Lorsque la tâche produit du texte libre, il n’y a pas de réponse unique correcte, tu demandes donc au modèle d’arbitrer. evaluer_qualite_texte décompose le jugement en quatre critères — pertinence, clarté, exhaustivité, ton professionnel — plutôt que de demander une note globale directe. Cette décomposition rend l’évaluation plus stable et t’indique sur quel axe la variante gagnante excelle : savoir que le gain vient du ton plutôt que de l’exhaustivité est précisément l’information dont tu as besoin pour écrire la prochaine version.
def evaluer_classification(result: dict,
label_attendu: str) -> dict:
"""Évalue une réponse de classification."""
try:
output = json.loads(result["output"])
prediction = output.get("category", "")
except json.JSONDecodeError:
prediction = ""
return {
"correct": prediction == label_attendu,
"prediction": prediction,
"attendu": label_attendu
}
def evaluer_qualite_texte(result: dict) -> dict:
"""Évalue la qualité d'une réponse textuelle en utilisant le LLM."""
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
instructions="You are a text quality evaluator. "
"Rate out of 10 based on: relevance, clarity, "
"completeness, professional tone.",
input=f"Question: {result['input']}\n\n"
f"Answer: {result['output']}",
text={
"format": {
"type": "json_schema",
"name": "evaluation",
"schema": {
"type": "object",
"properties": {
"pertinence": {"type": "integer"},
"clarte": {"type": "integer"},
"completude": {"type": "integer"},
"ton": {"type": "integer"},
"note_globale": {"type": "number"},
"commentaire": {"type": "string"}
},
"required": ["pertinence", "clarte",
"completude", "ton",
"note_globale", "commentaire"],
"additionalProperties": False
},
"strict": True
}
},
temperature=0.1
)
return json.loads(eval_response.output_text)
Exemple complet : tester deux styles de prompts
L’expérience ci-dessous oppose deux approches du support client. Le contrôle utilise une instruction minimale, professionnelle et neutre. La variante « empathique » impose une structure en trois étapes : reconnaître le problème, exprimer de l’empathie, puis proposer une solution avec des étapes. Tout le reste est identique, du modèle à la température. Cette symétrie est la condition pour attribuer tout écart mesuré au prompt. Changer à la fois le ton et la température donnerait un résultat ininterprétable.
Les cinq tickets de test couvrent délibérément différents registres : un incident de livraison chargé émotionnellement, un bug fonctionnel, une question neutre sur le mot de passe, une demande de remboursement litigieuse et une panne d’API signalée par un profil technique. Tu t’attends à ce que la variante empathique domine les deux premiers et soit pénalisée sur le dernier, où l’interlocuteur veut un statut et un délai, pas de la compassion. C’est cette nuance qu’une moyenne globale masque et qu’un examen ticket par ticket révèle — conduisant souvent à la vraie décision : router selon le type de demande plutôt que de choisir un ton unique.
experiment = PromptExperiment(
name="customer-support-style",
variants={
"control": {
"system_prompt": "You are a support agent. "
"Respond professionally.",
"model": "gpt-5.6-terra",
"temperature": 0.3
},
"empathique": {
"system_prompt": "You are a caring support agent. "
"Start by acknowledging the customer's problem, "
"show empathy, then propose a concrete solution "
"with steps.",
"model": "gpt-5.6-terra",
"temperature": 0.3
}
}
)
# Simuler le trafic
test_tickets = [
"My package hasn't arrived in 2 weeks.",
"The app crashes when I click on Settings.",
"How do I change my password?",
"I want a refund, the product is defective.",
"Your API has been returning a 500 error since this morning.",
]
for ticket in test_tickets:
result = experiment.run(ticket)
quality = evaluer_qualite_texte(result)
print(f"Variant: {result['variant']} | "
f"Score: {quality['note_globale']}/10")
print("\nStatistics:")
print(json.dumps(experiment.get_stats(), indent=2))
Signification statistique
Ne tire pas de conclusions trop rapidement. Avec peu de données, les résultats sont bruités, et l’erreur classique est de voir 7,4 contre 6,9 sur douze observations et de déclarer un vainqueur. Le test t de Student ci-dessous répond à la seule question qui compte : l’écart observé est-il plus grand que ce que le hasard produirait naturellement entre deux séries équivalentes ?
Une p_value inférieure à 0,05 signifie qu’un tel écart serait improbable si les deux variantes étaient égales. Au-dessus de ce seuil, tu n’as rien démontré — ce qui n’est pas la même chose que démontrer l’égalité. Le plus souvent, tu manques simplement de données. Compte sur un minimum de cent observations par variante avant de conclure, et méfie-toi de l’envie de vérifier les résultats chaque matin. Si tu regardes assez souvent, tu trouveras toujours un moment où l’écart semble significatif.
from scipy import stats
def test_significativite(scores_a: list[float],
scores_b: list[float]) -> dict:
"""Test t de Student pour comparer deux variantes."""
t_stat, p_value = stats.ttest_ind(scores_a, scores_b)
return {
"moyenne_a": sum(scores_a) / len(scores_a),
"moyenne_b": sum(scores_b) / len(scores_b),
"p_value": p_value,
"significatif": p_value < 0.05,
"recommandation": (
"Significant difference, deploy the winning variant"
if p_value < 0.05
else "Not enough data or no significant difference"
)
}
Lancer ta première expérience
Prends une tâche que tu connais bien et configure un PromptExperiment avec deux variantes, en ne changeant qu’une seule chose entre le contrôle et la variante : un ton, une structure imposée ou une instruction supplémentaire. Définis deux ou trois métriques avant de lancer quoi que ce soit, car choisir la métrique après avoir vu les résultats revient à choisir le vainqueur à l’avance, et c’est le biais le plus courant dans les tests maison.
Exécute l’expérience sur vingt entrées, puis analyse. Regarde la moyenne, mais surtout ouvre les cas où les deux variantes divergent le plus : ce sont eux qui expliquent l’écart. Vingt observations ne suffiront évidemment pas à atteindre la significativité, et le réaliser toi-même vaut mieux que de le lire ici. Enfin, documente la décision et archive les résultats bruts avec la date et la configuration exacte de la variante — c’est cette archive qui t’empêchera de refaire la même expérience dans un an.
Viktiga punkter
- Le test A/B remplace l’intuition par des données mesurables
- Attribue les variantes de manière déterministe par utilisateur
- Mesure les indicateurs métier, pas seulement la qualité perçue
- Attends la significativité statistique avant de conclure
- Documente chaque expérience et ses résultats