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

Métricas e Benchmarks

Aula 17 de 20 Atualizada a 3 de novembro de 2026 Avancado
Nesta página
  1. Medir a Qualidade com Métricas
  2. Comparar Significado em Vez de Palavras
  3. Verificar se o Modelo Não Está a Alucinar
  4. Construir um Benchmark Reproduzível
  5. Pontos-chave

Lição atualizada em 3 de novembro de 2026 com base na documentação da OpenAI: temperature e top_p só são aceites com um esforço de raciocínio de none, enquanto os modelos GPT-5.6 raciocinam por padrão (medium). As chamadas que definem estes parâmetros devem, portanto, especificar reasoning={"effort": "none"} (API Responses) ou reasoning_effort="none" (Chat Completions). Fontes: Using GPT-6 · GPT-5.6 Terra.

Medir a Qualidade com Métricas

Para além das pontuações de LLM-as-Judge, existem métricas quantitativas para avaliar diferentes aspetos das saídas dos LLM. O seu valor não reside numa maior precisão — um juiz LLM bem construído deteta nuances que nenhuma fórmula alguma vez captará —, mas sim na estabilidade e no baixo custo. A similaridade do cosseno devolve exatamente o mesmo número em cada execução, custa quase nada e pode, por isso, ser aplicada a milhares de casos em cada commit. Reserve então o juiz LLM para as dimensões que realmente o exigem.

Vamos rever as métricas essenciais antes de as integrar em benchmarks reproduzíveis.

Comparar Significado em Vez de Palavras

Comparar dois textos carácter a carácter torna-se inútil assim que a redação é livre. A similaridade semântica contorna este problema: cada texto é convertido num vetor por um modelo de embeddings, e medimos o ângulo entre os dois vetores. Duas frases que dizem a mesma coisa com palavras diferentes apontam na mesma direção.

import openai
import numpy as np

client = openai.OpenAI()

