Przejdź do głównej treści
Polski— Wybierz język
Menu

Testy A/B promptów

Lekcja 15 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Testy A/B promptów
  2. Zasada działania
  3. Framework do testów A/B
  4. Metryki ewaluacji
  5. Pełny przykład: testowanie dwóch stylów promptów
  6. Istotność statystyczna
  7. Uruchomienie pierwszego eksperymentu
  8. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane tylko przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Testy A/B promptów

Testowanie A/B promptów pozwala obiektywnie porównać dwie wersje promptu przy użyciu rzeczywistego ruchu. Zamiast wybierać prompt w oparciu o intuicję, mierzysz, który z nich przynosi lepsze rezultaty zgodnie z Twoimi metrykami biznesowymi. Jest to krok obowiązkowy między prototypowaniem a wdrożeniem produkcyjnym.

Zasada działania

Ruch przychodzący jest losowo dzielony między dwie (lub więcej) warianty promptu. Każda odpowiedź jest oceniana według z góry zdefiniowanych kryteriów, a wariant zwycięski jest wdrażany na 100% ruchu.

Siłą tej metody jest to, że oba warianty сталкиają się z tym samym ruchem, w tych samych warunkach i w tym samym czasie. Wszystkie zewnętrzne źródła zmienności – sezonowość, incydenty sieciowe, napływ nowej kategorii zgłoszeń – wpływają na obie grupy w równym stopniu i znoszą się wzajemnie podczas porównania. Test sekwencyjny nie może tego zagwarantować: uruchomienie starego promptu przez tydzień, a nowego przez kolejny, nie pozwala stwierdzić, czy poprawa wynikała z przepisania promptu, czy z kalendarza.

Framework do testów A/B

Klasa PromptExperiment ma trzy odpowiedzialności. assign_variant decyduje, który wariant obsłuży dane żądanie, run wykonuje wywołanie i loguje wynik, a get_stats agreguje dane.

Przypisanie wariantu zasługuje na uwagę. Gdy podano user_id, przypisanie jest deterministyczne, obliczane na podstawie hasha pary eksperyment-użytkownik. Ten sam użytkownik pozostaje w tej samej grupie od jednego wywołania do drugiego. Ta ciągłość nie jest teoretycznym udoskonaleniem: klient, który otrzyma ciepłą odpowiedź, a trzy minuty później suchą odpowiedź na swoje follow-up, pomyśli, że to błąd, a jego niezadowolenie zanieczyści oba warianty.

Każde wykonanie rejestruje dane wejściowe, wyjściowe, zużyte tokeny i znacznik czasu. Tokeny nie są tam dla ozdoby: wariant może wygrać pod względem jakości, jednocześnie podwajając długość odpowiedzi, a _estimate_cost przekłada tę różnicę na dolary, abyś mógł podjąć świadomą decyzję kompromisową.

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

client = OpenAI()

class PromptExperiment:
    """Framework do testów A/B promptów."""

    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:
        """Przypisuje wariant (przylepny do user_id, jeśli podano)."""
        if user_id:
            # Deterministyczne przypisanie według użytkownika
            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:
        """Wykonuje prompt z przypisanym wariantem."""
        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:
        """Oblicza statystyki dla każdego wariantu."""
        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:
        """Szacuje koszt w USD."""
        return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000

Metryki ewaluacji

Metryki zależą od Twojego przypadku użycia, a dwie rodziny pokrywają większość scenariuszy. Gdy zadanie ma poprawną odpowiedź – klasyfikacja zgłoszenia, ekstrakcja pola – ewaluacja sprowadza się do porównania z etykietą referencyjną. Tę rolę pełni evaluer_classification. Zwróć uwagę na istotny wybór: błędy parsowania są traktowane jako puste predykcje, a nie jako wyjątki, ponieważ wariant produkujący nieprawidłowy JSON powinien zostać ukarany w wyniku, a nie powodować awarii pomiaru.

Gdy zadanie generuje wolny tekst, nie ma jednej poprawnej odpowiedzi, więc prosisz model o rozstrzygnięcie. evaluer_qualite_texte rozbija ocenę na cztery kryteria – trafność, jasność, kompletność, profesjonalny ton – zamiast prosić o bezpośrednią ocenę ogólną. Ten podział sprawia, że ewaluacja jest stabilniejsza i informuje Cię, na której osi zwycięski wariant wyróżnia się: wiedza, że zysk wynika z tonu, a nie z kompletności, to dokładnie informacja potrzebna do napisania następnej wersji.

