Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Testovi A/B za upite

Lekcija 15 od 16 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Testovi A/B za upite
  2. Načelo
  3. Okvir za A/B testiranje
  4. Metrike evaluacije
  5. Potpuni primjer: Testiranje dva stila upita
  6. Statistička značajnost
  7. Pokretanje tvog prvog eksperimenta
  8. Ključne točke

Lekcija ažurirana 3. studenog 2026. na temelju OpenAI dokumentacije: parametri temperature i top_p prihvaćeni su samo uz napor rezoniranja (reasoning effort) vrijednosti none, dok modeli GPT-5.6 prema zadanim postavkama rezoniraju (medium). Pozivi koji postavljaju ove parametre stoga moraju specificirati reasoning={"effort": "none"} (Responses API) ili reasoning_effort="none" (Chat Completions). Izvori: Korištenje GPT-6 · GPT-5.6 Terra.

Testovi A/B za upite

Testiranje upita metodom A/B omogućuje ti objektivnu usporedbu dviju verzija upita koristeći stvarni promet. Umjesto odabira upita na temelju intuicije, mjeriš koji od njih daje bolje rezultate prema tvojim poslovnim metrikama. Ovo je obavezan korak između izrade prototipa i puštanja u proizvodnju.

Načelo

Dolazni promet nasumično se dijeli između dviju (ili više) varijanti upita. Svaki odgovor procjenjuje se prema unaprijed definiranim kriterijima, a pobjednička varijanta uvodi se na 100 % prometa.

Snaga ove metode leži u tome što se obje varijante suočavaju s istim prometom, pod istim uvjetima i u isto vrijeme. Svi vanjski izvori varijacija – sezonalnost, mrežni incidenti, dolazak nove kategorije zahtjeva – jednako utječu na obje skupine i poništavaju se u usporedbi. Sekvencijalni test to ne može garantirati: ako pokreneš stari upit tjedan dana, a novi sljedeći, nećeš moći utvrditi proizlazi li poboljšanje iz tvog prepisivanja ili iz kalendara.

Okvir za A/B testiranje

Razred PromptExperiment ima tri odgovornosti. assign_variant odlučuje koja varijanta obrađuje određeni zahtjev, run izvršava poziv i bilježi rezultat, a get_stats agregira podatke.

Dodjela zaslužuje napomenu. Kada se dostavi user_id, dodjela je deterministička i izračunava se iz hash vrijednosti para eksperiment-korisnik. Isti korisnik ostaje u istoj skupini od jednog poziva do drugog. Taj kontinuitet nije teoretsko usavršavanje: klijent koji primi topao odgovor, a zatim tri minute kasnije suh odgovor na svoj nastavak, pomislit će da je riječ o grešci, a njegovo nezadovoljstvo onečistit će obje varijante.

Svako izvršenje bilježi ulaz, izlaz, potrošene tokene i vremensku oznaku. Ti tokeni nisu tu samo za ukras: varijanta može pobijediti u kvaliteti uz udvostručenje duljine odgovora, a _estimate_cost taj jaz prevodi u dolare kako bi mogao donijeti informiranu odluku o kompromisu.

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

client = OpenAI()

class PromptExperiment:
    """Okvir za A/B testiranje upita."""

    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:
        """Dodjeljuje varijantu (fiksna po user_id ako je naveden)."""
        if user_id:
            # Deterministička dodjela po korisniku
            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:
        """Izvršava upit s dodijeljenom varijantom."""
        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:
        """Izračunava statistiku po varijanti."""
        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:
        """Procjenjuje trošak u USD."""
        return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000

Metrike evaluacije

Metrike ovise o tvom slučaju upotrebe, a dvije obitelji pokrivaju većinu scenarija. Kada zadatak ima točan odgovor – klasificiranje tiketa, izdvajanje polja – evaluacija se svodi na usporedbu s referentnom oznakom. To je uloga funkcije evaluer_classification. Ovdje je izbor poučan: neuspjeh parsiranja tretira se kao prazno predviđanje umjesto da se podiže iznimka, jer varijanta koja proizvodi neispravan JSON treba biti kažnjena u rezultatu, a ne srušiti mjerenje.

