Test A/B dei Prompt
In questa pagina
Lezione aggiornata il 3 novembre 2026 sulla base della documentazione OpenAI:
temperatureetop_psono accettati solo con uno sforzo di ragionamento (reasoning effort) impostato sunone, mentre i modelli GPT-5.6 ragionano per impostazione predefinita (medium). Le chiamate che impostano questi parametri devono quindi specificarereasoning={"effort": "none"}(API Responses) oreasoning_effort="none"(Chat Completions). Fonti: Utilizzo di GPT-6 · GPT-5.6 Terra.
Test A/B dei Prompt
Il test A/B dei prompt ti permette di confrontare oggettivamente due versioni di un prompt utilizzando traffico reale. Invece di scegliere un prompt basandoti sull’intuizione, misuri quale produce risultati migliori secondo le tue metriche aziendali. Questo è il passaggio obbligatorio tra la prototipazione e la produzione.
Principio
Il traffico in ingresso viene suddiviso casualmente tra due (o più) varianti di prompt. Ogni risposta viene valutata rispetto a criteri predefiniti e la variante vincente viene distribuita al 100% del traffico.
La forza di questo metodo è che entrambe le varianti affrontano lo stesso traffico, nelle stesse condizioni e nello stesso momento. Tutte le fonti esterne di variazione—stagionalità, incidenti di rete, arrivo di una nuova categoria di richieste—colpiscono entrambi i gruppi allo stesso modo e si annullano nel confronto. Un test sequenziale non può garantire questo: eseguire il vecchio prompt per una settimana e quello nuovo la successiva ti lascia incapace di dire se il miglioramento derivi dalla tua riscrittura o dal calendario.
Framework per Test A/B
La classe PromptExperiment ha tre responsabilità. assign_variant decide quale variante serve una data richiesta, run esegue la chiamata e registra il risultato, e get_stats aggrega i dati.
L’assegnazione merita una nota. Quando viene fornito un user_id, l’assegnazione è deterministica, calcolata da un hash della coppia esperimento-utente. Lo stesso utente rimane nello stesso gruppo da una chiamata all’altra. Questa continuità non è un raffinamento teorico: un cliente che riceve una risposta calorosa e poi, tre minuti dopo, una risposta secca al suo follow-up penserà che sia un bug, e la sua insoddisfazione inquinerà entrambe le varianti.
Ogni esecuzione registra l’input, l’output, i token consumati e il timestamp. Questi token non sono lì per decorazione: una variante potrebbe vincere sulla qualità raddoppiando la lunghezza della risposta, e _estimate_cost traduce quel divario in dollari così puoi fare un compromesso informato.
import random
import json
from datetime import datetime
from openai import OpenAI
client = OpenAI()
class PromptExperiment:
"""Framework per test A/B dei prompt."""
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:
"""Assegna una variante (persistente per user_id se fornito)."""
if user_id:
# Assegnazione deterministica per utente
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:
"""Esegue il prompt con la variante assegnata."""
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:
"""Calcola le statistiche per variante."""
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:
"""Stima il costo in USD."""
return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000
Metriche di Valutazione
Le metriche dipendono dal tuo caso d’uso e due famiglie coprono la maggior parte degli scenari. Quando il compito ha una risposta corretta—classificare un ticket, estrarre un campo—la valutazione si riduce al confronto con un’etichetta di riferimento. Questo è il ruolo di evaluer_classification. Nota una scelta istruttiva qui: i fallimenti di parsing sono trattati come previsioni vuote piuttosto che sollevare un’eccezione, perché una variante che produce JSON non valido dovrebbe essere penalizzata nel punteggio, non far crashare la misurazione.
Quando il compito produce testo libero, non c’è una singola risposta corretta, quindi chiedi al modello di arbitrare. evaluer_qualite_texte scompone il giudizio in quattro criteri—rilevanza, chiarezza, completezza, tono professionale—piuttosto che chiedere un punteggio globale diretto. Questa scomposizione rende la valutazione più stabile e ti dice su quale asse eccelle la variante vincente: sapere che il guadagno deriva dal tono piuttosto che dalla completezza è esattamente l’informazione di cui hai bisogno per scrivere la versione successiva.
def evaluer_classification(result: dict,
label_attendu: str) -> dict:
"""Valuta una risposta di classificazione."""
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:
"""Valuta la qualità di una risposta testuale usando l'LLM."""
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature richiede effort none
instructions="Sei un valutatore della qualità del testo. "
"Valuta su 10 basandoti su: rilevanza, chiarezza, "
"completezza, tono professionale.",
input=f"Domanda: {result['input']}\n\n"
f"Risposta: {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)
Esempio Completo: Test di Due Stili di Prompt
L’esperimento seguente confronta due approcci al supporto clienti. Il controllo usa un’istruzione minimale, professionale e neutra. La variante “empatica” impone una struttura in tre passaggi: riconoscere il problema, esprimere empatia, poi proporre una soluzione con passaggi. Tutto il resto è identico, dal modello alla temperatura. Questa simmetria è la condizione per attribuire qualsiasi divario misurato al prompt. Cambiare sia il tono che la temperatura insieme produrrebbe un risultato ininterpretabile.
I cinque ticket di test coprono deliberatamente registri diversi: un incidente di consegna carico di emotività, un bug funzionale, una domanda neutra sulla password, una richiesta di rimborso controversa e un’interruzione API segnalata da un profilo tecnico. Ti aspetti che la variante empatica domini i primi due e sia penalizzata sull’ultimo, dove l’interlocutore vuole uno stato e una stima dei tempi, non compassione. Questa è la sfumatura che una media globale maschera e che un esame ticket per ticket rivela—spesso portando alla vera decisione: instradare in base al tipo di richiesta piuttosto che scegliere un unico tono.
experiment = PromptExperiment(
name="customer-support-style",
variants={
"control": {
"system_prompt": "Sei un agente di supporto. "
"Rispondi in modo professionale.",
"model": "gpt-5.6-terra",
"temperature": 0.3
},
"empathique": {
"system_prompt": "Sei un agente di supporto premuroso. "
"Inizia riconoscendo il problema del cliente, "
"mostra empatia, poi proponi una soluzione concreta "
"con dei passaggi.",
"model": "gpt-5.6-terra",
"temperature": 0.3
}
}
)
# Simula il traffico
test_tickets = [
"Il mio pacco non è arrivato da 2 settimane.",
"L'app si blocca quando clicco su Impostazioni.",
"Come cambio la mia password?",
"Voglio un rimborso, il prodotto è difettoso.",
"La tua API restituisce un errore 500 da questa mattina.",
]
for ticket in test_tickets:
result = experiment.run(ticket)
quality = evaluer_qualite_texte(result)
print(f"Variante: {result['variant']} | "
f"Punteggio: {quality['note_globale']}/10")
print("\nStatistiche:")
print(json.dumps(experiment.get_stats(), indent=2))
Significatività Statistica
Non trarre conclusioni troppo velocemente. Con pochi dati, i risultati sono rumorosi, e l’errore classico è vedere 7,4 contro 6,9 su dodici osservazioni e dichiarare un vincitore. Il test t di Student qui sotto risponde all’unica domanda che conta: il divario osservato è più grande di quello che il caso produrrebbe naturalmente tra due serie equivalenti?
Un p_value inferiore a 0,05 significa che un tale divario sarebbe improbabile se le due varianti fossero uguali. Sopra quella soglia, non hai dimostrato nulla—il che non è lo stesso che dimostrare l’uguaglianza. Molto spesso, ti mancano solo dati. Conta su un minimo di cento osservazioni per variante prima di concludere, e diffida dalla voglia di controllare i risultati ogni mattina. Se guardi abbastanza spesso, troverai sempre un momento in cui il divario sembra significativo.
from scipy import stats
def test_significativite(scores_a: list[float],
scores_b: list[float]) -> dict:
"""Test t di Student per confrontare due varianti."""
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": (
"Differenza significativa, distribuisci la variante vincente"
if p_value < 0.05
else "Dati insufficienti o nessuna differenza significativa"
)
}
Eseguire il Tuo Primo Esperimento
Prendi un compito che conosci bene e imposta un PromptExperiment con due varianti, cambiando una sola cosa tra il controllo e la variante: un tono, una struttura imposta o un’istruzione aggiuntiva. Definisci due o tre metriche prima di lanciare qualsiasi cosa, perché scegliere la metrica dopo aver visto i risultati è come scegliere il vincitore in anticipo, ed è il bias più comune nei test fatti in casa.
Esegui l’esperimento su venti input, poi analizza. Guarda la media, ma soprattutto apri i casi in cui le due varianti divergono di più: questi spiegano il divario. Venti osservazioni ovviamente non saranno sufficienti per raggiungere la significatività, e rendersene conto da soli è meglio che leggerlo qui. Infine, documenta la decisione e archivia i risultati grezzi con la data e la configurazione esatta della variante—questo archivio è ciò che ti impedirà di eseguire lo stesso esperimento di nuovo tra un anno.
Punti chiave
- Il test A/B sostituisce l’intuizione con dati misurabili
- Assegna le varianti in modo deterministico per utente
- Misura le metriche aziendali, non solo la qualità percepita
- Attendi la significatività statistica prima di concludere
- Documenta ogni esperimento e i suoi risultati