GuidesOneMux

É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.

AI

Résumé · TL;DR

Pour savoir si un fine-tuning Hugging Face a amélioré votre cas d’usage, comparez le modèle à sa version de base sur les mêmes exemples réservés à l’évaluation, avec les mêmes prompts et paramètres de génération. Choisissez des métriques adaptées à la tâche, conservez les résultats au niveau des exemples, répétez les exécutions si la génération est stochastique et documentez ce que l’évaluation ne permet pas d’établir.

Points clés

  • Partez du comportement que le fine-tuning doit améliorer, pas d’un classement.
  • Utilisez des exemples exclus de l’entraînement, couvrant les cas courants, les cas difficiles, les exigences de format et les risques de régression.
  • Gardez fixes les révisions des modèles, les prompts, les paramètres de décodage, l’environnement d’exécution et les règles de notation.
  • Présentez les échecs par exemple et les limites, en plus des métriques agrégées.
Sur cette page (7)

La comparaison utile oppose le modèle fine-tuné au modèle de base

Un score de modèle n’est informatif que s’il répond à une question précise. Si vous avez fine-tuné un modèle Hugging Face pour qu’il produise un JSON valide, mesurez le respect du schéma sur des entrées représentatives. Si vous l’avez adapté à la classification de tickets d’assistance, utilisez des tickets réservés à l’évaluation et une métrique de classification comme le F1. Un benchmark public général peut fournir un point de comparaison, mais il ne suffit pas à montrer que le changement a amélioré votre flux de travail.

La discussion du forum Hugging Face qui inspire cette méthode recommande de commencer par définir la capacité visée, puis de comparer les modèles de base et fine-tuné sur les mêmes exemples et avec les mêmes paramètres. Elle rappelle aussi qu’il faut examiner les résultats au niveau des exemples et que les petits jeux d’évaluation peuvent produire des scores instables. Source : discussion du forum Hugging Face sur le benchmarking.

1. Formulez la question d’évaluation

Avant de choisir les données ou une métrique, complétez cette phrase : « Le fine-tuning doit améliorer ___ sans dégrader ___. » Par exemple : « Il doit extraire les champs des factures de façon plus fiable sans augmenter le taux de JSON invalide. » Vous obtenez ainsi une métrique principale et un indicateur de régression.

Constituez un jeu réservé à l’évaluation à partir d’exemples qui n’ont pas servi au fine-tuning. Incluez quelques catégories clairement identifiées :

CatégorieCe qu’elle permet d’observer
Entrées courantesLes performances sur la charge de travail attendue
Entrées difficilesLes erreurs sur des exemples ambigus, longs ou désordonnés
Cas de formatLe respect de la structure requise
Cas de régressionLa dégradation éventuelle de comportements bien gérés par le modèle de base
Cas d’informations manquantesLa capacité du modèle à ne pas inventer de réponses non étayées

Un petit jeu soigneusement vérifié peut servir de premier contrôle, mais ne permet pas d’établir des performances générales. Notez la raison d’inclusion de chaque exemple et gardez le jeu de test à l’écart de l’entraînement et de la mise au point des prompts. Si vous optimisez de façon répétée sur les mêmes cas de test, ceux-ci finissent par faire partie du processus de développement.

2. Figez les conditions de comparaison

Exécutez le modèle de base et le modèle fine-tuné sur des exemples identiques. Consignez les identifiants et révisions exacts des modèles, le tokenizer et le modèle de conversation, le texte des prompts, le message système, les exemples few-shot, les paramètres de décodage, les versions des logiciels ainsi que le matériel ou le backend d’inférence. Pour les fine-tunings basés sur des adaptateurs, précisez si vous avez évalué le modèle de base, le modèle de base avec adaptateur, ou une version fusionnée ou quantifiée.

L’exemple ci-dessous est un modèle de configuration illustratif, et non un benchmark testé. Il suppose que les deux identifiants de modèle sont compatibles avec l’interface de modèle de langage causal de Transformers. Fixez les révisions à des hachages de commit disponibles dans vos dépôts de modèles : les noms seuls peuvent renvoyer à des artefacts qui évoluent.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "your-org/your-model"
revision = "replace-with-a-commit-hash"

# Use the same settings and prompts for both model variants.
tokenizer = AutoTokenizer.from_pretrained(model_id, revision=revision)
model = AutoModelForCausalLM.from_pretrained(model_id, revision=revision)

prompt = "Extract the invoice number and total as JSON: ..."
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)

Cet exemple fixe le décodage glouton et une limite de sortie, mais ne définit ni modèle de conversation universel, ni configuration de périphérique, ni évaluateur de tâche. Suivez le format d’entrée documenté pour le modèle. Si l’application visée utilise un modèle de conversation, du contexte de récupération, de la quantification ou un endpoint hébergé, testez cette configuration réelle et consignez-la. Ne partez pas du principe que tous les modèles ou endpoints de service acceptent les mêmes paramètres.

3. Adaptez la notation à la tâche

