Aller au contenu
English

Des modèles de plongement plus récents

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

Où nous en sommes

Nous avons utilisé un modèle de plongement et réglé finement un encodeur. De nouveaux modèles de plongement apparaissent tous les quelques mois, chacun avec un meilleur score au classement. Dans cette leçon, nous comparons un ancien et un nouveau petit modèle multilingue sur nos propres messages anglais et français.

Leçon 16 sur 37 · Classification et routage de textes : envoyer chaque message au bon endroitDes modèles de plongement plus récents
Aperçu du cours

Ce que vous saurez faire

Déterminez si un nouveau modèle est meilleur pour vos messages, avant de changer quoi que ce soit. Un modèle plus récent, plus petit et mieux classé peut moins bien router les messages de votre boîte de réception. Un petit test sur vos propres données répond à la question en quelques minutes.

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 charge les deux modèles et mesure leur vitesse, un message à la fois. Il réexécute leurs scores sur les messages de test, trouve les messages qui expliquent l’écart et lance votre propre petit test. Ses cellules de configuration installent les paquets et téléchargent les données et les deux modèles (environ 470 Mo et 200 Mo). Vous n’avez donc rien à configurer localement. Environ 30 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 30 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Rien si vous utilisez le carnet. Ce module ne modifie aucun fichier de votre projet larkroute.

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

Le bureau de poste a besoin d’un nouveau commis. Un candidat a les meilleurs résultats à l’examen postal national. L’examen contient des centaines de questions sur plusieurs types de courrier : lettres, colis, formulaires, adresses étrangères. L’autre candidat est plus âgé et a des résultats moyens.

Le gestionnaire fait une chose simple. Il donne aux deux candidats les vraies lettres reçues un matin dans son bureau. Le candidat aux meilleurs résultats est plus lent et fait plus d’erreurs avec les adresses locales. L’examen mesurait quelque chose de réel, mais pas le travail de ce bureau.

Les modèles de plongement passent aussi ce genre d’examen. On les appelle des bancs d’essai, et leurs résultats figurent dans des classements (leaderboards) publics.

Le problème : un nouveau modèle tous les quelques mois

Section intitulée « Le problème : un nouveau modèle tous les quelques mois »

L’ancien modèle de ce module a été publié en 2021. Depuis, de nombreux modèles de plongement plus récents sont apparus. Chaque nouvelle fiche de modèle présente un tableau où le nouveau modèle dépasse les anciens. Tomás lit un de ces tableaux et dit : « Changeons de modèle. Le nouveau est plus récent, plus petit et meilleur. »

Est-il meilleur pour Larkfield? Le classement ne peut pas le dire. Un classement fait la moyenne des résultats d’un modèle sur de nombreuses tâches publiques, dans plusieurs langues. Il peut s’agir de trouver des documents pour une question, de comparer des phrases ou de regrouper des textes. Votre boîte de réception représente une seule tâche, avec vos destinations, vos formulations et votre mélange de langues. Un modèle peut avoir la meilleure moyenne et quand même être moins bon pour votre tâche.

La règle est courte : un classement indique quels modèles essayer; vos propres données de test indiquent quel modèle utiliser.

Le classement le plus utilisé pour les plongements (embeddings) est MTEB (Massive Text Embedding Benchmark). Il regroupe les tâches en familles : récupération (trouver des documents), classification, regroupement (clustering) et similarité. Vérifiez trois choses avant de faire confiance à un score :

  1. Quelle famille de tâches? Un score de récupération renseigne peu sur le routage des messages.
  2. Quelles langues? Une moyenne sur 50 langues renseigne peu sur les messages de soutien en français.
  3. Mesuré sur quel matériel? Les vitesses sur un gros GPU renseignent peu sur un CPU qui répond à un message à la fois.

Ensuite, exécutez le même test que pour chaque méthode. Utilisez les mêmes messages d’entraînement, les mêmes 2 000 messages de test et le même tableau des coûts. Traitez l’anglais et le français comme des tranches distinctes.

Un tout petit exemple : mêmes messages, nombres différents

Section intitulée « Un tout petit exemple : mêmes messages, nombres différents »

Les deux modèles de cette leçon donnent des nombres différents aux mêmes messages. Voici les trois messages de la première leçon :

