Crear evaluaciones personalizadas
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.
Actualización del 2 de noviembre de 2026 — Plataforma Evals. OpenAI ha anunciado el fin de su plataforma Evals: las evaluaciones existentes son de solo lectura desde el 31 de octubre de 2026, y tanto el panel de control como la API, incluidos los calificadores, cerrarán el 30 de noviembre de 2026. OpenAI ha publicado una guía de migración a Promptfoo. Los principios de evaluación de esta lección siguen siendo válidos; solo cambia la herramienta.
Adapta las evaluaciones a tu dominio
Los calificadores genéricos no bastan para evaluar la calidad en tu dominio específico. Un chatbot médico, un asistente legal y una herramienta de redacción de marketing tienen criterios de calidad distintos, y estos criterios no solo son más numerosos, sino que se priorizan de forma diferente. Un desajuste de tono en un boletín es una molestia; la misma aproximación en una instrucción de dosificación es un error grave. Un calificador genérico trata ambos casos igual, lo que equivale a no evaluar nada en absoluto.
Por eso necesitas evaluaciones personalizadas basadas en una rúbrica explícita que traduzca tus prioridades empresariales en pesos. Esa es la rúbrica que vamos a construir.
Traduce un requisito empresarial a una rúbrica
Una rúbrica es una lista de criterios ponderados que suman 1. El ejercicio más útil no es codificar la estructura, que lleva unas quince líneas, sino rellenarla: decidir que los beneficios para el cliente pesan 0,25 mientras que la longitud solo pesa 0,10 obliga a mantener una conversación explícita con los responsables de producto. Lo que obtienes es una definición compartida de «una buena respuesta» que nadie podrá discutir a posteriori.
from dataclasses import dataclass
@dataclass
class Critere:
nom: str
description: str
poids: float # 0 a 1, suma de pesos = 1
@dataclass
class Rubrique:
nom: str
criteres: list[Critere]
def valider(self) -> bool:
total = sum(c.poids for c in self.criteres)
return abs(total - 1.0) < 0.01
# Ejemplo: rúbrica para un asistente de redacción de marketing
rubrique_marketing = Rubrique(
nom="Qualité rédaction marketing",
criteres=[
Critere("ton", "Le ton est professionnel et engageant", 0.20),
Critere("cta", "Contient un appel à l'action clair", 0.15),
Critere("benefices", "Met en avant les bénéfices client", 0.25),
Critere("longueur", "Respecte la longueur demandée", 0.10),
Critere("grammaire", "Aucune faute de grammaire ou orthographe", 0.15),
Critere("marque", "Respecte les guidelines de la marque", 0.15),
],
)
El método valider merece ser llamado en las pruebas, no solo escrito. Las rúbricas evolucionan: añades un criterio de cumplimiento, eliminas uno que ya no sirve y la suma se desvía a 1,15 sin que nada señale la anomalía. Las puntuaciones siguen siendo calculables, pero erróneas, y al compararlas entre versiones te llevarán a conclusiones equivocadas.
El calificador traduce entonces la rúbrica a un prompt, solicita una puntuación de 0 a 5 por criterio y recompone una puntuación global ponderada. Cada puntuación viene acompañada de un comentario breve: eso es lo que te permitirá, al revisar casos deficientes, entender si el modelo respondió mal o si tu criterio estaba mal redactado.
import openai
import json
client = openai.OpenAI()
def evaluer_multi_criteres(
question: str,
reponse: str,
rubrique: Rubrique,
) -> dict:
"""Evalúa una respuesta frente a una rúbrica multicriterio."""
criteres_texte = "\n".join(
f"- {c.nom} (poids: {c.poids}): {c.description}"
for c in rubrique.criteres
)
prompt = (
"Évaluez cette réponse selon les critères suivants.\n"
"Pour chaque critère, donnez un score de 0 à 5.\n\n"
f"Question posée : {question}\n"
f"Réponse à évaluer : {reponse}\n\n"
f"Critères :\n{criteres_texte}\n\n"
"Répondez en JSON avec un objet scores contenant pour chaque critère "
"un score (0-5) et un commentaire court."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requiere effort none
input=prompt,
temperature=0.0,
)
try:
resultat = json.loads(response.output_text)
scores = resultat.get("scores", {})
# Calcular puntuación ponderada
score_pondere = 0
for critere in rubrique.criteres:
if critere.nom in scores:
score_brut = scores[critere.nom]["score"] / 5.0
score_pondere += score_brut * critere.poids
return {
"score_global": score_pondere,
"scores_details": scores,
"rubrique": rubrique.nom,
}
except (json.JSONDecodeError, KeyError):
return {"score_global": 0, "erreur": "Parsing échoué"}
Cuidado con el bucle de cálculo: si falta un criterio en la respuesta del juez, se ignora en silencio y contribuye con cero a la puntuación ponderada. Una respuesta excelente podría quedarse capped en 0,75 simplemente porque el juez olvidó una clave. Si tus puntuaciones parecen estancadas bajo un techo inexplicable, inspecciona scores_details antes de culpar al modelo evaluado.
Cuando la máquina juzga mejor que un humano
Hacer que un LLM califique código es un atajo costoso: el único veredicto que importa es la ejecución. El calificador siguiente concatena el código generado y una prueba, lo escribe en un archivo temporal, lo ejecuta y cuenta los aciertos. La puntuación resultante no necesita interpretación: una prueba se supera o no se supera.
import subprocess
import tempfile
def evaluer_code_python(
code_genere: str,
tests: list[str],
) -> dict:
"""Evalúa código Python ejecutándolo frente a pruebas."""
resultats_tests = []
for i, test in enumerate(tests):
code_complet = f"{code_genere}\n\n{test}"
with tempfile.NamedTemporaryFile(
mode="w", suffix=".py", delete=False
) as f:
f.write(code_complet)
f.flush()
try:
resultat = subprocess.run(
["python3", f.name],
capture_output=True,
text=True,
timeout=10,
)
succes = resultat.returncode == 0
resultats_tests.append({
"test": i,
"succes": succes,
"sortie": resultat.stdout[:200],
"erreur": resultat.stderr[:200] if not succes else "",
})
except subprocess.TimeoutExpired:
resultats_tests.append({
"test": i,
"succes": False,
"erreur": "Timeout (10s)",
})
nb_succes = sum(1 for r in resultats_tests if r["succes"])
return {
"score": nb_succes / len(tests) if tests else 0,
"tests_passes": nb_succes,
"tests_total": len(tests),
"details": resultats_tests,
}
El timeout=10 no es una precaución de confort: un modelo produce regularmente bucles infinitos y, sin este límite, tu campaña de evaluación se queda atascada en el primer caso fallido. Recuerda también que estás ejecutando código que no has escrito; fuera de un entorno de desarrollo aislado, esta función requiere un sandbox.
El resumen ilustra un caso mixto, donde parte del juicio es mecánico y parte no. La longitud es medible: la relación calculada penaliza simétricamente un resumen demasiado corto y uno demasiado largo, lo que evita el truco del modelo de copiar el texto fuente para no omitir nada. La fidelidad, en cambio, no es medible mediante una regla y vuelve al juez LLM, con una pregunta directa sobre información inventada.
def evaluer_resume(
texte_original: str,
resume: str,
longueur_cible: int = 100,
) -> dict:
"""Evalúa la calidad de un resumen."""
mots_resume = len(resume.split())
ratio_longueur = min(
mots_resume / longueur_cible,
longueur_cible / max(mots_resume, 1),
)
# Fidelidad vía LLM
response = client.responses.create(
model="gpt-5.6-terra",
input=(
f"Le résumé suivant est-il fidèle au texte original ? "
f"Contient-il des informations inventées ?\n\n"
f"Texte original (extrait) : {texte_original[:2000]}\n\n"
f"Résumé : {resume}\n\n"
f"Répondez en JSON avec les clés : fidélité (0-5), "
f"hallucinations (oui/non), commentaire (court)."
),
temperature=0.0,
)
try:
fidelite = json.loads(response.output_text)
except json.JSONDecodeError:
fidelite = {"fidelite": 0, "hallucinations": "inconnu"}
return {
"score_longueur": ratio_longueur,
"score_fidelite": fidelite.get("fidelite", 0) / 5.0,
"hallucinations": fidelite.get("hallucinations", "inconnu"),
"mots_resume": mots_resume,
"longueur_cible": longueur_cible,
}
Haz que la evaluación sea repetible
Una evaluación que repites manualmente acaba por no repetirse nunca más. La canalización encapsula la rúbrica y mantiene un historial de campañas, convirtiendo una medición puntual en una serie temporal: ves que la puntuación media bajó de 0,81 a 0,79 tras el cambio de prompt del martes, información que ninguna ejecución aislada podría haberte dado.
class PipelineEval:
"""Canalización de evaluación reutilizable."""
def __init__(self, nom: str, rubrique: Rubrique):
self.nom = nom
self.rubrique = rubrique
self.historique: list[dict] = []
def evaluer_batch(
self,
dataset: list[dict],
modele: str,
prompt_systeme: str,
) -> dict:
"""Evalúa un lote completo y devuelve métricas."""
resultats = []
for cas in dataset:
response = client.responses.create(
model=modele,
instructions=prompt_systeme,
input=cas["input"],
)
eval_result = evaluer_multi_criteres(
cas["input"],
response.output_text,
self.rubrique,
)
resultats.append(eval_result)
scores = [r["score_global"] for r in resultats]
rapport = {
"pipeline": self.nom,
"modele": modele,
"nb_cas": len(dataset),
"score_moyen": sum(scores) / len(scores),
"score_min": min(scores),
"score_max": max(scores),
}
self.historique.append(rapport)
return rapport
Un consejo para empezar: construye tu primera rúbrica sobre solo veinte casos, haz que los puntúen en paralelo el juez LLM y un experto de dominio, y luego compara las dos series. Las discrepancias te dirán qué criterios están mal descritos mucho antes de decirte nada sobre la calidad del modelo.
Puntos clave
- Crea rúbricas de evaluación específicas para tu dominio empresarial, con pesos explícitos
- Verifica que la suma de los pesos se mantenga en 1 a medida que evoluciona la rúbrica
- Combina evaluación automatizada (código, longitud) y LLM como juez (calidad)
- Prueba el código generado ejecutándolo, con un tiempo de espera y un entorno aislado
- Construye una canalización reutilizable que mantenga un historial de campañas