Guide

Sentence Transformers : des vecteurs sans quitter votre machine

Sentence Transformers calcule des embeddings en local, sans service externe : modèles denses, creux et de scoring, choix, fine-tuning, matériel, coûts et pièges.

L'équipe CodeWorlds13 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article9

Sentence Transformers est une bibliothèque qui calcule des embeddings en local, sur votre propre matériel, sans appeler de services externes. Elle est née dans le monde universitaire ; aujourd'hui, c'est l'équipe derrière la plus grande collection de modèles ouverts qui la développe, et le projet a déménagé sous leur dépôt.

L'alternative aux services payants est ici réelle et pas seulement théorique. Les modèles d'embeddings ouverts sont aujourd'hui assez bons pour que, sur une recherche dans des documents d'entreprise, l'écart avec les fournisseurs commerciaux soit souvent faible, tandis que le coût par token disparaît complètement.

Le prix, c'est le matériel, le temps passé à choisir un modèle et l'entretien. Je décris plus bas quand ce calcul devient positif, car la réponse n'est pas évidente et dépend de l'échelle.

Trois types de modèles

La bibliothèque prend en charge trois classes de modèles aux usages différents, et les distinguer est rentable, car les contenus en ligne les mélangent souvent.

Un modèle dense transforme le texte en un vecteur de quelques centaines de nombres, chacun signifiant quelque chose que l'on ne sait pas nommer. C'est l'embedding classique, familier des services commerciaux, et le point de départ de la plupart des usages.

Python
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("intfloat/multilingual-e5-large")

vectors = model.encode_document(chunks)
query = model.encode_query("What is the notice period?")

La séparation entre l'embedding des documents et celui des requêtes, visible dans ces deux méthodes, compte plus qu'il n'y paraît. Certains modèles attendent un préfixe avant le texte, l'un pour un document et l'autre pour une question, et l'omettre dégrade la précision d'une façon invisible sans mesure. Ces méthodes l'ajoutent elles-mêmes, mais seulement quand le modèle déclare les préfixes dans son fichier de configuration pour cette bibliothèque. Le modèle de l'exemple ci-dessus ne les déclare pas, donc les marqueurs de document et de requête doivent y être passés à la main, via le paramètre qui accepte un préfixe. Avant de supposer que cela se fait automatiquement, vérifiez sur la fiche du modèle si les préfixes y sont indiqués.

Un modèle creux (sparse) renvoie un vecteur avec un nombre énorme de dimensions, presque toutes à zéro. Cela paraît étrange et a un sens concret : les dimensions correspondent à des mots, donc un tel vecteur combine la recherche par le sens et la correspondance exacte des mots. Il résout un problème qui, avec des embeddings ordinaires, demande de construire une recherche hybride à partir de deux index séparés.

Un modèle de scoring de paires juge l'adéquation entre une requête et un document en voyant les deux à la fois. Il donne des résultats nettement meilleurs que la comparaison de vecteurs, au prix du temps, car il doit s'exécuter pour chaque paire séparément. D'où le montage en deux étapes : une recherche vectorielle peu coûteuse renvoie cinquante candidats, et ce modèle choisit les cinq meilleurs.

Ce troisième type est le plus sous-estimé en pratique. L'ajouter à une recherche existante représente généralement une douzaine de lignes de code et le plus grand saut de précision atteignable sans changer le modèle d'embeddings ni la façon de découper les documents. Essayez-le avant le fine-tuning, car il coûte une fraction de ce travail.

Choisir un modèle

C'est la décision où l'on perd le plus facilement une semaine, donc l'aborder avec méthode est rentable.

Commencez par la langue. Les modèles entraînés sur l'anglais seul se comportent mal sur des documents dans d'autres langues, même quand ils obtiennent de bons scores dans les benchmarks. Un modèle multilingue est ici le point de départ plutôt qu'un compromis.

Ensuite la taille. Un modèle de quelques centaines de millions de paramètres tourne sur un processeur ordinaire à une vitesse raisonnable, alors qu'un modèle plusieurs fois plus gros demande une carte graphique pour traiter des archives en un temps raisonnable. L'écart de précision est souvent plus petit que ne le suggère l'écart de taille.

Enfin la mesure sur vos propres données. Prenez cinquante vraies questions avec les réponses attendues, indexez la même collection avec trois modèles et comparez la fréquence à laquelle le bon document est arrivé dans les cinq premiers. Ce travail prend un après-midi et tranche plus qu'une semaine passée à lire des benchmarks.

Traitez les classements publics comme une liste de candidats plutôt que comme une réponse. Ils mesurent des tâches moyennées sur de nombreux domaines, et vos documents appartiennent à un domaine précis.

Le fine-tuning sur vos données

C'est ici que se trouve un avantage que les services commerciaux n'offrent pas du tout : la possibilité d'apprendre votre domaine au modèle.

Le gain peut être important avec un vocabulaire spécialisé. Un modèle généraliste ne sait pas que dans votre entreprise deux termes différents veulent dire la même chose, ni qu'une abréviation utilisée dans la documentation renvoie à un produit précis. Un fine-tuning sur quelques milliers de paires question-réponse issues de vos archives lui apprend ces liens.

