Aller au contenu
English

Reclassement par encodeur croisé

  • Leçon 20
  • 40 min
  • Module 6 : Reclasser les premiers résultats

Où nous en sommes

Dans la dernière leçon, nous avons séparé le classement en deux étapes : une rapide, puis une lente et précise. La deuxième étape exige un modèle qui lit mieux que notre recherche. Un encodeur croisé lit la requête et le produit ensemble. Dans cette leçon, nous l'ajoutons au projet. Nous mesurons où il aide, où il nuit et combien de millisecondes il ajoute.

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

Ce que vous saurez faire

Reclassez les meilleurs candidats avec un modèle qui lit la requête et le produit ensemble. Vous ajoutez un encodeur croisé (cross-encoder) au projet. Vous mesurez son gain sur les requêtes de test de Larkfield, par langue, et son coût en temps.

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

Le carnet (notebook) Jupyter examine les scores enregistrés de l’encodeur croisé pour une requête. Il mesure le reclassement sur les requêtes de validation, par langue. Ensuite, vous calculez combien de candidats tiennent dans un budget de 200 ms. Ses cellules de préparation téléchargent les données d’exercice. Il ne nécessite donc aucune préparation locale ni téléchargement de modèle. 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 40 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur (pour l’exercice guidé seulement)

  • Le projet larkfield-search à la fin du module 5, dans Recherche hybride. python -m pytest -q doit afficher 27 passed (27 tests réussis).
  • Le dépôt des exercices à côté (../nextia-learning-labs), comme dans Découvrir le catalogue et le journal des requêtes.
  • Sur macOS, la bibliothèque OpenMP de Homebrew pour LightGBM, utilisée dans la prochaine leçon : brew install libomp.

Un client tend une note à la vendeuse : « beds that have leds ». Une nouvelle vendeuse cherche les mots. « LEDs » figure sur beaucoup de boîtes : ampoules, projecteurs, bandes lumineuses. Elle apporte une boîte d’ampoules à DEL.

Une vendeuse expérimentée lit toute la note d’un coup. Elle comprend que « beds » désigne ce que le client veut, et que « that have leds » le décrit. Elle apporte des lits avec des lumières intégrées. Elle n’a pas examiné les mots un par un. Elle a lu les liens entre les mots.

Le problème : la recherche hybride associe des mots, pas la demande

Section intitulée « Le problème : la recherche hybride associe des mots, pas la demande »

La recherche hybride de Larkfield lit les mots (BM25) et les sens (le bi-encodeur de Recherche par le sens). Pour « beds that have leds », voici ses 5 premiers résultats sur le jeu de test :

hybrid-rrf: "beds that have leds" -> 10 results (query W-014: judged results are marked)
1. LK-97303 solar powered led spot light pack Landscape Lighting 623.99 [irrelevant]
2. LK-55076 25 watt equivalent blue e12/candelabra led light bulb Light Bulbs 396.99 [irrelevant]
3. LK-44879 5 watt ( 60 watt equivalent ) , ca10 led , dimmable light bu Light Bulbs 328.99 [irrelevant]
4. LK-66358 25 watt equivalent purple e12/candelabra led light bulb Light Bulbs 227.99 [irrelevant]
5. LK-83953 25 watt equivalent red e12/candelabra led light bulb Light Bulbs 622.99 [irrelevant]

« led » est un mot rare dans le catalogue. BM25 lui donne donc un poids élevé. Le bi-encodeur a créé un vecteur pour toute la requête et un pour chaque produit, séparément. Le vecteur de la requête se trouve quelque part entre « bed » et « LED ». Les ampoules sont proches de lui. Aucune partie de la recherche hybride ne lit la requête et le produit ensemble.

Un encodeur croisé est un modèle de langage qui lit la requête et le texte d’un produit comme une seule entrée. Il renvoie un seul score : à quel point ce produit répond à cette requête. Dans le modèle, chaque mot de la requête peut examiner chaque mot du produit, et inversement. Les mots se « croisent » entre les deux textes; c’est l’origine du nom.

