GuidesOneMux

Évaluer les modèles Hugging Face pour fiabiliser les décisions de nouvelle tentative et de reprise

Construisez une évaluation reproductible et adaptée à votre tâche pour comparer les modèles Hugging Face sur les décisions de nouvelle tentative et de reprise en production.

AI

Résumé · TL;DR

Une méthode pratique pour comparer les modèles Hugging Face de base et affinés sur les décisions de nouvelle tentative, de reprise et d’escalade, ainsi que sur les risques d’actions en double.

Points clés

  • Testez les décisions attendues du workflow sur des incidents réservés au test avant de vous fier aux scores des benchmarks publics.
  • Comparez les modèles de base et affinés avec les mêmes entrées, le même modèle de prompt, les mêmes paramètres de décodage et les mêmes conditions de service.
  • Évaluez les nouvelles tentatives dangereuses séparément de l’exactitude globale des actions et examinez les échecs par scénario.
  • Soumettez les recommandations du modèle à des contrôles déterministes des règles et prévoyez une escalade humaine lorsque nécessaire.
Sur cette page (7)

Partir de la décision opérationnelle

Pour évaluer un modèle Hugging Face destiné à l’exploitation de workflows, vérifiez s’il recommande la bonne action à entreprendre sur des incidents réservés au test, plutôt que de vous appuyer sur ses performances dans un classement généraliste. Comparez les modèles de base et affinés sur les mêmes cas, avec les mêmes paramètres de prompt et de génération, et présentez les recommandations dangereuses de nouvelle tentative séparément de l’exactitude globale.

Cette approche reprend le conseil central d’une discussion du forum Hugging Face sur les benchmarks : mesurer la capacité qui compte, utiliser des exemples exclus de l’entraînement, comparer les résultats à ceux du modèle de base et examiner les échecs individuels. Les règles et les contrôles propres au workflow présentés ci-dessous sont donnés à titre d’illustration ; ils ne constituent ni un benchmark testé ni une affirmation sur les performances d’un modèle.

Définir les règles avant de construire le test

Supposons qu’un modèle reçoive un résumé d’incident et recommande l’une des quatre actions suivantes : retry, recover, escalate ou stop. Rédigez les règles avec le responsable du workflow avant de demander au modèle de les appliquer. Par exemple :

  • Nouvelle tentative uniquement si l’échec est transitoire, si le nombre de tentatives autorisées n’est pas épuisé et si la réexécution est sûre au regard des règles d’idempotence du workflow.
  • Reprise lorsqu’une procédure de reprise documentée s’applique et que ses prérequis sont remplis.
  • Escalade lorsque le résultat d’un effet de bord est inconnu, que le contexte nécessaire manque ou qu’un opérateur doit prendre une décision.
  • Arrêt lorsque l’échec est permanent ou que le nombre de tentatives autorisées est épuisé, sauf si une règle de reprise distincte et approuvée s’applique.

Il s’agit d’exemples de règles, et non de classifications universelles. Un délai d’attente dépassé ne prouve pas à lui seul l’échec d’une opération : un paiement ou un message peut déjà avoir été envoyé. La recommandation du modèle doit passer par des contrôles déterministes des règles ; elle ne doit pas autoriser de façon autonome un effet de bord susceptible d’être exécuté en double.

Construire un jeu représentatif réservé au test

Commencez par des incidents expurgés ou des cas synthétiques réalistes qui reflètent les décisions auxquelles les opérateurs sont réellement confrontés. Excluez les exemples d’évaluation des données d’affinage et regroupez les incidents liés avant de répartir les données, afin que des quasi-doublons d’un même événement ne se retrouvent pas dans plusieurs jeux. Réservez un jeu de test final à la décision de mise en production ; utilisez un jeu de développement distinct pour modifier le prompt ou les règles.

Catégorie de testExempleDécision attendue selon les règles d’exemple
Échec transitoire, réexécution sûreErreur de service temporaire ; protection par idempotence confirmée ; tentatives encore autoriséesNouvelle tentative
Résultat inconnu d’un effet de bordDélai d’attente dépassé après la soumission d’un paiement ; état d’exécution inconnuEscalade
Nombre de tentatives épuiséÉchec transitoire, mais toutes les tentatives autorisées ont été utiliséesArrêt
Reprise documentéeÉtat connu permettant une reprise et présence de tous les prérequisReprise
Contexte manquantErreur fournie, mais sécurité de la réexécution inconnueEscalade
Cas de régressionIncident simple que le modèle de base traite déjà correctementSelon les règles

Incluez les incidents courants dans des proportions approximativement conformes à celles attendues, mais conservez aussi une catégorie distincte à haut risque pour les cas rares, comme les paiements dont l’issue est inconnue. Présentez les résultats des deux ; un jeu de cas dangereux volontairement surreprésentés ne doit pas être présenté comme représentatif de la distribution des incidents en production. Demandez à un expert du workflow d’étiqueter les actions attendues et de trancher les cas ambigus avant l’évaluation.

Fixer les paramètres de comparaison

