Evalúa tu modelo ajustado
En esta página
Actualización 2 de noviembre de 2026 — Disponibilidad del ajuste fino. El servicio de ajuste fino de autoservicio de OpenAI está siendo retirado gradualmente: desde el 7 de mayo de 2026, las organizaciones que nunca lo han utilizado ya no pueden crear trabajos; desde el 2 de julio, debes haber usado un modelo ajustado en los últimos 60 días; y a partir del 6 de enero de 2027, ningún cliente podrá lanzar nuevos trabajos. Los modelos ya entrenados seguirán siendo utilizables hasta que se retire su modelo base. Este curso sigue siendo útil para comprender y aprovechar un modelo existente; para nuevos proyectos, prioriza la ingeniería de prompts, RAG y las evaluaciones.
Por qué la evaluación es esencial
Un ajuste fino exitoso no se mide solo por la pérdida. La pregunta real es: ¿es tu modelo ajustado realmente mejor que el modelo base para tu caso de uso? Una curva que desciende limpiamente solo demuestra que el modelo aprendió a reproducir tus ejemplos; no dice nada sobre su comportamiento ante solicitudes no vistas. Esta lección te muestra cómo construir un protocolo de evaluación riguroso, combinando métricas automatizadas, juicio mediante LLM y revisión humana.
Construcción de un conjunto de prueba
Tu conjunto de prueba debe estar separado tanto de tus datos de entrenamiento como de validación. La distinción importa: el conjunto de validación monitoriza el entrenamiento y, por tanto, influye en tus decisiones de hiperparámetros, lo que gradualmente lo contamina. El conjunto de prueba, por el contrario, solo se abre una vez que el modelo está congelado. Representa las situaciones del mundo real que tu modelo encontrará en producción, con las mismas proporciones de casos sencillos y complejos. Una división 80/10/10 sobre un corpus previamente mezclado es un punto de partida razonable.
import json
import random
def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
"""Divide los datos en entrenamiento/validación/prueba."""
with open(file, "r") as f:
examples = [json.loads(l) for l in f]
random.shuffle(examples)
n = len(examples)
i1 = int(n * ratios[0])
i2 = int(n * (ratios[0] + ratios[1]))
datasets = {
"train": examples[:i1],
"validation": examples[i1:i2],
"test": examples[i2:]
}
for name, data in datasets.items():
with open(f"{name}.jsonl", "w") as f:
for ex in data:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"{name}: {len(data)} ejemplos")
return datasets
prepare_datasets("all_data.jsonl")
Evaluación automatizada
Evaluación basada en métricas
El principio es sencillo: para cada ejemplo de prueba, elimina el mensaje del asistente (esa es la respuesta esperada, que el modelo no debe ver), envía el resto y mantén la entrada, la respuesta de referencia y la respuesta generada una al lado de la otra. Esta estructura de tres columnas es la base de todo lo que sigue; usarla para el cálculo de métricas o el juicio cualitativo es solo cuestión de procesamiento posterior.
from openai import OpenAI
client = OpenAI()
def evaluate_model(model: str, test_examples: list[dict]) -> dict:
"""Evalúa un modelo en un conjunto de prueba."""
results = []
for ex in test_examples:
# Extrae la pregunta (sin la respuesta esperada)
input_messages = [
m for m in ex["messages"] if m["role"] != "assistant"
]
expected_answer = next(
m["content"] for m in ex["messages"] if m["role"] == "assistant"
)
# Obtiene la respuesta del modelo
response = client.responses.create(
model=model,
input=input_messages
)
model_answer = response.output_text
results.append({
"input": input_messages[-1]["content"],
"expected": expected_answer,
"obtained": model_answer
})
return results
Evaluación con LLM como juez
Una técnica potente consiste en utilizar un modelo de alto rendimiento para juzgar la calidad de la respuesta. La comparación palabra por palabra con la referencia se vuelve inservible en cuanto son aceptables varias formulaciones; un juez, sin embargo, aprecia el fondo. La calidad de su veredicto depende enteramente de la precisión del prompt: cuatro criterios calificados del 1 al 5, una salida JSON forzada y un comentario en texto libre que usarás más tarde para entender los fallos. Planifica los casos en los que la salida no sea analizable en lugar de permitir que una excepción interrumpa la campaña.
def evaluate_with_judge(results: list[dict]) -> list[dict]:
"""Utiliza gpt-5.6-sol como juez para evaluar las respuestas."""
evaluations = []
for r in results:
judge_prompt = f"""Evalúa la calidad de la respuesta obtenida en comparación con la respuesta esperada.
Pregunta: {r['input']}
Respuesta esperada: {r['expected']}
Respuesta obtenida: {r['obtained']}
Criterios (califica cada uno del 1 al 5):
1. Precisión: ¿Es correcta la información?
2. Completitud: ¿Se cubren todos los puntos importantes?
3. Estilo: ¿Son adecuados el tono y el formato?
4. Concisión: ¿Tiene la respuesta una longitud apropiada?
Responde en JSON: {{"accuracy": N, "completeness": N, "style": N, "conciseness": N, "comment": "..."}}"""
response = client.responses.create(
model="gpt-5.6-sol",
input=judge_prompt
)
try:
evaluation = json.loads(response.output_text)
evaluations.append(evaluation)
except json.JSONDecodeError:
evaluations.append({"error": "Respuesta no analizable"})
return evaluations
Métricas especializadas
Los dos enfoques anteriores funcionan bien para respuestas escritas. En cuanto la salida de tu modelo tiene una estructura fija, son posibles medidas más directas que te ahorran el rodeo por un juez.
Para clasificación
Cuando la salida esperada pertenece a un conjunto cerrado (una categoría de ticket, un sentimiento, un código de producto), la coincidencia exacta vuelve a ser relevante. Normaliza mayúsculas y espacios antes de comparar; de lo contrario, «Urgent» frente a «urgent» contará como un error y sesgará tu tasa.
def classification_metrics(results: list[dict]) -> dict:
"""Calcula precisión, exhaustividad y F1 para una tarea de clasificación."""
correct = sum(
1 for r in results
if r["expected"].strip().lower() == r["obtained"].strip().lower()
)
total = len(results)
precision = correct / total if total > 0 else 0
print(f"Precisión: {precision:.2%} ({correct}/{total})")
return {"precision": precision, "correct": correct, "total": total}
Para llamadas a funciones
Las llamadas a funciones se juzgan en dos ejes que deben medirse por separado. Un modelo que elige la función correcta pero se equivoca en el parámetro falla de forma distinta a uno que llama a la herramienta completamente equivocada: el primer problema se soluciona con ejemplos de extracción, el segundo con ejemplos de discriminación. Una única puntuación global ocultaría esta distinción y te dejaría trabajando a ciegas.
def function_calling_metrics(results: list[dict]) -> dict:
"""Evalúa la calidad de las llamadas a funciones."""
stats = {"correct_function": 0, "correct_params": 0, "total": 0}
for r in results:
stats["total"] += 1
if r.get("expected_function") == r.get("obtained_function"):
stats["correct_function"] += 1
if r.get("expected_params") == r.get("obtained_params"):
stats["correct_params"] += 1
print(f"Función correcta: {stats['correct_function']}/{stats['total']}")
print(f"Parámetros correctos: {stats['correct_params']}/{stats['total']}")
return stats
Evaluación humana
La evaluación automatizada no lo capta todo. Un tono ligeramente condescendiente, una frase que no encaja bien con tus clientes, una respuesta técnicamente correcta pero inutilizable: estos defectos solo aparecen bajo la mirada humana. El protocolo es directo. Muestrea de veinte a cincuenta respuestas al azar, nunca los casos que ya hayas marcado como problemáticos, o solo estarás midiendo tu propio sesgo de selección. A continuación, define criterios claros y medibles y formalízalos en una rúbrica de puntuación estandarizada para que dos revisores juzguen lo mismo.
Por último, haz que varias personas evalúen y calcula el acuerdo entre evaluadores. Un fuerte desacuerdo no necesariamente señala un mal modelo: muy a menudo, revela que tu rúbrica sigue siendo ambigua y necesita aclaración antes de poder concluir nada.
Muestra de rúbrica de evaluación
| Criterio | 1 (Deficiente) | 3 (Aceptable) | 5 (Excelente) |
|---|---|---|---|
| Relevancia | Fuera de tema | Parcialmente relevante | Perfectamente orientada |
| Tono | Inapropiado | Aceptable pero plano | Perfectamente alineado |
| Formato | No seguido | Parcialmente seguido | Perfectamente seguido |
Informe de evaluación
Un último reflejo separa una evaluación de una decisión: registra ambas familias de resultados en un único informe, acompañado de una recomendación explícita. El umbral que establezcas (aquí una media humana de 4 para pasar a producción, 3 para iterar sobre los datos) debe elegirse antes de lanzar la campaña. Decidido después, siempre se ajusta al resultado que esperabas.
def evaluation_report(auto_results: dict, human_results: dict):
"""Genera un informe de evaluación combinado."""
print("=" * 60)
print("INFORME DE EVALUACIÓN DEL MODELO AJUSTADO")
print("=" * 60)
print(f"\nMétricas automatizadas:")
for k, v in auto_results.items():
print(f" {k}: {v}")
print(f"\nEvaluación humana:")
for k, v in human_results.items():
print(f" {k}: {v}")
print(f"\nRecomendación:")
average_score = sum(human_results.values()) / len(human_results)
if average_score >= 4:
print(" El modelo está listo para producción")
elif average_score >= 3:
print(" Se necesitan mejoras: itera sobre los datos")
else:
print(" Resultados insuficientes: replantea tu enfoque")
Puntos clave
- Separa siempre un conjunto de prueba independiente (ni entrenamiento ni validación)
- Combina evaluación automatizada y humana
- La evaluación con LLM como juez es un buen compromiso entre ambas
- Define criterios medibles antes de empezar
- Una puntuación de pérdida baja no garantiza calidad de producción