Métricas e Benchmarks
Nesta página
Lição atualizada em 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 Responses) oureasoning_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