Aller au contenu
English

Les mêmes idées dans un serveur de recherche

  • Leçon 30
  • 30 min
  • Module 8 : Exploiter la recherche en production

Où nous en sommes

Nous avons construit chaque partie de la recherche en Python. Beaucoup d'équipes utilisent plutôt un serveur de recherche. Dans cette leçon, nous voyons BM25, les synonymes, les vecteurs et les requêtes hybrides dans OpenSearch. Nous voyons aussi ce qu'un serveur apporte et son coût d'exploitation.

Leçon 30 sur 30 · Recherche et classement : trouver la meilleure correspondanceLes mêmes idées dans un serveur de recherche

Ce que vous saurez faire

Reconnaissez chaque partie de la recherche que vous avez construite dans un serveur de recherche. Vous reliez les parties du projet à OpenSearch : BM25, analyseurs et synonymes, champ vectoriel, requêtes hybrides et versions d’index. Puis vous décidez quand un serveur vaut son coût.

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 (seulement pour essayer les étapes)

Vous avez construit une bibliothèque à la maison avec des outils manuels. Vous connaissez chaque coupe, car vous l’avez faite. Maintenant, une entreprise demande mille bibliothèques par semaine. Vous achetez une machine d’usine. Elle fait les mêmes coupes, plus vite, toute la journée, et plusieurs personnes peuvent l’utiliser.

La machine ne fait rien que vous ne compreniez déjà avec vos outils manuels. Mais elle exige un local, de l’électricité et quelqu’un pour l’entretenir. Si vous fabriquez trois bibliothèques par année, la machine est un mauvais choix.

Le projet larkfield-search s’exécute dans un seul processus Python sur un seul ordinateur. C’était le bon choix pour apprendre : chaque partie est visible, et vous avez mesuré chacune. Une boutique très fréquentée a besoin de plus :

  • Beaucoup de recherches en même temps, sur plusieurs machines, sans qu’une recherche lente bloque les autres.
  • Des mises à jour pendant le service : ajouter de nouveaux produits, supprimer les produits retirés, en quelques secondes, sans reconstruction.
  • Aucun point de défaillance unique : si une machine s’arrête, la recherche continue de fonctionner.
  • Des filtres et des facettes sur des millions de produits, rapidement.

Notre projet ne fait rien de cela, volontairement. Un serveur de recherche fait tout cela. Ce programme conserve les index, reçoit les mises à jour par le réseau et répond aux requêtes. Il s’exécute sur plusieurs machines formant une grappe.

OpenSearch est un serveur de recherche à code source ouvert (licence Apache-2.0). Il a commencé comme une copie d’Elasticsearch et utilise en interne Lucene, une bibliothèque de recherche. Vous lui envoyez des requêtes par HTTP, avec des corps JSON. Chaque idée de ce cours y trouve sa place.

Chaque partie de larkfield-search correspond à une fonction d'OpenSearch. index.py, avec SQLite FTS5 et bm25s, correspond à un index avec une similarité BM25. normalise.py, avec la conversion en minuscules et la racinisation, correspond à un analyseur avec conversion en minuscules et raciniseur. synonyms.csv correspond à un filtre synonym_graph. products.npy, une matrice NumPy plate, correspond à un champ knn_vector avec un graphe HNSW. rrf() dans runs/dense.py correspond à une requête hybride et à un pipeline de recherche. outputs/index/, un dossier par construction, correspond à des versions d'index et à un alias.
Chaque partie que vous avez construite trouve sa place dans un serveur de recherche.
Description textuelle du diagramme

Six lignes, chacune reliant une partie de larkfield-search à sa fonction OpenSearch par une flèche. index.py (SQLite FTS5 + bm25s) vers un index avec une similarité BM25. normalise.py (conversion en minuscules, racinisation) vers un analyseur. synonyms.csv vers un filtre synonym_graph. products.npy (matrice NumPy plate) vers un champ knn_vector avec un graphe HNSW. rrf() vers une requête hybride et un pipeline de recherche. outputs/index/ (un dossier par construction) vers des versions d’index et un alias.

Voici les mots qui changent :

