Aller au contenu
English

Plongements de phrases pour la classification

  • Leçon 13
  • 35 min
  • Module 4 : Plongements et petits modèles réglés finement

Où nous en sommes

Dans le module 3, nous avons acheminé les messages avec TF-IDF, qui compte les mots. Pour lui, « my parcel never came » et « the delivery did not arrive » sont donc différents. Dans cette leçon, un modèle de plongement de phrase donne des nombres semblables aux phrases semblables, en anglais et en français. Nous entraînons ensuite un classificateur simple sur ces nombres.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité
Leçon 13 sur 37 · Classification et routage de textes : envoyer chaque message au bon endroitPlongements de phrases pour la classification
Aperçu du cours

Ce que vous saurez faire

Donnez au routeur une compréhension du sens, pas seulement des mots. Un modèle de plongement de phrase (sentence embedding) transforme chaque message en une liste de nombres. Les messages au sens semblable reçoivent ainsi des nombres semblables, en anglais et en français. Un classificateur simple utilise ces nombres pour acheminer les messages.

Carnet JupyterFaites cette leçon dans un carnet JupyterColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter contient toutes les cellules de code, les tâches et les vérifications de cette leçon. Il compare deux paires de phrases, calcule les plongements des 8 000 messages et entraîne une régression logistique sur ces plongements. Il la compare ensuite à TF-IDF en anglais et en français. Ses cellules de préparation installent les paquets et téléchargent les données et le modèle (environ 470 Mo, une seule fois). Aucune préparation locale n’est donc nécessaire. Environ 35 minutes.

Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Rien si vous utilisez le carnet sur Colab ou Kaggle. Ce module ne change aucun fichier de votre projet larkroute.
  • Pour exécuter plutôt le carnet sur votre ordinateur, ouvrez-le dans Jupyter avec Python 3.12. Sa première cellule installe les paquets nécessaires.

Testé sur macOS (puce Apple) avec Python 3.12, sentence-transformers 6.2.0, PyTorch 2.15.0 (CPU) et scikit-learn 1.9.1, dans Jupyter. Colab, Kaggle et Windows n’ont pas été testés.

Au bureau de poste, un nouveau commis trie les lettres selon les mots sur l’enveloppe. « Parcel » va au comptoir des colis. Un matin, une lettre dit « the delivery did not arrive ». Elle ne contient pas « parcel », alors le nouveau commis la met de côté. Une commis plus expérimentée la prend et va directement au comptoir des colis. Elle ne cherche pas des mots identiques. Elle comprend ce que le client veut dire.

La lettre suivante est en français : « mon colis n’est jamais arrivé ». Le nouveau commis ne connaît pas le français. La commis expérimentée la lit et l’envoie au même comptoir. Pour elle, la langue n’a pas d’importance : le sens est le même.

Le modèle TF-IDF du module 3 est le nouveau commis. Cette leçon donne au routeur quelque chose de plus proche de la commis expérimentée.

TF-IDF attribue un nombre à chaque mot ou paire de mots. Pour lui, deux messages se ressemblent seulement s’ils ont des mots en commun. Voici trois messages courts :

Message Destination
A my parcel never came delivery
B the delivery did not arrive delivery
C my refund never came returns_refunds

A et B veulent dire la même chose, mais n’ont aucun mot en commun. A et C ont trois mots en commun (« my », « never », « came »), mais relèvent de deux équipes différentes. Nous comparons deux vecteurs TF-IDF avec la similarité cosinus, que la prochaine section explique. Elle vaut 1 quand deux messages pointent dans la même direction et 0 quand ils n’ont rien en commun. Avec les variables TF-IDF du projet, A et B obtiennent 0,000 : rien en commun. A et C obtiennent 0,586.

TF-IDF juge donc le message sur le remboursement plus proche du premier message sur le colis que l’autre message sur le colis. Avec 6 000 messages étiquetés, cela nuit rarement : le modèle voit assez de façons de dire « parcel ». Cela nuit davantage avec moins d’étiquettes, de nouvelles formulations ou une langue moins présente dans les données d’entraînement.

Un plongement de phrase est une liste de nombres qu’un modèle calcule pour une phrase entière. Le modèle a appris, à partir de nombreuses paires de phrases, à donner des nombres semblables aux phrases de sens semblable. Un « plongement » donne à chaque phrase une place, un point, dans un espace à plusieurs dimensions. Les phrases semblables occupent des places proches.