def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
    """Calculates the cosine similarity between two vectors."""
    a = np.array(vec_a)
    b = np.array(vec_b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

def semantic_similarity(text_a: str, text_b: str) -> float:
    """Measures the semantic similarity between two texts."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[text_a, text_b],
    )

    vec_a = response.data[0].embedding
    vec_b = response.data[1].embedding

    return cosine_similarity(vec_a, vec_b)

# Example
score = semantic_similarity(
    "The cat is on the rug.",
    "A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}")  # ~0.85+

O exemplo é elucidativo: duas frases sem palavras em comum obtêm uma pontuação superior a 0,85. Esta é a força do método, mas também a sua armadilha. A similaridade semântica ignora a negação e as nuances de grau — «o pagamento foi aceite» e «o pagamento foi recusado» parecem muito semelhantes ao nível dos vetores. Por isso, nunca a utilize isoladamente para validar uma resposta quando a exatidão factual é crucial.

Quando a questão é «a resposta aborda realmente a pergunta colocada?», nenhuma fórmula substitui o julgamento. A pontuação de relevância abaixo decomponde este julgamento em três perguntas distintas: A resposta é direta? Mantém-se focada? É completa? Esta decomposição é preferível a uma pontuação global, pois indica-lhe em que direção corrigir o prompt: um modelo prolixo e um modelo incompleto exigem correções opostas.

def relevance_score(
    question: str,
    answer: str,
    context: str | None = None,
) -> dict:
    """Evaluates whether the answer is relevant to the question."""
    prompt = (
        "Evaluate the relevance of this answer.\n\n"
        f"Question: {question}\n"
    )
    if context:
        prompt += f"Context provided: {context[:1000]}\n"
    prompt += (
        f"Answer: {answer}\n\n"
        "Criteria:\n"
        "1. Does the answer directly address the question? (0-5)\n"
        "2. Does the answer contain unrequested information? (0-5, 5=none)\n"
        "3. Is the answer complete? (0-5)\n\n"
        "Respond in JSON with keys: direct, focus, completeness."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0,
    )

    import json
    try:
        scores = json.loads(response.output_text)
        average = sum(scores.values()) / (len(scores) * 5)
        return {"score": average, "details": scores}
    except (json.JSONDecodeError, TypeError):
        return {"score": 0, "error": "Parsing failed"}

Note a formulação invertida do segundo critério, onde 5 significa «nenhuma informação não solicitada». Isto permite somar as três pontuações na mesma direção, mas é contra-intuitivo na leitura: quando adicionar os seus próprios critérios, mantenha esta convenção, caso contrário obterá médias que recompensam o defeito que pretendia penalizar.

Verificar se o Modelo Não Está a Alucinar

Numa aplicação de perguntas e respostas baseada em documentos, a métrica decisiva não é a qualidade da escrita, mas a fidelidade à fonte. O princípio de controlo é simples: apresente ao juiz o contexto original e a resposta gerada, e peça-lhe para classificar cada afirmação como suportada pelo contexto, ausente do contexto ou contraditória com o mesmo. A distinção entre estas duas últimas categorias é importante, pois uma afirmação meramente ausente pode ser um conhecimento geral correto, enquanto uma afirmação que contradiz a fonte é sempre um erro.

def detect_hallucinations(
    context: str,
    answer: str,
) -> dict:
    """Detects statements not supported by the context."""
    prompt = (
        "Analyze this answer and identify any statement "
        "that is NOT supported by the provided context.\n\n"
        f"Context: {context[:3000]}\n\n"
        f"Answer: {answer}\n\n"
        "For each statement in the answer, indicate:\n"
        "- supported: the statement is in the context\n"
        "- unsupported: the statement is not in the context\n"
        "- invented: the statement contradicts the context\n\n"
        "Respond in JSON with the key statements (list) and "
        "fidelity_score (0 to 1)."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0,
    )

    import json
    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"fidelity_score": 0, "error": "Parsing failed"}

Truncar o contexto para 3.000 caracteres é um limite que deve ter em conta: se a fonte exceder este tamanho, afirmações perfeitamente corretas serão contadas como não suportadas simplesmente porque o excerto que as justificava foi cortado. Para documentos longos, divida e avalie por secção, em vez de aceitar falsos positivos sistemáticos.

Construir um Benchmark Reproduzível

Um benchmark não é apenas mais uma métrica: é uma configuração que congela um conjunto de dados e um protocolo para que duas execuções sejam comparáveis. A classe abaixo mede a relevância, a fidelidade (quando o contexto está disponível), a latência e o custo, mantendo depois cada resultado datado e etiquetado pela versão do prompt.

from dataclasses import dataclass, field
import time

@dataclass
class BenchmarkResult:
    model: str
    prompt_version: str
    scores: dict
    avg_latency: float
    total_cost: float
    date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))

class Benchmark:
    """Reusable benchmark for comparing models and prompts."""

    def __init__(self, name: str, dataset: list[dict]):
        self.name = name
        self.dataset = dataset
        self.results: list[BenchmarkResult] = []

    def run(
        self,
        model: str,
        system_prompt: str,
        prompt_version: str,
    ) -> BenchmarkResult:
        """Runs the benchmark with a given model and prompt."""
        relevance_scores = []
        hallucination_scores = []
        latencies = []
        cost = 0

        for case in self.dataset:
            start = time.perf_counter()
            response = client.responses.create(
                model=model,
                instructions=system_prompt,
                input=case["input"],
            )
            latency = time.perf_counter() - start
            latencies.append(latency)

            # Evaluate
            relevance = relevance_score(
                case["input"], response.output_text
            )
            relevance_scores.append(relevance["score"])

            if case.get("context"):
                halluc = detect_hallucinations(
                    case["context"], response.output_text
                )
                hallucination_scores.append(
                    halluc.get("fidelity_score", 0)
                )

        result = BenchmarkResult(
            model=model,
            prompt_version=prompt_version,
            scores={
                "relevance": sum(relevance_scores) / len(relevance_scores),
                "fidelity": (
                    sum(hallucination_scores) / len(hallucination_scores)
                    if hallucination_scores else None
                ),
            },
            avg_latency=sum(latencies) / len(latencies),
            total_cost=cost,
        )

        self.results.append(result)
        return result

    def compare(self) -> str:
        """Compares all benchmark results."""
        lines = [f"Benchmark: {self.name}\n"]
        for r in self.results:
            lines.append(
                f"  {r.model} (prompt {r.prompt_version}) | "
                f"Relevance: {r.scores['relevance']:.2f} | "
                f"Latency: {r.avg_latency:.2f}s"
            )
        return "\n".join(lines)

A saída de compare coloca deliberadamente a relevância e a latência na mesma linha, porque é assim que a decisão é realmente tomada. Um modelo que ganha dois centésimos de ponto em relevância enquanto duplica o tempo de resposta não é uma escolha melhor para uma aplicação interativa; poderá sê-lo para processamento noturno. A tabela não decide por si; coloca o compromisso (trade-off) mesmo à sua frente.

Por fim, total_cost permanece zero nesta implementação. Preencha-o com os campos de utilização devolvidos pela API: uma comparação de modelos que omite o custo deixa de fora o critério que resolverá a discussão com a sua equipa financeira.

Pontos-chave

  • A similaridade semântica mede o significado, mas permanece cega à negação
  • Decomponha a relevância em critérios distintos em vez de uma pontuação global
  • Detete alucinações confrontando a resposta com o contexto de origem
  • Crie benchmarks reproduzíveis que meçam em conjunto a qualidade, a latência e o custo
  • Combine métricas automáticas e LLM-as-Judge para uma avaliação completa