Comprender las consultas

Unos 38 minutos de lectura, con 12 ejemplos en 10 secciones.

Edición 2026.11.10 Ejemplos verificados el 19 de nov de 2026 132 de 132 ejemplos pasan Qué ha cambiado

Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros

Traducido del libro en inglés, edición 2026.11.10. Lee el original

Al final de este capítulo podrás cambiar la consulta de un comprador antes de la recuperación: corregir su ortografía, escribir sus unidades de una sola forma, ampliarla con sinónimos, predecir su clase de producto, reescribirla con un modelo de lenguaje grande, buscar con un producto que el modelo imagina y convertir una consulta de seguimiento en una consulta independiente. También podrás decidir, a partir de juicios humanos, si cada cambio ayuda al recuperador al que alimenta.

Algunas de las consultas cortas que los compradores escriben en el cuadro de búsqueda de la tienda no pueden coincidir con los productos que buscan. ligth bulb escribe mal una palabra. 7qt slow cooker escribe su tamaño como un término que contienen 0 productos. Para midcentury tv unit, el capítulo 7 cuenta 25 productos exactos, de los cuales 0 contienen midcentury y 0 contienen unit.

Un comprador que escribe in white después de buscar un escritorio quiere decir un escritorio blanco, pero las palabras por sí solas no lo indican. La comprensión de consultas es todo lo que hace un sistema de búsqueda con una consulta antes de la recuperación para cerrar brechas como estas: corrige, normaliza, amplía, clasifica y reescribe. Los capítulos 5 a 7 cambiaron los recuperadores. Este capítulo cambia la consulta y mantiene fijos los recuperadores: BM25, la línea base del libro, sin lematización (stemming), en lib.lexical, y la recuperación semántica, que compara el embedding de la consulta con el de cada producto, calculados de antemano por Snowflake/snowflake-arctic-embed-m-v1.5.

Tres de las técnicas usan el LLM de la tienda. Es gemma4:12b-it-q4_K_M, un modelo abierto que Google publica bajo la licencia Apache 2.0 (ficha del modelo). Nada en los ejemplos lo llama. Dos scripts, recordings/llm_rewrites.py y recordings/llm_conversations.py, lo ejecutaron una vez, con temperatura 0 y una semilla fija, y guardaron sus salidas como grabaciones, que los ejemplos leen a través de lib.recorded. El manifest.json de cada grabación contiene los prompts completos. Las grabaciones usan el mismo modelo abierto y la misma configuración que las del capítulo 4. El LLM solo ve las palabras del comprador, nunca un producto. Cada puntuación del capítulo usa los juicios humanos.

Cada parámetro se elige con las 50 consultas de entrenamiento, y las 30 consultas de prueba se reservan para informar resultados. El capítulo fijó sus 5 comparaciones planificadas sobre las consultas de prueba antes de leer cualquiera de sus resultados. Cada una es un recuperador con un solo cambio, medido frente al mismo recuperador con la consulta tal como se escribió:

  1. BM25 con una lista de sinónimos
  2. recuperación semántica con un refuerzo para la clase predicha
  3. BM25 sobre la reescritura del LLM
  4. recuperación semántica sobre la reescritura del LLM
  5. recuperación semántica con HyDE, que promedia el embedding de la consulta con el de un producto que el LLM imagina

Cada comparación planificada debe cumplir la regla del libro: un valor p inferior a 0.01 en su prueba de permutaciones pareada, que es 0.05 dividido por el número de comparaciones planificadas. Junto a ella se presentan la prueba t pareada y un intervalo de bootstrap del 99 %. La corrección ortográfica, la normalización de unidades y la reescritura de consultas de seguimiento afectan a muy pocas consultas para ponerlas a prueba, así que sus secciones son exploratorias.

Corrige la ortografía según las palabras del catálogo

Último cambio en la edición 2026.11.10

La primera carencia es una errata, como en ligth bulb. En BM25, una palabra mal escrita solo coincide con los productos que tienen la misma falta de ortografía, y puede alejar el embedding de la consulta de los productos que quiere encontrar, como muestra el capítulo 6. Las consultas de búsqueda contienen muchos de estos errores. Un estudio de la búsqueda web, Cucerzan y Brill (2004), informa de que aproximadamente entre el 10 y el 15 por ciento de las consultas enviadas a los motores de búsqueda contienen errores. El corrector clásico es el modelo de canal ruidoso: para una palabra escrita t, elige la corrección c que maximiza P(c) × P(t | c) (Kernighan et al., 1990). P(c) indica con qué frecuencia aparece la palabra candidata. P(t | c), el modelo de errores, indica la probabilidad de que un comprador que quería escribir c escriba t. Kernighan et al. toman como candidatas las palabras a una edición de la errata: una eliminación, una inserción, una sustitución o un intercambio de dos letras contiguas. El número de inserciones, eliminaciones y sustituciones que convierten una cadena en otra es su distancia de edición (Manning et al., 2008), y el corrector de este capítulo también cuenta un intercambio como una edición. Un manual expone los dos principios en términos sencillos: de las ortografías correctas, elige la más cercana, y entre empates cercanos, elige la más frecuente (Manning et al., 2008). Norvig escribe un corrector de este tipo en unas pocas líneas (Norvig).

correction(t) = argmax over candidates c of  P(c) × P(t | c)

El léxico, la lista de palabras que se consideran correctas, decide qué se corrige. Los motores de búsqueda web construyen el suyo a partir de los registros de consultas, de modo que la corrección que eligen es la más habitual entre las consultas de otros usuarios (Manning et al.). La tienda no tiene registro, así que su léxico procede del texto del catálogo. De dónde procede el léxico importa para las marcas, porque un corrector en la búsqueda de productos debe distinguir las erratas genuinas de las marcas nuevas escritas de forma poco convencional (Guo et al., 2024).

El corrector que se usa aquí emplea el modelo de errores más básico: una palabra del léxico se mantiene, una edición vence a dos, y P(c), la frecuencia de cada candidata, desempata entre candidatas a la misma distancia de edición. Ejecútalo sobre todas las 80 consultas y observa cuáles cambia:

catalog-spelling-corrector.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""A spelling corrector built from the catalog's word counts, run on every query and checked againstlib.queries.correct_query. The prose's point rests on the "queries changed" line and on the line that says whether both correctors agree."""import refrom collections import Counterfrom lib.queries import correct_queryfrom lib.store import load_products, load_queries, product_texttexts = product_text(load_products()).str.lower()counts = Counter(re.findall(r"[a-z]+", " ".join(texts)))       # the lexicon, and how common each word isdef edits1(word):    """Every string one edit away: a deletion, a swap of two neighbouring letters, a replacement or an insertion."""    splits = [(word[:cut], word[cut:]) for cut in range(len(word) + 1)]    letters = "abcdefghijklmnopqrstuvwxyz"    return ({left + right[1:] for left, right in splits if right}            | {left + right[1] + right[0] + right[2:] for left, right in splits if len(right) > 1}            | {left + letter + right[1:] for left, right in splits if right for letter in letters}            | {left + letter + right for left, right in splits for letter in letters})def correct(word):    """Keep a word the catalog uses. Otherwise take the commonest catalog word one edit away, else two."""    if not word.isalpha() or word in counts:        return word    candidates = {edit for edit in edits1(word) if edit in counts} or {        two for edit in edits1(word) for two in edits1(edit) if two in counts}    # the most common candidate; on a tie in counts, the alphabetically first one    return max(sorted(candidates), key=counts.get) if candidates else wordqueries = load_queries()corrected = queries["query"].map(lambda query: " ".join(correct(word) for word in query.lower().split()))changed = queries[corrected != queries["query"].str.lower()]print(f"catalog words: {len(counts):,}")print("queries changed:", len(changed))print("of them, train queries:", (changed["split"] == "train").sum())for query_id, query in changed["query"].items():    print(f"  {query} ({changed.at[query_id, 'split']}), corrected: {corrected[query_id]}")same = corrected.equals(queries["query"].map(lambda query: correct_query(query, counts)))print("same as lib.queries.correct_query:", same)for word in ["tye", "tie", "the", "kohler", "whitehaven", "malachi", "luau"]:      # P(c), as counts    print(f"catalog count of {word}:", counts[word])
Salidapython catalog-spelling-corrector.py
catalog words: 19,680
queries changed: 4
of them, train queries: 3
  foutains with brick look (train), corrected: fountains with brick look
  twin over full bunk beds cool desins (train), corrected: twin over full bunk beds cool designs
  ligth bulb (train), corrected: light bulb
  tye dye duvet cover (test), corrected: the dye duvet cover
same as lib.queries.correct_query: True
catalog count of tye: 0
catalog count of tie: 45
catalog count of the: 20389
catalog count of kohler: 71
catalog count of whitehaven: 60
catalog count of malachi: 5
catalog count of luau: 4

El catálogo usa 19,680 palabras distintas, y el corrector cambia 4 consultas. De ellas, 3 son consultas de entrenamiento. La función compartida lib.queries.correct_query hace las mismas correcciones, y el corrector escribe cada consulta de entrenamiento como lo hacen las sondas ortográficas del capítulo 6 : las copias correctamente escritas de las consultas con erratas que el capítulo 6 preparó para el libro.

El corrector no toca las marcas, porque el catálogo las usa: kohler 71 veces y whitehaven 60. Algunas palabras que conserva son raras, como malachi, usada 5 veces, y luau, usada 4. Un léxico que dejara fuera las palabras raras trataría a ambas como erratas.

Los fallos del corrector están en las consultas de prueba. tye dye duvet cover se convierte en the dye duvet cover: tye está a una edición de tie (45 veces en el catálogo) y de the (20389), y P(c) elige la palabra frecuente. Y refrigerator with ice an water in door conserva su an. Ese an es un error de palabra real, una errata en la que cada palabra está bien escrita, como en «flew form Heathrow» (Manning et al., 2008). Ambos casos necesitan contexto. Para tye y para an, cuenta con qué frecuencia cada palabra del catálogo a una edición de distancia aparece justo antes de la palabra siguiente de la consulta, dye o water:

spelling-context-counts.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""For the misspelled word in two test queries, `tye` and the real-word error `an`, counts how often each nearby catalog word comes before the query's nextword, and shows the context-free corrector's choice. The prose's point rests on the "catalog count of ... thecorrector's choice" lines."""import refrom collections import Counterfrom lib.queries import correct_word, edits1, word_countsfrom lib.store import load_products, product_texttexts = product_text(load_products()).str.lower()counts = word_counts(texts)                                   # the corrector's lexiconwords_per_product = [re.findall(r"[a-z]+", text) for text in texts]pairs = Counter(pair for words in words_per_product for pair in zip(words, words[1:]))      # neighbouring words# tye in "tye dye duvet cover", an in "refrigerator with ice an water in door": each word, the word after itfor word, after in [("tye", "dye"), ("an", "water")]:    # the typed word and each catalog word one edit away, ranked by how often each comes before the next word    options = sorted(((pairs[(edit, after)], edit) for edit in edits1(word) | {word} if edit in counts), reverse=True)    for count, edit in options[:3]:        print(f"catalog count of {edit} {after}:", count)    choice = correct_word(word, counts)                        # what the corrector without context picks    print(f"the corrector's choice for {word}: {choice}")    print(f"catalog count of {choice} {after}, the corrector's choice:", pairs[(choice, after)])
Salidapython spelling-context-counts.py
catalog count of tie dye: 18
catalog count of type dye: 0
catalog count of tyke dye: 0
the corrector's choice for tye: the
catalog count of the dye, the corrector's choice: 0
catalog count of and water: 59
catalog count of a water: 20
catalog count of in water: 9
the corrector's choice for an: an
catalog count of an water, the corrector's choice: 0

