Aller au contenu
English

Router des questions bancaires

  • Étude de cas 1
  • 150 min
  • Facultative · 1 étude de cas requise pour le certificat

Où nous en sommes

Dans neuf modules, nous avons routé les messages synthétiques de Larkfield vers six équipes. Dans cette étude de cas, nous utilisons de vraies données ouvertes : des questions bancaires réparties entre 77 intentions détaillées. Nous regroupons les intentions par destination d'équipe, comparons quatre types de méthodes selon une mesure des coûts et choisissons combien de questions une personne lit.

Étude de cas 1 sur 4 · Classification et routage de textes : envoyer chaque message au bon endroitRouter des questions bancaires
Aperçu du cours

Ce que vous saurez faire

Partez de 13 083 questions bancaires portant 77 étiquettes détaillées pour prendre une décision de routage défendable avec des chiffres. Vous associerez les étiquettes à 7 équipes et comparerez quatre types de méthodes selon une mesure des coûts. Ensuite, choisissez combien de questions une personne lit, testez une seule fois et appliquez le routeur à de nouvelles questions.

Étude de casPièce de portfolio

Jeu de données
Banking77 (PolyAI)
Licence
CC BY 4.0
Durée
Environ 2,5 heures
S’exécute dans
Colab, Kaggle ou VS Code
Compétences utilisées
  • Une correspondance écrite des étiquettes
  • Référence de base TF-IDF
  • Plongements figés
  • Petit encodeur réglé finement
  • LLM enregistré, avec peu d'exemples
  • Confiance dans la destination
  • Seuil de révision fondé sur les coûts
  • Comparaison équitable sur un échantillon

Les carnets sont en anglais. Colab et Kaggle ouvrent votre propre copie. Pour utiliser VS Code, téléchargez le carnet depuis GitHub. Vous êtes bloqué ? Consultez le carnet de solution.

Le carnet (notebook) Jupyter exécute chaque étape de cette page, ainsi que trois tâches avec des vérifications. Ses cellules de préparation installent les paquets et téléchargent les données (1 Mo) et les fichiers du cours (44 Mo). Le modèle de base (environ 470 Mo) se télécharge une seule fois. Aucun compte ni aucune clé n’est nécessaire : les réponses du LLM ont été enregistrées. Après l’installation, l’exécution prend environ une minute sur un ordinateur portable.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 150 minutes

Ce que vous devez savoir

Cette étude de cas utilise l’ensemble du cours. Ces leçons sont les plus importantes :

Ce qu’il vous faut sur votre ordinateur

Rien : le carnet s’exécute dans Colab ou Kaggle. Pour l’exécuter localement, utilisez un environnement virtuel avec Python 3.12, pandas 3.1.1, scikit-learn 1.9.1, sentence-transformers 6.2.0, Transformers 5.22.2 et PyTorch 2.15.0 (CPU). La cellule de préparation crée un dossier banking77. Pour recommencer, supprimez ce dossier. Cette étude de cas ne modifie pas votre projet larkroute.

Testé sur macOS (Apple silicon) avec Python 3.12, dans Jupyter après un démarrage à neuf. Colab, Kaggle, Windows et Linux n’ont pas été testés.

Imaginez une petite banque en ligne. Ses clients écrivent au centre d’assistance dans l’application, et chaque question doit atteindre la bonne équipe. Aujourd’hui, une personne lit d’abord chaque question et la transfère à une équipe.

Leila dirige le service à la clientèle. Elle a sept équipes, des cartes aux virements. L’une d’elles traite les urgences, security : cartes perdues, téléphones volés et paiements que le client ne reconnaît pas. Une question pour cette équipe ne peut pas attendre dans la mauvaise file d’attente. Quelqu’un utilise peut-être l’argent du client.

Tunde est scientifique des données. Leila lui demande : « Un modèle peut-il envoyer la plupart des questions directement à la bonne équipe? Combien mon personnel doit-il encore lire? Et combien ça coûte? »

Nous avons inventé Leila, Tunde et la banque. Les questions proviennent d’un jeu de données publié, décrit ci-dessous.

L’étude de cas utilise le tableau des coûts du cours. Ce sont des hypothèses, avec les mêmes valeurs que pour Larkfield :

  • Une question dans la mauvaise file coûte 4 $ US : la mauvaise équipe la lit et la transfère, et le client attend plus longtemps.
  • Une question urgente pour security dans la mauvaise file coûte 20 $ US.
  • Une révision par une personne coûte 1,50 $ US : environ une minute du temps d’un agent.

Ainsi, « une personne lit tout », le processus actuel de Leila, coûte 1 500 $ US par 1 000 questions.

Vous créerez un routeur qui choisit l’une des 77 intentions (ce que veut le client). À partir de cette intention, il choisit l’une des 7 destinations (l’équipe qui répond). En cas d’incertitude, il transfère la question à une personne. Vous comparerez quatre types de méthodes avec une seule mesure : le coût par 1 000 questions.

Les données sont celles de Banking77, publié par PolyAI. Ce jeu contient 13 083 courtes questions adressées à une banque en ligne, chacune étiquetée avec l’une des 77 intentions. Par exemple, card_arrival (« Where is my new card? ») ou transfer_timing (« How long does a transfer take? »).

Des personnes recrutées par participation collective ont écrit les questions pour une banque imaginaire. Aucun vrai client n’est donc derrière ces questions. Elles sont réelles dans un autre sens : des personnes les ont écrites avec leurs propres mots, fautes de frappe et cas limites. Un seul modèle a rédigé la boîte de réception de Larkfield à partir de 27 gabarits de message.

Nous l’avons comparé à quatre autres jeux de données ouverts; la fiche du jeu de données explique pourquoi nous l’avons retenu.

Le carnet télécharge les deux fichiers du dépôt de PolyAI à une version fixe et vérifie leurs sommes de contrôle. Tunde les charge ensuite :

raw_train = pd.read_csv("data/train.csv").rename(columns={"category": "intent"})
test = pd.read_csv("data/test.csv").rename(columns={"category": "intent"})

Les premières vérifications affichent :

train file: 10,003 questions | test file: 3,080 | intents: 77
missing values: 0 | repeated questions: 0 | test questions also in train: 0
words per question: median 10, 90% have at most 22, longest 79
train questions per intent: from 35 (contactless_not_working) to 187 (card_payment_fee_charged) | test: 40 to 40
odd intent names: ['Refund_not_showing_up', 'reverted_card_payment?']

Ce que cela nous dit. Les fichiers sont propres et les questions sont courtes : la moitié ont 10 mots ou moins. Le fichier de test contient exactement 40 questions par intention. Deux noms d’intention ne suivent pas le même format. Nous les gardons tels quels; renommer des étiquettes sans le signaler peut rendre deux fichiers incompatibles.

Tunde lit aussi 100 questions choisies au hasard et les plus longues. Quelques-unes des lignes les plus longues sont des réponses écrites par un agent bancaire, pas des questions. Les vraies données contiennent ce genre de bruit.

Pensez à un bureau de poste. Les lettres ont des adresses précises, mais le centre de tri a seulement quelques sacs, un par fourgonnette. Le centre note une fois quelles rues vont dans quel sac, et chaque commis au tri utilise cette liste.

Les intentions de Banking77 sont les adresses précises. Les équipes de Leila sont les sacs. Tunde et Leila notent quelle équipe répond à chaque intention. C’est la correspondance écrite : un fichier, intent_routes.csv, avec une ligne par intention. C’est une décision d’affaires, lue par des personnes et par du code.

77 intentions à gauche, avec des flèches vers 7 cases de destination à droite. security : 6 intentions, urgentes, par exemple lost_or_stolen_card et card_payment_not_recognised. cards : 20 intentions, par exemple card_arrival, card_delivery_estimate et change_pin. payments_fees : 14 intentions, par exemple transaction_charged_twice, extra_charge_on_statement et exchange_rate. transfers : 11 intentions, par exemple pending_transfer et failed_transfer. top_ups : 10 intentions, par exemple pending_top_up et top_up_failed. cash_atm : 7 intentions, par exemple atm_support et declined_cash_withdrawal. account : 9 intentions, par exemple verify_my_identity et terminate_account.
La correspondance écrite : chacune des 77 intentions va vers exactement une des 7 destinations d'équipe. Les intentions proches, comme card_arrival et card_delivery_estimate, vont à la même équipe.
Description textuelle du diagramme

À gauche, une case : les 77 intentions, les étiquettes de Banking77, une par question. Sept flèches mènent à sept cases de destination. security compte 6 intentions et traite les urgences, par exemple lost_or_stolen_card et card_payment_not_recognised. cards compte 20 intentions, par exemple card_arrival, card_delivery_estimate et change_pin. payments_fees compte 14 intentions, par exemple transaction_charged_twice, extra_charge_on_statement et exchange_rate. transfers en compte 11, par exemple pending_transfer et failed_transfer. top_ups en compte 10, par exemple pending_top_up et top_up_failed. cash_atm en compte 7, par exemple atm_support et declined_cash_withdrawal. account en compte 9, par exemple verify_my_identity et terminate_account.

Ils ont suivi trois règles :

  • Une équipe par type de travail. Une équipe reçoit les intentions auxquelles son personnel peut répondre sans aide. L’équipe cards (cartes) traite tout ce qui concerne la carte elle-même : commande, livraison, NIP et cartes virtuelles.
  • L’urgence décide d’abord. Toute intention où quelqu’un d’autre utilise peut-être l’argent va à security (sécurité), même si une autre équipe connaît le sujet. Ainsi, card_payment_not_recognised (paiement par carte non reconnu) va à security, pas à payments_fees (paiements et frais).
  • Notez les choix difficiles. card_swallowed (un guichet automatique a retenu la carte) pourrait aller à cash_atm (argent comptant et guichets automatiques) ou à cards. Le client a besoin d’une nouvelle carte, donc l’intention va à cards. supported_cards_and_currencies (cartes et devises prises en charge) mélange deux sujets; elle va à payments_fees, avec les autres questions sur les devises.

Le carnet lit le fichier et le vérifie :

77 intents mapped to 7 routes; intents without a route: 0
intents priority train_questions share
route
security 6 urgent 799 0.080
cards 20 normal 2169 0.217
payments_fees 14 normal 2105 0.210
transfers 11 normal 1581 0.158
top_ups 10 normal 1232 0.123
cash_atm 7 normal 1104 0.110
account 9 normal 1013 0.101

Ce que cela nous dit. Les destinations ne sont pas égales : cards et payments_fees reçoivent chacune environ un cinquième des questions, et security, 8 %. C’est la structure à deux niveaux de la leçon Les étiquettes hiérarchiques.

Tunde note ses réponses avant d’entraîner quoi que ce soit :

  • Unité : une question. Elle reçoit une destination ou va à une personne.
  • Étiquettes : le modèle apprend les 77 intentions; la destination vient de la correspondance. Nous testons les deux niveaux.
  • Une mesure pour choisir : le coût par 1 000 questions, avec le tableau des coûts du cours. L’exactitude des destinations, l’exactitude des intentions, le rappel de security et la proportion envoyée en révision l’accompagnent.
  • La séparation : 2 000 questions d’entraînement deviennent des données de validation, stratifiées par intention. Tous les choix reposent sur ces données. Le fichier de test reste fermé jusqu’à la fin, et nous l’utilisons une seule fois.
  • Une comparaison équitable : les réponses du LLM hébergé ont été enregistrées pour un échantillon seulement. Il comprend jusqu’à 10 questions par intention : 765 questions de validation et 770 questions de test. Chaque méthode est aussi évaluée sur ce même échantillon.
train 8,003 | validation 2,000 | test 3,080 (used once, at the end)

Le fichier utilitaire du cours routing.py évalue chaque méthode, avec les 7 destinations de la banque et chaque question security marquée urgente.

Une référence de base : TF-IDF et régression logistique

Section intitulée « Une référence de base : TF-IDF et régression logistique »

Tunde commence avec la référence de base du projet du cours : TF-IDF de mots, de paires de mots et de groupes de lettres, avec régression logistique. Elle apprend les 77 intentions en 5 secondes. Sur les questions de validation :

method intent_accuracy route_accuracy security_recall review_share total_per_1000
0 TF-IDF + LR 0.896 0.962 0.919 0.0 256.0
1 everything to a person NaN 0.000 0.000 1.0 1500.0

Ce que cela nous dit. La référence de base trouve environ 9 intentions sur 10 et 96 destinations sur 100. Beaucoup d’erreurs d’intention arrivent quand même à la bonne équipe. La référence de base coûte 256 $ US par 1 000 questions, contre 1 500 $ US lorsqu’une personne lit tout.

Sur la boîte de réception synthétique de Larkfield, le même pipeline atteignait aussi 0,962 sur 7 destinations. Mais les 77 intentions sont beaucoup plus difficiles (0,896). Les étiquettes détaillées rédigées par de nombreuses personnes montrent les difficultés des vraies données.

Apprendre les intentions ou seulement les destinations?

Section intitulée « Apprendre les intentions ou seulement les destinations? »

Si la banque a seulement besoin de 7 destinations, pourquoi apprendre 77 intentions? Tunde entraîne le même pipeline directement sur les destinations :

route accuracy, trained on the 7 routes: 0.944

Ce que cela nous dit. Apprendre directement les 7 destinations donne un résultat moins bon : 0,944 contre 0,962. Chaque destination mélange des questions très différentes, donc une classe par destination rend la tâche plus difficile. Gardez les étiquettes détaillées et appliquez la correspondance ensuite.

Confiance dans la destination : additionner les intentions de chaque destination

Section intitulée « Confiance dans la destination : additionner les intentions de chaque destination »

Pour transférer les questions incertaines à une personne, nous avons besoin d’une confiance dans la destination. Le modèle donne une probabilité pour chacune des 77 intentions. Quel nombre représente la confiance dans la destination?

Pensez à un vote avec 77 candidats de 7 partis. Deux candidats d’un même parti obtiennent 42 % et 41 %. Aucun candidat n’a la majorité, mais le parti a 83 %, et c’est le parti qui vous intéresse.

La même logique s’applique aux destinations. La confiance dans la destination est la somme des probabilités de toutes les intentions de cette destination. La fonction route_proba() du carnet calcule cette somme pour chaque question.

Une question, « I lost my wallet and all my cards were in it. », reçoit 77 probabilités d'intention de l'encodeur réglé finement : lost_or_stolen_card 0,418, compromised_card 0,416, lost_or_stolen_phone 0,044, les 74 autres 0,122 ensemble. L'ancienne méthode prend seulement l'intention la plus probable : 0,418 est inférieur à 0,75, donc une personne doit la lire. Cette étude de cas additionne les intentions de chaque destination : security 0,916, les 6 autres destinations 0,084 ensemble. 0,916 est supérieur à 0,75, donc la question va à security.
Une question de validation. Avec seulement son intention la plus probable, elle irait à une personne. Sa confiance dans la destination, la somme des intentions security, est de 0,916, donc elle va directement à security.
Description textuelle du diagramme

La question est « I lost my wallet and all my cards were in it. » L’encodeur réglé finement donne 77 probabilités d’intention : lost_or_stolen_card 0,418, compromised_card 0,416, lost_or_stolen_phone 0,044, et les 74 autres 0,122 ensemble. Une flèche, « ancienne méthode », prend seulement l’intention la plus probable : 0,418 est inférieur au seuil de 0,75, donc une personne doit la lire. L’autre flèche, « cette étude de cas », additionne les intentions de chaque destination : security 0,916, et les 6 autres destinations 0,084 ensemble. 0,916 est supérieur à 0,75, donc la question va à security.

Le modèle ne sait pas avec certitude quelle intention de sécurité s’applique, mais les trois vont à la même équipe. Sur les 2 000 questions de validation, avec un seuil de 0,75, l’intention la plus probable est sous le seuil pour 138 questions. La confiance dans la destination est sous le seuil pour seulement 57 questions. La somme évite la file de révision à 81 questions, qui vont quand même à la bonne équipe.

La référence de base fait 207 erreurs d’intention sur les questions de validation. Tunde les compte par paire :

intent mistakes: 207, of which inside the same route: 132 (64%); they cost nothing at the route level
intent predicted questions same_route
0 top_up_reverted top_up_failed 5 True
1 top_up_failed pending_top_up 4 True
2 wrong_exchange_rate_for_cash_withdrawal card_payment_wrong_exchange_rate 3 False
3 pending_transfer transfer_not_received_by_recipient 3 True
4 balance_not_updated_after_bank_transfer transfer_not_received_by_recipient 3 True
5 card_payment_wrong_exchange_rate wrong_exchange_rate_for_cash_withdrawal 3 False

Ce que cela nous dit. Deux erreurs d’intention sur trois restent dans une même équipe, donc la correspondance les rend gratuites. Les erreurs coûteuses franchissent une frontière d’équipe : un mauvais taux de change sur un retrait d’argent (cash_atm) plutôt que sur un paiement par carte (payments_fees).

La paire la plus connue dans Banking77 est card_arrival (arrivée de la carte) et card_delivery_estimate (délai de livraison estimé de la carte). Lisez deux questions d’entraînement :

  • « I ordered my card but it still isn’t here » porte l’étiquette card_arrival.
  • « I ordered my card a couple weeks ago and haven’t received it yet. When can I expect it? » porte l’étiquette card_delivery_estimate.

Une personne pourrait attribuer l’une ou l’autre étiquette à chacune des questions. Sur les données de validation, la référence de base confond cette paire seulement deux fois. Sur les questions de test, le modèle choisi la confondra 7 fois. Les deux intentions vont à cards, donc cela ne coûte rien au niveau des destinations. Si la banque envoie plus tard une réponse automatique différente pour chaque intention, cette frontière comptera de nouveau.

Erreur courante

Les étiquettes qui sont toutes les deux correctes

Symptôme : Tunde lit les questions que le modèle classe « mal » entre card_arrival et card_delivery_estimate. Pour la plupart, il est d’accord avec le modèle.

Cause : la frontière entre les étiquettes n’est pas nette. De nombreuses personnes recrutées par participation collective ont étiqueté des questions semblables de façons différentes. Un modèle ne peut pas être plus cohérent que ses étiquettes, comme l’a montré Mesurer l’accord.

Solution : ne cherchez pas à gagner ces points avec un plus gros modèle. Regroupez les deux intentions dans une équipe, comme le fait la correspondance. Si la différence compte pour l’entreprise, rédigez une consigne d’étiquetage pour cette frontière et réétiquetez un échantillon. C’est l’approche de la leçon Guide d’étiquetage.

Conséquence pour le travail en IA : une partie de chaque « taux d’erreur » sur un jeu de données public vient des étiquettes bruitées. Lisez les erreurs avant d’acheter plus d’exactitude.

Chaque méthode apprend sur les mêmes 8 003 questions d’entraînement et est évaluée sur les mêmes 2 000 questions de validation.

L’ancien modèle de plongement du cours transforme chaque question en 384 nombres qui représentent son sens. Une régression logistique apprend les 77 intentions à partir de ces nombres, comme dans Plongements de phrases pour la classification. Produire les plongements des 13 083 questions prend 13 secondes sur un portable.

Le résultat : exactitude de 0,900 pour les intentions, de 0,962 pour les destinations, et 232 $ US par 1 000 questions. Dans la boîte de réception de Larkfield, les plongements figés perdaient nettement contre TF-IDF (0,920 contre 0,962). Ici, ils sont à égalité pour les destinations et coûtent un peu moins cher. Dans de courtes questions écrites par plusieurs personnes, beaucoup de mots expriment un même sens. C’est là que les nombres fondés sur le sens aident.

Ensuite, le même modèle, réglé finement. Ses 12 couches et une nouvelle tête de classification à 77 sorties apprennent à partir des questions d’entraînement. La grande table de mots reste figée, comme dans Régler finement un petit encodeur sur CPU. Sur ses 117,7 millions de paramètres, 21,7 millions apprennent.

Le premier entraînement utilisait la recette de Larkfield avec 4 époques. Sa perte de validation baissait encore à la fin (0,706), et son exactitude pour les intentions atteignait 0,890 : l’entraînement était insuffisant. Le deuxième utilisait 6 époques et un taux d’apprentissage plus élevé (0,0002). L’entraînement a pris 484 secondes, soit environ 8 minutes, sur le CPU d’un portable (4 fils d’exécution). Sa perte de validation a cessé de baisser autour de 0,37. Ce résultat est le point de contrôle (checkpoint) prêt à utiliser : 43,4 Mo de poids modifiés dans le dépôt des exercices. Le carnet (notebook) Jupyter le charge, et une cellule facultative l’entraîne de nouveau.

missing: ['bert.embeddings.word_embeddings.weight'] | unexpected: []
method intent_accuracy route_accuracy security_recall total_per_1000 ms_per_message
0 fine-tuned encoder 0.922 0.968 0.956 182.0 4.36

Ce que cela nous apprend. Seule la table de mots figée manque, comme prévu. L’encodeur réglé finement est le meilleur jusqu’ici dans chaque colonne. Il atteint 0,922 pour les intentions et 0,968 pour les destinations. Il trouve 95,6 % des questions de sécurité et coûte 182 $ US par 1 000 questions. Il lui faut environ 4 millisecondes par question.

Le LLM hébergé, avec peu d’exemples et des réponses enregistrées

Section intitulée « Le LLM hébergé, avec peu d’exemples et des réponses enregistrées »

Un LLM hébergé (Azure chat-small) a choisi une intention pour les questions de l’échantillon. La requête (prompt) présente les 77 intentions regroupées par destination. Elle ajoute les 8 questions d’entraînement les plus semblables avec leurs intentions, comme dans Exemples dans la requête et descriptions d’étiquettes. La réponse est en JSON : une intention de la liste et une valeur de confiance. Nous avons enregistré chaque réponse une fois, pour que vous puissiez les réutiliser sans clé. Voici la requête pour une question de test :

Labelled examples:
- "I was issued a new card a week ago but still haven't received it. How long will it be until I receive it?" -> card_arrival
- "I ordered my card a couple weeks ago and haven't received it yet. When can I expect it?" -> card_delivery_estimate
- "My card hasn't arrived in the mail yet. I ordered it two weeks ago. What can I do?" -> card_arrival
...
Question:
I still have not received my new card, I ordered over a week ago.
few-shot: 1535 answers, all valid: True | tokens in 1083, out 20 | 0.118 dollars per 1,000 | median 1378 ms

Chacune des 1 535 réponses coûte environ un dixième de cent et prend environ 1,4 seconde.

Le LLM n’a des réponses que pour l’échantillon. Chaque méthode est donc évaluée sur les mêmes 765 questions de validation :

method intent_accuracy route_accuracy security_recall total_per_1000
0 embeddings (frozen) + LR 0.901 0.962 0.967 193.5
1 LLM few-shot (recorded) 0.898 0.963 0.950 209.3
2 fine-tuned encoder 0.920 0.967 0.933 214.4
3 TF-IDF + LR 0.885 0.954 0.900 308.5

Ce que cela nous apprend. Sur cet échantillon, les plongements figés coûtent le moins cher et l’encodeur arrive troisième. Mais l’écart entre les trois est de moins de 21 $ US. Une seule question de sécurité urgente dans la mauvaise file d’attente change une ligne de 26 $ US par 1 000 questions. Sur les 2 000 questions, l’encodeur coûtait nettement le moins cher (182 contre 232 et 256). Utilisez un petit échantillon pour trouver de grands écarts, pas de petits écarts.

Le LLM est aussi bon que les modèles entraînés, sans entraînement. Mais il n’est pas meilleur, prend plus d’une seconde par question, et chaque question sort de la banque.

Tunde choisit l’encodeur réglé finement : le plus exact et le moins cher sur toutes les données de validation. Il est rapide et fonctionne dans la banque.

Une file de révision fondée sur le tableau des coûts

Section intitulée « Une file de révision fondée sur le tableau des coûts »

Voici la deuxième décision : quelles questions vont à une personne? Une question dont la confiance dans la destination est sous un seuil va en révision, comme dans Décider, faire réviser ou transférer à une personne. Chaque révision coûte 1,50 $ US, mais élimine le risque d’une erreur de 4 ou 20 $ US. Tunde essaie chaque seuil de 0,30 à 0,99 sur les questions de validation :

def with_review(P, threshold):
"""The routes, with "review" where the highest route probability is below the threshold."""
return np.where(P.max(axis=1) >= threshold, P.idxmax(axis=1), "review")
  • Coût total par 1 000 questions
  • Mauvaises destinations
  • Révisions (1,50 $ US chacune)
Encodeur réglé finement, 2 000 questions de validation. Quand le seuil augmente, les mauvaises destinations coûtent moins cher et les révisions coûtent plus cher. Le total est le plus bas à 0,75 : 138,8 $ US par 1 000 questions, avec 2,8 % des questions révisées.
Description textuelle du graphique

Trois lignes selon le seuil, de 0,30 à 0,97. Le coût des mauvaises destinations baisse de 182 $ US par 1 000 questions à 0,30, à 154 à 0,60, 110 à 0,70, 96,8 à 0,75, 56 à 0,90 et 23,2 à 0,95. Le coût des révisions augmente de 0 à 0,30, à 15 à 0,60, 33 à 0,70, 42 à 0,75, 91,5 à 0,90 et 141 à 0,95. Le total est de 182 à 0,30, 169 à 0,60 et 143 à 0,70. Il atteint son minimum de 138,8 à 0,75, puis monte à 147,5 à 0,90, 164,2 à 0,95 et 256 à 0,97. À 0,99, non illustré, 78 % des questions vont en révision et le total atteint 1 165.

lowest cost on validation: threshold 0.75, review 2.8%, 138.8 dollars per 1,000 (no review: 182.0 at 0.30)

Ce que cela nous apprend. Transférer 2,8 % des questions à une personne réduit le coût de 182 à 138,8 $ US par 1 000 questions, soit de 24 %. La courbe est plate près de son minimum : de 0,70 à 0,80, le total reste entre 138,8 et 146. Au-dessus de 0,95, le coût monte rapidement, car les probabilités atteignent rarement 0,99, même quand le modèle a raison.

Et si l’équipe de Leila ne peut lire que 2 % des questions? Le seuil le moins cher sous cette limite est 0,66 : 1,8 % des questions révisées, pour 152,2 $ US par 1 000 questions. La limite coûte environ 13 $ US par 1 000 questions. Leila peut comparer ce coût à celui d’un agent supplémentaire.

Tunde ouvre maintenant le fichier de test. Toutes les méthodes et le seuil ont été choisis sur les données de validation; rien ne change après cette exécution.

method intent_accuracy route_accuracy security_recall review_share total_per_1000
0 fine-tuned encoder, review below 0.75 NaN 0.966 0.958 0.022 92.4
1 fine-tuned encoder 0.930 0.976 0.963 0.000 141.6
2 TF-IDF + LR 0.908 0.969 0.938 0.000 200.0
3 embeddings (frozen) + LR 0.908 0.964 0.925 0.000 239.0
4 everything to a person NaN 0.000 0.000 1.000 1500.0
Les 3 080 questions de test, utilisées une seule fois. Révision : l'encodeur réglé finement qui transfère les questions sous 0,75 à une personne, le moins cher. Figés : les plongements figés. Une personne qui lirait tout coûterait 1 500 $ US.
Description textuelle du graphique

Un diagramme à quatre colonnes, représentant le coût par 1 000 questions de test. Encodeur avec révision sous 0,75 : 92 $ US, le plus bas, dans la première couleur. Encodeur seul : 142. TF-IDF : 200. Plongements figés : 239. Tout transférer à une personne, non illustré, coûterait 1 500.

Ce que cela nous apprend. Le choix tient : l’encodeur est aussi la meilleure méthode sur les questions de test (0,930 pour les intentions, 0,976 pour les destinations). Avec la file de révision, il coûte 92,4 $ US par 1 000 questions et en transfère 2,2 % à une personne. Son exactitude pour les destinations paraît plus faible (0,966) uniquement parce qu’une question révisée compte comme « non routée ». Le test coûte moins cher que la validation (138,8), car chaque ensemble a son propre bruit. Citez les deux.

Les échantillons avec des réponses de LLM enregistrées montrent la même chose :

method intent_accuracy route_accuracy review_share total_per_1000
0 cascade: encoder >= 0.75, LLM >= 0.9, else a person NaN 0.984 0.005 49.4
1 fine-tuned encoder, review below 0.75 NaN 0.978 0.013 55.8
2 fine-tuned encoder 0.942 0.984 0.000 83.1
3 LLM few-shot (recorded) 0.945 0.983 0.000 88.4
4 TF-IDF + LR 0.917 0.977 0.000 135.1
5 embeddings (frozen) + LR 0.914 0.966 0.000 197.4
6 LLM zero-shot (recorded) 0.812 0.931 0.000 337.8
Les 770 questions de test avec des réponses de LLM enregistrées. Révision : l'encodeur avec révision sous 0,75. Exemples et Zéro : le LLM avec peu d'exemples et le LLM zéro exemple. Le LLM avec peu d'exemples est à égalité avec l'encodeur; le LLM zéro exemple est le plus cher. La cascade est la moins chère, mais repose sur très peu de questions.
Description textuelle du graphique

Un diagramme à cinq colonnes, représentant le coût par 1 000 questions parmi les 770 questions de l’échantillon de test. Cascade : 49 $ US. Encodeur avec révision : 56, dans la première couleur. Encodeur seul : 83. LLM avec peu d’exemples : 88. LLM zéro exemple : 338. TF-IDF, non illustré, coûte 135 sur cet échantillon.

Ce que cela nous apprend. Le LLM avec peu d’exemples (few-shot) et l’encodeur sont à égalité : 0,945 contre 0,942 pour les intentions, 88,4 contre 83,1 $ US. Le LLM zéro exemple (zero-shot), avec seulement les noms d’intentions, est loin derrière (0,812 pour les intentions). Les exemples dans la requête enseignent au LLM les limites entre les étiquettes, comme chez Larkfield.

La première ligne est une cascade, comme dans Les cascades. L’encodeur décide quand sa confiance dans la destination atteint au moins 0,75. En dessous, le LLM décide quand la confiance qu’il écrit atteint au moins 0,9. Une personne lit le reste. Tunde a choisi 0,9 sur l’échantillon de validation. Sur l’échantillon de test, la cascade coûte 49,4 $ US contre 55,8, et ne transfère que 0,5 % des questions à une personne.

Mais les preuves sont limitées. Le seuil du LLM a été choisi sur seulement 17 questions incertaines, et l’échantillon de test en compte environ 10. La cascade est une bonne prochaine expérience : enregistrez les réponses du LLM pour chaque question incertaine pendant un mois. Puis décidez à partir de centaines de questions, pas de dix.

Sur les 3 080 questions de test, l’encodeur fait 217 erreurs d’intention. Parmi elles, 142 restent dans une même destination. Ainsi, seulement 73 questions (2,4 %) arrivent à la mauvaise équipe :

intent predicted questions same_route
0 declined_transfer declined_card_payment 5 False
1 card_arrival card_delivery_estimate 4 True
2 top_up_reverted top_up_failed 4 True
3 balance_not_updated_after_bank_transfer transfer_timing 4 True
4 fiat_currency_support exchange_via_app 3 True
5 card_delivery_estimate card_arrival 3 True

Ce que cela nous apprend. La limite la plus coûteuse se situe entre les virements et les paiements par carte. « My payment was declined » peut désigner l’un ou l’autre, et seul le client sait lequel. Par destination, les questions transfers (virements) envoyées à payments_fees (paiements et frais) constituent l’erreur de destination la plus fréquente (11). Pour l’équipe des urgences, 9 des 240 questions de sécurité sont allées à une autre équipe. Il y en avait 4 dans account (compte), 3 dans cards (cartes) et 2 dans payments_fees. Ces 9 questions représentent 180 des 436 $ US des mauvaises destinations, car chacune coûte 20 $ US.

La dernière étape applique le routeur à huit nouvelles questions que nous avons écrites dans le style d’une vraie boîte de réception.

text intent route confidence decision
0 My new card still has not come. It has been 10 days. card_arrival cards 0.985 send to cards
1 There is a payment in Lisbon on my card and I have never been there. card_payment_not_recognised security 0.962 send to security
2 How long does a transfer to a euro account take? transfer_timing transfers 0.906 send to transfers
3 I paid cash in at the machine but my balance did not change. balance_not_updated_after_cheque_or_cash_deposit cash_atm 0.792 send to cash_atm
4 Why did I pay a fee when I topped up with my card? top_up_by_card_charge top_ups 0.944 send to top_ups
5 Can my 15 year old son open an account? age_limit account 0.989 send to account
6 The shop says the payment failed but the money left my account. reverted_card_payment? payments_fees 0.972 send to payments_fees
7 hello? why_verify_identity account 0.623 review by a person

Ce que cela nous apprend. Sept destinations semblent correctes, et le paiement de Lisbonne va à security (sécurité) avec 0,962. Le dépôt en espèces est le moins certain (0,792), près du seuil. « hello? » n’a pas d’intention; le modèle en choisit quand même une, mais avec 0,623, la question va à une personne. Une question qui ne correspond à aucune des 77 intentions fait l’objet de la prochaine étude de cas.

Tunde écrit à Leila, dans le langage de Leila :

  • Utilisez l’encodeur réglé finement et transférez les questions dont la confiance dans la destination est sous 0,75 à une personne. Sur les questions de test, cela coûtait 92,4 $ US par 1 000 questions. Tout lire coûte 1 500 $ US, et le modèle TF-IDF simple coûte 200 $ US. Environ 2 questions sur 100 vont encore à une personne.
  • Conservez la correspondance écrite dans un fichier révisé. Toute modification change les destinations. Révisez-la avec les responsables d’équipe, gérez ses versions et testez de nouveau le routeur après chaque modification.
  • Surveillez chaque semaine les questions manquées par l’équipe de sécurité. Dans le test, 9 des 240 questions urgentes sont allées ailleurs. Demandez aux agents de signaler les questions de sécurité qu’ils reçoivent, et ajoutez-les aux données d’entraînement.
  • N’ajoutez pas encore le LLM hébergé. Il est à égalité avec l’encodeur, est 300 fois plus lent et envoie les questions des clients hors de la banque. Testez d’abord la cascade sur un mois de questions incertaines.
  • Si l’équipe de révision ne peut lire que 2 % des questions, utilisez 0,66. Cela coûte environ 13 $ US de plus par 1 000 questions que 0,75.

Et voici à quoi ne pas l’utiliser :

  • Pas pour répondre automatiquement aux clients. Le routeur choisit une équipe; les personnes répondent.
  • Pas comme preuve pour une vraie banque. Ces questions ont été écrites pour une banque imaginaire. Étiquetez quelques milliers de vos propres messages et testez de nouveau.
  • Les données réelles sont plus difficiles au niveau détaillé, pas au niveau des équipes. Destinations : 0,969 pour TF-IDF sur le test, près du 0,962 de Larkfield. Intentions : 0,908.
  • Le classement des méthodes a changé avec les données. Les plongements figés étaient à égalité avec TF-IDF ici, alors qu’ils perdaient chez Larkfield. Testez sur vos propres données.
  • Limites. Des personnes recrutées par une plateforme participative ont écrit ces questions. Elles sont plus propres et plus courtes que de vraies questions. Chacune a une intention, donc aucune ne contient deux demandes. Les données sont uniquement en anglais, certaines étiquettes sont ambiguës, le tableau des coûts est une hypothèse. Les réponses du LLM n’ont été enregistrées que pour les échantillons.
  • Une mauvaise destination, c’est un vrai client qui attend. Pour les questions de sécurité, l’attente peut coûter de l’argent au client. Gardez un moyen pour tout agent de transférer immédiatement une question à security, peu importe ce que dit le routeur.
  • Vérifiez pour qui le routeur échoue. Banking77 ne contient aucune information sur les clients, donc nous n’avons pas pu vérifier les groupes de clients. Avec de vrais messages, comparez le taux d’erreur par langue, par canal et, si la loi le permet, par groupe de clients. Faites-le comme dans Priorité, urgence et langue.
  • Les messages des clients sont des données personnelles. L’encodeur fonctionne dans la banque. Avant d’envoyer de vrais messages à un LLM hébergé, vérifiez le contrat et la loi. Retirez les noms et les numéros de compte.
  • Citez la source. CC BY 4.0 exige une attribution : nommez PolyAI et l’article, ajoutez un lien vers la licence et indiquez vos modifications.

Cette étude de cas transforme un ensemble d’étiquettes détaillées en décision d’affaires : une correspondance, une méthode, un seuil et un coût. Adaptez-la avec une modification. Par exemple, associez les intentions à 5 équipes, changez le coût des questions de sécurité ou essayez un deuxième encodeur. Puis publiez-la pour que quelqu’un puisse la lire en cinq minutes.

Quoi mettre dans le dépôt :

  • README.md, la page que les gens lisent d’abord (modèle ci-dessous).
  • Le carnet, exécuté du début à la fin, avec ses sorties.
  • intent_routes.csv : votre correspondance, avec une phrase par destination pour expliquer pourquoi.
  • comparison.csv : chaque méthode sur la validation, et les résultats de test à part.
  • La source et la licence des données : le dépôt PolyAI, CC BY 4.0, l’article et le SHA-256 des fichiers utilisés.

Un modèle de README :

# Routing banking questions to 7 teams, with a review queue chosen by cost
## Problem
An online bank's help desk gets questions in 77 intents. Seven teams answer them. A question in
the wrong queue costs $4, an urgent security question $20, a review by a person $1.50 (assumptions).
## Data and licence
Banking77 (Casanueva et al., PolyAI, 2020), 13,083 questions, 77 intents, CC BY 4.0,
github.com/PolyAI-LDN/task-specific-datasets. Crowd-written questions for an imagined bank.
## Approach
A written mapping from 77 intents to 7 routes. Validation 2,000 split from train; test used once.
Compared TF-IDF + logistic regression, frozen MiniLM embeddings, a fine-tuned MiniLM encoder
(CPU, 8 minutes), and a few-shot LLM (recorded, on a sample). Route confidence = sum of the
intent probabilities of the route. Review threshold chosen on validation by cost.
## Results (test, used once)
Fine-tuned encoder, review below 0.75: $92.4 per 1,000 questions, 2.2% reviewed
(everything to a person: $1,500; TF-IDF: $200). Intent accuracy 0.930, route accuracy 0.976.
## Limits
Crowd-written questions; one intent per question; English only; assumed costs.

Comment le décrire en entrevue, en deux phrases : « J’ai routé des questions bancaires de 77 intentions vers 7 équipes avec une correspondance écrite, puis comparé TF-IDF, les plongements, un petit encodeur réglé finement et un LLM sur une mesure de coût. L’encodeur réglé finement, avec un seuil de révision choisi dans le tableau des coûts, a réduit le coût par 1 000 questions de 1 500 $ US à 92 $ US, et j’ai montré que la plupart des erreurs d’intention restantes n’envoyaient jamais les questions à la mauvaise équipe. »

Pour aller plus loin :

Le carnet contient trois tâches avec des vérifications. Prédisez chaque réponse avant de l’exécuter.

1. Apprenez directement les destinations. Dans la section 6, entraînez le même pipeline TF-IDF sur train.route. Mesurez son exactitude pour les destinations sur les questions de validation.

Afficher la réponse
direct = tfidf_lr().fit(train.text, train.route)
direct_accuracy = round(float((direct.predict(validation.text) == validation.route).mean()), 3)
route accuracy, trained on the 7 routes: 0.944

Inférieure à 0,962, comme expliqué dans la section sur la référence de base.

2. La paire liée aux cartes. Dans la section 7, comptez les questions de validation étiquetées card_delivery_estimate (estimation de livraison de carte) que la référence de base prédit comme card_arrival (arrivée de carte).

Afficher la réponse
crosstab = pd.crosstab(pair.intent, pd.Series(tfidf_intent_val[pair.index], index=pair.index, name="predicted"))
estimate_as_arrival = int(crosstab.loc["card_delivery_estimate", "card_arrival"])
predicted card_arrival card_delivery_estimate
intent
card_arrival 30 0
card_delivery_estimate 2 18
card_delivery_estimate questions predicted as card_arrival: 2
  1. Lisez le tableau par lignes : sur 20 questions card_delivery_estimate, 2 sont allées à card_arrival. Les deux sont dans cards, donc elles ne coûtent rien.

3. Une équipe de révision plus petite. Dans la section 11, trouvez le seuil le moins cher quand au plus 2 % des questions peuvent aller en révision.

Afficher la réponse
under = curve[curve.review_share <= 0.02]
threshold_2 = float(under.loc[under.total_per_1000.idxmin(), "threshold"])
threshold with at most 2% to review: 0.66
review_share total_per_1000
0.018 152.2

0,66 : 1,8 % des questions révisées, 152,2 $ US par 1 000 questions.

Vérifiez votre compréhension

La référence de base apprend 77 intentions, même si la banque n'a besoin que de 7 destinations. Entraînée directement sur les 7 destinations, elle atteint 0,944 plutôt que 0,962. Pourquoi le modèle plus détaillé réussit-il mieux la tâche plus générale?

Afficher la réponse

Chaque destination regroupe des questions très différentes. « My card was stolen » et « Who set up this direct debit? » vont toutes deux à security (sécurité), mais partagent peu de mots. Un modèle avec une classe par destination doit tracer une seule région autour de toutes ces questions. C’est difficile. Un modèle avec une classe par intention apprend chaque type de question séparément. La correspondance les regroupe ensuite. Conservez donc les étiquettes détaillées quand vous les avez. Associez-les aux équipes après le modèle, pas avant.

Vérifiez votre compréhension

Pour « I lost my wallet and all my cards were in it. », l'intention principale a une probabilité de seulement 0,418. Pourtant, le routeur envoie la question directement à la sécurité avec un seuil de 0,75. Est-ce une erreur?

Afficher la réponse

Non. Le modèle hésite sur quelle intention de sécurité correspond à la question : lost_or_stolen_card 0,418, compromised_card 0,416, lost_or_stolen_phone 0,044. Les trois vont à la même équipe. La confiance dans la destination est la somme des probabilités de ses intentions : 0,916 pour la sécurité. La décision porte sur la destination. C’est donc la confiance dans cette destination qu’il faut comparer au seuil. Sur les données de validation, cette somme a évité la révision de 81 questions sur 2 000.

Vérifiez votre compréhension

Sur les 765 questions de validation de l'échantillon, les plongements figés coûtent 193,5 $ US par 1 000 questions. L'encodeur réglé finement coûte 214,4 $ US. Sur les 2 000 questions de validation, l'encodeur coûte 182 $ US et les plongements, 232 $ US. À quel résultat Tunde devrait-il se fier, et pourquoi?

Afficher la réponse

Au résultat sur les 2 000 questions. L’échantillon est plus petit, et les méthodes donnent des résultats proches. Une seule question urgente de sécurité dans la mauvaise file d’attente change une ligne de résultats de l’échantillon de 20 ÷ 765 × 1 000. Cela représente environ 26 $ US par 1 000 questions. C’est plus que l’écart entre les méthodes. Un échantillon permet de comparer une méthode qui n’a des réponses que pour cet échantillon, comme le LLM enregistré. Il permet aussi de repérer de grands écarts. Pour départager des méthodes proches, utilisez le plus grand jeu de données disponible. Confirmez ensuite une seule fois sur les données de test.

Récapitulatif

  • Une correspondance écrite a transformé 77 intentions détaillées en 7 destinations d’équipe, en donnant la priorité à l’urgence. Deux erreurs d’intention sur trois restaient dans la même équipe.
  • Apprendre les intentions et additionner leurs probabilités par destination a surpassé l’apprentissage direct des destinations (0,962 contre 0,944). La confiance dans la destination est la somme des probabilités de ses intentions.
  • Sur toutes les données de validation, l’encodeur réglé finement avait la meilleure exactitude et le coût le plus bas. Le LLM avec peu d’exemples (few-shot) l’égalait sur un échantillon. Le LLM zéro exemple (zero-shot) était loin derrière.
  • Le seuil de révision venait du tableau des coûts : 0,75 sur les données de validation, avec 2,8 % des questions révisées. Sur les données de test, utilisées une seule fois : 92,4 $ US par 1 000 questions et 2,2 % révisées. Lire toutes les questions aurait coûté 1 500 $ US.
  • Les données réelles étaient plus difficiles au niveau des intentions (0,930 pour l’encodeur) qu’au niveau des équipes (0,976).

Ensuite, la deuxième étude de cas : les questions qui ne correspondent à aucune intention, et comment les transférer à une personne.

Leçon suivante : Trouver ce que le robot ne sait pas traiter