A/B-testaus kehotteille
Tällä sivulla
Oppitunti päivitetty 3. marraskuuta 2026 OpenAI:n dokumentaation perusteella:
temperaturejatop_phyväksytään vain, kun päättelypyrkimys onnone, kun taas GPT-5.6-mallit käyttävät oletusarvoisesti päättelyä (medium). Näitä parametreja asettavien kutsujen on siksi määritettäväreasoning={"effort": "none"}(Responses API) taireasoning_effort="none"(Chat Completions). Lähteet: Using GPT-6 · GPT-5.6 Terra.
A/B-testaus kehotteille
Kehotteiden A/B-testaus mahdollistaa kahden kehotteen version objektiivisen vertailun todellisella liikenteellä. Sen sijaan, että valitsisit kehotteen intuition perusteella, mittaat, kumpi tuottaa parempia tuloksia liiketoimintamittareidesi mukaan. Tämä on pakollinen vaihe prototyypin ja tuotantoon siirtymisen välillä.
Periaate
Saapuva liikenne jaetaan satunnaisesti kahden (tai useamman) kehotemuunnoksen kesken. Jokainen vastaus arvioidaan ennalta määriteltyjen kriteerien perusteella, ja voittava muunnos otetaan käyttöön 100 %:lle liikenteestä.
Menetelmän vahvuus on siinä, että molemmat muunnokset kohtaavat saman liikenteen samoissa olosuhteissa samaan aikaan. Kaikki ulkoiset vaihtelun lähteet – kausivaihtelu, verkkohäiriöt, uuden pyyntötyypin saapuminen – vaikuttavat molempiin ryhmiin yhtä lailla ja kumoavat toisensa vertailussa. Peräkkäinen testi ei takaa tätä: vanhan kehotteen käyttäminen viikon ja uuden seuraavan viikon aikana ei kerro, johtuiko parannus uudelleenkirjoituksesta vai kalenterista.
A/B-testauskehys
PromptExperiment-luokalla on kolme vastuualuetta. assign_variant päättää, mikä muunnos palvelee tiettyä pyyntöä, run suorittaa kutsun ja kirjaa tuloksen, ja get_stats kokoaa tiedot.
Määrittäminen ansaitsee huomion. Kun user_id annetaan, määrittäminen on determinististä ja lasketaan kokeen ja käyttäjän parin hash-arvosta. Sama käyttäjä pysyy samassa ryhmässä kutsusta toiseen. Tämä jatkuvuus ei ole teoreettinen hienosäätö: asiakas, joka saa lämpimän vastauksen ja sitten kolme minuuttia myöhemmin kuivan vastauksen seurantarviinsä, luulee sen olevan bugi, ja hänen tyytymättömyytensä saastuttaa molemmat muunnokset.
Jokainen suoritus tallentaa syötteen, tulosteen, kulutetut tokenit ja aikaleiman. Nämä tokenit eivät ole koristeeksi: muunnos voi voittaa laadussa mutta kaksinkertaistaa vastauksen pituuden, ja _estimate_cost muuntaa tämän eron dollareiksi, jotta voit tehdä informoidun kompromissin.
import random
import json
from datetime import datetime
from openai import OpenAI
client = OpenAI()
class PromptExperiment:
"""Kehotteiden A/B-testauskehys."""
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:
"""Määrittää muunnoksen (sitova user_id:n perusteella, jos annettu)."""
if user_id:
# Deterministinen määrittäminen käyttäjän perusteella
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:
"""Suorittaa kehotteen määritetyllä muunnoksella."""
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:
"""Laskee tilastot muunnosta kohden."""
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:
"""Arvioi kustannukset USD:ssä."""
return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000
Arviointimittarit
Mittarit riippuvat käyttötarkoituksestasi, ja kaksi luokkaa kattaa useimmat skenaariot. Kun tehtävällä on oikea vastaus – kuten lipun luokittelu tai kentän erottelu – arviointi pelkistyy vertailuun viitearvoon. Tämä on evaluer_classification-funktion rooli. Huomaa tässä opettavainen valinta: jäsentämisvirheet käsitellään tyhjinä ennusteina poikkeuksen heittämisen sijaan, koska muunnos, joka tuottaa virheellistä JSONia, tulee rankaista pisteytyksessä, eikä mittauksen kaatuessa.
Kun tehtävä tuottaa vapaata tekstiä, yhtä oikeaa vastausta ei ole, joten pyydät mallia toimimaan arbitraattorina. evaluer_qualite_texte jakaa arvion neljään kriteeriin – relevanssi, selkeys, täydellisyys, ammattimainen sävy – sen sijaan, että pyytäisi suoraa kokonaispisteytystä. Tämä jako tekee arvioinnista vakaampaa ja kertoo, missä akselissa voittava muunnos loistaa: tieto siitä, että hyöty tulee sävystä eikä täydellisyydestä, on juuri se tieto, jota tarvitset seuraavan version kirjoittamiseen.
def evaluer_classification(result: dict,
label_attendu: str) -> dict:
"""Arvioi luokitteluvastauksen."""
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:
"""Arvioi tekstivastauksen laadun LLM:n avulla."""
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature vaatii 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)
Täydellinen esimerkki: Kahden kehotetyylin testaus
Alla oleva koe vertaa kahta lähestymistapaa asiakastukeen. Kontrolli käyttää minimaalista, ammattimaista ja neutraalia ohjetta. “Empaattinen” muunnos määrää kolmivaiheisen rakenteen: tunnusta ongelma, osoita empatiaa ja ehdota sitten konkreettista ratkaisua vaiheittain. Kaikki muu on identtistä, mallista lämpötilaan. Tämä symmetria on ehto sille, että mitattu ero voidaan johtaa kehotteeseen. Sekä sävyn että lämpötilan muuttaminen samanaikaisesti tuottaisi tulkintakelvottoman tuloksen.
Viisi testilippua kattavat tarkoituksellisesti erilaisia rekistereitä: emotionaalisesti latautunut toimitusongelma, toiminnallinen bugi, neutraali salasanakysymys, kiistanalainen hyvityspyyntö ja teknisen profiilin raportoima API-katko. Odotat empaattisen muunnoksen dominoivan kahta ensimmäistä ja saavan sanktioita viimeisessä, jossa keskustelukumppani haluaa tilatiedot ja ETA-ajan, ei myötätuntoa. Tämä on se vivahde, jonka globaali keskiarvo peittää ja joka paljastuu lippukohtaisessa tarkastelussa – mikä johtaa usein todelliseen päätökseen: reititä pyyntötyypin perusteella yhden sävyn valitsemisen sijaan.
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
}
}
)
# Simuloi liikennettä
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))
Tilastollinen merkitsevyys
Älä tee johtopäätöksiä liian nopeasti. Pienellä datalla tulokset ovat kohinaisia, ja klassinen virhe on nähdä 7,4 versus 6,9 kahdentoista havainnon perusteella ja julistaa voittaja. Alla oleva Studentin t-testi vastaa ainoaan kysymykseen, joka merkitsee: onko havaittu ero suurempi kuin mitä sattuma tuottaisi luonnostaan kahden ekvivalentin sarjan välille?
p_value alle 0,05 tarkoittaa, että tällainen ero olisi epätodennäköinen, jos kaksi muunnosta olisivat yhtä suuria. Sen yläpuolella et ole osoittanut mitään – mikä ei ole sama asia kuin yhtäläisyyden osoittaminen. Useimmiten sinulta puuttuu vain dataa. Luota vähintään sataan havaintoon muunnosta kohden ennen johtopäätösten tekemistä, ja varo halua tarkistaa tulokset joka aamu. Jos tarkistat tarpeeksi usein, löydät aina hetken, jolloin ero vaikuttaa merkitykselliseltä.
from scipy import stats
def test_significativite(scores_a: list[float],
scores_b: list[float]) -> dict:
"""Studentin t-testi kahden muunnoksen vertailuun."""
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"
)
}
Ensimmäisen kokeesi suorittaminen
Ota tehtävä, jonka tunnet hyvin, ja luo PromptExperiment kahdella muunnoksella muuttaen vain yhtä asiaa kontrollin ja muunnoksen välillä: sävyä, määrättyä rakennetta tai lisäohjetta. Määrittele kaksi tai kolme mittaria ennen kuin käynnistät mitään, koska mittarin valitseminen tulosten näkemisen jälkeen on kuin voittajan valitsemista etukäteen, ja se on yleisin vinouma itse tehdyissä testeissä.
Suorita koe kahdellakymmenellä syötteellä ja analysoi sitten. Katso keskiarvoa, mutta erityisesti avaa tapaukset, joissa kaksi muunnosta poikkeavat toisistaan eniten: ne selittävät eron. Kaksikymmentä havaintoa ei ilmeisestikään riitä merkitsevyyden saavuttamiseen, ja tämän oivaltaminen itse on parempaa kuin sen lukeminen täältä. Lopuksi dokumentoi päätös ja arkistoi raakatulokset päivämäärineen ja muunnosten tarkkojen konfiguraatioiden kanssa – tämä arkisto on se, mikä estää sinua suorittamasta samaa koetta uudelleen vuoden kuluttua.
Keskeiset asiat
- A/B-testaus korvaa intuition mitattavalla datalla
- Määritä muunnokset deterministisesti käyttäjän perusteella
- Mittaa liiketoimintamittareita, älä vain koettua laatua
- Odota tilastollista merkitsevyyttä ennen johtopäätöksiä
- Dokumentoi jokainen koe ja sen tulokset