Antes de dye, el texto del catálogo tiene tie 18 veces, y la elección del corrector, the, 0. Antes de water, and aparece 59 veces, por delante de a con 20, mientras que an, la elección del corrector, tiene 0. Para estas dos consultas, un corrector que puntuara cada candidata con su palabra vecina elegiría tie y and. Cada consulta corregida puede ahora evaluarse con sus propios juicios, lo que muestra si el cambio ayuda:

measure-spelling-corrections.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Scores each typo query, and the variant spelling tye dye, with BM25, and with recorded embeddings where the correctedtext has one, as typed and as corrected. The prose's point rests on the nDCG@10 lines for queries 20 and 224 (train) and the corrected BM25 line for 459 (test)."""from lib.lexical import LexicalSearchfrom lib.metrics import ndcg_at_kfrom lib.queries import correct_query, word_countsfrom lib.recorded import probesfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, product_text, qrelsproducts, queries, judgments = load_products(), load_queries(), qrels()counts = word_counts(product_text(products))bm25, semantic = LexicalSearch(products), SemanticSearch()probe_queries, probe_vectors = probes()      # recorded embeddings of the four typo queries, spelled correctlyspelling = probe_queries[probe_queries["kind"] == "spelling"]# the probes' embeddings, keyed by the correctly spelled text, so a corrected query can find its ownspelled = {row["query"]: probe_vectors[index] for index, row in spelling.iterrows()}typo_queries = spelling["of_query_id"].astype(int).tolist()print("typo queries:", len(typo_queries))print("of them, test queries:", (queries.loc[typo_queries, "split"] == "test").sum())for query_id in typo_queries + [459]:        # the typo queries, then the one variant spelling, tye dye    typed = queries.at[query_id, "query"]    corrected = correct_query(typed, counts)    label = f"{query_id} ({queries.at[query_id, 'split']})"    print(f"{label}: {typed} -> {corrected}")    for name, text in [("typed", typed), ("corrected", corrected)]:        ranking = list(bm25.search(text, k=10).index)        print(f"{label}, bm25 ndcg@10 {name}: {ndcg_at_k(ranking, judgments[query_id], 10):.3f}")    if corrected == typed.lower():        print(f"{label}: the corrector changes nothing")    elif corrected in spelled:        for name, vector in [("typed", semantic.query_vectors[query_id]), ("corrected", spelled[corrected])]:            ranking = list(semantic.search_vector(vector, k=10).index)            print(f"{label}, semantic ndcg@10 {name}: {ndcg_at_k(ranking, judgments[query_id], 10):.3f}")    else:        print(f"{label}: no recorded embedding of the corrected text")
Salidapython measure-spelling-corrections.py
typo queries: 4
of them, test queries: 1
305 (train): ligth bulb -> light bulb
305 (train), bm25 ndcg@10 typed: 0.945
305 (train), bm25 ndcg@10 corrected: 0.945
305 (train), semantic ndcg@10 typed: 1.000
305 (train), semantic ndcg@10 corrected: 1.000
20 (train): foutains with brick look -> fountains with brick look
20 (train), bm25 ndcg@10 typed: 0.356
20 (train), bm25 ndcg@10 corrected: 0.507
20 (train), semantic ndcg@10 typed: 0.353
20 (train), semantic ndcg@10 corrected: 0.645
224 (train): twin over full bunk beds cool desins -> twin over full bunk beds cool designs
224 (train), bm25 ndcg@10 typed: 0.488
224 (train), bm25 ndcg@10 corrected: 0.488
224 (train), semantic ndcg@10 typed: 0.565
224 (train), semantic ndcg@10 corrected: 0.616
406 (test): refrigerator with ice an water in door -> refrigerator with ice an water in door
406 (test), bm25 ndcg@10 typed: 0.501
406 (test), bm25 ndcg@10 corrected: 0.501
406 (test): the corrector changes nothing
459 (test): tye dye duvet cover -> the dye duvet cover
459 (test), bm25 ndcg@10 typed: 0.953
459 (test), bm25 ndcg@10 corrected: 0.953
459 (test): no recorded embedding of the corrected text

La corrección importa sobre todo para foutains with brick look (entrenamiento). La recuperación semántica pasa de 0.353 a 0.645, y BM25 de 0.356 a 0.507.

De las otras dos erratas de entrenamiento, twin over full bunk beds cool desins solo mueve la recuperación semántica, de 0.565 a 0.616, y ligth bulb no mueve ninguno de los dos recuperadores. En el caso de refrigerator with ice an water in door, el corrector no cambia nada, y una corrección acertada tampoco podría ayudar a BM25. De la an escrita y la and correcta, bm25s descarta an, and como palabras vacías, y la copia del capítulo 6 de la consulta escrita con and obtiene 0.501, lo mismo que la consulta tal como se escribió.

Para tye dye duvet cover, BM25 obtiene 0.953 en ambos casos, porque the es una palabra vacía y tye no coincide con ningún producto, así que ambas versiones buscan los mismos términos. La recuperación semántica no puede evaluarse sobre el texto corregido, porque las grabaciones no contienen un embedding de él. La tienda tiene 4 consultas con erratas, de las cuales 1 es una consulta de prueba, y el menor valor p de permutación bilateral que pueden dar tan pocas es 0.125.

Regla práctica: Construye el léxico a partir de tu catálogo, y de tu registro de consultas cuando lo tengas, y corrige solo las palabras que no contiene, para que las marcas se conserven. Antes de corregir una palabra, revisa sus vecinas: un corrector sin contexto convierte las variantes ortográficas en palabras comunes y no detecta los errores de palabra real. Evalúa cada corrección con los juicios propios de las consultas con erratas, y reúne muchas más consultas con erratas de las que tiene la tienda antes de probar un corrector.

Normaliza las unidades como las escribe el catálogo

Último cambio en la edición 2026.11.8

Una errata tiene una sola forma correcta; una medida, como en 7qt slow cooker, suele tener varias. La normalización convierte las distintas formas de escribir una misma cosa en una sola forma, tanto en los productos como en la consulta. Las medidas de este catálogo la necesitan. El capítulo 5 descubrió que 7qt y 7 qt nunca coinciden entre sí, porque el tokenizador descarta la 7 de un solo carácter. Un normalizador que une cada número con su unidad, escrito de una única manera, convierte ambas en un solo término, 7qt. Debe ejecutarse sobre el texto del producto al construir el índice, y sobre cada consulta. También tiene que producir términos que el tokenizador conserve enteros. El tokenizador divide las palabras en el punto decimal, así que 3.7qt se convertiría en 7qt. Para evitarlo, la función compartida lib.queries.normalize_units escribe el punto como un guion bajo, que el tokenizador conserva dentro de una palabra. Además, deja in tal cual cuando le sigue un número o one, como en 3 in 1.

Una regla escrita a partir de las consultas cubriría qt, in, inch y ". Antes de confiar en ella, cuenta cómo escribe el catálogo las pulgadas. Primero las contamos, imprimimos los términos que el tokenizador obtiene de algunos textos normalizados y construimos BM25 tres veces: sobre el texto tal como está escrito, normalizado con esa primera regla y normalizado con normalize_units, que además gestiona las dos comillas simples del catálogo, '', para las pulgadas. Puntuamos cada consulta, de entrenamiento o de prueba, que contenga un número con unidad:

normalize-units-both-sides.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · pystemmer 3.1.0 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Counts how the catalog writes inches, prints the terms the tokenizer makes of normalized texts, and scores BM25 onevery query with a unit under three rules. The prose's point rests on the "bm25 ndcg@10" lines for queries 62 and 482."""from lib.lexical import LexicalSearchfrom lib.lexical_by_hand import tokenizefrom lib.metrics import ndcg_at_kfrom lib.queries import INCH_SPELLINGS, normalize_units, unit_rulesfrom lib.store import load_products, load_queries, product_text, qrelsproducts, queries, judgments = load_products(), load_queries(), qrels()text = product_text(products).str.lower()# the catalog's spellings of inches after a number; -? also takes a hyphen, as in 48-inchfor name, unit in [("''", r"''"), ('"', r"\""), ("inch", r"-?inch")]:    print(f"products that write a number then {name}:", text.str.contains(rf"\d\s*{unit}").sum())# the first rule, written from the queries' units: lib's inch spellings (inches, inch, in, ") without the two apostrophes; quarts are always includedfirst_try = unit_rules([spelling for spelling in INCH_SPELLINGS if spelling != "''"])   # written from queries# None leaves the text as written, with no normalizationrules = {"as written": None, "first try": first_try, "normalized": unit_rules()}checks = [("3.7-quart slow cooker", "normalized"), ("3 in 1 sofa bed", "normalized"), ("1 in twin", "normalized"),          ("48 '' range hood", "first try"), ("48 '' range hood", "normalized")]for example, name in checks:                                                   # what the tokenizer reads    print(f"terms of {example}, {name}:", " ".join(tokenize(normalize_units(example, rules[name]))))searches = {}for name, rule in rules.items():    rewritten = products.copy()    if rule is not None:        for column in ["name", "product_class", "category", "description"]:   # the columns product_text joins            rewritten[column] = rewritten[column].map(lambda value: normalize_units(value, rule))    searches[name] = LexicalSearch(rewritten)# queries with a number and a unit: qt, in, inch or a double quotewith_units = queries[queries["query"].str.contains(r"\d\s*(?:qt|in\b|inch|\")")]print("queries with a unit:", len(with_units))print("of them, test queries:", (with_units["split"] == "test").sum())for query_id, query in with_units["query"].items():    label = f"{query_id} ({queries.at[query_id, 'split']})"    print(f"{label}: {query} -> {normalize_units(query)}")    for name, rule in rules.items():        typed = query if rule is None else normalize_units(query, rule)        ranking = list(searches[name].search(typed, k=10).index)        print(f"{label}, bm25 ndcg@10 {name}: {ndcg_at_k(ranking, judgments[query_id], 10):.3f}")
Salidapython normalize-units-both-sides.py
products that write a number then '': 3014
products that write a number then ": 65
products that write a number then inch: 215
terms of 3.7-quart slow cooker, normalized: 3_7qt slow cooker
terms of 3 in 1 sofa bed, normalized: sofa bed
terms of 1 in twin, normalized: 1in twin
terms of 48 '' range hood, first try: 48 range hood
terms of 48 '' range hood, normalized: 48in range hood
queries with a unit: 4
of them, test queries: 2
62 (train): 7qt slow cooker -> 7qt slow cooker
62 (train), bm25 ndcg@10 as written: 0.554
62 (train), bm25 ndcg@10 first try: 0.930
62 (train), bm25 ndcg@10 normalized: 0.930
101 (train): 48 in entry table with side by side drawer -> 48in entry table with side by side drawer
101 (train), bm25 ndcg@10 as written: 0.569
101 (train), bm25 ndcg@10 first try: 0.569
101 (train), bm25 ndcg@10 normalized: 0.569
285 (test): 48" sliding single track , barn door for laundry -> 48in sliding single track , barn door for laundry
285 (test), bm25 ndcg@10 as written: 0.592
285 (test), bm25 ndcg@10 first try: 0.592
285 (test), bm25 ndcg@10 normalized: 0.592
482 (test): 48 inch kitchen hood -> 48in kitchen hood
482 (test), bm25 ndcg@10 as written: 1.000
482 (test), bm25 ndcg@10 first try: 0.824
482 (test), bm25 ndcg@10 normalized: 1.000