Le modèle de cette leçon est paraphrase-multilingual-MiniLM-L12-v2. Publié en 2021, il compte 118 millions de paramètres, utilise la licence Apache-2.0 et donne 384 nombres par message. Sa fiche indique qu’il fonctionne dans plus de 50 langues : une phrase anglaise et sa traduction française reçoivent des nombres semblables. Nous l’appelons le modèle plus ancien dans ce module, car une leçon ultérieure le compare à un modèle plus récent.

384 nombres, c’est trop pour vérifier à la main. Voici donc la même idée avec deux nombres par message. Ces nombres sont inventés pour l’exemple. Imaginez que le premier signifie « sur la livraison » et le second « sur l’argent ».

Message Nombres Longueur
A : my parcel never came (3, 1) √(3² + 1²) = √10 = 3,162
B : the delivery did not arrive (4, 1) √(4² + 1²) = √17 = 4,123
C : my refund never came (1, 3) √(1² + 3²) = √10 = 3,162
Trois plongements inventés, avec deux nombres chacun. A et B pointent presque dans la même direction; C pointe ailleurs. La similarité cosinus mesure l'angle entre deux flèches.
Description textuelle du graphique

Trois flèches partent de (0, 0). A va jusqu’à (3, 1) et B jusqu’à (4, 1). Les deux sont proches de l’axe horizontal « sur la livraison », avec un très petit angle entre elles. C va jusqu’à (1, 3), près de l’axe vertical « sur l’argent ». L’angle entre A et C est beaucoup plus grand que celui entre A et B.

Le produit scalaire multiplie les nombres à la même position, puis additionne les résultats. Nous le divisons ensuite par le produit des deux longueurs. Ainsi, un long message avec de grands nombres ne paraît pas plus semblable uniquement à cause de sa taille. Le résultat est la similarité cosinus : le cosinus de l’angle entre les deux flèches. Elle vaut 1 quand les flèches pointent dans la même direction.

Paire Produit scalaire Produit des longueurs Similarité cosinus
A et B 3 × 4 + 1 × 1 = 13 3,162 × 4,123 = 13,04 13 ÷ 13,04 = 0,997
A et C 3 × 1 + 1 × 3 = 6 3,162 × 3,162 = 10 6 ÷ 10 = 0,600
B et C 4 × 1 + 1 × 3 = 7 4,123 × 3,162 = 13,04 7 ÷ 13,04 = 0,537

A et B pointent presque dans la même direction. C est plus éloigné des deux. C’est ce que nous voulons pour le routage : les deux messages de livraison ensemble, celui de remboursement à part. Le cours RAG : créer une IA qui utilise vos données utilise la même mesure pour trouver des documents.

Passons au vrai modèle, avec ses 384 nombres. La bibliothèque sentence-transformers donne à chaque message ses nombres. Avec normalize_embeddings=True, chaque plongement a une longueur de 1. La similarité cosinus est donc simplement le produit scalaire :

from sentence_transformers import SentenceTransformer
embedder = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
revision="e8f8c211226b894fcb81acc59f3b34ba3efd5f42", device="cpu")
e = embedder.encode(["my parcel never came", "the delivery did not arrive", "my refund never came"],
normalize_embeddings=True)
print(e.shape, round(float(e[0] @ e[1]), 3), round(float(e[0] @ e[2]), 3), round(float(e[1] @ e[2]), 3))
Paire TF-IDF Modèle de plongement plus ancien
A et B (même sens, aucun mot commun) 0,000 0,697
A et C (mots communs, autre équipe) 0,586 0,668
B et C 0,000 0,496

Le code affiche (3, 384) et les trois nombres. Le vrai modèle place A plus près de B que de C, comme prévu, mais de peu : 0,697 contre 0,668. TF-IDF donnait l’ordre inverse (0,000 contre 0,586). Le plongement reconnaît le sens, mais pas parfaitement : les phrases de même structure obtiennent aussi des nombres élevés. Le carnet montre un deuxième cas. « The delivery is late » et sa traduction française « la livraison est en retard » obtiennent 0,953. « The delivery is late » et « the payment is late », qui ont trois mots en commun, obtiennent 0,804.

Pour acheminer les messages, la similarité ne suffit pas : il faut une décision. Le plan comporte deux étapes :

  1. Le modèle de plongement transforme chaque message en 384 nombres. Il reste figé : ses paramètres ne changent pas, et il n’apprend pas à partir des étiquettes de Larkfield.
  2. Une régression logistique, du même type que dans le module 3, apprend à partir des 6 000 messages d’entraînement étiquetés. Elle reçoit 384 nombres par message, au lieu de 38 615 nombres TF-IDF.