Paire Ancien modèle (2021) Nouveau modèle (2026)
A et B : my parcel never came / the delivery did not arrive 0,697 0,909
A et C : my parcel never came / my refund never came 0,668 0,875
B et C : the delivery did not arrive / my refund never came 0,496 0,828

Les deux modèles placent A plus près de B. Mais le nouveau modèle donne un nombre élevé à chaque paire (de 0,828 à 0,909). L’ancien les espace davantage (de 0,496 à 0,697). Est-ce que 0,875 signifie « similaire »? Pour le nouveau modèle, c’est une valeur assez basse; pour l’ancien, elle serait très élevée. On ne peut pas comparer un nombre d’un modèle à celui d’un autre : chaque modèle a son propre espace. Seul le résultat sur votre tâche peut être comparé.

Ancien modèle Nouveau modèle
Nom paraphrase-multilingual-MiniLM-L12-v2 granite-embedding-97m-multilingual-r2
Publication 2021 2026
Paramètres 118 millions 97 millions
Nombres par message 384 384
Couches 12 12
Table de mots 250 037 jetons 180 000 jetons
Entrée la plus longue 512 jetons 32 768 jetons
Taille sur disque 470,6 Mo 194,9 Mo
Licence Apache-2.0 Apache-2.0

Les deux licences permettent un usage commercial. Le nouveau modèle est plus petit surtout parce que sa table de mots est plus petite : 180 000 jetons (tokens) plutôt que 250 037. Il lit des textes beaucoup plus longs. Cela aide pour les longs documents, mais ne change rien pour les messages de soutien d’environ 28 mots.

Sa fiche présente une affirmation du fournisseur, que nous n’avons pas vérifiée par des mesures. Elle indique un score de 60,3 aux tâches de récupération multilingues de MTEB. Elle le décrit comme « le meilleur score de récupération parmi les modèles de plongement multilingues ouverts de moins de 100 millions de paramètres ». La fiche mesure sa vitesse sur un gros GPU, en documents par seconde. La tâche de Larkfield n’est pas la récupération. Son routeur fonctionne sur un CPU, un message à la fois.

Priya exécute le même pipeline avec les deux modèles. Elle calcule les plongements des 6 000 messages d’entraînement et entraîne une régression logistique avec les mêmes réglages pour les deux. Ensuite, elle évalue les 2 000 messages de test.

Avant de regarder, faites une prédiction : le nouveau modèle gagnera-t-il sur l’exactitude, le français ou la vitesse?

  • Ancien modèle (2021)
  • Nouveau modèle (2026)
Exactitude sur les données de test par langue, plongements figés + régression logistique. Le nouveau modèle est moins bon dans les deux langues, et l'écart est plus grand en français. L'axe commence à 80 %.
Description textuelle du graphique

Un graphique à quatre colonnes, sur un axe allant de 80 % à 100 %. L’ancien modèle obtient 93,1 % sur les 1 411 messages de test anglais et 89,6 % sur les 589 messages français. Le nouveau modèle obtient 92,1 % en anglais et 86,8 % en français. Il est en retard de 1,0 point en anglais et de 2,8 points en français.

  • TF-IDF + régression logistique
  • Ancien modèle (2021)
  • Nouveau modèle (2026), chargé avec des nombres sur 16 ou 32 bits
Temps par message, un à la fois, sur le CPU d'un portable (4 fils d'exécution). Chargé tel qu'il est stocké, avec des nombres sur 16 bits, le nouveau modèle prend environ quatre fois plus de temps que l'ancien. Chargé avec des nombres sur 32 bits, il prend environ le même temps.
Description textuelle du graphique

Un graphique à quatre colonnes. TF-IDF avec régression logistique prend environ 0,1 ms par message. L’ancien modèle de plongement prend 6,8 ms. Le nouveau, chargé avec ses nombres stockés sur 16 bits (le réglage par défaut), prend 26,9 ms. Le même modèle chargé avec des nombres sur 32 bits prend 7,0 ms. C’est environ le même temps que l’ancien modèle, avec la même exactitude.

Méthode (2 000 messages de test) Exactitude F1 macro Prises de contrôle de compte détectées needs_person détectés Coût par 1 000 ms par message
Plongements, ancien modèle + LR 0,920 0,924 10 sur 12 92 sur 99 779,0 $ US 6,8
Plongements, nouveau modèle + LR 0,906 0,904 11 sur 12 84 sur 99 895,0 $ US 26,9 (7,0 sur 32 bits)