La forma habitual en que el catálogo escribe las pulgadas es la que una regla escrita a partir de las consultas no detecta: dos comillas simples tras un número, en los productos 3014, frente a 65 en " y 215 en inch.

El tokenizador lee 3.7-quart slow cooker, normalizado, como 3_7qt slow cooker, y 3 in 1 sofa bed como sofa bed. normalize_units sigue interpretando mal 1 in twin como 1in twin, por eso merece la pena imprimir los términos.

La normalización mejora la consulta de entrenamiento 7qt slow cooker: el nDCG@10 de BM25 pasa de 0.554 a 0.930, y la primera regla da 0.930. La consulta de prueba 48 inch kitchen hood muestra lo que pierde la primera regla al no detectar las dos comillas. Puntúa 1.000 tal como está escrita y 0.824 con la primera regla. La consulta se convierte en 48in, mientras que la primera regla deja una campana escrita 48 '' como 48 range hood, y la regla completa la convierte en 48in range hood. Con la regla completa, la consulta de la campana puntúa 1.000.

La otra consulta de entrenamiento, 48 in entry table with side by side drawer, puntúa 0.569 tal como está escrita y 0.569 normalizada, y la consulta de prueba sobre una puerta corredera de granero puntúa 0.592 y 0.592. Eso deja 4 consultas con unidad, de las cuales 2 son consultas de prueba: muy pocas para probar nada.

Regla práctica: Escribe las reglas de normalización a partir del texto del catálogo, no de las consultas, contando todas las formas en que escribe cada unidad. Imprime los términos que el tokenizador obtiene del texto normalizado, porque una regla que parece correcta puede producir términos que coincidan con los productos equivocados. Aplica las mismas reglas a productos y consultas en una misma versión, y reconstruye el índice. Cuando el catálogo guarda las medidas en campos, como el ancho en attributes, compara la medida con el campo en su lugar, como sugiere el capítulo 6.

Expandir consultas con una lista de sinónimos

Último cambio en la edición 2026.11.10

Algunas brechas no son erratas ni unidades, sino palabras distintas para una misma cosa, como cuando los productos exactos para midcentury tv unit dicen stand. La expansión de consultas añade términos a una consulta para que pueda coincidir con productos que usan otras palabras para lo mismo. La expansión suele aumentar el recall, la proporción de productos relevantes que encuentra una búsqueda (Manning et al., 2008). También puede reducir significativamente la precisión, la proporción de productos encontrados que son relevantes, sobre todo cuando la consulta contiene términos ambiguos (Manning et al., 2008). Una palabra que la expansión añade puede coincidir con productos que el comprador no pidió, y alejar la consulta de su significado, lo que se llama deriva de la consulta. Los términos de expansión pueden venir de una lista de sinónimos construida a mano, o de los resultados. La retroalimentación de pseudo-relevancia supone que los primeros resultados son relevantes y añade sus términos a la consulta, lo que hace de la deriva su riesgo conocido (Manning et al., 2008).

Aquí lib.queries.SYNONYMS contiene 14 grupos de palabras intercambiables, como stand y unit, escritos al leer las consultas de entrenamiento cuyos productos exactos no coinciden con alguna palabra de la consulta. Cuando una consulta contiene una palabra o frase de un grupo, expand añade los otros miembros del grupo, y BM25 busca el resultado. Mide esto en las consultas de entrenamiento y, después, haz la primera de las comparaciones planificadas del capítulo sobre las consultas de prueba:

synonym-expansion-train-and-test.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Expands each query with the synonym list, scores BM25 on the train and test queries as typed and expanded, andruns the list's planned test comparison. The prose's point rests on the "synonyms, bm25" lines of that comparison."""from lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.queries import PLANNED_TEST_COMPARISONS, SYNONYMS, THRESHOLD, expand, report_plannedfrom lib.store import load_products, load_queries, qrelsproducts, judgments = load_products(), qrels()bm25 = LexicalSearch(products)print("synonym groups:", len(SYNONYMS))scores = {}for split in ["train", "test"]:    queries = load_queries(split)    expanded = queries.assign(query=queries["query"].map(expand))    changed = queries.index[expanded["query"] != queries["query"]]    print(f"{split} queries the list changes:", len(changed))    for name, frame in [("typed", queries), ("expanded", expanded)]:        scores[split, name] = evaluate(bm25.run(frame), qrels(split))        print(f"{split} ndcg@10 {name}: {scores[split, name]['ndcg@10'].mean():.3f}")        print(f"{split} judged@10 {name}: {scores[split, name]['judged@10'].mean():.3f}")for query in queries.loc[changed, "query"]:                   # the test queries the list changes    print(f"test query changed: {query}")    # expand returns the query, a space, then the added words, so this slice keeps only the added words    print(f"words the list adds to it: {expand(query)[len(query) + 1:]}")change = (scores["train", "expanded"]["ndcg@10"] - scores["train", "typed"]["ndcg@10"]).round(3)print(f"train queries better, worse: {(change > 0).sum()}, {(change < 0).sum()}")       # for choosing, not evidenceprint(f"share of the net train gain from the largest gain: {change.max() / change.sum():.3f}")for kind, query_id in [("gain", change.idxmax()), ("loss", change.idxmin())]:    query = load_queries().at[query_id, "query"]    # the same slice: everything after the query and the space that expand puts between them    added = expand(query)[len(query) + 1:]    print(f"largest train {kind}: {query}")    print(f"largest train {kind}, words added: {added}")    print(f"largest train {kind}, change: {change[query_id]:+.3f}")named = [product_id for product_id in bm25.search(expand(query), k=10).index if added in products.at[product_id, "name"]]print(f"largest train loss, top 10 names with {added}:", len(named))      # query and added: the largest loss'sprint("largest train loss, of those, unjudged:", sum(product_id not in judgments[query_id] for product_id in named))print("\nplanned test comparisons:", len(PLANNED_TEST_COMPARISONS))print(f"p-value threshold: {THRESHOLD:.2f}")report_planned("synonyms, bm25", scores["test", "expanded"]["ndcg@10"], scores["test", "typed"]["ndcg@10"])
Salidapython synonym-expansion-train-and-test.py
synonym groups: 14
train queries the list changes: 14
train ndcg@10 typed: 0.695
train judged@10 typed: 0.930
train ndcg@10 expanded: 0.722
train judged@10 expanded: 0.944
test queries the list changes: 1
test ndcg@10 typed: 0.725
test judged@10 typed: 0.927
test ndcg@10 expanded: 0.725
test judged@10 expanded: 0.927
test query changed: indoor multi tiered plant stand
words the list adds to it: unit
train queries better, worse: 6, 5
share of the net train gain from the largest gain: 0.473
largest train gain: midcentury tv unit
largest train gain, words added: stand mid century
largest train gain, change: +0.632
largest train loss: wire basket with dividers
largest train loss, words added: hamper
largest train loss, change: -0.176
largest train loss, top 10 names with hamper: 4
largest train loss, of those, unjudged: 4

planned test comparisons: 5
p-value threshold: 0.01
synonyms, bm25, mean difference: 0.000
synonyms, bm25, wins, losses, ties: 0, 0, 30
synonyms, bm25, permutation p: 1.000
synonyms, bm25, established at 0.01: no
synonyms, bm25, t-test p: 1.000
synonyms, bm25, t-test agrees: yes
synonyms, bm25, 99% interval: 0.000 to 0.000
synonyms, bm25, interval agrees: yes

La lista cambia 14 consultas de entrenamiento. El nDCG@10 medio pasa de 0.695 a 0.722, y judged@10, la proporción de los 10 primeros con juicio, también sube, de 0.930 a 0.944.

De las consultas de entrenamiento que cambian, 6, 5 puntúan mejor y peor, respectivamente, y una consulta, midcentury tv unit, aporta 0.473 de la ganancia neta, ganando +0.632 con stand mid century añadida. La lista se escribió a partir de estas consultas, así que incluso estas cifras le son favorables.

La mayor pérdida, -0.176, muestra la deriva: wire basket with dividers obtiene hamper, y 4 productos cuyos nombres contienen hamper entran en sus 10 primeros. De ellos, 4 no tienen juicio, así que la métrica los cuenta como irrelevantes, lo que para los cestos de ropa sucia es una suposición razonable.

En las consultas de prueba, la lista cambia 1 consulta, indoor multi tiered plant stand, al añadir unit. Judged@10 se mantiene en 0.927, y la diferencia no queda establecida (comparaciones planificadas). En las consultas para las que se escribió, la lista ayudó a casi tantas consultas como perjudicó, y las consultas para las que no se escribió rara vez contienen sus palabras.

Regla práctica: Mantén una lista de sinónimos para las brechas de vocabulario que hayas observado, escribe cada entrada a partir de una consulta fallida y lee los productos que añade cada entrada antes de conservarla. Nunca informes de la ganancia de una lista sobre las consultas a partir de las que la escribiste, y conserva una entrada solo si una comparación planificada sobre las consultas de prueba muestra una ganancia. Prueba primero cualquier expansión en la recuperación semántica: las reescrituras del LLM, que añaden sinónimos y también amplían y eliminan palabras, la perjudican. Cuando las brechas son demasiadas para listarlas, prueba en cambio la derivación de raíces o la recuperación dispersa aprendida.

Entrena un clasificador de consultas con texto de productos

Último cambio en la edición 2026.11.10

En lugar de cambiar las palabras de una consulta, un sistema puede predecir qué tipo de producto pide la consulta. La clasificación de consultas asigna una consulta a una clase de la taxonomía de la tienda, como Range Hoods. En la búsqueda de productos, "asignar una consulta a una taxonomía de productos predefinida es un paso importante en la canalización de comprensión de consultas del comercio electrónico" (Skinner and Kallumadi, 2019): una clase predicha puede orientar la recuperación hacia la parte correcta del catálogo. Entrenar un clasificador suele requerir consultas etiquetadas. Skinner y Kallumadi informan de que una asignación existente a una taxonomía de productos puede mejorar la clasificación de consultas y reducir la necesidad de datos etiquetados. Preentrenan con títulos de productos, cuyas clases se conocen, y luego ajustan con menos consultas etiquetadas.

La tienda va más allá y no usa consultas etiquetadas, porque no tiene ninguna. WANDS asigna a cada consulta una query_class, "la categoría a la que pertenece la consulta" (WANDS), pero el capítulo 2 muestra que es una predicción, y algunos valores son incorrectos. Además, la muestra de WANDS que usa el libro tiene como máximo una consulta por clase (examples/data/wands/README.md), así que ninguna clase tiene dos consultas de las que aprender. Por eso entrena con los productos, que llevan product_class, y aplica el clasificador a las consultas.

Un clasificador naive Bayes puede aprender las clases a partir del texto de los productos en pocas líneas. En palabras, naive Bayes considera probable una clase para una consulta cuando esa clase es común entre los productos y cuando las palabras de la consulta son comunes en el texto de productos de esa clase. Trata las palabras como independientes, que es la parte "naive" (ingenua). A cada recuento se le suma 1, de modo que una palabra nunca vista en una clase no descarte esa clase:

predicted class = argmax over classes c of  log P(c) + sum over the query's words w of  log P(w | c)
P(w | c)        = (count of w in class c's text + 1) / (number of words in class c's text + vocabulary size)

Lo construimos a mano a partir de los recuentos de palabras del texto de productos, lo comprobamos frente a MultinomialNB de scikit-learn en la versión 1.9.1, y luego comparamos sus predicciones con query_class y con las clases de los productos exactos de cada consulta:

query-classes-by-hand.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""A naive Bayes query classifier built by hand from product text, checked against scikit-learn's MultinomialNB andcompared with each query's exact products. The prose's point rests on the two "queries where most exact productshave" lines and on the agreement line with MultinomialNB."""import numpy as npfrom lib.queries import class_rows, train_classifierfrom lib.store import load_labels, load_products, load_queries, product_textproducts, queries, labels = load_products(), load_queries(), load_labels()rows = class_rows(products)                     # one row per (product, class) for products with a classvectorizer, model = train_classifier(products)  # the same, by scikit-learn's MultinomialNBwords = vectorizer.transform(product_text(rows))  # word counts: one row per (product, class), one column per wordclasses = np.array(sorted(rows["label"].unique()))print("product classes:", len(classes))print("products without a class:", (products["product_class"] == "").sum())print("products with several classes:", products["product_class"].str.contains("|", regex=False).sum())# query classes whose name matches no product classmissing = queries["query_class"].dropna()[lambda names: ~names.isin(classes)]print("query classes that no product has:", len(missing))print("query classes that no product has, names:", "; ".join(missing))# Naive Bayes: log P(class) + sum over the query's words of log P(word | class), each word count smoothed by 1word_counts = np.vstack([np.asarray(words[(rows["label"] == name).to_numpy()].sum(axis=0)) for name in classes])log_prior = np.log(rows["label"].value_counts()[classes].to_numpy() / len(rows))log_likelihood = np.log((word_counts + 1) / (word_counts.sum(axis=1, keepdims=True) + word_counts.shape[1]))query_words = vectorizer.transform(queries["query"])predicted = classes[np.asarray(query_words @ log_likelihood.T + log_prior).argmax(axis=1)]print("same predictions as MultinomialNB:", (predicted == model.predict(query_words)).sum(), "of", len(queries))queries = queries.assign(predicted=predicted)print("predicted class equals query_class:", (queries["predicted"] == queries["query_class"]).sum())# judgment grade 2 is exact; a product's classes are joined by |, so they're split before matchingexact = labels[labels["grade"] == 2].join(products["product_class"].str.split("|"), on="product_id")for column, name in [("predicted", "predicted class"), ("query_class", "query_class")]:    share = [exact.loc[exact["query_id"] == query_id, "product_class"].apply(lambda names: label in names).mean()             for query_id, label in queries[column].items()]    print(f"queries where most exact products have the {name}:", (np.array(share) > 0.5).sum())# outdoor light fixtures, desk and chair set, and pool floatsfor query_id in [133, 255, 410]:    query, split, label = queries.loc[query_id, ["query", "split", "predicted"]]    print(f"{query_id} ({split}): {query} -> {label}"          f" (query_class: {queries.at[query_id, 'query_class']})")print("predicted class for 7qt slow cooker:", queries.at[62, "predicted"])       # its query_class has no products
Salidapython query-classes-by-hand.py
product classes: 410
products without a class: 800
products with several classes: 620
query classes that no product has: 1
query classes that no product has, names: Crock Pots & Slow Cookers
same predictions as MultinomialNB: 80 of 80
predicted class equals query_class: 60
queries where most exact products have the predicted class: 63
queries where most exact products have the query_class: 63
133 (test): outdoor light fixtures -> Light Bulbs (query_class: Outdoor Wall Lights)
255 (test): desk and chair set -> Desks (query_class: Office Chairs)
410 (train): pool floats -> Deck Boxes (query_class: Lawn Games)
predicted class for 7qt slow cooker: Slow Cookers

