Aller au contenu
English

Recherche par le sens

  • Leçon 15
  • 40 min
  • Module 5 : La recherche dense et la recherche hybride

Où nous en sommes

La recherche lexicale exige les mêmes mots dans la requête et le produit. Les gens n'utilisent pas toujours les mots du produit. Dans cette leçon, nous transformons les requêtes et les produits en plongements, puis nous cherchons par le sens.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Trouvez les produits qui correspondent à l’intention d’une personne, même si la requête et le produit ne partagent aucun mot utile.

Carnet JupyterRecherche par le sens dans un carnet JupyterColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter charge les vecteurs des produits et des requêtes. Il attribue un score à chaque produit avec un seul produit matriciel et mesure la recherche dense sur les requêtes de validation anglaises. Une dernière partie facultative télécharge le modèle et encode une nouvelle requête. Ses cellules de préparation téléchargent les données, donc aucune configuration locale n’est 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 40 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le projet larkfield-search avec son environnement virtuel actif, et le dépôt des laboratoires à côté, comme dans les modules précédents. Cette leçon ajoute quatre fichiers de l’instantané end-of-m05, met à jour requirements.txt et le README, et installe deux gros paquets (environ 760 Mo sur disque).

Une cliente entre dans une boutique de jardinage. Elle dit : « J’ai besoin d’un siège pour le jardin. » Aucune étiquette n’indique « siège pour le jardin ». Les étiquettes indiquent « banc en teck », « tabouret pliant » et « chaise de patio ».

Une bonne vendeuse ne cherche pas les mots « siège pour le jardin ». Elle réfléchit à l’intention de la cliente : quelque chose pour s’asseoir, qui peut rester dehors. Puis elle se dirige vers les bancs et les tabourets. Elle ne va pas vers les statues de jardin, même si elles aussi sont « pour le jardin ».

C’est la recherche par le sens. La vendeuse compare des idées, pas des mots.

Le problème : la même idée exprimée avec d’autres mots

Section intitulée « Le problème : la même idée exprimée avec d’autres mots »

BM25 compare des mots. Un produit reçoit un score seulement pour les mots de la requête qui apparaissent dans son texte. Quand une personne emploie d’autres mots que le catalogue, BM25 utilise seulement les mots qui correspondent par hasard.

Essayez la meilleure exécution lexicale jusqu’ici :

Fenêtre de terminal
search query "seat for the garden" --run bm25-norm+spell+syn -k 5
bm25-norm+spell+syn: "seat for the garden" -> 5 results
1. LK-80545 smile for me solar garden gnome statue Garden Statues 531.99
2. LK-30203 francine , the fairy gardener cast garden statue Garden Statues 630.99
3. LK-19627 the secret garden fairy statue Garden Statues 513.99
4. LK-98696 bulldoze and the garden gnome statue Garden Statues 248.99
5. LK-98373 the enchanted garden fairies statue Garden Statues 281.99

Cinq statues de jardin. « garden » (jardin) figure dans leurs titres courts, donc BM25 leur donne des scores élevés. « seat » (siège) est fréquent dans les longues descriptions, donc il ajoute peu au score. Rien sur cette page n’est un siège.

Cette requête ne fait pas partie du jeu de requêtes du cours, donc elle n’a aucun jugement. Nous l’avons écrite pour montrer le problème.

Un plongement (embedding) est une liste de nombres qui représente le sens d’un texte. Un modèle lit le texte et écrit la liste. Les textes de sens semblable reçoivent des listes semblables. Les textes de sens différent reçoivent des listes différentes.

Une liste de nombres est un vecteur. Nous pouvons donc comparer deux textes en comparant leurs vecteurs. La comparaison habituelle est la similarité cosinus : 1 quand deux vecteurs pointent dans la même direction, 0 quand ils n’ont rien en commun. Similarité et distance, dans le cours de mathématiques, l’explique avec des images.

La recherche avec des plongements s’appelle recherche dense. « Dense » signifie que chaque nombre du vecteur est utilisé. BM25 fait l’inverse : ses vecteurs ont une position par mot du vocabulaire, et presque toutes contiennent zéro.

Le modèle utilisé est un bi-encodeur. « Bi » signifie deux : il encode séparément la requête et le produit, avec le même modèle. Les deux ne se rencontrent jamais dans le modèle. Cela offre un grand avantage. Nous pouvons encoder tous les produits une seule fois, avant toute recherche. Au moment de la recherche, seule la requête est nouvelle.