Sur cette boîte de réception, le nouveau modèle est moins bon dans presque toutes les colonnes. Il fait 189 erreurs contre 159, et son exactitude en français passe de 0,896 à 0,868. Il manque 15 des 99 messages qui nécessitent une personne; l’ancien modèle en manque 7. Il détecte une prise de contrôle de compte de plus, soit 11 sur 12. C’est bien, mais pas assez pour compenser le reste : le coût total est de 895,0 $ US par 1 000 messages, contre 779,0 $ US.

Pourquoi? Nous ne le savons pas avec certitude, et nous n’avons pas mesuré les raisons. Le nouveau modèle a été entraîné surtout pour la récupération et les longs documents. L’ancien a été entraîné pour donner des nombres similaires aux paraphrases, ce qui ressemble aux besoins du routage. Mais une explication plausible n’est pas une mesure. La mesure, c’est le tableau.

Quand la bibliothèque a chargé le nouveau modèle, elle a affiché un avertissement. Celui-ci indiquait que le modèle était chargé avec torch.bfloat16 sur CPU. Selon le CPU, l’inférence pouvait être beaucoup plus lente qu’avec torch.float32. bfloat16 permet de stocker chaque nombre sur 16 bits plutôt que 32. Cela réduit de moitié la taille du fichier du modèle, et de nombreux CPU calculent lentement avec ce format.

Les 26,9 ms du tableau comparatif utilisaient ce réglage par défaut. Nous avons rechargé le modèle avec des nombres sur 32 bits, avec model_kwargs={"dtype": torch.float32}, puis mesuré à nouveau. Résultat : 7,0 ms par message, environ comme l’ancien modèle. L’exactitude n’a pas changé : 0,906, et le coût est resté à 895,0 $ US par 1 000 messages. Donc, « le nouveau modèle est quatre fois plus lent » était faux. Un réglage de chargement était lent, pas le modèle.

Lisez les avertissements qu’une bibliothèque affiche, et mesurez avec les réglages que vous utiliserez. Le nouveau modèle reste le moins exact sur cette boîte de réception; il n’est pas le plus lent.

Les deux modèles ne font pas simplement les mêmes erreurs, avec quelques erreurs de plus pour l’un. Le carnet compte 72 messages de test que seul le nouveau modèle route correctement, et 102 que seul l’ancien route correctement. Les modèles sont en désaccord dans les deux sens. Si un nouveau modèle est « un peu moins bon » en moyenne, il peut rester meilleur sur une tranche importante pour vous. Par exemple, les prises de contrôle de compte. Examinez les tranches avant de décider.

Un test complet avec 6 000 étiquettes prend du temps, alors un test rapide est tentant. Le carnet entraîne les deux modèles avec seulement 100 messages étiquetés par destination (700 en tout). Il évalue ensuite les mêmes 2 000 messages de test :

Étiquettes pour l’entraînement Ancien modèle Nouveau modèle
100 par destination (700) 0,836 0,859
les 6 000 0,920 0,906

Avec 700 étiquettes, le nouveau modèle gagne, en anglais (0,878 contre 0,851) et en français (0,813 contre 0,798). Avec 6 000 étiquettes, l’ancien gagne. Les deux résultats sont réels. Nous n’avons pas mesuré pourquoi l’ordre change. Ce qui compte, c’est qu’il change selon la quantité de données d’entraînement.

Testez avec la quantité de données étiquetées que vous utiliserez vraiment. Si vous aurez 6 000 étiquettes, un test avec 700 peut vous faire choisir le mauvais modèle.

Changer de modèle de plongement ne consiste jamais seulement à changer un nom dans le code :

  • Recalculez les plongements. Chaque plongement stocké, pour l’entraînement et la recherche, vient de l’ancien modèle et doit être recalculé.
  • Réentraînez. Le classificateur a appris à partir des nombres de l’ancien modèle; il n’a aucun sens avec les nouveaux nombres. Le cas d’échec ci-dessous montre ce qui arrive si vous oubliez.
  • Retestez. Sur vos données de test, par tranche, avec le tableau des coûts et le temps mesuré un message à la fois.
  • Fixez la version. Utilisez une révision fixe, comme ce cours le fait pour chaque modèle, afin qu’il ne puisse pas changer sans vous.
  • Essayez-le quand un nouveau modèle est performant dans votre famille de tâches (ici la classification, pas la récupération) et vos langues. Sa taille doit convenir à votre matériel, et sa licence à votre usage.
  • Changez de modèle seulement s’il gagne sur vos messages de validation et vos tranches. Le gain doit compenser le recalcul des plongements, le réentraînement et les nouveaux tests.
  • Ne changez pas de modèle parce qu’il est plus récent, plus petit ou premier dans un classement. Sur cette boîte de réception, le modèle de 2021 est meilleur que celui de 2026.