Los productos usan 410 clases. 800 productos no tienen ninguna y se excluyen, y 620 tienen varias, así que cada uno de ellos aporta una fila de entrenamiento por clase.

El clasificador construido a mano hace la misma predicción que MultinomialNB en 80 of 80 consultas. Su predicción coincide con query_class en 60 de ellas, pero query_class también es una suposición. Frente a los juicios, las dos suposiciones empatan: en 63 consultas la mayoría de los productos exactos tiene la clase predicha, y en 63 tienen query_class. Tres de sus predicciones muestran cómo interpreta una consulta solo por sus palabras: outdoor light fixtures se convierte en Light Bulbs, desk and chair set se convierte en Desks, y pool floats se convierte en Deck Boxes.

El diseño de la muestra limita lo que puede mostrar esta comprobación. Cada clase se prueba con como máximo una consulta, así que no se puede medir la precisión por clase, y 80 consultas cubren solo una parte de las 410 clases, así que los recuentos no dicen nada del resto. Un clasificador de consultas no puede entrenarse con estas consultas en absoluto, y dos clasificadores solo pueden compararse según si cada uno acierta estas pocas consultas. Además, 1 clase de consulta, Crock Pots & Slow Cookers, no nombra ninguna clase de producto, así que ningún clasificador entrenado con productos puede predecirla.

Regla práctica: Cuando no tienes consultas etiquetadas, entrena un clasificador de consultas con las clases de tus productos y compruébalo frente a las clases de los productos exactos juzgados, no frente a las suposiciones de otro clasificador. Cuando tus registros te den consultas etiquetadas, entrena con ellas. Trata la clase predicha como una pista para la ordenación, nunca como una etiqueta.

Potenciar la clase predicha en lugar de filtrar

Último cambio en la edición 2026.11.10

Aquí la clase predicha proviene del clasificador de Bayes ingenuo entrenado con el texto de los productos. Una clase predicha puede actuar sobre la recuperación de dos maneras. Un filtro conserva solo los productos de la clase predicha. Un refuerzo suma una cantidad fija a las puntuaciones de los productos de la clase predicha, de modo que suben sin que se elimine nada más. Un filtro es tan bueno como el clasificador: todo producto relevante fuera de la clase predicha desaparece.

Las valoraciones de entrenamiento de la tienda muestran cuánto costaría un filtro: para las consultas de entrenamiento, 501 of 1937 productos exactos están fuera de la clase predicha de su consulta. Añadimos un aumento a las similitudes de la recuperación semántica, el mejor sistema de ordenación de la tienda y, por tanto, su referente que hay que superar, y probamos cinco pesos de aumento y un filtro sobre las consultas de entrenamiento. Llevamos el mejor aumento a las consultas de prueba para la segunda de las comparaciones planificadas del capítulo:

class-boost-train-and-test.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Counts the exact train products outside each query's predicted class, scores a class filter and several boosts onthe train queries, and takes the best boost to the test queries as a planned comparison. The prose's point rests onthe "exact train products outside the predicted class" line and on the planned comparison's lines."""from lib.metrics import evaluatefrom lib.queries import THRESHOLD, class_boost_run, in_class, report_planned, train_classifierfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsproducts, queries = load_products(), load_queries()vectorizer, model = train_classifier(products)               # trained on product text, never on queriespredicted = dict(zip(queries.index, model.predict(vectorizer.transform(queries["query"]))))semantic = SemanticSearch()train, train_judgments = load_queries("train"), qrels("train")exact, outside = 0, 0for query_id, judged in train_judgments.items():    member = in_class(products, predicted[query_id])    exact += sum(grade == 2 for grade in judged.values())    outside += sum(grade == 2 and not member[product_id] for product_id, grade in judged.items())print(f"exact train products outside the predicted class: {outside} of {exact}")base = evaluate(semantic.run(train), train_judgments)print(f"train ndcg@10 semantic: {base['ndcg@10'].mean():.3f}")print(f"train judged@10 semantic: {base['judged@10'].mean():.3f}")train_scores = {}for weight in [None, 0.01, 0.02, 0.05, 0.1, 0.2]:                          # None: keep only the predicted class    train_scores[weight] = evaluate(class_boost_run(semantic, train.index, predicted, products, weight), train_judgments)    name = "filter" if weight is None else f"boost {weight}"    print(f"train ndcg@10 {name}: {train_scores[weight]['ndcg@10'].mean():.3f}")# every weight except None, the filterboosts = [weight for weight in train_scores if weight is not None]best = max(boosts, key=lambda weight: train_scores[weight]["ndcg@10"].mean())for name, weight in [("filter", None), ("best boost", best)]:    print(f"train judged@10 {name}: {train_scores[weight]['judged@10'].mean():.3f}")print("best boost on train:", best)print(f"\nthe planned test comparison, threshold {THRESHOLD:.2f}:")test, test_judgments = load_queries("test"), qrels("test")boosted = evaluate(class_boost_run(semantic, test.index, predicted, products, best), test_judgments)plain = evaluate(semantic.run(test), test_judgments)print(f"test judged@10 semantic: {plain['judged@10'].mean():.3f}")print(f"test judged@10 boosted: {boosted['judged@10'].mean():.3f}")report_planned("class boost, semantic", boosted["ndcg@10"], plain["ndcg@10"])
Salidapython class-boost-train-and-test.py
exact train products outside the predicted class: 501 of 1937
train ndcg@10 semantic: 0.772
train judged@10 semantic: 0.964
train ndcg@10 filter: 0.675
train ndcg@10 boost 0.01: 0.773
train ndcg@10 boost 0.02: 0.774
train ndcg@10 boost 0.05: 0.768
train ndcg@10 boost 0.1: 0.742
train ndcg@10 boost 0.2: 0.692
train judged@10 filter: 0.866
train judged@10 best boost: 0.966
best boost on train: 0.02

