Métricas y puntos de referencia
En esta página
Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI:
temperatureytop_psolo se aceptan con un esfuerzo de razonamiento denone, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificarreasoning={"effort": "none"}(API Responses) oreasoning_effort="none"(Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.
Medición de la calidad con métricas
Más allá de las puntuaciones de LLM-as-Judge, existen métricas cuantitativas para evaluar distintos aspectos de las salidas de los LLM. Su valor no radica en ser más precisas —un juez LLM bien construido percibe matices que ninguna fórmula captará jamás—, sino en que son estables y baratas. La similitud del coseno devuelve exactamente el mismo número en cada ejecución, cuesta casi nada y, por ello, puede ejecutarse sobre miles de casos con cada confirmación de código. Dejas entonces el juez LLM para aquellas dimensiones que realmente lo requieren.
Repasaremos las métricas esenciales antes de ensamblarlas en puntos de referencia reproducibles.
Comparar significado, no palabras
Comparar dos textos carácter por carácter se vuelve inútil en cuanto la redacción es libre. La similitud semántica sortea este problema: cada texto se convierte en un vector mediante un modelo de incrustación (embedding) y medimos el ángulo entre ambos vectores. Dos frases que dicen lo mismo con palabras distintas apuntan en la misma dirección.
import openai
import numpy as np
client = openai.OpenAI()
def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
"""Calcula la similitud del coseno entre dos vectores."""
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:
"""Mide la similitud semántica entre dos textos."""
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)
# Ejemplo
score = semantic_similarity(
"The cat is on the rug.",
"A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}") # ~0,85+
El ejemplo es ilustrativo: dos frases sin ninguna palabra en común obtienen una puntuación superior a 0,85. Esta es la fortaleza del método, pero también su trampa. La similitud semántica ignora la negación y los matices de grado; «el pago fue aceptado» y «el pago fue rechazado» resultan muy similares en el espacio vectorial. Por tanto, nunca la uses sola para validar una respuesta cuando importe la exactitud factual.
Cuando la pregunta es «¿responde realmente la respuesta a la pregunta formulada?», ninguna fórmula sustituye al juicio. La puntuación de relevancia siguiente desglosa ese juicio en tres preguntas distintas: ¿es directa la respuesta? ¿se mantiene centrada? ¿es completa? Este desglose es mejor que una puntuación global porque te indica en qué dirección corregir el prompt: un modelo verboso y un modelo incompleto exigen correcciones opuestas.
def relevance_score(
question: str,
answer: str,
context: str | None = None,
) -> dict:
"""Evalúa si la respuesta es relevante para la pregunta."""
prompt = (
"Evalúa la relevancia de esta respuesta.\n\n"
f"Pregunta: {question}\n"
)
if context:
prompt += f"Contexto proporcionado: {context[:1000]}\n"
prompt += (
f"Respuesta: {answer}\n\n"
"Criterios:\n"
"1. ¿La respuesta aborda directamente la pregunta? (0-5)\n"
"2. ¿La respuesta contiene información no solicitada? (0-5, 5=ninguna)\n"
"3. ¿La respuesta es completa? (0-5)\n\n"
"Responde en JSON con las claves: direct, focus, completeness."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requiere 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"}
Observa la formulación invertida del segundo criterio, donde 5 significa «sin información no solicitada». Esto permite sumar las tres puntuaciones en la misma dirección, pero resulta contraintuitivo al leerlo: cuando añadas tus propios criterios, mantén esta convención o acabarás con promedios que premian el defecto que pretendías penalizar.
Verificar que el modelo no alucina
En una aplicación de preguntas y respuestas basada en documentos, la métrica decisiva no es la calidad de redacción, sino la fidelidad a la fuente. El principio de control es simple: presenta al juez el contexto original y la respuesta generada, y pídele que clasifique cada afirmación como respaldada por el contexto, ausente en el contexto o contradictoria con él. La distinción entre estas dos últimas categorías importa, porque una afirmación meramente ausente podría ser conocimiento general correcto, mientras que una afirmación que contradice la fuente es siempre un error.
def detect_hallucinations(
context: str,
answer: str,
) -> dict:
"""Detecta afirmaciones no respaldadas por el contexto."""
prompt = (
"Analiza esta respuesta e identifica cualquier afirmación "
"que NO esté respaldada por el contexto proporcionado.\n\n"
f"Contexto: {context[:3000]}\n\n"
f"Respuesta: {answer}\n\n"
"Para cada afirmación de la respuesta, indica:\n"
"- supported: la afirmación está en el contexto\n"
"- unsupported: la afirmación no está en el contexto\n"
"- invented: la afirmación contradice el contexto\n\n"
"Responde en JSON con la clave statements (lista) y "
"fidelity_score (0 a 1)."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requiere 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 el contexto a 3.000 caracteres es un límite que debes tener presente: si la fuente supera este tamaño, afirmaciones perfectamente exactas se contarán como no respaldadas simplemente porque el pasaje que las justificaba quedó cortado. Para documentos largos, divide y evalúa por sección en lugar de aceptar falsos positivos sistemáticos.
Ensamblar un punto de referencia reproducible
Un punto de referencia no es solo otra métrica: es una configuración que congela un conjunto de datos y un protocolo para que dos ejecuciones sean comparables. La clase siguiente mide relevancia, fidelidad (cuando hay contexto disponible), latencia y coste, y conserva cada resultado con fecha y etiquetado por versión del 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:
"""Punto de referencia reutilizable para comparar modelos y 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:
"""Ejecuta el punto de referencia con un modelo y un prompt dados."""
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)
# Evaluar
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:
"""Compara todos los resultados del punto de referencia."""
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)
La salida de compare coloca deliberadamente relevancia y latencia en la misma línea, porque así es como se toma realmente la decisión. Un modelo que gana dos centésimas de punto en relevancia mientras duplica el tiempo de respuesta no es una mejor opción para una aplicación interactiva; podría serlo para un procesamiento nocturno. La tabla no decide por ti; pone el compromiso justo delante de tus ojos.
Por último, total_cost permanece en cero en esta implementación. Rellénalo a partir de los campos usage devueltos por la API: una comparación de modelos que omite el coste deja fuera el criterio que zanjará la discusión con tu equipo financiero.
Puntos clave
- La similitud semántica mide el significado, pero permanece ciega a la negación
- Desglosa la relevancia en criterios distintos en lugar de usar una puntuación global
- Detecta alucinaciones confrontando la respuesta con el contexto fuente
- Crea puntos de referencia reproducibles que midan juntos calidad, latencia y coste
- Combina métricas automáticas y LLM-as-Judge para una evaluación completa