def evaluer_classification(result: dict,
                            label_attendu: str) -> dict:
    """Ocenia odpowiedź klasyfikacyjną."""
    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:
    """Ocenia jakość odpowiedzi tekstowej przy użyciu LLM."""
    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature wymaga 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)

Pełny przykład: testowanie dwóch stylów promptów

Poniższy eksperyment kontrastuje dwa podejścia do obsługi klienta. Wariant kontrolny używa minimalnej, profesjonalnej i neutralnej instrukcji. Wariant „empatyczny“ narzuca trzyetapową strukturę: potwierdź problem, wyraź empatię, a następnie zaproponuj konkretne rozwiązanie z krokami. Wszystko inne jest identyczne, od modelu po temperaturę. Ta symetria jest warunkiem przypisania wszelkiej zmierzonej różnicy promptowi. Zmiana zarówno tonu, jak i temperatury jednocześnie dałaby wynik nieinterpretowalny.

Pięć testowych zgłoszeń celowo obejmuje różne rejestry: emocjonalnie nacechowany incydent z dostawą, błąd funkcjonalny, neutralne pytanie o hasło, sporne żądanie zwrotu pieniędzy oraz awaria API zgłoszona przez profil techniczny. Oczekujesz, że wariant empatyczny zdominuje pierwsze dwa i zostanie ukarany w ostatnim, gdzie rozmówca chce statusu i szacowanego czasu naprawy (ETA), a nie współczucia. To niuans, który uśrednia globalna średnia, a który ujawnia badanie zgłoszenie po zgłoszeniu – często prowadząc do właściwej decyzji: routingu w oparciu o typ żądania, zamiast wybierania jednego tonu.

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

# Symulacja ruchu
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))

Istotność statystyczna

Nie wyciągaj wniosków zbyt szybko. Przy małej ilości danych wyniki są obarczone szumem, a klasycznym błędem jest zobaczenie 7,4 kontra 6,9 na dwunastu obserwacjach i ogłoszenie zwycięzcy. Poniższy test t-Studenta odpowiada na jedyne ważne pytanie: czy zaobserwowana różnica jest większa niż ta, którą przypadek naturalnie wyprodukowałby między dwiema równoważnymi seriami?

Wartość p_value poniżej 0,05 oznacza, że taka różnica byłaby mało prawdopodobna, gdyby oba warianty były równe. Powyżej tej wartości nie udowodniłeś niczego – co nie jest tym samym co udowodnienie równości. Najczęściej po prostu brakuje Ci danych. Licz na minimum sto obserwacji na wariant przed wyciągnięciem wniosków i strzeż się pokusy sprawdzania wyników każdego ranka. Jeśli będziesz patrzeć wystarczająco często, zawsze znajdziesz moment, w którym różnica wydaje się znacząca.

from scipy import stats

def test_significativite(scores_a: list[float],
                          scores_b: list[float]) -> dict:
    """Test t-Studenta do porównania dwóch wariantów."""
    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,
        "recommandacja": (
            "Istotna różnica, wdróż zwycięski wariant"
            if p_value < 0.05
            else "Za mało danych lub brak istotnej różnicy"
        )
    }

Uruchomienie pierwszego eksperymentu

Weź zadanie, które dobrze znasz, i skonfiguruj PromptExperiment z dwoma wariantami, zmieniając tylko jedną rzecz między kontrolą a wariantem: ton, narzuconą strukturę lub dodatkową instrukcję. Zdefiniuj dwie lub trzy metryki przed uruchomieniem czegokolwiek, ponieważ wybór metryki po zobaczeniu wyników jest jak wybieranie zwycięzcy z góry i jest to najczęstszy błąd w testach domowej roboty.

Uruchom eksperyment na dwudziestu danych wejściowych, a następnie przeanalizuj wyniki. Spójrz na średnią, ale przede wszystkim otwórz przypadki, w których oba warianty najbardziej się różnią: one wyjaśniają lukę. Dwadzieścia obserwacji oczywiście nie wystarczy, aby osiągnąć istotność statystyczną, a samodzielne uświadomienie sobie tego jest lepsze niż przeczytanie tego tutaj. Na koniec udokumentuj decyzję i zarchiwizuj surowe wyniki wraz z datą i dokładną konfiguracją wariantu – to archiwum powstrzyma Cię przed uruchamianiem tego samego eksperymentu ponownie za rok.

Kluczowe wnioski

  • Testy A/B zastępują intuicję mierzalnymi danymi
  • Przypisuj warianty deterministycznie według użytkownika
  • Mierz metryki biznesowe, a nie tylko postrzeganą jakość
  • Poczekaj na istotność statystyczną przed wyciągnięciem wniosków
  • Dokumentuj każdy eksperyment i jego wyniki