the planned test comparison, threshold 0.01:
test judged@10 semantic: 0.990
test judged@10 boosted: 0.993
class boost, semantic, mean difference: 0.005
class boost, semantic, wins, losses, ties: 7, 4, 19
class boost, semantic, permutation p: 0.174
class boost, semantic, established at 0.01: no
class boost, semantic, t-test p: 0.164
class boost, semantic, t-test agrees: yes
class boost, semantic, 99% interval: -0.002 to 0.017
class boost, semantic, interval agrees: yes

En las consultas de entrenamiento, el filtro obtiene peores resultados que el ordenador sin modificar: nDCG@10 baja de 0.772 a 0.675, y judged@10 de 0.964 a 0.866, de modo que sus primeros 10 resultados también se llenan de productos que nadie valoró.

Los aumentos pequeños apenas mueven la puntuación de entrenamiento, y los grandes la perjudican: nDCG@10 es 0.773 con 0.01 y 0.692 con 0.2. El mejor aumento en entrenamiento es 0.02, con 0.774, y judged@10 de 0.966.

En las consultas de prueba, judged@10 es 0.990 sin aumento y 0.993 con él, y la ganancia del aumento no está demostrada (comparaciones planificadas).

Regla práctica: No filtres por una clase predicha. Auméntala con un peso ajustado en las consultas de entrenamiento, y mantén el aumento solo si su comparación planificada queda demostrada. La de la tienda no lo está, así que su recuperación semántica se queda sin aumento. Recomendamos un filtro por clase solo cuando la clase la haya elegido la persona compradora, por ejemplo al hacer clic en una categoría.

Reescribir consultas con un LLM

Último cambio en la edición 2026.11.8

La reescritura de consultas sustituye la consulta por un texto escrito para recuperar mejores resultados. Mientras el corrector, las reglas de unidades y la lista de sinónimos corrigen cada uno un tipo de hueco, un LLM puede corregir la ortografía, expandir abreviaturas y añadir sinónimos en un solo paso, sin ninguna lista que mantener. En rewrite-retrieve-read, la consulta reescrita va al recuperador en lugar de la original (Ma et al., 2023). Los estudios informan de mejoras. Con query2doc, que añade a la consulta un pasaje escrito por un LLM, un pseudo-documento, BM25 mejoró entre un 3 % y un 15 % en conjuntos de datos de IR ad hoc, con text-davinci-003 escribiendo los pasajes para las consultas de MS MARCO y TREC DL (Wang et al., 2023). Otros estudios informan de fallos. Una comparación de 11 métodos de expansión, 12 conjuntos de datos y 24 recuperadores encontró que la expansión ayuda a los modelos más débiles y, en general, perjudica a los más fuertes (Weller et al., 2024). Otro estudio encontró que la expansión basada en LLM puede degradar de forma significativa la recuperación cuando el LLM carece del conocimiento necesario o la consulta es muy ambigua (Abe et al., 2025).

Las reescrituras que leen los ejemplos se registraron con el LLM de la tienda, el modelo abierto nombrado en la apertura del capítulo, ejecutado en local sobre cada consulta por separado. La instrucción del prompt es: "Rewrite this search query from an online furniture and home-goods store so that a search engine finds what the shopper wants. Fix spelling, expand abbreviations and add common synonyms for the product type, but keep every requirement the shopper stated and add none of your own. Return a single line." El resto del prompt da la consulta y pide JSON, y el manifiesto de la grabación lo recoge completo. El script de grabación incrustó cada reescritura como consulta, con el mismo modelo de incrustación que los productos. BM25 busca el texto de la reescritura, y la recuperación semántica su incrustación. Las consultas de entrenamiento van primero, para ver qué cambian las reescrituras antes de cualquier prueba:

llm-rewrites-on-train.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Prints the store's recorded LLM rewrites for a few train queries, then scores BM25 and semantic retrieval on thetrain queries, typed and rewritten. The prose's point rests on the nDCG@10 lines for both retrievers."""from lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.recorded import llm_rewrites, manifestfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsrecording = manifest("llm-rewrites")print("model:", recording["model"])print("embedding model:", recording["embedding_model"])print("rewrite prompt, first line:", recording["prompts"]["rewrite"].split("\n")[0])table, rewrite_vectors, _ = llm_rewrites()rewrites = table.set_index("query_id")["rewrite"]# the embeddings come in the table's row order, not query order: row maps each query_id to its rowrow = {query_id: position for position, query_id in enumerate(table["query_id"])}# a spelling fix, a product code, and malachi sledfor query_id in [20, 205, 313]:    print(f"rewrite of {load_queries().at[query_id, 'query']}: {rewrites[query_id]}")queries, judgments = load_queries("train"), qrels("train")products = load_products()# judgment grade 2 is exactexact = [product_id for product_id, grade in judgments[313].items() if grade == 2]print("exact products for malachi sled:", "; ".join(products.loc[exact, "name"]))bm25, semantic = LexicalSearch(products), SemanticSearch()runs = {"bm25, typed": bm25.run(queries),        "bm25, rewrite": bm25.run(queries.assign(query=rewrites[queries.index].to_numpy())),        "semantic, typed": semantic.run(queries),        "semantic, rewrite": {query_id: list(semantic.search_vector(rewrite_vectors[row[query_id]]).index)                              for query_id in queries.index}}scores = {name: evaluate(run, judgments) for name, run in runs.items()}for name, frame in scores.items():    print(f"train ndcg@10 {name}: {frame['ndcg@10'].mean():.3f}")    print(f"train judged@10 {name}: {frame['judged@10'].mean():.3f}")for retriever in ["bm25", "semantic"]:                       # for choosing, not evidence    change = (scores[f"{retriever}, rewrite"]["ndcg@10"] - scores[f"{retriever}, typed"]["ndcg@10"]).round(3)    print(f"train queries better, worse, {retriever}: {(change > 0).sum()}, {(change < 0).sum()}")    print(f"largest train loss, {retriever}: {queries.at[change.idxmin(), 'query']}")    print(f"largest train loss, {retriever}, change: {change.min():+.3f}")
Salidapython llm-rewrites-on-train.py
model: gemma4:12b-it-q4_K_M
embedding model: Snowflake/snowflake-arctic-embed-m-v1.5
rewrite prompt, first line: Rewrite this search query from an online furniture and home-goods store so that a search engine finds what the shopper wants. Fix spelling, expand abbreviations and add common synonyms for the product type, but keep every requirement the shopper stated and add none of your own. Return a single line.
rewrite of foutains with brick look: fountains with brick look, brick style water features, masonry fountains, faux brick fountains
rewrite of ines shag rug w003096809: Ines shag rug w003096809 area rug carpet
rewrite of malachi sled: Malachi sled sofa couch settee loveseat
exact products for malachi sled: malachi sled end table; malachi 44 '' console table; malachi sled coffee table
train ndcg@10 bm25, typed: 0.695
train judged@10 bm25, typed: 0.930
train ndcg@10 bm25, rewrite: 0.646
train judged@10 bm25, rewrite: 0.868
train ndcg@10 semantic, typed: 0.772
train judged@10 semantic, typed: 0.964
train ndcg@10 semantic, rewrite: 0.759
train judged@10 semantic, rewrite: 0.924
train queries better, worse, bm25: 23, 24
largest train loss, bm25: malachi sled
largest train loss, bm25, change: -0.644
train queries better, worse, semantic: 18, 25
largest train loss, semantic: wall design shelf
largest train loss, semantic, change: -0.653

La ortografía sale bien (fountains with brick look, brick style water features, masonry fountains, faux brick fountains), y los códigos se conservan (Ines shag rug w003096809 area rug carpet). Para malachi sled, una línea de productos, el LLM supuso un sofá: escribió Malachi sled sofa couch settee loveseat, mientras que los productos exactos son malachi sled end table; malachi 44 '' console table; malachi sled coffee table.

En las consultas de entrenamiento, la reescritura baja nDCG@10 para ambos recuperadores: BM25 de 0.695 a 0.646, y la recuperación semántica de 0.772 a 0.759. Judged@10 baja para ambos, de 0.930 a 0.868 y de 0.964 a 0.924, así que las reescrituras sacan productos que nadie juzgó, y parte de cada caída de nDCG@10 puede proceder de ellos.

Las pérdidas no son una sola consulta mala: el número de consultas que puntúan mejor y peor es 23, 24 para BM25 y 18, 25 para la recuperación semántica. La mayor pérdida de BM25 es malachi sled, la línea de productos que el LLM convirtió en un sofá, con -0.644, y la de la recuperación semántica es wall design shelf, con -0.653.

Estos números de entrenamiento moldean las expectativas y no demuestran nada. La tercera y la cuarta de las 5 comparaciones planificadas del capítulo se fijaron de antemano, así que se aplican a las consultas de prueba sea cual sea lo que muestren las de entrenamiento, y cada una se considera establecida si p es menor que 0.01. Antes de que lleguen los números de prueba, elige una opción: ¿la reescritura ayuda a BM25, el recuperador más débil, perjudica a la recuperación semántica, el más fuerte, o no hace ninguna de las dos cosas?

llm-rewrites-on-test.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Scores BM25 and semantic retrieval on the test queries, as typed and rewritten, as the chapter's planned comparisons,then repeats both on condensed runs as an exploratory check. The prose's point rests on the "established at 0.01" lines."""from lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.queries import THRESHOLD, condensed, report_planned, rewrite_runsfrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsqueries, judgments = load_queries("test"), qrels("test")             # scored on the human judgments# for each retriever, its run on the rewrite, then its run on the query as typedruns = rewrite_runs(queries, LexicalSearch(load_products()), SemanticSearch())print(f"the planned test comparisons, threshold {THRESHOLD:.2f}:")for retriever, (rewritten, typed) in runs.items():    name = f"llm rewrite, {retriever}"    after, before = evaluate(rewritten, judgments), evaluate(typed, judgments)    for form, frame in [("typed", before), ("rewrite", after)]:        print(f"{name}, test ndcg@10 {form}: {frame['ndcg@10'].mean():.3f}")        print(f"{name}, test judged@10 {form}: {frame['judged@10'].mean():.3f}")    report_planned(name, after["ndcg@10"], before["ndcg@10"])    # Exploratory, never established: the same comparison on condensed runs, which drop unjudged products    # rewritten comes first in each pair, as rewrite_runs returns them; the rewrite is "after"    after, before = (evaluate(condensed(run, judgments), judgments)["ndcg@10"] for run in (rewritten, typed))    # confidence = 1 - THRESHOLD: a 99% interval, at the level the planned comparisons use    result = compare(after, before, confidence=1 - THRESHOLD)    print(f"{name}, condensed ndcg@10 typed: {before.mean():.3f}")    print(f"{name}, condensed ndcg@10 rewrite: {after.mean():.3f}")    print(f"{name}, condensed, exploratory mean difference: {result['mean difference']:.3f}")    print(f"{name}, condensed, exploratory permutation p: {result['permutation p']:.3f}")    low, high = result["ci low"], result["ci high"]    print(f"{name}, condensed, exploratory {1 - THRESHOLD:.0%} interval: {low:.3f} to {high:.3f}")
Salidapython llm-rewrites-on-test.py
the planned test comparisons, threshold 0.01:
llm rewrite, bm25, test ndcg@10 typed: 0.725
llm rewrite, bm25, test judged@10 typed: 0.927
llm rewrite, bm25, test ndcg@10 rewrite: 0.669
llm rewrite, bm25, test judged@10 rewrite: 0.903
llm rewrite, bm25, mean difference: -0.056
llm rewrite, bm25, wins, losses, ties: 13, 15, 2
llm rewrite, bm25, permutation p: 0.060
llm rewrite, bm25, established at 0.01: no
llm rewrite, bm25, t-test p: 0.060
llm rewrite, bm25, t-test agrees: yes
llm rewrite, bm25, 99% interval: -0.143 to 0.005
llm rewrite, bm25, interval agrees: yes
llm rewrite, bm25, condensed ndcg@10 typed: 0.778
llm rewrite, bm25, condensed ndcg@10 rewrite: 0.725
llm rewrite, bm25, condensed, exploratory mean difference: -0.053
llm rewrite, bm25, condensed, exploratory permutation p: 0.044
llm rewrite, bm25, condensed, exploratory 99% interval: -0.150 to -0.002
llm rewrite, semantic, test ndcg@10 typed: 0.830
llm rewrite, semantic, test judged@10 typed: 0.990
llm rewrite, semantic, test ndcg@10 rewrite: 0.749
llm rewrite, semantic, test judged@10 rewrite: 0.947
llm rewrite, semantic, mean difference: -0.081
llm rewrite, semantic, wins, losses, ties: 7, 19, 4
llm rewrite, semantic, permutation p: 0.000
llm rewrite, semantic, established at 0.01: yes
llm rewrite, semantic, t-test p: 0.000
llm rewrite, semantic, t-test agrees: yes
llm rewrite, semantic, 99% interval: -0.132 to -0.035
llm rewrite, semantic, interval agrees: yes
llm rewrite, semantic, condensed ndcg@10 typed: 0.834
llm rewrite, semantic, condensed ndcg@10 rewrite: 0.791
llm rewrite, semantic, condensed, exploratory mean difference: -0.043
llm rewrite, semantic, condensed, exploratory permutation p: 0.002
llm rewrite, semantic, condensed, exploratory 99% interval: -0.079 to -0.014

