Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Testes A/B e Métricas de Negócio

Aula 12 de 16 Atualizada a 2 de novembro de 2026 Avancado
Nesta página
  1. Para Além da Loss: Medir o Impacto no Negócio
  2. Configurar um Teste A/B
  3. Escolher as Métricas de Negócio Adequadas
  4. Recolher as Medições
  5. Aguardar a Significância Estatística
  6. Escalar Gradualmente
  7. Pontos-chave

Atualização de 2 de novembro de 2026 — Disponibilidade do fine-tuning. O serviço de fine-tuning self-service da OpenAI está a ser descontinuado: desde 7 de maio de 2026, as organizações que nunca o utilizaram já não podem criar jobs; desde 2 de julho, é necessário ter utilizado um modelo com fine-tuning nos últimos 60 dias; e a partir de 6 de janeiro de 2027, nenhum cliente poderá lançar novos jobs. Os modelos já treinados permanecem utilizáveis até que o seu modelo base seja desativado. Este curso mantém a sua utilidade para compreender e aproveitar um modelo existente; para novos projetos, priorize a engenharia de prompts, o RAG e as avaliações.

Para Além da Loss: Medir o Impacto no Negócio

A loss de treino e as pontuações de qualidade não são suficientes. O que realmente importa é o impacto do seu modelo com fine-tuning nos seus KPIs de negócio: satisfação do cliente, tempo de resolução, taxa de conversão. Um modelo pode produzir respostas que os seus revisores consideram elegantes, aumentando simultaneamente a taxa de escalonamento para os seus agentes humanos. É esse segundo número, e não o primeiro, que decide o futuro do projeto.

Configurar um Teste A/B

Um teste A/B compara duas variantes em condições reais, com tráfego autêntico. O Grupo A, ou grupo de controlo, recebe respostas do modelo base com o seu prompt otimizado; o Grupo B, ou grupo de teste, obtém respostas do modelo com fine-tuning. Os utilizadores são atribuídos aleatoriamente a ambos os grupos e os resultados são medidos utilizando as mesmas métricas. Toda a validade do exercício depende desta atribuição: se o Grupo B receber, por acaso, apenas os pedidos mais simples, a sua aparente superioridade não mede nada além dessa sorte.

A função choisir_variante resolve este problema através do hashing do ID do utilizador. Esta abordagem garante que o mesmo utilizador vê sempre a mesma variante — algo essencial, pois alternar entre sessões exporia a pessoa a dois estilos de resposta e distorceria a sua avaliação de satisfação. Produz uma distribuição estatisticamente equilibrada assim que o volume é suficiente e mantém-se reproduzível: recalcular mais tarde gera exatamente os mesmos grupos, permitindo recalcularem-se métricas esquecidas sem relançar o teste.

import random
import hashlib
from openai import OpenAI

client = OpenAI()

MODELE_BASE = "gpt-5.6-luna"
MODELE_FT = "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
PROMPT_BASE = "You are a professional customer support assistant..."

def choisir_variante(user_id: str, pourcentage_test: int = 50) -> str:
    """Assigns a user to group A or B deterministically."""
    h = int(hashlib.md5(user_id.encode()).hexdigest(), 16)
    return "B" if (h % 100) < pourcentage_test else "A"

def repondre(user_id: str, question: str) -> dict:
    """Responds with the correct model based on the A/B group."""
    variante = choisir_variante(user_id)

    if variante == "A":
        response = client.responses.create(
            model=MODELE_BASE,
            instructions=PROMPT_BASE,
            input=question
        )
    else:
        response = client.responses.create(
            model=MODELE_FT,
            input=question
        )

    return {
        "variante": variante,
        "modele": MODELE_BASE if variante == "A" else MODELE_FT,
        "reponse": response.output_text,
        "user_id": user_id
    }

Escolher as Métricas de Negócio Adequadas

Os indicadores a monitorizar dependem inteiramente do que o seu assistente deve entregar, e cada família de casos de uso tem os seus próprios.

Para um serviço de apoio ao cliente, a taxa de resolução ao primeiro contacto responde à pergunta mais concreta: o utilizador precisou de contactar novamente o apoio? A pontuação CSAT, uma classificação de satisfação de 1 a 5 recolhida após a interação, capta sentimentos que as métricas automatizadas ignoram. O tempo de resolução mede a duração total da troca, e a taxa de escalonamento — a fração de conversas transferidas para um humano — lê-se como uma admissão de falha do modelo nos casos envolvidos. Um fine-tuning bem-sucedido reduz tipicamente ambos estes últimos indicadores simultaneamente.

Para um chatbot de vendas, o raciocínio desloca-se para jusante. A taxa de conversão conta as conversas que levam a uma compra ou agendamento; a taxa de engagement, expressa como o número médio de mensagens por conversa, exige uma interpretação cuidadosa, pois uma troca mais longa pode sinalizar tanto interesse como incompreensão; a taxa de rejeição isola os utilizadores que saem após a primeira mensagem, muitas vezes porque a resposta inicial falhou o alvo.