Comparez-le au bi-encodeur de Recherche par le sens. Un bi-encodeur encode la requête et chaque produit séparément en vecteurs. Les vecteurs des produits sont calculés une fois, à l’avance. Une recherche encode donc seulement la requête, puis compare les vecteurs. C’est rapide, mais le modèle ne voit jamais la requête et le produit côte à côte.

Comparaison de deux modèles. Bi-encodeur, étape un : la requête passe une fois dans le modèle et devient un vecteur de requête; chaque produit a été encodé une fois à l'avance en 40 066 vecteurs de produits; les vecteurs de tous les produits sont comparés en quelques millisecondes. Encodeur croisé, étape deux : la requête et un produit, par exemple beds that have leds et emete low profile standard bed, entrent ensemble dans le modèle; il lit les deux mot par mot et donne un score, 0,878. Une exécution du modèle par paire : 50 paires exigent 50 exécutions.
Un bi-encodeur encode séparément la requête et les produits, ce qui permet d'encoder les produits à l'avance. Un encodeur croisé lit chaque paire ensemble : plus de précision, et une exécution du modèle par paire.
Description textuelle du diagramme

Deux boîtes, l’une au-dessus de l’autre. « Bi-encodeur (étape un, module 5) » : « Requête : beds that have leds » → « Modèle, une exécution par requête » → « Vecteur de la requête »; « Chaque produit, encodé une fois, à l’avance » → « 40 066 vecteurs de produits »; les deux vecteurs → « Comparer les vecteurs, quelques millisecondes pour tous les produits ». « Encodeur croisé (étape deux) » : « Requête + un produit : beds that have leds + emete low profile standard bed » → « Le modèle lit les deux ensemble, mot par mot » → « Un score : 0,878, une exécution par paire, 50 paires = 50 exécutions ».

L’encodeur croisé échange donc de la vitesse contre de la précision. Il ne peut rien préparer à l’avance, car chaque score dépend de la requête. Pour 50 candidats, il s’exécute 50 fois à chaque recherche. C’est pourquoi sa place est à l’étape deux.

L’équipe du cours a exécuté l’encodeur croisé sur les 100 meilleurs candidats hybrides de « beds that have leds ». Elle a enregistré les scores. En voici cinq :

Produit Rang hybride Score de l’encodeur croisé Rang selon ce score (sur 100) Jugement
solar powered led spot light pack 1 0,754 70 non pertinent
25 watt equivalent blue e12/candelabra led light bulb 2 0,766 49 non pertinent
emete low profile standard bed 7 0,878 1 exact
satty bed led kit 17 0,849 5 exact
galway upholstered led storage platform bed 23 0,835 8 exact

Les scores sont proches les uns des autres, entre environ 0,75 et 0,88. Seul leur ordre compte. L’ampoule et le projecteur ont les scores les plus bas, autour de 0,75 à 0,77. Les lits et l’ensemble de DEL pour lit ont les scores les plus élevés. L’encodeur croisé a lu « beds » comme l’objet voulu, et « leds » comme un détail.

Reclasser signifie prendre les n meilleurs candidats de l’étape un, les trier selon ce score, puis garder le reste en dessous. Les candidats sous le rang n conservent leur ordre hybride.

Le projet utilise granite-embedding-reranker-english-r2 d’IBM : 149 millions de paramètres, un téléchargement de 598 Mo, une licence Apache-2.0. Sa fiche de modèle indique que toutes ses données d’entraînement ont une licence permissive. Elle indique aussi qu’il n’a pas été entraîné sur MS MARCO. C’est une affirmation du fournisseur; l’équipe du cours n’a pas vérifié les données d’entraînement. Beaucoup d’encodeurs croisés populaires, comme cross-encoder/ms-marco-MiniLM-L6-v2, sont entraînés sur MS MARCO. Les conditions d’utilisation de MS MARCO précisent que les jeux de données sont « intended for non-commercial research purposes only » (destinés uniquement à la recherche non commerciale). Pour un magasin, la licence des données d’entraînement compte autant que celle des poids.

