Salt la conținutul principal
Română— Alege o limbă
Meniu

Testarea A/B a prompturilor

Lecția 15 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Testarea A/B a prompturilor
  2. Principiu
  3. Cadru de testare A/B
  4. Metrici de evaluare
  5. Exemplu complet: Testarea a două stiluri de prompt
  6. Semnificație statistică
  7. Rularea primului dumneavoastră experiment
  8. Puncte cheie

Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii temperature și top_p sunt acceptați doar cu un efort de raționament de none, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specifice reasoning={"effort": "none"} (API-ul Responses) sau reasoning_effort="none" (Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.

Testarea A/B a prompturilor

Testarea A/B a prompturilor vă permite să comparați obiectiv două versiuni ale unui prompt folosind trafic real. În loc să alegeți un prompt bazându-vă pe intuiție, măsurați care dintre ele produce rezultate mai bune conform metricilor dumneavoastră de afaceri. Acesta este pasul obligatoriu între prototipare și producție.

Principiu

Traficul de intrare este împărțit aleatoriu între două (sau mai multe) variante de prompt. Fiecare răspuns este evaluat în funcție de criterii predefinite, iar varianta câștigătoare este implementată pentru 100% din trafic.

Forța acestei metode constă în faptul că ambele variante se confruntă cu același trafic, în aceleași condiții, în același timp. Toate sursele externe de variație—sezonalitatea, incidentele de rețea, sosirea unei noi categorii de cereri—afectează ambele grupuri în mod egal și se anulează reciproc în comparație. Un test secvențial nu poate garanta acest lucru: rularea vechiului prompt timp de o săptămână și a celui nou în săptămâna următoare vă lasă incapabil să stabiliți dacă îmbunătățirea a provenit din rescrierea dumneavoastră sau din calendar.

Cadru de testare A/B

Clasa PromptExperiment are trei responsabilități. assign_variant decide care variantă servește o anumită cerere, run execută apelul și înregistrează rezultatul, iar get_stats agregă datele.

Atribuirea merită o notă. Când este furnizat un user_id, atribuirea este deterministă, calculată dintr-un hash al perechii experiment-utilizator. Același utilizator rămâne în același grup de la un apel la altul. Această continuitate nu este un rafinament teoretic: un client care primește un răspuns cald și apoi, trei minute mai târziu, un răspuns sec la follow-up-ul său va crede că este o eroare, iar nemulțumirea sa va polua ambele variante.

Fiecare execuție înregistrează intrarea, ieșirea, tokenii consumați și marcajul temporal. Acești tokeni nu sunt acolo de decor: o variantă ar putea câștiga la calitate dublând în același timp lungimea răspunsului, iar _estimate_cost traduce acel decalaj în dolari pentru a vă permite să faceți un compromis informat.

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

client = OpenAI()

class PromptExperiment:
    """Cadru de testare A/B pentru prompturi."""

    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:
        """Atribuie o variantă (persistentă pe user_id dacă este furnizat)."""
        if user_id:
            # Atribuire deterministă pe utilizator
            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:
        """Execută promptul cu varianta atribuită."""
        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:
        """Calculează statisticile per 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:
        """Estimează costul în USD."""
        return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000

Metrici de evaluare

Metricile depind de cazul dumneavoastră de utilizare, iar două familii acoperă majoritatea scenariilor. Când sarcina are un răspuns corect—clasificarea unui tichet, extragerea unui câmp—evaluarea se rezumă la compararea cu o etichetă de referință. Acesta este rolul funcției evaluer_classification. Observați o alegere instructivă aici: erorile de parsare sunt tratate ca predicții goale în loc să arunce o excepție, deoarece o variantă care produce JSON invalid ar trebui penalizată în scor, nu să blocheze măsurarea.

Când sarcina produce text liber, nu există un singur răspuns corect, așa că cereți modelului să arbitreze. Funcția evaluer_qualite_texte descompune judecata în patru criterii—relevanță, claritate, completitudine, ton profesional—în loc să ceară un scor global direct. Această descompunere face evaluarea mai stabilă și vă spune pe ce axă excelează varianta câștigătoare: știind că câștigul provine din ton și nu din completitudine este exact informația de care aveți nevoie pentru a scrie următoarea versiune.

def evaluer_classification(result: dict,
                            label_attendu: str) -> dict:
    """Evaluează un răspuns de clasificare."""
    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:
    """Evaluează calitatea unui răspuns text folosind LLM."""
    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature necesită 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)

Exemplu complet: Testarea a două stiluri de prompt

Experimentul de mai jos contrastează două abordări pentru suportul clienților. Varianta de control folosește o instrucțiune minimală, profesională și neutră. Varianta „empatică“ impune o structură în trei pași: recunoașterea problemei, exprimarea empatiei, apoi propunerea unei soluții concrete cu pași. Tot restul este identic, de la model la temperatură. Această simetrie este condiția pentru a atribui orice decalaj măsurat promptului. Schimbarea simultană a tonului și a temperaturii ar duce la un rezultat neinterpretabil.

Cele cinci tichete de test acoperă deliberat registre diferite: un incident de livrare încărcat emoțional, o eroare funcțională, o întrebare neutră despre parolă, o cerere de rambursare controversată și o pană de API raportată de un profil tehnic. Vă așteptați ca varianta empatică să domine primele două și să fie penalizată la ultima, unde interlocutorul dorește o stare și un timp estimat de rezolvare, nu compasiune. Aceasta este nuanța pe care o medie globală o maschează și pe care o examinare tichet cu tichet o relevă—ducând adesea la decizia reală: rutarea în funcție de tipul cererii în loc de alegerea unui singur ton.

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

# Simulare trafic
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))

Semnificație statistică

Nu trageți concluzii prea repede. Cu puține date, rezultatele sunt zgomotoase, iar greșeala clasică este să vedeți 7,4 față de 6,9 pe douăsprezece observații și să declarați un câștigător. Testul t al lui Student de mai jos răspunde la singura întrebare care contează: este decalajul observat mai mare decât ceea ce ar produce natural șansa între două serii echivalente?

O valoare p_value sub 0,05 înseamnă că un astfel de decalaj ar fi improbabil dacă cele două variante ar fi egale. Peste această valoare, nu ați demonstrat nimic—ceea ce nu este la fel cu demonstrarea egalității. Cel mai adesea, vă lipsesc doar datele. Contați pe un minim de o sută de observații per variantă înainte de a concluziona și feriți-vă de impulsul de a verifica rezultatele în fiecare dimineață. Dacă priviți destul de des, veți găsi întotdeauna un moment în care decalajul pare semnificativ.

from scipy import stats

def test_significativite(scores_a: list[float],
                          scores_b: list[float]) -> dict:
    """Testul t al lui Student pentru compararea a două variante."""
    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": (
            "Diferență semnificativă, implementați varianta câștigătoare"
            if p_value < 0.05
            else "Date insuficiente sau nicio diferență semnificativă"
        )
    }

Rularea primului dumneavoastră experiment

Luați o sarcină pe care o cunoașteți bine și configurați un PromptExperiment cu două variante, schimbând un singur lucru între control și variantă: un ton, o structură impusă sau o instrucțiune suplimentară. Definiți două sau trei metrici înainte de a lansa orice, deoarece alegerea metricii după vizualizarea rezultatelor este ca și cum ați alege câștigătorul în avans, iar acesta este cel mai comun bias în testele realizate intern.

Rulați experimentul pe douăzeci de intrări, apoi analizați. Uitați-vă la medie, dar mai ales deschideți cazurile în care cele două variante diverg cel mai mult: acestea explică decalajul. Douăzeci de observații nu vor fi evident suficiente pentru a ajunge la semnificație statistică, iar realizarea acestui lucru pe cont propriu este mai bună decât citirea lui aici. În final, documentați decizia și arhivați rezultatele brute cu data și configurația exactă a variantei—această arhivă este ceea ce vă va opri să rulați din nou același experiment peste un an.

Puncte cheie

  • Testarea A/B înlocuiește intuiția cu date măsurabile
  • Atribuiți variantele determinist pe utilizator
  • Măsurați metrici de afaceri, nu doar calitatea percepută
  • Așteptați semnificația statistică înainte de a concluziona
  • Documentați fiecare experiment și rezultatele sale