Utilisez des vérifications directes lorsque le comportement souhaité peut être vérifié objectivement. Pour les sorties structurées, indiquez séparément le taux de JSON valide, le taux de conformité au schéma et la précision au niveau des champs : une syntaxe valide ne garantit pas l’exactitude des valeurs. Pour la classification, indiquez la métrique choisie et la répartition des classes. Pour la génération de code, utilisez des tests adaptés à la tâche visée. Pour les réponses ouvertes, définissez une grille d’évaluation portant sur l’exactitude, l’exhaustivité, le respect des consignes et l’ancrage dans les sources, puis examinez un échantillon des jugements.

Les outils d’évaluation Hugging Face, tels que Evaluate ou Lighteval, peuvent aider à organiser les métriques ou les exécutions de benchmark, comme le mentionne la discussion du forum. Le choix d’un outil ne remplace pas la conception de la tâche : documentez le jeu de données, l’évaluateur, la version de l’outil et les prompts personnalisés éventuels. Considérez les évaluations automatisées ou produites par un modèle comme des éléments de preuve assortis de limites, et non comme la vérité terrain.

Enregistrez pour chaque exemple l’entrée, la réponse attendue ou la grille d’évaluation, les sorties des deux modèles, le score et une brève étiquette d’échec. Parmi les étiquettes utiles : réponse incorrecte, détail manquant, affirmation non étayée, format invalide, consigne ignorée et régression. Les moyennes peuvent masquer un échec grave concentré dans une catégorie.

4. Répétez les exécutions lorsque l’aléatoire compte

Avec un décodage déterministe et des entrées fixes, des exécutions répétées ne révèlent parfois pas grand-chose sur la variabilité de l’échantillonnage. Si la production utilise l’échantillonnage, exécutez plusieurs graines et indiquez les paramètres de décodage ainsi que la variation entre les exécutions. La discussion du forum suggère trois exécutions avec des graines différentes comme vérification pratique, notamment lorsque le jeu d’évaluation est petit ; il s’agit d’une heuristique, pas d’une garantie de signification statistique.

Indiquez le nombre d’exemples par catégorie et évitez de présenter un faible écart de score comme une amélioration avérée sans analyse de l’incertitude. Si un résultat varie fortement selon les exécutions ou les catégories, examinez-le avant de désigner un gagnant.

5. Précisez ce que l’évaluation ne peut pas prouver

Un résultat obtenu sur des données réservées étaye une affirmation portant sur les exemples et la configuration testés. Il ne prouve pas les performances auprès de tous les utilisateurs, dans tous les domaines, toutes les langues, tous les styles de prompt ou sur tous les backends de déploiement. Les scores de benchmarks publics reposent sur leurs propres distributions de tâches et règles de notation, qui peuvent ne pas correspondre à votre application. Si la récupération, les outils ou l’infrastructure de service font partie du produit, un test du modèle seul n’évalue pas ces composants.

Un rapport concis devrait inclure l’objectif de l’évaluation ; la source et la partition des données ; leur exclusion de l’entraînement ; les révisions du modèle et des adaptateurs ; les paramètres de prompt et de décodage ; la définition des métriques ; le nombre d’exemples ; les résultats par catégorie ; des échecs représentatifs ; et les limites connues. Les fiches de modèle Hugging Face peuvent servir à décrire les résultats et les limites de l’évaluation, mais la configuration doit rester compréhensible en langage courant.

Une règle de décision pratique

Ne privilégiez le fine-tuning que s’il améliore le comportement visé sur les cas réservés à l’évaluation, sans régressions inacceptables dans les catégories importantes. Conservez les sorties et la configuration afin qu’une autre personne puisse reproduire la comparaison. Le résultat n’est pas un classement universel des modèles : c’est un élément de preuve pour une tâche définie, dans une configuration documentée.

FAQ

Faut-il utiliser un benchmark public pour évaluer un fine-tuning Hugging Face ?

Utilisez-en un si sa tâche et sa méthode de notation correspondent à la capacité qui vous intéresse. Considérez-le comme un élément de contexte supplémentaire, et non comme un substitut à une évaluation sur des données réservées issues de votre cas d’usage.

La loss d’évaluation suffit-elle à montrer qu’un fine-tuning a amélioré le modèle ?

Non. La loss d’évaluation peut aider à suivre l’entraînement, mais elle ne permet pas d’établir directement que les réponses générées sont plus exactes, respectent le format requis ou évitent les régressions. Évaluez les sorties avec des contrôles adaptés à la tâche et examinez des exemples.

Quelle doit être la taille d’un jeu d’évaluation réservé ?

Il n’existe pas de minimum universel. Commencez par un jeu couvrant des cas représentatifs et des modes d’échec importants, indiquez sa taille et sa composition, et ne considérez pas les résultats d’un petit jeu comme définitifs.

Faut-il exécuter l’évaluation plusieurs fois ?

Si la génération est stochastique, répétez les exécutions avec des graines différentes et indiquez les paramètres ainsi que la variabilité. La publication du forum citée suggère trois exécutions comme vérification pratique, mais ce nombre ne garantit pas la signification statistique.

Articles liés