GuidesOneMux

Cómo crear una evaluación reproducible de Hugging Face para incidentes de API

Flujo práctico de evaluación con Hugging Face para comparar revisiones de modelos con prompts fijos, tareas representativas, señales observables de fallos de API y limitaciones claras.

AI

Resumen · TL;DR

Una evaluación útil debe distinguir entre un cambio en la calidad de las respuestas y un cambio en el comportamiento de la API. Esta guía explica cómo comparar revisiones de modelos de Hugging Face con tareas reservadas y pertinentes para incidentes, registrando parámetros fijos, resultados de las solicitudes y limitaciones.

Puntos clave

  • Crea un conjunto reservado basado en patrones reales de tareas, que incluya casos habituales, fallos conocidos, restricciones de formato y situaciones límite.
  • Compara el modelo base y el ajustado con el mismo prompt, las mismas revisiones de modelo, los mismos parámetros de decodificación y las mismas condiciones de servicio.
  • Registra los resultados observables de la API por separado de las puntuaciones de calidad de las respuestas para no confundir fallos de transporte con regresiones del modelo.
  • Informa de los fallos por ejemplo y de la incertidumbre; un conjunto de evaluación pequeño no permite demostrar una fiabilidad general.
En esta página (8)

La pregunta clave: ¿regresó el modelo o falló la API?

Cuando se produce un incidente de API después de cambiar un modelo, una única puntuación global no permite saber qué ocurrió. Un tiempo de espera agotado, una respuesta mal formada, una respuesta que no es JSON válido y una respuesta con datos incorrectos son fallos distintos y requieren soluciones diferentes. Una evaluación reproducible con Hugging Face debe registrar tanto el resultado de la solicitud como la calidad de cualquier respuesta recibida.

El flujo de trabajo siguiente es una evaluación local ilustrativa con Hugging Face Transformers. No se ha probado con un modelo concreto ni con una API alojada. Si evalúas una API, usa los mismos casos de prueba y registra los detalles de las solicitudes y respuestas específicos del proveedor cuando estén disponibles.

1. Define un conjunto pequeño y representativo del incidente

Empieza por la tarea que el sistema debe realizar desde la perspectiva del usuario, no por una clasificación general. Si la API responde preguntas a partir del contexto proporcionado, reúne ejemplos reservados que reflejen la distribución de tareas. Incluye:

  • Solicitudes habituales que deberían resolverse correctamente.
  • Casos relacionados con incidentes recientes o errores conocidos del modelo.
  • Comprobaciones de formato, como la presencia de campos JSON obligatorios.
  • Entradas largas, ambiguas, incompletas o sin contexto.
  • Casos en los que el comportamiento esperado sea indicar que no se conoce la respuesta.

Mantén los ejemplos de evaluación fuera de los datos de ajuste fino. Elimina secretos y datos personales, y documenta cómo se seleccionaron los ejemplos. Un conjunto pequeño y revisado cuidadosamente puede servir para diagnosticar problemas, pero no demuestra que el modelo sea fiable con todas las solicitudes de producción.

Esto coincide con las recomendaciones principales de un debate sobre benchmarking en Hugging Face: comparar modelos base y ajustados con un conjunto reservado, usar los mismos prompts y parámetros, elegir métricas adecuadas para la tarea y revisar los fallos individuales. Fuente: debate del foro de Hugging Face.

2. Fija las condiciones de comparación

Registra el modelo base y su revisión exactos, el modelo ajustado y su revisión, el tokenizador o la plantilla de chat, la versión del conjunto de evaluación, la plantilla del prompt y la configuración de ejecución. Fija parámetros de generación como temperature, top-p y la longitud máxima de salida. Si la aplicación incluye contexto de recuperación o ejemplos few-shot, mantenlos también idénticos.

Para que la evaluación sea reproducible, guarda el prompt renderizado real —no solo la plantilla— y la salida de cada ejemplo. Si el modelo usa un adaptador, indica si evaluaste solo el modelo base, el modelo base con el adaptador o un artefacto fusionado. Son configuraciones distintas.

Ejemplo ilustrativo con Transformers

Este ejemplo local supone dos modelos de lenguaje causal compatibles disponibles mediante Hugging Face Transformers. Sustituye los identificadores de modelo por las revisiones que quieras evaluar. En una ejecución real, fija las versiones de los paquetes y las revisiones de los modelos; main no es una revisión fija. El código es ilustrativo, no un resultado probado.

from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed

MODEL_ID = "org/model"
MODEL_REVISION = "<commit-or-tag>"
SEED = 17

set_seed(SEED)
tokenizer = AutoTokenizer.from_pretrained(
    MODEL_ID,
    revision=MODEL_REVISION,
)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    revision=MODEL_REVISION,
)
model.eval()

prompt = "Context: ...\nQuestion: ...\nAnswer:"
inputs = tokenizer(prompt, return_tensors="pt")

output = model.generate(
    **inputs,
    do_sample=False,
    max_new_tokens=128,
)
answer = tokenizer.decode(
    output[0][inputs["input_ids"].shape[1]:],
    skip_special_tokens=True,
)
print(answer)

