GuidesOneMux

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

AI

Résumé · TL;DR

Pour déterminer si un ajustement fin Hugging Face améliore l’extraction structurée, comparez le modèle ajusté à son modèle de base sur les mêmes exemples tenus à l’écart de l’entraînement, avec des prompts et des paramètres de génération identiques. Évaluez séparément la possibilité d’analyser le JSON, la validité du schéma et l’exactitude des champs, examinez les échecs et publiez suffisamment de détails de configuration pour permettre à d’autres de reproduire l’évaluation.

Points clés

  • Utilisez des exemples tenus à l’écart qui n’ont pas servi à l’ajustement fin.
  • Évaluez les révisions du modèle de base et du modèle ajusté avec le même prompt, le même modèle de conversation, les mêmes paramètres de décodage et le même chemin d’inférence.
  • Distinguez le JSON valide, la conformité au schéma et l’exactitude sémantique des champs dans des métriques séparées.
  • Incluez des exemples ordinaires, difficiles, mal formés, ambigus et ne contenant pas l’information attendue.
  • Présentez les échecs au niveau des exemples et les limites de l’évaluation ; un petit jeu d’évaluation ne suffit pas à démontrer une fiabilité générale.
Sur cette page (8)

La question à laquelle répond l’évaluation

Un modèle d’extraction structurée peut produire un JSON syntaxiquement valide tout en extrayant une valeur erronée. Il peut aussi identifier la bonne valeur, mais omettre une clé obligatoire ou ajouter un champ non étayé. Une évaluation utile répond donc à trois questions distinctes : La sortie peut-elle être analysée ? Respecte-t-elle le schéma ? Les valeurs extraites sont-elles correctes ?

Pour un modèle de base Hugging Face et sa version ajustée, répondez à ces questions à partir des mêmes entrées tenues à l’écart, avec le même prompt et les mêmes paramètres de génération. Vous vérifierez ainsi si l’ajustement fin a amélioré la tâche d’extraction, et non s’il a progressé dans un classement sans rapport avec celle-ci.

Cette approche reprend la distinction faite dans une discussion Hugging Face Community entre l’évaluation propre à une tâche et les benchmarks publics : les scores publics peuvent donner un point de repère, mais un jeu tenu à l’écart et adapté à la tâche visée constitue un test plus direct. La discussion recommande également d’enregistrer les sorties, de comparer équitablement les modèles de base et ajusté, et d’examiner les échecs individuels. Source : Hugging Face Community, « What’s your method for benchmarking? »

1. Définir le contrat d’extraction

Avant de constituer les exemples, définissez ce que le modèle doit extraire, ce qui est considéré comme absent et ce qu’il doit faire lorsque la source ne contient pas la réponse. Décidez si les clés supplémentaires sont interdites et si les valeurs vides, null ou une valeur d’abstention explicite servent à représenter une information manquante.

Par exemple, une tâche portant sur des factures peut exiger le nom du fournisseur, la date de facture et le montant total. Le contrat d’évaluation doit préciser si les dates doivent respecter le format ISO, comment représenter la devise et si une date manquante doit être indiquée par null plutôt que devinée. Ces choix ont une incidence sur la conception du schéma et la notation ; ils ne doivent pas être laissés à l’appréciation de la personne qui évalue.

Utilisez un JSON Schema comme contrat vérifiable par machine. Le schéma ci-dessous est illustratif et ne constitue pas une configuration testée pour un modèle Hugging Face ou un point de terminaison de service particulier :

{
  "type": "object",
  "properties": {
    "supplier": {"type": ["string", "null"]},
    "invoice_date": {
      "type": ["string", "null"],
      "format": "date"
    },
    "total": {"type": ["number", "null"]},
    "currency": {"type": ["string", "null"]}
  },
  "required": ["supplier", "invoice_date", "total", "currency"],
  "additionalProperties": false
}

Un validateur de schéma peut vérifier la structure, les types, les clés obligatoires et les propriétés supplémentaires. Il ne peut pas établir qu’une valeur est étayée par le document source. Pour cela, il faut des valeurs attendues étiquetées et des règles de comparaison propres à la tâche.

2. Constituer un jeu tenu à l’écart qui reflète les entrées réelles

Séparez les exemples d’évaluation des données d’ajustement fin. Si un modèle a déjà vu un exemple pendant l’entraînement, une réponse correcte peut relever de la mémorisation plutôt que de la généralisation. Un jeu restreint peut servir à une première vérification, à condition que ses exemples et son objectif soient clairement définis ; ne le présentez pas comme une preuve de performance sur l’ensemble des documents.

