Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A/B tesztelési promptok

15. lecke 16 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. A/B tesztelési promptok
  2. Elv
  3. A/B tesztelési keretrendszer
  4. Értékelési mutatók
  5. Teljes példa: Két promptstílus tesztelése
  6. Statisztikai szignifikancia
  7. Az első kísérleted elindítása
  8. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért expliciten meg kell adniuk a reasoning={"effort": "none"} (Responses API) vagy reasoning_effort="none" (Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.

A/B tesztelési promptok

A promptok A/B tesztelése lehetővé teszi, hogy valós forgalom alapján objektíven összehasonlíts egy prompt két változatát. Ahelyett, hogy ösztönösen választanál, megméred, melyik hoz jobb eredményeket az üzleti mutatóid szerint. Ez a kötelező lépés a prototípuskészítés és az élesítés között.

Elv

A bejövő forgalmat véletlenszerűen osztod szét két (vagy több) promptvariáns között. Minden választ kiértékelsz előre meghatározott szempontok alapján, és a győztes variánst a forgalom 100%-ára telepíted.

A módszer ereje abban rejlik, hogy mindkét variáns ugyanazzal a forgalommal, ugyanazon feltételek mellett, ugyanabban az időben néz szembe. Minden külső változékonysági forrás – szezonalitás, hálózati incidensek, új kéréstípusok megjelenése – mindkét csoportot egyformán érinti, így a comparison során kioltják egymást. Egy szekvenciális teszt ezt nem garantálhatja: ha egy hétig a régi, majd a következő héten az új promptot futtatod, nem tudod eldönteni, hogy a javulás az átírásodnak vagy a naptárnak köszönhető.

A/B tesztelési keretrendszer

A PromptExperiment osztálynak három feladata van. Az assign_variant eldönti, melyik variáns szolgáljon ki egy adott kérést, a run végrehajtja a hívást és naplózza az eredményt, a get_stats pedig aggregálja az adatokat.

A hozzárendelés külön figyelmet érdemel. Ha megadsz egy user_id-t, a hozzárendelés determinisztikus lesz, amelyet a kísérlet és a felhasználó párosának hash-értékéből számítunk. Ugyanaz a felhasználó hívásról hívásra ugyanabban a csoportban marad. Ez a folytonosság nem elméleti finomság: egy ügyfél, aki először meleg hangnemű választ kap, majd három perccel később száraz választ a követésére, azt hinné, hogy hiba történt, és elégedetlensége mindkét variánst szennyezné.

Minden végrehajtás rögzíti a bemenetet, a kimenetet, a felhasznált tokeneket és az időbélyeget. Ezek a tokének nem díszítésnek vannak: egy variáns nyerhet a minőségben, miközben megduplázza a válasz hosszát, és az _estimate_cost ezt a különbséget dollárra váltja, így megalapozott kompromisszumot köthetsz.

import random
import json
from datetime import datetime
from openai import OpenAI

client = OpenAI()

class PromptExperiment:
    """A/B tesztelési keretrendszer promptokhoz."""

    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:
        """Hozzárendel egy variánst (sticky user_id alapján, ha meg van adva)."""
        if user_id:
            # Determinisztikus hozzárendelés felhasználó alapján
            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:
        """Végrehajtja a promptot a hozzárendelt variánssal."""
        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:
        """Statisztikákat számít variánsenként."""
        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:
        """Becsült költség USD-ben."""
        return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000

Értékelési mutatók

A mutatók a használati esetedtől függenek, és két család lefedi a legtöbb forgatókönyvet. Ha a feladatnak van helyes válasza – például egy jegy osztályozása vagy egy mező kinyerése –, az értékelés arra redukálódik, hogy összehasonlítod egy referenciacímkével. Ezt a szerepet tölti be az evaluer_classification. Figyeld meg a tanulságos választást itt: a feldolgozási hibákat üres előrejelzésként kezeljük ahelyett, hogy kivételt dobnánk, mert annak a variánsnak, amely érvénytelen JSON-t produkál, büntetnie kell magát a pontszámban, nem pedig összeomlasztania a mérést.

Amikor a feladat szabad szöveget eredményez, nincs egyetlen helyes válasz, így a modellt kéred fel döntőbírónak. Az evaluer_qualite_texte négy kritériumra bontja az ítéletet – relevancia, érthetőség, teljesség, professzionális hangnem –, ahelyett, hogy közvetlen összesített pontszámot kérne. Ez a lebontás stabilabbá teszi az értékelést, és megmutatja, melyik tengelyen jeleskedik a győztes variáns: annak ismerete, hogy a nyereség a hangnemből és nem a teljességből származik, pontosan az az információ, amire szükséged van a következő verzió megírásához.

def evaluer_classification(result: dict,
                            label_attendu: str) -> dict:
    """Kiértékel egy osztályozási választ."""
    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:
    """Kiértékeli a szöveges válasz minőségét az LLM segítségével."""
    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # a temperature megköveteli a none effortet
        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)