Ejecuta el mismo arnés de evaluación con la versión de referencia y la revisión candidata. La decodificación greedy reduce la variación del muestreo, pero no elimina todas las fuentes de variación: el hardware, las bibliotecas, los kernels y las implementaciones de servicio pueden afectar los resultados. Si el endpoint de producción usa parámetros o un entorno de ejecución distintos, un resultado local no reproduce directamente el comportamiento de producción.

3. Registra las señales de fallo de la API por separado de la calidad de las respuestas

Para cada caso de prueba, guarda un identificador de solicitud, la marca de tiempo, la revisión del modelo, el prompt o una referencia al prompt que proteja la privacidad, los parámetros de generación, la latencia, el estado HTTP y si se recibió una respuesta. Registra señales observables de fallo, como tiempos de espera agotados, errores de conexión, respuestas de límite de solicitudes, errores del servidor, respuestas vacías, salidas truncadas o respuestas que no se pueden analizar. No clasifiques una respuesta ausente como una respuesta incorrecta: regístrala como una solicitud fallida o no disponible.

En las respuestas recibidas correctamente, evalúa los resultados de la tarea de manera independiente. Para las salidas JSON, comprueba que se puedan analizar, que cumplan el esquema, que incluyan los campos obligatorios y que sus valores sean correctos. Para las respuestas a preguntas, usa una clave de respuestas o una rúbrica, y revisa la veracidad y si la respuesta está respaldada por el contexto proporcionado. Conserva la salida sin procesar junto a su puntuación para que quien la revise más adelante pueda entender la etiqueta de fallo.

Un registro de resultados compacto podría incluir: ID del caso, revisión del modelo, resultado de la solicitud, latencia, salida, comprobaciones aprobadas o fallidas, etiqueta de error y nota de revisión. Evita registrar datos sensibles de producción en los artefactos de evaluación.

4. Interpreta los resultados como un diagnóstico, no como una sentencia

Compara los recuentos de fallos y las métricas de las tareas por segmento, no solo en el conjunto completo. Si la revisión candidata tiene más tiempos de espera agotados, pero una calidad de respuesta similar en las solicitudes completadas, investiga el servicio o el procesamiento de solicitudes antes de concluir que las respuestas del modelo han empeorado. Si las solicitudes se completan, pero disminuye la validez del esquema, revisa el formato del prompt, la revisión del modelo y las restricciones de salida. Si solo fallan los casos con mucho contexto, comprueba cómo se construye el contexto y cómo se truncan las entradas.

Los conjuntos pequeños son sensibles al ruido. Repite las ejecuciones cuando la generación o el servicio no sean deterministas e informa del número de ejemplos y ejecuciones. El debate del foro también recomienda repetir las ejecuciones en evaluaciones pequeñas, porque las diferencias reducidas en las puntuaciones pueden deberse al ruido. No presentes un cambio de dos puntos como concluyente sin pruebas suficientes que respalden esa interpretación.

Limitaciones que conviene comunicar

Indica qué aspectos no cubre el conjunto: tamaño, intervalo de fechas, distribución de tareas, casos límite excluidos y si los ejemplos se parecen al tráfico real de producción. Explica si la evaluación se hizo con Transformers local o con una API alojada, así como las diferencias en el entorno de ejecución o los parámetros. Una evaluación puede revelar fallos concretos, pero no garantizar el tiempo de actividad, la seguridad ni el rendimiento fuera de las condiciones probadas.

Conclusión

Para diagnosticar incidentes de API, procura que cada evaluación responda a dos preguntas: ¿se completó la solicitud y la respuesta obtenida fue adecuada para la tarea? Los ejemplos reservados, los parámetros fijos, los registros por caso y las limitaciones explícitas hacen que la comparación sea reproducible y ayudan a orientar la investigación hacia el modelo, el prompt o la ruta de la API.

FAQ

¿Conviene evaluar un modelo de Hugging Face con un benchmark público o con un conjunto de pruebas propio?

Empieza con un conjunto reservado que se ajuste a la tarea y a los incidentes que necesitas diagnosticar. Los benchmarks públicos pueden aportar contexto adicional, pero quizá no midan los prompts, los formatos o el dominio de tu aplicación.

¿Qué debo mantener fijo al comparar revisiones de modelos?

Mantén lo más constantes posible los ejemplos, el prompt renderizado, la plantilla de chat, los parámetros de decodificación, el contexto de recuperación, las revisiones del modelo y del adaptador, y las condiciones de ejecución. Registra cualquier elemento que no se pueda mantener constante.

¿Cómo distingo un fallo de API de un problema de calidad del modelo?

Registra los resultados de las solicitudes por separado de las comprobaciones de las respuestas. Los tiempos de espera agotados, los errores HTTP y las respuestas vacías son fallos de solicitud; las respuestas incorrectas o los formatos no válidos son fallos de calidad en respuestas que sí se completaron.

¿La decodificación greedy hace que una evaluación sea totalmente reproducible?

No. Reduce la variación del muestreo, pero las versiones de las bibliotecas, el hardware, los kernels y las implementaciones de servicio aún pueden influir. Registra el entorno y, al diagnosticar un incidente de producción, evalúa en condiciones similares a las de producción.

Artículos relacionados