Evaluación automatizada de prompts
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 de Responses) oreasoning_effort="none"(Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.
Evaluación automatizada de prompts
La evaluación automatizada es la piedra angular de un pipeline de ingeniería de prompts maduro. Te permite detectar regresiones, comparar modelos y validar cambios antes del despliegue. Sin ella, cada modificación de un prompt es una apuesta a ciegas.
Tipos de evaluación
Tres familias de evaluadores reparten el trabajo en función de la naturaleza de la salida esperada; casi siempre combinarás varios de ellos.
Evaluación de coincidencia exacta
Para tareas con una única respuesta esperada, basta una comparación directa. eval_exact_match normaliza mayúsculas y espacios en blanco antes de comparar: sin esta precaución, «Bug» y «bug» contarían como error, llevándote a solucionar un problema que no existe.
eval_set_match gestiona casos en los que la respuesta es un conjunto: entidades encontradas en un documento, categorías asignadas a un artículo. Calcula precisión y exhaustividad (recall), dos cifras que cuentan historias distintas: una precisión alta con una exhaustividad baja indica un modelo excesivamente cauteloso que solo extrae lo que le resulta seguro; lo contrario delata un modelo que alucina para rellenar huecos. La medida F1 las resume cómodamente, pero no las sustituye a la hora de diagnosticar.
def eval_exact_match(prediction: str, reference: str) -> bool:
"""Coincidencia exacta tras normalización."""
return prediction.strip().lower() == reference.strip().lower()
def eval_set_match(prediction: set, reference: set) -> dict:
"""Coincidencia de conjuntos (entidades, categorías)."""
tp = len(prediction & reference)
fp = len(prediction - reference)
fn = len(reference - prediction)
precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = (2 * precision * recall / (precision + recall)
if (precision + recall) > 0 else 0)
return {"precision": precision, "recall": recall, "f1": f1}
Evaluación semántica (Embedding)
Para respuestas de texto donde la redacción puede variar, la coincidencia exacta resulta absurda: «Tu pedido se entregará mañana» y «La entrega está programada para mañana» dicen lo mismo, pero puntuarían cero. La similitud del coseno entre embeddings mide la proximidad semántica en lugar de la coincidencia de caracteres, devolviendo una puntuación continua.
Tú estableces el umbral por encima del cual una respuesta se considera aceptable. Calíbralo con unas pocas decenas de pares que hayas clasificado manualmente como «equivalentes» o «diferentes» y elige el valor que mejor separe ambos grupos: un umbral elegido a ojo produce resultados tan arbitrarios como no medir nada, con la ilusión añadida de rigor.
from openai import OpenAI
import numpy as np
client = OpenAI()
def eval_semantic_similarity(prediction: str,
reference: str) -> float:
"""Similitud del coseno entre embeddings."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[prediction, reference]
)
emb_pred = np.array(response.data[0].embedding)
emb_ref = np.array(response.data[1].embedding)
similarity = float(
np.dot(emb_pred, emb_ref) /
(np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
)
return similarity
Evaluación mediante LLM (LLM-as-Judge)
El modelo evalúa la calidad de una respuesta. Este es el único enfoque viable cuando no existe una referencia: nadie va a redactar a mano la respuesta de soporte «correcta» para doscientos tickets.
Que un juez sea usable depende de unos pocos factores. Primero, el modelo utilizado: eliges un modelo más capaz como juez, aquí gpt-5.6-sol, porque un juez al mismo nivel que el evaluado tiende a validar sus propios defectos. Segundo, exigir justificación: motivar cada puntuación estabiliza el juicio y te permite detectar un evaluador que usa el criterio equivocado; una justificación que habla de longitud cuando el criterio era claridad es una señal de alarma. Por último, temperature a 0,1 garantiza la estabilidad de la puntuación entre ejecuciones.
def eval_llm_judge(question: str, prediction: str,
criteria: list[str]) -> dict:
"""Evaluación mediante un modelo juez."""
criteria_text = "\n".join(
f"- {c}: puntuación de 1 a 5" for c in criteria
)
response = client.responses.create(
model="gpt-5.6-sol", # Modelo más capaz como juez
reasoning={"effort": "none"}, # temperature requiere effort none
instructions="Eres un evaluador experto e imparcial.",
input=f"""Evalúa esta respuesta según los siguientes criterios:
Pregunta formulada: {question}
Respuesta a evaluar: {prediction}
Criterios:
{criteria_text}
Para cada criterio, asigna una puntuación de 1 a 5 con justificación.""",
text={
"format": {
"type": "json_schema",
"name": "evaluation",
"schema": {
"type": "object",
"properties": {
"scores": {
"type": "array",
"items": {
"type": "object",
"properties": {
"criterion": {"type": "string"},
"score": {"type": "integer"},
"justification": {"type": "string"}
},
"required": ["criterion", "score",
"justification"],
"additionalProperties": False
}
},
"overall_score": {"type": "number"},
"verdict": {"type": "string"}
},
"required": ["scores", "overall_score", "verdict"],
"additionalProperties": False
},
"strict": True
}
},
temperature=0.1
)
return json.loads(response.output_text)
Pipeline de evaluación completo
EvalPipeline ensambla estos bloques de construcción: carga un conjunto de pruebas, ejecuta el prompt en cada caso, aplica todos los evaluadores proporcionados y agrega las puntuaciones. Los evaluadores se pasan como una lista de funciones, todas llamadas con la misma firma; añadir una métrica no requiere modificar el pipeline, y puedes ejecutar coincidencia exacta, similitud semántica y un juez en la misma ejecución sin pagar tres veces por la generación.
El método summary también acumula los tokens consumidos. Esta línea, aparentemente secundaria, te protege de una trampa común: una versión de prompt que gana dos puntos de puntuación mientras triplica la factura no es necesariamente la elección correcta, y es mejor aprenderlo en el momento de sopesar compromisos que cuando llegue la factura mensual.
import json
from dataclasses import dataclass
from pathlib import Path
@dataclass
class TestCase:
"""Un caso de prueba para evaluación."""
input_text: str
expected_output: str = None
metadata: dict = None
class EvalPipeline:
"""Pipeline de evaluación automatizada."""
def __init__(self, test_suite_path: str):
"""Carga el conjunto de pruebas desde un archivo JSON."""
data = json.loads(Path(test_suite_path).read_text())
self.test_cases = [TestCase(**tc) for tc in data]
self.results = []
def run(self, prompt_config: dict,
evaluators: list[callable]) -> dict:
"""Ejecuta todas las pruebas y evalúa los resultados."""
self.results = []
for tc in self.test_cases:
# Generar respuesta
response = client.responses.create(
model=prompt_config["model"],
reasoning={"effort": "none"}, # temperature requiere effort none
instructions=prompt_config["system_prompt"],
input=tc.input_text,
temperature=prompt_config.get("temperature", 0.1)
)
prediction = response.output_text
# Evaluar con cada evaluador
scores = {}
for evaluator in evaluators:
score = evaluator(
question=tc.input_text,
prediction=prediction,
reference=tc.expected_output
)
scores[evaluator.__name__] = score
self.results.append({
"input": tc.input_text,
"expected": tc.expected_output,
"prediction": prediction,
"scores": scores,
"tokens": {
"input": response.usage.input_tokens,
"output": response.usage.output_tokens
}
})
return self.summary()
def summary(self) -> dict:
"""Resume los resultados de la evaluación."""
if not self.results:
return {"error": "Sin resultados"}
# Agregar puntuaciones por evaluador
all_scores = {}
for result in self.results:
for eval_name, score in result["scores"].items():
if eval_name not in all_scores:
all_scores[eval_name] = []
if isinstance(score, (int, float)):
all_scores[eval_name].append(score)
elif isinstance(score, dict) and "f1" in score:
all_scores[eval_name].append(score["f1"])
summary = {
"total_tests": len(self.results),
"average_scores": {
name: sum(scores) / len(scores)
for name, scores in all_scores.items()
if scores
},
"total_token_cost": sum(
r["tokens"]["input"] + r["tokens"]["output"]
for r in self.results
)
}
return summary
Conjunto de pruebas: formato
El formato del conjunto de pruebas se mantiene intencionadamente minimalista: una entrada, la salida esperada y metadatos de forma libre. Estos metadatos son más útiles de lo que parecen: al etiquetar cada caso por categoría, desglosas las puntuaciones y descubres que tu clasificador no falla al azar, sino en una familia específica de solicitudes, algo que una media global del 88 % no revela. Los tres ejemplos siguientes también muestran qué debe contener un buen conjunto: casos claros, como un fallo de inicio, pero también casos que bordean otra categoría; una pregunta sobre una funcionalidad faltante se parece mucho a un informe de error, y es en este límite donde se decide la calidad de un clasificador.
[
{
"input_text": "Mi paquete no ha llegado",
"expected_output": "complaint",
"metadata": {"category": "delivery"}
},
{
"input_text": "¿Cómo activo el modo oscuro?",
"expected_output": "question",
"metadata": {"category": "feature"}
},
{
"input_text": "La aplicación se cierra al inicio en iOS 18",
"expected_output": "bug",
"metadata": {"category": "technical"}
}
]
Integración en CI/CD
Ejecuta la evaluación en cada cambio de prompt. La función ci_eval_check convierte la medición en una barrera de seguridad: ejecuta el pipeline, compara la puntuación media con un umbral y devuelve un booleano que tu cadena de integración interpreta como éxito o fallo de compilación. Un cambio que haga caer la precisión por debajo del 85 % ya no llega a producción, igual que una prueba unitaria rota bloquea una fusión.
Establece el umbral en función de la puntuación que ya alcanza la versión actual, no desde un ideal. Si lo pones demasiado alto, condenas al equipo a eludir la verificación con desactivaciones temporales que se vuelven permanentes; si lo pones demasiado bajo, no estás comprobando nada mientras muestras una insignia verde. Por último, ten presente que el conjunto de pruebas debe seguir siendo representativo del tráfico real: un umbral cumplido en veinte casos escritos hace dos años no demuestra nada sobre las solicitudes de hoy.
def ci_eval_check(prompt_config: dict,
test_suite: str,
min_score: float = 0.85) -> bool:
"""Barrera CI/CD: comprueba que el prompt alcanza la puntuación mínima."""
pipeline = EvalPipeline(test_suite)
def accuracy(question, prediction, reference):
return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0
results = pipeline.run(prompt_config, [accuracy])
avg_score = results["average_scores"].get("accuracy", 0)
print(f"Puntuación media: {avg_score:.2%}")
print(f"Umbral mínimo: {min_score:.2%}")
if avg_score < min_score:
print("FALLO: puntuación por debajo del umbral")
return False
print("ÉXITO: prompt validado")
return True
Panel de evaluación
Haz un seguimiento de la evolución de la puntuación en el tiempo. Una única puntuación no dice nada; la serie cuenta la historia de tu prompt y responde a la pregunta que siempre surge en las reuniones: ¿estamos avanzando? La función siguiente produce una tabla en Markdown que pone lado a lado, para cada versión, la puntuación media, los tokens consumidos y el coste estimado. El formato no es casual: se pega directamente en una pull request, haciendo la comparación legible para personas que nunca abrirán tu código.
def comparison_report(results: dict[str, dict]) -> str:
"""Genera un informe comparativo entre versiones de prompt."""
report = "# Informe de evaluación comparativa\n\n"
report += "| Versión | Puntuación media | Tokens medios | Coste |\n"
report += "|---------|---------------|----------------|------|\n"
for version, data in results.items():
score = data.get("average_scores", {})
score_val = list(score.values())[0] if score else 0
tokens = data.get("total_token_cost", 0)
report += (f"| {version} | {score_val:.2%} | "
f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")
return report
Configura tus barreras de seguridad
Construye un conjunto de veinte casos de prueba para un prompt real, colocando un puñado de casos límite en lugar de veinte ejemplos cómodos: un conjunto que aprueba al 100 % a la primera no te enseña nada. Implementa los tres tipos de evaluador y ejecútalos juntos en dos versiones de tu prompt. La coincidencia exacta da un número limpio, la similitud semántica captura reformulaciones legítimas y el juez ilumina los casos en los que los dos primeros discrepan; estos desacuerdos son los más ricos en lecciones sobre lo que realmente esperas del modelo.
Compara, identifica la versión ganadora y configura el script de CI que bloquee el despliegue si la puntuación cae. Sabrás que el sistema funciona el día que rechace un cambio que te parecía obvio.
Puntos clave
- La evaluación automatizada es esencial para iterar con confianza
- Combina según necesites evaluación exacta, semántica y LLM-as-judge
- Mantén un conjunto de pruebas que evolucione con tu aplicación
- Integra la evaluación en tu CI/CD con un umbral mínimo
- Usa un modelo más capaz como juez para evaluar un modelo más barato
- Documenta las puntuaciones de cada versión para seguir la evolución
Pon a prueba tus conocimientos
Técnicas avanzadas e industrialización: la comprobación final.
1. ¿Qué debe contener un system prompt eficaz?
Respuesta: Rol, alcance, reglas de comportamiento, formato de salida y gestión de casos límite; redactado como una especificación y probado como código.
2. ¿Cuándo debes usar autoconsistencia?
Respuesta: En problemas de razonamiento con respuestas verificables: genera múltiples razonamientos independientes y quédate con la respuesta mayoritaria; la varianza se convierte en aliada.
3. ¿Qué garantiza el modo JSON con validación de esquema?
Respuesta: Una salida que se ajusta estrictamente al esquema (tipos, campos obligatorios, enumeraciones), validada en el lado de la API y revalidada en el código (JSON Schema, Zod) para una cadena sin sorpresas.
4. ¿Qué es el grounding (anclaje)?
Respuesta: Anclar las respuestas en hechos proporcionados (documentos, datos recuperados) en lugar de en la memoria del modelo, con el requisito de citar o abstenerse de fuentes externas.
5. ¿Cuál es el propósito de un catálogo de prompts versionado?
Respuesta: Tratar los prompts como artefactos: versiones, pruebas A/B, evaluaciones automatizadas en cada cambio; sabes qué se está ejecutando en producción y por qué.
El bucle final del curso —versionar, probar, evaluar automáticamente— transforma la ingeniería de prompts artesanal en una práctica de equipo.