De nouveaux modèles continuent d’arriver. Gardez vos données de test et votre script de comparaison prêts. Ainsi, évaluer chaque nouveau candidat prendra une heure, plutôt qu’un projet entier.

  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 configuration.
  3. Dans la section 1, écrivez votre prédiction. Puis chargez les deux modèles. L’ancien a 117,653,760 paramètres et le nouveau en a 97,441,152.
  4. Dans la section 2, mesurez la vitesse. Le nouveau modèle est plusieurs fois plus lent avec son chargement initial. Exécutez ensuite la cellule suivante, qui le charge avec des nombres sur 32 bits : il est environ aussi rapide que l’ancien.
  5. Dans la section 3, réexécutez les scores enregistrés. L’ancien obtient 0.92, le nouveau 0.906.
  6. Dans la section 5, exécutez votre propre petit test avec 100 étiquettes par destination. Cela prend environ deux minutes. Le nouveau modèle gagne ce test : 0.859 contre 0.836.

À votre tour : les messages qui expliquent l’écart

Section intitulée « À votre tour : les messages qui expliquent l’écart »

Dans la section 4 du carnet, comptez les messages de test que seul le nouveau modèle route correctement (new_only). Comptez aussi ceux que seul l’ancien route correctement (old_only). Faites d’abord une prédiction : est-ce que new_only est près de zéro?

Afficher la réponse
truth = test["route"].to_numpy()
old_right = old["prediction"].to_numpy() == truth
new_right = new["prediction"].to_numpy() == truth
new_only = int((new_right & ~old_right).sum())
old_only = int((old_right & ~new_right).sum())
print(new_only, old_only)
72 102

La différence, 102 − 72 = 30, est l’écart entre 189 et 159 erreurs. Mais il y a 174 messages pour lesquels un seul des deux modèles a raison. « Moins bon en moyenne » cache de nombreux messages pour lesquels le nouveau modèle a raison.

Erreur courante

Un nouveau modèle sous un ancien classificateur

Symptôme : Tomás remplace le nom de l’ancien modèle par celui du nouveau dans le code. Le service démarre, chaque message reçoit une destination et aucune erreur n’apparaît. Une semaine plus tard, l’équipe de Grace dit que la plupart des messages arrivent dans la mauvaise file d’attente.

Cause : la régression logistique a été entraînée sur les nombres de l’ancien modèle. Les deux modèles donnent 384 nombres, donc les dimensions correspondent et rien n’échoue. Mais le nombre 17 du nouveau modèle signifie autre chose que le nombre 17 de l’ancien. Nous avons inséré cette erreur et l’avons mesurée. Le même classificateur obtient 0,920 sur les plongements de l’ancien modèle et 0,178 sur ceux du nouveau. Il envoie 1 550 des 2 000 messages de test à product.

Solution : traitez le modèle de plongement et le classificateur comme une seule unité avec une seule version. Quand le modèle de plongement change, recalculez les plongements, réentraînez et retestez. Enregistrez le nom et la révision du modèle de plongement avec le classificateur. Refusez de charger un classificateur avec un autre modèle de plongement.

Conséquence dans le travail en IA : les erreurs de « mêmes dimensions » sont silencieuses. Un modèle, un index ou un cache construit avec un modèle de plongement puis utilisé avec un autre donne des résultats absurdes. Il les donne avec une confiance totale. Gérez leurs versions ensemble.

Vérifiez votre compréhension

La fiche du nouveau modèle annonce le meilleur score de récupération multilingue dans sa catégorie de taille. Donnez trois raisons pour lesquelles ce score ne prédit pas son score sur la boîte de réception de Larkfield.

Afficher la réponse

