Testes A/B de Prompts
Nesta página
Lição atualizada a 3 de novembro de 2026 com base na documentação da OpenAI:
temperatureetop_psó são aceites com um esforço de raciocínio denone, enquanto os modelos GPT-5.6 raciocinam por padrão (medium). As chamadas que definem estes parâmetros devem, portanto, especificarreasoning={"effort": "none"}(API de Respostas) oureasoning_effort="none"(Chat Completions). Fontes: Using GPT-6 · GPT-5.6 Terra.
Testes A/B de Prompts
Os testes A/B de prompts permitem comparar objetivamente duas versões de um prompt utilizando tráfego real. Em vez de escolher um prompt com base na intuição, mede qual deles produz melhores resultados de acordo com as suas métricas de negócio. Este é o passo obrigatório entre a prototipagem e a produção.
Princípio
O tráfego de entrada é dividido aleatoriamente entre duas (ou mais) variantes de prompt. Cada resposta é avaliada com base em critérios predefinidos e a variante vencedora é implementada para 100% do tráfego.
A força deste método reside no facto de ambas as variantes enfrentarem o mesmo tráfego, nas mesmas condições e ao mesmo tempo. Todas as fontes externas de variação — sazonalidade, incidentes de rede, chegada de uma nova categoria de pedidos — afetam ambos os grupos igualmente e anulam-se na comparação. Um teste sequencial não pode garantir isto: executar o prompt antigo durante uma semana e o novo na semana seguinte impede-o de saber se a melhoria resultou da sua reescrita ou do calendário.
Estrutura de Testes A/B
A classe PromptExperiment tem três responsabilidades. assign_variant decide qual a variante que serve um determinado pedido, run executa a chamada e regista o resultado, e get_stats agrega os dados.
A atribuição merece uma nota. Quando é fornecido um user_id, esta é determinística, calculada a partir de um hash do par experimento-utilizador. O mesmo utilizador permanece no mesmo grupo de uma chamada para a outra. Esta continuidade não é um refinamento teórico: um cliente que receba uma resposta calorosa e, três minutos depois, uma resposta seca ao seu acompanhamento, pensará que se trata de um erro, e a sua insatisfação contaminará ambas as variantes.
Cada execução regista a entrada, a saída, os tokens consumidos e o carimbo de data/hora. Estes tokens não estão lá apenas para decoração: uma variante pode ganhar em qualidade enquanto duplica o comprimento da resposta, e _estimate_cost traduz essa diferença em dólares para que possa fazer uma compensação informada.
import random
import json
from datetime import datetime
from openai import OpenAI
client = OpenAI()
class PromptExperiment:
"""Estrutura de testes A/B para prompts."""
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:
"""Atribui uma variante (fixa por user_id se fornecido)."""
if user_id:
# Atribuição determinística por utilizador
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:
"""Executa o prompt com a variante atribuída."""
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:
"""Calcula estatísticas por 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:
"""Estima o custo em USD."""
return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000
Métricas de Avaliação
As métricas dependem do seu caso de uso, e duas famílias cobrem a maioria dos cenários. Quando a tarefa tem uma resposta correta — classificar um ticket, extrair um campo — a avaliação resume-se a comparar com um rótulo de referência. É esta a função de evaluer_classification. Note uma escolha instrutiva aqui: as falhas de análise são tratadas como previsões vazias em vez de gerar uma exceção, porque uma variante que produza JSON inválido deve ser penalizada na pontuação, não fazer falhar a medição.
Quando a tarefa produz texto livre, não há uma única resposta correta, pelo que pede ao modelo para arbitrar. evaluer_qualite_texte decompõe o julgamento em quatro critérios — relevância, clareza, completude, tom profissional — em vez de pedir uma pontuação global direta. Esta decomposição torna a avaliação mais estável e indica-lhe em que eixo a variante vencedora se destaca: saber que o ganho vem do tom e não da completude é exatamente a informação de que precisa para escrever a próxima versão.
def evaluer_classification(result: dict,
label_attendu: str) -> dict:
"""Avalia uma resposta de classificação."""
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:
"""Avalia a qualidade de uma resposta de texto utilizando o LLM."""
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires 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)
Exemplo Completo: Testar Dois Estilos de Prompt
A experiência abaixo contrasta duas abordagens ao apoio ao cliente. O controlo utiliza uma instrução mínima, profissional e neutra. A variante “empática” impõe uma estrutura de três passos: reconhecer o problema, expressar empatia e, em seguida, propor uma solução com passos. Todo o resto é idêntico, desde o modelo à temperatura. Esta simetria é a condição para atribuir qualquer diferença medida ao prompt. Alterar simultaneamente o tom e a temperatura produziria um resultado interpretável.
Os cinco tickets de teste cobrem deliberadamente diferentes registos: um incidente de entrega emocionalmente carregado, um erro funcional, uma pergunta neutra sobre palavra-passe, um pedido de reembolso contencioso e uma indisponibilidade da API relatada por um perfil técnico. Espera-se que a variante empática domine os dois primeiros e seja penalizada no último, onde o interlocutor quer um estado e um prazo estimado, não compaixão. Esta é a nuance que uma média global mascara e que um exame ticket a ticket revela — levando frequentemente à decisão real: encaminhar com base no tipo de pedido em vez de escolher um único tom.
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
}
}
)
# Simular tráfego
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))
Significância Estatística
Não tire conclusões demasiado depressa. Com poucos dados, os resultados são ruidosos, e o erro clássico é ver 7,4 contra 6,9 em doze observações e declarar um vencedor. O teste t de Student abaixo responde à única questão que importa: a diferença observada é maior do que a que o acaso produziria naturalmente entre duas séries equivalentes?
Um p_value abaixo de 0,05 significa que tal diferença seria improvável se as duas variantes fossem iguais. Acima desse valor, não demonstrou nada — o que não é o mesmo que demonstrar igualdade. Na maioria das vezes, apenas faltam dados. Conte com um mínimo de cem observações por variante antes de concluir e cuidado com a vontade de verificar os resultados todas as manhãs. Se olhar com frequência suficiente, encontrará sempre um momento em que a diferença parece significativa.
from scipy import stats
def test_significativite(scores_a: list[float],
scores_b: list[float]) -> dict:
"""Teste t de Student para comparar duas variantes."""
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"
)
}
Executar o Seu Primeiro Experimento
Pegue numa tarefa que conheça bem e configure um PromptExperiment com duas variantes, alterando apenas uma coisa entre o controlo e a variante: um tom, uma estrutura imposta ou uma instrução adicional. Defina duas ou três métricas antes de lançar qualquer coisa, porque escolher a métrica depois de ver os resultados é como escolher o vencedor antecipadamente, e é o viés mais comum em testes caseiros.
Execute a experiência em vinte entradas e, em seguida, analise. Olhe para a média, mas especialmente abra os casos em que as duas variantes divergem mais: estes explicam a diferença. Vinte observações obviamente não serão suficientes para alcançar significância, e perceber isso por si mesmo é melhor do que ler aqui. Finalmente, documente a decisão e arquive os resultados brutos com a data e a configuração exata da variante — este arquivo é o que o impedirá de executar a mesma experiência novamente dentro de um ano.
Pontos-chave
- Os testes A/B substituem a intuição por dados mensuráveis
- Atribua variantes deterministicamente por utilizador
- Meça métricas de negócio, não apenas qualidade percebida
- Aguarde a significância estatística antes de concluir
- Documente cada experiência e os seus resultados