A/B тестване на подкани
На тази страница
Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите
temperatureиtop_pсе приемат само при усилие за разсъждение (reasoning effort) със стойностnone, докато моделите от серията GPT-5.6 разсъждават по подразбиране (medium). Следователно заявките, които задават тези параметри, трябва изрично да включватreasoning={"effort": "none"}(Responses API) илиreasoning_effort="none"(Chat Completions). Източници: Използване на GPT-6 · GPT-5.6 Terra.
A/B тестване на подкани
A/B тестването на подкани Ви позволява обективно да сравните две версии на една подкана, използвайки реален трафик. Вместо да избирате подкана въз основа на интуиция, Вие измервате коя от тях произвежда по-добри резултати спрямо Вашите бизнес метрики. Това е задължителната стъпка между прототипирането и внедряването в продукция.
Принцип
Входящият трафик се разпределя случайно между два (или повече) варианта на подканата. Всеки отговор се оценява спрямо предварително дефинирани критерии и печелившият вариант се внедрява за 100% от трафика.
Силата на този метод е, че и двата варианта се сблъскват с един и същи трафик, при едни и същи условия и по едно и също време. Всички външни източници на вариация – сезонност, мрежови инциденти, появата на нова категория заявки – засягат и двете групи еднакво и се неутрализират при сравнението. Последователният тест не може да гарантира това: ако пуснете старата подкана за една седмица, а новата за следващата, няма да можете да кажете дали подобрението идва от Вашето пренаписване или от календара.
Рамка за A/B тестване
Класът PromptExperiment има три отговорности. assign_variant решава кой вариант да обслужи дадена заявка, run изпълнява извикването и записва резултата, а get_stats агрегира данните.
Разпределението заслужава специално внимание. Когато се предостави user_id, то е детерминирано и се изчислява чрез хеш на двойката експеримент-потребител. Един и същи потребител остава в същата група от едно извикване до следващото. Тази приемственост не е теоретично усъвършенстване: клиент, който получи топъл отговор и след това, три минути по-късно, сух отговор на последващия си въпрос, ще помисли, че става въпрос за бъг, а неговото недоволство ще замърси и двата варианта.
Всяко изпълнение записва входа, изхода, консумираните токени и времевия печат. Тези токени не са там за красота: един вариант може да спечели по качество, докато удвоява дължината на отговора, а _estimate_cost превръща тази разлика в долари, за да можете да направите информиран компромис.
import random
import json
from datetime import datetime
from openai import OpenAI
client = OpenAI()
class PromptExperiment:
"""Рамка за A/B тестване на подкани."""
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:
"""Възлага вариант (фиксиран по user_id, ако е предоставен)."""
if user_id:
# Детерминирано разпределение по потребител
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:
"""Изпълнява подканата с възложения вариант."""
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:
"""Изчислява статистика за всеки вариант."""
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:
"""Оценява разхода в USD."""
return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000
Метрики за оценка
Метриките зависят от Вашия случай на употреба и две семейства покриват повечето сценарии. Когато задачата има правилен отговор – класифициране на билет, извличане на поле – оценката се свежда до сравнение с референтен етикет. Това е ролята на evaluer_classification. Обърнете внимание на един поучителен избор тук: грешките при парсиране се третират като празни предсказания, вместо да хвърлят изключение, защото вариант, който произвежда невалиден JSON, трябва да бъде наказан в резултата, а не да срива измерването.
Когато задачата произвежда свободен текст, няма единствен правилен отговор, затова молите модела да арбитрира. evaluer_qualite_texte разбива преценката на четири критерия – релевантност, яснота, пълнота, професионален тон – вместо да иска директна обща оценка. Това разбиване прави оценката по-стабилна и Ви казва по коя ос печелившият вариант превъзхожда: знанието, че печалбата идва от тона, а не от пълнотата, е точно информацията, от която се нуждаете, за да напишете следващата версия.
def evaluer_classification(result: dict,
label_attendu: str) -> dict:
"""Оценява отговор за класификация."""
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:
"""Оценява качеството на текстов отговор, използвайки LLM."""
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature изисква 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)
Пълен пример: Тестване на два стила на подкани
Експериментът по-долу противопоставя два подхода за поддръжка на клиенти. Контролният вариант използва минимална, професионална и неутрална инструкция. Вариантът „емпатичен“ налага тристъпкова структура: признаване на проблема, изразяване на емпатия и след това предлагане на конкретно решение със стъпки. Всичко останало е идентично, от модела до температурата. Тази симетрия е условието за приписване на всяка измерена разлика на подканата. Промяната едновременно на тона и температурата би довела до неинтерпретируем резултат.
Петте тестови билета умишлено обхващат различни регистри: емоционално зареден инцидент с доставка, функционален бъг, неутрален въпрос за парола, спорно искане за възстановяване на средства и прекъсване на API, докладвано от технически профил. Очаквате емпатичният вариант да доминира в първите два и да бъде наказан в последния, където събеседникът иска статус и прогнозно време за решение, а не съчувствие. Това е нюансът, който средната стойност掩ва и който прегледът билет по билет разкрива – често водещ до истинското решение: насочване въз основа на типа заявка, вместо избор на един единствен тон.
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
}
}
)
# Симулиране на трафик
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))
Статистическа значимост
Не правете изводи твърде бързо. При малко данни резултатите са шумни и класическата грешка е да видите 7,4 срещу 6,9 при дванадесет наблюдения и да обявите победител. t-тестът на Стюudent по-долу отговаря на единствения въпрос, който има значение: дали наблюдаваната разлика е по-голяма от тази, която случайността би произвела естествено между две еквивалентни серии?
Стойност на p_value под 0,05 означава, че такава разлика би била малко вероятна, ако двата варианта бяха равни. Над тази стойност Вие не сте доказали нищо – което не е същото като доказване на равенство. Най-често просто Ви липсват данни. Разчитайте на минимум сто наблюдения на вариант, преди да направите извод, и се пазете от желанието да проверявате резултатите всяка сутрин. Ако гледате достатъчно често, винаги ще откриете момент, в който разликата изглежда смислена.
from scipy import stats
def test_significativite(scores_a: list[float],
scores_b: list[float]) -> dict:
"""t-тест на Стюudent за сравняване на два варианта."""
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"
)
}
Стартиране на Вашия първи експеримент
Вземете задача, която познавате добре, и настройте PromptExperiment с два варианта, променяйки само едно нещо между контролния вариант и варианта: тон, наложена структура или допълнителна инструкция. Дефинирайте две или три метрики, преди да стартирате каквото и да е, защото изборът на метрика след виждане на резултатите е като избиране на победителя предварително и това е най-честото отклонение в домашните тестове.
Стартирайте експеримента върху двадесет входа, след което анализирайте. Погледнете средната стойност, но най-вече отворете случаите, в които двата варианта се разминават най-много: те обясняват разликата. Двадесет наблюдения очевидно няма да са достатъчни, за да се достигне значимост, и осъзнаването на това от Вас самите е по-добро, отколкото да го прочетете тук. Накрая, документирайте решението и архивирайте суровите резултати с датата и точната конфигурация на варианта – този архив е това, което ще Ви спре да стартирате същия експеримент отново след година.
Ключови изводи
- A/B тестването замества интуицията с измерими данни
- Разпределяйте вариантите детерминирано по потребител
- Измервайте бизнес метрики, а не само възприеманото качество
- Изчакайте статистическа значимост, преди да направите извод
- Документирайте всеки експеримент и неговите резултати