Premièrement, la famille de tâches : le score concerne la récupération (trouver des documents pour une question), tandis que le routage est une classification. Deuxièmement, les données : c’est une moyenne de nombreux jeux de données publics et de nombreuses langues. Elle ne représente pas les destinations, les formulations ni le mélange d’anglais (1 411 messages de test) et de français (589) de Larkfield. Troisièmement, les conditions : la fiche mesure la vitesse sur un gros processeur graphique (GPU), en documents par seconde. Le routeur de Larkfield utilise un processeur central (CPU) et traite un seul message à la fois. L’ancien modèle prend 6,8 ms; le nouveau prend 7,0 ms avec des nombres sur 32 bits. Avec les nombres sur 16 bits utilisés pour son stockage, le nouveau prend 26,9 ms. Une affirmation du fournisseur justifie un test, mais ne constitue pas un résultat.

Vérifiez votre compréhension

Sur cette boîte de réception, le nouveau modèle obtient 0,906 et l'ancien, 0,920. Le nouveau détecte 11 des 12 prises de contrôle de comptes; l'ancien en détecte 10. Changeriez-vous de modèle? Utilisez le tableau des coûts.

Afficher la réponse

Non. Le coût total du nouveau modèle est plus élevé : 895,0 $ US par 1 000 messages, contre 779,0 $ US. La prise de contrôle supplémentaire qu’il détecte vaut 200 $ US. Cela ne compense pas les 30 erreurs supplémentaires au total ni les moins bons résultats en français (0,868 contre 0,896). Il manque aussi 15 messages needs_person (besoin d’une personne), contre 7, chacun valant 40 $ US. Si les prises de contrôle comptent le plus, mieux vaut un modèle qui détecte les 12. C’est le cas de l’encodeur réglé finement (12 sur 12, 103,0 $ US).

Vérifiez votre compréhension

Les deux modèles produisent 384 nombres par message. Tomás veut garder le classificateur entraîné et changer seulement le modèle de plongement. Que se passe-t-il, et que doit-il faire à la place?

Afficher la réponse

Rien ne provoque d’erreur, car les dimensions correspondent. Mais le classificateur a appris ses poids à partir des nombres de l’ancien modèle. Chaque nombre a un sens différent dans l’espace du nouveau modèle, donc les destinations deviennent presque aléatoires. Dans notre test construit, le score du classificateur est passé de 0,920 à 0,178. Il doit recalculer les plongements des messages d’entraînement avec le nouveau modèle et entraîner un nouveau classificateur. Ensuite, il le teste sur les données de test et leurs tranches. Il gère ensemble les versions du modèle de plongement et du classificateur.

Récapitulatif

  • Un classement (leaderboard) comme MTEB présente une moyenne de nombreuses tâches publiques. Il indique quels modèles essayer, pas lequel utiliser. Vérifiez la famille de tâches, les langues et le matériel associés à un score.
  • Sur cette boîte de réception, le nouveau modèle (2026, 97 millions de paramètres) est moins bon que l’ancien (2021, 118 millions). Il obtient 0,906 contre 0,920, et 0,868 contre 0,896 en français. Il coûte 895,0 $ US contre 779,0 $ US par 1 000 messages.
  • Plus récent ne veut pas dire meilleur. Mesurez l’exactitude par tranche, le coût et le temps par message, en traitant un seul message à la fois. Lisez les avertissements de la bibliothèque : avec ses nombres stockés sur 16 bits, le nouveau modèle prend 26,9 ms par message. Avec des nombres sur 32 bits, il prend 7,0 ms.
  • Un test rapide peut mener au mauvais choix : avec 100 étiquettes par destination, le nouveau modèle gagne (0,859 contre 0,836). Testez avec la quantité de données que vous utiliserez réellement.
  • Changer de modèle exige de recalculer les plongements, d’entraîner et de tester à nouveau. Un classificateur entraîné sur les nombres d’un modèle produit des résultats incohérents sur ceux d’un autre, sans signaler d’erreur.
  • Fixez chaque modèle à une révision précise et identifiez les chiffres de sa fiche comme des affirmations du fournisseur.

Tous les modèles vus jusqu’ici ont appris à partir d’exemples étiquetés. Ensuite, nous classerons les messages avec les noms des destinations seulement, sans un seul message étiqueté.

Leçon suivante : Classification zéro exemple sans LLM