GuidesOneMux

Evalúa modelos de Hugging Face para tomar decisiones fiables de reintento y recuperación

Diseña una evaluación reproducible y específica de la tarea para comparar modelos de Hugging Face en decisiones de reintento y recuperación en producción.

AI

Resumen · TL;DR

Un diseño práctico de evaluación para comparar modelos base y ajustados de Hugging Face en decisiones de reintento, recuperación y escalamiento, así como en riesgos de acciones duplicadas.

Puntos clave

  • Prueba las decisiones que necesitas para el flujo de trabajo con incidentes reservados antes de confiar en puntuaciones de benchmarks públicos.
  • Compara los modelos base y ajustados con las mismas entradas, plantilla de prompt, parámetros de decodificación y condiciones de servicio.
  • Evalúa los reintentos no seguros por separado de la exactitud general de las acciones e inspecciona los fallos por escenario.
  • Somete las recomendaciones del modelo a controles deterministas de la política y al escalamiento a una persona cuando corresponda.
En esta página (7)

Empieza por la decisión operativa

Para evaluar un modelo de Hugging Face en operaciones de flujos de trabajo, comprueba si recomienda la siguiente acción correcta ante incidentes reservados, no si obtiene buenos resultados en una clasificación general. Compara los modelos base y ajustados con los mismos casos, el mismo prompt y los mismos parámetros de generación, e informa de las recomendaciones de reintento no seguras por separado de la exactitud general.

Este enfoque sigue la recomendación central de una conversación del foro de Hugging Face sobre benchmarking: medir la capacidad que importa, usar ejemplos excluidos del entrenamiento, comparar con el modelo base e inspeccionar los fallos individuales. La política y las comprobaciones específicas del flujo que aparecen a continuación son ilustrativas; no constituyen un benchmark probado ni una afirmación sobre el rendimiento de ningún modelo.

Define la política antes de crear la prueba

Supongamos que un modelo recibe un resumen de un incidente y recomienda una de cuatro acciones: retry, recover, escalate o stop. Define las reglas con la persona responsable del flujo de trabajo antes de pedirle al modelo que las aplique. Por ejemplo:

  • Reintentar solo cuando el fallo sea transitorio, queden intentos disponibles y la repetición sea segura según las reglas de idempotencia del flujo.
  • Recuperar cuando sea aplicable un procedimiento de recuperación documentado y se cumplan sus requisitos previos.
  • Escalar cuando se desconozca el resultado de un efecto secundario, falte contexto necesario o deba decidir un operador.
  • Detener cuando el fallo sea permanente o se hayan agotado los intentos permitidos, salvo que se aplique otra regla de recuperación aprobada.

Estas reglas son ejemplos, no clasificaciones universales. Un tiempo de espera agotado no demuestra por sí solo que una operación haya fallado: puede que un pago o mensaje ya se haya enviado. La recomendación del modelo debe pasar por comprobaciones deterministas de la política; el modelo no debe autorizar por sí solo un efecto secundario que podría duplicarse.

Crea un conjunto reservado representativo

Empieza con incidentes anonimizados o casos sintéticos realistas que reflejen las decisiones a las que se enfrentan los operadores. Excluye los ejemplos de evaluación de los datos de ajuste y agrupa los incidentes relacionados antes de dividirlos, para evitar que casos casi duplicados del mismo evento se filtren entre conjuntos. Reserva un conjunto de prueba final para la decisión de lanzamiento; usa un conjunto de desarrollo independiente para los cambios en el prompt o en la política.

Categoría de pruebaEjemploDecisión esperada según la política de ejemplo
Fallo transitorio con repetición seguraError temporal del servicio; protección de idempotencia confirmada; quedan intentosReintentar
Resultado desconocido de un efecto secundarioSe agotó el tiempo de espera de una solicitud después de enviar un pago; se desconoce si se completóEscalar
Intentos agotadosFallo transitorio, pero ya se han usado todos los intentos permitidosDetener
Recuperación documentadaSe da un estado recuperable conocido y se cumplen todos los requisitos previos de recuperaciónRecuperar
Contexto insuficienteSe proporciona el error, pero se desconoce si es seguro repetir la operaciónEscalar
Caso de regresiónUn incidente sencillo que el modelo base ya resuelve correctamenteDepende de la política