Python
from sentence_transformers import SentenceTransformerTrainer, losses

loss = losses.MultipleNegativesRankingLoss(model)

trainer = SentenceTransformerTrainer(
    model=model,
    train_dataset=training_set,
    loss=loss,
)
trainer.train()

La forme la plus simple et généralement suffisante des données d'entraînement est constituée de paires : une question et le fragment qui contient la réponse. Vous n'avez besoin d'aucun exemple négatif, car la fonction de perte traite les autres paires d'un lot comme des négatifs.

L'origine de ces paires est une question plus difficile que l'entraînement lui-même. Trois sources fonctionnent en pratique : l'historique des requêtes de recherche avec ce sur quoi les utilisateurs ont cliqué, les tickets de support avec leurs réponses, et des paires générées par un modèle de langage à partir de vos documents et relues par une personne.

Une réserve qui mérite d'être dite : le fine-tuning n'a de sens que lorsque vous avez mesuré qu'un modèle généraliste est insuffisant. C'est plusieurs jours de travail, alors qu'améliorer le découpage ou ajouter une étape de notation des candidats donne généralement plus pour moins.

Performances et matériel

Le calcul pour les embeddings locaux diffère de celui d'un service, car le coût est fixe plutôt que variable.

Un processeur suffit pour des requêtes qui arrivent une par une. Un modèle de taille moyenne calcule un vecteur pour une courte requête en quelques dizaines de millisecondes, ce qui dans une application typique disparaît dans le temps de réponse de tout le reste.

Une carte graphique devient nécessaire pour l'indexation. Traiter cent mille fragments sur un processeur prend des heures, sur une carte des minutes. Si vous le faites une fois, des heures sont acceptables. Si les archives sont mises à jour chaque jour, une carte se rentabilise vite.

Trois réglages font la plus grande différence sans changer de modèle. Le premier est le traitement par lots plutôt qu'un par un, car un modèle calcule de nombreux textes ensemble bien moins cher qu'en séquence. Le deuxième est une précision numérique plus basse, qui divise à peu près le temps par deux pour une perte pratiquement imperceptible. Le troisième est de trier les fragments par longueur avant le traitement, pour que chaque lot contienne des textes de taille similaire.

Faites aussi attention à la mémoire. Un modèle chargé l'occupe pendant toute la durée de vie du processus, donc le charger dans une fonction qui démarre à chaque requête est coûteux et lent. Chargez-le une fois au démarrage de l'application et gardez-le.

L'exploiter en production

La bibliothèque calcule des vecteurs et son rôle s'arrête là, donc le reste du système est à vous. Quelques points méritent d'être planifiés avant qu'un modèle n'arrive en production.

Le premier est la façon dont le modèle est exposé. Le charger dans chaque processus de l'application signifie autant de copies en mémoire que de processus, et avec un modèle de deux gigaoctets cela cesse vite de tenir. Un montage plus raisonnable est un service distinct qui calcule les vecteurs, interrogé par le reste de l'application, avec une seule copie du modèle en mémoire.

Le deuxième est l'échauffement. Le premier appel après le chargement prend nettement plus de temps que les suivants, car les tampons ne s'allouent et les chemins de calcul ne se compilent qu'à ce moment. Exécuter une requête synthétique au démarrage supprime ce pic, qui frappe sinon le premier utilisateur après chaque déploiement.

Le troisième est le versionnement. Consignez à côté de l'index le nom du modèle, sa version et les réglages avec lesquels les vecteurs ont été produits. Sans cela, ajouter des documents après une mise à jour de la bibliothèque ou après avoir récupéré une version plus récente du modèle donne des entrées incomparables avec le reste, et le symptôme est simplement de moins bons résultats, sans erreur.

Le quatrième est le téléchargement du modèle au démarrage. Par défaut, la bibliothèque récupère les poids sur le réseau à la première utilisation, ce qui est un problème dans un environnement sans accès à internet ou lors d'une montée en charge soudaine. Intégrez le modèle à l'image du conteneur ou montez-le depuis un volume, et le démarrage devient prévisible.

Ce que cela coûte vraiment

Comparer avec un service payant vaut la peine d'être fait sur des chiffres, car l'intuition trompe ici dans les deux sens.

Côté service, la facture est simple : nombre de tokens fois le tarif. Indexer un million de fragments de cinq cents tokens, ce sont cinq cents millions de tokens, soit de dix à quelques dizaines de dollars une fois, plus quelques centimes pour les requêtes.

Côté auto-hébergé, le coût comporte trois parties, dont deux sont omises dans ce genre de comparaisons. La première est la machine, de quelques dizaines à quelques centaines de dollars par mois selon que vous avez besoin d'une carte graphique. La deuxième est le temps pour choisir un modèle et le déployer, soit plusieurs jours de travail. La troisième est l'entretien : mises à jour, supervision et réaction quand quelque chose cesse de fonctionner.

Il en découle un seuil simple. Pour une indexation unique de petites archives, le service l'emporte nettement. À fort volume régulier, l'auto-hébergement commence à gagner, car le coût cesse de croître avec le trafic. Avec des données qui ne peuvent pas quitter l'entreprise, le calcul est sans objet, puisqu'il n'y a tout simplement pas d'alternative.

Chiffrez-le une fois, sur vos propres chiffres, plutôt que de vous fier à la croyance que le local est toujours moins cher. Dans une application typique avec quelques milliers de requêtes par jour, la facture d'embeddings chez un fournisseur est souvent inférieure au coût d'une machine.

Sentence Transformers face aux alternatives

OptionPoint fortPoint faibleÀ choisir quand
Sentence TransformersLes données restent chez vous, aucun coût par token, fine-tuningMatériel, entretien et choix du modèle vous incombentDonnées sensibles ou fort volume régulier
OpenAIDémarrage le plus simple, prévisibilitéLe coût croît avec le volume, les données sortentUn prototype et des volumes modérés
Voyage AIEspace partagé au sein d'une famille de modèlesUn fournisseur de plus à facturerUn projet où le modèle peut changer
CohereImages et texte dans un même espacePlus cher sur les imagesDocuments avec mise en page visuelle

La première ligne gagne dans deux situations. La première est celle de données qui ne peuvent pas quitter l'entreprise, et il n'y a alors rien à discuter. La seconde est un fort volume régulier, où le coût par token s'accumule mois après mois alors qu'une machine coûte la même chose quel que soit le trafic.

Elle perd sur un prototype et à petite échelle. Monter un modèle, le choisir et le maintenir est un travail qui, sur un millier de documents, coûte plus que quelques dollars d'appels d'API.

Erreurs courantes

La première est d'omettre les préfixes qu'un modèle exige. Certains modèles attendent des marqueurs différents pour un document et pour une requête, et les méthodes prévues pour chacun les ajoutent automatiquement seulement quand le modèle les a consignés dans sa configuration. Avec un modèle qui ne les déclare pas, c'est à vous de les fournir.

La deuxième est de charger le modèle à chaque requête. Cela prend des secondes et occupe de la mémoire, alors que le charger une fois au démarrage du processus suffit.

La troisième est de traiter les fragments un par un. Les lots sont plusieurs fois plus rapides et c'est l'une des rares optimisations qui ne coûte rien.

La quatrième est de choisir un modèle d'après un classement sans tester sur vos propres données. Les benchmarks mesurent des tâches moyennées, et vos documents appartiennent à un domaine.

La cinquième est de faire du fine-tuning avant de mesurer si un modèle généraliste suffit. Améliorer le découpage donne généralement plus pour une fraction de l'effort.

La sixième est de mélanger dans un seul index des vecteurs de modèles différents, ou de versions différentes du même modèle. Ils ne sont pas comparables et la recherche renvoie alors des résultats arbitraires.

La septième est de télécharger les poids du modèle depuis le réseau au démarrage du service. Dans un environnement sans accès à internet, ou lors d'une augmentation soudaine du nombre d'instances, cela se termine par un échec de démarrage au pire moment.

FAQ

Les modèles locaux égalent-ils les services payants ?

Sur la recherche dans des documents texte, l'écart est souvent faible, surtout après un fine-tuning sur vos propres données. Sur les tâches qui exigent de gérer des images ou la plus haute précision dans un domaine étroit, les services commerciaux restent en tête. La mesure sur votre propre jeu de questions tranche.

De quel matériel a-t-on besoin ?

Un processeur suffit pour servir des requêtes, car une requête unique se calcule en quelques dizaines de millisecondes. Une carte graphique aide pour indexer de grandes collections, où elle transforme des heures en minutes, et se rentabilise vite sur des archives mises à jour chaque jour.

En quoi un modèle de scoring de paires diffère-t-il d'un modèle ordinaire ?

Un modèle ordinaire calcule le vecteur d'un document une fois, sans connaître la question. Un modèle de scoring de paires voit la requête et le document ensemble, donc il juge l'adéquation plus précisément au prix du temps. D'où le montage en deux étapes : une recherche vectorielle rapide, puis la notation de quelques dizaines de candidats.

Quand le fine-tuning vaut-il la peine ?

Quand vous avez mesuré qu'un modèle généraliste ne gère pas votre vocabulaire et que l'amélioration du découpage ainsi que l'ajout d'une notation des candidats n'ont pas suffi. Il vous faut quelques milliers de paires question-fragment, idéalement issues de votre propre historique de recherche ou de vos tickets de support.

Où doivent vivre les vecteurs calculés ?

Dans n'importe quelle base de données vectorielle, comme celle décrite dans l'article sur Qdrant. La bibliothèque calcule des vecteurs et son rôle s'arrête là, donc le stockage et la recherche appartiennent à une couche séparée que vous choisissez indépendamment.

La documentation se trouve sur le site du projet, et le code dans le dépôt GitHub.

À lire aussi