Dans ce cours Dans OpenSearch Ce que c’est
un produit un document un objet JSON avec des champs
le dossier de l’index un index les documents et leurs index inversés
l’analyseur d’un champ l’analyseur d’un champ les étapes qui transforment le texte en jetons (tokens)
la matrice plate de plongements (embeddings) un champ knn_vector un vecteur pour chaque document, avec une structure de recherche
une exécution comme hybrid-rrf une requête et un pipeline de recherche la façon de trouver et de combiner les résultats
le pointeur current un alias un nom qui pointe vers une version d’index

Larkfield dans OpenSearch, étape par étape (non exécuté)

Section intitulée « Larkfield dans OpenSearch, étape par étape (non exécuté) »

Cette commande démarre un seul nœud OpenSearch sur votre ordinateur, avec la sécurité désactivée. Ne désactivez jamais la sécurité sur un serveur accessible à d’autres personnes.

Fenêtre de terminal
docker run -d --name larkfield-os -p 9200:9200 \
-e discovery.type=single-node \
-e DISABLE_INSTALL_DEMO_CONFIG=true -e DISABLE_SECURITY_PLUGIN=true \
-e OPENSEARCH_JAVA_OPTS="-Xms1g -Xmx1g" \
opensearchproject/opensearch:2.19.1

-Xms1g -Xmx1g donne au serveur 1 Go de mémoire pour son tas Java. Arrêtez et supprimez le conteneur avec docker rm -f larkfield-os quand vous avez terminé.

2. Créer l’index : BM25, un analyseur, des synonymes et un champ vectoriel

Section intitulée « 2. Créer l’index : BM25, un analyseur, des synonymes et un champ vectoriel »

Une seule requête HTTP crée l’index products-v1. Elle configure BM25 avec les paramètres de Larkfield et un analyseur anglais avec racinisation. Elle ajoute un filtre de synonymes utilisé seulement lors de la recherche. Elle ajoute aussi un champ vectoriel pour les 384 nombres du bi-encodeur.

Fenêtre de terminal
curl -s -X PUT "http://localhost:9200/products-v1" -H "Content-Type: application/json" -d '{
"settings": {
"index": { "knn": true, "similarity": { "default": { "type": "BM25", "k1": 1.2, "b": 0.75 } } },
"analysis": {
"filter": {
"en_stem": { "type": "stemmer", "language": "english" },
"larkfield_synonyms": { "type": "synonym_graph", "synonyms": ["couch, sofa", "wardrobe, armoire"] }
},
"analyzer": {
"en_index": { "tokenizer": "standard", "filter": ["lowercase", "en_stem"] },
"en_search": { "tokenizer": "standard", "filter": ["lowercase", "larkfield_synonyms", "en_stem"] }
}
}
},
"mappings": {
"properties": {
"title": { "type": "text", "analyzer": "en_index", "search_analyzer": "en_search" },
"description": { "type": "text", "analyzer": "en_index", "search_analyzer": "en_search" },
"title_fr": { "type": "text", "analyzer": "french" },
"product_class": { "type": "keyword" },
"price": { "type": "float" },
"in_stock": { "type": "boolean" },
"embedding": { "type": "knn_vector", "dimension": 384,
"method": { "name": "hnsw", "space_type": "cosinesimil", "engine": "lucene" } }
}
}
}'

Lisez chaque partie :

  • similarity (similarité) : la même formule BM25 que le projet, avec k1 à 1,2 et b à 0,75. Lucene omet le facteur k1 + 1. Les paramètres bm25s du projet font la même chose.
  • analyzer (analyseur) : conversion en minuscules, puis raciniseur anglais, comme dans Normaliser le texte. L’analyseur de recherche ajoute les synonymes : une requête pour « couch » (canapé) cherche aussi « sofa ». Les synonymes s’appliquent seulement à la requête, comme dans le projet. Une différence : le projet donne un poids de moitié à un mot ajouté (Synonymes et réécriture de requête). Ce filtre lui donne le même poids qu’au mot de la personne.
  • title_fr utilise l’analyseur français intégré d’OpenSearch.
  • product_class est un keyword (mot-clé) : des valeurs exactes pour les filtres et les facettes, comme dans Filtres et facettes.
  • embedding est un champ vectoriel avec un graphe HNSW. HNSW est une méthode approximative : elle trouve rapidement des voisins proches en parcourant un graphe, mais peut en manquer quelques-uns. La matrice plate du projet compare chaque produit, donc elle n’en manque aucun.