Incluez des exemples issus de plusieurs catégories :

  • Entrées courantes : documents représentatifs contenant des valeurs clairement indiquées.
  • Cas difficiles : mises en page inhabituelles, entrées longues, bruit OCR ou valeurs exprimées dans des formats inattendus.
  • Informations manquantes : champs réellement absents de la source, pour vérifier que le modèle ne devine pas.
  • Ambiguïtés : valeurs contradictoires ou références peu claires, avec un comportement attendu défini à l’avance.
  • Cas de régression : exemples que le modèle de base traite déjà correctement, afin de repérer les régressions dues à l’ajustement fin.
  • Cas de résistance au format : entrées susceptibles de provoquer des commentaires, des délimiteurs Markdown, des clés manquantes ou des propriétés supplémentaires.

Pour chaque exemple, conservez l’entrée source, la sortie attendue et les éventuelles règles de normalisation. Définissez ces règles avant la notation. Par exemple, si 1,250.00 et 1250 sont des totaux équivalents, normalisez les valeurs numériques de façon cohérente ; ne modifiez pas la règle après avoir constaté quel modèle en tire avantage.

3. Fixer la configuration d’évaluation Hugging Face

Consignez l’identifiant exact et la révision de chacun des deux modèles : le modèle de base et le modèle ajusté. Si l’ajustement fin utilise un adaptateur, indiquez la révision de celui-ci et précisez si l’évaluation charge le modèle de base avec l’adaptateur, un modèle fusionné ou un autre artefact. La discussion Hugging Face souligne que les adaptateurs, les poids fusionnés, la quantification et les chemins de service peuvent se comporter différemment ; l’artefact évalué est donc important.

Dans la mesure du possible, gardez ces paramètres identiques pour les deux modèles :

  • le message système, le modèle de prompt et le modèle de conversation ;
  • les exemples d’entrée, leur ordre et les éventuelles démonstrations few-shot ;
  • les paramètres de décodage, notamment la température, top-p et le nombre maximal de nouveaux tokens ;
  • le backend d’inférence, la quantification et la gestion pertinente du contexte.

Pour comparer les résultats d’une tâche d’extraction de manière reproductible, un décodage déterministe constitue un point de départ raisonnable, si le modèle et le backend choisis le prennent en charge. Consignez les valeurs réelles des paramètres au lieu de supposer que tous les points de terminaison appliquent toutes les options. Si un point de terminaison ne documente pas la prise en charge d’un paramètre, indiquez que ce point est inconnu et ne prétendez pas que les exécutions étaient identiques sur ce paramètre.

Formulez clairement l’instruction du prompt : ne renvoyer que l’objet JSON demandé, respecter la convention du schéma pour les valeurs manquantes et ne pas déduire de valeurs absentes de l’entrée. Cela ne garantit pas la conformité ; c’est précisément ce que l’évaluation mesure.

4. Évaluer séparément la validité et l’exactitude

Indiquez les nombres bruts ainsi que les pourcentages, surtout pour les petits jeux de données. Une grille d’évaluation utile peut prendre la forme suivante :

MesureCe qu’elle vérifieCe qu’elle ne prouve pas
Taux de JSON analysableLa sortie peut être décodée comme JSONLes clés ou les valeurs sont correctes
Taux de conformité au schémaLa sortie analysée respecte le schéma choisiLes valeurs correspondent à la source
Présence des champs obligatoiresLes clés requises sont présentesLes valeurs sont exactes
Correspondance exacte par champChaque champ correspond à sa valeur étiquetée après la normalisation déclaréeLa généralisation au-delà du jeu d’évaluation
Correspondance exacte par enregistrementTous les champs évalués d’un enregistrement sont correctsLa robustesse face à des formats inédits

Pour chaque mesure, indiquez le numérateur et le dénominateur — par exemple, « 18 sorties sur 20 ont passé la validation du schéma » — ainsi que le pourcentage. Précisez comment vous traitez les sorties entourées de texte ou de délimiteurs Markdown. Une règle cohérente consiste à noter d’abord la réponse brute : si la tâche exige une sortie JSON uniquement, tout texte supplémentaire constitue un échec de format. Évitez de réparer silencieusement les sorties du modèle, sauf si cette réparation fait partie du flux de production réel ; si vous évaluez une étape de réparation, présentez ses résultats séparément.

5. Examiner les échecs, pas seulement les scores agrégés