from sklearn.linear_model import LogisticRegression
E_train = embedder.encode(train["text"].tolist(), batch_size=64, normalize_embeddings=True)
E_test = embedder.encode(test["text"].tolist(), batch_size=64, normalize_embeddings=True)
clf = LogisticRegression(C=10, max_iter=3000).fit(E_train, train["route"])
rt.show([rt.score("embeddings MiniLM + logistic regression", test, clf.predict(E_test))])

batch_size=64 signifie que le modèle lit 64 messages à la fois. Calculer les plongements des 8 000 messages prend environ une minute sur le processeur d’un portable. La régression logistique s’entraîne ensuite en une fraction de seconde, car 384 nombres par message, c’est très peu.

Avant de continuer, faites une prédiction : les plongements dépasseront-ils TF-IDF (0,962), maintenant que le routeur comprend le sens?

Méthode (2 000 messages de test) Exactitude Anglais Français Coût par 1 000
TF-IDF + régression logistique 0,962 0,966 0,952 296,0 $ US
Plongements, modèle plus ancien + régression logistique 0,920 0,931 0,896 779,0 $ US

Dans cette boîte de réception, les plongements figés perdent, en anglais comme en français. Ils font environ deux fois plus d’erreurs, et ces erreurs coûtent plus du double. Ils ratent 2 des 12 prises de contrôle de compte (TF-IDF en rate 1), ce qui explique une grande partie du coût. L’exécution du carnet, avec un réglage légèrement différent, donne 0,918.

C’est une vraie surprise, et la raison compte. TF-IDF apprend les mots exacts des 6 000 messages de Larkfield, y compris les habitudes de cette boîte de réception. Le modèle figé ne connaît que le sens général. Une ligne droite dans ses 384 nombres sépare moins bien sept destinations que 38 615 variables basées sur les mots. Rappelez-vous aussi que cette boîte de réception est plus facile qu’une vraie : ses mots sont réguliers. Avec de vrais messages de clients et davantage de formulations différentes, l’équilibre peut changer. L’étude de cas Router des questions bancaires compare les méthodes sur de vraies données.

Pouvons-nous voir pourquoi? Chaque message a 384 nombres, mais une image a deux dimensions. L’ACP (analyse en composantes principales) trouve les deux directions où les points sont les plus dispersés. Elle place ensuite chaque message selon ces deux directions.

Un nuage de 2 000 petits points, un par message de test, colorés selon la destination. Les messages sur les produits forment un groupe à gauche. Les messages sur les comptes forment un groupe en bas. Les messages delivery, returns_refunds et orders se chevauchent dans un grand groupe en haut, au centre. Une ellipse rouge pointillée le marque. Les points billing et needs_person se trouvent près de ce groupe. Les messages mal acheminés portent un anneau foncé; la plupart sont dans l'ellipse.
Les 2 000 messages de test, placés selon les deux directions principales de leurs plongements (modèle plus ancien). Les messages sur les produits et les comptes sont à part. Livraisons, retours et commandes se chevauchent, et la plupart des erreurs de routage sont là.
Description textuelle du diagramme

Le graphique montre 2 000 points, un par message de test, en sept couleurs, une par destination. Les messages sur les produits forment un groupe distinct à gauche. Les messages sur les comptes forment un groupe distinct en bas. Les messages delivery, returns_refunds et orders se chevauchent dans un grand nuage en haut, au centre. Une ellipse rouge pointillée le marque. Les messages billing et needs_person se trouvent près de ce nuage. Les messages que le classificateur sur les plongements a mal acheminés sont plus gros et portent un anneau foncé. La plupart sont dans l’ellipse. Les deux directions conservent 16 % de la dispersion des 384 nombres; l’image cache donc beaucoup d’information. Deux points qui se touchent ici peuvent être éloignés dans l’espace complet.

L’image montre le problème d’un coup d’œil. Un colis en retard, un retour de colis et une modification de commande parlent tous d’une commande, d’un colis et d’une date. Leur sens général est proche. Pour Larkfield, ils relèvent de trois équipes. Le modèle figé ne connaît pas les frontières de Larkfield; seul le petit classificateur qui le suit les apprend.

Interprétez l’image avec prudence. Deux dimensions ne conservent que 16 % de la dispersion. L’espace réel sépare donc les destinations mieux que l’image le laisse croire. Utilisez ce type d’image pour savoir où regarder, pas pour mesurer.

