Évaluer Hugging Face de façon reproductible pour diagnostiquer les incidents d’API
Un workflow pratique d’évaluation Hugging Face pour comparer des versions de modèles avec des prompts fixes, des tâches représentatives, des signaux observables de défaillance de l’API et des limites clairement exposées.
Résumé · TL;DR
Une évaluation utile doit distinguer une baisse de la qualité des réponses d’un changement du comportement de l’API. Ce guide explique comment comparer des versions de modèles Hugging Face sur des tâches réservées et pertinentes pour les incidents, tout en consignant les paramètres fixes, les résultats des requêtes et les limites.
Points clés
- Constituez un jeu réservé à partir de tâches réelles, comprenant des cas courants, des défaillances connues, des contraintes de format et des cas limites.
- Comparez le modèle de base et le modèle affiné avec le même prompt, les mêmes versions de modèles, les mêmes paramètres de décodage et les mêmes conditions de service.
- Consignez séparément les résultats observables de l’API et les scores de qualité des réponses afin de ne pas confondre les échecs de transport avec les régressions du modèle.
- Présentez les échecs par exemple et l’incertitude ; un petit jeu d’évaluation ne permet pas d’établir une fiabilité générale.
Sur cette page (8)
La question à trancher : le modèle a-t-il régressé ou l’API a-t-elle échoué ?
Lorsqu’un incident d’API survient après une modification du modèle, un score agrégé unique ne suffit pas à expliquer ce qui s’est passé. Un dépassement de délai, une réponse mal formée, une réponse JSON invalide et une réponse factuellement erronée sont des défaillances différentes, qui appellent des solutions différentes. Une évaluation Hugging Face reproductible doit consigner à la fois le résultat de la requête et la qualité de toute réponse renvoyée.
Le workflow ci-dessous présente une évaluation locale illustrative avec Hugging Face Transformers. Il n’a pas été testé avec un modèle ou une API hébergée en particulier. Si vous évaluez une API, utilisez les mêmes cas de test et consignez, lorsque c’est possible, les détails des requêtes et réponses propres au fournisseur.
1. Définir un petit jeu représentatif des incidents
Partez de la tâche visible par l’utilisateur que le système est censé accomplir, et non d’un classement général. Pour une API qui répond à des questions à partir du contexte fourni, rassemblez des exemples réservés issus de la distribution des tâches. Incluez :
- Des requêtes typiques auxquelles le système devrait répondre correctement.
- Des cas liés à des incidents récents ou à des erreurs connues du modèle.
- Des vérifications de format, par exemple la présence de champs JSON obligatoires.
- Des entrées longues, ambiguës, incomplètes ou dépourvues de contexte.
- Des cas où le comportement attendu consiste à indiquer que la réponse est inconnue.
Excluez les exemples d’évaluation des données de fine-tuning. Supprimez les secrets et les informations personnelles, et documentez la méthode de sélection des exemples. Un petit jeu soigneusement examiné peut être utile au diagnostic, mais ne prouve pas la fiabilité du modèle pour toutes les requêtes en production.
Cette démarche reprend les conseils essentiels d’une discussion sur le benchmarking sur le forum Hugging Face : comparer les modèles de base et affinés sur un jeu réservé, utiliser les mêmes prompts et paramètres, choisir des métriques adaptées à la tâche et examiner les échecs individuellement. Source : discussion sur le forum Hugging Face.
2. Fixer les conditions de comparaison
Consignez le modèle de base et sa version exacts, le modèle affiné et sa version, le tokenizer ou le modèle de chat, la version du jeu d’évaluation, le modèle de prompt et la configuration d’exécution. Fixez les paramètres de génération, comme la température, top-p et la longueur maximale de sortie. Veillez également à utiliser le même contexte de récupération et les mêmes exemples few-shot s’ils font partie de l’application.
Pour garantir la reproductibilité, enregistrez le prompt effectivement rendu, et pas seulement son modèle, ainsi que la sortie de chaque exemple. Si le modèle utilise un adaptateur, précisez si l’évaluation porte sur le modèle de base seul, sur le modèle de base avec adaptateur ou sur un artefact fusionné. Il s’agit de configurations distinctes.
Exemple de configuration avec Transformers
Cet exemple local suppose deux modèles de langage causal compatibles, accessibles via Hugging Face Transformers. Remplacez les identifiants des modèles par les versions que vous souhaitez évaluer. Pour une exécution réelle, verrouillez les versions des paquets et des modèles ; main ne correspond pas à une version fixe. Le code est fourni à titre illustratif et ne constitue pas un résultat testé.
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)
Exécutez le même harnais sur la version de référence et sur la version candidate. Le décodage glouton réduit les variations dues à l’échantillonnage, mais ne supprime pas toutes les sources de variation : le matériel, les bibliothèques, les kernels et les implémentations de service peuvent influer sur les résultats. Si votre endpoint de production utilise d’autres paramètres ou un autre environnement d’exécution, un résultat local ne reproduit pas directement le comportement en production.
3. Consigner séparément les signaux de défaillance de l’API et la qualité des réponses
Pour chaque cas de test, enregistrez un identifiant de requête, un horodatage, la version du modèle, le prompt ou une référence au prompt respectueuse de la confidentialité, les paramètres de génération, la latence, le statut HTTP et la réception ou non d’une réponse. Consignez les signaux de défaillance observables, comme les dépassements de délai, les erreurs de connexion, les réponses de limitation de débit, les erreurs serveur, les réponses vides, les sorties tronquées ou les réponses impossibles à analyser. Ne considérez pas une réponse manquante comme une réponse erronée : classez-la comme une requête indisponible ou échouée.
Pour les réponses reçues, évaluez séparément les résultats par rapport à la tâche. Pour une sortie JSON, vérifiez qu’elle peut être analysée, qu’elle respecte le schéma, qu’elle contient les champs obligatoires et que les valeurs de ces champs sont correctes. Pour les questions-réponses, utilisez un corrigé ou une grille d’évaluation, puis examinez l’exactitude factuelle et la conformité de la réponse au contexte fourni. Conservez la sortie brute avec son score afin qu’une personne chargée d’une vérification ultérieure puisse comprendre l’étiquette d’échec.
Un enregistrement de résultat concis peut inclure : l’ID du cas, la version du modèle, le résultat de la requête, la latence, la sortie, les vérifications réussies ou échouées, l’étiquette d’erreur et une note de révision. Évitez de consigner des données de production sensibles dans un artefact d’évaluation.
4. Interpréter les résultats comme un diagnostic, pas comme un verdict
Comparez les nombres d’échecs et les métriques de la tâche par catégorie, et pas seulement sur l’ensemble du jeu. Si la version candidate présente davantage de dépassements de délai, mais une qualité de réponse similaire pour les requêtes terminées, examinez le service ou le traitement des requêtes avant de conclure à une régression des réponses. Si les requêtes aboutissent, mais que la validité du schéma diminue, examinez le format du prompt, la version du modèle et les contraintes de sortie. Si seuls les cas à contexte long échouent, vérifiez la construction du contexte et le comportement de troncature.
Les petits jeux produisent des résultats variables. Répétez les exécutions lorsque la génération ou le service n’est pas déterministe, et indiquez le nombre d’exemples et d’exécutions. La discussion sur le forum recommande également de répéter les exécutions pour les petites évaluations, car de faibles écarts de score peuvent relever du bruit. Ne présentez pas une variation de deux points comme décisive sans éléments suffisants pour étayer cette interprétation.
Limites à publier
Précisez ce que le jeu ne couvre pas : sa taille, sa période, la distribution des tâches, les cas limites exclus et la représentativité des exemples par rapport au trafic réel en production. Indiquez si l’évaluation a utilisé Transformers en local ou une API hébergée, ainsi que les différences éventuelles d’environnement d’exécution ou de paramètres. Une évaluation peut révéler des défaillances précises ; elle ne garantit ni la disponibilité, ni la sécurité, ni les performances en dehors des conditions testées.
Conclusion
Pour diagnostiquer un incident d’API, chaque évaluation doit répondre à deux questions : la requête a-t-elle abouti, et la réponse renvoyée était-elle adaptée à la tâche ? Des exemples réservés, des paramètres fixes, des enregistrements par cas et des limites explicites rendent la comparaison reproductible et aident à orienter l’enquête vers le modèle, le prompt ou le chemin de l’API.
FAQ
Dois-je évaluer un modèle Hugging Face à l’aide d’un benchmark public ou de mon propre jeu de test ?
Commencez par un jeu réservé qui correspond à la tâche et aux incidents que vous devez diagnostiquer. Les benchmarks publics peuvent apporter un contexte supplémentaire, mais ils ne mesurent pas forcément les prompts, les formats ou le domaine de votre application.
Quels éléments dois-je garder fixes lorsque je compare des versions de modèles ?
Dans la mesure du possible, conservez les mêmes exemples, le même prompt rendu, le même modèle de chat, les mêmes paramètres de décodage, le même contexte de récupération, les mêmes versions du modèle et de l’adaptateur, ainsi que les mêmes conditions d’exécution. Consignez tout élément qui ne peut pas rester constant.
Comment distinguer une défaillance de l’API d’un problème de qualité du modèle ?
Consignez les résultats des requêtes séparément des vérifications des réponses. Les dépassements de délai, les erreurs HTTP et les réponses vides sont des échecs de requête ; les réponses incorrectes ou les formats invalides sont des problèmes de qualité sur les réponses effectivement reçues.
Le décodage glouton rend-il une évaluation entièrement reproductible ?
Non. Il réduit les variations dues à l’échantillonnage, mais les versions des bibliothèques, le matériel, les kernels et les implémentations de service peuvent aussi avoir un effet. Consignez l’environnement et, pour diagnostiquer un incident de production, évaluez dans des conditions proches de la production.
Articles liés
Guides
Comment évaluer un modèle Hugging Face en tenant compte de la confidentialité
Créez un jeu d’évaluation réservé pour comparer un modèle de base Hugging Face et sa version affinée, avec des paramètres fixes et des protections pour les données utilisateur et les identifiants.
Guides
Évaluer les modèles Hugging Face pour une extraction JSON fiable
Un plan d’évaluation pratique et reproductible pour comparer des modèles Hugging Face de base et ajustés sur une tâche d’extraction structurée, avec vérification du schéma, notation par champ, paramètres de génération fixes et limites documentées.
Guides
Évaluer un modèle Hugging Face de façon reproductible : tâches, paramètres et limites
Un protocole pratique pour comparer un modèle Hugging Face de base à une version fine-tunée à l’aide d’exemples réservés à l’évaluation, de paramètres de génération fixes, de métriques adaptées à la tâche et de limites documentées.
Guides
Comment évaluer de manière reproductible les modèles Hugging Face sur des modifications de code de dépôt
Mettez en place une évaluation reproductible des modèles de code Hugging Face : tâches de dépôt tenues à l’écart, paramètres de génération fixes, tests exécutés en isolation et limites clairement documentées.