Para BM25, nDCG@10 baja de 0.725 a 0.669, una diferencia que no está establecida (comparaciones planificadas). Judged@10 también baja, de 0.927 a 0.903.

La recuperación semántica muestra una pérdida establecida: nDCG@10 baja de 0.830 a 0.749, con un valor p de permutación que se redondea a 0.000. Judged@10 también baja, de 0.990 a 0.947.

Como judged@10 bajó, repetimos ambas comparaciones sobre listas condensadas, que eliminan los productos sin juzgar antes de puntuar. Esa comprobación se eligió después de ver la caída, así que es exploratoria y no puede establecer nada.

Para la recuperación semántica, el nDCG@10 condensado sigue bajando, de 0.834 a 0.791, una diferencia de -0.043, un valor p de permutación de 0.002 y un intervalo del 99 % desde -0.079 to -0.014. Así que la pérdida no depende solo de los productos sin juzgar.

Para BM25, el nDCG@10 condensado pasa de 0.778 a 0.725, con un valor p de permutación de 0.044.

La reescritura no ayudó a BM25: se movió en sentido contrario al que informan Weller et al. y query2doc, aunque no en una cantidad establecida. El daño de la reescritura a la recuperación semántica es lo que Weller et al. encontraron para recuperadores fuertes. Ambos resultados se sostienen para este modelo, este prompt y estas consultas.

Las consultas que más se mueven muestran lo que hace una reescritura. Léelas con el número de productos sin juzgar en el top 10 de cada reescritura, que la métrica cuenta como irrelevantes:

rewrite-largest-changes.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""For each retriever, finds the test queries whose nDCG@10 moves most under the rewrite, and counts the unjudgedproducts in each rewritten top 10. The prose's point rests on the largest-loss and largest-gain lines, and on thespelling-only check for BM25's largest gain."""from bm25s.stopwords import STOPWORDS_ENfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluate, ndcg_at_kfrom lib.queries import rewrite_runsfrom lib.recorded import llm_rewrites, probesfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsqueries, judgments = load_queries("test"), qrels("test")bm25 = LexicalSearch(load_products())rewrites = llm_rewrites()[0].set_index("query_id")["rewrite"]largest = {}for retriever, (rewritten, typed) in rewrite_runs(queries, bm25, SemanticSearch()).items():    change = evaluate(rewritten, judgments)["ndcg@10"] - evaluate(typed, judgments)["ndcg@10"]    for kind, query_id in [("loss", change.idxmin()), ("gain", change.idxmax())]:        label, largest[(retriever, kind)] = f"{retriever}, largest {kind}", query_id        print(f"{label}: {queries.at[query_id, 'query']}")        print(f"{label}, change: {change[query_id]:+.3f}")        print(f"{label}, rewrite: {rewrites[query_id]}")        unjudged = sum(product_id not in judgments[query_id] for product_id in rewritten[query_id][:10])        print(f"{label}, unjudged products in the rewrite's top 10: {unjudged}")# BM25's largest gain: score the query with only its spelling fixed (chapter 6's probe), apart from the added wordsquery_id = largest[("bm25", "gain")]# the spelling probes, keyed by the test query each one correctsspelled = probes()[0].dropna(subset=["of_query_id"]).set_index("of_query_id")["query"]if query_id in spelled.index:    for name, text in [("typed", queries.at[query_id, "query"]), ("spelling fixed only", spelled[query_id])]:        ranking = list(bm25.search(text, k=10).index)        print(f"bm25, largest gain, ndcg@10 {name}: {ndcg_at_k(ranking, judgments[query_id], 10):.3f}")    # bm25s's English stop words, which it drops before matching    print("bm25 stop words among an and and:", ", ".join(word for word in ["an", "and"] if word in STOPWORDS_EN))
Salidapython rewrite-largest-changes.py
bm25, largest loss: fold in half table
bm25, largest loss, change: -0.471
bm25, largest loss, rewrite: folding table, collapsible table, drop leaf table, gateleg table
bm25, largest loss, unjudged products in the rewrite's top 10: 3
bm25, largest gain: refrigerator with ice an water in door
bm25, largest gain, change: +0.159
bm25, largest gain, rewrite: refrigerator with ice and water in door, fridge with door dispenser, refrigerator with external water and ice dispenser
bm25, largest gain, unjudged products in the rewrite's top 10: 1
semantic, largest loss: pull out sleeper loveseat
semantic, largest loss, change: -0.304
semantic, largest loss, rewrite: pull out sleeper loveseat sofa couch convertible sofa sofa bed
semantic, largest loss, unjudged products in the rewrite's top 10: 4
semantic, largest gain: nautical platters
semantic, largest gain, change: +0.055
semantic, largest gain, rewrite: nautical platters serving trays seafood platters maritime serving boards
semantic, largest gain, unjudged products in the rewrite's top 10: 0
bm25, largest gain, ndcg@10 typed: 0.501
bm25, largest gain, ndcg@10 spelling fixed only: 0.501
bm25 stop words among an and and: an, and

Las dos mayores pérdidas proceden de una reescritura que elimina o amplía lo que pidió el comprador. La mayor pérdida de BM25, -0.471 para fold in half table, procede de folding table, collapsible table, drop leaf table, gateleg table, que elimina in half y añade otros tipos de mesa; 3 de su top 10 están sin juzgar. La mayor pérdida de la recuperación semántica, -0.304 para pull out sleeper loveseat, procede de pull out sleeper loveseat sofa couch convertible sofa sofa bed, que amplía un sofá de dos plazas a cualquier sofá; 4 de su top 10 están sin juzgar.

La mayor ganancia de BM25, +0.159 para refrigerator with ice an water in door, procede de refrigerator with ice and water in door, fridge with door dispenser, refrigerator with external water and ice dispenser. La reescritura corrige an, pero con solo esa corrección BM25 puntúa 0.501, lo mismo que la consulta tal como se escribió, 0.501, porque ambas grafías son palabras vacías. La ganancia viene de las palabras que añade la reescritura. La mayor ganancia de la recuperación semántica es +0.055, para nautical platters, reescrita como nautical platters serving trays seafood platters maritime serving boards.

Regla práctica: No pongas una reescritura de LLM delante de un recuperador fuerte sin una comparación planificada sobre las consultas de prueba. Lee las pérdidas por consulta en busca de requisitos eliminados y productos ampliados, que la instrucción "mantén cada requisito" del prompt no impide. La recuperación semántica de la tienda, el ranker que hay que superar, sigue buscando la consulta tal como se escribió.

Búsqueda con un producto hipotético (HyDE)

Último cambio en la edición 2026.11.10

Donde una reescritura le pide al LLM una mejor consulta, HyDE, abreviatura de hypothetical document embeddings (incrustaciones de documentos hipotéticos), le pide el documento que imagina que respondería a la consulta. Un codificador incrusta el documento hipotético, escrito por un LLM para responder a la consulta, y el vector cae en una zona del espacio de incrustaciones del corpus donde están los documentos reales (Gao et al., 2023). Los detalles inventados no tienen que ser verdaderos: los autores sostienen que el cuello de botella denso del codificador filtra los detalles alucinados, pero esto es su argumento, no una medición. Sus resultados principales usan InstructGPT (text-davinci-003), muestreado con temperatura 0.7. En TREC DL19, un benchmark de ranking de pasajes, HyDE elevó el nDCG@10 de Contriever, un modelo de incrustaciones entrenado sin etiquetas de relevancia, de 44.5 a 61.3 en una escala de 0 a 100 (Gao et al., Tabla 1). Con un Contriever ajustado con etiquetas, el resultado dependió del LLM. Los más pequeños bajaron ligeramente el nDCG@10, ya que los modelos de instrucciones más débiles pueden perjudicar el rendimiento general del recuperador ajustado, mientras que InstructGPT lo subió, sobre todo en DL19, de 62.1 a 67.4 (Tabla 4).

Varios métodos de expansión mantienen la consulta original en la mezcla. HyDE promedia las incrustaciones de los documentos hipotéticos junto con la de la propia consulta (Gao et al., sección 3.2). La retroalimentación de relevancia mejora una consulta a partir de los juicios sobre sus primeros resultados, y la versión de Rocchio desplaza el vector de la consulta hacia los resultados juzgados relevantes, manteniendo el vector original en su suma (Manning et al., 2008). Para BM25, query2doc repite la consulta cinco veces antes del pasaje generado, de modo que los términos originales conservan su peso (Wang et al., 2023).

El registro de HyDE contiene un producto hipotético por consulta, que el LLM de la tienda escribió solo a partir de la consulta: un nombre, una clase y una descripción, incrustados como un producto. La función hyde aquí lo promedia con la incrustación de la consulta y reescala el resultado a longitud 1, como el capítulo 6 aconseja después de cualquier promediado. Las dos incrustaciones se diferencian en un aspecto: la de la consulta lleva el prompt de consulta del modelo de incrustaciones, y la del producto no lleva ninguno, como ocurre con todos los productos.

hyde(query) = (embedding(hypothetical product) + embedding(query)) / 2,  then scaled to length 1

Sobre las consultas de entrenamiento, probamos también la incrustación del producto hipotético por sí sola y, para BM25, el texto del producto hipotético por sí solo y con la consulta repetida cinco veces antes, tal como lo pondera query2doc. Luego ejecutamos la última de las comparaciones planificadas del capítulo:

hyde-train-and-test.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Scores HyDE, its parts and their combinations with BM25 and semantic retrieval on the train queries, then runs HyDEagainst semantic retrieval as the chapter's last planned comparison on the test queries. The prose's point rests onthe train lines for the hypothetical product alone and on the planned comparison's lines."""import numpy as npfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.queries import THRESHOLD, report_plannedfrom lib.recorded import llm_rewritesfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrels# the hypothetical products' embeddings come in the table's row order; zip pairs each with its query_idtable, _, hypothetical_vectors = llm_rewrites()hypothetical, vectors = table.set_index("query_id")["hypothetical"], dict(zip(table["query_id"], hypothetical_vectors))bm25, semantic = LexicalSearch(load_products()), SemanticSearch()def hyde(query_id):    """Gao et al.'s average of the hypothetical product's embedding and the query's, scaled back to length 1."""    average = (vectors[query_id] + semantic.query_vectors[query_id]) / 2    return average / np.linalg.norm(average)def runs(queries):    ids, typed = queries.index, queries["query"]    return {"semantic": semantic.run(queries),            "hypothetical alone": {query_id: list(semantic.search_vector(vectors[query_id]).index) for query_id in ids},            "hyde": {query_id: list(semantic.search_vector(hyde(query_id)).index) for query_id in ids},            "bm25": bm25.run(queries),            "bm25, hypothetical alone": bm25.run(queries.assign(query=ids.map(hypothetical))),            "bm25, query five times plus hypothetical": bm25.run(queries.assign(           # query2doc's weighting                query=[" ".join([typed[query_id]] * 5 + [hypothetical[query_id]]) for query_id in ids]))}train = {name: evaluate(run, qrels("train")) for name, run in runs(load_queries("train")).items()}for name, frame in train.items():    print(f"train ndcg@10 {name}: {frame['ndcg@10'].mean():.3f}")    print(f"train judged@10 {name}: {frame['judged@10'].mean():.3f}")change = (train["hypothetical alone"]["ndcg@10"] - train["semantic"]["ndcg@10"]).round(3)    # for choosing, not evidenceprint(f"train queries better, worse, hypothetical alone: {(change > 0).sum()}, {(change < 0).sum()}")print(f"\nthe planned test comparison, threshold {THRESHOLD:.2f}:")test = {name: evaluate(run, qrels("test")) for name, run in runs(load_queries("test")).items()        if name in ["semantic", "hyde"]}for name, frame in test.items():    print(f"test judged@10 {name}: {frame['judged@10'].mean():.3f}")report_planned("hyde, semantic", test["hyde"]["ndcg@10"], test["semantic"]["ndcg@10"])
Salidapython hyde-train-and-test.py
train ndcg@10 semantic: 0.772
train judged@10 semantic: 0.964
train ndcg@10 hypothetical alone: 0.704
train judged@10 hypothetical alone: 0.890
train ndcg@10 hyde: 0.769
train judged@10 hyde: 0.946
train ndcg@10 bm25: 0.695
train judged@10 bm25: 0.930
train ndcg@10 bm25, hypothetical alone: 0.644
train judged@10 bm25, hypothetical alone: 0.854
train ndcg@10 bm25, query five times plus hypothetical: 0.694
train judged@10 bm25, query five times plus hypothetical: 0.912
train queries better, worse, hypothetical alone: 13, 29

