Búsqueda, de principio a fin

Unos 31 minutos de lectura, con 11 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 terminar este capítulo podrás construir una canalización de búsqueda aproximada pero completa para un catálogo de productos, desde la consulta de un comprador hasta una lista ordenada de productos, y medir con un solo número si un cambio en esa canalización la mejora. Cada capítulo posterior toma una parte de esta canalización y la vuelve sólida.

Los compradores de una tienda en línea de muebles y artículos para el hogar escriben en su cuadro de búsqueda consultas como clear shower curtain o 48 inch kitchen hood. El libro sigue a esa tienda a lo largo de todo el texto y la llama la tienda. La tienda necesita dos respuestas: qué tan buena es su búsqueda y si un cambio la mejora. Te enfrentarás a las mismas dos preguntas con cualquier sistema de búsqueda, así que el libro prueba todos los métodos con la tienda, donde puedes ver qué hace cada uno con consultas reales.

La tienda tiene lo necesario para responderlas: un catálogo, un conjunto de consultas reales y los juicios de personas sobre qué productos corresponden a cada consulta. Así que en este capítulo buscarás en el catálogo de tres maneras (por coincidencia de palabras, por coincidencia de significado y combinando ambas), reordenarás los mejores resultados con un modelo más lento y evaluarás cada versión con esos juicios. No todas las etapas mejoran la puntuación. Esa es la lección principal del capítulo: mide cada cambio.

Cargar los datos de la tienda

Último cambio en la edición 2026.11.10

Antes de mejorar un sistema de búsqueda, necesitas tres cosas: los elementos que busca, las consultas que escriben las personas y los juicios que indican qué elementos coinciden con cada consulta. Los motores de búsqueda llaman documentos a los elementos. En este libro son productos. Un juicio es la etiqueta que da una persona a un par formado por una consulta y un producto, y una calificación es el número que representa la etiqueta de un juicio. Sin juicios, puedes observar los resultados y formarte opiniones, pero no puedes distinguir una mejora de una regresión.

Los datos de la tienda, que los ejemplos del libro buscan y puntúan, son reales. Es una muestra de WANDS, un conjunto de datos público de búsqueda de productos que Wayfair publicó con un artículo en ECIR 2022 (Chen et al., 2022), bajo la licencia MIT (licencia). El conjunto completo tiene 42,994 productos, 480 consultas y 233,448 juicios (repositorio). Las consultas son una muestra estratificada de búsquedas reales de compradores tomada del registro de búsquedas de un trimestre de 2021, y cada etiqueta es el voto mayoritario de hasta tres anotadores entrenados (Chen et al., secciones 4.1 y 5). El script prep/wands_sample.py extrae la muestra del libro, y la ficha de datos de la muestra, examples/data/wands/README.md, explica cómo. El código de preparación que necesitan muchos ejemplos vive en los módulos compartidos del libro, archivos breves en examples/lib/ que puedes abrir y leer. lib.store, uno de esos módulos, carga la muestra, y el siguiente ejemplo muestra lo que devuelve:

load-the-store.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Loads the store's sample and prints its size, how its queries split, and how its judgments are labelled. The prose quotes the split from the `train queries` and `test queries` lines."""import pandas as pdfrom lib.store import DATA, load_labels, load_products, load_queriesproducts = load_products()queries = load_queries()labels = load_labels()                                   # one row per judged (query, product) pairconflicts = pd.read_csv(DATA / "label_conflicts.csv")    # pairs WANDS labelled two waysprint(f"products: {len(products):,}")print("queries:", len(queries))print("train queries:", (queries["split"] == "train").sum())print("test queries:", (queries["split"] == "test").sum())print(f"judged pairs: {len(labels):,}")print("pairs with conflicting labels:", len(conflicts))for label in ["exact", "partial", "irrelevant"]:    print(f"{label} pairs: {(labels['label'] == label).sum():,}")print(f"products judged for at least one query: {labels['product_id'].nunique():,}")print()print(queries.head(4).to_string())
Salidapython load-the-store.py
products: 12,000
queries: 80
train queries: 50
test queries: 30
judged pairs: 13,077
pairs with conflicting labels: 7
exact pairs: 3,252
partial pairs: 7,972
irrelevant pairs: 1,853
products judged for at least one query: 11,917

                               query        query_class  split
query_id
6                acrylic clear chair      Dining Chairs  train
10                   king poster bed               Beds  train
20          foutains with brick look          Wallpaper  train
36        laundry basket with wheels  Hampers & Baskets  train

La muestra tiene 12,000 productos y 80 consultas. Las consultas se dividen una sola vez, antes de ejecutar cualquier ranker: 50 consultas de entrenamiento para ajustar y 30 consultas de prueba para informar. Todas las puntuaciones de este libro se informan sobre las consultas de prueba, y nada se ajusta con ellas. Una puntuación sobre consultas con las que ajustaste mide qué tan bien te ajustaste a esas consultas, no qué tan bien funciona la búsqueda.

WANDS juzgó algunos pares más de una vez. La muestra conserva una fila por par, 13,077 en total. Cuando las etiquetas de un par difieren, la muestra conserva la calificación más baja y registra el par en label_conflicts.csv, que contiene 7 pares. El código que puntúa un ranking lee los juicios a través de lib.store.qrels, que los devuelve como {query_id: {product_id: grade}}. El capítulo 2 examina los juicios con detenimiento.

Cada juicio es una de tres etiquetas, definidas por los autores del conjunto de datos (Chen et al., sección 3.2). Exacto significa que el producto coincide por completo con la consulta de búsqueda. Parcial significa que solo "coincide con la entidad objetivo de la consulta, pero no cumple los modificadores de la consulta". Irrelevante significa que el producto no es relevante para la consulta. Las calificaciones del libro son 2, 1 y 0. De los pares juzgados, 3,252 son exactos, 7,972 parciales y 1,853 irrelevantes. En este libro, un producto relevante es aquel juzgado como exacto para la consulta, salvo que una oración indique lo contrario.

Los datos de la tienda vienen con tres advertencias. Primero, la query_class de cada consulta es la clase predicha por WANDS para ella, no un juicio (Chen et al., Tabla 1): foutains with brick look se clasifica como Wallpaper. Tómala como una pista. Segundo, nadie juzgó todos los productos para todas las consultas. Eso habría requerido unos 60 millones de juicios, así que WANDS juzgó candidatos reunidos a partir de productos en los que los compradores hicieron clic o que añadieron a sus carritos y de varios sistemas de búsqueda, y se detuvo cuando aparecieron pocas coincidencias exactas nuevas (Chen et al., secciones 4.2 y 4.3). Un producto sin juicio para una consulta es sin juzgar: desconocido, no irrelevante. Tercero, casi todos los productos de la muestra, 11,917 de 12,000, están juzgados para al menos una de sus consultas, así que la muestra contiene menos distractores que un catálogo completo: productos que compiten por los primeros puestos de una consulta sin coincidir con ella.