Enregistrez chaque entrée, la sortie de référence, la sortie brute du modèle de base, la sortie brute du modèle ajusté, le résultat de la validation et les scores par champ. Attribuez une courte étiquette d’erreur, telle que JSON invalide, clé manquante, valeur erronée, inférence non étayée, propriété supplémentaire ou abstention incorrecte. Examinez ensuite les exemples où le modèle ajusté s’est amélioré et ceux où il a régressé.

Une hausse de la conformité au schéma peut masquer une baisse de l’exactitude de l’extraction. À l’inverse, un modèle peut extraire davantage de champs correctement tout en produisant parfois un JSON mal formé. Gardez ces mesures distinctes afin que l’équipe puisse déterminer quelle erreur compte le plus dans son flux de travail.

Avec un petit jeu, quelques exemples peuvent fortement faire varier le pourcentage. Indiquez la taille de l’échantillon et évitez de considérer comme concluante une faible différence de score. Dans une réponse ultérieure, la discussion fournie recommande plusieurs exécutions avec différentes graines, car les scores d’un petit jeu peuvent varier ; la pertinence de cette recommandation dépend du comportement d’échantillonnage du modèle et de votre configuration d’inférence. Si les sorties sont déterministes, répéter les mêmes exécutions peut simplement reproduire les mêmes résultats, sans apporter d’éléments indépendants.

6. Publier une note de reproductibilité et les limites

Un rapport utile indique la source et la partition du jeu de données, le nombre d’exemples, leur exclusion de l’entraînement, les révisions du modèle et de l’adaptateur, le prompt et le modèle de conversation, les paramètres de génération, le chemin d’inférence, le validateur et les règles de notation, ainsi que des exemples représentatifs d’échec. Signalez les paramètres qu’il n’a pas été possible de confirmer ou de maintenir constants.

Formulez votre conclusion avec précision : « Dans ce test, la révision ajustée a passé la validation du schéma sur 18 des 20 exemples tenus à l’écart » est une affirmation étayée. « Le modèle extrait les factures de façon fiable » dépasse ce qu’une évaluation restreinte peut établir. Les benchmarks publics peuvent constituer un second niveau d’évaluation s’ils correspondent à l’objectif, mais ils ne remplacent pas les tests portant sur le contrat d’extraction réel.

Conclusion

Pour l’extraction JSON avec Hugging Face, faites de l’évaluation une comparaison reproductible, et non une démonstration : mettez de côté des exemples représentatifs, fixez et consignez la configuration, validez la structure, évaluez les valeurs des champs et examinez les échecs. Présentez les limites du jeu de données et de la configuration d’inférence avec les résultats. Les lecteurs pourront ainsi juger si le changement observé est pertinent pour leur propre flux de travail d’extraction.

FAQ

Un JSON valide suffit-il à prouver qu’un modèle Hugging Face extrait correctement les données ?

Non. Le fait que la sortie puisse être analysée indique seulement qu’elle peut être décodée comme JSON. Vérifiez séparément la conformité au schéma, la présence des champs obligatoires et l’exactitude des champs par rapport à des exemples sources étiquetés.

Faut-il comparer un modèle ajusté à son modèle de base ?

Oui, si l’objectif est de mesurer l’apport de l’ajustement fin. Exécutez les deux modèles sur les mêmes exemples tenus à l’écart, avec le même prompt, le même modèle de conversation, les mêmes paramètres de génération et, dans la mesure du possible, le même chemin d’inférence. Consignez les différences que vous ne pouvez pas maintenir constantes.

Quels exemples inclure dans un jeu d’évaluation de l’extraction JSON ?

Incluez des exemples courants, des entrées difficiles ou bruitées, des champs manquants, des cas ambigus, des tests de résistance au format et des exemples que le modèle de base traite déjà correctement. Séparez le jeu des données d’ajustement fin et documentez l’étiquetage des valeurs attendues.

La validation JSON Schema permet-elle de vérifier la véracité des valeurs extraites ?

Non. La validation du schéma vérifie la structure et les types de données, pas si une valeur est étayée par l’entrée. Utilisez des valeurs attendues étiquetées et une notation par champ pour évaluer l’exactitude de l’extraction.

Comment traiter les sorties du modèle qui contiennent du texte autour du JSON ?

Décidez-en avant les tests. Si la tâche exige uniquement du JSON, considérez le texte supplémentaire comme un échec de format. Si un analyseur ou une étape de réparation en production le supprime, évaluez et présentez séparément ce flux de travail plutôt que de nettoyer silencieusement les sorties.

Articles liés