Le projet contient déjà les plongements dans data/embeddings/products.npy, dans l’ordre du catalogue. Un court script Python envoie chaque produit comme document. Il utilise le client opensearch-py (python -m pip install opensearch-py; le cours ne fixe pas sa version et ne le teste pas).

import numpy as np
from opensearchpy import OpenSearch, helpers
from larkfield_search import data
client = OpenSearch("http://localhost:9200")
cat = data.catalogue()
vectors = np.load("data/embeddings/products.npy").astype("float32")
docs = ({"_index": "products-v1", "_id": row.product_id,
"title": row.title, "description": row.description, "title_fr": row.title_fr,
"product_class": row.product_class, "price": float(row.price), "in_stock": bool(row.in_stock),
"embedding": vectors[i].tolist()}
for i, row in enumerate(cat.itertuples()))
print(helpers.bulk(client, docs, chunk_size=500))

L’API bulk (en masse) envoie beaucoup de documents dans une seule requête. Plus tard, la même API ajoute un nouveau produit ou supprime un produit retiré, un document à la fois. Le serveur continue de répondre aux requêtes pendant ce temps. C’est la mise à jour incrémentale de Garder l’index à jour.

Fenêtre de terminal
curl -s "http://localhost:9200/products-v1/_search" -H "Content-Type: application/json" -d '{
"size": 10,
"query": { "multi_match": { "query": "couch", "fields": ["title", "description", "title_fr"] } }
}'

multi_match calcule le score de chaque champ avec BM25 et conserve par défaut le score du meilleur champ. L’exécution bm25-fields du projet additionne plutôt les scores pondérés des champs. Les deux classements différeront donc un peu, même avec la même formule.

OpenSearch peut combiner une requête lexicale et une requête vectorielle dans une seule requête hybride. Un pipeline de recherche combine les deux listes. Votre code encode la requête avec le même bi-encodeur que les produits, puis envoie le vecteur.

La requête outdoor cushion suit deux chemins. Une requête match exécute BM25 sur title et description avec l'analyseur et les synonymes. Votre code encode la requête avec le bi-encodeur en 384 nombres. Une requête knn trouve les 100 meilleurs résultats par vecteur, de façon approximative, avec HNSW. Un pipeline de recherche avec score-ranker-processor combine les deux par RRF, avec une constante de rang de 60. Le résultat est une seule liste classée, dont les 10 premiers résultats vont à la page.
Une requête hybride dans OpenSearch : la même fusion des rangs réciproques que hybrid-rrf du projet, exécutée par le serveur.
Description textuelle du diagramme

« outdoor cushion » (coussin d’extérieur) se divise en deux. En haut : « requête match : BM25 sur title, description; analyseur + synonymes ». En bas : « Votre code encode la requête : bi-encodeur, 384 nombres » → « requête knn : les 100 meilleurs résultats par vecteur, approximatifs (HNSW) ». Les deux vont vers « Pipeline de recherche : score-ranker-processor, RRF, constante de rang de 60 » → « Une seule liste classée, les 10 premiers résultats vers la page ».

D’abord, créez le pipeline une seule fois. Le score-ranker-processor avec RRF est apparu dans OpenSearch 2.19. rank_constant (constante de rang) est le k de la fusion des rangs réciproques : 60, comme dans le projet.

Fenêtre de terminal
curl -s -X PUT "http://localhost:9200/_search/pipeline/larkfield-rrf" -H "Content-Type: application/json" -d '{
"phase_results_processors": [
{ "score-ranker-processor": { "combination": { "technique": "rrf", "rank_constant": 60 } } }
]
}'

Puis envoyez la requête hybride. Ici, en Python, avec le bi-encodeur du projet :

from larkfield_search import dense
vector = dense.encode("outdoor cushion").astype("float32").tolist()
body = {"size": 10, "query": {"hybrid": {"queries": [
{"multi_match": {"query": "outdoor cushion", "fields": ["title", "description", "title_fr"]}},
{"knn": {"embedding": {"vector": vector, "k": 100}}},
]}}}
hits = client.search(index="products-v1", body=body, params={"search_pipeline": "larkfield-rrf"})
print([h["_id"] for h in hits["hits"]["hits"]])

L’exécution hybrid-blend du projet additionne les scores normalisés : 0,8 pour la recherche lexicale et 0,2 pour la recherche dense. Chaque score est ramené entre 0 et 1. Pour cela, OpenSearch propose normalization-processor, avec la normalisation min_max et les poids [0.8, 0.2].

Un alias est le pointeur de Garder l’index à jour, à l’intérieur du serveur. Le code de la boutique cherche toujours dans l’alias products. Pour mettre en production la version 2, construisez products-v2 à côté de la version 1, vérifiez-le et déplacez l’alias en une requête atomique :

Fenêtre de terminal
curl -s -X POST "http://localhost:9200/_aliases" -H "Content-Type: application/json" -d '{
"actions": [
{ "remove": { "index": "products-v1", "alias": "products" } },
{ "add": { "index": "products-v2", "alias": "products" } }
]
}'

Les deux actions se produisent ensemble. Pour revenir en arrière, inversez-les.

Un serveur n’améliore pas la recherche à lui seul. Il exécute les mêmes idées. Pour savoir s’il classe aussi bien que le projet, mesurez-le de la même façon. Exécutez les 243 requêtes de test dans OpenSearch et recueillez les 100 premiers résultats de chacune. Puis évaluez-les avec compare.py à partir des mêmes jugements. Attendez-vous à de petites différences. Le segmenteur et le raciniseur ne sont pas identiques. multi_match combine les champs d’une autre façon. Et HNSW est approximatif.

Mesurez aussi le temps, comme dans Budgets de latence et de coût. Une requête par HTTP ajoute le temps réseau à chaque recherche.

LambdaMART exige un module d’extension, ou votre propre code après la recherche du serveur. Beaucoup d’équipes gardent l’étape deux dans leur propre service : le serveur renvoie 100 candidats, et leur code les reclasse. C’est l’entonnoir de Classement en deux étapes.

Un serveur apporte Il coûte
Beaucoup de recherches simultanées, sur plusieurs machines Des machines qui fonctionnent en permanence
Des mises à jour pendant le service, en quelques secondes De la mémoire : les index inversés, les graphes HNSW et le tas Java
Des copies des données, pour tolérer la panne d’une machine Généralement trois nœuds, pas un seul, pour une grappe sûre
Des filtres, des facettes et des agrégations sur des millions de documents Des personnes qui savent l’exploiter, le mettre à niveau et le surveiller
Des alias, des instantanés et des sauvegardes Des mises à niveau, des paramètres de sécurité et du contrôle d’accès

Voici un exemple détaillé avec le prix donné en exemple dans le cours : un serveur avec 4 vCPU et 16 Go coûte 0,17 $ US par heure (une hypothèse). Cela donne 0,17 × 24 × 30 ≈ 122 $ US par mois. Une grappe de trois nœuds semblables coûte environ 367 $ US par mois. Le stockage, les sauvegardes et le temps des personnes qui l’exploitent s’ajoutent à ce coût. Des services de recherche hébergés existent aussi : ils exploitent la grappe pour vous, à leur propre tarif. Les prix changent : consultez la page du fournisseur.

Larkfield devrait-elle utiliser un serveur de recherche?

Section intitulée « Larkfield devrait-elle utiliser un serveur de recherche? »

Pas encore. Ses index comprennent 102,5 Mo d’index lexicaux et 31,3 Mo de plongements. LambdaMART répond en 36 ms sur un seul fil d’exécution. Une reconstruction complète prend quelques secondes, et le journal synthétique contient environ 2 500 recherches par semaine. Le service Python sur un petit serveur tient dans le budget.

Un serveur devient rentable dans trois cas. Le catalogue contient des millions de produits, les mises à jour doivent apparaître en quelques secondes, ou la recherche doit survivre à la panne d’une machine. Les idées restent les mêmes. Vous connaissez maintenant chacune pour l’avoir construite vous-même. Vous pouvez donc lire les paramètres d’un serveur et comprendre ce qu’ils font.

Erreur courante

Passer à un serveur et supposer que le classement reste le même

Symptôme : l’équipe transfère la recherche de Larkfield vers OpenSearch pendant une fin de semaine. Les paramètres semblent corrects : BM25 avec k1 à 1,2 et b à 0,75, raciniseur anglais, synonymes, RRF avec k à 60. Le lundi, Omar demande : « Est-ce aussi bon qu’avant? » Personne ne le sait.

Cause : l’équipe a copié les paramètres et sauté la mesure. De petites parties diffèrent : le segmenteur, la combinaison des champs, la recherche vectorielle approximative, et LambdaMART manque. Chacune peut modifier le NDCG@10, davantage sur certaines tranches que sur d’autres.

Solution : avant que quiconque voie les résultats, exécutez les mêmes 243 requêtes de test dans le serveur. Évaluez-les avec compare.py, puis comparez-les avec l’exécution du projet, par tranche. Ensuite, testez en ligne, comme dans Tester les changements en ligne.

Conséquence pour le travail en recherche : un nouvel outil est un changement de classement comme un autre. Mesurez-le hors ligne, puis en ligne, puis publiez-le avec un moyen de revenir en arrière.

Vérifiez votre compréhension

Dans OpenSearch, pourquoi le filtre de synonymes est-il seulement dans l'analyseur de recherche, et non dans l'analyseur d'indexation?

Afficher la réponse

Pour que les synonymes élargissent la requête, et non les produits stockés. Les jetons stockés ne dépendent alors pas des règles. Les produits sont indexés de la même façon, quelles que soient les règles. Le projet applique ses règles de synonymes au même endroit : à la requête. (La façon dont un serveur prend en compte une liste de règles modifiée dépend de sa version : consultez sa documentation.)

Vérifiez votre compréhension

La recherche dense du projet compare la requête aux 40 066 produits. Le champ knn_vector d'OpenSearch utilise HNSW. Que gagnez-vous et que pouvez-vous perdre?

Afficher la réponse

HNSW lit seulement une petite partie des vecteurs en parcourant un graphe. Il reste donc rapide pour des millions de produits. Mais il est approximatif : il peut manquer quelques produits réellement les plus proches. À la taille de Larkfield, la recherche dans la matrice plate prend 2,1 ms et ne manque rien. HNSW n’est donc pas nécessaire.

Vérifiez votre compréhension

Quelle fonction d'OpenSearch joue le rôle du fichier pointeur `current` de la dernière leçon, et pourquoi est-elle sûre?

Afficher la réponse

Un alias. Le code de la boutique cherche dans l’alias. Une seule requête _aliases le retire de l’ancien index et l’ajoute au nouveau, ensemble, de façon atomique. Aucune recherche ne voit un basculement à moitié effectué. Le déplacer de nouveau permet de revenir en arrière.

Récapitulatif

  • Un serveur de recherche (OpenSearch, Apache-2.0, avec Lucene à l’intérieur) exécute les mêmes idées que le projet. Il offre la similarité BM25, des analyseurs avec racinisation et synonymes, un champ vectoriel, des requêtes hybrides avec RRF et des alias. L’équipe du cours ne l’a pas exécuté.
  • Il apporte de nombreuses recherches simultanées, des mises à jour pendant le service, des copies des données et des filtres à grande échelle. Il exige des machines qui fonctionnent en permanence, de la mémoire et des personnes. Un nœud au prix d’exemple de 0,17 $ US par heure coûte environ 122 $ US par mois.
  • Passer à un serveur est un changement de classement : mesurez-le avec les mêmes requêtes de test et compare.py, puis testez-le en ligne.
  • Larkfield n’a pas besoin d’un serveur à sa taille actuelle. Un catalogue de millions de produits, des mises à jour en quelques secondes ou la tolérance aux pannes changeraient cela.

C’est la fin des modules d’enseignement. Vous pouvez maintenant définir un problème de recherche, le mesurer, construire chaque famille de méthodes et exploiter le résultat en production. Ensuite, les études de cas : commencez par la recherche de produits sur l’ensemble des données WANDS.

Leçon suivante : Recherche de produits pour un magasin de meubles