Utilisez exactement le même texte d’incident, les mêmes instructions système, le même schéma de réponse, les mêmes exemples few-shot et les mêmes paramètres de génération pour les deux modèles. Consignez les révisions du modèle de base et du modèle affiné, le tokenizer et le template de chat, le statut de l’adapter ou du modèle fusionné, la version de la bibliothèque d’inférence, le backend, la quantification et le matériel. Si un système de retrieval fournit des runbooks, figez également le contexte récupéré.

Pour chaque cas, enregistrez le prompt, l’action attendue, la réponse brute, l’action extraite et l’étiquette d’erreur. Considérez les JSON invalides, les champs manquants et les actions non reconnues comme des échecs, plutôt que de les corriger silencieusement. Si les deux modèles nécessitent des templates de chat différents pour fonctionner correctement, documentez cet écart : le résultat mesure alors les systèmes configurés dans leur ensemble, et non le seul affinage.

Si la génération est stochastique, répétez la comparaison avec plusieurs seeds consignés et présentez chaque exécution ainsi que l’intervalle des résultats. La prise en charge des seeds et la reproductibilité varient selon le backend ; un seed fixe ne garantit pas des sorties identiques d’un environnement à l’autre. La discussion du forum recommande également de répéter les exécutions, car un score unique obtenu sur un petit jeu peut être instable.

Évaluer séparément les actions et les nouvelles tentatives dangereuses

Prérequis : Python 3, un fichier JSON Lines réservé au test et un fichier de réponses enregistré par modèle. Générez ces réponses avec la configuration d’inférence Hugging Face de votre choix avant d’exécuter cet outil d’évaluation local. L’exemple ci-dessous n’a pas été testé et ne suppose aucun modèle, endpoint hébergé ou paramètre de génération pris en charge particulier.

Chaque ligne de cases.jsonl doit contenir un id, une expected_action et un booléen retry_safe attribué selon les règles du workflow. Chaque ligne d’un fichier de réponses doit contenir le même id et la réponse brute du modèle sous forme de chaîne dans output. Par exemple :

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

Un enregistrement de réponse correspondant pourrait être {"id":"timeout-01","output":"{\"action\":\"retry\"}"}. L’outil d’évaluation suivant exige exactement une réponse par cas et signale cette réponse comme une nouvelle tentative dangereuse :

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}")

Exécutez-le une fois par fichier de sortie enregistré :

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

Cet outil vérifie les actions, mais ne valide pas le schéma dans son intégralité : il ne rejette pas les champs JSON supplémentaires et n’évalue pas l’explication. Pour une utilisation en production, ajoutez le schéma réel et validez tous les paramètres de reprise requis. Vérifiez également que l’action proposée est sûre, même lorsqu’elle correspond à l’étiquette : les étiquettes peuvent être erronées.

Interpréter les résultats et résoudre les problèmes

Comparez l’exactitude globale, le nombre de sorties invalides, les nouvelles tentatives dangereuses et les résultats par catégorie. Examinez chaque nouvelle tentative dangereuse et chaque régression par rapport au modèle de base. Pour recover, vérifiez que la procédure proposée et ses prérequis sont corrects ; l’exactitude de l’action ne suffit pas à l’établir. Consignez le nombre de cas sous-jacent à chaque taux, en particulier pour les échecs rares.

Si les IDs ne correspondent pas, vérifiez si des générations manquent ou si des enregistrements sont en double avant l’évaluation. Si les réponses invalides prédominent, examinez les troncatures, le template de chat et le schéma demandé avant de changer de modèle. Si un modèle recommande de nouvelles tentatives lorsque le contexte manque, ajoutez ces cas à un jeu de développement et révisez les instructions ou l’entraînement, sans modifier le jeu de test final réservé.

Définissez les critères de mise en production avec le responsable du workflow avant de consulter les résultats finaux, notamment le nombre de recommandations dangereuses acceptables et les cas qui exigent une escalade. Un petit jeu réservé au test ne peut pas prouver la sécurité en production ; il peut révéler des échecs concrets et aider à prendre une décision mieux informée. Documentez les limites du jeu de données, les paramètres, des exemples d’échecs et les risques non résolus avec les résultats. Les benchmarks publics peuvent apporter un contexte supplémentaire, mais ils ne remplacent pas ce test propre au workflow.

Sources

FAQ

Faut-il utiliser un classement public Hugging Face pour évaluer les décisions de nouvelle tentative ?

Commencez par un jeu représentatif du workflow, réservé au test. Les benchmarks publics peuvent apporter du contexte, mais leurs tâches et leurs méthodes de notation ne mesurent pas nécessairement vos règles de nouvelle tentative ni les risques d’actions en double.

Un seed fixe rend-il une évaluation Hugging Face parfaitement reproductible ?

Pas nécessairement. La prise en charge des seeds et la reproductibilité dépendent du backend d’inférence et de l’environnement. Consignez les seeds, les révisions des modèles, les versions logicielles et les paramètres de service, et présentez les variations entre les exécutions.

Un modèle peut-il exécuter automatiquement la nouvelle tentative qu’il recommande ?

Une recommandation ne devrait pas, à elle seule, autoriser l’exécution. Appliquez des contrôles déterministes des règles du workflow, notamment sur la sécurité de la réexécution et les limites de tentatives, et faites remonter les cas où le résultat d’un effet de bord est incertain.

Articles liés