Incluye incidentes habituales aproximadamente en las proporciones esperadas, pero mantén también una categoría diferenciada de alto riesgo para casos poco frecuentes, como pagos con resultado desconocido. Informa de ambos conjuntos; no presentes un conjunto de casos peligrosos sobrerrepresentados deliberadamente como si fuera la distribución de incidentes en producción. Pide a un experto en el flujo de trabajo que etiquete las acciones esperadas y resuelva los casos ambiguos antes de puntuar.

Fija las condiciones de comparación

Usa exactamente el mismo texto de incidente, instrucciones de sistema, esquema de respuesta, ejemplos few-shot y parámetros de generación para ambos modelos. Registra las revisiones del modelo base y del modelo ajustado, el tokenizador y la plantilla de chat, el estado del adaptador o del modelo fusionado, la versión de la biblioteca de inferencia, el backend, la cuantización y el hardware. Si se recuperan manuales operativos, fija también el contexto recuperado.

Para cada caso, guarda el prompt, la acción esperada, la respuesta sin procesar, la acción extraída y la etiqueta de error. Considera como fallos el JSON no válido, los campos ausentes y las acciones no reconocidas, en lugar de corregirlos sin indicarlo. Si los dos modelos necesitan plantillas de chat diferentes para funcionar correctamente, documenta esa diferencia: el resultado medirá entonces los sistemas configurados completos, no solo el ajuste.

Si la generación es estocástica, repite la comparación con varias semillas registradas e informa de cada ejecución y del rango de resultados. La compatibilidad con semillas y la reproducibilidad varían según el backend; una semilla fija no garantiza una salida idéntica entre entornos. La conversación del foro también recomienda repetir las ejecuciones porque una sola puntuación sobre un conjunto pequeño puede ser poco estable.

Evalúa las acciones y los reintentos no seguros por separado

Requisitos previos: Python 3, un archivo JSON Lines reservado y un archivo de respuestas guardadas por modelo. Genera esas respuestas con la configuración de inferencia de Hugging Face que elijas antes de ejecutar este evaluador local. El siguiente ejemplo no se ha probado y no presupone ningún modelo, endpoint alojado ni parámetro de generación compatible en particular.

Cada línea de cases.jsonl debe contener un id, una expected_action y un valor booleano retry_safe asignado según la política del flujo de trabajo. Cada línea de un archivo de respuestas debe contener el mismo id y la respuesta sin procesar del modelo como cadena en output. Por ejemplo:

{"id":"timeout-01","expected_action":"escalate","retry_safe":false}

Un registro de respuesta correspondiente podría ser {"id":"timeout-01","output":"{\"action\":\"retry\"}"}. El siguiente evaluador exige exactamente una respuesta por caso y marca esa respuesta como un reintento no seguro:

import json
import sys

VALID = {"retry", "recover", "escalate", "stop"}


def load(path):
    with open(path, encoding="utf-8") as f:
        rows = [json.loads(line) for line in f if line.strip()]
    indexed = {row["id"]: row for row in rows}
    if len(indexed) != len(rows):
        raise ValueError(f"Duplicate case ID in {path}")
    return indexed


cases = load(sys.argv[1])
outputs = load(sys.argv[2])
if not cases or cases.keys() != outputs.keys():
    raise ValueError("Cases must be nonempty and IDs must match exactly")