Les plongements savent quand même des choses que TF-IDF ignore. Le carnet compte les messages de test en français que le modèle de plongement achemine correctement et TF-IDF incorrectement : il y en a 9. Le modèle de plongement sait que « colis » est proche de « parcel ». Il l’a appris à partir de paires de phrases traduites, pas des étiquettes de Larkfield.

Les plongements aident surtout dans trois cas :

  • Peu d’étiquettes. Avec 8 messages étiquetés par destination, TF-IDF a vu trop peu de mots. La prochaine leçon mesure cet effet.
  • Nouvelles formulations et autres langues. Une paraphrase ou une langue peu présente dans les données d’entraînement se retrouve quand même près des bons messages.
  • Un point de départ pour apprendre. Dans Régler finement un petit encodeur sur CPU, le modèle entier apprend à partir des étiquettes. Ce modèle est le meilleur sur cette boîte de réception.

Un modèle de plongement est beaucoup plus lourd que TF-IDF :

TF-IDF + régression logistique Modèle de plongement plus ancien + régression logistique
Taille sur disque environ 2,1 Mo (le pipeline entraîné, compressé) 470,6 Mo (le modèle) + un tout petit classificateur
Temps par message, un à la fois environ 0,1 ms 6,8 ms
Temps par message, 64 à la fois 2,9 ms
Temps d’entraînement environ 3 secondes environ une minute pour les plongements, puis moins d’une seconde

Au tarif du cours de 0,05 $ US par heure de CPU, même 6,8 ms par message coûtent bien moins d’un cent par 1 000 messages. Ici, le coût important est celui des erreurs : 779,0 $ US par 1 000 contre 296,0 $ US.

  • Utilisez-les avec peu d’étiquettes, plusieurs langues ou des messages dont la formulation change souvent. Utilisez-les aussi pour obtenir rapidement un deuxième avis en complément de TF-IDF.
  • Ne les utilisez pas seuls avec des milliers de messages étiquetés dans un domaine régulier, comme ici. TF-IDF est moins cher, plus rapide et plus exact sur cette boîte de réception.
  • Leur coût : un modèle de 470 Mo en mémoire et environ 7 ms par message. Fixez une révision précise pour le téléchargement, afin que les nombres ne changent pas à votre insu.
  1. Ouvrez le carnet depuis l’encadré Faites cette leçon dans un carnet Jupyter en haut de cette page.
  2. Exécutez les cellules de préparation. La cellule des données se termine par Ready: 10000 messages (6000 train, 2000 validation, 2000 test), all synthetic. (prêt : 10 000 messages, dont 6 000 d’entraînement, 2 000 de validation et 2 000 de test, tous synthétiques).
  3. Dans la section 1, écrivez votre prédiction. Exécutez ensuite la cellule. Vous voyez 0.953 pour la paire française et 0.804 pour la paire avec des mots en commun.
  4. Dans la section 2, exécutez la cellule qui calcule les plongements de la boîte de réception. Elle affiche (6000, 384) (2000, 384).
  5. Dans la section 3, lancez la comparaison. Les plongements obtiennent 0.918, TF-IDF 0.962.
  6. Dans la section 5, lancez le test de vitesse. Traiter un message à la fois est plusieurs fois plus lent que les traiter par lots.

Dans la section 4 du carnet, comptez les messages de test en français que le modèle de plongement achemine correctement et TF-IDF incorrectement. Placez le nombre dans fr_better. Faites d’abord une prédiction : plus ou moins de 20?

Afficher la réponse
fr = (test["language"] == "fr").to_numpy()
emb_right = clf.predict(E_test) == test["route"].to_numpy()
tfidf_right = tfidf_model.predict(test["text"]) == test["route"].to_numpy()
fr_better = int((fr & emb_right & ~tfidf_right).sum())
print(fr_better)
9

Neuf des 589 messages de test en français. Les plongements aident pour quelques messages, mais perdent pour un plus grand nombre. Comptez aussi dans l’autre sens (TF-IDF correct, plongements incorrects) : vous obtenez un nombre beaucoup plus grand.

Erreur courante

Rapide dans le carnet, lent dans le routeur

Symptôme : Tomás mesure le modèle de plongement dans un carnet. Il calcule les plongements de 2 000 messages en environ 6 secondes et écrit : « 3 ms par message ». Dans le service de routage, chaque message prend plus du double du temps.