Le coût de ce choix : le modèle est entraîné pour l’anglais. Vous verrez ce que cela signifie pour les requêtes françaises de Larkfield.

Exercice guidé : ajouter les fichiers du module et reclasser

Section intitulée « Exercice guidé : ajouter les fichiers du module et reclasser »

Ce module ajoute six fichiers Python et un fichier de tests au projet. Copiez-les tous maintenant depuis l’instantané end-of-m06. Cette leçon explique rerank.py et l’exécution rerank-ce. Les deux prochaines leçons expliquent les autres.

  1. Dans larkfield-search, avec l’environnement virtuel actif, copiez les fichiers de ce module depuis l’instantané. Il s’agit du nouveau code, de ses tests, de la nouvelle liste de paquets et du README.

    Fenêtre de terminal
    S=../nextia-learning-labs/C38/snapshots/end-of-m06
    for f in requirements.txt larkfield_search/rerank.py larkfield_search/ltr.py larkfield_search/clicks.py larkfield_search/runs/rerank.py larkfield_search/commands/ltr.py larkfield_search/commands/clicks.py tests/test_rerank.py README.md; do
    cp "$S/$f" "$f"
    done
  2. Installez le nouveau paquet. Le nouveau requirements.txt ajoute LightGBM, pour la prochaine leçon :

    Fenêtre de terminal
    python -m pip install -r requirements.txt

    La dernière ligne affiche Successfully installed lightgbm-4.7.0 (lightgbm-4.7.0 installé avec succès).

  3. Exécutez les tests :

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

    Quatre tests sont nouveaux. L’un vérifie que rerank-ce utilise les scores enregistrés.

  4. Ouvrez larkfield_search/runs/rerank.py. L’exécution rerank-ce tient en sept lignes :

    def rerank_ce(query, query_id=None, k=100):
    n = int(settings.get("rerank", RERANK))
    cand = hybrid_rrf(query, query_id, max(k, 100))
    head = [p for p, _ in cand[:n]]
    s = rerank.scores(query, query_id, head)
    head = sorted(zip(head, s), key=lambda x: (-x[1], x[0]))
    return with_codes(query, head + cand[n:], k)

    Elle prend les 100 premiers candidats de hybrid-rrf (étape un). Elle évalue les n premiers (50 par défaut), les trie par score et garde les autres en dessous. La dernière ligne applique la règle des codes de produits de Correspondances exactes et règles. rerank.scores renvoie le score enregistré quand le cours en possède un. Pour toute autre requête ou tout autre produit, il télécharge le modèle (environ 600 Mo) la première fois. Il calcule ensuite les scores des paires sur votre ordinateur.

  5. Comparez les deux ordres pour « beds that have leds » :

    Fenêtre de terminal
    search query "beds that have leds" --run rerank-ce
    rerank-ce: "beds that have leds" -> 10 results (query W-014: judged results are marked)
    1. LK-61422 emete low profile standard bed Beds 680.99 [out of stock] [exact]
    2. LK-72114 abner upholstered sleigh bed Beds 967.99 [exact]
    3. LK-62518 skofte odessa upholstered platform bed Beds 720.99 [exact]
    4. LK-43564 bassik upholstered low profile platform bed Beds 1113.99 [exact]
    5. LK-21564 satty bed led kit Bed Accessories 152.99 [exact]
    6. LK-21124 adjustable bed base Adjustable Beds 650.99 [irrelevant]
    7. LK-96147 galway upholstered led storage platform bed Beds 576.99 [exact]
    8. LK-59268 cieran tufted upholstered storage platform bed Beds 699.99 [out of stock] [irrelevant]
    9. LK-29326 jovenko upholstered led storage platform bed Beds 817.99 [exact]
    10. LK-84745 sabara upholstered led storage platform bed Beds 659.99 [out of stock] [exact]

    Huit des dix résultats sont exacts. Le NDCG@10 de cette requête passe de 0,073 à 0,852. Les produits 2, 3 et 4 occupaient les rangs hybrides 35, 36 et 44. L’étape un les avait trouvés, mais trop bas.

  6. Mesurez sur toutes les requêtes de test :

    Fenêtre de terminal
    search eval --run rerank-ce
    rerank-ce on 243 test queries: NDCG@10 0.635 (95% interval 0.589 to 0.679)
    recall@100 0.540, MRR 0.672, zero results 0.0%, judged in the top 10 66.7%; 1.6 ms a query (p50), 2.3 ms (p95)

    hybrid-rrf donnait 0,621 (0,576 à 0,663). Une requête s’est beaucoup améliorée; la moyenne a peu changé.