Ligne du haut, exécutée une fois : 40 066 produits (titre, classe et 40 premiers mots de la description) entrent dans le bi-encodeur granite-embedding-97m-multilingual-r2. Il écrit un tableau de 40 066 lignes de 384 nombres, soit 30,8 Mo en float16. L'équipe du cours l'a fait; cela a pris 163 secondes. Lignes du bas, pour chaque recherche, environ 8 ms au total : la requête seat for the garden entre dans le même bi-encodeur (5,5 ms) et devient un vecteur de 384 nombres. Un produit matriciel avec le tableau des produits donne le cosinus avec chaque produit (2,1 ms). Les 5 meilleurs scores : 0,877 noreen owl garden stool, 0,874 gaspar bollen girl picking flowers statue, 0,873 owl garden figurine, 0,871 haussen fairy garden stake, 0,870 fairy garden figurine.
Un bi-encodeur encode les produits une fois et la requête au moment de la recherche. La recherche elle-même est un seul produit matriciel.
Description textuelle du diagramme

La ligne du haut s’exécute une seule fois, avant toute recherche. Les 40 066 produits entrent dans le bi-encodeur. Pour chaque produit, le modèle lit le titre, la classe de produit et les 40 premiers mots de la description. Il écrit un tableau de 40 066 lignes de 384 nombres. Chaque nombre est stocké en float16, un format de 2 octets, donc le tableau occupe 30,8 Mo en mémoire. L’équipe du cours l’a fait pour vous : 42 066 produits (avec les 2 000 réservés au travail final) ont pris 163 secondes. Les lignes du bas s’exécutent à chaque recherche, en environ 8 ms. La requête « seat for the garden » (siège pour le jardin) entre dans le même modèle (5,5 ms). Elle devient un vecteur de 384 nombres. Un produit matriciel avec le tableau donne le cosinus avec chaque produit (2,1 ms). Les 5 meilleurs scores sont 0,877 pour un noreen owl garden stool, puis 0,874, 0,873, 0,871 et 0,870 pour quatre statues et ornements de jardin.

Notre modèle est granite-embedding-97m-multilingual-r2 d’IBM. Il écrit 384 nombres pour chaque texte et lit plusieurs langues, dont le français. Sa licence est Apache-2.0. Sa fiche de modèle indique que chaque jeu de données d’entraînement possède une licence permissive. C’est l’affirmation du fournisseur; nous n’avons pas vérifié nous-mêmes les données d’entraînement.

Les vrais plongements ont 384 nombres, et ces nombres n’ont pas de nom. Pour voir le calcul, voici un exemple simplifié avec trois nombres. Nous avons inventé ces vecteurs. Disons que les trois nombres signifient « pour s’asseoir », « pour le jardin » et « pour décorer ».

Texte s’asseoir jardin décoration
requête « seat for the garden » 0,8 0,6 0,0
banc de jardin 0,6 0,8 0,0
chaise de bureau 1,0 0,0 0,0
boyau d’arrosage 0,0 1,0 0,0
statue de jardin 0,0 0,6 0,8

Chaque vecteur a une longueur de 1 : par exemple, 0,6 × 0,6 + 0,8 × 0,8 = 1. Pour des vecteurs de longueur 1, le cosinus est le produit scalaire : multipliez les nombres position par position, puis additionnez.

Produit Produit scalaire avec la requête Cosinus
banc de jardin 0,8 × 0,6 + 0,6 × 0,8 + 0 × 0 0,96
chaise de bureau 0,8 × 1,0 + 0,6 × 0 + 0 × 0 0,80
boyau d’arrosage 0,8 × 0 + 0,6 × 1,0 + 0 × 0 0,60
statue de jardin 0,8 × 0 + 0,6 × 0,6 + 0 × 0,8 0,36

Le banc arrive premier, car ses deux nombres sont proches de ceux présents dans la requête. La statue arrive dernière : elle partage seulement « jardin » et possède un nombre absent de la requête.

Un vrai modèle fonctionne de la même façon, avec 384 nombres. Mais il a appris ses nombres à partir de données et ne suit pas toujours notre exemple simplifié. Nous avons encodé les mêmes textes courts avec le vrai modèle :

Paire de textes Cosinus (vrai modèle)
« seat for the garden » et « garden statue » (statue de jardin) 0,887
« seat for the garden » et « garden bench » (banc de jardin) 0,853
« seat for the garden » et « office chair » (chaise de bureau) 0,796

Le vrai modèle classe la statue un peu devant le banc. « garden » pèse beaucoup dans ses nombres. Observez aussi la plage : chaque cosinus se situe entre 0,79 et 0,89. Seul l’ordre compte, pas la valeur. Un cosinus de 0,85 ne signifie pas « pertinent à 85 % ».

Pour une requête, nous avons besoin du cosinus avec les 40 066 produits. Placez les vecteurs des produits dans un tableau, une ligne par produit. Un produit matriciel du tableau et du vecteur de la requête donne alors les 40 066 produits scalaires à la fois. NumPy le fait en environ 2 ms sur un portable.

C’est un index plat : aucune structure astucieuse, chaque produit reçoit un score. Pour 40 066 produits, c’est assez rapide. Les très grands catalogues utilisent un index approximatif qui attribue un score à seulement certains produits. Nous y revenons au module 8.

L’équipe du cours a encodé chaque produit et chaque requête du cours une fois, puis fourni les vecteurs dans data/embeddings/. Les leçons n’ont donc pas à attendre le modèle. Une requête absente du jeu du cours est encodée sur votre ordinateur, et le modèle est téléchargé la première fois.

  1. Copiez les fichiers de ce module depuis l’instantané end-of-m05. Quatre fichiers sont nouveaux : le texte lu par le modèle (embedtext.py), la recherche dense (dense.py), les exécutions de ce module (runs/dense.py) et leurs tests. requirements.txt et le README sont mis à jour :

    Fenêtre de terminal
    S=../nextia-learning-labs/C38/snapshots/end-of-m05
    for f in requirements.txt larkfield_search/embedtext.py larkfield_search/dense.py larkfield_search/runs/dense.py tests/test_dense.py README.md; do
    cp "$S/$f" "$f"
    done
  2. Installez les deux nouveaux paquets, sentence-transformers et PyTorch. Sur Linux, installez d’abord la version CPU de PyTorch pour éviter que pip télécharge la grosse version GPU :

    Fenêtre de terminal
    python -m pip install torch==2.15.0 --index-url https://download.pytorch.org/whl/cpu # Linux only
    python -m pip install -r requirements.txt

    Le téléchargement est volumineux. L’environnement virtuel passe d’environ 240 Mo à environ 1 Go.

  3. Exécutez les tests. Ils utilisent un minuscule catalogue fictif, donc ils n’ont pas besoin du modèle :

    Fenêtre de terminal
    python -m pytest -q
    ........................... [100%]
    27 passed in 7.17s

    Trois tests sont nouveaux. L’un vérifie la fusion des rangs réciproques à la main; vous la découvrirez dans Recherche hybride.

  4. Cherchez par le sens :

    Fenêtre de terminal
    search query "seat for the garden" --run dense -k 5
    dense: "seat for the garden" -> 5 results
    1. LK-87094 noreen owl garden stool Accent Stools 59.99
    2. LK-24871 gaspar bollen girl picking flowers statue Garden Statues 576.99
    3. LK-14244 owl garden figurine Garden Statues 176.99
    4. LK-67532 haussen fairy garden stake Garden Accents 243.99
    5. LK-95148 fairy garden figurine Garden Statues 611.99

    La première fois, la commande télécharge le modèle (environ 200 Mo) et prend environ 15 secondes. Chaque fois qu’elle charge le modèle, elle peut d’abord afficher quelques lignes. Il s’agit d’une note sur les redirections (sur macOS), d’une barre de progression « Loading weights » (chargement des poids), et d’un avertissement concernant un jeton Hugging Face manquant. Vous pouvez les ignorer.

Un tabouret arrive premier. Le mot « seat » ne figure pas dans son titre, et BM25 ne l’a pas trouvé. La recherche dense l’a trouvé parce qu’un tabouret est un siège. Mais les quatre résultats suivants sont des ornements de jardin. Le modèle a un peu compris « seat », et beaucoup compris « garden ». La recherche par le sens n’est pas magique : c’est une estimation apprise des textes qui sont proches.

Une requête ne prouve rien. Mesurez l’exécution sur les 243 requêtes de test, comme chaque exécution du cours :

Fenêtre de terminal
search eval --run dense
dense on 243 test queries: NDCG@10 0.519 (95% interval 0.471 to 0.566)
recall@100 0.453, MRR 0.510, zero results 0.0%, judged in the top 10 57.4%; 1.2 ms a query (p50), 1.4 ms (p95)

Le temps est court ici parce que les requêtes de test ont déjà leurs vecteurs. Encoder une nouvelle requête en direct ajoute environ 5,5 ms. La recherche dense complète prend 8,0 ms (p50) et 9,8 ms (p95) sur un fil d’exécution.

NDCG@10 sur les requêtes de test (moyenne de 241), avec des intervalles à 95 %. La recherche dense dépasse largement la recherche actuelle de Larkfield, mais reste clairement sous la meilleure exécution lexicale.
Description textuelle du graphique

Le graphique montre cinq exécutions, chacune avec son NDCG@10 et son intervalle à 95 % sur les requêtes de test (moyenne de 241 sur 243). current, la recherche actuelle de Larkfield : 0,195 (0,155 à 0,237). bm25 : 0,429 (0,381 à 0,476). bm25-fields+codes : 0,506 (0,458 à 0,552). bm25-norm+spell+syn, la meilleure exécution lexicale du module 4 : 0,620 (0,574 à 0,662). dense, mise en évidence : 0,519 (0,471 à 0,566).

La recherche dense seule obtient 0,519. C’est beaucoup mieux que la recherche actuelle de Larkfield (0,195). Mais c’est clairement moins bon que la meilleure exécution lexicale, à 0,620. Les deux intervalles ne se touchent même pas.

Deux détails comptent pour la suite. D’abord, l’exécution dense conserve la règle des codes de Correspondances exactes et règles. Toutes les exécutions depuis le module 4 le font. Sans elle, la recherche dense ne trouverait jamais un code. Ensuite, seulement 57,4 % des 10 premiers produits de dense ont un jugement. Cette proportion s’affiche sous « judged in the top 10 » (jugés parmi les 10 premiers), et le cours la nomme judged@10. Les juges ont noté les produits trouvés par les anciennes recherches. Un produit non jugé compte comme non pertinent, ce qui sous-estime un peu la recherche dense. Jugements d’un modèle de langage a mesuré cet effet avec les étiquettes du modèle pour les produits non jugés. Avec elles, dense passe de 0,494 à 0,514 sur les requêtes de test anglaises et françaises. C’est un petit changement, pas l’écart de 0,1.

Tomás lit les nombres et fronce les sourcils. « La recherche vectorielle est censée remplacer la recherche par mots-clés. » La prochaine leçon examine où la recherche dense gagne, où elle perd, et pourquoi.

Utilisez-la quand les gens décrivent les produits avec leurs propres mots, ou quand la requête et le catalogue utilisent des langues différentes. Elle sert aussi de deuxième avis à côté d’une recherche lexicale. Elle ne renvoie jamais une page vide : chaque produit a un cosinus.

Ne l’utilisez pas seule quand les mots exacts comptent : noms, codes, tailles et marques rares. La prochaine leçon mesure ces cas.

Ce qu’elle coûte :

Coût Valeur chez Larkfield Étiquette
Encoder le catalogue une fois 163 s pour 42 066 produits (257,8 par seconde, 4 fils) mesuré
Vecteurs des produits 30,8 Mo en mémoire en float16; float32 (4 octets par nombre) prend deux fois plus de place mesuré
float16 plutôt que float32 99,3 % des mêmes 10 premiers produits sur 200 requêtes mesuré
Encoder une requête 5,5 ms (p50, 1 fil) mesuré
Attribuer un score à chaque produit 2,1 ms (p50) mesuré
Paquets environ 760 Mo de plus dans l’environnement virtuel mesuré
Le modèle 195 Mo, téléchargé une fois mesuré

Un nouveau produit a besoin de son vecteur avant que la recherche dense puisse le trouver. L’étape d’encodage appartient donc au pipeline qui ajoute les produits à l’index. Le module 8 y revient.

Erreur courante

Deux modèles, un index

Symptôme : après une mise à niveau du modèle, la recherche dense renvoie des résultats absurdes pour chaque requête. Rien n’a planté, et chaque requête reçoit encore dix résultats.

Cause : les produits ont été encodés avec l’ancien modèle, et les requêtes avec le nouveau. Chaque modèle possède ses propres nombres. Un cosinus entre les vecteurs de deux modèles ne signifie rien.

Diagnostic : vérifiez quel modèle et quelle version ont écrit chaque tableau. Le projet stocke ces renseignements dans data/embeddings/model.json et charge le modèle à cette révision exacte.

Correction : fixez la révision du modèle. Quand vous changez de modèle, encodez à nouveau tout le catalogue. Faites passer le côté requêtes et le côté produits au nouveau modèle en même temps.

Conséquence pour le travail en IA : un plongement n’a de sens qu’avec les plongements du même modèle. Stockez le nom et la révision du modèle avec chaque tableau de vecteurs, en recherche et en récupération pour un modèle de langage.

Cherchez par le sens avec vos propres mots. Prédisez d’abord les résultats, puis exécutez :

Fenêtre de terminal
search query "something to sit on outside" --run dense -k 5

Nos résultats : un ensemble de sièges extérieurs, un sofa de patio, un ensemble de patio à bascule et deux autres ensembles de sièges extérieurs. Aucun de ces titres ne contient « sit » (s’asseoir) ou « outside » (dehors). Essayez ensuite la même requête avec --run bm25-norm+spell+syn, puis comparez.

Pour en savoir plus sur les plongements en récupération pour un modèle de langage, avec des segments de documents plutôt que des produits, consultez Les plongements pour la recherche dans le cours RAG.

Vérifiez votre compréhension

Pourquoi un bi-encodeur peut-il chercher parmi 40 066 produits en quelques millisecondes, alors que le modèle prend 163 secondes pour tous les lire?

Afficher la réponse

Un bi-encodeur encode la requête et chaque produit séparément. Tous les produits sont donc encodés une seule fois, avant toute recherche, et les vecteurs sont stockés. Au moment de la recherche, le modèle lit seulement la requête (environ 5,5 ms). Ensuite, un produit matriciel du tableau stocké et du vecteur de la requête donne le cosinus avec chaque produit (environ 2 ms). Les 163 secondes sont nécessaires une seule fois, et non à chaque recherche.

Vérifiez votre compréhension

Dans l'exemple simplifié, la requête est (0,8, 0,6, 0,0) et un produit est (0,6, 0,0, 0,8). Les deux ont une longueur de 1. Quel est le cosinus, et le produit est-il proche de la requête?

Afficher la réponse

Le produit scalaire est 0,8 × 0,6 + 0,6 × 0,0 + 0,0 × 0,8 = 0,48. Pour des vecteurs de longueur 1, c’est le cosinus : 0,48. Il est inférieur à celui du banc (0,96) et de la chaise de bureau (0,80). Il est supérieur à celui de la statue (0,36). Dans un vrai modèle, seul l’ordre des cosinus compte, pas leur valeur.

Vérifiez votre compréhension

La recherche dense obtient 0,519 sur les requêtes de test, et la meilleure exécution lexicale, 0,620. Seulement 57,4 % des 10 premiers produits de la recherche dense ont été jugés. Omar demande : « La recherche dense est-elle vraiment moins bonne, ou les jugements sont-ils injustes? » Que répondez-vous?

Afficher la réponse

Les deux sont en partie vrais, mais l’écart est réel. Les produits non jugés comptent comme non pertinents, ce qui sous-évalue un peu la recherche dense. Les étiquettes du modèle pour ces produits ont fait passer son score de 0,494 à 0,514 sur les requêtes de test anglaises et françaises : environ 0,02. L’écart avec l’exécution lexicale est d’environ 0,1, et les deux intervalles ne se touchent pas. La recherche dense seule est donc moins bonne ici. Pour une comparaison juste, présentez judged@10 à côté du NDCG et jugez davantage de ses produits avant de décider.

Récapitulatif

  • Un plongement (embedding) est un vecteur de nombres qui représente le sens d’un texte. Un bi-encodeur encode la requête et les produits séparément, avec le même modèle.
  • Les produits sont encodés une seule fois (163 s ici); au moment de la recherche, seule la requête est encodée (5,5 ms). Un produit matriciel donne la similarité cosinus avec chaque produit (2,1 ms).
  • Pour des vecteurs de longueur 1, le cosinus est le produit scalaire. Seul l’ordre des cosinus compte.
  • « seat for the garden » trouve d’abord un tabouret de jardin que BM25 a manqué, puis des statues de jardin. Le sens est une estimation apprise.
  • La recherche dense obtient un NDCG@10 de 0,519 (de 0,471 à 0,566). C’est bien mieux que la recherche actuelle de Larkfield, et nettement moins bien que la meilleure exécution lexicale (0,620). Les produits non jugés expliquent une partie de l’écart, mais seulement environ 0,02.

La recherche dense est meilleure pour certaines requêtes et moins bonne pour d’autres. Une moyenne ne montre pas lesquelles. Ensuite, vous comparez la recherche dense à BM25 par type de requête et trouvez les requêtes où elle échoue.

Leçon suivante : Où la recherche dense échoue