Cause : le carnet a calculé les plongements de 64 messages à la fois. Le modèle utilise alors bien le processeur, et le temps se répartit sur 64 messages. Le service de routage reçoit un message à la fois et assume donc le coût complet pour chacun. Sur notre portable, c’est 6,8 ms contre 2,9 ms.

Solution : mesurez le temps par message comme le service fonctionnera. Traitez un message à la fois, sur le même type d’ordinateur, après une phase de préparation. Présentez les deux nombres et indiquez lequel correspond au service. La section 5 du carnet le fait.

Conséquence dans le travail en IA : une vitesse mesurée par lots donne l’impression qu’un modèle est moins cher et plus rapide qu’en production. Tous les temps et coûts par message du tableau comparatif de ce cours sont mesurés un message à la fois.

Vérifiez votre compréhension

Avec les nombres inventés A = (3, 1) et C = (1, 3), calculez la similarité cosinus étape par étape. Que dit le résultat sur les deux messages?

Afficher la réponse

Le produit scalaire est 3 × 1 + 1 × 3 = 6. Les longueurs sont chacune √10 = 3,162, donc leur produit est 10. La similarité cosinus est 6 ÷ 10 = 0,600. A et B ont obtenu 0,997. A est donc beaucoup plus proche de B (l’autre message de livraison) que de C (le message de remboursement). Pourtant, A et C partagent trois mots. C’est le rôle d’un plongement (embedding) : un sens semblable donne une direction semblable, quels que soient les mots.

Vérifiez votre compréhension

Les plongements figés avec régression logistique atteignent 0,920 sur les messages de test de Larkfield, et TF-IDF atteint 0,962. Tomás dit : « Les plongements comprennent le sens, donc le test doit être faux. » Que répondez-vous?

Afficher la réponse

Le test est correct; c’est l’attente qui est fausse. Le modèle de plongement est figé : il connaît le sens général, pas les frontières entre les équipes de Larkfield. Selon le sens général, un colis en retard, un colis retourné et une commande modifiée sont voisins. L’image en deux dimensions montre que ces trois destinations se chevauchent. Seul le petit classificateur ajouté au modèle apprend les frontières, à partir de 384 nombres. TF-IDF apprend à partir de 38 615 variables de mots tirées des 6 000 messages de Larkfield. Ces mots sont réguliers dans cette boîte de réception synthétique. Les plongements aident quand il y a peu d’étiquettes et de nouvelles formulations. Dans cette boîte de réception avec 6 000 étiquettes, TF-IDF gagne.

Vérifiez votre compréhension

Le service doit répondre à un message à la fois. Quel temps par message inscrivez-vous au tableau comparatif pour le modèle de plongement : 2,9 ms ou 6,8 ms? Pourquoi?

Afficher la réponse

6,8 ms, mesurées un message à la fois. 2,9 ms est le temps obtenu quand le modèle lit 64 messages ensemble et partage le travail entre eux. Le service ne reçoit pas 64 messages à la fois, donc il n’atteint jamais cette vitesse. Un tableau qui mélange les temps par lot et les temps individuels compare les méthodes de façon injuste.

Récapitulatif

  • Un plongement de phrase (sentence embedding) est une liste de nombres pour une phrase entière (ici 384). Les phrases au sens semblable obtiennent des nombres semblables, même entre l’anglais et le français.
  • La similarité cosinus compare deux plongements : le produit scalaire divisé par le produit des deux longueurs. Avec les nombres inventés, A et B obtiennent 0,997, et A et C obtiennent 0,600. TF-IDF donne 0 à A et B, car ils ne partagent aucun mot.
  • Un modèle de plongement figé, avec une régression logistique ajoutée, atteint 0,920 sur cette boîte de réception (anglais 0,931, français 0,896, 779,0 $ US par 1 000). TF-IDF atteint 0,962 (296,0 $ US). Le modèle figé connaît le sens, pas les frontières de Larkfield.
  • L’image en deux dimensions (ACP) montre que les livraisons, les retours et les commandes se chevauchent. La plupart des erreurs de destination se trouvent là. Elle conserve seulement une partie de la dispersion : utilisez-la pour observer, pas pour mesurer.
  • Mesurez la vitesse un message à la fois : 6,8 ms, pas 2,9 ms par lots.

Les plongements n’ont pas gagné avec 6 000 étiquettes. Ensuite, nous retirons la plupart des étiquettes pour voir quelle méthode fonctionne encore avec 8 messages étiquetés par destination.

Leçon suivante : Peu d'étiquettes avec des plongements