Modelos de decisión en lugar de LLM jueces: cómo ajustar umbrales sin arruinarte en evaluaciónArtículo · digest del 21 de octubre
Plano infográfico de calibración de un modelo de decisión sobre papel con un gráfico de la curva Precision-Recall y un umbral de corte en 0.80.
Artículo4 secciones≈ 6 min

Modelos de decisión en lugar de LLM jueces: cómo ajustar umbrales sin arruinarte en evaluación

Si alguna vez has construido un agente de IA autónomo, seguro que conoces el mayor dolor de cabeza en producción: ¿cómo saber si el bot no se acaba de liar al llamar a una API externa y le está soltando tonterías educadas al cliente? El enfoque estándar que recomiendan la mayoría de los tutoriales de moda parece directo: cogemos los registros de la conversación (trazas), los enviamos a un modelo insignia pesado como GPT-4o o Claude Opus con el prompt «Evalúa del 1 al 5 si hubo un error aquí» y cruzamos los dedos.

Pero hagamos cuentas. Cuando un agente ejecuta miles de sesiones al día, usar un LLM completo como «juez» (LLM-as-a-judge) para cada pequeño paso se convierte en un agujero financiero enorme. Además, añades una latencia de 3 a 5 segundos por cada consulta de verificación.

El ingeniero y especialista en evaluación Hamel Husain, junto con Antaripa Saha, publicaron un análisis detallado de una vía alternativa: usar modelos de decisión especializados. Son clasificadores compactos no generativos que no divagan sobre el sentido de la vida, sino que devuelven una probabilidad concreta de error. Ya habíamos tocado antes el tema del modelo no generativo Typesafe Jev, y ahora han salido datos frescos de un benchmark práctico sobre registros reales.

98 trazas de producción y batalla de clasificadores

Los autores del experimento tomaron un caso real: 98 trazas válidas de un agente complejo de búsqueda y reserva de alojamiento. En esta muestra había 61 fallos reales registrados (errores en argumentos de herramientas, fechas incorrectas, fallos de lógica) y 37 tareas completadas con éxito.

Pasaron esas trazas por cinco modelos de decisión actuales:

  • Perplexity Decider 1.1 (27B): marcó un récord de bajo coste —apenas $0.0082 por revisar las 100 sesiones— con un F1-score final de 0.79. Eso sí, su tiempo medio de respuesta fue notable: 7.85 segundos.
  • OpenAI Decisions (basado en GPT-6 Luna): logró la mayor precisión con un F1-score de 0.87, pero costó $0.0372 por cada 100 ejecuciones, 4.5 veces más caro que Perplexity.
  • Liquid d1 y d1-ultra: modelos ultrarrápidos con un coste bajísimo ($0.02 y $0.042 por millón de tokens) y un tiempo de respuesta de apenas 1.56 segundos.
  • Cloudflare Clef Flash y TypeSafe Jev 1.13: clasificadores ligeros sólidos con una estructuración estricta de respuestas.

La trampa del umbral estándar 0.50

El hallazgo principal del estudio es que la mayoría de los desarrolladores tiran dinero a la basura por una costumbre escolar. Al recibir del clasificador una probabilidad de error entre 0.0 y 1.0, los ingenieros ponen por defecto la regla: «Si la puntuación supera 0.50, disparamos la alerta».

Es un error fatal. Las puntuaciones en bruto de los modelos vienen sesgadas: unas arquitecturas subestiman sistemáticamente las notas y otras las inflan. Con el umbral en 0.50, el modelo Liquid d1 dejaba escapar más de la mitad de los fallos reales, mientras que Perplexity Decider lanzaba una lluvia de falsos positivos que obligaba al equipo de guardia a silenciar las alertas en Slack.

En un negocio real siempre te mueves entre Precision (precisión: si salta la alerta, de verdad hay un fallo) y Recall (exhaustividad: qué porcentaje de fallos reales hemos atrapado). Para que el sistema sea predecible, hay que calibrar matemáticamente el umbral de corte.

Buscando el umbral óptimo en Python

Así se calcula el umbral óptimo sobre puntuaciones históricas guardadas usando la librería scikit-learn. Fijamos un requisito de negocio estricto: precisión y exhaustividad mínimas del 80 %, y a partir de ahí maximizamos el F1-score:

import numpy as np
from sklearn.metrics import precision_recall_curve

def find_optimal_threshold(y_true, y_scores, min_precision=0.80, min_recall=0.80):
    """
    Búsqueda del umbral de corte que garantiza límites mínimos de precisión y exhaustividad.
    y_true: arreglo de etiquetas reales (1 - error, 0 - éxito)
    y_scores: arreglo de probabilidades del modelo de decisión
    """
    precisions, recalls, thresholds = precision_recall_curve(y_true, y_scores)
    best_threshold = 0.50
    best_f1 = 0.0

    for p, r, t in zip(precisions[:-1], recalls[:-1], thresholds):
        if p >= min_precision and r >= min_recall:
            # Calculamos la media armónica entre Precision y Recall
            f1 = 2 * (p * r) / (p + r) if (p + r) > 0 else 0.0
            if f1 > best_f1:
                best_f1 = f1
                best_threshold = float(t)

    return best_threshold, best_f1

Mover el umbral de 0.50 al óptimo calculado (por ejemplo, 0.38 en modelos con sesgo) sube al instante el F1-score entre 10 y 15 puntos sin reentrenar pesos ni tocar el prompt.

Calibración de probabilidades: el método de Platt

El segundo problema de los modelos en bruto es la distorsión de los valores absolutos. Si el modelo devuelve 0.90, no significa que en 90 de cada 100 casos haya realmente un error. Para alinear las probabilidades funciona muy bien el Platt scaling, que entrena una regresión logística sobre los logaritmos de las cuotas (log-odds):

from sklearn.linear_model import LogisticRegression

def calibrate_platt_scaling(train_scores, train_labels, test_scores):
    """
    Calibración de las salidas del clasificador mediante el método de Platt.
    Sirve para convertir puntuaciones en bruto en probabilidades estadísticas reales.
    """
    eps = 1e-6
    # Recortamos valores extremos para mantener la estabilidad del logaritmo
    clipped_train = np.clip(train_scores, eps, 1.0 - eps)
    log_odds_train = np.log(clipped_train / (1.0 - clipped_train)).reshape(-1, 1)

    calibrator = LogisticRegression(C=1.0, solver='lbfgs')
    calibrator.fit(log_odds_train, train_labels)

    clipped_test = np.clip(test_scores, eps, 1.0 - eps)
    log_odds_test = np.log(clipped_test / (1.0 - clipped_test)).reshape(-1, 1)
    
    # Devolvemos la probabilidad calibrada de la clase positiva
    return calibrator.predict_proba(log_odds_test)[:, 1]
Límites de la calibración en muestras pequeñas

El método de Platt mejora notablemente el Brier score en modelos con sesgo sistemático (Perplexity, Liquid d1), pero en conjuntos diminutos (menos de 50 ejemplos) existe riesgo de sobreajuste. Reserva siempre un conjunto de prueba aislado antes de ajustar los pesos del calibrador.

En resumen: deja de quemar LLM pesados para revisar de forma rutinaria cada paso de un agente. Combinar un modelo de decisión económico de fracciones de centavo con un umbral de disparo bien calculado ofrece la misma fiabilidad, ahorrando presupuesto y salud mental al equipo de soporte.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2