Regla práctica: Divide tus consultas en entrenamiento y prueba antes de cambiar nada. Lee los resultados de prueba para entender un ranker, pero elige y ajusta cada cambio con consultas de entrenamiento, e informa con las de prueba. Trata los productos sin juzgar como desconocidos. Si todavía no tienes juicios, recoge algunos antes de cambiar el ranking.

Clasificar productos con BM25

Último cambio en la edición 2026.11.10

Buscar en el catálogo de la tienda cumple dos funciones. La recuperación encuentra los productos que podrían coincidir con una consulta, dentro de todo el catálogo. La clasificación ordena los productos recuperados, del mejor al peor. El enfoque léxico hace ambas cosas comparando las palabras de la consulta con las palabras del texto de cada producto, y puntuando la coincidencia.

BM25 es una función de puntuación léxica con tres partes. Un producto puntúa más alto cuando contiene las palabras de la consulta, y más aún si son palabras poco frecuentes, porque una palabra que aparece en pocos productos dice más sobre ellos. Repetir una palabra suma cada vez menos, hasta un límite, que la literatura sobre BM25 llama saturación. Y un texto largo se penaliza frente a uno corto, de modo que no puede ganar solo por contener más palabras; el parámetro b fija cuánto, desde 0 (sin penalización) hasta 1 (penalización total) (Robertson and Zaragoza, 2009). El capítulo 5 construye la fórmula a mano.

El BM25 del libro funciona con bm25s 0.3.16, una biblioteca de Python para BM25. Por defecto puntúa con la variante de BM25 que usa la biblioteca de búsqueda Lucene, con k1=1.5 (el ajuste de saturación) y b=0.75 (código fuente de bm25s). Sus puntuaciones difieren un poco de la fórmula estándar de los manuales, pero un estudio de reproducibilidad sobre tres colecciones de noticias no encontró diferencias significativas de eficacia entre las variantes de BM25 (Kamphuis et al., 2020). Antes de puntuar, bm25s divide el texto en tokens. Los pasa a minúsculas, conserva las palabras de dos o más caracteres, elimina las palabras vacías del inglés como and y no reduce las palabras a un radical común (tokenizador de bm25s). El clasificador que usa este libro, lib.lexical.LexicalSearch, indexa el nombre, la clase, la categoría y la descripción de cada producto, unidos en un solo texto.

La consulta de prueba de la tienda clear shower curtain muestra BM25 en acción. Quien escribe esa consulta busca una cortina transparente, y el catálogo tiene muchas cortinas que no son transparentes, además de accesorios que comparten las palabras. Estos son los 10 primeros resultados de BM25:

La mayoría de los diez son cortinas o forros de ducha, pero los últimos son ganchos para cortinas de ducha. BM25 encontró las palabras "shower curtain" en los nombres de los ganchos y les dio una puntuación casi tan alta como a las cortinas, porque compara palabras, no cosas: no sabe que un gancho no es una cortina. Nada de lo impreso aquí indica si las cortinas son transparentes. Para eso necesitas los juicios de la tienda.

Regla práctica: Empieza con BM25 con los valores por defecto de la biblioteca como línea base. No necesita datos de entrenamiento ni modelo, y cuando falla puedes ver qué palabras lo causaron. No cambies sus parámetros hasta que puedas medir un cambio con consultas de entrenamiento. Cuando los compradores y los productos usen palabras distintas para lo mismo, añade recuperación semántica.

Revisa los resultados frente a los juicios

Último cambio en la edición 2026.11.8

Un ranking significa poco mientras no sepas qué quería el comprador. Los juicios aportan esa información, un par a la vez. Para este propósito son mejor evidencia que los clics. Los autores de WANDS señalan que "los datos de registros de comportamiento de usuarios sufren sesgos posicionales y favorecerían los rankings similares al sistema de producción" (Chen et al., sección 3.1). Un comprador hace clic en lo que se le muestra primero, así que los clics confirman sobre todo el ranking que ya tienes.

A continuación, coloca cada uno de los 10 primeros productos de BM25 para clear shower curtain junto a su juicio. Un producto que nadie juzgó para esta consulta aparece como unjudged:

judge-first-results.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Puts BM25's top 10 for `clear shower curtain` beside each product's judgment, and counts the labels. The prose's reading of the top 10 rests on the labelled rows and the `in the top 10` lines after them."""from lib.lexical import LexicalSearchfrom lib.store import load_products, load_queries, qrelsLABELS = {2: "exact", 1: "partial", 0: "irrelevant"}products = load_products()query_id = 246query = load_queries().at[query_id, "query"]judgments = qrels()[query_id]                        # {product_id: grade} for this querytop = LexicalSearch(products).search(query, k=10).index# a product with no judgment for this query is unjudged, not irrelevantresults = [LABELS.get(judgments.get(product_id), "unjudged") for product_id in top]print("query:", query)print()for rank, (product_id, label) in enumerate(zip(top, results), start=1):    print(f"{rank:>2}  {label:<10}  {products.at[product_id, 'name'][:55]}")print()for label in ["exact", "partial", "irrelevant", "unjudged"]:    print(f"{label} in the top 10: {results.count(label)}")print("products judged for this query:", len(judgments))print("exact products judged for this query:", sum(grade == 2 for grade in judgments.values()))
Salidapython judge-first-results.py
query: clear shower curtain

 1  partial     rodas vinyl shower curtain
 2  exact       woolley vinyl single shower curtain
 3  exact       woolley vinyl solid color single shower curtain
 4  exact       siniard single shower curtain
 5  exact       simmon vinyl single shower curtain liner
 6  partial     71 '' x71 '' 4pcs shower curtain sets beach theme showe
 7  partial     newburg check 3d vinyl single shower curtain + hooks
 8  irrelevant  gilded pineapple shower curtain hooks
 9  irrelevant  double shower curtain hooks
10  irrelevant  stainless steel shower curtain hooks

exact in the top 10: 4
partial in the top 10: 3
irrelevant in the top 10: 3
unjudged in the top 10: 0
products judged for this query: 253
exact products judged for this query: 12

Los 10 primeros resultados de BM25 contienen 4 productos exactos, 3 parciales, 3 irrelevantes (los ganchos) y 0 sin juzgar. El primer resultado es parcial: según la definición del conjunto de datos, coincide con lo que el comprador pidió, una cortina de ducha, pero no con el modificador, transparente.

Los juicios también indican cuál sería el mejor top 10 posible. Los evaluadores etiquetaron 253 productos para esta consulta, de los cuales 12 son exactos. Así, un ranking ideal podría ocupar las diez posiciones con productos exactos, y BM25 ocupó 4. Esa diferencia es lo que una métrica debe medir.

Leer los resultados de esta manera muestra el tipo de error que comete un ranker. Aquí, BM25 coincidió con las palabras de un accesorio y pasó por alto un modificador. Un promedio sobre muchas consultas oculta eso, y los errores que ves son los que puedes corregir.