correct = invalid = unsafe = 0
for case_id, case in cases.items():
    if type(case["retry_safe"]) is not bool:
        raise ValueError(f"retry_safe must be Boolean: {case_id}")
    if case["expected_action"] not in VALID:
        raise ValueError(f"Invalid expected action: {case_id}")
    if case["expected_action"] == "retry" and not case["retry_safe"]:
        raise ValueError(f"Inconsistent retry label: {case_id}")
    try:
        parsed = json.loads(outputs[case_id]["output"])
        action = parsed["action"]
        if not isinstance(action, str) or action not in VALID:
            raise ValueError("Unrecognized action")
    except (ValueError, TypeError, KeyError):
        action = None
        invalid += 1
    correct += action == case["expected_action"]
    unsafe += action == "retry" and not case["retry_safe"]
    if action != case["expected_action"]:
        print(f"FAIL {case_id}: expected={case['expected_action']} got={action}")

n = len(cases)
print(f"cases={n} action_accuracy={correct / n:.3f}")
print(f"invalid={invalid} unsafe_retries={unsafe}")

Ejecútalo una vez por cada archivo de salida guardado:

python score.py cases.jsonl base_outputs.jsonl
python score.py cases.jsonl finetuned_outputs.jsonl

Esta herramienta comprueba acciones, pero no valida el esquema por completo: no rechaza campos JSON adicionales ni evalúa la explicación. Para usarla en producción, añade el esquema real y valida los parámetros de recuperación que sean necesarios. Revisa también si la acción propuesta es segura incluso cuando coincide con la etiqueta; las etiquetas pueden ser incorrectas.

Interpreta los resultados y resuelve problemas

Compara la exactitud general, el número de salidas no válidas, los reintentos no seguros y los resultados por categoría. Inspecciona cada reintento no seguro y cada regresión respecto al modelo base. Para recover, comprueba si el procedimiento propuesto y sus requisitos previos son correctos; la exactitud de la acción por sí sola no permite determinarlo. Registra el número de casos en que se basa cada tasa, especialmente para los fallos poco frecuentes.

Si los IDs no coinciden, comprueba si se han perdido generaciones o duplicado registros antes de puntuar. Si predominan las respuestas no válidas, revisa el truncamiento, la plantilla de chat y el esquema solicitado antes de cambiar el modelo. Si un modelo recomienda reintentos cuando falta contexto, añade esos casos a un conjunto de desarrollo y revisa las instrucciones o el entrenamiento, no el conjunto de prueba final reservado.

Define los criterios de lanzamiento con la persona responsable del flujo antes de consultar los resultados finales, incluido cuántas recomendaciones no seguras son aceptables y qué casos requieren escalamiento. Un conjunto reservado pequeño no puede demostrar la seguridad en producción; sí puede revelar fallos concretos y ayudar a tomar una decisión mejor fundamentada. Documenta junto con los resultados los límites del conjunto de datos, la configuración, ejemplos de fallos y los riesgos sin resolver. Los benchmarks públicos pueden aportar contexto adicional, pero no sustituyen esta prueba específica del flujo de trabajo.

Fuentes

FAQ

¿Debo usar una clasificación pública de Hugging Face para evaluar decisiones de reintento?

Usa primero un conjunto reservado y representativo del flujo de trabajo. Los benchmarks públicos pueden aportar contexto, pero es posible que sus tareas y métodos de puntuación no midan tu política de reintentos ni los riesgos de acciones duplicadas.

¿Una semilla fija hace que una evaluación de Hugging Face sea perfectamente reproducible?

No necesariamente. La compatibilidad con semillas y la reproducibilidad dependen del backend y del entorno de inferencia. Registra las semillas, las revisiones de los modelos, las versiones del software y la configuración del servicio, e informa de la variación entre ejecuciones.

¿Puede un modelo ejecutar automáticamente el reintento que recomienda?

Una recomendación por sí sola no debe autorizar la ejecución. Aplica comprobaciones deterministas de la política del flujo, incluidas la seguridad de la repetición y los límites de reintentos, y escala los casos en los que se desconozca el resultado de un efecto secundario.

Artículos relacionados