Kada zadatak proizvodi slobodan tekst, ne postoji jedan točan odgovor, pa tražiš od modela da presudi. Funkcija evaluer_qualite_texte raščlanjuje prosudbu na četiri kriterija – relevantnost, jasnoća, potpunost, profesionalan ton – umjesto da traži izravnu ukupnu ocjenu. Ta raščlamba čini evaluaciju stabilnijom i govori ti u kojoj osi pobjednička varijanta prednjači: znati da dobitak proizlazi iz tona, a ne iz potpunosti, upravo je informacija koja ti treba za pisanje sljedeće verzije.

def evaluer_classification(result: dict,
                            label_attendu: str) -> dict:
    """Evaluira odgovor klasifikacije."""
    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:
    """Evaluira kvalitetu tekstualnog odgovora koristeći LLM."""
    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature zahtijeva 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)

Potpuni primjer: Testiranje dva stila upita

Eksperiment u nastavku suprotstavlja dva pristupa korisničkoj podršci. Kontrolna verzija koristi minimalnu, profesionalnu i neutralnu instrukciju. Varijanta „empatična“ nameće strukturu u tri koraka: priznaj problem, izrazi empatiju, zatim predloži konkretno rješenje s koracima. Sve ostalo je identično, od modela do temperature. Ta simetrija uvjet je da se bilo kakav izmjereni jaz pripiše upitu. Istovremena promjena tona i temperature dala bi neinterpretabilni rezultat.

Pet testnih tiketa namjerno pokriva različite registre: emocionalno nabijen incident s isporukom, funkcionalna greška, neutralno pitanje o lozinci, sporan zahtjev za povrat novca i prekidanje API-ja koje je prijavio tehnički profil. Očekuješ da će empatična varijanta dominirati u prva dva slučaja, a biti kažnjena u posljednjem, gdje sugovornik želi status i procjenu vremena (ETA), a ne suosjećanje. To je nijansa koju globalni prosjek prikriva, a koju otkriva ispitivanje tiket po tiket – što često vodi do prave odluke: usmjeravanje prema vrsti zahtjeva umjesto odabira jednog tona.

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

# Simuliraj promet
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))

Statistička značajnost

Ne donosi zaključke prebrzo. S malo podataka rezultati su bučni, a klasična greška je vidjeti 7,4 naspram 6,9 na dvanaest opažanja i proglasiti pobjednika. Studentov t-test u nastavku odgovara na jedino pitanje koje je bitno: je li uočeni jaz veći od onoga što bi slučajnost prirodno proizvela između dviju ekvivalentnih serija?

Vrijednost p_value ispod 0,05 znači da bi takav jaz bio malo vjerojatan da su dvije varijante jednake. Iznad toga, nisi dokazao ništa – što nije isto što i dokazivanje jednakosti. Najčešće ti jednostavno nedostaje podataka. Računaj na minimum od sto opažanja po varijanti prije donošenja zaključka i čuvaj se poriva da provjeravaš rezultate svako jutro. Ako gledaš dovoljno često, uvijek ćeš naći trenutak u kojem jaz djeluje smisleno.

from scipy import stats

def test_significativite(scores_a: list[float],
                          scores_b: list[float]) -> dict:
    """Studentov t-test za usporedbu dviju varijanti."""
    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"
        )
    }

Pokretanje tvog prvog eksperimenta

Uzmi zadatak koji dobro poznaješ i postavi PromptExperiment s dvije varijante, mijenjajući samo jednu stvar između kontrole i varijante: ton, nametnutu strukturu ili dodatnu instrukciju. Definiraj dvije ili tri metrike prije pokretanja bilo čega, jer odabir metrike nakon viđenja rezultata isto je što i unaprijed odabrani pobjednik, a to je najčešća pristranost u domaćim testovima.

Pokreni eksperiment na dvadeset ulaza, zatim analiziraj. Gledaj prosjek, ali posebno otvori slučajeve u kojima se dvije varijante najviše razilaze: oni objašnjavaju jaz. Dvadeset opažanja očito neće biti dovoljno za postizanje značajnosti, a shvatiti to sam bolje je nego to ovdje pročitati. Naposljetku, dokumentiraj odluku i arhiviraj sirove rezultate s datumom i točnom konfiguracijom varijante – ta arhiva je ono što će te spriječiti da za godinu dana ponovno pokreneš isti eksperiment.

Ključne točke

  • A/B testiranje zamjenjuje intuiciju mjerljivim podacima
  • Dodjeljuj varijante deterministički po korisniku
  • Mjeri poslovne metrike, a ne samo percipiranu kvalitetu
  • Pričekaj statističku značajnost prije donošenja zaključka
  • Dokumentiraj svaki eksperiment i njegove rezultate