Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Testovanie promptov A/B

Lekcia 15 z 16 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Testovanie promptov A/B
  2. Princíp
  3. Rámec pre testovanie A/B
  4. Metriky hodnotenia
  5. Kompletný príklad: Testovanie dvoch štýlov promptov
  6. Štatistická významnosť
  7. Spustenie tvojho prvého experimentu
  8. Kľúčové poznatky

Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre temperature a top_p sú akceptované len pri úsilí o logické uvažovanie (reasoning effort) nastavenom na none, zatiaľ čo modely GPT-5.6 štandardne uvažujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovať reasoning={"effort": "none"} (Responses API) alebo reasoning_effort="none" (Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.

Testovanie promptov A/B

Testovanie promptov A/B ti umožňuje objektívne porovnať dve verzie promptu pomocou reálnej prevádzky. Namiesto toho, aby si vyberal prompt na základe intuície, meriaš, ktorý z nich prináša lepšie výsledky podľa tvojich obchodných metrík. Toto je povinný krok medzi prototypovaním a nasadením do produkcie.

Princíp

Prichádzajúca prevádzka sa náhodne rozdelí medzi dve (alebo viac) variantov promptu. Každá odpoveď sa vyhodnotí podľa vopred definovaných kritérií a víťazný variant sa nasadí na 100 % prevádzky.

Silou tejto metódy je, že oba varianty čelia rovnakej prevádzke, za rovnakých podmienok a v rovnakom čase. Všetky vonkajšie zdroje variácií – sezónnosť, výpadky siete, príchod novej kategórie požiadaviek – ovplyvňujú obe skupiny rovnako a pri porovnaní sa navzájom vyrušia. Sekvenčný test toto nedokáže zaručiť: ak spustíš starý prompt na týždeň a nový na nasledujúci, nebudeš vedieť povedať, či zlepšenie prišlo z tvojej úpravy, alebo z kalendára.

Rámec pre testovanie A/B

Trieda PromptExperiment má tri zodpovednosti. assign_variant rozhoduje, ktorý variant obslúži danú požiadavku, run vykoná volanie a zaznamená výsledok a get_stats agreguje dáta.

Pridelenie variantu si zaslúži poznámku. Ak je poskytnutý user_id, priradenie je deterministické, vypočítané z hashu páru experiment-užívateľ. Ten istý užívateľ zostáva v tej istej skupine od jedného volania k druhému. Táto kontinuita nie je len teoretická vylepšenie: zákazník, ktorý dostane ústretovú odpoveď a o tri minúty neskôr suchú odpoveď na svoju následnú otázku, si bude myslieť, že ide o chybu, a jeho nespokojnosť znečistí obe varianty.

Každé vykonanie zaznamenáva vstup, výstup, spotrebované tokeny a časovú pečiatku. Tieto tokeny nie sú len na okrasu: variant môže vyhrať v kvalite, ale zdvojnásobiť dĺžku odpovede, a _estimate_cost prepočíta tento rozdiel na doláre, aby si mohol urobiť informované rozhodnutie o kompromise.

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

client = OpenAI()

class PromptExperiment:
    """Rámec pre A/B testovanie promptov."""

    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:
        """Priradí variant (trvalo viazaný na user_id, ak je poskytnutý)."""
        if user_id:
            # Deterministické priradenie podľa užívateľa
            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:
        """Vykoná prompt s priradeným variantom."""
        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číta štatistiky pre každý variant."""
        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

Metriky hodnotenia

Metriky závisia od tvojho prípadu použitia a dve rodiny pokrývajú väčšinu scenárov. Keď má úloha správnu odpoveď – klasifikácia tiketu, extrakcia poľa – hodnotenie sa obmedzuje na porovnanie s referenčným označením. To je úloha funkcie evaluer_classification. Všimni si inštruktívnu voľbu: zlyhania pri parsovaní sa považujú za prázdne predpovede namiesto vyvolania výnimky, pretože variant, ktorý produkuje neplatný JSON, by mal byť penalizovaný v skóre, nie spôsobiť pád merania.

Keď úloha produkuje voľný text, neexistuje jedna správna odpoveď, takže požiadaš model, aby rozhodol. Funkcia evaluer_qualite_texte rozkladá úsudok na štyri kritériá – relevantnosť, jasnosť, úplnosť, profesionálny tón – namiesto toho, aby žiadala priame celkové skóre. Tento rozklad robí hodnotenie stabilnejším a povie ti, v ktorej oblasti víťazný variant vyniká: vedieť, že zisk pochádza skôr z tónu než z úplnosti, je presne informácia, ktorú potrebuješ na napísanie ďalšej verzie.

def evaluer_classification(result: dict,
                            label_attendu: str) -> dict:
    """Vyhodnotí odpoveď klasifikácie."""
    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:
    """Vyhodnotí kvalitu textovej odpovede pomocou 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ý príklad: Testovanie dvoch štýlov promptov

Nasledujúci experiment porovnáva dva prístupy k zákazníckej podpore. Kontrolný variant používa minimálnu, profesionálnu a neutrálnu inštrukciu. Variant „empatický“ ukladá trojkrokovú štruktúru: uznať problém, vyjadriť empatiu a potom navrhnúť konkrétne riešenie s krokmi. Všetko ostatné je identické, od modelu po teplotu. Táto symetria je podmienkou pre pripísanie akéhokoľvek nameraného rozdielu promptu. Zmena tónu aj teploty súčasne by viedla k neinterpretovateľnému výsledku.

Päť testovacích tiketov zámerne pokrýva rôzne registre: emocionálne vypätý incident s doručením, funkčná chyba, neutrálna otázka týkajúca sa hesla, sporná požiadavka na vrátenie peňazí a výpadok API nahlásený technickým profilom. Očakávaš, že empatický variant bude dominovať v prvých dvoch prípadoch a bude penalizovaný v poslednom, kde interlocutor chce stav a odhadovaný čas opravy, nie súcit. Toto je nuansa, ktorú globálny priemer maskuje a ktorú odhalí preskúmanie tiket po tikete – čo často vedie k skutočnému rozhodnutiu: smerovať požiadavky podľa typu žiadosti namiesto výberu jedného 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
        }
    }
)

