Aller au contenu
English

Budgets de latence et de coût

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

Où nous en sommes

Notre page de recherche est complète et évaluée hors ligne. Avant de servir le public, elle doit être rapide et abordable. Dans cette leçon, nous mesurons le temps de chaque étape, mettons en cache les requêtes populaires et calculons le coût par millier de requêtes.

Ce que vous saurez faire

Rendez la recherche assez rapide et abordable avant de servir le public. Vous mesurez le temps de chaque étape sur votre ordinateur et convertissez les millisecondes en coût par 1 000 requêtes. Vous voyez aussi combien économise un cache de requêtes populaires.

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

Le carnet (notebook) Jupyter chronomètre BM25 et la recherche dense sur 50 requêtes de test. Il convertit les millisecondes en argent avec le prix donné en exemple dans le cours. Il mesure aussi les recherches auxquelles répondrait un cache des 100 requêtes les plus fréquentes. Ses cellules de préparation téléchargent les données de pratique. Aucune préparation locale ni aucun téléchargement de modèle n’est donc nécessaire. Environ 20 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 35 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le projet larkfield-search à la fin du module 7, avec son environnement virtuel actif et search check qui réussit.
  • Les deux modèles des modules 5 et 6 (environ 800 Mo au total). S’ils ne sont pas encore sur votre ordinateur, search bench les télécharge la première fois.

Un restaurant promet un repas en 15 minutes. Le chef connaît chaque étape : 1 minute pour prendre la commande, 8 minutes sur le gril, 2 minutes pour dresser l’assiette. Si un nouveau plat exige 30 minutes au four, il ne peut pas figurer au menu du dîner, même s’il est excellent.

La cuisine prépare aussi certaines choses avant le dîner. La soupe du jour est prête dans une marmite. La moitié des clients la commandent et la reçoivent immédiatement.

Le chef surveille deux choses. Le temps : chaque repas arrive-t-il dans le délai promis? Et l’argent : combien de cuisiniers, pour combien de repas? La recherche fonctionne de la même façon.

Dans le module 6, l’encodeur croisé a reclassé les 50 premiers candidats. Sur les requêtes de test de Larkfield, le NDCG@10 est passé de 0,621 à 0,635. Ce gain n’était pas clair, mais supposons qu’il le soit. Cette conception est-elle prête pour le public?

Rappelez-vous le budget de latence d’Amira dans Une boutique où la recherche échoue : 200 ms. C’est le temps maximal d’une recherche, de la requête à la liste classée. C’est une hypothèse de ce cours, une cible courante pour une page de recherche qui semble instantanée.

Avec 50 candidats, l’encodeur croisé prenait 1 121 ms par recherche (la médiane) sur le portable de l’équipe du cours, avec 1 fil d’exécution. Un fil d’exécution (thread), ou simplement fil, est une suite de travail sur un cœur de processeur. C’est plus de cinq fois le budget. Les gens attendraient plus d’une seconde après chaque recherche. La meilleure conception hors ligne peut donc être la mauvaise conception pour le public.

Un budget de latence transforme « assez rapide » en un nombre que vous pouvez mesurer.

L’idée : mesurer chaque étape, puis répartir le budget

Section intitulée « L’idée : mesurer chaque étape, puis répartir le budget »

Une recherche est une chaîne d’étapes. Le temps total est à peu près la somme des temps des étapes. Vous mesurez donc chaque étape séparément pour voir où passe le temps.

Les temps de recherche varient. Une requête courte est rapide; une longue est plus lente. Un seul nombre ne suffit donc pas. Nous utilisons deux centiles :

  • p50 (la médiane) : la moitié des recherches sont plus rapides que cette valeur.
  • p95 (95e centile) : 95 recherches sur 100 sont plus rapides que cette valeur. Les 5 autres sont les recherches lentes.

Voici un petit exemple construit. Dix recherches ont pris les temps suivants, en ordre croissant : 4, 5, 5, 6, 6, 7, 7, 8, 9 et 40 ms.

Mesure Comment la lire Valeur
p50 le milieu de la liste triée : à mi-chemin entre la 5e valeur (6) et la 6e (7) 6,5 ms
moyenne la somme divisée par 10 9,7 ms
p95 près du haut de la liste environ 40 ms

Une seule recherche lente fait monter la moyenne à 9,7 ms. Sans elle, la moyenne serait de 6,3 ms. Le p50 change à peine. Le p95 montre la recherche lente. Le budget s’applique aussi aux recherches lentes : vérifiez donc le p95 autant que le p50.

L’équipe du cours a mesuré chaque étape sur 40 requêtes de test en anglais, sur son portable (Apple M4), avec 1 fil :

Une recherche avec un budget de 200 ms. D'abord, une vérification du cache : les 100 textes de requête les plus fréquents répondent à 51 % des recherches avec une page stockée. Sinon : orthographe 0,01 ms, puis BM25 lexical 1,1 ms et encodage de la requête 5,5 ms suivi de la recherche dense 2,1 ms, fusion 0,05 ms, puis l'étape LambdaMART, variables et modèle, 35 ms mesurées avec sa propre recherche de candidats. La conception complète est mesurée à 36 ms (p50). Un trajet pointillé : un encodeur croisé sur 50 candidats prend plutôt 977 ms, au-delà du budget.
Les étapes d'une recherche, p50 avec 1 fil, mesurées sur le portable de l'équipe du cours. Le cache répond à la moitié des recherches avant qu'une étape s'exécute.
Description textuelle du diagramme

Un flux de gauche à droite. « Une recherche, budget de 200 ms » mène à une question : « Dans le cache? » (les 100 textes les plus fréquents répondent à 51 % des recherches). Oui : « Page stockée, aucune recherche nécessaire ». Non : « Orthographe, 0,01 ms », puis deux branches : « BM25 lexical, 1,1 ms » et « Encoder la requête, 5,5 ms », suivie de « Recherche dense, 2,1 ms ». Les deux mènent à « Fusion, 0,05 ms », puis à « Étape LambdaMART, variables et modèle, 35 ms, mesurée avec sa propre recherche de candidats », puis à « La page : conception complète mesurée, 36 ms (p50) ». Une flèche pointillée part de la fusion : « plutôt : encodeur croisé sur 50, 977 ms », vers une boîte rouge « Au-delà du budget ».

Mesuré sur le portable de l'équipe du cours, 40 requêtes de test en anglais, 1 fil. L'étape LambdaMART comprend sa propre recherche de candidats. Les barres ne s'additionnent donc pas exactement; la conception complète a été mesurée à 36,1 ms.
Description textuelle du graphique

Six barres. Orthographe 0,01 ms, BM25 lexical 1,1 ms, encodage de la requête avec le bi-encodeur 5,5 ms, recherche dense 2,1 ms, fusion 0,05 ms et étape LambdaMART 35,3 ms.

Lisez le graphique de gauche à droite :

  • L’orthographe et la fusion ne coûtent presque rien : des centièmes de milliseconde.
  • BM25 lit un index, pas chaque produit, ce qui prend environ 1 ms.
  • L’encodage de la requête est la partie la plus lente de la recherche hybride. Le bi-encodeur est un petit réseau de neurones qui s’exécute une fois par recherche. La recherche dense elle-même multiplie un vecteur par une matrice de 40 066 lignes en 2,1 ms.
  • L’étape LambdaMART calcule 19 variables pour 100 candidats et exécute le modèle. Elle prend la majeure partie du temps, mais tient facilement dans le budget.

L’encodeur croisé n’apparaît pas sur le graphique, car il n’y entrerait pas. Dans cette mesure des étapes, il a pris 977 ms sur 50 candidats avec 1 fil, et 710 ms avec 4 fils. C’est la seule étape qui dépasse le budget. La recherche complète avec cet encodeur a pris 1 121 ms dans le tableau des conceptions ci-dessous. Chaque mesure venait d’une exécution distincte, donc les nombres diffèrent un peu.

Un modèle peut répartir son travail sur plusieurs fils. Reclassement par encodeur croisé montrait que son temps augmente avec le nombre de candidats reclassés. Seuls 10 candidats tenaient dans le budget. Voici le même explorateur. Cette fois, comparez seulement les temps avec 1 fil et 4 fils.

Explorer

L'encodeur croisé face au budget de 200 ms

NDCG@10
0,635
Temps par recherche (p50)
981 ms
Budget
200 ms

Reclasser 50 candidats prend 981 ms par recherche sur 1 fil : 781 ms au-delà du budget. Le NDCG@10 vaut 0,635 (0,589 à 0,679), +0,014 par rapport à l’étape un seule. Dans ses 50 premiers, l’étape un a 44 % des produits exacts : l’encodeur croisé ne peut ordonner que ce que l’étape un a trouvé. Pour comparer, LambdaMART atteint 0,668 en 36 ms.

  1. 40 066produits au catalogue
  2. Étape un : recherche hybride100 candidats9,2 ms
  3. Étape deux : encodeur croiséreclasse les 50 premiers972 ms
  4. La page10 premiers affichés
Classement en deux étapes sur les 243 requêtes de test de Larkfield (1 fil). Les lignes marquées « dépasse » manquent le budget.
ReclassésExacts parmi les n premiers de l’étape unNDCG@10 (intervalle à 95 %)Temps par recherche, p50, 1 fil budget 200 ms
0 (étape un seule)aucun0,621 (0,576–0,663)9,2 ms · tient
1027 %0,631 (0,587–0,672)194 ms · tient
2033 %0,641 (0,595–0,684)400 ms · dépasse
5044 %0,635 (0,589–0,679)981 ms · dépasse
10054 %0,631 (0,584–0,674)1 904 ms · dépasse
LambdaMART à la placeaucun0,66836 ms · tient
La recherche hybride trouve 100 candidats; l'encodeur croisé reclasse les n premiers. Temps réel par recherche (p50) sur le portable de l'équipe du cours, avec 1 ou 4 fils, et NDCG@10 sur les requêtes de test de Larkfield (moyenne de 241 des 243 requêtes).
Description textuelle de l’explorateur

L’explorateur commence avec 50 candidats reclassés sur 1 fil. Les boutons permettent de choisir 0, 10, 20, 50 ou 100 candidats et 1 ou 4 fils. Le tableau donne le temps par recherche avec 1 et 4 fils : 0 reclassé, 9,2 ms et 10,3 ms; 10, 194 ms et 155 ms; 20, 400 ms et 295 ms; 50, 981 ms et 732 ms; 100, 1 904 ms et 1 396 ms. La ligne du budget est à 200 ms. LambdaMART prend 36 ms avec 1 fil et 34 ms avec 4 fils, avec un NDCG@10 de 0,668.

Ce que montre l’explorateur

Non. Quatre fils réduisent le temps de 981 ms à 732 ms : un quart de moins, pas quatre fois moins. Et quatre fils occupent quatre cœurs de processeur pour cette seule recherche. Le serveur peut donc traiter moins de recherches simultanées, comme le montre la section sur les coûts ci-dessous.

Vous payez un serveur infonuagique à l’heure, qu’il soit occupé ou non. Ce cours utilise un exemple de prix : 0,17 $ US par heure pour un serveur avec 4 processeurs virtuels (vCPU) et 16 Go. C’est une hypothèse, pas une soumission. Les prix changent : consultez la page de votre fournisseur.

Exemple détaillé : le coût d’une recherche LambdaMART

Section intitulée « Exemple détaillé : le coût d’une recherche LambdaMART »

Une recherche occupe un vCPU pendant sa durée. Son coût est donc son temps processeur multiplié par le prix d’une vCPU-seconde.

Étape Calcul Valeur
Prix d’un vCPU pour une heure 0,17 ÷ 4 0,0425 $ US
Prix d’une vCPU-seconde 0,0425 ÷ 3 600 0,0000118 $ US
Temps processeur d’une recherche LambdaMART 36 ms × 1 fil 0,036 vCPU-seconde
Temps processeur de 1 000 recherches 0,036 × 1 000 36 vCPU-secondes
Coût de 1 000 recherches 36 × 0,0000118 environ 0,0004 $ US

Ainsi, 1 000 recherches LambdaMART coûtent moins d’un dixième de cent. Le nombre de fils multiplie le temps processeur : 750 ms sur 4 fils représentent 3 vCPU-secondes pour une recherche.

L’équipe du cours a mesuré chaque conception en exécution réelle sur 40 requêtes de test en anglais. Le coût utilise le prix ci-dessus et les temps p50. La réécriture par modèle de langage du module 4 fait appel à un modèle hébergé. Son coût est donc le prix par appel du fournisseur.

Conception p50 / p95 en ms $ US par 1 000 requêtes Tient dans 200 ms?
Larkfield aujourd’hui (current) 1,7 / 16,2 0,00002 oui
BM25 avec compréhension de la requête (bm25-norm+spell+syn) 1,1 / 2,0 0,00001 oui
Recherche hybride (hybrid-rrf) 9,2 / 15,1 0,0001 oui
LambdaMART (ltr) 36,1 / 54,1 0,0004 oui
Encodeur croisé sur 50 (rerank-ce), 1 fil 1 121 / 1 445 0,013 non
Encodeur croisé sur 50, 4 fils 753 / 1 119 0,035 non
Réécriture par modèle de langage (appel réseau) 1 195 / 1 581 0,04 (prix du fournisseur) non

Deux choses ressortent.

  1. Le coût n’est pas le problème ici. C’est le temps. Même la conception la plus coûteuse revient à quelques cents par 1 000 recherches. Mais trois conceptions dépassent le budget : au p95, d’un facteur de cinq ou plus.
  2. La meilleure conception hors ligne est aussi rapide. LambdaMART a le NDCG@10 le plus élevé du module 6 (0,668) et utilise un cinquième du budget.

Le coût réel : les serveurs pour l’heure la plus occupée

Section intitulée « Le coût réel : les serveurs pour l’heure la plus occupée »

Le coût par requête cache une chose. Vous payez les serveurs à l’heure, et il vous en faut assez pour le moment le plus occupé. Un serveur a 4 vCPU. Si chaque recherche LambdaMART occupe un vCPU pendant 36 ms, un vCPU peut traiter environ 1 000 ÷ 36 ≈ 27 recherches par seconde. Avec 4 vCPU, le serveur peut traiter environ 110 recherches par seconde lorsqu’il est entièrement occupé.

L’encodeur croisé sur 4 fils occupe les 4 vCPU pendant environ 750 ms. Le même serveur traite environ 1,3 recherche par seconde. Pour le même trafic, il faut environ 80 fois plus de serveurs. Les vrais serveurs ont aussi besoin d’une marge : prévoyez donc une utilisation inférieure à leur capacité totale. Le cours Mettre à l’échelle les API et les charges de travail d’IA mesure la capacité en détail.

Un cache conserve les résultats d’une requête récente. La prochaine personne qui fait la même requête les reçoit sans recherche. Le module 1 montrait que quelques textes de requête représentent une grande partie du journal de Larkfield. C’est la tête du journal. Un cache fonctionne bien sur cette tête.

Mesurée sur le journal synthétique des requêtes (20 000 recherches) : la part des recherches dont le texte figure parmi les n textes les plus fréquents. Un vrai journal a aussi une tête et une longue traîne, mais ses nombres diffèrent.
Description textuelle du graphique

Cinq barres. Un cache des 10 textes de requête les plus fréquents répond à 20,4 % des recherches; 40 textes, 37,1 %; 100 textes, 51,1 %; 500 textes, 84,5 %; 1 000 textes, 95,4 %.

Les 100 textes les plus fréquents répondent à la moitié des recherches. Le journal de Larkfield est synthétique, et notre code a rendu fréquentes les requêtes courtes et larges. Dans une vraie boutique, vérifiez cette courbe sur votre propre journal avant de créer un cache.

Mettez en cache la liste classée des identifiants de produit, pas la page complète. Le prix, le stock et l’indicateur de solde changent pendant la journée. Lisez leurs valeurs actuelles lorsque vous construisez la page.

Toute réponse en cache vieillit. L’invalidation du cache consiste à supprimer les anciennes réponses quand quelque chose change. Supprimez le cache quand vous passez à un nouvel index ou modèle de classement, comme le montre Garder l’index à jour. Donnez aussi à chaque réponse une courte durée de vie, par exemple une heure, pour que les nouveaux produits apparaissent. Le cours Mettre à l’échelle les API et les charges de travail d’IA couvre en profondeur les clés de cache et l’invalidation.

Un cache ne rend pas rapide la traîne lente. La moitié des recherches de Larkfield ne trouvent toujours pas de réponse dans le cache. Elles ont besoin d’une conception qui tient dans le budget à elle seule.

Les index doivent tenir en mémoire, sinon chaque recherche attend le disque. L’équipe du cours a mesuré :

  • Les index lexicaux (SQLite FTS5 et BM25 pour chaque champ et analyseur) : 102,5 Mo.
  • Le fichier de plongements (embeddings) des produits (40 066 × 384 nombres, float16) : 31,3 Mo sur disque (30,8 Mo pour les nombres seuls en mémoire). Float32 doublerait la taille. Sur 200 requêtes, float16 a conservé 99,3 % des 10 premiers résultats de float32.

Les deux tiennent facilement dans un serveur de 16 Go. La recherche dense lit chaque ligne de la matrice de plongements. Son temps augmente donc avec le catalogue. À 40 066 produits, elle prend 2,1 ms. Un catalogue dix fois plus grand demanderait environ dix fois plus de temps : ce serait encore rapide. Pour des millions de produits, les équipes utilisent un index approximatif comme HNSW. C’est un graphe de proches voisins, offert dans des bibliothèques comme FAISS. Il ne lit qu’une petite partie des vecteurs et peut manquer quelques vrais voisins. À cette taille, Larkfield n’en a pas besoin. Les mêmes idées dans un serveur de recherche en montre un.

Ce module ajoute trois fichiers Python et un fichier de test au projet. Copiez-les tous maintenant, avec le README, à partir de l’instantané end-of-m08. Cette leçon utilise bench.py. La prochaine utilise interleave.py.

  1. Dans larkfield-search, avec l’environnement virtuel actif, copiez les fichiers :

    Fenêtre de terminal
    S=../nextia-learning-labs/C38/snapshots/end-of-m08
    for f in larkfield_search/bench.py larkfield_search/interleave.py larkfield_search/commands/online.py tests/test_online.py README.md; do
    cp "$S/$f" "$f"
    done

    Aucun nouveau paquet n’est nécessaire.

  2. Exécutez les tests :

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

    Trois tests sont nouveaux. L’un vérifie la formule de coût : 100 ms sur un fil à 0,17 $ US par heure pour 4 vCPU.

  3. Avant l’étape suivante, notez votre prédiction : sur votre ordinateur, combien de temps prendra l’étape LambdaMART?

  4. Mesurez chaque étape sur 30 requêtes de test, avec les modèles sur 4 fils (la valeur par défaut) :

    Fenêtre de terminal
    search bench --queries 30

    La première exécution charge les deux modèles, ce qui prend environ 30 secondes. PyTorch peut d’abord afficher une ligne d’avertissement sur « Redirects » (redirections). Vous pouvez l’ignorer. Sur le portable de l’équipe du cours, la sortie était :

    30 test queries, models on 4 thread(s); milliseconds per query:
    stage p50 p95
    understand 0.0 1.9
    lexical 0.6 1.0
    encode 5.8 6.8
    dense search 1.2 1.3
    fusion 0.1 0.1
    rerank 50 726.5 868.7
    ltr features and model 32.7 59.6
    design p50 ms p95 ms US$ per 1,000
    hybrid 7.7 20.5 0.00036
    hybrid + rerank 50 734.2 876.4 0.03467
    ltr (hybrid inside) 38.5 65.4 0.00182
    index (FTS5 and BM25): 81.2 MB
    product embeddings: 31.3 MB

    Vos nombres seront différents : ils dépendent de votre ordinateur et des autres programmes qui y tournent.

  5. Exécutez de nouveau avec 1 fil et comparez la colonne de coût :

    Fenêtre de terminal
    search bench --queries 30 --threads 1

    Sur le portable de l’équipe du cours, hybrid + rerank 50 prenait 1 036,8 ms (p50) et coûtait 0,01224 $ US par 1 000 recherches. Le coût est inférieur avec 1 fil, car il utilise un vCPU au lieu de quatre. Le temps est plus long.

Regardez les deux dernières lignes. Votre index est plus petit que 102,5 Mo (ici 81,2 Mo; le vôtre peut différer). Le projet construit l’index d’un champ seulement lorsqu’une exécution en a besoin pour la première fois. Vous n’avez pas encore exécuté toutes les conceptions dans ce dossier.

À vous de jouer : un budget pour un serveur plus lent

Section intitulée « À vous de jouer : un budget pour un serveur plus lent »

Le vrai serveur de Larkfield pourrait être plus lent que le portable de l’équipe du cours. Supposez que chaque étape y prend trois fois plus de temps. Utilisez les durées des étapes de cette leçon (p50, 1 fil) et répondez sans rien exécuter :

  1. LambdaMART tient-il encore dans le budget de 200 ms? Vérifiez aussi son p95.
  2. Omar veut réserver la réécriture par modèle de langage aux requêtes absentes du cache. Combien de recherches du journal synthétique attendraient encore cette réécriture, avec un cache des 100 textes les plus fréquents?
Réponses
  1. Oui. 36,1 ms × 3 ≈ 108 ms au p50, et 54,1 ms × 3 ≈ 162 ms au p95. Les deux tiennent dans le budget de 200 ms. Toutefois, le p95 laisse peu de marge pour le réseau et la page.
  2. Environ la moitié : 48,9 %. Les 100 textes les plus fréquents répondent à 51,1 % des recherches. Les autres 48,9 % attendraient environ 1,2 seconde (p50) pour la réécriture. Une meilleure approche : réécrire les requêtes de tête une seule fois, conserver les réécritures et garder les requêtes de la traîne sur le parcours rapide.

Erreur courante

Mesurer sur un portable au calme et promettre ce résultat en production

Symptôme : Tomás exécute search bench --queries 10 une seule fois. Il voit que l’encodeur croisé traite 10 candidats en 155 ms sur 4 fils. Il dit à Omar : « Ça tient dans le budget. »

Cause : une courte exécution sur un portable peu sollicité mesure le meilleur cas. Le p50 masque les recherches lentes. Selon les mesures de l’équipe du cours, 10 candidats sur 4 fils donnaient un p50 de 155 ms. Le p95 atteignait toutefois 196 ms. Sur 1 fil, le p95 était de 525 ms. Un serveur occupé exécute aussi plusieurs recherches à la fois. Elles partagent donc le processeur, ce qui ralentit chacune d’elles.

Solution : mesurez le p95 en plus du p50, sur au moins 30 requêtes, avec du matériel semblable au serveur. Gardez une marge pour le réseau et la page : une étape qui prend à elle seule 155 des 200 ms ne convient pas.

Conséquence pour le travail en recherche : un budget est une promesse concernant les recherches lentes, avec un trafic réel. Mesurez dans ces conditions, ou gardez une grande marge.

Mesurez la durée de chaque étape avant de choisir une conception, pas après. Une conception qui gagne hors ligne, mais dépasse le budget, n’est pas une candidate. Mesurez de nouveau sur le serveur, sous charge, avant la mise en production.

Ce travail coûte peu. search bench prend moins d’une minute. Le carnet (notebook) Jupyter prend environ 20 minutes. Les économies sont importantes : Larkfield n’a pas créé un service d’encodeur croisé qui aurait exigé beaucoup plus de serveurs. Il aurait quand même été trop lent.

Utilisez un cache quand les requêtes de tête représentent une grande part de votre journal. Ne vous en servez pas pour justifier une conception lente : les requêtes de la traîne suivent encore le parcours lent.

Vérifiez votre compréhension

Dix recherches ont pris 3, 3, 4, 4, 5, 5, 5, 6, 6 et 90 ms. Quel est le p50, et quel nombre Amira devrait-elle comparer à son budget?

Afficher la réponse

Le p50 est de 5 ms (entre les 5e et 6e valeurs triées, 5 et 5). Amira devrait aussi vérifier le p95, qui est proche de 90 ms ici. Le budget est une promesse pour les recherches lentes aussi.

Vérifiez votre compréhension

À 0,17 $ US l'heure pour 4 processeurs virtuels (vCPU), combien coûtent 1 000 recherches de 9 ms sur 1 fil?

Afficher la réponse

9 ms × 1 000 = 9 vCPU-secondes. Une vCPU-seconde coûte 0,17 ÷ 4 ÷ 3 600 ≈ 0,0000118 $ US. Donc, 9 × 0,0000118 ≈ 0,0001 $ US. C’est le coût de la recherche hybride dans le tableau de cette leçon.

Vérifiez votre compréhension

Un cache des 100 textes les plus fréquents répond à 51,1 % des recherches de Larkfield. Pourquoi la conception sans cache doit-elle quand même tenir dans le budget?

Afficher la réponse

Parce que les autres 48,9 % des recherches ne trouvent rien dans le cache et exécutent la recherche complète. La plupart sont des requêtes de la traîne, chacune saisie par peu de personnes. Un cache accélère la moyenne, mais n’aide pas la personne qui saisit une requête rare.

Récapitulatif

  • Un budget de latence est la durée maximale d’une recherche : 200 ms pour Larkfield (une hypothèse). Vérifiez le p95 autant que le p50.
  • Sur le portable de l’équipe du cours, chaque étape prend quelques millisecondes, sauf l’encodeur croisé. LambdaMART prend 36 ms (p50). L’encodeur croisé sur 50 candidats prend 1 121 ms sur 1 fil et 753 ms sur 4 fils.
  • Coût par 1 000 requêtes = secondes de processeur × prix d’une vCPU-seconde. À 0,17 $ US l’heure pour 4 vCPU (une hypothèse), chaque conception coûte quelques cents ou moins. Le temps est la limite. Les serveurs nécessaires pour l’heure la plus occupée représentent le vrai coût.
  • Un cache des 100 textes les plus fréquents répond à 51,1 % des recherches du journal synthétique. Mettez les identifiants de produits en cache, lisez les prix et les stocks à jour. Videz le cache quand l’index ou le modèle change.

Vous avez maintenant une conception rapide et peu coûteuse. Mais le NDCG hors ligne utilise des jugements, pas des personnes. Ensuite, vous testerez un changement avec les clics des personnes : entrelacement (interleaving) et tests A/B.

Leçon suivante : Tester les changements en ligne