Teljes példa: Két promptstílus tesztelése

Az alábbi kísérlet két ügyfélszolgálati megközelítést állít szembe. A kontroll egy minimális, professzionális és semleges utasítást használ. Az „empátiikus“ variáns egy három lépésből álló struktúrát ír elő: ismerd el a problémát, fejezz ki empátiát, majd javasolj konkrét megoldást lépésekkel. Minden más azonos, a modelltől a hőmérsékletig. Ez a szimmetria a feltétele annak, hogy bármilyen mért különbséget a promptnak tulajdoníts. Ha egyszerre változtatnád meg a hangnemet és a hőmérsékletet, az értelmezhetetlen eredményt adna.

Az öt tesztjegy szándékosan különböző regisztereket fed le: egy érzelmileg telített kézbesítési incidenst, egy funkcionális hibát, egy semleges jelszókérdést, egy vitatott visszatérítési kérelmet és egy technikai profil által jelentett API-kimaradást. Azt várod, hogy az empátiikus variáns domináljon az első kettőben, és büntetve legyen az utolsóban, ahol a beszélgetőpartner státuszt és becslést akar, nem együttérzést. Ez az a nüansz, amit egy globális átlag elmaszkol, és amit a jegyenkénti vizsgálat tár fel – ami gyakran a valódi döntéshez vezet: a kérés típusa alapján irányítsd a forgalmat, ahelyett, hogy egyetlen hangnemet választanál.

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

# Forgalom szimulálása
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))

Statisztikai szignifikancia

Ne vonj le túl gyorsan következtetéseket. Kevés adat mellett az eredmények zajosak, és a klasszikus hiba az, hogy tizenkét megfigyelés alapján a 7,4-et a 6,9 ellenében látva győztest hirdetsz. Az alábbi Student-féle t-próba csak egyetlen kérdésre ad választ: nagyobb-e a megfigyelt különbség annál, amit a véletlen természetesen produkálna két egyenértékű sorozat között?

A 0,05 alatti p_value azt jelenti, hogy egy ilyen különbség valószínűtlen lenne, ha a két variáns egyenlő lenne. Efölött semmit nem bizonyítottál – ami nem ugyanaz, mint az egyenlőség bizonyítása. Legtöbbször egyszerűen nincs elég adatod. Számíts legalább száz megfigyelésre variánsenként, mielőtt következtetnél, és óvakodj a kísértéstől, hogy minden reggel ellenőrizd az eredményeket. Ha elég gyakran nézed, mindig találsz egy pillanatot, amikor a különbség jelentősnek tűnik.

from scipy import stats

def test_significativite(scores_a: list[float],
                          scores_b: list[float]) -> dict:
    """Student-féle t-próba két variáns összehasonlítására."""
    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"
        )
    }

Az első kísérleted elindítása

Válassz egy jól ismert feladatot, és állíts be egy PromptExperiment-et két variánssal, ahol csak egy dolgot változtatsz a kontroll és a variáns között: egy hangnemet, egy előírt struktúrát vagy egy további utasítást. Mielőtt bármit elindítanál, definiálj két vagy három mutatót, mert a mutató eredmények utáni kiválasztása olyan, mint előre kiválasztani a győztest, és ez a leggyakoribb torzítás a házi készítésű tesztekben.

Futtasd a kísérletet húsz bemeneten, majd elemezz. Nézd meg az átlagot, de különösen nyisd meg azokat az eseteket, ahol a két variáns a leginkább eltér: ezek magyarázzák a különbséget. Húsz megfigyelés nyilván nem lesz elég a szignifikancia eléréséhez, és ezt magadnak rájönni jobb, mint itt olvasni. Végül dokumentáld a döntést, és archiváld a nyers eredményeket a dátummal és a pontos variánskonfigurációval – ez az archívum akadályozza meg, hogy egy év múlva ugyanazt a kísérletet futtasd le újra.

Főbb megállapítások

  • Az A/B tesztelés az ösztönt mérhető adatokkal helyettesíti
  • A variánsokat determinisztikusan, felhasználó alapján rendeld hozzá
  • Üzleti mutatókat mérj, ne csak az érzékelt minőséget
  • Várd meg a statisztikai szignifikanciát, mielőtt következtetnél
  • Dokumentálj minden kísérletet és annak eredményeit