# Simulácia prevádzky
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))

Štatistická významnosť

Nerob závery príliš rýchlo. Pri malom množstve dát sú výsledky zašumené a klasickou chybou je vidieť rozdiel 7,4 oproti 6,9 pri dvanástich pozorovaniach a vyhlásiť víťaza. Nižšie uvedený Studentov t-test odpovedá na jedinú dôležitú otázku: je pozorovaný rozdiel väčší než to, čo by prirodzene vzniklo náhodou medzi dvoma ekvivalentnými sériami?

Hodnota p_value pod 0,05 znamená, že takýto rozdiel by bol nepravdepodobný, ak by boli oba varianty rovnaké. Nad touto hranicou si nič nepreukázal – čo nie je to isté ako preukázanie rovnosti. Najčastejšie ti len chýbajú dáta. Počítaj s minimom sto pozorovaní na variant pred tým, než urobíš záver, a stráž sa pred nutkaním kontrolovať výsledky každé ráno. Ak sa pozrieš dostatočne často, vždy nájdeš moment, keď sa rozdiel bude zdať zmysluplný.

from scipy import stats

def test_significativite(scores_a: list[float],
                          scores_b: list[float]) -> dict:
    """Studentov t-test na porovnanie dvoch variantov."""
    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"
        )
    }

Spustenie tvojho prvého experimentu

Vezmi úlohu, ktorú dobre poznáš, a nastav PromptExperiment s dvoma variantmi, pričom medzi kontrolou a variantom zmeníš len jednu vec: tón, vnútenú štruktúru alebo dodatočnú inštrukciu. Pred spustením čohokoľvek definuj dve alebo tri metriky, pretože výber metriky po zhliadnutí výsledkov je ako vopred vybrať víťaza a je to najčastejšia chyba pri domáco vytvorených testoch.

Spusť experiment na dvadsiatich vstupoch a potom analyzuj. Pozri sa na priemer, ale hlavne otvor prípady, kde sa dva varianty najviac líšia: tie vysvetľujú rozdiel. Dvadsať pozorovaní zjavne nebude stačiť na dosiahnutie štatistickej významnosti a uvedomenie si tohto faktu samotným je lepšie než čítanie o tom tu. Nakoniec zdokumentuj rozhodnutie a archivuj surové výsledky s dátumom a presnou konfiguráciou variantu – táto archívna evidencia je to, čo ti zabráni o rok spustiť ten istý experiment znova.

Kľúčové poznatky

  • Testovanie A/B nahrádza intuíciu merateľnými dátami
  • Priraď varianty deterministicky podľa užívateľa
  • Meraj obchodné metriky, nielen vnímanú kvalitu
  • Pred vyvodením záverov počkaj na štatistickú významnosť
  • Dokumentuj každý experiment a jeho výsledky