Para uma tarefa de classificação ou extração, regressa-se ao trio clássico. A precisão fornece a percentagem de classificações corretas, a revocação a percentagem de casos positivos detetados e a pontuação F1, a média harmónica de ambas, impede que se aceite um modelo que nunca prevê a classe rara apenas para evitar erros.

Recolher as Medições

Estes indicadores são inúteis se viverem em três folhas de cálculo separadas. Um único coletor, alimentado em cada interação, mantém a variante juntamente com a métrica e permite gerar um relatório comparativo com um único comando. A classe ABTracker abaixo realiza este trabalho mínimo: regista, agrupa por variante e calcula médias e taxas.

import datetime

class ABTracker:
    """Metric collector for A/B testing."""

    def __init__(self):
        self.events = []

    def log_interaction(
        self,
        user_id: str,
        variante: str,
        question: str,
        reponse: str,
        metriques: dict
    ):
        """Records an interaction with its metrics."""
        self.events.append({
            "timestamp": datetime.datetime.now().isoformat(),
            "user_id": user_id,
            "variante": variante,
            "question": question,
            "reponse": reponse,
            **metriques
        })

    def rapport(self) -> dict:
        """Generates a comparative A vs B report."""
        groupes = {"A": [], "B": []}
        for e in self.events:
            groupes[e["variante"]].append(e)

        rapport = {}
        for variante, events in groupes.items():
            if not events:
                continue
            rapport[variante] = {
                "nb_interactions": len(events),
                "csat_moyen": self._moyenne(events, "csat"),
                "resolution_premier_contact": self._taux(events, "resolu"),
                "temps_moyen_sec": self._moyenne(events, "temps_resolution"),
            }

        return rapport

    def _moyenne(self, events, cle):
        vals = [e[cle] for e in events if cle in e and e[cle] is not None]
        return sum(vals) / len(vals) if vals else None

    def _taux(self, events, cle):
        vals = [e[cle] for e in events if cle in e]
        return sum(vals) / len(vals) * 100 if vals else None

tracker = ABTracker()

Aguardar a Significância Estatística

Não tire conclusões demasiado cedo. Após vinte interações por grupo, uma diferença de 0,4 pontos no CSAT não tem valor: bastam três clientes satisfeitos para a produzir. São necessárias interações suficientes para que os resultados sejam significativos, e as referências abaixo indicam a ordem de grandeza a atingir antes mesmo de olhar para os números.

100
Minimum per group
500+
For reliable results
p < 0.05
Significance threshold

Assim que atingir esse volume, um teste estatístico decide por si. O teste de Mann-Whitney funciona bem para pontuações de satisfação, que são classificações ordinais raramente distribuídas normalmente. O seu valor-p responde a uma pergunta precisa: qual é a probabilidade de observar uma diferença tão grande se os dois modelos fossem, na realidade, iguais? Abaixo de 0,05, a hipótese de simples acaso torna-se difícil de defender.

from scipy import stats

def test_significativite(scores_a: list[float], scores_b: list[float]):
    """Tests whether the difference between A and B is significant."""
    stat, p_value = stats.mannwhitneyu(scores_a, scores_b, alternative="two-sided")

    moy_a = sum(scores_a) / len(scores_a)
    moy_b = sum(scores_b) / len(scores_b)

    print(f"Mean A: {moy_a:.3f}")
    print(f"Mean B: {moy_b:.3f}")
    print(f"p-value: {p_value:.4f}")

    if p_value < 0.05:
        gagnant = "B (fine-tuned)" if moy_b > moy_a else "A (base)"
        print(f"Significant difference — {gagnant} is better")
    else:
        print("No significant difference")

Escalar Gradualmente

Mesmo um teste bem-sucedido não justifica mudar todo o tráfego de um dia para o outro: uma falha que aparece apenas uma vez em mil permanece invisível numa amostra e torna-se muito visível em volume total. Progrida em etapas de uma semana, verificando as suas métricas em cada passo antes de abrir o seguinte.

  1. Fase 1 (1 semana): 10% do tráfego no modelo com fine-tuning
  2. Fase 2 (1 semana): 30% se as métricas forem positivas
  3. Fase 3 (1 semana): 50% para o teste A/B principal
  4. Fase 4: 100% se o teste for conclusivo

Se uma etapa degradar as suas métricas, regresse à anterior em vez de avançar para a seguinte na esperança de que o número se recupere sozinho. Uma semana gasta a compreender o porquê custa sempre menos do que um mês de tráfego servido por um modelo dececionante.

Pontos-chave

  • As métricas de negócio importam mais do que a loss de treino
  • Utilize hashing determinístico para a atribuição A/B
  • Aguarde a significância estatística antes de concluir (p < 0,05)
  • Implemente gradualmente: 10%, 30%, 50%, 100%
  • Meça custos e latência além da qualidade