the planned test comparison, threshold 0.01:
test judged@10 semantic: 0.990
test judged@10 hyde: 0.970
hyde, semantic, mean difference: -0.031
hyde, semantic, wins, losses, ties: 8, 14, 8
hyde, semantic, permutation p: 0.108
hyde, semantic, established at 0.01: no
hyde, semantic, t-test p: 0.121
hyde, semantic, t-test agrees: yes
hyde, semantic, 99% interval: -0.115 to 0.001
hyde, semantic, interval agrees: yes

Sobre las consultas de entrenamiento, el producto hipotético por sí solo lleva el nDCG@10 de la recuperación semántica de 0.772 a 0.704, y los números de consultas que puntúan mejor y peor son 13, 29. Judged@10 baja con él, de 0.964 a 0.890.

Promediado con la consulta, obtiene 0.769, con judged@10 de 0.946. BM25 se comporta de la misma manera: 0.695 con la consulta, 0.644 con el texto hipotético por sí solo, y 0.694 con la consulta repetida cinco veces antes, con judged@10 de 0.930, 0.854 y 0.912.

Mantener la consulta recupera lo que el producto hipotético pierde, y sobre las consultas de entrenamiento, para cualquiera de los dos recuperadores, la combinación no aporta nada sobre la consulta sola. Los números de entrenamiento orientan el diseño; solo la comparación de prueba planificada es evidencia.

Sobre las consultas de prueba, judged@10 pasa de 0.990 a 0.970, y HyDE no muestra una diferencia establecida con la recuperación semántica (comparaciones planificadas). Este resultado corresponde a un producto hipotético por consulta, del modelo de 12 mil millones de parámetros de la tienda, gemma4:12b-it-q4_K_M, ejecutado con temperatura 0. Gao et al. muestrearon de un LLM mucho mayor, y solo ese elevó su recuperador ajustado.

Regla práctica: Cuando pruebes HyDE, incorpora siempre la incrustación propia de la consulta en el promedio. Espera las mayores ganancias con un codificador entrenado sin etiquetas; con un codificador ajustado, Gao et al. vieron ganancias solo con su LLM más grande, y la tienda, con su modelo, prompt y codificador, no vio ninguna. En un codificador como el de la tienda, que ya supera a BM25 en estas consultas, prueba HyDE antes de pagar una llamada al LLM por consulta. La tienda no lo usa.

Convierte un seguimiento en una consulta independiente

Último cambio en la edición 2026.11.10

La última brecha de la apertura del capítulo proviene de la conversación: el siguiente mensaje de un comprador suele depender del anterior, como in white refina una búsqueda de un escritorio. La recuperación ve un solo texto, así que un seguimiento tiene que convertirse en una consulta independiente, una que se pueda leer sin los turnos anteriores y que conserve lo que el comprador todavía quiere. La reescritura conversacional de consultas convierte una pregunta dependiente del contexto en una autocontenida con la misma respuesta, y el conjunto de datos CANARD reúne 40,527 de estas reescrituras (Elgohary et al., 2019). En TREC CAsT 2019, una evaluación de búsqueda conversacional, las reescrituras de personas superaron en un 35 % relativo al mejor sistema automático (Dalton et al., 2020). Trabajos posteriores con LLM guiados por prompts encontraron que «las reescrituras de consulta informativas pueden producir un rendimiento de recuperación considerablemente mejor que las reescrituras humanas, especialmente con recuperadores dispersos» (Ye et al., 2023), y en TREC iKAT 2025, sucesor de CAsT, la mayoría de las ejecuciones usaron LLM en sus flujos, para la reescritura de consultas simples o múltiples (resumen de TREC iKAT 2025).

WANDS no tiene conversaciones, así que escribimos para el libro las conversaciones de la tienda: 12 seguimientos, cada uno refinando una consulta de prueba por un atributo (un color, una forma, un tamaño o un acabado). El LLM de la tienda, que vio solo los dos turnos, reescribió cada uno para que se sostuviera por sí mismo. Por ejemplo, tras coat rack for bedroom viene something in black, reescrito como black coat rack for bedroom. Los juicios califican los productos según la primera consulta, no según la consulta refinada, así que nDCG no puede puntuar el seguimiento. En su lugar, cuenta tres tipos de producto en cada top 10: los que conservan el refinamiento, porque sus attributes o su texto contienen el valor, como black (el ejemplo también imprime el recuento de attributes solo); los del tipo correcto, que los jueces calificaron como exacto o parcial para la primera consulta; y los que cumplen ambas condiciones. Comparamos el seguimiento solo con los dos turnos unidos y con la consulta independiente, cada una incrustada como consulta, con la primera consulta como línea base. Añadimos un filtro sobre los 100 primeros resultados de la consulta independiente que conserva los productos que declaran el valor, tomando el valor de la conversación registrada; un sistema en producción tendría que extraerlo del seguimiento.

follow-up-refinements.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 · scikit-learn 1.9.1 · scipy 1.18.1 Superado
"""Counts, in each conversation's top 10, the products that keep the refinement and the products of the right kind, forthe follow-up alone, the joined turns, the standalone query, and the standalone query filtered by the value. The prose'spoint rests on the "refinement in text or attributes" and "right kind with the refinement" lines."""import numpy as npfrom lib.queries import mentionsfrom lib.recorded import llm_conversationsfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, product_text, qrelsproducts, judgments, semantic = load_products(), qrels("test"), SemanticSearch()attributes, text = products["attributes"], product_text(products)        # the embeddings read only the textconversations, vectors = llm_conversations()                 # follow-ups we wrote for the book, not shoppers'print("conversations:", len(conversations))# row 4, the fifth conversation, which the example printsexample = conversations.iloc[4]print(f"first query: {load_queries().at[example['query_id'], 'query']}")print(f"follow-up: {example['follow_up']}")print(f"standalone: {example['standalone']}")shares, filtered_lengths = {}, []                            # shares: (top 10, measure) -> one share per conversationfor row, (first, value) in enumerate(zip(conversations["query_id"], conversations["value"])):    # the standalone query's top 100, the pool the filter draws from    standalone = semantic.search_vector(vectors["standalone"][row], k=100).index    stated = mentions(standalone, value, attributes) | mentions(standalone, value, text)    tops = {"first query": semantic.search(first, k=10).index,            "follow-up alone": semantic.search_vector(vectors["follow_up"][row], k=10).index,            "turns joined": semantic.search_vector(vectors["joined"][row], k=10).index,            "standalone": standalone[:10],            "standalone, filtered": standalone[stated][:10]}         # given the value, which a live system extracts    filtered_lengths.append(len(tops["standalone, filtered"]))    for name, top in tops.items():        in_attributes = mentions(top, value, attributes)        in_either = in_attributes | mentions(top, value, text)        # the first query's grade 1 (partial) or 2 (exact); a product with no judgment counts as 0        right_kind = np.array([judgments[first].get(product_id, 0) >= 1 for product_id in top], dtype=bool)        for measure, hits in [("refinement in attributes", in_attributes), ("refinement in text or attributes", in_either),                              ("right kind", right_kind), ("right kind with the refinement", in_either & right_kind)]:            shares.setdefault((name, measure), []).append(hits.sum() / 10)     # empty places count as missesfor (name, measure), values in shares.items():    print(f"{name}, {measure}: {np.mean(values):.3f}")kept = np.subtract(shares["standalone", "refinement in text or attributes"], shares["turns joined", "refinement in text or attributes"])print(f"standalone against turns joined, more, fewer, same: {(kept > 0).sum()}, {(kept < 0).sum()}, {(kept == 0).sum()}")print("conversations the filter leaves with fewer than 10 products:", sum(length < 10 for length in filtered_lengths))
Salidapython follow-up-refinements.py
conversations: 12
first query: coat rack for bedroom
follow-up: something in black
standalone: black coat rack for bedroom
first query, refinement in attributes: 0.125
first query, refinement in text or attributes: 0.200
first query, right kind: 0.958
first query, right kind with the refinement: 0.175
follow-up alone, refinement in attributes: 0.433
follow-up alone, refinement in text or attributes: 0.950
follow-up alone, right kind: 0.058
follow-up alone, right kind with the refinement: 0.058
turns joined, refinement in attributes: 0.208
turns joined, refinement in text or attributes: 0.383
turns joined, right kind: 0.933
turns joined, right kind with the refinement: 0.325
standalone, refinement in attributes: 0.200
standalone, refinement in text or attributes: 0.392
standalone, right kind: 0.958
standalone, right kind with the refinement: 0.350
standalone, filtered, refinement in attributes: 0.583
standalone, filtered, refinement in text or attributes: 0.900
standalone, filtered, right kind: 0.675
standalone, filtered, right kind with the refinement: 0.675
standalone against turns joined, more, fewer, same: 5, 4, 3
conversations the filter leaves with fewer than 10 products: 3

El seguimiento solo conserva el refinamiento en 0.950 de su top 10, pero solo 0.058 son del tipo correcto de producto. Cualquier forma que conserve la primera consulta encuentra el tipo correcto de producto: 0.933 para los turnos unidos y 0.958 para la consulta independiente.

En estas conversaciones, los turnos unidos y la consulta independiente conservan el refinamiento con más frecuencia que la primera consulta, que nunca lo pidió: 0.383 y 0.392, frente a 0.200.

Contado en attributes solo, las proporciones son más bajas, 0.208, 0.200 y 0.125, porque muchos productos declaran el valor solo en su texto, que es lo único que leen los embeddings. Las conclusiones de abajo se basan en el recuento de texto o atributos, que puede sobrestimar, ya que un producto que menciona round legs cuenta como redondo.

La reescritura del LLM no funciona mejor que unir los turnos: frente a los turnos unidos, la consulta independiente conserva más, menos o el mismo número de productos refinados en 5, 4, 3 conversaciones, y los productos del tipo correcto que además conservan el refinamiento constituyen el 0.350 de los top 10 de la consulta independiente, frente al 0.325 de los turnos unidos.

El filtro eleva esa proporción a 0.675, pero deja 3 conversaciones con menos de 10 productos.

Estas 12 conversaciones son nuestras, no de compradores, así que los recuentos son un diagnóstico, no una prueba.

Regla práctica: Nunca busques un seguimiento solo. Únelo al menos a los turnos anteriores, o reescríbelo para que se sostenga por sí mismo. Cuando el refinamiento nombre un valor que el catálogo declara, extráelo y prioriza o filtra por él, y recurre a la lista sin filtrar cuando queden muy pocos productos. Mide con conversaciones de tus propios registros antes de confiar en nada de esto.

Qué sale mal en producción

Último cambio en la edición 2026.11.8

Cada reescritura con un LLM es una llamada al modelo en el camino de la consulta. Los ejemplos leen reescrituras grabadas una vez, sin conexión, pero un cuadro de búsqueda en vivo llama al modelo en cada consulta mientras la persona compradora espera. Los autores de query2doc señalan que necesita inferencia con LLM, que puede ser bastante más lenta (Wang et al., 2023), y la consulta más larga también ralentiza la búsqueda con BM25. Una regla práctica, no una medición: reescribe sin conexión las consultas frecuentes y guarda los resultados en caché, y llama al modelo en línea solo para las consultas en las que una prueba muestre una mejora.

Una reescritura pertenece a un modelo y a un prompt. Otra versión del modelo o un prompt reformulado pueden cambiar cualquier reescritura. Los manifiestos de las grabaciones de la tienda guardan el resumen criptográfico del modelo y cada prompt literalmente, y un cambio en cualquiera de los dos obliga a volver a medir.

El léxico debe seguir al catálogo. Un corrector construido con el catálogo del mes pasado puede tomar por erratas los nombres de marca de este mes. Reconstruye el léxico junto con el índice y registra cada consulta que el corrector modifique junto a la original, para poder detectar sobrecorrecciones como tye → the. En consultas traducidas automáticamente, las erratas cambian qué productos devuelve una búsqueda (Hanneman et al., 2024), así que espera que un error que el corrector no detecte se manifieste como resultados inestables para una consulta.

Un clasificador sigue a su taxonomía. Cuando las clases de producto se renombran, dividen o fusionan, vuelve a entrenar el clasificador. Una clase de consulta que no nombra ninguna clase de producto, como Crock Pots & Slow Cookers, nunca puede predecirse; para 7qt slow cooker el clasificador predice Slow Cookers en su lugar.

Las consultas reescritas hacen aparecer productos no juzgados. Cada cambio basado en LLM de este capítulo que se puntuó con nDCG@10 redujo judged@10. Antes de adoptar una reescritura, haz juzgar los productos no juzgados de sus primeros 10 resultados, o revisa las puntuaciones condensadas como lo hace el capítulo 2.

Regla práctica: Registra la consulta tal como se escribió y como se reescribió, guarda en caché las reescrituras con LLM, versiona el modelo y el prompt junto con las salidas, y reconstruye el léxico y el clasificador cada vez que cambie el catálogo.

Decisiones que tomó este capítulo

Último cambio en la edición 2026.11.8

Cada ajuste de abajo se eligió con las consultas de entrenamiento. La tabla recoge las 5 comparaciones planificadas del capítulo sobre las consultas de prueba, una por columna: un recuperador con un solo cambio, frente al mismo recuperador con la consulta tal como se escribió.

Medida BM25, sinónimos Semántico, refuerzo de clase BM25, reescritura con LLM Semántico, reescritura con LLM Semántico, HyDE
Diferencia media 0.000 0.005 -0.056 -0.081 -0.031
Victorias, derrotas, empates 0, 0, 30 7, 4, 19 13, 15, 2 7, 19, 4 8, 14, 8
p de permutación 1.000 0.174 0.060 0.000 0.108
Establecido no no no yes no
p de la prueba t 1.000 0.164 0.060 0.000 0.121
Intervalo del 99 % 0.000 to 0.000 -0.002 to 0.017 -0.143 to 0.005 -0.132 to -0.035 -0.115 to 0.001
La prueba t coincide yes yes yes yes yes
El intervalo coincide yes yes yes yes yes
  • Ortografía: corrige solo las palabras que el catálogo no usa. El corrector arregla las erratas de entrenamiento de la tienda, pero las consultas con erratas son muy pocas para probarlo, y necesita contexto antes de manejar tye dye o ice an water. La tienda todavía no lo ejecuta.
  • Unidades: una sola forma escrita para productos y consultas, con las ortografías del propio catálogo, manteniendo los decimales completos. Las consultas de tamaño son muy pocas para probarlo, así que BM25 de referencia se mantiene tal como está.
  • Sinónimos: una lista para las lagunas vistas en las consultas de entrenamiento, solo para BM25. Cambió 1 consulta de prueba y no mostró una diferencia establecida, así que la referencia no expande.
  • Clases de consulta: Bayes ingenuo entrenado con el texto de los productos, porque la muestra tiene como máximo una consulta por clase. La clase predicha es una pista. Un filtro pierde en entrenamiento, y el mejor refuerzo no está establecido en prueba, así que el recuperador semántico se queda sin refuerzo.
  • Reescrituras con LLM: no se usan. La pérdida para el recuperador semántico está establecida, y el cambio en BM25 no.
  • HyDE: no se usa. Promediado con la consulta, no muestra una diferencia establecida, y el producto hipotético por sí solo pierde en entrenamiento.
  • Seguimientos: nunca se buscan por separado. Unir los turnos funciona casi igual de bien que la consulta independiente del LLM. Un filtro sobre el valor refinado es el siguiente paso, y necesita un valor extraído y una alternativa.
  • Los recuperadores toman la consulta tal como se escribió: la recuperación semántica sigue siendo el clasificador a superar, y BM25, sin lematizar, sigue siendo la referencia.
  • Lo que mostró el capítulo: un cambio que parece correcto con las consultas de entrenamiento tiene que superar una comparación planificada con las consultas de prueba, y ninguno de los cambios probados aquí la superó como mejora. La reescritura del LLM fue la única diferencia establecida, y fue una pérdida para el recuperador semántico.

Este capítulo, en esta edición

Edición 2026.11.10Ejemplos verificados el 19 de nov de 2026Superan la prueba 12 de 12 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.10.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 8 de 11: Comprender las consultas

  1. Corrige la ortografía según las palabras del catálogo
  2. Normaliza las unidades como las escribe el catálogo
  3. Expandir consultas con una lista de sinónimos
  4. Entrena un clasificador de consultas con texto de productos
  5. Potenciar la clase predicha en lugar de filtrar
  6. Reescribir consultas con un LLM
  7. Búsqueda con un producto hipotético (HyDE)
  8. Convierte un seguimiento en una consulta independiente
  9. Qué sale mal en producción
  10. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos