Aller au contenu
English

Travail final

  • Après les études de cas
  • environ 3 h

Où nous en sommes

Chaque module a ajouté un élément de recherche et l'a mesuré séparément : le jeu de test, BM25, la compréhension de la requête, la recherche hybride, le reclassement et la page. Dans ce travail, vous les utilisez tous pour la nouvelle saison de Larkfield.

Ce que vous saurez faire

Appliquez chaque module du cours à une nouvelle situation. Livrez un dossier de conception de recherche qu’Omar, Amira et Hana pourront utiliser. La nouvelle saison ressemble au catalogue du cours, mais ses produits n’ont aucun clic et ses requêtes n’ont aucun jugement. Vous devez donc mesurer chaque choix à nouveau, plutôt que le copier des leçons.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 180 minutes
  • Vous avez terminé les modules 1 à 8. Chaque partie ci-dessous nomme les leçons qu’elle utilise.
  • Vous n’avez pas besoin des études de cas du module 9 pour ce travail. (Le certificat en exige au moins une.) Pour voir d’abord cinq conceptions comparées sur tout WANDS, ouvrez Recherche de produits pour un magasin de meubles.
  • Votre dossier larkfield-search fonctionne à la fin du module 8 : python -m pytest -q affiche 39 passed (39 tests réussis), comme dans Budgets de latence et de coût. Les données du cours sont dans larkfield-search/data. Le dossier nextia-learning-labs est à côté de larkfield-search, comme dans Découvrir le catalogue et le journal des requêtes.
  • Prévoyez environ 3 h de travail, plus le temps pour juger les résultats. Le jugement est la partie la plus longue. Prévoyez environ 3 h pour environ 1 000 notes, à environ 10 secondes par note. Le travail informatique est court. Dans la solution de l’auteur, la conception la plus lente utilisait l’encodeur croisé (cross-encoder) : environ une seconde par requête, car il lit 50 produits pour chaque requête.
  • Testé sur macOS avec Python 3.12.13 et les versions fixées des paquets du projet. Les commandes Windows sont fournies, mais elles n’ont pas été exécutées.

Larkfield ajoute une nouvelle saison à son catalogue. Trois choses changent en même temps :

  • De nouveaux produits. 2 000 produits arrivent en mars. Personne ne les a encore cherchés, donc ils n’ont aucun clic dans le journal. C’est le démarrage à froid de Nouveaux produits et démarrage à froid, mais pour une saison entière.
  • De nouvelles requêtes. Les clients saisiront des requêtes jamais utilisées dans le cours : des requêtes anglaises, des requêtes françaises et quelques problèmes d’exercice que nous avons créés exprès.
  • Aucun jugement. Personne n’a jugé les nouvelles requêtes. Avant de dire qu’une conception est meilleure, vous devez créer votre propre jeu de test.

Omar, le gestionnaire de produit, veut que les nouveaux produits soient trouvés dès le premier jour. Amira, la développeuse, maintient son budget : 200 ms pour une recherche. Hana, la responsable du marchandisage, demande encore « les articles en solde d’abord » sur la page de la nouvelle saison. Tomás, l’ingénieur en IA, a une réponse prête : « Utilisez la meilleure conception du cours. LambdaMART a gagné, alors livrez LambdaMART. »

Priya vous demande de leur répondre avec des preuves. L’image montre l’ordre du travail :

Un flux de gauche à droite. Les données du cours et la nouvelle saison entrent dans make_data.py. Ensuite, l'étape 1, choisir et juger, sépare les requêtes jugées en une partie de développement et une partie réservée verrouillée. La partie de développement alimente les étapes 2 et 3, les conceptions et les changements de requêtes, puis l'étape 4, le choix. L'exécution sur la partie réservée a lieu une seule fois, après le choix. L'étape 5, le plan de test en ligne, vient en dernier.
L'ordre du travail. La partie réservée reste verrouillée jusqu'à ce que tous les choix soient faits; vous l'exécutez ensuite une seule fois.
Description textuelle du diagramme

Deux cases grises à gauche : les données du cours (40 066 produits, le journal, les clics et les jugements) et la nouvelle saison (2 000 nouveaux produits sans clics, 120 requêtes sans jugements). Les deux entrent dans make_data.py, qui crée un dossier de données contenant 42 066 produits. Ensuite vient l’étape 1, choisir et juger : une règle choisit l’échantillon, vous réunissez les 10 premiers résultats, les jugez avec des consignes et mesurez l’accord avec un deuxième juge. Les requêtes jugées se séparent en deux : une partie de développement que vous mesurez aussi souvent que vous voulez, et une partie réservée, en rouge, qui reste verrouillée. La partie de développement alimente les étapes 2 et 3, les conceptions et les changements de requêtes, puis l’étape 4, le choix selon les tranches, la latence et le coût. Après le choix, l’exécution sur la partie réservée a lieu une seule fois, en rouge, sans changement par la suite. L’étape 5, le plan de test en ligne décidé à l’avance, vient en dernier.

Soyez honnête au sujet des données. Les produits, les requêtes et les jugements humains viennent de WANDS (licence MIT), comme dans le cours. Les prix, le stock, les indicateurs de solde et les dates sont synthétiques : notre code les a créés. Le journal des requêtes est aussi synthétique. Un modèle de langage a traduit automatiquement les requêtes françaises à partir de requêtes anglaises. Les retraduire est donc plus facile qu’avec de vrais clients francophones. Présentez vos chiffres « sur les requêtes de la nouvelle saison de Larkfield », avec leurs intervalles. Ne les promettez pas pour un vrai magasin.

Les données sont dans le dépôt des laboratoires, dans C38/final/. Les données du cours, dans C38/data/, restent inchangées.

Fichier Lignes Ce que représente une ligne
catalogue_new.csv.gz 2 000 Un produit de la nouvelle saison, avec les mêmes 17 colonnes que le catalogue du cours. Tous ont été ajoutés entre le 2 mars 2026 et le 15 mars 2026. Aucun ne figure dans le journal des requêtes et aucun n’a de clic. 403 ont un titre français (traduit automatiquement).
queries.csv 120 Une requête de la nouvelle saison : query_id (N-001 à N-120), query et language (en ou fr, anglais ou français). Aucun jugement.
embeddings/products_new.npy, embeddings/queries.npy 2 000 et 120 Les plongements (embeddings) des nouveaux produits et des requêtes, créés avec le bi-encodeur du cours, dans l’ordre des fichiers.
make_data.py Crée un dossier de données que la commande search peut lire : les données du cours, ce dossier et vos jugements.

Le dossier contient aussi embeddings/model.json, README.md, dataset-card.md et SHA256SUMS. Sa taille est d’environ 2 Mo. Les identifiants sont nouveaux et dans un ordre aléatoire : un identifiant ne révèle rien sur une requête. L’équipe du cours conserve les jugements des 120 requêtes. Personne ne les utilise pour faire des choix.

Vérifiez les fichiers, créez le dossier de données et indiquez-le au projet. Exécutez ceci dans votre dossier larkfield-search, avec .venv actif :

Fenêtre de terminal
git -C ../nextia-learning-labs pull
F=../nextia-learning-labs/C38/final
(cd "$F" && shasum -a 256 -c SHA256SUMS | grep -vc ': OK$')
python "$F/make_data.py"
export LARKFIELD_DATA=final-data LARKFIELD_OUTPUTS=outputs-final
search info
search index

Le nombre affiché par shasum est le nombre de fichiers incorrects. Il doit être 0. Ensuite, make_data.py, search info et search index affichent :

Wrote final-data/: 42,066 products (2,000 new), 120 final queries, 0 of your judgments.
Splits: train 260, validation 121, course-test 243, test 120
No judgments yet: search eval prints nan for the final queries until you add yours.
Note: search check compares with the course data, so it fails on this folder. Use search info.
Catalogue: 42,066 products in 551 product classes; 8,000 with a French title (machine-translated)
In stock: 87.1%; on sale: 14.8% (synthetic)
Queries with judgments: 744 (260 train, 121 validation, 120 test); English 583, French 161
Judgments: 291,230 (exact, partial or irrelevant)
Query log (synthetic): 20,000 searches, 1,903 different queries, 2025-09-01 to 2025-10-26
Indexed 42,066 products in 2.5 s: SQLite FTS5 (title, description) and BM25 (title and description). Index size 55.5 MB.

Ce qui s’est passé :

  • make_data.py a créé un nouveau dossier, final-data/. Votre dossier data/ n’a pas changé. Le nouveau dossier contient les 42 066 produits de la nouvelle saison, les requêtes et jugements du cours, et les 120 nouvelles requêtes.
  • Les requêtes de test du cours forment maintenant la partition course-test. Les nouvelles requêtes forment la partition test, donc search eval et search compare les mesurent. Elles n’ont pas encore de jugements, donc search eval affiche nan (valeur non numérique) pour l’instant.
  • search info compte les 120 nouvelles requêtes comme des « requêtes avec jugements », mais compte 0 jugement pour elles : les 291 230 jugements viennent tous du cours.
  • LARKFIELD_DATA indique le dossier à chaque commande search. LARKFIELD_OUTPUTS garde le nouvel index séparé de celui du cours. Fermez le terminal, ou supprimez les deux variables, pour revenir aux données du cours.
  • search check compare avec les données du cours, donc il échoue sur ce dossier. C’est normal.

search bench et search interleave lisent les requêtes de test du cours. Exécutez-les donc avec les données du cours (les deux variables supprimées). La partie 4 montre comment chronométrer une conception sur le nouveau catalogue.

Créez un dossier search-pack/ dans votre dossier larkfield-search. Placez-y tous les fichiers du travail. Ce qu’il faut remettre donne la liste des fichiers.

Le dossier suit les règles de réussite du cours : une partie pour chaque élément exigé.

Une case en haut : search-pack avec REPORT.md. En dessous, cinq cases : 1 Jeu de test, 2 Conceptions, 3 Changements de requêtes, 4 Le choix, 5 Plan en ligne, chacune avec son contenu et son fichier.
Les cinq parties du dossier de conception de recherche et les fichiers à remettre.
Description textuelle du diagramme

Une case en haut : le dossier search-pack, avec REPORT.md et les commandes qui produisent chaque chiffre. En dessous, cinq cases. 1 Jeu de test : GUIDELINES.md, splits.csv, pool.csv et judgments.csv, avec l’accord avec un deuxième juge. 2 Conceptions : comparison.csv, avec BM25 et trois autres familles, globalement et par tranche, avec des intervalles. 3 Changements de requêtes : une ligne par changement, avec la différence appariée qui a mené à le garder ou l’abandonner. 4 Le choix : latence p50 et p95, coût par 1 000 requêtes et OMAR.md, qui explique pourquoi cette conception. 5 Plan en ligne : ONLINE.md, avec l’entrelacement ou un test A/B, la mesure, les garde-fous, la taille et la règle d’arrêt.

Utilise Jugements de pertinence, Créer un jeu de test qui représente vos utilisateurs et Jugements d’un modèle de langage.

Il n’y a aucun jugement. Le NDCG en a besoin. Votre première tâche est donc celle d’une vraie équipe pour une nouvelle saison : choisir des requêtes, regarder les résultats et leur donner une note. Vous ne pouvez pas juger les 120 requêtes et les 42 066 produits. Vous jugez un échantillon, et vous le jugez bien.

  1. Choisissez les requêtes avant d’exécuter toute conception. Prenez au moins 40 des 120 requêtes. Choisissez-les uniquement à partir des colonnes publiques, avec une règle écrite dans REPORT.md. Par exemple : toutes les requêtes dont le numéro se termine par 1, 3, 6 ou 8. Ne choisissez jamais une requête parce qu’une conception y semble bonne ou mauvaise.

  2. Choisissez maintenant la partie réservée, avec une deuxième règle. Par exemple : parmi vos requêtes choisies, celles dont le numéro est un multiple de 3. Écrivez les deux parties dans search-pack/splits.csv, avec les colonnes query_id et part (dev ou heldout, développement ou partie réservée). Vous mesurerez la partie réservée une seule fois, à la fin, comme dans Gardez certaines requêtes à l’écart de votre travail.

  3. Étiquetez les tranches à partir du texte. Ajoutez une colonne kind à splits.csv : par exemple english (anglais), french (français), code (un code de produit) et misspelt (avec des fautes d’orthographe). Lisez chaque requête pour décider. Ajoutez aussi toute tranche enseignée dans le cours que vous pouvez reconnaître, comme les requêtes contenant un nombre. Écrivez la taille de chaque tranche dans REPORT.md.

  4. Écrivez vos consignes. Partez du fichier docs/judging-guidelines.md du projet et enregistrez votre version dans search-pack/GUIDELINES.md. Ajoutez une règle pour chaque nouveau cas rencontré : une requête française et un produit anglais, un code de produit, un nom de marque mal écrit, un nouveau produit presque sans description.

  5. Réunissez les résultats. Pour chaque requête choisie, prenez les 10 premiers résultats d’au moins quatre conceptions de familles différentes. Par exemple : bm25, bm25-norm+spell+syn, hybrid-rrf et ltr. Jugez chaque produit qu’au moins une d’elles affiche. C’est la mise en commun : aucune conception n’est alors mesurée sur des produits que personne n’a jugés. Un court script le fait avec les fonctions du projet :

    # search-pack/pool.py: run it with LARKFIELD_DATA=final-data (and after search ltr train)
    import pandas as pd
    from larkfield_search import data, engine
    chosen = set(pd.read_csv("search-pack/splits.csv")["query_id"])
    q = data.queries()
    q = q[q["query_id"].isin(chosen)]
    cat = data.catalogue().set_index("product_id")
    pool = {}
    for run in ["bm25", "bm25-norm+spell+syn", "hybrid-rrf", "ltr"]:
    ranked, _ = engine.run_queries(run, q, k=10)
    for qid, ids in ranked.items():
    for pid in ids:
    pool.setdefault((qid, pid), []).append(run)
    text = dict(zip(q["query_id"], q["query"]))
    rows = [{"query_id": qid, "query": text[qid], "product_id": pid, "title": cat.loc[pid, "title"],
    "product_class": cat.loc[pid, "product_class"], "found_by": " ".join(runs), "your_grade": ""}
    for (qid, pid), runs in sorted(pool.items())]
    pd.DataFrame(rows).to_csv("search-pack/pool.csv", index=False)
    print(len(rows), "pairs to judge")

    Exécutez search ltr train une fois avant : le modèle LambdaMART apprend des requêtes d’entraînement du cours, comme dans Apprentissage du classement. Dans l’exécution de l’auteur, ces quatre conceptions ont donné environ 24 produits à juger par requête : 1 139 paires pour 48 requêtes. Avec la recherche dense et l’encodeur croisé en plus, l’ensemble à juger est passé à 1 521 paires.

  6. Jugez. Remplissez your_grade avec 2 (exact), 1 (partiel) ou 0 (non pertinent), selon vos consignes. Ouvrez la description du produit quand le titre ne suffit pas. Ne regardez pas found_by pendant le jugement : cette colonne indique quelle conception a trouvé le produit et peut influencer votre note. Enregistrez le fichier dans search-pack/judgments.csv.

  7. Mesurez l’accord avec un deuxième juge. Demandez à un collègue de juger au moins 100 de vos paires sans voir vos notes. Ou utilisez un modèle de langage comme juge, comme dans Jugements d’un modèle de langage. Donnez-lui vos consignes, la requête et le produit, et demandez une note. Utilisez votre propre clé et indiquez le coût. Présentez l’accord, le kappa de Cohen et le tableau 3 × 3, comme le fait search judge agree. Dites quel juge est plus sévère, aussi par langue.

  8. Donnez vos jugements au projet :

    Fenêtre de terminal
    python "$F/make_data.py" --judgments search-pack/judgments.csv --splits search-pack/splits.csv
    search eval --run bm25 --by kind

    Vos requêtes de développement forment maintenant la partition test. Vos requêtes réservées forment la partition heldout, qu’aucune commande ne lit. La colonne kind de votre fichier de partitions se trouve dans queries.csv, donc --by kind fonctionne.

Partie 2 : une référence de base et trois autres familles

Section intitulée « Partie 2 : une référence de base et trois autres familles »

Utilise BM25, Recherche par le sens, Recherche hybride, Reclassement par encodeur croisé et Apprentissage du classement.

  1. La référence de base. Mesurez bm25 sur vos requêtes de développement. Chaque autre conception lui est comparée.

  2. Au moins trois autres familles. Par exemple : la compréhension de la requête sur BM25 (bm25-norm+spell+syn), la recherche dense (dense), la recherche hybride (hybrid-rrf ou hybrid-blend), l’encodeur croisé (rerank-ce) et LambdaMART (ltr). Deux réglages d’une même famille comptent comme une seule famille.

    Fenêtre de terminal
    search eval --run hybrid-rrf --by kind
    search compare bm25-norm+spell+syn ltr --by kind

    Les scores enregistrés de l’encodeur croisé couvrent seulement les requêtes du cours. Pour les nouvelles requêtes, rerank-ce télécharge l’encodeur croisé la première fois (environ 600 Mo) et calcule le score de chaque paire sur votre ordinateur.

  3. Présentez les colonnes du cours pour chaque conception : le NDCG@10 avec son intervalle à 95 %, le rappel à 100 (recall@100), le MRR, le taux de requêtes sans résultat, judged@10 et la latence. Écrivez-les dans search-pack/comparison.csv, une ligne par conception, comme dans le tableau de comparaison du cours.

  4. Divisez en tranches. Donnez le NDCG@10 par kind pour chaque conception, avec la taille de chaque tranche. Utilisez search compare pour les différences que vous affirmez : une différence appariée avec son intervalle.

  5. Examinez judged@10. Une conception qui trouve des produits absents de votre ensemble à juger est mesurée injustement, car un produit non jugé compte comme non pertinent. Si le judged@10 d’une conception est faible, jugez aussi ses produits manquants et dites-le.

  6. Examinez les nouveaux produits. Comptez combien de fois chaque conception place un produit de la nouvelle saison parmi ses 10 premiers résultats. Notez aussi les rangs de vos nouveaux produits jugés exacts. Une conception qui a appris des clics n’a aucun clic pour eux.

Partie 3 : compréhension de la requête, un changement à la fois

Section intitulée « Partie 3 : compréhension de la requête, un changement à la fois »

Utilise Normaliser le texte, Corriger l’orthographe, Synonymes et réécriture de requête, Détecter ce que demande la requête et Correspondances exactes et règles.

  1. Ajoutez un changement à la fois et mesurez chacun par rapport à l’étape précédente, avec search compare : la règle des codes (bm25-fields+codes), la normalisation et la racinisation (bm25-norm), la correction orthographique (+spell), les synonymes (+syn) et le détecteur de classe et de prix (+detect).

    Fenêtre de terminal
    search compare bm25-norm bm25-norm+spell --by kind
  2. Gardez ou abandonnez chaque changement selon sa mesure. Écrivez une ligne par changement dans REPORT.md : la différence appariée avec son intervalle, les tranches améliorées, les tranches dégradées et votre décision. « Il a aidé la tranche avec fautes d’orthographe sans nuire aux autres » est une raison. « C’est une bonne idée » n’en est pas une.

  3. Trouvez une requête à laquelle un changement nuit. La correction orthographique transforme de vrais noms en mots courants, comme dans Une mauvaise correction est pire qu’aucune correction. Cherchez une requête dont le NDCG@10 baisse. Dites ce que vous feriez : protéger les mots présents dans le catalogue, ajouter un lien « vouliez-vous dire » ou ne rien faire.

  4. Essayez un changement de votre choix, par exemple une nouvelle règle de synonymes dans une copie de synonyms.csv, une protection pour le correcteur orthographique ou la règle des codes pour des codes écrits autrement. Mesurez-le comme les autres.

  5. La réécriture par modèle de langage (llm-rewrite) a des réponses enregistrées seulement pour les requêtes du cours. Pour les nouvelles requêtes, elle cherche avec la requête elle-même, donc elle ne mesure rien de nouveau. Excluez-la, ou réécrivez les requêtes avec votre propre clé et indiquez le coût et le temps par requête.

Partie 4 : choisir une conception, puis exécuter la partie réservée

Section intitulée « Partie 4 : choisir une conception, puis exécuter la partie réservée »

Utilise Budgets de latence et de coût, Nouveaux produits et démarrage à froid et Aucun résultat et règles d’affaires.

  1. Chronométrez chaque conception candidate sur le nouveau catalogue. LARKFIELD_LIVE=1 force chaque exécution à encoder la requête et à calculer le score de chaque paire, comme en production. LARKFIELD_THREADS=1 limite PyTorch à un fil d’exécution, comme dans le tableau du cours :

    Fenêtre de terminal
    LARKFIELD_LIVE=1 LARKFIELD_THREADS=1 search eval --run ltr

    Dans PowerShell, définissez d’abord $env:LARKFIELD_LIVE = "1" et $env:LARKFIELD_THREADS = "1", puis supprimez les deux variables après. La dernière ligne de search eval donne p50 et p95 en millisecondes. Exécutez chaque conception deux fois et gardez la deuxième exécution : la première charge les modèles.

  2. Convertissez le temps en coût par 1 000 requêtes, comme dans Convertir les millisecondes en argent. Utilisez le prix du serveur du cours : 0,17 $ US l’heure pour 4 vCPU, une hypothèse dans costs.json. Indiquez combien de requêtes s’exécutent en même temps.

  3. Vérifiez le budget et les règles d’affaires. Le budget d’Amira est de 200 ms. Si votre conception inclut la règle de Hana, « les articles en solde d’abord », mesurez son coût en NDCG@10. Mesurez aussi son effet sur les premiers résultats en rupture de stock. Si vous ajoutez un emplacement d’exploration pour les nouveaux produits (ltr+explore), mesurez son coût et son apport.

  4. Faites votre choix sur les requêtes de développement. Écrivez votre justification dans search-pack/OMAR.md : une page, sans code. Dites ce que la conception améliore, pour quelles tranches, à quelle latence et à quel coût. Indiquez aussi quelle tranche se dégrade, avec votre commentaire. Un choix fondé uniquement sur la moyenne n’est pas accepté.

  5. Exécutez maintenant la partie réservée, une seule fois. Créez son dossier de données. Mesurez votre conception choisie, la référence de base et les autres conceptions présentées dans votre rapport, sans rien changer :

    Fenêtre de terminal
    python "$F/make_data.py" --out final-heldout --judgments search-pack/judgments.csv --splits search-pack/splits.csv --heldout
    LARKFIELD_DATA=final-heldout search eval --run ltr --by kind

    Écrivez les chiffres tels quels dans REPORT.md. Si le résultat réservé contredit le résultat de développement, dites-le. Ne revenez pas modifier la conception : vous transformeriez la partie réservée en deuxième partie de développement.

Utilise Tester les changements en ligne.

Votre test hors ligne indique quelle conception est meilleure selon vos jugements. Les gens peuvent ne pas être d’accord. Écrivez le plan du test en ligne dans search-pack/ONLINE.md, avant le début de tout test. Suivez Un plan écrit avant le test :

  1. La question, et l’entrelacement ou un test A/B. Expliquez pourquoi. L’entrelacement nécessite moins de recherches; un test A/B mesure le taux d’ajout au panier de chaque conception séparément.
  2. La mesure qui tranche : par exemple, les victoires en entrelacement ou le taux d’ajout au panier.
  3. Les garde-fous : les mesures qui ne doivent pas se dégrader. Par exemple, le taux de requêtes sans résultat, la latence p95 comparée à 200 ms, la proportion de premiers résultats en rupture de stock et celle des nouveaux produits affichés.
  4. La taille, décidée à l’avance. Calculez-la avec la simulation du cours : exécutez search interleave pour vos deux conceptions sur les données du cours. Les deux variables doivent être supprimées. Lisez ensuite Combien de recherches exige une différence réelle. Convertissez cette taille en semaines de trafic de Larkfield.
  5. La règle d’arrêt : regardez une seule fois, à la taille prévue. Arrêtez plus tôt seulement si un garde-fou est franchi. N’arrêtez jamais parce que la nouvelle conception « semble bonne », comme le montre Consultations répétées : des gagnants qui n’existent pas.
  6. Le retour arrière : comment revenir à l’ancienne conception en quelques minutes.

Le dossier search-pack/ dans votre dossier larkfield-search :

search-pack/
GUIDELINES.md Part 1: your judging guidelines (the course's plus your rules)
splits.csv Part 1: the chosen queries, dev or heldout, and your slice labels
pool.csv Part 1: the pooled pairs and the designs that found them
judgments.csv Part 1: your grades
agreement.md Part 1: the second judge, the agreement, kappa and the 3 x 3 table
comparison.csv Parts 2 and 4: one row per design, the course's columns
OMAR.md Part 4: one page for Omar, no code
ONLINE.md Part 5: the online test plan
pool.py and any other script or notebook that you used
REPORT.md Parts 1 to 5, with the commands that make every number
requirements.txt exact versions (pip freeze)

REPORT.md contient ces sections :

# Search design pack for the new season
## Data checks (files, checksums, what you see in the new season)
## Test set (Part 1: the two rules, the slices and their sizes, the pool, the guidelines' new rules)
## Agreement (Part 1: the second judge, agreement, kappa, who is stricter, by language)
## Designs by slice (Part 2: the table, the slices, judged@10, the new products)
## Query changes (Part 3: one row per change, the query that a change hurts, your own change)
## The choice (Part 4: latency, cost per 1,000, the budget, the rules, the slice that got worse)
## Held-out run (Part 4: the numbers of the one run, as they came)
## Online test plan (Part 5: a summary of ONLINE.md)
## Limits (what your test set cannot see, and what you would measure next)
## How to reproduce (commands, versions, run times, a fresh environment)

Un réviseur note chaque élément démontré, partiellement démontré ou pas encore démontré, avec une raison concrète. Sans réviseur, utilisez le tableau pour évaluer votre propre dossier, ou demandez à un collègue. Le cours est terminé seulement quand les cinq éléments sont démontrés. Vous pouvez améliorer un élément et le soumettre de nouveau.

Élément requis Démontré quand Partiellement démontré, par exemple Pas encore démontré, par exemple
1. Jeu de test (module 2) Au moins 40 requêtes choisies selon une règle écrite avant toute exécution, avec une partie réservée choisie selon une deuxième règle. Des consignes écrites couvrant les nouveaux cas. Un ensemble réunissant les 10 premiers résultats d’au moins quatre conceptions, tous jugés. Accord avec un deuxième juge sur au moins 100 paires : accord, kappa, tableau et indication du juge le plus strict. Tailles des tranches indiquées. Accord sur moins de 100 paires, ou sans tableau. Ou l’ensemble provient d’une ou deux conceptions. Aucune consigne écrite. Ou les requêtes ont été choisies après avoir vu les résultats.
2. Conceptions (modules 3, 5 et 6) BM25 et au moins trois autres familles, sur les mêmes requêtes de développement et les mêmes jugements. NDCG@10 avec son intervalle, recall@100, taux de requêtes sans résultat et latence pour chacune, globalement et par tranche, avec les tailles. judged@10 présenté et commenté. Aucun intervalle, ou aucune tranche. Ou la latence manque pour une conception. Moins de trois autres familles. Ou chaque conception est mesurée sur des requêtes différentes.
3. Changements aux requêtes (modules 3 et 4) Chaque changement mesuré par rapport à l’étape précédente, avec un intervalle apparié et ses tranches. Une décision par changement, avec sa raison. Une requête qu’un changement dégrade, avec une explication. Les changements sont mesurés tous ensemble, donc leurs effets sont impossibles à distinguer. Un changement conservé « parce qu’il devrait aider », sans mesure.
4. Le choix (modules 7 et 8) Une conception choisie sur les requêtes de développement. p50 et p95 mesurés sur le nouveau catalogue. Coût par 1 000 requêtes avec le prix du serveur comme hypothèse, et budget de 200 ms vérifié. La tranche qui se dégrade est nommée et commentée. La partie réservée est exécutée une fois, après le choix, et présentée telle quelle. La latence est copiée du cours, pas mesurée sur le nouveau catalogue. Ou le coût n’a aucune hypothèse. La partie réservée sert au réglage ou au choix. Ou le choix repose seulement sur la moyenne, alors qu’une tranche se dégrade sans commentaire.
5. Plan en ligne (module 8) Entrelacement ou test A/B avec justification, mesure décisive, au moins deux garde-fous, taille décidée à l’avance et calculée avec la simulation du cours, règle d’arrêt prévoyant une seule consultation et retour arrière. Aucune taille, ou une taille sans source. Ou aucun garde-fou sur la latence. « L’exécuter jusqu’à ce qu’il gagne. » Ou aucune règle d’arrêt.

Non accepté, peu importe ce que montre le reste (l’élément est « pas encore démontré ») :

  • Les requêtes réservées utilisées pour régler la conception : une conception ou un paramètre modifié après l’exécution réservée, ou cette exécution répétée jusqu’à obtenir un bon résultat. (Élément 4.)
  • Une conception choisie uniquement sur la moyenne, quand une tranche se dégrade et que le dossier n’en dit rien. Les tranches sont celles enseignées dans le cours : français, requêtes avec fautes d’orthographe, codes, requêtes larges et nouveaux produits. (Élément 4.)
  • Des notes copiées d’une autre source. WANDS est public, et ses jugements sur ces requêtes sont accessibles. Les consulter est interdit, et cela n’aide pas. La grille évalue votre méthode, pas votre score : les règles, l’ensemble de résultats, les consignes, l’accord et l’exécution réservée. (Élément 1.)

Un bon dossier est honnête avant d’être impressionnant. Il contient trois choses.

  • Des chiffres avec leurs tailles. Chaque NDCG a son intervalle et le nombre de requêtes qui le sous-tend. Il indique s’il provient de la partie de développement, de la partie réservée ou du score de l’équipe du cours.
  • Une référence de base simple dans chaque comparaison. BM25 pour les conceptions; l’étape précédente pour chaque changement aux requêtes. Si votre changement ne la dépasse pas, le dossier le dit.
  • Une décision avec son coût. « Pour la nouvelle saison, cette conception trouve plus souvent le meilleur produit en premier pour ces tranches. Elle coûte ce montant par 1 000 requêtes et est moins bonne pour cette tranche, ce que nous acceptons parce que… »

Les fourchettes ci-dessous proviennent de la solution de l’auteur. L’auteur l’a construite uniquement à partir des fichiers publics, avec le code du cours, mais sans juger à la main. Les jugements de l’équipe du cours ont remplacé les notes que vous écrivez. chat-small a noté les paires de l’ensemble que l’équipe n’avait jamais jugées. Ensuite, l’équipe du cours a évalué les conceptions sur les 120 requêtes avec tous les jugements qu’elle conserve. Vos méthodes et votre échantillon peuvent différer. Comparez la méthode et la taille de chaque résultat, pas le chiffre exact.

  • Votre jeu de test est petit, et ses intervalles le montrent. Avec 32 requêtes de développement, les intervalles du NDCG@10 de l’auteur avaient une largeur de 0,12 à 0,23. Une tranche de 6 requêtes françaises indiquait que LambdaMART était clairement moins bon en français. Le score de l’équipe sur les 30 requêtes françaises indiquait qu’il était bien meilleur. Donnez les tailles et ne faites confiance à aucune tranche contenant seulement quelques requêtes.
  • Votre NDCG est plus élevé que celui de l’équipe, et c’est normal. Les chiffres de développement de l’auteur dépassaient d’environ 0,15 à 0,2 le score de l’équipe pour les mêmes conceptions. Un ensemble complet laisse très peu de produits non jugés parmi vos 10 premiers résultats. Les jugements de l’équipe manquent pour environ un tiers des 10 premiers résultats. Un jugement manquant compte comme non pertinent. Comparez les différences entre les conceptions, pas les niveaux.
  • Le modèle juge est strict. chat-small était d’accord avec les notes des gens sur environ 3 paires sur 4 (kappa d’environ 0,55). Il donnait la note inférieure environ quatre fois plus souvent que la note supérieure, comme dans le cours.
  • La compréhension de la requête apporte le plus grand gain à faible coût. Selon le score de l’équipe, normalisation, correction orthographique et synonymes augmentaient le NDCG@10 d’environ 0,15 par rapport à BM25. Le coût restait sous 2 ms par requête. La correction orthographique récupérait la plupart des requêtes avec fautes d’orthographe (environ +0,25 sur cette tranche), mais dégradait légèrement le français. Les règles de synonymes ne changeaient presque rien. Le détecteur de classe aidait le français et dégradait légèrement l’anglais. Sur 32 requêtes de développement, l’auteur l’a abandonné; le score complet aurait justifié de le garder pour le français.
  • Le mélange hybride apportait un petit gain qui s’est confirmé. L’auteur a choisi hybrid-blend sur les requêtes de développement : environ +0,03 par rapport à la conception lexicale, sans tranche dégradée. Il prend moins de 10 ms par requête et coûte environ 0,0001 $ US par 1 000 requêtes. L’exécution réservée (+0,04, avec un intervalle large) et le score de l’équipe (environ +0,025, avec un intervalle excluant zéro) concordaient.
  • LambdaMART était le meilleur en moyenne, et le pire pour les nouveaux produits. Selon le score de l’équipe, il dépassait les conceptions hybrides d’environ 0,03, surtout en français, à environ 37 ms par requête. Mais les nouveaux produits représentaient moins de 1 % de ses 10 premiers résultats, contre environ 7 % pour les autres conceptions. (Ils représentent environ 5 % du catalogue.) Le modèle apprenait des clics et du temps passé par un produit dans la boutique. Les nouveaux produits n’ont ni l’un ni l’autre. L’emplacement d’exploration augmentait leur proportion à environ 4 %, avec une petite perte de NDCG. Un dossier qui choisit LambdaMART doit le dire et ajouter cet emplacement ou un autre plan.
  • L’encodeur croisé est trop lent. Il prenait environ 1 s par requête sur un fil, cinq fois le budget d’Amira, pour un gain inférieur à celui de LambdaMART.
  • La recherche dense seule perdait face à la conception lexicale, d’environ 0,06, et de plus de 0,2 sur les requêtes avec fautes d’orthographe.
  • Le test en ligne nécessite une taille décidée à l’avance. Pour le changement de l’auteur, l’entrelacement vérifié toutes les 100 recherches semblait « clair » après une médiane de 600 recherches. Le test A/B, vérifié de la même façon, désignait l’ancienne conception comme gagnante dans 2 exécutions sur 5. Dans Tester les changements en ligne, un test équitable consulté une seule fois nécessitait environ 5 000 recherches.

Erreur courante

La partie réservée utilisée deux fois

Symptôme : le NDCG@10 réservé de votre conception choisie est aussi élevé que sur les requêtes de développement. Votre rapport indique que vous avez « corrigé une chose » après la première exécution réservée.

Cause : après l’exécution réservée, vous avez modifié la conception et exécuté la partie réservée de nouveau. Dès lors, elle est devenue une deuxième partie de développement, et son chiffre est trop bon.

Correction : exécutez la partie réservée une seule fois, après tous les choix. Si elle contredit la partie de développement, présentez les deux et dites ce que vous testeriez ensuite. Une nouvelle partie réservée nécessite de nouvelles requêtes jugées.

Conséquence dans le travail en IA : l’équipe annonce un gain que les premiers vrais clients ne voient pas.

Erreur courante

Une meilleure moyenne qui cache une tranche dégradée

Symptôme : votre conception choisie a le meilleur NDCG@10 global. Un collègue découvre que les requêtes françaises se sont dégradées.

Cause : la moyenne mélange les tranches. Un grand gain en anglais peut cacher une perte en français. C’est ce qu’a fait l’encodeur croisé dans Reclassement par encodeur croisé : il lit seulement l’anglais.

Correction : présentez chaque tranche avec sa taille et utilisez search compare --by kind. Nommez la tranche perdante et dites ce que vous faites : accepter la perte, l’acheminer vers une autre conception ou la corriger.

Conséquence dans le travail en IA : un changement qui a « gagné » est annulé après les plaintes d’un groupe de clients.

  • Le jeu de test choisi après les résultats. Choisir des requêtes où une conception échoue ou excelle fait du jeu de test un argument pour cette conception. Écrivez d’abord la règle.
  • Un ensemble de résultats provenant d’une seule conception. Chaque autre conception est alors mesurée sur des produits que personne n’a jugés et semble moins bonne qu’elle ne l’est. Regroupez les résultats d’au moins quatre conceptions et vérifiez judged@10.
  • La latence du cours copiée. Le nouveau catalogue est plus grand, et votre ordinateur n’est pas celui de l’équipe du cours. Mesurez avec LARKFIELD_LIVE=1.
  • Un modèle juge traité comme des gens. Dans le cours, le modèle juge était plus strict que les juges de WANDS. S’il est votre seul juge, votre NDCG est inférieur à celui que donneraient les notes des gens. Les paires françaises n’ont jamais été vérifiées auprès de gens.
  • La correction orthographique conservée pour chaque requête. Elle aide les requêtes avec fautes d’orthographe et peut briser de vrais noms. Mesurez-la par tranche et ajoutez-lui une protection.
  • Un test arrêté quand il « semble bon ». Avec des consultations répétées, un test A/A indique un faux gagnant dans environ la moitié des tests. Décidez d’abord de la taille et regardez une seule fois.
Afficher les valeurs publiques de vérification

Ouvrez ceci seulement après avoir obtenu vos propres chiffres. Ces valeurs proviennent des fichiers publics et des données du cours, vous pouvez donc les vérifier. Ce ne sont pas les réponses au travail.

  • Données : 2 000 nouveaux produits, ajoutés du 2 mars 2026 au 15 mars 2026, dont 403 avec un titre français; 120 requêtes, 90 marquées en et 30 marquées fr. Le dossier contient 9 fichiers, environ 2,1 Mo, et chaque fichier dans SHA256SUMS est valide. Aucun nouveau produit ne figure dans le fichier log/impressions.csv.gz du cours.
  • Le dossier de données : make_data.py écrit 42 066 produits dans 551 classes de produits, avec 8 000 titres français. Les nouveaux produits représentent environ 5 % du catalogue. search index prend quelques secondes et écrit 55,5 Mo.
  • LambdaMART : search ltr train sur final-data apprend des mêmes 260 requêtes d’entraînement que dans le cours. Il utilise 13 209 candidats avec une étiquette supérieure à 0. (Les données du cours en donnent 13 763 : certains nouveaux produits prennent maintenant une place parmi les candidats. Personne ne les a jugés pour les requêtes d’entraînement.)
  • Vitesse sur le portable de l’auteur (Apple M4, LARKFIELD_LIVE=1, un fil, p50) : BM25 0,5 ms, BM25 avec compréhension de la requête 0,8 ms, recherche dense 6,8 ms, conceptions hybrides environ 8 ms, LambdaMART environ 37 ms, LambdaMART avec l’emplacement d’exploration environ 61 ms, encodeur croisé environ 970 ms.

Récapitulatif

Vous pouvez maintenant passer d’un problème de recherche dans un nouveau catalogue à une décision. Vous construisez votre propre jeu de test avec une règle, des consignes, un ensemble de résultats et un deuxième juge. Vous en gardez une partie à l’écart jusqu’à la fin. Vous comparez BM25 à d’autres familles de conceptions par tranche, avec des intervalles. Vous gardez chaque changement aux requêtes seulement quand une mesure le justifie. Vous choisissez une conception selon la pertinence, la latence et le coût, sans cacher la tranche perdante. Et vous planifiez un test en ligne dont la taille et la règle d’arrêt sont décidées à l’avance. Les études de cas du module 9 suivent les mêmes étapes sur d’autres données ouvertes : Recherche de produits pour un magasin de meubles, Requêtes d’achat avec des négatifs difficiles et Rechercher dans un centre d’aide ou un corpus scientifique.