Regla práctica: Antes de calcular cualquier métrica, lee los primeros resultados de cinco o diez consultas junto a sus juicios. Busca patrones: accesorios, modificadores que faltan, tamaños incorrectos. Cuando varios de los primeros resultados no estén juzgados, haz que se juzguen antes de confiar en la puntuación de esa consulta.

Puntúa un ranking con nDCG@10

Último cambio en la edición 2026.11.10

Para comparar rankings, necesitas un número por ranking. Debe premiar los productos coincidentes, y los exactos más que los parciales, y contar más un producto cercano a la parte superior que uno cercano a la inferior, porque los compradores leen desde arriba. Ganancia acumulada descontada normalizada en 10, nDCG@10, cumple las tres cosas.

En palabras: cada uno de los 10 primeros resultados obtiene una ganancia igual a su grado: 2 si es exacto, 1 si es parcial, 0 si es irrelevante. La ganancia se divide entre un descuento que crece con la posición: el logaritmo en base 2 de la posición más uno, de modo que el primer resultado cuenta por completo y el tercero cuenta la mitad. Sumar las ganancias descontadas da la ganancia acumulada descontada, DCG. Al dividir entre el DCG del mejor top 10 posible para esa consulta, el DCG ideal, la puntuación queda entre 0 y 1, donde 1 significa que no existe un top 10 mejor. Un producto no evaluado obtiene 0.

DCG@10  = sum over positions i from 1 to 10 of  grade(i) / log2(i + 1)
nDCG@10 = DCG@10 / ideal DCG@10

El artículo de WANDS también puntúa la búsqueda con nDCG@10, con ganancias de 1.0, 0.5 y 0 para exacto, parcial e irrelevante (Chen et al., sección 6). Los grados del libro son el doble de esas ganancias, lo que duplica tanto el DCG como el DCG ideal, así que nDCG no cambia.

Toma el ranking que BM25 asigna a clear shower curtain: primero un producto parcial, luego cortinas exactas y parciales, y después tres ganchos irrelevantes. Calcula a mano el DCG, el DCG ideal y su cociente, y compáralos con lib.metrics, el módulo compartido de métricas del libro:

ndcg-for-one-query.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Computes nDCG@10 for one test query step by step, then checks it against `lib.metrics`. The prose's point rests on the `ndcg@10` line and on the library line that prints the same value."""import mathfrom lib.lexical import LexicalSearchfrom lib.metrics import ndcg_at_kfrom lib.store import load_products, load_queries, qrelsproducts = load_products()query = load_queries().at[246, "query"]                      # "clear shower curtain"judgments = qrels("test")[246]                                # {product_id: grade}ranking = list(LexicalSearch(products).search(query, k=10).index)grades = [judgments.get(product_id, 0) for product_id in ranking]     # unjudged counts as 0# positions count from 1, so the first result is discounted by log2(2) = 1dcg = sum(grade / math.log2(position + 1) for position, grade in enumerate(grades, start=1))best = sorted(judgments.values(), reverse=True)[:10]                  # the best possible top 10ideal = sum(grade / math.log2(position + 1) for position, grade in enumerate(best, start=1))print("grades:", grades)print("best grades:", best)print(f"dcg@10: {dcg:.3f}")print(f"ideal dcg@10: {ideal:.3f}")print(f"ndcg@10: {dcg / ideal:.3f}")print(f"ndcg@10 from lib.metrics: {ndcg_at_k(ranking, judgments, 10):.3f}")
Salidapython ndcg-for-one-query.py
grades: [1, 2, 2, 2, 2, 1, 1, 0, 0, 0]
best grades: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
dcg@10: 5.586
ideal dcg@10: 9.087
ndcg@10: 0.615
ndcg@10 from lib.metrics: 0.615

El ranking obtiene un DCG de 5.586. El mejor top 10 posible contiene solo productos exactos y obtiene 9.087. Su cociente, 0.615, coincide con lo que devuelve ndcg_at_k en lib.metrics: 0.615. El producto parcial en la posición 1 es el que más puntuación hace perder de todos los resultados individuales, porque ocupa el lugar sin descuento. Cada gancho resta menos, porque está más abajo, pero juntos restan más.

Ese único número resume lo que mostraron los juicios: un ranking que encontró el tipo correcto de producto y cometió dos tipos de error. Puedes calcularlo para cualquier ranking de cualquier consulta evaluada, y compararlos.

Regla práctica: Usa nDCG@10 como métrica principal cuando tus juicios sean graduados y la primera página de resultados sea lo más importante, como sucede en la búsqueda de una tienda. Cuando solo tengas etiquetas de sí o no, o cuando los compradores miren un solo resultado, otra métrica encaja mejor. El capítulo 3 construye las alternativas y dice cuándo elegir cada una.

Puntúa todas las consultas de prueba

Último cambio en la edición 2026.11.10

Una consulta es una anécdota. Para juzgar un buscador, puntúalo sobre un conjunto fijo de consultas y promedia: en este libro, las consultas de prueba. Las listas de resultados de todas las consultas de un conjunto forman una ejecución, que se escribe como {query_id: [product_id, ...]}, con el mejor resultado primero. lib.metrics.evaluate puntúa una ejecución frente a los juicios y devuelve una fila por consulta.

Junto a nDCG@10, evaluate informa de judged@10: la proporción de los 10 primeros que tiene algún juicio para la consulta. Como los productos sin juzgar cuentan como grado 0, un judged@10 bajo significa que la puntuación es en parte una suposición. No puede distinguir un producto irrelevante de uno relevante que nadie juzgó.

Ahora ejecuta BM25 sobre todas las consultas de prueba, conserva sus 100 primeros productos para cada una y puntúa la ejecución:

bm25-test-scores.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Scores BM25 on every test query, keeping each query's top 100, and prints the averages and the spread. The prose's point rests on the mean and judged@10 lines and on the three lowest queries printed after them."""from lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.store import load_products, load_queries, qrelsLABELS = {2: "exact", 1: "partial", 0: "irrelevant"}products, queries, judgments = load_products(), load_queries("test"), qrels("test")run = LexicalSearch(products).run(queries, k=100)       # {query_id: [product_id, ...]}scores = evaluate(run, judgments)                        # one row per test queryscores["query"] = queries["query"]print("test queries:", len(scores))print(f"mean ndcg@10: {scores['ndcg@10'].mean():.3f}")print(f"mean judged@10: {scores['judged@10'].mean():.3f}")print(f"lowest ndcg@10: {scores['ndcg@10'].min():.3f}")print(f"median ndcg@10: {scores['ndcg@10'].median():.3f}")print(f"highest ndcg@10: {scores['ndcg@10'].max():.3f}")print("queries with ndcg@10 of 1:", (scores["ndcg@10"].round(3) == 1).sum())print()lowest = scores.nsmallest(3, "ndcg@10")print(lowest[["query", "ndcg@10", "judged@10"]].round(3).to_string())print("lowest query:", lowest["query"].iloc[0])print(f"judged@10 of the lowest query: {lowest['judged@10'].iloc[0]:.3f}")print()# query 133, outdoor light fixtures, is the second-lowest scorer in the table aboveprint(f"judged@10 for {queries.at[133, 'query']}: {scores.at[133, 'judged@10']:.3f}")print("bm25 top 5 for", queries.at[133, "query"])for product_id in run[133][:5]:    label = LABELS.get(judgments[133].get(product_id), "unjudged")    print(f"  {label:<10}  {products.at[product_id, 'name'][:60]}")
Salidapython bm25-test-scores.py
test queries: 30
mean ndcg@10: 0.725
mean judged@10: 0.927
lowest ndcg@10: 0.212
median ndcg@10: 0.687
highest ndcg@10: 1.000
queries with ndcg@10 of 1: 4

                            query  ndcg@10  judged@10
query_id
46           beach blue headboard    0.212        0.5
133        outdoor light fixtures    0.286        0.2
292       decorative white pillow    0.467        1.0
lowest query: beach blue headboard
judged@10 of the lowest query: 0.500

judged@10 for outdoor light fixtures: 0.200
bm25 top 5 for outdoor light fixtures
  exact       malikah 1 -bulb outdoor bulkhead light
  unjudged    60 watt equivalent e12 led candle light bulb
  unjudged    5w ( 40 watt equivalent ) , b11 led , dimmable light bulb e1
  unjudged    60 watt equivalent , a19 led , non-dimmable light bulb , war
  unjudged    40 watt equivalent e12 dimmable led edison candle light bulb

Sobre 30 consultas de prueba, BM25 promedia un nDCG@10 de 0.725, con un judged@10 medio de 0.927. Ese promedio es el primer resultado medido de la tienda, y cada buscador posterior se compara con él.

El promedio oculta una gran dispersión. Las puntuaciones van de 0.212 a 1.000, con una mediana de 0.687, y 4 consultas obtienen un 1 perfecto.

La consulta con la puntuación más baja, beach blue headboard, tiene un judged@10 de 0.500. Otra consulta de puntuación baja, outdoor light fixtures, tiene un judged@10 de 0.200: los 5 primeros de BM25 contienen una luminaria exterior exacta, y luego bombillas que comparten las palabras de la consulta y que nadie juzgó para esta consulta. Una bombilla no es una luminaria, así que aquí el grado 0 probablemente es justo. Pero la métrica no puede saberlo, y para otro buscador u otra consulta, los productos sin juzgar podrían ser buenos.

Regla práctica: Informa del nDCG@10 medio sobre las consultas de prueba junto con el judged@10 medio, y lee las consultas con peor puntuación cada vez que puntúes una ejecución. Cuando el judged@10 de un buscador sea menor que el de otro, averigua por qué antes de comparar sus nDCG: la diferencia puede deberse a juicios que faltan, no a peores resultados.

Buscar por significado con embeddings

Último cambio en la edición 2026.11.10

La recuperación léxica falla cuando las palabras del comprador y las del producto no coinciden, o cuando las palabras compartidas significan cosas distintas, como ocurre con los ganchos que BM25 ordena para clear shower curtain. La recuperación semántica compara los significados de la consulta y del producto en lugar de sus palabras. Se apoya en los embeddings. Un embedding es una lista de números, un vector, que una red neuronal calcula para un fragmento de texto. La red se entrena para que los textos con significados parecidos reciban vectores que apuntan en direcciones parecidas. Tú calculas el embedding de cada producto una sola vez, de antemano. En el momento de buscar, calculas el embedding de la consulta y devuelves los productos cuyos vectores están más cerca de él. Si todos los vectores se escalan a longitud 1, la cercanía es el producto escalar de dos vectores, que equivale al coseno del ángulo que forman.

Calcular los embeddings de los productos de antemano es lo que hace esto rápido. En el artículo que presentó Sentence-BERT, encontrar el par más parecido entre 10,000 oraciones tardó unas 65 horas en una GPU V100 cuando BERT leía cada par. Calcular el embedding de cada oración una vez y comparar los embeddings tardó unos 5 segundos, casi todos ellos dedicados a calcular los embeddings: la comparación en sí tardó unos 0.01 segundos (Reimers and Gurevych, 2019).

Los embeddings de la tienda provienen del modelo abierto Snowflake/snowflake-arctic-embed-m-v1.5. Los ejemplos nunca llaman a un modelo, de modo que cada ejemplo se ejecuta sin conexión y da siempre la misma salida. En su lugar, una grabación, aquí el script recordings/embeddings.py, ejecuta el modelo una vez y guarda sus vectores, y los ejemplos los leen sin conexión a través de lib.recorded. Elegimos este modelo porque es abierto y tiene licencia Apache 2.0, de modo que cualquiera puede descargar la versión fijada y volver a ejecutar la grabación. La grabación añade a cada consulta la instrucción que pide la ficha del modelo ("Represent this sentence for searching relevant passages:") y calcula los embeddings de los productos tal como están (ficha del modelo). La recuperación semántica del libro, construida como lib.semantic.SemanticSearch, multiplica cada vector de producto por el vector de la consulta y ordena los resultados. El capítulo 6 la construye paso a paso.

Cada producto es un vector de 768 números, y la recuperación semántica compara el vector de la consulta con cada uno; estos son los diez más cercanos, con sus juicios:

Para esta consulta, la recuperación semántica funciona mejor que BM25. Su top 10 contiene 5 productos exactos, frente a los 4 de BM25, y 0 irrelevantes. Su nDCG@10 es 0.793, frente a el 0.615 de BM25. Observa lo cercanas que están las similitudes: el primero y el décimo se diferencian en 0.035. La recuperación semántica siempre devuelve algo, ordenado por diferencias pequeñas.

Una sola consulta puede engañar, así que compara los dos rankers en cada consulta de prueba:

compare-lexical-semantic.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Scores BM25 and semantic retrieval on every test query and counts the queries each one is better on. The prose's point that the test set is too small to show a pattern rests on the `better` and `size in inches` lines."""from lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("test"), qrels("test")bm25 = evaluate(LexicalSearch(products).run(queries, k=100), judgments)semantic = evaluate(SemanticSearch().run(queries, k=100), judgments)for name, scores in [("bm25", bm25), ("semantic", semantic)]:    print(f"{name} ndcg@10: {scores['ndcg@10'].mean():.3f}")    print(f"{name} judged@10: {scores['judged@10'].mean():.3f}")# per test query, rounded to three decimals: queries that differ only beyond the third place count as tieddifference = (semantic["ndcg@10"] - bm25["ndcg@10"]).round(3)print("semantic better:", (difference > 0).sum())print("bm25 better:", (difference < 0).sum())print("tied:", (difference == 0).sum())sized = queries["query"].str.contains(r"\d+\s*(?:inch|in\b|\"|'')")             # a size in inchesprint("test queries with a size in inches:", sized.sum())print("of those, bm25 better:", (difference[sized] < 0).sum())print()print("queries where bm25 is better:")print(queries.loc[difference[difference < 0].index, "query"].to_string())
Salidapython compare-lexical-semantic.py
bm25 ndcg@10: 0.725
bm25 judged@10: 0.927
semantic ndcg@10: 0.830
semantic judged@10: 0.990
semantic better: 21
bm25 better: 7
tied: 2
test queries with a size in inches: 2
of those, bm25 better: 2

queries where bm25 is better:
query_id
63                                     monthly calendar
72                                   fold in half table
94             kohler whitehaven farmhouse kitchen sink
285    48" sliding single track , barn door for laundry
292                             decorative white pillow
293                            wood floor protector mat
482                                48 inch kitchen hood

Promediando las consultas de prueba, la recuperación semántica va por delante: un nDCG@10 de 0.830 frente al 0.725 de BM25. Su judged@10, 0.990, también es mayor que el 0.927 de BM25, de modo que parte del déficit de BM25 podría deberse a productos que nadie juzgó. Para outdoor light fixtures, al menos, esos productos son bombillas, y una puntuación de 0 es justa.

La recuperación semántica es mejor en 21 consultas, BM25 en 7, y 2 están empatadas. La tienda tiene solo 30 consultas de prueba, así que el capítulo 3 comprueba si una diferencia como esta es mayor que el azar.

BM25 es mejor en 2 de las 2 consultas de prueba que indican un tamaño en pulgadas. Los tokens exactos, como tamaños y números de modelo, pueden favorecer la coincidencia de palabras, pero un recuento tan pequeño no puede mostrar un patrón. En las consultas de entrenamiento que contienen un dígito, BM25 es mejor en 1 de 5 (Encuentra las consultas que gana cada recuperador), y el modelo de embeddings también hace coincidir los dígitos, como texto (Revisa las consultas que contienen dígitos).

Un resultado teórico muestra dónde se quedan cortos los vectores únicos. Weller et al. demuestran que la dimensión de un embedding limita qué combinaciones de resultados principales puede devolver un solo vector. En LIMIT, un conjunto de datos que construyeron para probar ese límite, BM25 encuentra el 93.6 % de los elementos relevantes en sus primeros 100, y el mejor modelo de vector único, el 18.9 %. En una variante de LIMIT con las palabras sustituidas por sinónimos, la puntuación de BM25 cae más de un 89 % (Weller et al., 2025). La recuperación léxica y la semántica fallan en lugares distintos.

Regla práctica: añade la recuperación semántica cuando los compradores describan lo que quieren con sus propias palabras. No des por hecho que la recuperación léxica gana en términos exactos como tamaños, marcas y números de modelo: antes de confiar en ella allí, cuenta qué recuperador gana en las consultas de entrenamiento que los contienen. Con estos datos, la recuperación semántica por sí sola obtiene hasta ahora la puntuación más alta, así que es el ranker que hay que superar.

Fusiona dos rankings con fusión recíproca de rangos

Último cambio en la edición 2026.11.10

Como la recuperación léxica y la semántica fallan en lugares distintos, la recuperación híbrida combina un ranking de cada una, aquí el de BM25 y el de la recuperación semántica, con la esperanza de conservar las fortalezas de ambas. Sus puntuaciones no pueden sumarse directamente, porque están en escalas distintas (el capítulo 7 muestra por qué). La fusión recíproca de rangos (RRF, por sus siglas en inglés) evita el problema usando solo los rangos. Cada producto obtiene, por cada ranking que lo contiene, 1 dividido entre la suma de una constante y su rango, y las puntuaciones se suman:

RRF(product) = sum over rankings r of  1 / (k + rank of product in r),   with k = 60

La constante k aplana la parte superior: con k = 60, el rango 1 obtiene 1/61 y el rango 10 obtiene 1/70. Así, un producto cercano a la cima de ambos rankings supera a uno que está en la cima de solo uno. Los autores fijaron k = 60 en un estudio piloto y encontraron que «la elección no era crítica» (Cormack et al., 2009). Fusionaron dos tipos de ejecuciones: envíos a TREC, las evaluaciones compartidas de la Text REtrieval Conference, y 30 configuraciones de un mismo sistema de búsqueda. En esos experimentos, RRF superó a la mejor ejecución individual, en promedio, entre un 4 % y un 5 % en la precisión media promedio (MAP, por sus siglas en inglés), que promedia, sobre las consultas, la precisión en la posición de cada resultado relevante. Ese es un escenario distinto al de fusionar un ranking léxico y uno semántico, y un estudio posterior sobre búsqueda híbrida encontró que una suma ponderada y ajustada de puntuaciones normalizadas supera a RRF (Bruch et al., 2023). El capítulo 7 ajusta ambas sobre consultas de entrenamiento. Aquí, RRF se ejecuta sin ajuste.

RRF es lo bastante corto como para escribirlo a mano, como dos funciones: rrf_scores puntúa los productos de una consulta, y reciprocal_rank_fusion los ordena para cada consulta, colocando los productos con puntuaciones iguales en orden de product_id, de modo que ningún ranking gane los empates por pasarse primero. El ejemplo hybrid-rrf fusiona los 100 primeros resultados de BM25 y de la recuperación semántica para cada consulta de prueba, comprueba las puntuaciones de los dos productos que clear shower curtain coloca primero, y puntúa la ejecución híbrida.

BM25 puntúa 0.725 y la recuperación semántica 0.830, así que el ranking más débil obtiene un voto igual de importante. ¿Su voto arrastrará hacia abajo la ejecución fusionada, o los dos se cubrirán lo bastante bien sus fallos como para superar a la recuperación semántica? Elige una de tres respuestas antes de leer el resultado: por encima de la recuperación semántica, entre las dos, o por debajo de BM25.

hybrid-rrf.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Fuses BM25 and semantic retrieval with reciprocal rank fusion, by hand for one query and then for every test query. The prose's point rests on the hybrid's `ndcg@10` line and on the two scores printed for the first product, which agree."""from lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsdef rrf_scores(rankings, k=60):    """Each product scores the sum of 1 / (k + rank) over the rankings that contain it."""    scores = {}    for ranking in rankings:        for rank, product_id in enumerate(ranking, start=1):            scores[product_id] = scores.get(product_id, 0) + 1 / (k + rank)    return scoresdef reciprocal_rank_fusion(runs, k=60, depth=100):    """For each query, products in order of their RRF scores, best first; equal scores by product_id."""    fused = {}    for query_id in runs[0]:        scores = rrf_scores([run[query_id] for run in runs], k)        # equal scores fall back to product_id, so neither ranking wins ties by being passed first        fused[query_id] = sorted(scores, key=lambda product_id: (-scores[product_id], product_id))[:depth]    return fusedproducts, queries, judgments = load_products(), load_queries("test"), qrels("test")bm25, semantic = LexicalSearch(products).run(queries, k=100), SemanticSearch().run(queries, k=100)hybrid = reciprocal_rank_fusion([bm25, semantic])for place, product_id in zip(["first", "second"], hybrid[246]):       # query 246, "clear shower curtain"    # list.index counts from 0, and a rank counts from 1    bm25_rank, semantic_rank = bm25[246].index(product_id) + 1, semantic[246].index(product_id) + 1    print(f"{place} product: {products.at[product_id, 'name']}")    print(f"{place} product's bm25 rank: {bm25_rank}")    print(f"{place} product's semantic rank: {semantic_rank}")    # the formula with the two ranks in it, where k = 60    print(f"{place} product's score by hand: {1 / (60 + bm25_rank) + 1 / (60 + semantic_rank):.5f}")    print(f"{place} product's score from rrf_scores: {rrf_scores([bm25[246], semantic[246]])[product_id]:.5f}")hybrid_scores, semantic_scores = evaluate(hybrid, judgments), evaluate(semantic, judgments)print(f"hybrid ndcg@10: {hybrid_scores['ndcg@10'].mean():.3f}")print(f"hybrid judged@10: {hybrid_scores['judged@10'].mean():.3f}")difference = (hybrid_scores["ndcg@10"] - semantic_scores["ndcg@10"]).round(3)print("better than semantic:", (difference > 0).sum())print("worse than semantic:", (difference < 0).sum())print("tied with semantic:", (difference == 0).sum())
Salidapython hybrid-rrf.py
first product: woolley vinyl solid color single shower curtain
first product's bm25 rank: 3
first product's semantic rank: 1
first product's score by hand: 0.03227
first product's score from rrf_scores: 0.03227
second product: woolley vinyl single shower curtain
second product's bm25 rank: 2
second product's semantic rank: 2
second product's score by hand: 0.03226
second product's score from rrf_scores: 0.03226
hybrid ndcg@10: 0.812
hybrid judged@10: 0.980
better than semantic: 9
worse than semantic: 14
tied with semantic: 7

El primer producto fusionado, woolley vinyl solid color single shower curtain, está en el rango 3 del ranking de BM25 y en el rango 1 del de la recuperación semántica. Su puntuación suma un término de cada ranking, 1/(60 + 3) + 1/(60 + 1), que a mano da 0.03227, el mismo valor que devuelve rrf_scores.

El segundo, woolley vinyl single shower curtain, está en el rango 2 del ranking de BM25 y en el rango 2 del de la recuperación semántica, y obtiene 0.03226, así que queda segundo.

La ejecución híbrida obtiene 0.812: por encima de BM25, y por debajo de la recuperación semántica por sí sola. Consulta por consulta, supera a la recuperación semántica en 9 consultas, pierde en 14 y empata en 7. Su judged@10 es 0.980.

Así, aquí la fusión no mejoró la recuperación semántica, lo que no es lo mismo que empeorar la búsqueda. Por qué no ayudó es una cuestión del capítulo 7, que comprueba cada recuperador antes de fusionar y ajusta la mezcla sobre consultas de entrenamiento.

Si elegiste por encima de la recuperación semántica, la lección es que combinar dos rankings no garantiza una mejora. La fusión es un cambio como cualquier otro, y hay que medirla.

Regla práctica: Mide cada recuperador por separado antes de fusionarlos. Usa RRF con k = 60 como valor por defecto sin ajustar, y conserva el ranking fusionado solo si supera al mejor recuperador individual en consultas reservadas. Cuando un recuperador es mucho más débil, prueba a ponderar los rankings o a ajustar k sobre consultas de entrenamiento, en lugar de aceptar votos iguales. El capítulo 7 prueba ambas cosas con los datos de la tienda, y ninguna de las mezclas ajustadas que informa supera a la recuperación semántica en las consultas de prueba (Informa de las mezclas ajustadas en consultas de prueba).

Reordenar los 50 primeros con un codificador cruzado

Último cambio en la edición 2026.11.10

Todas las etapas anteriores han sido recuperación, que debe puntuar cada producto del catálogo para cada consulta y por eso tiene que ser barata. El reordenamiento (reranking) reordena una lista corta procedente de la recuperación con un modelo más lento, uno que puede permitirse observar la consulta y cada producto juntos porque solo ve unas pocas decenas de productos.

Un tipo de modelo de reordenamiento es el codificador cruzado (cross-encoder), que lee la consulta y el texto del producto juntos, como una única entrada, y emite una puntuación de relevancia para el par, puntuando cada par de forma independiente (Nogueira y Cho, 2019). Un modelo de embeddings lee el producto por separado, así que sus vectores pueden calcularse de antemano. Un codificador cruzado necesita la consulta, así que no puede calcular nada de antemano, y ejecutarlo sobre cada par cuesta tiempo: el lado lento de la comparación con Sentence-BERT fue BERT leyendo cada par de oraciones como codificador cruzado. Por eso un codificador cruzado reordena una lista corta que recupera una primera etapa más barata (Nogueira y Cho, sección 2; Retrieve & Re-Rank). A cambio de ese coste, puede relacionar cada palabra de la consulta con cada palabra del producto mediante la atención, la parte del modelo que permite que cada palabra se apoye en las demás de su entrada. Reimers y Gurevych (2019, sección 4.3) señalan que BERT puede usar la atención para comparar directamente las dos oraciones. En 2019, en el benchmark de pasajes MS MARCO, reordenar los 1,000 primeros pasajes de BM25 de esta manera mejoró MRR@10, una medida de lo alto que aparece el primer pasaje relevante, un 27 % en términos relativos respecto al mejor resultado anterior (Nogueira y Cho).

Un codificador cruzado es un modelo de lenguaje, pero no un modelo de lenguaje grande (LLM). Un LLM es un modelo entrenado con grandes cantidades de texto para generar texto en respuesta a una instrucción. Los capítulos posteriores usan LLM para juzgar, reescribir y reordenar. Un codificador cruzado no genera nada: emite un número.

El codificador cruzado de la tienda es el modelo abierto Alibaba-NLP/gte-reranker-modernbert-base, elegido por la misma razón que el modelo de embeddings: es abierto y tiene licencia Apache 2.0, así que cualquiera puede volver a ejecutar la grabación. Su grabación, recordings/cross_encoder.py, guarda las puntuaciones del modelo una sola vez, para cada producto de la unión de los 100 primeros de BM25 y de la recuperación semántica para cada consulta, de modo que cada producto de los 50 primeros del híbrido tiene una puntuación. El paso de reordenamiento reordena los 50 primeros de la ejecución híbrida, BM25 y recuperación semántica fusionados con RRF, según esas puntuaciones, deja el resto en su lugar y evalúa el resultado, que el libro llama híbrido reordenado:

cross-encoder-rerank.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Reorders the top 50 of the hybrid run by cross-encoder score, keeps the rest in place, and scores the result. The prose's point rests on the reranked nDCG@10 line, set beside the hybrid's score, and on the better and worse counts."""from lib.fusion import reciprocal_rank_fusionfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.recorded import cross_encoder_scores, manifestfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("test"), qrels("test")bm25 = LexicalSearch(products).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)hybrid = reciprocal_rank_fusion([bm25, semantic])        # the same function as in the hybrid sectionrecorded = cross_encoder_scores()                        # one score per (query, product) pairscore = {(query_id, product_id): value for query_id, product_id, value in recorded.itertuples(index=False)}print("cross-encoder model:", manifest("cross-encoder")["model"])depth = 50                                               # rerank the top 50reranked = {}for query_id, ranking in hybrid.items():    # the top 50 are reordered by score; equal scores keep the hybrid's order    top = sorted(ranking[:depth], key=lambda product_id: score[(query_id, product_id)], reverse=True)    # products below the top 50 keep their hybrid order    reranked[query_id] = top + ranking[depth:]before, after = evaluate(hybrid, judgments), evaluate(reranked, judgments)print(f"reranked ndcg@10: {after['ndcg@10'].mean():.3f}")print(f"reranked judged@10: {after['judged@10'].mean():.3f}")difference = (after["ndcg@10"] - before["ndcg@10"]).round(3)print("better than hybrid:", (difference > 0).sum())print("worse than hybrid:", (difference < 0).sum())
Salidapython cross-encoder-rerank.py
cross-encoder model: Alibaba-NLP/gte-reranker-modernbert-base
reranked ndcg@10: 0.798
reranked judged@10: 0.980
better than hybrid: 11
worse than hybrid: 12

Aquí el reranker no ayuda. Obtiene 0.798 frente a 0.812 de la ejecución híbrida de la que partió. Mejora 11 consultas y empeora 12. En todo el capítulo, sobre las consultas de prueba:

Ranker nDCG@10 judged@10
BM25 0.725 0.927
Semántico 0.830 0.990
Híbrido (RRF, k = 60) 0.812 0.980
Híbrido reordenado (top 50) 0.798 0.980

Una consulta que empeoró, refrigerator with ice an water in door, muestra cómo un reordenador pierde terreno:

rerank-one-query.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Shows the hybrid and reranked top 5 for one query whose nDCG@10 the reranker lowered, with each product's cross-encoder score and judgment. The prose's point rests on the two rank lines and the two nDCG@10 lines."""import refrom lib.fusion import reciprocal_rank_fusionfrom lib.lexical import LexicalSearchfrom lib.metrics import ndcg_at_kfrom lib.recorded import cross_encoder_scoresfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, product_text, qrelsLABELS = {2: "exact", 1: "partial", 0: "irrelevant"}products = load_products()query_id = 406query = load_queries().at[query_id, "query"]judgments = qrels()[query_id]recorded = cross_encoder_scores()score = recorded[recorded["query_id"] == query_id].set_index("product_id")["score"]bm25 = {query_id: list(LexicalSearch(products).search(query, k=100).index)}semantic = {query_id: list(SemanticSearch().search(query_id, k=100).index)}hybrid = reciprocal_rank_fusion([bm25, semantic])[query_id]# the top 50 are reordered by score; the rest stay in the hybrid's orderreranked = sorted(hybrid[:50], key=score.get, reverse=True) + hybrid[50:]print("query:", query)for name, ranking in [("hybrid", hybrid), ("reranked", reranked)]:    first_exact = next(rank for rank, product_id in enumerate(ranking, start=1) if judgments.get(product_id) == 2)    print()    print(f"{name} ndcg@10: {ndcg_at_k(ranking, judgments, 10):.3f}")    print(f"{name} rank of the first exact product: {first_exact}")    for product_id in ranking[:5]:        label = LABELS.get(judgments.get(product_id), "unjudged")        print(f"  {score[product_id]:.2f}  {label:<10}  {products.at[product_id, 'name']}")exact = next(product_id for product_id in hybrid if judgments.get(product_id) == 2)words = set(re.findall(r"\w+", product_text(products).at[exact].lower()))   # name, class, category, descriptionprint()print("hybrid's first exact product:", products.at[exact, "name"])print("its text says ice or water:", "yes" if {"ice", "water"} & words else "no")
Salidapython rerank-one-query.py
query: refrigerator with ice an water in door

hybrid ndcg@10: 0.660
hybrid rank of the first exact product: 3
  1.95  partial     apec water icemaker-kit-38-14-ro refrigerator/icemaker installation accessory
  2.06  partial     36 '' french door 26.1 cu . ft. smart energy star refrigerator with interior ice maker
  1.44  exact       36 '' french door refrigerator 27 cu . ft. energy star refrigerator
  2.19  partial     36 '' energy star counter-depth french door 22.6 cu . ft. refrigerator with ice maker
  2.19  partial     800 series 21 cu . ft. smart energy star counter depth french door refrigerator with internal water dispenser

reranked ndcg@10: 0.533
reranked rank of the first exact product: 9
  2.20  partial     smeg classic 36 '' french door 22 cu . ft. refrigerator with ice maker
  2.19  partial     36 '' energy star counter-depth french door 22.6 cu . ft. refrigerator with ice maker
  2.19  partial     800 series 21 cu . ft. smart energy star counter depth french door refrigerator with internal water dispenser
  2.10  partial     28 '' energy star counter depth top freezer 12.56 cu . ft. refrigerator with auto ice maker
  2.06  partial     36 '' french door 26.1 cu . ft. smart energy star refrigerator with interior ice maker

hybrid's first exact product: 36 '' french door refrigerator 27 cu . ft. energy star refrigerator
its text says ice or water: no

El codificador cruzado entierra el primer producto exacto, pasándolo del puesto 3 al puesto 9, y baja el nDCG@10 de esta consulta de 0.660 a 0.533. Los 5 primeros reordenados son frigoríficos cuyos nombres dicen ice maker o water dispenser, y los jueces los marcaron como parciales: coinciden con lo que se pedía, un frigorífico, pero no con el modificador, hielo y agua en la puerta. El primer producto exacto de la ejecución híbrida, un frigorífico de puertas francesas, recibe la puntuación más baja del codificador cruzado de los 5 primeros del híbrido.

Los jueces marcaron ese frigorífico como exacto, así que según la definición del conjunto de datos coincide plenamente con la consulta. Sin embargo, su texto no dice nada sobre hielo ni agua, de modo que ningún modelo que lea solo el texto podría ordenarlo por ese modificador. Los jueces de WANDS vieron la imagen y la página web de cada producto además de su nombre (directrices de anotación), lo que probablemente les permitió ver lo que el texto no dice. Un reordenador de propósito general nunca ha visto los juicios de esta tienda. El capítulo 9 entrena rankers con los juicios de las consultas de entrenamiento.

Regla práctica: Reordena una lista corta, aquí 50 productos, porque el coste crece con cada par. Adopta un reordenador solo cuando supere a la mejor recuperación por sí sola en consultas reservadas. Este no mejoró la ejecución híbrida ni la recuperación semántica, así que la mejor canalización de la tienda hasta ahora es la recuperación semántica por sí sola. Antes de renunciar al reordenamiento, prueba una profundidad distinta o un ranker entrenado con tus propios juicios. Ni una profundidad distinta ni LambdaMART superan a la recuperación semántica en las consultas de prueba del capítulo 9 (Fija la profundidad de reordenamiento a partir de un presupuesto, Informa de LambdaMART en las consultas de prueba).

Lo que sale mal en producción

Último cambio en la edición 2026.10.7

El tokenizador descarta palabras sin avisar. El tokenizador por defecto de bm25s conserva solo los tokens de dos o más caracteres y no aplica stemming a las palabras (tokenizador de bm25s). Ejecútalo sobre una consulta de entrenamiento y una consulta de prueba, y cuenta los productos que no puede emparejar:

tokenizer-drops-terms.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Tokenizes one train query, one test query and the products' text with bm25s, and counts the products that have `chairs` or only `chair`. The prose's points rest on the printed token lists and on the two product counts."""import bm25sfrom lib.store import load_products, product_textdef tokenize(texts):    """The tokenizer lib.lexical uses for products and queries, with bm25s's default settings."""    # stopwords="en" removes English words such as "and"; no stemmer is set, so "chairs" and "chair" stay different tokens    return bm25s.tokenize(texts, stopwords="en", return_ids=False, show_progress=False)for query in ["ge top loading washer 4.5", "bistro table and chairs"]:    print(f"{query!r} -> {tokenize([query])[0]}")products = tokenize(product_text(load_products()).tolist())print()print("products with the token chairs:", sum("chairs" in tokens for tokens in products))print("products with chair but not chairs:", sum("chair" in tokens and "chairs" not in tokens for tokens in products))
Salidapython tokenizer-drops-terms.py
'ge top loading washer 4.5' -> ['ge', 'top', 'loading', 'washer']
'bistro table and chairs' -> ['bistro', 'table', 'chairs']

products with the token chairs: 895
products with chair but not chairs: 359

El 4.5 de ge top loading washer 4.5 desaparece, porque 4 y 5 tienen un carácter cada uno, así que ese número no influye en el ranking. Y chairs solo coincide con los productos que dicen chairs: 895 sí los tienen, mientras que 359 dicen chair y nunca chairs, y ninguno de ellos puede coincidir con esa palabra de bistro table and chairs. Ninguno de los dos casos produce un error. El capítulo 5 muestra ambos problemas y añade stemming.

Los resultados sin juzgar parecen fallos. Un ranker que muestra productos que nadie juzgó obtiene puntuaciones más bajas de las que quizá merece, y un ranker que muestra los juzgados obtiene una ventaja. Informa de judged@10 junto con cada puntuación, y haz que se juzguen los productos nuevos cuando esa métrica baje.

Es probable que las puntuaciones obtenidas con una muestra sean optimistas. La muestra conserva 12,000 productos, casi todos juzgados para alguna consulta. El catálogo completo de WANDS tiene 42,994 (repositorio), y el catálogo de una tienda puede ser mucho mayor, con más casos cercanos compitiendo por los 10 primeros puestos. Este capítulo no mide eso, pero espera puntuaciones más bajas con un catálogo completo. Tampoco compares las puntuaciones de aquí con las del artículo de WANDS: ese trabajo usó el BM25 de Solr, un servidor de búsqueda, sobre los títulos y las descripciones de los productos (Chen et al.).

Las salidas de un modelo pertenecen a una versión concreta del modelo. Los embeddings de productos y de consultas deben proceder del mismo modelo y de la misma versión, o sus similitudes no son comparables. Si cambias el modelo, tienes que volver a calcular los embeddings de todo el catálogo. Cada carpeta de examples/data/recorded/ contiene un manifest.json que fija el modelo y su versión.

La reordenación tiene un coste en tiempo en cada consulta. Los embeddings de los productos se calculan una sola vez. Un cross-encoder se ejecuta sobre cada par, para cada consulta, mientras el comprador espera. En este capítulo, un script de grabación calcula las puntuaciones de antemano en una GPU, lo que oculta ese coste. El capítulo 9 calcula lo que cuesta cada profundidad de reordenación (Fija la profundidad de reordenación según un presupuesto).

Regla práctica: Revisa los tokens en que se convierten tus consultas, sigue judged@10 y registra la versión del modelo junto a cada vector que almacenes.

Decisiones que tomó este capítulo

Último cambio en la edición 2026.11.8

Estos valores predeterminados se mantienen hasta que un capítulo posterior los pruebe con las consultas de entrenamiento.

  • Informar con prueba, ajustar con entrenamiento. Todas las puntuaciones de este capítulo corresponden a las 30 consultas de prueba. Este capítulo no ajusta nada; los capítulos posteriores solo ajustan con las 50 consultas de entrenamiento.
  • Métrica principal: nDCG@10, con judged@10 al lado. Las calificaciones sirven como ganancias, los productos no evaluados cuentan como calificación 0, y judged@10 muestra cuándo esa suposición tiene peso.
  • Línea base: BM25 con los valores predeterminados de bm25s, k1=1.5 y b=0.75, sobre el nombre, la clase, la categoría y la descripción de cada producto. El ajuste espera hasta que pueda medirse con las consultas de entrenamiento.
  • Recuperación semántica a partir de embeddings grabados de un modelo abierto, comparados mediante producto punto de vectores de longitud unitaria, de modo que cada ejemplo se ejecute sin conexión y dé siempre el mismo resultado. Elegir entre modelos es una cuestión para más adelante.
  • Recuperación híbrida: RRF con k = 60 y pesos iguales, sin ajustar, tal como la usaron sus autores.
  • Profundidad de reordenamiento: los 50 primeros del híbrido, puntuados por un cross-encoder grabado, de modo que cada producto reordenado tenga una puntuación registrada. En una tienda en vivo, la profundidad es tanto una decisión de costo como de calidad.
  • El ranker que hay que superar es la recuperación semántica por sí sola, porque con estos datos ni la fusión ni este reordenador mejoraron sobre ella. El capítulo 3 comprueba si diferencias como estas son mayores que el azar, en un arnés de evaluación.
  • Lo que mostró el capítulo: una etapa que debería ayudar, la fusión o el reordenamiento, no superó a la recuperación semántica con estos datos, así que cada cambio se mide antes de conservarlo.

Este capítulo, en esta edición

Edición 2026.11.10Ejemplos verificados el 19 de nov de 2026Superan la prueba 11 de 11 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 1 de 11: Búsqueda, de principio a fin

  1. Cargar los datos de la tienda
  2. Clasificar productos con BM25
  3. Revisa los resultados frente a los juicios
  4. Puntúa un ranking con nDCG@10
  5. Puntúa todas las consultas de prueba
  6. Buscar por significado con embeddings
  7. Fusiona dos rankings con fusión recíproca de rangos
  8. Reordenar los 50 primeros con un codificador cruzado
  9. Lo que sale mal en producción
  10. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos