Testy A/B pro prompty
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry
temperatureatop_pjsou akceptovány pouze při úsilí o uvažování (reasoning effort) nastaveném nanone, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovatreasoning={"effort": "none"}(Responses API) neboreasoning_effort="none"(Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.
Testy A/B pro prompty
Testování promptů metodou A/B ti umožňuje objektivně porovnat dvě verze promptu pomocí reálného provozu. Místo toho, abys vybral prompt na základě intuice, změříš, který z nich přináší lepší výsledky podle tvých obchodních metrik. Toto je povinný krok mezi prototypováním a nasazením do produkce.
Princip
Příchozí provoz je náhodně rozdělen mezi dvě (nebo více) variant promptu. Každá odpověď je hodnocena podle předem definovaných kritérií a vítězná varianta je nasazena na 100 % provozu.
Silnou stránkou této metody je, že obě varianty čelí stejnému provozu, za stejných podmínek a ve stejný čas. Všechny vnější zdroje variací – sezónnost, výpadky sítě, příchod nové kategorie požadavků – ovlivňují obě skupiny stejně a při porovnání se vyruší. Sekvenční test toto nemůže zaručit: pokud spustíš starý prompt jeden týden a nový další, nebudeš schopen rozeznat, zda zlepšení přišlo díky tvému přepsání, nebo jen kvůli kalendáři.
Framework pro testy A/B
Třída PromptExperiment má tři odpovědnosti. assign_variant rozhoduje, která varianta obslouží daný požadavek, run provede volání a zaznamená výsledek a get_stats agreguje data.
Přiřazení si zaslouží zmínku. Pokud je poskytnuto user_id, je přiřazení deterministické, vypočítané z hashe dvojice experiment-uživatel. Stejný uživatel zůstává ve stejné skupině od jednoho volání k druhému. Tato kontinuita není teoretickou vylepšením: zákazník, který obdrží vřelou odpověď a o tři minuty později suchou odpověď na svůj následný dotaz, si bude myslet, že jde o chybu, a jeho nespokojenost znečistí obě varianty.
Každé provedení zaznamenává vstup, výstup, spotřebované tokeny a časové razítko. Tyto tokeny tu nejsou jen pro okrasu: varianta může zvítězit v kvalitě, ale zdvojnásobit délku odpovědi, a _estimate_cost převádí tento rozdíl na dolary, abys mohl učinit informované rozhodnutí o kompromisu.
import random
import json
from datetime import datetime
from openai import OpenAI
client = OpenAI()
class PromptExperiment:
"""Framework pro A/B testování promptů."""
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:
"""Přiřadí variantu (lepivá podle user_id, pokud je poskytnuto)."""
if user_id:
# Deterministické přiřazení podle uživatele
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:
"""Provede prompt s přiřazenou variantou."""
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:
"""Vypočítá statistiky pro každou variantu."""
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:
"""Odhadne náklady v USD."""
return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000
Evaluační metriky
Metriky závisí na tvém případě použití a dvě rodiny pokrývají většinu scénářů. Když má úkol správnou odpověď – klasifikace tiketu, extrakce pole – evaluace se сводí k porovnání s referenčním štítkem. To je role funkce evaluer_classification. Všimni si zde poučné volby: selhání parsování jsou treatována jako prázdné predikce místo vyvolání výjimky, protože varianta, která produkuje neplatné JSON, by měla být penalizována ve skóre, nikoliv shodit měření.
Když úkol produkuje volný text, neexistuje jedna správná odpověď, takže požádáš model, aby rozhodl. evaluer_qualite_texte rozkládá úsudek na čtyři kritéria – relevance, srozumitelnost, úplnost, profesionální tón – místo žádosti o přímé celkové skóre. Tento rozklad činí evaluaci stabilnější a říká ti, na které ose vítězná varianta vyniká: vědět, že zisk pochází z tónu spíše než z úplnosti, je přesně informace, kterou potřebuješ k napsání další verze.
def evaluer_classification(result: dict,
label_attendu: str) -> dict:
"""Evaluuje klasifikační odpověď."""
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:
"""Evaluuje kvalitu textové odpovědi pomocí LLM."""
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature vyžaduje 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)
Kompletní příklad: Testování dvou stylů promptů
Níže uvedený experiment kontrastuje dva přístupy k zákaznické podpoře. Kontrolní varianta používá minimální, profesionální a neutrální instrukci. Varianta „empatická“ ukládá tříkrokovou strukturu: uznat problém, vyjádřit empatii, poté navrhnout konkrétní řešení s kroky. Všechno ostatní je identické, od modelu po teplotu. Tato symetrie je podmínkou pro připsání jakéhokoli naměřeného rozdílu promptu. Změna tónu i teploty zároveň by vedla k neinterpretovatelnému výsledku.
Pět testovacích tiketů záměrně pokrývá různé registry: emocionálně nabitý incident s doručením, funkční chyba, neutrální dotaz na heslo, sporná žádost o vrácení peněz a výpadek API nahlášený technickým profilem. Očekáváš, že empatická varianta bude dominovat u prvních dvou a bude penalizována u posledního, kde interlocutor chce status a odhad času (ETA), nikoliv soucit. To je nuance, kterou globální průměr maskuje a kterou odhalí zkoumání tiket po tiketu – což často vede ke skutečnému rozhodnutí: směrovat podle typu požadavku místo výběru jednoho tónu.
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
}
}
)
# Simulace provozu
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))
Statistická významnost
Nedělej závěry příliš rychle. S malým množstvím dat jsou výsledky šumivé a klasickou chybou je vidět 7,4 versus 6,9 na dvanácti pozorováních a vyhlásit vítěze. Níže uvedený Studentův t-test odpovídá na jedinou otázku, na které záleží: je pozorovaný rozdíl větší než to, co by náhoda přirozeně vyprodukovala mezi dvěma ekvivalentními sériemi?
Hodnota p_value pod 0,05 znamená, že takový rozdíl by byl nepravděpodobný, pokud by byly obě varianty stejné. Nad touto hodnotou jsi nic neprokázal – což není totéž jako prokázání rovnosti. Nejčastěji ti jen chybí data. Počítej s minimem sto pozorování na variantu před učiněním závěru a dej si pozor na nutkání kontrolovat výsledky každé ráno. Pokud se budeš dívat dost často, vždy najdeš okamžik, kdy se rozdíl bude zdát smysluplný.
from scipy import stats
def test_significativite(scores_a: list[float],
scores_b: list[float]) -> dict:
"""Studentův t-test pro porovnání dvou variant."""
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"
)
}
Spuštění tvého prvního experimentu
Vezmi úkol, který dobře znáš, a nastav PromptExperiment se dvěma variantami, přičemž mezi kontrolní variantou a testovanou variantou změníš pouze jednu věc: tón, vynucenou strukturu nebo dodatečnou instrukci. Před spuštěním čehokoli definuj dvě nebo tři metriky, protože výběr metriky až po shlédnutí výsledků je jako vybírání vítěze předem a je to nejčastější zkreslení u domácích testů.
Spusť experiment na dvaceti vstupech a poté proveď analýzu. Podívej se na průměr, ale především otevři případy, kde se obě varianty nejvíce liší: ty vysvětlují rozdíl. Dvacet pozorování zjevně nebude stačit k dosažení statistické významnosti a uvědomit si to sám je lepší, než si to zde přečíst. Nakonec zdokumentuj rozhodnutí a archivuj surové výsledky s datem a přesnou konfigurací varianty – tento archiv je tím, co ti zabrání spustit stejný experiment znovu za rok.
Klíčové poznatky
- Testy A/B nahrazují intuici měřitelnými daty
- Přiřazuj varianty deterministicky podle uživatele
- Měř obchodní metriky, nejen vnímanou kvalitu
- Před učiněním závěru vyčkej na statistickou významnost
- Dokumentuj každý experiment a jeho výsledky