Une moyenne peut cacher deux groupes qui évoluent dans des directions opposées. Comparez les deux exécutions par langue :

Fenêtre de terminal
search compare hybrid-rrf rerank-ce --by language
rerank-ce minus hybrid-rrf on 241 test queries: ndcg@10 +0.014 (95% interval -0.008 to +0.036); better on 93, worse on 75, the same on 73
language queries hybrid-rrf rerank-ce difference low high worse
en 181 0.723 0.758 0.034 0.012 0.056 49
fr 60 0.311 0.264 -0.048 -0.100 0.005 26

La différence est calculée sur 241 requêtes, pas 243. Deux requêtes de test n’ont aucun produit exact, donc leur NDCG n’est pas défini. Le graphique montre la même comparaison par langue et par type de requête.

L'encodeur croisé sur les 50 premiers candidats, moins la recherche hybride, sur les requêtes de test de Larkfield, avec l'intervalle apparié à 95 %. Il aide les requêtes anglaises et nuit aux requêtes françaises.
Description textuelle du graphique

Deux panneaux de différences, avec une ligne à zéro. Par langue : toutes les requêtes +0,014 (−0,008 à +0,036); anglais +0,034 (+0,012 à +0,056); français −0,048 (−0,100 à +0,005). Par type : WANDS en anglais (requêtes réelles) +0,035 (+0,009 à +0,061); requêtes avec fautes ajoutées +0,043 (−0,018 à +0,109); français −0,048 (−0,102 à +0,001).

Sur les requêtes anglaises, le gain est de +0,034 (intervalle à 95 % de +0,012 à +0,056) : il est clair. Sur les requêtes françaises, le reclassement dégrade les résultats : −0,048 (−0,100 à +0,005). L’intervalle touche tout juste zéro; le préjudice est donc probable, mais pas certain. Dans l’ensemble, les deux effets se compensent : +0,014, sans gain clair.

Le modèle est entraîné pour l’anglais. Il lit une requête française comme si elle était anglaise. Vous avez vu la requête de test française « chaise ergonomique » (« ergonomic chair ») dans Recherche hybride. Le bi-encodeur multilingue a trouvé cinq chaises exactes. BM25 a trouvé des chaises longues, et la recherche hybride a mélangé les deux. La recherche hybride compte trois chaises de bureau exactes dans ses 5 premiers résultats. Les 3 premiers résultats de l’encodeur croisé :

rerank-ce: "chaise ergonomique" -> 10 results (query F-422: judged results are marked)
1. LK-25009 iancarlo chesterfield chaise lounge 161.99 [out of stock] [not judged]
2. LK-72973 rosemead velvet chaise lounge Indoor Chaise Lounges 269.99 [out of stock] [not judged]
3. LK-77648 anne chaise lounge Indoor Chaise Lounges 281.99 [not judged]

Les dix résultats sont des chaises longues ou des produits semblables. En anglais, « chaise » apparaît dans « chaise lounge », un long siège pour s’allonger. Le modèle a reconnu le mot anglais et ignoré « ergonomique ». Les chaises de bureau, aux rangs hybrides 1, 3 et 5, sortent des 10 premiers résultats. Le NDCG@10 de cette requête passe de 0,578 à 0,032.

Rappelez-vous que nos requêtes françaises sont traduites automatiquement à partir des requêtes anglaises de WANDS. De vrais clients francophones peuvent écrire autrement. Mais la direction est claire : un modèle uniquement anglais ne devrait pas réordonner les résultats français. Une protection simple consiste à ne pas utiliser l’encodeur croisé quand la requête est française. C’est un choix à mesurer, pas à présumer.

Classement en deux étapes montrait le compromis dans son explorateur. Le temps du modèle augmente avec chaque candidat. Seulement 10 candidats tiennent dans le budget de 200 ms d’Amira. Le projet utilise 50 candidats par défaut : 981 ms par recherche sur 1 fil d’exécution, pour un NDCG@10 de 0,635.

Les temps proviennent du portable de l’équipe du cours (un processeur Apple M4), avec le modèle exécuté en direct. Une deuxième mesure a séparé une recherche en étapes, sur 40 requêtes de test anglaises avec 1 fil. Avec les 50 candidats par défaut, l’encodeur croisé seul prenait 977 ms au p50 (710 ms sur 4 fils). La recherche complète prenait 1 121 ms au p50 et 1 445 ms au p95. Toutes les autres étapes prenaient quelques millisecondes. Les deux mesures provenaient d’exécutions distinctes, donc leurs chiffres diffèrent un peu (981 ms ci-dessus). Sur votre ordinateur, les temps seront différents, mais pas la forme de la courbe : le temps du modèle augmente avec chaque paire.

L’argent n’est pas le problème. Supposons qu’un serveur à 4 processeurs virtuels coûte 0,17 $ US l’heure (vérifiez le prix actuel de votre fournisseur). Alors, 1 000 recherches avec l’encodeur croisé sur 1 fil coûtent environ 0,013 $ US. Le temps est le problème.

Le carnet a trouvé que 20 candidats donnaient les meilleurs résultats sur la validation. Avant de l’exécuter, faites une prédiction : avec 20 candidats, les résultats français se dégradent-ils encore?

Fenêtre de terminal
search eval --run rerank-ce --set rerank=20 --by language
La sortie et ce qu’elle montre
rerank-ce on 243 test queries: NDCG@10 0.641 (95% interval 0.595 to 0.684)
recall@100 0.540, MRR 0.682, zero results 0.0%, judged in the top 10 68.5%; 1.5 ms a query (p50), 2.3 ms (p95)
language queries ndcg@10 low high zero-result rate
en 182 0.757 0.716 0.795 0.000
fr 61 0.293 0.207 0.378 0.000

Avec 20 candidats, le NDCG@10 est de 0,641 sur toutes les requêtes de test, la meilleure des cinq profondeurs. L’anglais reste autour de 0,757. Le français atteint 0,293, toujours sous les 0,311 de la recherche hybride. Mais il souffre moins qu’avec 50 candidats (0,264). Moins de candidats signifie moins d’occasions de faire monter une mauvaise chaise longue. Mais 20 candidats prennent 295 ms par recherche sur 4 fils : toujours au-delà du budget.

Erreur courante

Le temps d'évaluation n'est pas le temps du modèle

Symptôme : Tomás lit la sortie de search eval --run rerank-ce :

recall@100 0.540, MRR 0.672, zero results 0.0%, judged in the top 10 66.7%; 1.6 ms a query (p50), 2.3 ms (p95)

Il dit à Amira : « L’encodeur croisé n’ajoute presque rien : 1,6 ms par requête. On le met en production. »

Cause : search eval utilise les scores enregistrés. Il cherche 50 nombres dans un tableau. Il n’exécute jamais le modèle. Son temps est donc celui de la recherche hybride, plus une consultation du tableau. Le temps en direct, avec le modèle, est d’environ 1,1 seconde par recherche sur 1 fil.

Correction : mesurez le temps du système en direct, avec le modèle actif, comme dans Budgets de latence et de coût avec search bench. Présentez séparément le temps avec les scores enregistrés et le temps en direct. Précisez lequel vous citez.

Conséquence pour le travail en recherche : les enregistrements rendent les expériences rapides et reproductibles. Ils cachent aussi le coût de ce que vous avez enregistré. Avant une mise en production, mesurez le parcours réel, sur du matériel semblable à vos serveurs.

Utilisez un encodeur croisé quand le haut de votre liste exige une lecture attentive de la requête. Il faut aussi disposer du temps nécessaire. Il aide surtout les requêtes longues et descriptives, comme « beds that have leds ». Sur les requêtes précises de Larkfield, le gain est de +0,030 (+0,002 à +0,058). Sur les requêtes de test anglaises, il donne +0,034, un gain clair.

Ne l’utilisez pas sans vérifier :

  • Langue. Un modèle uniquement anglais nuit aux requêtes françaises : −0,048 sur le jeu de test de Larkfield. Utilisez un modèle de reclassement multilingue, ou évitez le reclassement pour les langues que le modèle ne connaît pas.
  • Temps. Une exécution du modèle par paire. Sur un processeur de portable, seulement 10 candidats tiennent dans les 200 ms. Un processeur graphique (GPU) serait beaucoup plus rapide; l’équipe du cours n’en a pas mesuré.
  • Licence. Vérifiez les données d’entraînement ainsi que les poids.

Sur les données de Larkfield, le gain total de l’encodeur croisé n’est pas clair. Il coûte aussi une seconde par recherche. La prochaine leçon essaie une autre deuxième étape. Elle apprend à partir de nombreux signaux, dont les scores textuels que vous avez déjà. Elle s’exécute en environ 36 ms.

Vérifiez votre compréhension

Pourquoi un bi-encodeur peut-il calculer ses vecteurs de produits à l'avance, mais pas un encodeur croisé ses scores?

Afficher la réponse

Un bi-encodeur encode chaque produit seul, sans la requête. Le vecteur du produit reste donc le même pour chaque recherche. Un encodeur croisé lit la requête et le produit ensemble. Son score dépend donc de la requête. Il ne peut s’exécuter qu’à l’arrivée de la requête : une exécution du modèle par paire.

Vérifiez votre compréhension

L'encodeur croisé donne +0,014 au total (−0,008 à +0,036), +0,034 en anglais et −0,048 en français. Omar demande si c'est un gain. Que lui dites-vous?

Afficher la réponse

Pas au total : l’intervalle comprend zéro. Le gain est clair pour les requêtes en anglais. C’est probablement une perte pour celles en français, car le modèle est entraîné pour l’anglais. Si Larkfield veut l’utiliser, réservez-le aux requêtes en anglais et mesurez ce changement. Il coûte aussi environ une seconde par recherche avec 50 candidats.

Vérifiez votre compréhension

search eval indique 1,6 ms par requête pour rerank-ce. Le budget d'Amira est de 200 ms. Peut-elle utiliser 50 candidats?

Afficher la réponse

Non. Les 1,6 ms reposent sur des scores enregistrés : le modèle ne s’est pas exécuté. En direct, 50 candidats ont pris environ 981 ms par recherche sur 1 fil et 732 ms sur 4 fils. Ces mesures proviennent du portable de l’équipe du cours. Seuls 10 candidats tiennent dans les 200 ms (155 ms sur 4 fils).

Récapitulatif

  • Un encodeur croisé lit la requête et un produit ensemble, puis donne un score. Il est plus précis qu’un bi-encodeur, mais s’exécute une fois par paire. Il convient donc uniquement à l’étape deux.
  • Pour « beds that have leds », il fait passer le NDCG@10 de 0,073 à 0,852. Sur toutes les requêtes de test de Larkfield, reclasser les 50 premiers résultats donne 0,635 (0,589 à 0,679). C’est +0,014 par rapport à la recherche hybride : le gain n’est pas clair.
  • Il aide les requêtes en anglais (+0,034, gain clair) et nuit à celles en français (−0,048). Le modèle fonctionne seulement en anglais et lit « chaise ergonomique » comme « chaise lounge ».
  • En direct, 50 candidats prennent environ 1,1 s par recherche sur 1 fil. Les 1,6 ms de search eval reposent sur des scores enregistrés et masquent le temps du modèle.

L’encodeur croisé connaît seulement le texte de la requête et du produit. Un magasin en sait plus : le prix, les stocks, les évaluations, ce que les gens ont acheté. Ensuite, vous entraînez un modèle qui combine tous ces signaux.

Leçon suivante : Apprentissage du classement