Trouver ce que le robot ne sait pas traiter
- Étude de cas 2
- 150 min
- Facultative · 1 étude de cas requise pour le certificat
Où nous en sommes
Dans neuf modules, nous avons transféré les messages incertains à une personne. Dans cette étude de cas, nous utilisons de vraies données ouvertes : un jeu de données d'intentions avec des demandes qu'aucune intention ne couvre. Nous les détectons, les transférons à une personne et comptons les mauvaises réponses automatiques ainsi évitées.
Étude de cas 2 sur 4 · Classification et routage de textes : envoyer chaque message au bon endroitTrouver ce que le robot ne sait pas traiter
1. Le problème du routage et son coût
2. Des étiquettes fiables
3. Références de base : règles et modèles classiques
4. Plongements et petits modèles réglés finement
5. Les LLM comme classificateurs
6. Modèles de décision, cascades et distillation
7. Des formes d'étiquettes plus difficiles
8. La confiance et les personnes dans la boucle
9. Exploiter le routeur en production
Ce que vous saurez faire
Apprenez à un assistant virtuel à dire « Je ne peux pas vous aider avec cela, voici une personne » au bon moment. Vous comparerez trois façons de détecter les demandes que l’assistant n’est pas conçu pour traiter. Vous mesurerez le coût de chaque façon. Ensuite, vous choisirez le seuil selon le prix d’une mauvaise réponse et celui d’un transfert.
Le carnet (notebook) Jupyter exécute chaque étape de cette page, plus deux tâches avec des vérifications. Ses cellules de préparation installent les paquets et téléchargent les données (environ 2,5 Mo) depuis le dépôt du jeu de données. Le modèle de plongement (environ 470 Mo) se télécharge une seule fois. Aucun compte ni aucune clé ne sont nécessaires. L’exécution prend environ 2 minutes sur le processeur d’un portable récent; Colab gratuit est plus lent.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
Cette étude de cas utilise tout le cours. Ces leçons sont les plus importantes :
- Le tableau des coûts et le coût par 1 000 messages, dans Le coût de chaque erreur.
- TF-IDF avec la régression logistique, dans Bayes naïf, régression logistique et SVM linéaire.
- Les plongements de phrase (sentence embeddings) et la similarité cosinus, dans Plongements de phrases pour la classification.
- Un LLM hébergé comme classificateur, dans Classification zéro exemple avec un LLM.
- L’étalonnage et les trois zones, dans La confiance est-elle vraie? et Décider, faire réviser ou transférer à une personne.
Ce qu’il vous faut sur votre ordinateur
Rien : le carnet fonctionne dans Colab ou Kaggle. Pour l’exécuter localement, ouvrez-le dans Jupyter avec Python 3.12. Sa cellule de préparation travaille dans un nouveau dossier clinc-oos; pour recommencer, supprimez ce dossier. Cette étude de cas ne modifie pas votre projet larkroute.
Testé sur macOS (Apple silicon) avec Python 3.12, pandas 3.1.1, scikit-learn 1.9.1, sentence-transformers 6.2.0 et PyTorch 2.15.0 (CPU), dans Jupyter, à partir d’un état vierge. Colab, Kaggle, Windows et Linux n’ont pas été testés.
La situation
Section intitulée « La situation »Au bureau de poste, une lettre arrive parfois pour une rue qui n’existe pas ici. Une bonne commis ne la met pas dans le casier le plus proche. Elle la dépose sur le bureau de la personne qui traite les lettres inhabituelles.
Larkfield prévoit un assistant conversationnel sur son site Web pour les demandes simples, comme « où est ma commande ». Grace, la responsable du soutien, a une inquiétude. « Les clients vont lui demander des choses qu’il n’est pas conçu pour traiter. S’il répond quand même, il donne une mauvaise réponse avec un air sûr de lui. Je préférerais qu’il dise Je ne peux pas vous aider avec cela, voici une personne. »
Tomás a déjà une réponse : « Un LLM sait quand une question est étrange. Laissons-le décider. » Priya, la scientifique des données, veut d’abord le mesurer. L’assistant n’a pas encore de vrai journal de conversations. Elle utilise donc un jeu de données public conçu pour cette question.
Une demande qu’aucune intention de l’assistant ne couvre est hors champ (out-of-scope). Une intention est une chose que l’assistant sait faire, comme « vérifier le solde ». La question de cette étude de cas est : quand le robot conversationnel devrait-il transférer une demande à une personne?
Ce que vous allez créer
Section intitulée « Ce que vous allez créer »Vous créerez un détecteur de demandes hors champ pour un assistant qui possède 150 intentions. Vous comparez trois façons :
- un seuil de confiance sur un classificateur : transférer quand le modèle n’est pas assez sûr;
- une distance à l’exemple le plus proche : transférer quand aucune demande d’entraînement n’est assez semblable;
- une classe hors champ explicite : le classificateur apprend « aucune de ces réponses » à partir d’exemples.
Vous mesurez deux nombres ensemble. L’exactitude dans le champ est la proportion de demandes dans le champ qui reçoivent une bonne réponse. Le rappel hors champ est la proportion de demandes hors champ transférées à une personne. Vous choisissez le seuil selon deux prix : une mauvaise réponse et un transfert. Pour Tomás, vous réexécutez les réponses enregistrées d’un LLM hébergé.
Les données
Section intitulée « Les données »Les données proviennent de CLINC150. Ce jeu contient 23 700 demandes courtes adressées à un assistant virtuel imaginaire. Des travailleurs participatifs les ont rédigées pour 150 intentions dans 10 domaines, comme les services bancaires, les voyages et les conversations informelles. Ils ont aussi rédigé 1 200 demandes hors champ qui ne correspondent à aucune des 150 intentions.
Le fichier contient six listes de paires [text, intent]. Priya les lit dans trois tableaux et regarde leur taille :
import jsonraw = json.load(open("data/data_full.json", encoding="utf-8"))DOMAIN_OF = {i: d for d, intents in json.load(open("data/domains.json")).items() for i in intents}
def part(*keys): """One part of CLINC150 as a table. The out-of-scope requests have the intent "oos".""" rows = [(text, intent) for k in keys for text, intent in raw[k]] df = pd.DataFrame(rows, columns=["text", "intent"]) df["domain"] = df.intent.map(DOMAIN_OF).fillna("out of scope") return df
train, validation, test = part("train", "oos_train"), part("val", "oos_val"), part("test", "oos_test")# CLINC150 has no request IDs: we number the rows in the order of the file.for prefix, df in [("TR", train), ("VA", validation), ("TE", test)]: df.insert(0, "message_id", [f"C-{prefix}-{i:05d}" for i in range(1, len(df) + 1)])for name, df in [("train", train), ("validation", validation), ("test", test)]: oos = (df.intent == "oos").sum() print(f"{name:10}: {len(df):6,} requests, {df.intent.nunique() - 1} intents, out of scope {oos:5,} ({oos / len(df):.1%})")print("domains:", sorted(set(DOMAIN_OF.values())))La sortie :
train : 15,100 requests, 150 intents, out of scope 100 (0.7%)validation: 3,100 requests, 150 intents, out of scope 100 (3.2%)test : 5,500 requests, 150 intents, out of scope 1,000 (18.2%)domains: ['auto_and_commute', 'banking', 'credit_cards', 'home', 'kitchen_and_dining', 'meta', 'small_talk', 'travel', 'utility', 'work']Ce que cela nous apprend. Chaque ligne contient une demande et son intention, ou oos (hors champ). La proportion de demandes hors champ diffère dans chaque partie : 0,7 % dans les données d’entraînement, 3,2 % en validation, 18,2 % en test. Les auteurs ont choisi peu d’exemples pour apprendre et beaucoup pour tester.
Premières vérifications
Section intitulée « Premières vérifications »words = train.text.str.split().str.len()print(f"words per request: median {words.median():.0f}, 90% have at most {words.quantile(0.9):.0f}, longest {words.max()}")print("missing or empty texts:", int((train.text.str.strip() == "").sum() + train.text.isna().sum()))print("repeated requests in train:", int(train.text.duplicated().sum()), "| test requests also in train:", int(test.text.isin(train.text).sum()))print("in-scope requests per intent: train", train[train.intent != "oos"].intent.value_counts().unique(), "| validation", validation[validation.intent != "oos"].intent.value_counts().unique(), "| test", test[test.intent != "oos"].intent.value_counts().unique())print("\nThree out-of-scope requests from the training part:")for t in train[train.intent == "oos"].text.head(3): print(" -", t)La sortie :
words per request: median 8, 90% have at most 13, longest 28missing or empty texts: 0repeated requests in train: 0 | test requests also in train: 2in-scope requests per intent: train [100] | validation [20] | test [30]
Three out-of-scope requests from the training part: - how much is an overdraft fee for bank - why are exponents preformed before multiplication in the order of operations - what size wipers does this car takeCe que cela nous apprend. Les demandes sont courtes (médiane de 8 mots). Il n’y a ni valeurs manquantes ni doublons. Seules 2 demandes de test apparaissent aussi dans les données d’entraînement. Chaque intention a le même nombre de demandes.
Les trois demandes hors champ montrent pourquoi la tâche est difficile. « How much is an overdraft fee for bank » ressemble à une demande bancaire. Mais aucune des 15 intentions bancaires ne répond aux questions sur les frais. Une demande hors champ est souvent proche de quelque chose que le robot conversationnel sait faire.
Définir le problème
Section intitulée « Définir le problème »Deux résultats et leurs prix
Section intitulée « Deux résultats et leurs prix »Pour chaque demande, le robot conversationnel fait l’une de deux choses. Il répond avec une intention ou transfère à une personne. Chaque résultat peut être bon ou mauvais :
| La demande est… | Le robot répond correctement | Le robot répond mal | Le robot transfère |
|---|---|---|---|
| dans le champ (une des 150 intentions) | 0 $ US | 4 $ US : une mauvaise réponse | 1,50 $ US : une personne fait ce que le robot aurait pu faire |
| hors champ | (impossible) | 4 $ US : une mauvaise réponse | 0 $ US : le bon endroit |
Ces prix sont des hypothèses qui suivent le tableau des coûts de Larkfield. Une révision par une personne coûte 1,50 $ US (une minute d’un agent), et un message dans la mauvaise file d’attente, 4 $ US. Ici, une mauvaise réponse signifie que le client lit une réponse absurde, redemande et finit souvent par joindre une personne. Une demande hors champ qui arrive à une personne ne coûte rien de plus.
Le carnet nomme le transfert needs_person (besoin d’une personne), comme la destination de Larkfield. Ainsi, l’utilitaire du cours routing.py calcule tous les coûts. Sa cellule utilitaire définit decide(), score() (une ligne du tableau comparatif) et sweep() (tous les seuils).
Combien de demandes sont hors champ?
Section intitulée « Combien de demandes sont hors champ? »Le coût par 1 000 demandes dépend de leur répartition. La vraie répartition de Larkfield restera inconnue jusqu’à la mise en service de l’assistant. Priya fixe donc une hypothèse pour tous les coûts de cette page : 1 demande sur 5 est hors champ. Avec cette hypothèse, « tout transférer à une personne » coûte 1 200 $ US par 1 000 demandes. Cela représente 800 demandes dans le champ à 1,50 $ US chacune. C’est la ligne « sans robot », le nombre que chaque méthode doit battre.
Un petit exemple détaillé
Section intitulée « Un petit exemple détaillé »Voici un exercice avec 6 demandes. Sous le seuil, le robot conversationnel transfère la demande.
| Demande | Vraie intention | Le modèle dit | Confiance | À 0,50 | Coût | À 0,75 | Coût |
|---|---|---|---|---|---|---|---|
| what’s my checking balance | balance | balance | 0,91 | répondre | 0 | répondre | 0 |
| book a table for two at 8 | restaurant_reservation | restaurant_reservation | 0,62 | répondre | 0 | transférer | 1,50 |
| how do i fix my sink | hors champ | schedule_maintenance | 0,34 | transférer | 0 | transférer | 0 |
| transfer 50 $ US to sam | transfer | transfer | 0,48 | transférer | 1,50 | transférer | 1,50 |
| what is the tallest mountain | hors champ | distance | 0,71 | répondre | 4 | transférer | 0 |
| set an alarm for 6 | alarm | reminder | 0,55 | répondre | 4 | transférer | 1,50 |
À 0,50, le total est de 9,50 $ US pour 6 demandes, avec deux mauvaises réponses. À 0,75, le total est de 4,50 $ US. Les deux mauvaises réponses sont devenues des transferts. Mais une bonne réponse aussi : la réservation de table (0,62).
Quand cet échange vaut-il le coût? Supposons que le modèle ait une probabilité p d’avoir raison. Répondre coûte (1 − p) × 4 en moyenne. Transférer une demande dans le champ coûte 1,50. Les deux coûts sont égaux à p = 1 − 1,50 ÷ 4 = 0,625. C’est le seuil de rentabilité, mais seulement si la confiance était une vraie probabilité.
Trois façons de dire « Je ne peux pas aider »
Section intitulée « Trois façons de dire « Je ne peux pas aider » »Description textuelle du diagramme
Un diagramme de flux. À gauche, une nouvelle demande : « can you recommend a good plumber near me ». Des flèches mènent à trois boîtes. Boîte 1, seuil de confiance : le classificateur choisit une des 150 intentions. La règle demande si sa probabilité maximale est sous le seuil. Boîte 2, exemple le plus proche : la règle trouve la demande d’entraînement la plus semblable. Elle demande si la similarité est sous le seuil. Boîte 3, une classe hors champ : le classificateur a aussi appris l’étiquette oos à partir de 100 exemples. La règle demande s’il prédit oos. De chaque boîte, une flèche mène à « Oui : transférer. Je ne peux pas vous aider avec cela. Voici une personne. » Une autre mène à « Non : répondre avec l’intention ».
La troisième façon exige des exemples de demandes hors champ : CLINC150 en a 100 dans ses données d’entraînement. Chaque méthode a son propre seuil, choisi sur les données de validation pour obtenir le coût le plus bas.
La référence de base : un modèle qui répond toujours
Section intitulée « La référence de base : un modèle qui répond toujours »Le premier modèle utilise TF-IDF avec la régression logistique du cours, comme dans Bayes naïf, régression logistique et SVM linéaire. Priya l’entraîne uniquement sur les 15 000 demandes d’entraînement dans le champ. Il n’a donc aucun moyen de dire « aucune de ces intentions ».
from sklearn.feature_extraction.text import TfidfVectorizerfrom sklearn.linear_model import LogisticRegressionfrom sklearn.pipeline import FeatureUnion, make_pipeline
def tfidf_lr(): """The course project's TF-IDF + logistic regression: words and word pairs, plus letter groups.""" words = TfidfVectorizer(ngram_range=(1, 2), min_df=2, sublinear_tf=True, strip_accents="unicode") letters = TfidfVectorizer(analyzer="char_wb", ngram_range=(2, 5), min_df=3, sublinear_tf=True) return make_pipeline(FeatureUnion([("words", words), ("letters", letters)]), LogisticRegression(C=10, max_iter=3000))
in_scope = train[train.intent != "oos"]t0 = time.perf_counter()tfidf = tfidf_lr().fit(in_scope.text, in_scope.intent) # learns the 150 intents onlyprint(f"fitted on {len(in_scope):,} in-scope requests in {time.perf_counter() - t0:.0f} s")p = tfidf.predict_proba(validation.text)tfidf_val = (tfidf.classes_[p.argmax(axis=1)], p.max(axis=1)) # (intent, confidence) for each requesttfidf_ms = ms_per_message(tfidf.predict_proba, list(validation.text))rows_val = [score("everything to a person", validation, [HAND_OFF] * len(validation)), score("TF-IDF + LR, always answers", validation, tfidf_val[0], cpu_cost(tfidf_ms), tfidf_ms)]table(rows_val)La sortie :
fitted on 15,000 in-scope requests in 9 s method in_scope_accuracy oos_recall macro_f1 hand_off_share wrong_answers mistakes_per_1000 run_per_1000 total_per_1000 ms_per_message0 TF-IDF + LR, always answers 0.924 0.0 0.903 0.0 0.261 1043.2 0.0 1043.2 0.561 everything to a person 0.000 1.0 0.000 1.0 0.000 1200.0 0.0 1200.0 NaNCe que cela nous apprend. En validation, le modèle répond correctement à une proportion de 0,924 des demandes dans le champ. Mais son rappel hors champ est de 0. Environ 1 réponse sur 4 est donc mauvaise (wrong_answers, mauvaises réponses, 0,261). Le coût est de 1 043,2 $ US par 1 000, à peine moins cher que sans robot (1 200 $ US).
Dans le tableau, un transfert compte comme une réponse incorrecte pour in_scope_accuracy (exactitude dans le champ). macro_f1 (F1 macro) traite le transfert comme une 151e étiquette. hand_off_share (proportion de transferts) et wrong_answers sont des proportions de toutes les demandes, selon la répartition supposée.
Sur la boîte de réception synthétique de Larkfield, le même modèle atteignait 0,962. Ici, il atteint 0,924 sur les seules demandes dans le champ, avec 150 étiquettes plutôt que 7. Les formulations viennent aussi de nombreuses personnes.
Explorer ce qu’il faut pour décider
Section intitulée « Explorer ce qu’il faut pour décider »Deux questions déterminent si un seuil peut fonctionner. La confiance est-elle juste? Et les demandes hors champ obtiennent-elles une confiance plus faible?
La confiance est-elle juste?
Section intitulée « La confiance est-elle juste? »La confiance est-elle vraie? présentait le tableau de fiabilité. Priya vérifie les demandes de validation dans le champ avec l’utilitaire du cours rt.reliability() :
# Is the confidence true? The reliability table of the in-scope validation requests (Module 8).ins = (validation.intent != "oos").to_numpy()rel, ece = rt.reliability(tfidf_val[1][ins], tfidf_val[0][ins] == validation.intent[ins])print("expected calibration error:", ece)print("median confidence: in scope", round(float(np.median(tfidf_val[1][ins])), 3), "| out of scope", round(float(np.median(tfidf_val[1][~ins])), 3))relLa sortie :
expected calibration error: 0.0967median confidence: in scope 0.944 | out of scope 0.11 bin messages mean_confidence accuracy0 0.0-0.1 29 0.073 0.3101 0.1-0.2 73 0.152 0.4522 0.2-0.3 77 0.256 0.5063 0.3-0.4 85 0.349 0.6714 0.4-0.5 104 0.456 0.7025 0.5-0.6 128 0.550 0.8056 0.6-0.7 153 0.652 0.8957 0.7-0.8 201 0.750 0.9358 0.8-0.9 343 0.858 0.9749 0.9-1.0 1807 0.972 0.996Ce que cela nous apprend. L’erreur d’étalonnage attendue est de 0,097 : pire que sur la boîte de réception de Larkfield (0,050). Le modèle est trop peu sûr de lui. Quand il annonce 0,45, il a raison 70 % du temps; quand il annonce 0,15, il a raison 45 % du temps. Un modèle qui répartit sa confiance sur 150 intentions donne une petite part à chacune. Le seuil de rentabilité de 0,625 ne s’applique donc pas. Le seuil doit venir des coûts.
L’écart entre les demandes dans le champ et hors champ
Section intitulée « L’écart entre les demandes dans le champ et hors champ »La bonne nouvelle : les demandes dans le champ obtiennent une confiance médiane de 0,944, et les demandes hors champ, de 0,11.
- Dans le champ (3 000 demandes)
- Hors champ (100 demandes)
Description textuelle du graphique
Un graphique linéaire avec la confiance de 0 à 1 sur l’axe horizontal, par classes de 0,05. L’axe vertical montre la proportion de chaque groupe. La courbe hors champ commence haut : 19 % des demandes hors champ se situent entre 0 et 0,05. Ensuite, 24 % se situent entre 0,05 et 0,10, et 16 % entre 0,10 et 0,15. Puis elle baisse et reste entre 0 % et 4 % à partir de 0,30. La courbe dans le champ reste sous 3,5 % par classe jusqu’à 0,80. Elle monte à 7 % à 0,85 et à 13 % à 0,90. Elle bondit à 48 % dans la dernière classe, de 0,95 à 1,00. Environ 79 % des demandes hors champ sont sous 0,30. Environ 60 % des demandes dans le champ sont à 0,90 ou plus.
Ce que cela nous apprend. La plupart des demandes hors champ sont sous 0,3, et celles dans le champ, au-dessus de 0,9. Un seuil au milieu sépare la plupart d’entre elles. Le chevauchement a un coût : certaines demandes dans le champ sont basses, et quelques demandes hors champ sont hautes.
Un seuil tiré des coûts
Section intitulée « Un seuil tiré des coûts »Priya essaie tous les seuils de 0,00 à 0,99 sur les demandes de validation et garde le moins cher. Elle suit Décider, faire réviser ou transférer à une personne, avec un seuil plutôt que deux.
thresholds = np.round(np.arange(0.0, 1.0, 0.01), 2)curve_tfidf = sweep("TF-IDF + LR", validation, *tfidf_val, thresholds)best = curve_tfidf.loc[curve_tfidf.total_per_1000.idxmin()]T_TFIDF = float(best.threshold)print(f"lowest cost on validation: hand off below {T_TFIDF:.2f}; in-scope accuracy {best.in_scope_accuracy:.3f}, " f"out-of-scope recall {best.oos_recall:.3f}, {best.total_per_1000:.1f} dollars per 1,000")shown = curve_tfidf.threshold.isin([0.0, 0.1, 0.2, T_TFIDF, 0.4, 0.5, 0.6, 0.7, 0.9])curve_tfidf.loc[shown, ["threshold", "in_scope_accuracy", "oos_recall", "hand_off_share", "wrong_answers", "total_per_1000"]]La sortie :
lowest cost on validation: hand off below 0.55; in-scope accuracy 0.838, out-of-scope recall 0.900, 312.1 dollars per 1,000 threshold in_scope_accuracy oos_recall hand_off_share wrong_answers total_per_10000 0.00 0.924 0.00 0.000 0.261 1043.210 0.10 0.921 0.43 0.094 0.169 689.520 0.20 0.910 0.67 0.161 0.111 484.040 0.40 0.878 0.84 0.238 0.059 342.450 0.50 0.854 0.86 0.270 0.047 334.955 0.55 0.838 0.90 0.295 0.035 312.160 0.60 0.819 0.91 0.314 0.030 319.570 0.70 0.774 0.95 0.363 0.018 331.690 0.90 0.600 0.99 0.516 0.004 493.7- TF-IDF + LR (la référence de base)
- Plongements + LR avec une classe oos (meilleur)
Description textuelle du graphique
Un graphique linéaire avec le seuil de 0 à 1 sur l’axe horizontal. L’axe vertical montre le coût par 1 000 demandes, de 0 à 1 200. La courbe TF-IDF commence à 1 043,2 $ US à 0,00. Elle descend rapidement à 484,0 $ US à 0,20 et à 342,4 $ US à 0,40. Elle atteint son minimum, 312,1 $ US, à 0,55. Elle remonte lentement à 493,7 $ US à 0,90 et à 958,3 $ US à 0,99. La courbe des plongements + LR avec une classe oos commence plus bas, à 551,2 $ US. La classe transfère déjà la moitié des demandes hors champ. Elle atteint son minimum, 212,8 $ US, à 0,62, puis monte à 1 089,6 $ US à 0,99.
Ce que cela nous apprend. Le coût descend rapidement de 1 043,2 $ US à 0,00 jusqu’à son minimum à 0,55 : 312,1 $ US par 1 000. À ce seuil, le robot transfère 90 % des demandes hors champ à une personne. Il répond correctement à une proportion de 0,838 des demandes dans le champ, contre 0,924 auparavant. Le seuil de 0,55 est sous le seuil de rentabilité de 0,625, parce que le modèle manque de confiance.
De 0,40 à 0,70, le coût reste entre 312,1 $ US et 346,9 $ US. Le seuil exact compte moins que le fait d’en avoir un.
Les autres options
Section intitulée « Les autres options »Des plongements avec un classificateur
Section intitulée « Des plongements avec un classificateur »Le deuxième modèle utilise l’ancien modèle de plongement du cours (de Plongements de phrases pour la classification), figé. Chaque demande devient 384 nombres, puis une régression logistique apprend les 150 intentions à partir de ces nombres.
from sentence_transformers import SentenceTransformertorch.set_num_threads(4)# The course's older embedding model, frozen. Each request becomes 384 numbers of length 1.embedder = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2", revision="e8f8c211226b894fcb81acc59f3b34ba3efd5f42", device="cpu")t0 = time.perf_counter()E = {name: embedder.encode(list(df.text), batch_size=128, normalize_embeddings=True) for name, df in [("train", train), ("validation", validation), ("test", test)]}print(f"{sum(len(v) for v in E.values()):,} requests embedded in {time.perf_counter() - t0:.0f} s")ins_train = (train.intent != "oos").to_numpy()frozen = LogisticRegression(C=10, max_iter=3000).fit(E["train"][ins_train], train.intent[ins_train])p = frozen.predict_proba(E["validation"])frozen_val = (frozen.classes_[p.argmax(axis=1)], p.max(axis=1))frozen_ms = ms_per_message(lambda t: frozen.predict_proba(embedder.encode(t, normalize_embeddings=True)), list(validation.text), n=100)curve_frozen = sweep("embeddings + LR", validation, *frozen_val, thresholds)T_FROZEN = float(curve_frozen.loc[curve_frozen.total_per_1000.idxmin(), "threshold"])print("embeddings + LR: lowest cost on validation when it hands off below", T_FROZEN)La sortie :
23,700 requests embedded in 46 sembeddings + LR: lowest cost on validation when it hands off below 0.6La conversion des 23 700 demandes en plongements prend moins d’une minute, une seule fois.
L’exemple le plus proche
Section intitulée « L’exemple le plus proche »La deuxième approche ne nécessite aucun classificateur. Imaginez un commis qui trie le courrier avec une boîte de lettres d’exemple. Si même l’exemple le plus semblable est éloigné, la lettre ne correspond probablement à aucun casier ici.
La similarité cosinus de deux demandes vaut 1 quand elles ont le même sens, et près de 0 sans lien. La règle : trouvez la demande d’entraînement dans le champ qui a la similarité la plus élevée. Si la similarité atteint ou dépasse le seuil, répondez avec son intention. Sinon, transférez à une personne.
# Distance to the nearest example: how similar is the request to the closest in-scope training request?bank, bank_intent = E["train"][ins_train], train.intent[ins_train].to_numpy()
def nearest(X, size=1000): """For each row of X: the intent of the most similar in-scope training request, and the cosine similarity.""" intents, sims = [], [] for i in range(0, len(X), size): S = X[i:i + size] @ bank.T # the vectors have length 1, so this is the cosine similarity intents.append(bank_intent[S.argmax(axis=1)]) sims.append(S.max(axis=1)) return np.concatenate(intents), np.concatenate(sims)
nearest_val = nearest(E["validation"])curve_nearest = sweep("nearest example", validation, *nearest_val, thresholds)T_NEAREST = float(curve_nearest.loc[curve_nearest.total_per_1000.idxmin(), "threshold"])ins = (validation.intent != "oos").to_numpy()print("median similarity to the nearest example: in scope", round(float(np.median(nearest_val[1][ins])), 3), "| out of scope", round(float(np.median(nearest_val[1][~ins])), 3))print("nearest example: lowest cost on validation when it hands off below", T_NEAREST)La sortie :
median similarity to the nearest example: in scope 0.876 | out of scope 0.529nearest example: lowest cost on validation when it hands off below 0.76Ce que cela nous apprend. Les demandes dans le champ ont une similarité médiane de 0,876 avec leur exemple le plus proche; les demandes hors champ, 0,529. Mais le seuil le moins coûteux est élevé (0,76), et cette règle transfère aussi beaucoup de demandes dans le champ.
Une classe hors champ explicite
Section intitulée « Une classe hors champ explicite »La troisième approche donne au modèle les 100 demandes d’entraînement hors champ comme 151e intention, oos. Quand il prédit oos, le robot conversationnel transfère à une personne. Priya essaie cette approche deux fois : seule, puis avec un seuil en plus.
# An explicit class: the 100 out-of-scope training requests become a 151st intent, "oos".oos_tfidf = tfidf_lr().fit(train.text, train.intent)p = oos_tfidf.predict_proba(validation.text)oos_tfidf_val = (oos_tfidf.classes_[p.argmax(axis=1)], p.max(axis=1))oos_frozen = LogisticRegression(C=10, max_iter=3000).fit(E["train"], train.intent)p = oos_frozen.predict_proba(E["validation"])oos_frozen_val = (oos_frozen.classes_[p.argmax(axis=1)], p.max(axis=1))curve_oos_tfidf = sweep("TF-IDF + LR, oos class", validation, *oos_tfidf_val, thresholds)curve_oos_frozen = sweep("embeddings + LR, oos class", validation, *oos_frozen_val, thresholds)T_OOS_TFIDF = float(curve_oos_tfidf.loc[curve_oos_tfidf.total_per_1000.idxmin(), "threshold"])T_OOS_FROZEN = float(curve_oos_frozen.loc[curve_oos_frozen.total_per_1000.idxmin(), "threshold"])rows_val += [score("TF-IDF + LR, oos class, no threshold", validation, decide(*oos_tfidf_val, 0.0), cpu_cost(tfidf_ms), tfidf_ms), score("embeddings + LR, oos class, no threshold", validation, decide(*oos_frozen_val, 0.0), cpu_cost(frozen_ms), frozen_ms)]print("thresholds with the oos class: TF-IDF", T_OOS_TFIDF, "| embeddings", T_OOS_FROZEN)La sortie :
thresholds with the oos class: TF-IDF 0.49 | embeddings 0.62Erreur courante
Une classe hors champ sans seuil
Symptôme : Tomás dit : « Nous avons des exemples de demandes hors champ. Entraînons le modèle avec une classe pour elles, et c’est réglé. » Sans seuil, les plongements + LR avec la classe oos détectent seulement 50 % des demandes de validation hors champ. TF-IDF avec cette classe en détecte 41 %. Le coût est de 551,2 $ US par 1 000 demandes.
Cause : le hors champ n’est pas un seul sujet. C’est le monde entier moins 150 intentions, et 100 exemples ne peuvent pas tout montrer.
Solution : gardez la classe et ajoutez un seuil de confiance. La classe détecte les demandes hors champ qui ressemblent à ses exemples. Le seuil détecte celles qui ne ressemblent à rien de connu du modèle.
Conséquence dans le travail en IA : une démonstration avec des questions étranges connues réussit. Puis de vrais utilisateurs posent des questions sur un nouveau sujet, et le robot répond avec une confiance totale.
Une comparaison équitable avec une seule mesure
Section intitulée « Une comparaison équitable avec une seule mesure »Le tableau utilise le seuil propre à chaque méthode, de la moins coûteuse à la plus coûteuse, par 1 000 demandes.
# Every method at the threshold chosen on validation (the lowest cost), one row each.CHOSEN = {"TF-IDF + LR": (tfidf_val, T_TFIDF, tfidf_ms), "embeddings + LR": (frozen_val, T_FROZEN, frozen_ms), "nearest example": (nearest_val, T_NEAREST, frozen_ms), "TF-IDF + LR, oos class": (oos_tfidf_val, T_OOS_TFIDF, tfidf_ms), "embeddings + LR, oos class": (oos_frozen_val, T_OOS_FROZEN, frozen_ms)}rows_val += [score(f"{m}, hand off below {t:.2f}", validation, decide(*v, t), cpu_cost(ms), ms) for m, (v, t, ms) in CHOSEN.items()]table(rows_val)La sortie :
method in_scope_accuracy oos_recall macro_f1 hand_off_share wrong_answers mistakes_per_1000 run_per_1000 total_per_1000 ms_per_message0 embeddings + LR, oos class, hand off below 0.62 0.884 0.93 0.925 0.271 0.021 212.8 0.0 212.8 11.921 embeddings + LR, hand off below 0.60 0.891 0.90 0.928 0.259 0.028 230.8 0.0 230.8 11.922 TF-IDF + LR, oos class, hand off below 0.49 0.856 0.91 0.899 0.277 0.038 295.9 0.0 295.9 0.563 TF-IDF + LR, hand off below 0.55 0.838 0.90 0.890 0.295 0.035 312.1 0.0 312.1 0.564 nearest example, hand off below 0.76 0.738 0.97 0.798 0.367 0.043 432.1 0.0 432.1 11.925 embeddings + LR, oos class, no threshold 0.951 0.50 0.942 0.103 0.137 551.2 0.0 551.2 11.926 TF-IDF + LR, oos class, no threshold 0.923 0.41 0.912 0.084 0.178 714.8 0.0 714.8 0.567 TF-IDF + LR, always answers 0.924 0.00 0.903 0.000 0.261 1043.2 0.0 1043.2 0.568 everything to a person 0.000 1.00 0.000 1.000 0.000 1200.0 0.0 1200.0 NaNCe que cela nous apprend.
- Chaque seuil aide beaucoup. La pire méthode avec un seuil (l’exemple le plus proche, 432,1 $ US) coûte moins que la meilleure sans seuil (551,2 $ US).
- La meilleure est plongements + LR avec la classe
oos, avec transfert sous 0,62 : 212,8 $ US par 1 000 demandes. Elle combine la classe et le seuil. - Les plongements battent TF-IDF ici. Dans la boîte de réception de Larkfield, TF-IDF gagnait (0,962 contre 0,920). Pour ces demandes courtes et variées, le sens compte plus que les mots exacts.
- L’exemple le plus proche est la méthode la plus faible. Elle détecte le plus de demandes hors champ (0,97), mais répond correctement à seulement 0,738 des demandes dans le champ. Un seul voisin donne un vote bruité; le classificateur utilise les 100 exemples de chaque intention.
Le compromis en image
Section intitulée « Le compromis en image »Une image montre tous les seuils. Chacun donne un point : rappel hors champ à l’horizontale, exactitude dans le champ à la verticale. Plus haut et plus à droite, c’est mieux.
- TF-IDF + LR
- TF-IDF + LR, classe oos (pointillés)
- Plongements + LR (pointillés)
- Plongements + LR, classe oos
- Exemple le plus proche
Description textuelle du graphique
Un graphique en courbes avec le rappel hors champ de 0 à 1 (0 % à 100 %) à l’horizontale et l’exactitude dans le champ de 50 % à 100 % à la verticale. Chacune des cinq courbes commence à son extrémité gauche (seuil 0) et descend vers la droite quand le seuil augmente. TF-IDF + LR commence à 0 % de rappel et 92,4 % d’exactitude, plongements + LR à 0 % et 95,1 %, l’exemple le plus proche à 0 % et 88,0 %. Les deux courbes avec une classe oos commencent plus à droite : TF-IDF à 41 % de rappel et 92,3 %, plongements à 50 % et 95,1 %. À 90 % de rappel, l’exactitude dans le champ est de 90,9 % pour plongements + LR avec la classe oos (la plus élevée), 89,1 % pour plongements + LR, 85,9 % pour TF-IDF avec la classe, 83,8 % pour TF-IDF sans elle, et 80,7 % pour l’exemple le plus proche (la plus basse). Un point marque le seuil choisi, 0,62, à 93 % de rappel et 88,4 % d’exactitude.
Ce que cela nous apprend. Chaque courbe descend vers la droite : détecter plus de demandes hors champ coûte toujours quelques bonnes réponses. À 90 % de rappel hors champ, l’exactitude dans le champ va de 0,909 (plongements avec la classe oos) à 0,807 (l’exemple le plus proche).
Ces courbes reposent sur seulement 100 demandes de validation hors champ, donc une demande représente un point de rappel. Une différence de 2 ou 3 points est du bruit.
La question de Tomás : le LLM hébergé
Section intitulée « La question de Tomás : le LLM hébergé »Priya a donné au modèle hébergé du cours, chat-small, les 150 intentions par domaine et une sortie possible : out_of_scope. Il a répondu en JSON avec une intention et une confiance, comme dans Classification zéro exemple avec un LLM. Ses réponses ont été enregistrées pour un échantillon, donc vous n’avez besoin d’aucune clé. Les échantillons comptent 3 demandes par intention plus 100 hors champ (validation), et 6 par intention plus 200 hors champ (test) : 18,2 % hors champ dans les deux.
# The prompt of the recorded answers: the 150 intents by domain, and a way out.by_domain = "\n".join(f"- {d}: " + ", ".join(sorted(i for i in INTENTS if DOMAIN_OF[i] == d)) for d in sorted(set(DOMAIN_OF.values())))SYSTEM = ("You are the intent classifier of a virtual assistant. Choose exactly one intent from this list " f"(grouped by domain):\n{by_domain}\n" "If the request fits none of these intents, choose out_of_scope. " "Answer in JSON with the intent and your confidence from 0 to 1.")print(SYSTEM[:400], "...")print(f"\n{len(SYSTEM.split())} words in the instructions")La sortie :
You are the intent classifier of a virtual assistant. Choose exactly one intent from this list (grouped by domain):- auto_and_commute: current_location, directions, distance, gas, gas_type, jump_start, last_maintenance, mpg, oil_change_how, oil_change_when, schedule_maintenance, tire_change, tire_pressure, traffic, uber- banking: account_blocked, balance, bill_balance, bill_due, freeze_account, ...
212 words in the instructionsLe carnet Jupyter évalue le LLM à côté des autres méthodes sur le même échantillon. Chaque méthode garde le seuil choisi sur toute la partie validation :
def recorded(mode): """The recorded answers of the hosted LLM (chat-small), one line per request.""" rows = [json.loads(x) for x in open(f"recordings/llm-{mode}.jsonl", encoding="utf-8")] return pd.DataFrame(rows).set_index("message_id")
zero = recorded("zero-shot")filtered = zero.get("filtered", pd.Series(False, index=zero.index)).fillna(False).astype(bool)answered = zero[~filtered] # the provider's content filter refused a few requests: no answer, a hand-offPRICE_IN, PRICE_OUT = 0.10, 0.50 # chat-small, dollars per 1 million tokens (the course's price table)llm_run = (answered.tokens_in.mean() * PRICE_IN + answered.tokens_out.mean() * PRICE_OUT) / 1e6 * 1000llm_ms = answered.latency_s.median() * 1000print(f"zero-shot: {len(zero)} requests, {len(answered)} answers, all valid: {answered.valid.all()}, " f"refused by the content filter: {filtered.sum()} | tokens in {answered.tokens_in.mean():.0f}, " f"out {answered.tokens_out.mean():.0f} | {llm_run:.3f} dollars per 1,000 | median {llm_ms:.0f} ms")
def llm_answers(part): a = zero.loc[part.message_id] return a.intent.replace("out_of_scope", "oos").to_numpy(), a.confidence.to_numpy()
llm_val = llm_answers(validation_sample)curve_llm = sweep("LLM zero-shot", validation_sample, *llm_val, thresholds)T_LLM = float(curve_llm.loc[curve_llm.total_per_1000.idxmin(), "threshold"])vs = validation_sample.indexrows_sample = [score(f"{m}, hand off below {t:.2f}", validation_sample, decide(v[0][vs], v[1][vs], t), cpu_cost(ms), ms) for m, (v, t, ms) in CHOSEN.items()]rows_sample += [score("LLM zero-shot, its own out_of_scope only", validation_sample, decide(*llm_val, 0.0), llm_run, llm_ms), score(f"LLM zero-shot, hand off below {T_LLM:.2f}", validation_sample, decide(*llm_val, T_LLM), llm_run, llm_ms)]table(rows_sample)La sortie :
zero-shot: 1650 requests, 1646 answers, all valid: True, refused by the content filter: 4 | tokens in 1132, out 18 | 0.122 dollars per 1,000 | median 1236 ms method in_scope_accuracy oos_recall macro_f1 hand_off_share wrong_answers mistakes_per_1000 run_per_1000 total_per_1000 ms_per_message0 embeddings + LR, oos class, hand off below 0.62 0.891 0.93 0.919 0.268 0.019 200.0 0.000 200.0 11.921 embeddings + LR, hand off below 0.60 0.898 0.90 0.921 0.256 0.025 216.0 0.000 216.0 11.922 LLM zero-shot, hand off below 0.59 0.913 0.94 0.919 0.231 0.039 218.7 0.122 218.8 1236.003 LLM zero-shot, its own out_of_scope only 0.916 0.94 0.919 0.225 0.042 224.9 0.122 225.0 1236.004 TF-IDF + LR, oos class, hand off below 0.49 0.873 0.91 0.895 0.266 0.036 268.4 0.000 268.4 0.565 TF-IDF + LR, hand off below 0.55 0.853 0.90 0.884 0.287 0.031 282.7 0.000 282.7 0.566 nearest example, hand off below 0.76 0.749 0.97 0.799 0.366 0.034 396.4 0.000 396.4 11.92Ce que cela nous apprend. Tomás a en partie raison. Avec seulement sa propre réponse out_of_scope, le LLM détecte 0,94 des demandes hors champ et répond correctement à 0,916 des demandes dans le champ, sans entraînement. Aucune méthode locale ne fait aussi bien sur les deux mesures. Un seuil sur la confiance qu’il écrit (0,59) change peu de choses. Mais la meilleure méthode locale coûte moins sur cet échantillon : 200,0 $ US contre 218,8 $ US. Elle transfère les demandes dans le champ auxquelles le LLM attribue une mauvaise intention, à 1,50 $ US chacune.
Le LLM entraîne aussi les coûts de Coût par 1 000 messages. Il prend environ 1 236 ms par demande, contre environ 12 ms pour les plongements locaux. Chaque demande part à l’extérieur, et la facture est de 0,12 $ US par 1 000 demandes.
Changer une chose
Section intitulée « Changer une chose »Le seuil venait de deux hypothèses : la part des demandes hors champ et le prix d’une mauvaise réponse.
La part des demandes hors champ
Section intitulée « La part des demandes hors champ »Faites d’abord une prédiction : si davantage de demandes sont hors champ, le meilleur seuil augmente-t-il ou diminue-t-il?
# Change one thing: the share of out-of-scope requests. Choose the threshold again for each share.for share in [0.05, 0.20, 0.40]: c = pd.DataFrame([{"threshold": t, **score("", validation, decide(*oos_frozen_val, t), share=share)} for t in thresholds]) b = c.loc[c.total_per_1000.idxmin()] print(f"{share:.0%} out of scope: hand off below {b.threshold:.2f}, out-of-scope recall {b.oos_recall:.3f}, " f"in-scope accuracy {b.in_scope_accuracy:.3f}, {b.total_per_1000:.1f} dollars per 1,000")La sortie :
5% out of scope: hand off below 0.52, out-of-scope recall 0.910, in-scope accuracy 0.908, 185.5 dollars per 1,00020% out of scope: hand off below 0.62, out-of-scope recall 0.930, in-scope accuracy 0.884, 212.8 dollars per 1,00040% out of scope: hand off below 0.69, out-of-scope recall 0.950, in-scope accuracy 0.859, 216.4 dollars per 1,000Ce que cela nous apprend. Le seuil augmente avec cette part : 0,52 à 5 %, 0,62 à 20 %, 0,69 à 40 %. Avec plus de demandes hors champ, chaque réponse représente un risque plus grand. Il faut donc mesurer cette part durant les premières semaines du véritable assistant, à partir d’un échantillon des transferts.
À vous : une mauvaise réponse coûte plus cher
Section intitulée « À vous : une mauvaise réponse coûte plus cher »Dans une banque, une mauvaise réponse peut déplacer de l’argent. La tâche du carnet fixe son prix à 10 $ US et demande le nouveau seuil le moins coûteux de la meilleure méthode.
Afficher la réponse
# Change one thing: a wrong answer costs 10 dollars, not 4 (a bank, where a wrong answer moves money).COSTS_4 = dict(COSTS)COSTS.update(wrong_queue=10.0, needs_person_sent_to_team=10.0)c = sweep("", validation, *oos_frozen_val, thresholds)threshold_10 = float(c.loc[c.total_per_1000.idxmin(), "threshold"])COSTS.update(COSTS_4)print("a wrong answer costs 10 dollars: hand off below", threshold_10)print(c.loc[c.threshold == threshold_10, ["in_scope_accuracy", "oos_recall", "hand_off_share", "total_per_1000"]].to_string(index=False))a wrong answer costs 10 dollars: hand off below 0.69 in_scope_accuracy oos_recall hand_off_share total_per_1000 0.859 0.95 0.298 312.3La cellule de vérification affiche Check passed: threshold_10 is 0.69. (vérification réussie : threshold_10 vaut 0,69). Le robot devient plus prudent : il transfère sous 0,69 au lieu de 0,62. Il détecte 95 % des demandes hors champ et transfère 29,8 % de toutes les demandes.
Le test final, une seule fois
Section intitulée « Le test final, une seule fois »La partie test contient 5 500 demandes qu’aucune étape n’a utilisées, dont 1 000 hors champ. Priya évalue les seuils choisis une seule fois.
# The test requests, once. Every method and threshold was chosen on validation; nothing changes after this cell.p = tfidf.predict_proba(test.text); tfidf_test = (tfidf.classes_[p.argmax(axis=1)], p.max(axis=1))p = frozen.predict_proba(E["test"]); frozen_test = (frozen.classes_[p.argmax(axis=1)], p.max(axis=1))p = oos_tfidf.predict_proba(test.text); oos_tfidf_test = (oos_tfidf.classes_[p.argmax(axis=1)], p.max(axis=1))p = oos_frozen.predict_proba(E["test"]); oos_frozen_test = (oos_frozen.classes_[p.argmax(axis=1)], p.max(axis=1))nearest_test = nearest(E["test"])TESTS = {"TF-IDF + LR": tfidf_test, "embeddings + LR": frozen_test, "nearest example": nearest_test, "TF-IDF + LR, oos class": oos_tfidf_test, "embeddings + LR, oos class": oos_frozen_test}rows_test = [score("everything to a person", test, [HAND_OFF] * len(test)), score("TF-IDF + LR, always answers", test, tfidf_test[0], cpu_cost(tfidf_ms), tfidf_ms)]rows_test += [score(f"{m}, hand off below {t:.2f}", test, decide(*TESTS[m], t), cpu_cost(ms), ms) for m, (v, t, ms) in CHOSEN.items()]table(rows_test)La sortie :
method in_scope_accuracy oos_recall macro_f1 hand_off_share wrong_answers mistakes_per_1000 run_per_1000 total_per_1000 ms_per_message0 embeddings + LR, oos class, hand off below 0.62 0.866 0.892 0.906 0.276 0.031 271.5 0.0 271.5 11.921 TF-IDF + LR, oos class, hand off below 0.49 0.859 0.907 0.897 0.273 0.039 295.7 0.0 295.7 0.562 embeddings + LR, hand off below 0.60 0.874 0.852 0.906 0.261 0.040 296.4 0.0 296.4 11.923 TF-IDF + LR, hand off below 0.55 0.842 0.913 0.889 0.293 0.034 300.1 0.0 300.1 0.564 nearest example, hand off below 0.76 0.740 0.959 0.797 0.358 0.049 446.9 0.0 446.9 11.925 TF-IDF + LR, always answers 0.928 0.000 0.841 0.000 0.258 1031.1 0.0 1031.1 0.566 everything to a person 0.000 1.000 0.002 1.000 0.000 1200.0 0.0 1200.0 NaNCe que cela nous apprend. Les meilleures et les pires méthodes restent les mêmes qu’en validation; les trois du milieu ont moins de 5 $ US d’écart. Plongements + LR avec la classe oos, avec transfert sous 0,62, coûte 271,5 $ US par 1 000 demandes sur le test (validation : 212,8 $ US). Cette méthode répond correctement à 0,866 des demandes dans le champ et transfère 0,892 des demandes hors champ à une personne. Sans détection, le même type de robot coûte 1 031,1 $ US; sans robot, le coût est de 1 200 $ US.
Qu’est-ce que cela évite? Comptez les mauvaises réponses automatiques par 1 000 demandes : 258 pour le robot qui répond toujours, 31 pour celui choisi. Le prix est de 276 transferts par 1 000 demandes, dont 178 sont hors champ et nécessitent une personne de toute façon.
Les réponses du LLM ont été enregistrées pour un échantillon de 1 100 demandes de test. Sur ce même échantillon :
# The LLM was recorded for a sample of the test requests: compare every method on that same sample.ts = test_sample.indexllm_test = llm_answers(test_sample)rows_test_sample = [score(f"{m}, hand off below {t:.2f}", test_sample, decide(TESTS[m][0][ts], TESTS[m][1][ts], t), cpu_cost(ms), ms) for m, (v, t, ms) in CHOSEN.items()]rows_test_sample += [score("LLM zero-shot, its own out_of_scope only", test_sample, decide(*llm_test, 0.0), llm_run, llm_ms), score(f"LLM zero-shot, hand off below {T_LLM:.2f}", test_sample, decide(*llm_test, T_LLM), llm_run, llm_ms)]table(rows_test_sample)La sortie :
method in_scope_accuracy oos_recall macro_f1 hand_off_share wrong_answers mistakes_per_1000 run_per_1000 total_per_1000 ms_per_message0 embeddings + LR, oos class, hand off below 0.62 0.874 0.915 0.908 0.272 0.029 247.6 0.000 247.6 11.921 LLM zero-shot, hand off below 0.59 0.903 0.960 0.913 0.229 0.048 248.0 0.122 248.1 1236.002 TF-IDF + LR, oos class, hand off below 0.49 0.864 0.945 0.900 0.279 0.030 253.3 0.000 253.3 0.563 LLM zero-shot, its own out_of_scope only 0.907 0.935 0.914 0.222 0.053 264.0 0.122 264.1 1236.004 TF-IDF + LR, hand off below 0.55 0.847 0.940 0.889 0.295 0.028 272.0 0.000 272.0 0.565 embeddings + LR, hand off below 0.60 0.886 0.865 0.910 0.252 0.039 276.4 0.000 276.4 11.926 nearest example, hand off below 0.76 0.744 0.960 0.791 0.356 0.048 438.7 0.000 438.7 11.92Ce que cela nous apprend. Sur cet échantillon, le LLM avec son seuil et la meilleure méthode locale coûtent autant : 248,1 $ US et 247,6 $ US par 1 000 demandes. Le LLM détecte plus de demandes hors champ (0,960 contre 0,915) et répond correctement à plus de demandes dans le champ (0,903 contre 0,874). Mais il donne plus de mauvaises réponses : 4,8 % des demandes contre 2,9 %.
Quatre des 1 650 demandes enregistrées n’ont reçu aucune réponse : le filtre de contenu du fournisseur a refusé des demandes sans danger comme « tell me what the point of life is ». Le carnet les compte comme des transferts. Votre système doit prévoir une voie pour les refus.
Le compromis sur les demandes de test
Section intitulée « Le compromis sur les demandes de test »- TF-IDF + LR (référence de base)
- Plongements + LR, classe oos (méthode choisie)
- Exemple le plus proche
Description textuelle du graphique
Un graphique en courbes comme celui ci-dessus, sur les demandes de test, avec trois courbes. TF-IDF + LR commence à 0 % de rappel et 92,8 % d’exactitude dans le champ, l’exemple le plus proche à 0 % et 88,1 %, et plongements + LR avec une classe oos à 37,9 % et 94,6 %. Les trois descendent vers la droite, et l’exemple le plus proche reste le plus bas. Des points marquent les seuils choisis sur la validation : TF-IDF à 0,55 (91,3 % de rappel, 84,2 % d’exactitude), l’exemple le plus proche à 0,76 (95,9 %, 74,0 %), et plongements avec la classe oos à 0,62 (89,2 %, 86,6 %).
Les courbes de test sont plus lisses : 1 000 demandes hors champ au lieu de 100. Les points choisis se trouvent près du coude de chaque courbe. La méthode choisie détecte un peu moins de demandes hors champ qu’en validation (0,892 contre 0,93). À 90 % de rappel, les deux méthodes avec une classe oos sont presque égales : 0,862 et 0,864 d’exactitude dans le champ. Les plongements avec la classe coûtent toujours le moins au point choisi, 271,5 $ US contre 295,7 $ US, car ils donnent moins de mauvaises réponses (3,1 % des demandes contre 3,9 %). Présentez l’ordre des méthodes, pas l’écart exact.
Ce qui fonctionne encore mal
Section intitulée « Ce qui fonctionne encore mal »Priya lit les erreurs de la méthode choisie, pas seulement leur nombre.
# Where does the chosen method still go wrong on the test requests?chosen_intent, chosen_conf = oos_frozen_testd = decide(chosen_intent, chosen_conf, T_OOS_FROZEN)oos = (test.intent == "oos").to_numpy()missed = test[oos & (d != HAND_OFF)].assign(answered_as=d[oos & (d != HAND_OFF)], confidence=chosen_conf[oos & (d != HAND_OFF)].round(3))print(f"out-of-scope requests answered by the bot: {len(missed)} of {oos.sum()}")handed = test[~oos & (d == HAND_OFF)]print(f"in-scope requests handed to a person: {len(handed)} of {(~oos).sum()}; most often:", handed.intent.value_counts().head(5).to_dict())missed.sort_values("confidence", ascending=False)[["text", "answered_as", "confidence"]].head(8)La sortie :
out-of-scope requests answered by the bot: 108 of 1000in-scope requests handed to a person: 550 of 4500; most often: {'distance': 13, 'reminder_update': 13, 'order': 13, 'change_user_name': 12, 'restaurant_suggestion': 12} text answered_as confidence5223 read my friend's text message text 0.9985138 look up the conversion rate for the euro to dollar exchange exchange_rate 0.9935362 can you order some ointment for me order 0.9875365 please read the text message i just received text 0.9835017 give me the weather forecast for today weather 0.9784605 why can you have the square root of a negative number calculator 0.9734927 can you look at what the oldest age is someone can enlist in the army how_old_are_you 0.9614501 how many prime numbers are there between 0 and 100 calculator 0.961Ce que cela nous apprend. Parmi les 1 000 demandes de test hors champ, 108 reçoivent encore une réponse. Certaines sont proches d’une intention : « Read my friend’s text message » est proche de l’intention text, qui envoie un message. D’autres semblent relever de choix d’étiquetage : « give me the weather forecast for today » est étiquetée hors champ, et le robot répond weather avec une confiance de 0,978. Les données réelles ont des étiquettes limites, comme la boîte de réception de Larkfield dans Guide d’étiquetage.
À l’inverse, 550 des 4 500 demandes dans le champ (12 %) sont transférées à une personne. Aucune intention ne ressort : distance, reminder_update et order perdent chacune 13 de leurs 30 demandes de test.
La deuxième tâche du carnet trouve le domaine qui répond au plus grand nombre de demandes hors champ : utility (27 sur 108), avec des intentions larges comme weather, calculator et text. Recueillez d’abord des exemples hors champ proches des intentions de utility.
Une exécution de bout en bout sur de nouvelles entrées
Section intitulée « Une exécution de bout en bout sur de nouvelles entrées »La dernière étape applique la méthode choisie à huit demandes que nous avons écrites.
# New input: requests that we wrote for this case study (not from CLINC150).new = pd.DataFrame({"text": [ "how much money is in my savings account", "please move 200 dollars from checking to savings", "what's the weather going to be like in boston tomorrow", "can you recommend a good plumber near me", "my card was stolen, someone is using it right now", "what is the meaning of life", "how many calories are in a banana", "write a poem about my cat"]})X = embedder.encode(list(new.text), normalize_embeddings=True)p = oos_frozen.predict_proba(X)new["intent"], new["confidence"] = oos_frozen.classes_[p.argmax(axis=1)], p.max(axis=1).round(3)new["decision"] = decide(new.intent, new.confidence, T_OOS_FROZEN)new["decision"] = np.where(new.decision == HAND_OFF, "hand off to a person", "answer: " + new.decision)newLa sortie :
text intent confidence decision0 how much money is in my savings account balance 0.907 answer: balance1 please move 200 dollars from checking to savings transfer 0.969 answer: transfer2 what's the weather going to be like in boston tomorrow weather 0.947 answer: weather3 can you recommend a good plumber near me directions 0.259 hand off to a person4 my card was stolen, someone is using it right now report_lost_card 0.818 answer: report_lost_card5 what is the meaning of life meaning_of_life 0.986 answer: meaning_of_life6 how many calories are in a banana calories 0.982 answer: calories7 write a poem about my cat text 0.130 hand off to a personCe que cela nous apprend. Le robot répond à six demandes et en transfère deux : le plombier (0,259) et le poème (0,130). « What is the meaning of life » correspond à une intention de conversation informelle, donc le robot répond avec une confiance de 0,986. « My card was stolen, someone is using it right now » va à report_lost_card avec une confiance de 0,818. Mais c’est urgent, et transférer immédiatement les demandes urgentes à une personne est une règle d’affaires (voir « Utilisation responsable » ci-dessous).
La décision de routage
Section intitulée « La décision de routage »Priya écrit à Grace, dans le langage de Grace :
- Méthode : plongements (l’ancien modèle du cours, figé) avec régression logistique. Elle apprend les 150 intentions plus une classe hors champ à partir d’exemples.
- Seuil : transférer quand la classe est
oosou quand la confiance est inférieure à 0,62. - Ce qui va aux personnes : 27,6 % de toutes les demandes sur la partie test, avec 1 demande sur 5 hors champ. Environ 12 % (550 sur 4 500) des demandes dans le champ sont aussi transférées.
- Ce que cela coûte : 271,5 $ US par 1 000 demandes sur le test (212,8 $ US sur la validation). Un robot qui répond toujours coûte 1 031,1 $ US, et tout confier à une personne coûte 1 200 $ US. Le temps de calcul coûte moins de 0,001 $ US par 1 000 demandes.
- Ce que cela évite : les mauvaises réponses automatiques passent de 258 à 31 par 1 000 demandes.
Et pour Tomás : sur l’échantillon de test, le LLM hébergé a détecté autant de demandes hors champ que toute autre méthode (0,960), sans entraînement. C’est la bonne deuxième étape pour les demandes que le modèle local transfère, comme dans Les cascades.
Pour Larkfield : la méthode se transpose, pas les chiffres. Recueillez des exemples hors champ durant les premières semaines de transferts, puis choisissez de nouveau le seuil.
Constats et limites
Section intitulée « Constats et limites »- Un robot qui répond toujours fait à peine mieux qu’aucun robot (1 031,1 $ US contre 1 200 $ US). La détection hors champ apporte l’essentiel de la valeur.
- Combinez deux signaux : la classe et le seuil.
- La confiance était trop faible (ECE 0,097), donc la formule 1 − 1,50 ÷ 4 aurait donné le mauvais seuil.
- Le seuil dépend de la répartition. Des parts hors champ de 5 %, 20 % et 40 % donnent trois seuils. Cette répartition est une réalité d’affaires que vous devez mesurer.
- Bruit. Seulement 100 demandes de validation hors champ ont servi à choisir tous les seuils. Sur le test, les trois méthodes du milieu avaient moins de 5 $ US d’écart.
- Données écrites par des contributeurs en 2019. Les demandes sont courtes, propres et en anglais. Les conversations réelles sont moins propres, et les vraies demandes hors champ changent avec l’actualité.
- Une intention par demande. Un vrai message peut mélanger une demande dans le champ et une autre hors champ. Ce jeu de données ne permet pas de tester cela.
Utilisation responsable
Section intitulée « Utilisation responsable »- Un transfert doit atteindre une personne. « Je ne peux pas vous aider avec ça » sans personne derrière mène à une impasse. Mesurez le temps d’attente des transferts, comme Grace le fait pour sa file d’attente.
- Certaines demandes hors champ sont urgentes. Les demandes de test hors champ de CLINC150 comprennent « how long does it take to call an ambulance ». Ajoutez avant le modèle une règle pour les mots liés à la sécurité, comme la destination
needs_personde Larkfield, et testez-la. - Dites ce que le robot ne peut pas faire. Dites-le clairement au client et conservez la demande pour que la personne n’ait pas à la redemander.
- Les données quittent votre ordinateur seulement avec le LLM. L’option LLM envoie chaque demande à un service externe : vérifiez d’abord vos règles de confidentialité. Les enregistrements contiennent seulement les demandes publiques de CLINC150.
- Attribuez les données à leur source. CC BY 3.0 exige une attribution partout où vous utilisez CLINC150 : utilisez le texte d’attribution dans l’encadré ci-dessus.
Faites-en un projet de portfolio
Section intitulée « Faites-en un projet de portfolio »Cette étude de cas montre que vous pouvez rendre un robot conversationnel plus sûr, pas seulement plus exact. Personnalisez-la en apportant un changement. Essayez d’autres prix, une autre proportion de demandes hors champ (out-of-scope) ou un encodeur réglé finement. Vous pouvez utiliser celui de Régler finement un petit encodeur sur CPU. Ensuite, rendez votre projet public et facile à lire en cinq minutes.
Quoi mettre dans le dépôt :
README.md, la page que les gens lisent en premier (modèle ci-dessous).- Le carnet (notebook) Jupyter, exécuté du début à la fin, avec ses sorties.
- Le graphique du compromis sur les demandes de test, avec le point choisi.
decision.json: la méthode, le modèle et sa révision, le seuil, les coûts, la proportion supposée, le commit (version enregistrée) des données et leur SHA-256.- La source et la licence des données, avec le texte d’attribution. CC BY 3.0 permet de partager les données en citant leur source, mais un lien et une somme de contrôle suffisent.
Un modèle de README :
# When should a chatbot hand off? Out-of-scope detection on CLINC150
## ProblemA virtual assistant with 150 intents gets requests it was not built for. A wronganswer costs about $4, an unneeded hand-off $1.50. Assume 1 request in 5 is out of scope.
## Data and licenceCLINC150 (Larson et al., 2019), 23,700 requests, 150 intents + out of scope,CC BY 3.0, https://github.com/clinc/oos-eval (commit 828f809). Rows numbered; no other changes.
## ApproachThree ways: a confidence threshold, the nearest example (cosine similarity ofsentence embeddings), an explicit out-of-scope class. Each threshold chosen onvalidation by expected cost. A hosted LLM replayed on a sample.
## Results (test, used once)Embeddings + LR with an oos class, hand off below 0.62: $271.5 per 1,000(always answer: $1,031.1; everyone to a person: $1,200). In-scope accuracy 0.866,out-of-scope recall 0.892. Wrong answers per 1,000: 258 -> 31.
## LimitsCrowd-written English requests from 2019; 100 out-of-scope validation examples;the threshold depends on the assumed share and prices.Comment le décrire en entrevue, en deux phrases : « J’ai créé un détecteur hors champ pour un assistant à 150 intentions, puis choisi son seuil de transfert selon les coûts d’une mauvaise réponse et d’un transfert; sur des données de test réservées, il a réduit les mauvaises réponses automatiques de 258 à 31 par 1 000 demandes. J’ai comparé un seuil de confiance, une règle de l’exemple le plus proche et une classe hors champ, puis montré que le meilleur seuil change avec la proportion de demandes hors champ. »
Pour aller plus loin :
- Étalonnez le classificateur avec la mise à l’échelle par température (temperature scaling), présentée dans Demander une décision, pas du texte. Vérifiez si le seuil le moins coûteux se rapproche de 0,625.
- Construisez la cascade : le modèle local décide quand il est sûr, le LLM réexécuté examine les transferts, une personne reçoit le reste.
- Écrivez cinq demandes hors champ sur la sécurité et vérifiez si votre règle de sécurité les détecte avant le modèle.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Si la confiance était une probabilité réelle, le point d'équilibre serait 1 − 1,50 ÷ 4 = 0,625. Pourtant, le seuil le moins coûteux pour TF-IDF sur les données de validation est plus bas. Expliquez pourquoi et dites comment vous le vérifieriez.
Afficher la réponse
Un modèle qui répartit sa probabilité entre 150 intentions manque d’assurance : sa confiance est inférieure à sa probabilité réelle d’avoir raison. Quand TF-IDF indique 0,45, il a raison environ 70 % du temps; son erreur d’étalonnage attendue est d’environ 0,10. La formule du point d’équilibre suppose une confiance réelle, donc elle donne un seuil trop élevé. La recherche du coût minimal évalue chaque seuil avec les résultats réels. Pour vérifier, lisez le tableau de fiabilité ou étalonnez le modèle. Voyez ensuite si le seuil le moins coûteux se rapproche de 0,625.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Tomás entraîne une classe hors champ explicite sur 100 exemples et dit que le problème est résolu. Que lui montrez-vous et qu'ajoutez-vous?
Afficher la réponse
Montrez-lui son rappel des demandes hors champ sans seuil. Les plongements (embeddings) + LR avec cette classe détectent seulement environ la moitié des demandes hors champ de validation. Le hors champ comprend tout ce qui dépasse les 150 intentions, et 100 exemples ne peuvent pas le couvrir. Ajoutez un seuil de confiance : il détecte les demandes qui ne ressemblent à rien de ce que le modèle connaît. Ensemble, les deux approches formaient la méthode la moins coûteuse sur les données de validation et de test.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Prédisez : l'assistant de Larkfield entre en service. Un échantillon de conversations réelles montre que 40 % des demandes sont hors champ, plutôt que 20 %. Le seuil monte-t-il ou baisse-t-il, et pourquoi?
Afficher la réponse
Il monte. Avec plus de demandes hors champ, une mauvaise réponse devient plus probable à chaque niveau de confiance. Le robot conversationnel devrait répondre seulement quand il est plus sûr et transférer davantage de demandes. Sur les données de validation, le seuil de la meilleure méthode est passé de 0,52 à 5 % à 0,62 à 20 %, puis à 0,69 à 40 %. Cette proportion est un fait d’affaires : mesurez-la dans les demandes réelles, puis choisissez de nouveau le seuil.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Un robot conversationnel qui répond toujours se trompe sur chaque demande hors champ. Ici, il coûtait 1 031,1 $ US par 1 000 demandes de test, contre 1 200 $ US sans robot conversationnel.
- Trois façons de transférer : un seuil de confiance, la distance à l’exemple le plus proche et une classe hors champ explicite. Chaque seuil provenait des coûts sur les données de validation. Une mauvaise réponse coûte 4 $ US, un transfert coûte 1,50 $ US, et une demande sur cinq est hors champ.
- Mesurez ensemble l’exactitude des demandes dans le champ et le rappel des demandes hors champ, puis tracez le compromis. Détecter davantage de demandes hors champ fait toujours perdre certaines bonnes réponses.
- La meilleure méthode était les plongements + LR avec la classe
ooset un seuil de 0,62. Sur les données de test, elle coûtait 271,5 $ US par 1 000 demandes. Les mauvaises réponses sont passées de 258 à 31 par 1 000 demandes. - Le seuil change avec la proportion de demandes hors champ et le prix d’une mauvaise réponse. Le LLM réexécuté détectait bien les demandes hors champ et convient comme deuxième étape.
Ensuite, un autre jeu de données réel : des demandes en anglais et en français, avec seulement quelques étiquettes par intention.
Leçon suivante : Trier des demandes avec peu d'étiquettes