Recuperación léxica
Unos 36 minutos de lectura, con 13 ejemplos en 12 secciones.
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
En esta página
- Dividir el texto del producto en términos
- Construir un índice invertido
- Ponderar términos con TF-IDF
- Reconstruye BM25 a mano para que coincida con bm25s
- Reduce términos a su raíz para que coincidan las formas de las palabras
- Comprueba el stemming en las consultas de prueba
- Ajusta los parámetros de BM25 en consultas de entrenamiento
- Pondera el nombre del producto por encima de la descripción
- Indexar los atributos de producto como un campo
- Emparejar frases con posiciones de términos
- Qué sale mal en producción
- Decisiones de este capítulo
Al final de este capítulo podrás construir una búsqueda léxica desde cero: convertir el texto de los productos en términos, indexar los términos y puntuar los productos con TF-IDF y BM25, coincidiendo puntuación por puntuación con la biblioteca bm25s. También podrás decidir qué cambios en el procesamiento del texto y en los parámetros de BM25 merecen conservarse, eligiéndolos con las consultas de entrenamiento y comprobándolos con las consultas de prueba.
La recuperación léxica encuentra y ordena los productos según las palabras que comparten con la consulta. Ordena los resultados cuando un comprador busca en los muebles y artículos para el hogar de the store: BM25, a través de la biblioteca bm25s. Cuando un comprador escribe 7qt slow cooker o pool floats, los resultados del BM25 del capítulo 1 son débiles. Su nDCG@10 medio en las consultas de prueba, 0.725, lo muestra, pero no explica por qué, porque el capítulo 1 lo usó como una caja negra con los valores predeterminados de bm25s. Este capítulo abre esa caja. Reconstruyes a mano cada paso sobre los 12,000 productos de la tienda y lo verificas contra bm25s, y luego cambias un paso a la vez y mides cada cambio frente a los judgments de la tienda.
Cada cambio se elige en las 50 train queries y se comprueba en las 30 consultas de prueba. Antes de leer cualquier resultado de prueba, el capítulo fija sus comparaciones planificadas sobre las consultas de prueba. Son cinco, cada una frente a la misma búsqueda sin el cambio:
- stemming
- los mejores
k1yben el entrenamiento, frente a los valores predeterminados de bm25s (tuning) - el mejor peso en el entrenamiento para el nombre del producto (fields)
- los atributos del producto como campo (attributes)
- la mejor bonificación por frase en el entrenamiento (phrases)
Con cinco comparaciones planificadas, la regla del libro fija el umbral en un valor p de 0.01. Una mejora queda establecida si el permutation test pareado da un valor p inferior a ese umbral. Cada comparación también informa del t-test pareado y de un bootstrap interval del 99 %, e indica si cada uno concuerda con la prueba de permutación.
Dividir el texto del producto en términos
La búsqueda nunca compara cadenas de texto tal cual. La consulta y el texto de cada producto pasan primero por los mismos pasos. Dividir el texto en fragmentos da tokens. Pasar a minúsculas hace que Chair y chair sean un solo token. Eliminar las palabras vacías, palabras muy comunes como the y with, deja los términos que compara la búsqueda, y todos los términos del catálogo forman su vocabulario. Un producto solo puede coincidir con una consulta en los términos que comparten, así que estos pasos deciden qué puede coincidir, antes de que empiece cualquier puntuación.
bm25s, que ejecuta el BM25 de la tienda, toma tres decisiones aquí. Pasa a minúsculas. Conserva cada secuencia de dos o más caracteres de palabra, es decir, letras, dígitos o guiones bajos, con la expresión regular (?u)\b\w\w+\b, que su documentación describe como el método de CountVectorizer de scikit-learn. Y elimina 33 palabras vacías del inglés, entre ellas no, not, with y for. No aplica raíces de palabras a menos que le pases un stemmer (tokenizador de bm25s, palabras vacías). Para ver los pasos uno a uno, escríbelos a mano, comprueba el resultado con bm25s.tokenize en cada producto y pasa por ellos la consulta de entrenamiento 7qt slow cooker:
1"""Splits product text into terms by hand, checks the split against bm25s on every product, then shows what the store's sizes and a negation turn into. The prose's point rests on the line that counts products tokenized differently, and on the lines that count products with the term 7qt and products whose text says 7 qt."""2import re34import bm25s5from bm25s.stopwords import STOPWORDS_EN67from lib.lexical import LexicalSearch8from lib.store import load_products, load_queries, product_text, qrels910# two or more word characters (letters, digits or underscores): a single character, such as the 7 in 7 qt, is no token11TOKEN = re.compile(r"(?u)\b\w\w+\b")12STOPWORDS = set(STOPWORDS_EN) # the 33 English stop words bm25s removes131415def tokenize(text, pattern=TOKEN):16 """Lowercase, split into tokens, and drop stop words."""17 return [token for token in pattern.findall(text.lower()) if token not in STOPWORDS]181920products, queries = load_products(), load_queries()21texts = product_text(products).tolist()22by_hand = [tokenize(text) for text in texts]23# bm25s's own split, with stopwords="en": the same 33 words as STOPWORDS above24with_bm25s = bm25s.tokenize(texts, stopwords="en", return_ids=False, show_progress=False)25print("products tokenized differently:", sum(mine != theirs for mine, theirs in zip(by_hand, with_bm25s)))26print()27query = queries.at[62, "query"] # a train query28print("query 62:", query, "->", tokenize(query))29print("product 1:", products.at[1, "name"], "->", tokenize(products.at[1, "name"]))30print("products with the term 7qt:", sum("7qt" in terms for terms in by_hand))31# a 7 on its own: the lookbehind skips 27 qt and 3.7 qt, which are other sizes32print("products whose text says 7 qt:", sum(re.search(r"(?<![\d.])7 qt\b", text.lower()) is not None for text in texts))33grades = qrels("train")[62]34print("exact products judged for query 62:", sum(grade == 2 for grade in grades.values()))35top_10 = LexicalSearch(products).search(query, k=10).index # chapter 1's BM2536print("exact products in bm25's top 10:", sum(grades.get(product_id) == 2 for product_id in top_10))37digits_apart = re.compile(r"(?u)\d+|[^\W\d_]+") # keeps single digits; 7qt -> 7, qt38changed = queries["query"].map(lambda text: tokenize(text) != tokenize(text, digits_apart))39for split in ["train", "test"]:40 print(f"{split} queries whose terms change with digits apart:", changed[queries["split"] == split].sum())41print()42print("probe:", "rug not wool", "->", tokenize("rug not wool")) # written for this chapter43# whole words, so note and nothing don't count44print("queries with not or no:", queries["query"].str.contains(r"\b(?:not|no)\b").sum())
python tokenize-product-text.pyproducts tokenized differently: 0
query 62: 7qt slow cooker -> ['7qt', 'slow', 'cooker']
product 1: all-clad 7 qt . slow cooker -> ['all', 'clad', 'qt', 'slow', 'cooker']
products with the term 7qt: 0
products whose text says 7 qt: 8
exact products judged for query 62: 9
exact products in bm25's top 10: 1
train queries whose terms change with digits apart: 4
test queries whose terms change with digits apart: 0
probe: rug not wool -> ['rug', 'wool']
queries with not or no: 0
El número de productos que el tokenizador escrito a mano y bm25s dividen de forma distinta es 0, así que el problema no está en ninguno de los dos, sino en las reglas que comparten. Una persona que escribe 7qt slow cooker quiere una olla de cocción lenta de 7 cuartos, y 7qt sí sobrevive como un token. Pero coincide con 0 productos, porque el texto del producto escribe el tamaño separado, como 7 qt en 8 productos, y el tokenizador descarta el 7 de un carácter. Así que el tamaño no influye en el ranking, en ninguno de los dos lados de la coincidencia, y BM25 no puede distinguir una olla de 7 cuartos de cualquier otra olla de cocción lenta. De los 9 productos que los jueces marcaron como exactos para esta consulta, los 10 primeros de BM25 incluyen 1.
Un patrón que conserva los dígitos sueltos y separa los números de sus unidades, (?u)\d+|[^\W\d_]+, cambia los términos de 4 consultas de entrenamiento y 0 consultas de prueba, así que los juicios de la tienda dicen poco sobre él.
La lista de palabras vacías falla de la misma manera, y bm25s no lanza ningún error. Considera rug not wool, una consulta de prueba de sondeo: una escrita para este capítulo para probar un comportamiento, no una de las consultas de la tienda. Se convierte en rug wool, así que una alfombra de lana coincide con sus dos términos. Los juicios solo pueden medir este daño en consultas con una negación, y 0 de las consultas de la tienda contienen not o no. Los sistemas de búsqueda han pasado de listas largas de palabras vacías a listas cortas o a ninguna, en parte porque en algunas consultas las palabras vacías aportan significado, y en parte porque conservarlas se ha vuelto barato (Manning et al., 2008).
Regla práctica: Imprime los términos en que se convierten tus consultas y tus productos antes de ajustar cualquier puntuación, y pasa ambos por el mismo tokenizador. Parte de los valores predeterminados de bm25s, como hace la tienda. Cuando las personas escriban tallas, cantidades o números de modelo, usa un patrón de tokens que conserve los dígitos sueltos y separe un número de su unidad, como el de arriba. Cuando escriban negaciones, desactiva la lista de palabras vacías. Cada uno de estos cambios modifica la búsqueda, así que mídelo en las consultas de entrenamiento y compruébalo en las consultas de prueba antes de conservarlo.
Construir un índice invertido
Para puntuar una consulta formada por esos términos, la búsqueda necesita los productos que contienen cada uno de ellos. Leer el texto de cada producto para cada consulta funciona con una muestra pequeña, pero no con un catálogo de millones. Un índice invertido da la vuelta a los textos: para cada término, guarda la lista de productos que contienen el término, llamada los postings del término (Manning et al., 2008). Junto con cada producto, los postings guardan la frecuencia del término, es decir, el número de veces que el término aparece en el texto de ese producto. El número de productos en los postings de un término es su frecuencia de documento: los motores de búsqueda llaman documentos a los elementos que buscan, y en este libro son productos. Una consulta solo lee los postings de sus propios términos.
El índice de la tienda asocia cada término con un diccionario de IDs de producto y frecuencias de término. También guarda la longitud de cada producto en términos, que necesita BM25. Construirlo requiere una sola pasada sobre el texto de cada producto, con el tokenizador de la sección anterior. Después, el código busca los términos de la consulta de prueba 7qt slow cooker:
1"""Builds the store's inverted index by hand from each product's tokenized text, then looks up a train query's terms in it. The prose's point rests on the lines that count products with every query term and with any query term, and on the line for the product code."""2from collections import Counter34from lib.lexical_by_hand import tokenize5from lib.store import load_products, load_queries, product_text67postings = {} # {term: {product_id: how many times the term occurs in that product}}8lengths = {} # {product_id: number of terms}9for product_id, text in product_text(load_products()).items():10 terms = tokenize(text)11 lengths[product_id] = len(terms)12 for term, count in Counter(terms).items():13 postings.setdefault(term, {})[product_id] = count1415print(f"vocabulary: {len(postings):,} terms")16print(f"average product length: {sum(lengths.values()) / len(lengths):.1f} terms")17# (product ID, term frequency) pairs, starting from product 118print("postings for cooker, first 3:", list(postings["cooker"].items())[:3])19print()20query = load_queries().at[62, "query"]21for term in tokenize(query):22 print(f"products with {term}:", len(postings.get(term, {})))23found = [set(postings.get(term, {})) for term in tokenize(query)]24print("products with any query term:", len(set.union(*found)))25print("products with every query term:", len(set.intersection(*found)))26print("products with w003096809:", len(postings.get("w003096809", {}))) # the code in query 205
python inverted-index-by-hand.pyvocabulary: 20,393 terms
average product length: 50.3 terms
postings for cooker, first 3: [(1, 3), (2, 2), (115, 1)]
products with 7qt: 0
products with slow: 157
products with cooker: 141
products with any query term: 158
products with every query term: 0
products with w003096809: 0
Los 12,000 productos de la tienda usan 20,393 terms, y el texto de un producto promedia 50.3 terms. Cada par en los postings de cooker es un ID de producto y una frecuencia de término. El primero es el producto 1, la olla de cocción lenta de 7 qt de la sección del tokenizador.
Para 7qt slow cooker, los postings enumeran 157 productos para slow, 141 para cooker y 0 para 7qt, y juntos cubren 158 productos. Esos son todos los que puntuar esta consulta tiene que leer. Los productos que contienen los tres términos suman 0, porque ninguno tiene 7qt. Por eso, una consulta booleana AND, que devuelve solo los productos que contienen todos los términos de la consulta, no devuelve nada para esta consulta. Una búsqueda que puntúa cada producto que contiene alguno de los términos, como hace BM25, sigue devolviendo ollas de cocción lenta, y deja que las puntuaciones decidan cuáles aparecen primero.
Regla práctica: Cuando los resultados de una consulta parezcan incorrectos, busca sus términos en el índice antes de cambiar la puntuación. Un término sin postings, como 7qt, no puede ayudar a ningún producto, sea cual sea el puntuador, así que corrige el tokenizador o la consulta. Para las consultas que escriben los compradores, haz coincidir los productos que contienen cualquiera de los términos en lugar de todos, porque una sola palabra sin coincidencia vaciaría los resultados. Sirve las búsquedas desde el índice de una biblioteca, y conserva uno pequeño como este para comprobar qué coincide con un término.
Ponderar términos con TF-IDF
No todas las coincidencias valen lo mismo. Dos ideas las ponderan. Un término que aparece con frecuencia en el texto de un producto tiene más probabilidades de ser aquello de lo que trata el producto: esa es su frecuencia de término, tf. Y una coincidencia en un término raro dice más que una coincidencia en uno común. Karen Spärck Jones propuso ponderar los términos según cuántos documentos los contienen, de modo que "las coincidencias en términos menos frecuentes, más específicos, tienen un valor mayor que las coincidencias en términos frecuentes" (Spärck Jones, 1972; copia reimpresa gratuita). Ese peso se convirtió en la frecuencia inversa de documento, IDF: el logaritmo del número de productos dividido por la frecuencia documental del término, alto para un término raro y bajo para uno común (Manning et al., 2008). TF-IDF multiplica tf e IDF para cada término de la consulta y suma los resultados (Manning et al., 2008):
idf(t) = ln(N / df(t)) N products, df(t) of them contain t
tf-idf(q, d) = sum over query terms t of tf(t, d) × idf(t)
furniture es un término común en los productos de la tienda. TF-IDF se basa en el índice invertido. El código muestra el IDF de furniture y de cada término de la consulta de entrenamiento laundry basket with wheels, y después el top 3 de TF-IDF para esa consulta, con la puntuación y las frecuencias de término de cada producto. Por último, puntúa las 50 consultas de entrenamiento con TF-IDF y con BM25 tal como lo ejecuta el capítulo 1:
1"""Computes TF-IDF over the inverted index, shows the IDF of each term of one train query and TF-IDF's top 3 for it, then scores every train query with TF-IDF and with BM25. The prose's point rests on the train nDCG@10 and judged@10 lines, and on the line that counts the queries where BM25 scores higher or lower."""2import math34import pandas as pd56from lib.lexical import LexicalSearch7from lib.lexical_by_hand import InvertedIndex, tokenize8from lib.metrics import evaluate9from lib.store import load_products, load_queries, product_text, qrels1011products, train, judgments = load_products(), load_queries("train"), qrels("train")12index = InvertedIndex(product_text(products))13n = len(index.lengths) # every product, the N in the IDF formula141516def tf_idf(query):17 """TF-IDF scores of the products that contain a query term, best first."""18 scores = {}19 for term in tokenize(query):20 postings = index.postings.get(term, {})21 # a term no product contains has no postings, so it adds nothing to any score22 idf = math.log(n / len(postings)) if postings else 0.023 for product_id, tf in postings.items():24 scores[product_id] = scores.get(product_id, 0.0) + tf * idf25 # stable: tied products keep the order in which they were first scored26 return pd.Series(scores, dtype=float).sort_values(ascending=False, kind="stable")272829# train query 36, by its ID; judgments grade 2, 1 and 0 as exact, partial and irrelevant30query, labels = train.at[36, "query"], {2: "exact", 1: "partial", 0: "irrelevant"}31for term in ["furniture"] + tokenize(query):32 print(f"idf of {term}: {math.log(n / len(index.postings[term])):.3f}")33print(f"\ntf-idf top 3 for {query!r}:")34for rank, (product_id, score) in enumerate(tf_idf(query).head(3).items(), start=1):35 counts = ", ".join(f"{term} {index.postings[term].get(product_id, 0)}" for term in tokenize(query))36 print(f" {rank} {score:4.1f} {labels[judgments[36][product_id]]:<8} {counts:<29} {products.at[product_id, 'name'][:22]}")37print()38# the top 100 of each scorer on every train query; bm25 is chapter 1's, from lib.lexical39runs = {"tf-idf": {query_id: list(tf_idf(text).index[:100]) for query_id, text in train["query"].items()},40 "bm25": LexicalSearch(products).run(train)}41results = {name: evaluate(run, judgments) for name, run in runs.items()} # one row per train query42for name, frame in results.items():43 print(f"{name} train ndcg@10: {frame['ndcg@10'].mean():.3f}")44 print(f"{name} train judged@10: {frame['judged@10'].mean():.3f}")45# rounded to three decimals, so a difference too small to show counts as a tie46change = (results["bm25"]["ndcg@10"] - results["tf-idf"]["ndcg@10"]).round(3)47print(f"train queries where bm25 scores higher, lower: {(change > 0).sum()}, {(change < 0).sum()}")
python tf-idf-by-hand.pyidf of furniture: 0.919
idf of laundry: 3.985
idf of basket: 3.925
idf of wheels: 4.839
tf-idf top 3 for 'laundry basket with wheels':
1 51.3 partial laundry 4, basket 9, wheels 0 dirty clothes basket ,
2 45.4 exact laundry 6, basket 3, wheels 2 laundry sorter basket
3 39.7 partial laundry 7, basket 3, wheels 0 weave laundry basket
tf-idf train ndcg@10: 0.579
tf-idf train judged@10: 0.836
bm25 train ndcg@10: 0.695
bm25 train judged@10: 0.930
train queries where bm25 scores higher, lower: 36, 10
El primer producto de TF-IDF es parcial, una cesta que nunca dice wheels pero repite basket más que cualquiera de los dos productos que aparecen debajo. Los IDF preparan ese resultado. furniture obtiene 0.919, y los términos de la consulta obtienen 3.985 para laundry, 3.925 para basket y 4.839 para wheels: más raros y cercanos entre sí. Con IDF tan parecidos, las repeticiones superan la ausencia de wheels, como muestran las puntuaciones. El producto exacto, el único de los tres que dice wheels, queda en segundo lugar. En TF-IDF la frecuencia de término no tiene techo, así que un producto puede superar a otro por repetir una palabra.
En las consultas de entrenamiento, TF-IDF promedia un nDCG@10 de 0.579 frente al 0.695 de BM25, y BM25 puntúa más alto y más bajo en 36, 10 consultas, respectivamente. El judged@10 de TF-IDF es 0.836 frente al 0.930 de BM25; cuando el judged@10 de una ejecución es menor, parte de su diferencia puede deberse a productos que nadie evaluó y no a productos peores. Esta comparación en las consultas de entrenamiento te indica en qué puntuador conviene basarse, y el libro reserva su evidencia para las consultas de prueba.
Regla práctica: Pondera los términos por IDF en cualquier puntuador léxico, porque una coincidencia en un término raro es mejor evidencia. No ordenes productos con TF-IDF sin procesar: limita cuánto puede aportar un término repetido y corrige los textos largos, que es lo que hace BM25. Conserva TF-IDF para explicar un ranking, donde puedes leer directamente el tf y el idf de cada término.
Reconstruye BM25 a mano para que coincida con bm25s
BM25 conserva el IDF y cambia la forma en que se cuenta la frecuencia de un término, de dos maneras. Con saturación, cada repetición de un término suma menos que la anterior, y ningún número de repeticiones puede empujar la contribución del término más allá de un techo (Robertson y Zaragoza, 2009). El parámetro k1 fija la rapidez con que el término se acerca a ese techo. Con normalización por longitud, un texto largo, que tiene más oportunidades de contener cualquier término, recibe frecuencias de término descontadas. El parámetro b fija cuánto: "b = 1 realizará una normalización completa por la longitud del documento, mientras que b = 0 desactivará la normalización" (Robertson y Zaragoza). En la forma que bm25s calcula por defecto (puntuación de bm25s):
idf(t) = ln(1 + (N − df(t) + 0.5) / (df(t) + 0.5))
bm25(q, d) = sum over query terms t of
idf(t) × tf(t, d) / (tf(t, d) + k1 × (1 − b + b × length(d) / average length))
Dos detalles difieren entre los libros de texto y las bibliotecas. Una variante común multiplica la fracción por k1 + 1, lo que aumenta todas las puntuaciones en el mismo factor y por tanto deja el ranking sin cambios (Robertson y Zaragoza, sección 3.5.1). Y el IDF original de Robertson, sin el 1 dentro del logaritmo, es negativo para un término presente en más de la mitad de los documentos, por lo que Lucene, una biblioteca de búsqueda de código abierto, añade el 1 (Kamphuis et al., 2020). El valor por defecto de bm25s, method="lucene", es la fórmula de Lucene calculada con longitudes exactas de documento (README de bm25s), mientras que Lucene mismo las aproxima (Kamphuis et al.). "BM25" nombra una familia de variantes de este tipo, y un estudio de ocho de ellas no encontró diferencias significativas en efectividad sobre tres colecciones de noticias (Kamphuis et al.).
Escribe la fórmula sobre el índice invertido de la tienda con los valores por defecto de bm25s, k1=1.5 y b=0.75, y compárala con bm25s 0.3.16: primero la puntuación de cada producto para cada una de las 80 consultas, y después los dos rankings, por sus 100 primeros y por nDCG@10:
1"""Writes BM25 by hand over the inverted index at bm25s's defaults, and checks every score and every ranking against bm25s. The prose's point rests on the IDF lines for the word your, the largest score difference, the same-top-100 line and the test nDCG@10 lines."""2import math34import pandas as pd56from lib.lexical import LexicalSearch7from lib.lexical_by_hand import InvertedIndex, tokenize8from lib.metrics import evaluate9from lib.store import load_products, load_queries, product_text, qrels1011products, queries = load_products(), load_queries()12index, library = InvertedIndex(product_text(products)), LexicalSearch(products) # by hand, and bm25s as chapter 1 uses it13# k1 and b at bm25s's defaults14n, k1, b = len(index.lengths), 1.5, 0.75151617def bm25(query):18 scores = {}19 for term in tokenize(query):20 df = len(index.postings.get(term, {}))21 # Lucene's IDF: the 1 in the logarithm keeps it positive, even for a term in most products22 idf = math.log(1 + (n - df + 0.5) / (df + 0.5))23 for product_id, tf in index.postings.get(term, {}).items():24 # length normalization: a product of average length gets a factor of 125 length = 1 - b + b * index.lengths[product_id] / index.average_length26 scores[product_id] = scores.get(product_id, 0.0) + idf * tf / (tf + k1 * length)27 return pd.Series(scores, dtype=float)282930df = len(index.postings["your"])31print(f"products with your: {df:,}")32# Robertson's IDF has no 1 in the logarithm, so it goes negative for a term in over half the products33print(f"robertson idf of your: {math.log((n - df + 0.5) / (df + 0.5)):.3f}")34print(f"lucene idf of your: {math.log(1 + (n - df + 0.5) / (df + 0.5)):.3f}")35for tf in [1, 2, 4, 9]: # one term, in a product of average length36 print(f"term weight at tf {tf}: {tf / (tf + k1):.3f}")37# products that share no term with a query score 0, as bm25s gives them38gaps = [(bm25(query).reindex(products.index, fill_value=0) - library.retriever.get_scores(tokenize(query))).abs().max()39 for query in queries["query"]]40print(f"\nlargest score difference from bm25s: {max(gaps):.0e}")41print("bm25s score type:", library.retriever.get_scores(["chair"]).dtype)42ranked = {query_id: list(bm25(query).sort_index().sort_values(ascending=False, kind="stable").index[:100])43 for query_id, query in queries["query"].items()} # equal scores in product_id order44library_ranked = library.run(queries) # lib.lexical also orders equal scores by product_id45print("same top 100 for every query:", "yes" if ranked == library_ranked else "no")46for split in ["train", "test"]:47 for name, run in [("by hand", ranked), ("with bm25s", library_ranked)]:48 print(f"{split} ndcg@10 {name}: {evaluate(run, qrels(split))['ndcg@10'].mean():.3f}")
python bm25-by-hand.pyproducts with your: 6,135
robertson idf of your: -0.045
lucene idf of your: 0.671
term weight at tf 1: 0.400
term weight at tf 2: 0.571
term weight at tf 4: 0.727
term weight at tf 9: 0.857
largest score difference from bm25s: 1e-06
bm25s score type: float32
same top 100 for every query: yes
train ndcg@10 by hand: 0.695
train ndcg@10 with bm25s: 0.695
test ndcg@10 by hand: 0.725
test ndcg@10 with bm25s: 0.725
La palabra your aparece en 6,135 de los 12,000 productos. El IDF original de Robertson le asigna -0.045, y el de Lucene le asigna 0.671. Un IDF negativo haría que una coincidencia con una palabra redujera la puntuación de un producto. Los pesos de los términos muestran la saturación: en un producto de longitud media, una aparición de un término aporta 0.400 de su IDF, y nueve apariciones aportan 0.857.
Las puntuaciones coinciden. La mayor diferencia en todos los productos y consultas es 1e-06, con la precisión de los números float32 que devuelve bm25s. Sin embargo, que las puntuaciones coincidan no basta por sí solo para fijar un ranking: cuando las puntuaciones son iguales, una implementación aún debe elegir qué producto empatado va primero. La nuestra ordena los productos empatados por ID de producto. También lo hace el BM25 compartido del libro, lib.lexical del capítulo 1, que toma la puntuación de cada producto de bm25s y luego ordena las puntuaciones iguales por ID de producto. Al preguntar si ambos dan los mismos 100 primeros para cada consulta, el ejemplo responde yes.
Los rankings se deducen de las puntuaciones. En las consultas de entrenamiento, el nDCG@10 medio es 0.695 a mano y 0.695 con bm25s; en las consultas de prueba, 0.725 y 0.725.
Regla práctica: Sirve BM25 desde una biblioteca como bm25s, y mantén una versión pequeña que hayas escrito tú para comprobarla, porque la tuya muestra de dónde viene cada parte de una puntuación. Compara dos implementaciones primero por sus puntuaciones y después por sus rankings. Antes de comparar rankings, desempata de la misma manera en ambas, por ID de producto como hace el BM25 del libro, porque los productos empatados por sí solos pueden hacer que dos implementaciones correctas ordenen de forma distinta. Cuando dos sistemas BM25 ordenan de forma distinta, compara sus tokenizadores antes que sus fórmulas. El estudio de variantes mantuvo fijas la tokenización y las palabras vacías, y señala que ajustes más mundanos, como la elección de las palabras vacías, suelen producir diferencias mayores que la fórmula (Kamphuis et al.).
Reduce términos a su raíz para que coincidan las formas de las palabras
Un cliente escribe pool floats, y un producto dice float o floating. Para el tokenizador son términos distintos, así que no coinciden. El stemming corta las terminaciones comunes de las palabras, de modo que las formas de una palabra comparten un solo término, su raíz. Martin Porter diseñó su algoritmo de eliminación de sufijos para la recuperación de información, y en su prueba redujo un vocabulario de 10,000 palabras a 6,370 raíces, un recorte de aproximadamente un tercio (Porter, 1980). Su página recomienda su sucesor, el stemmer Snowball para inglés o Porter2 (Porter), que reduce a una raíz distinta un poco más del 5% de las palabras (Snowball). El stemming intercambia precisión por exhaustividad. Aumenta la exhaustividad mientras perjudica la precisión, y ayuda mucho a algunas consultas mientras perjudica a otras tanto (Manning et al., 2008).
Un stemmer rudimentario ocupa pocas líneas. Escribe a mano uno que corte -ing, -es, -ed o -s cuando queden al menos tres letras, y compáralo con el stemmer Snowball para inglés de PyStemmer, que recomienda el tokenizador de bm25s (tokenizador de bm25s) y que el libro fija en la versión 3.1.0 (PyStemmer). Después cuenta los productos cuyo texto contiene una palabra, y los que contienen su raíz:
1"""Compares a hand-written suffix stripper with the Snowball English stemmer on a few words, then counts the products whose text contains each word and its stem. The prose's point rests on the counts for floats and for molding, and on the vocabulary reduction line."""2import Stemmer34from lib.lexical_by_hand import InvertedIndex5from lib.store import load_products, product_text678def strip_suffix(word):9 """A stemmer by hand: cut the first ending that matches, if at least three letters are left."""10 # the first ending that matches is cut, so the order matters: "es" is tried before "s"11 for ending in ["ing", "es", "ed", "s"]:12 # at least three letters must remain, so short words such as "is" keep their endings13 if word.endswith(ending) and len(word) - len(ending) >= 3:14 return word[: -len(ending)]15 return word161718stemmer = Stemmer.Stemmer("english") # Snowball English, also called Porter219words = ["floats", "floating", "molding", "molded", "moldings", "shelves", "shelving", "shelf"]20for word, stem in zip(words, stemmer.stemWords(words)):21 print(f"{word}: snowball {stem}, by hand {strip_suffix(word)}")2223products = load_products()24text = product_text(products)25plain, stemmed = InvertedIndex(text), InvertedIndex(text, stem=True)26print()27for word in ["floats", "molding"]:28 print(f"products with {word}:", len(plain.postings[word]))29 print(f"products with the stem of {word}:", len(stemmed.postings[stemmer.stemWord(word)]))30# every product with a word whose stem is float: float, floats, floating and any other form31float_products = list(stemmed.postings["float"])32print("products with the stem of floats that say floating:", len(plain.postings["floating"].keys() & set(float_products)))33for product_class, count in products.loc[float_products, "product_class"].value_counts().head(2).items():34 print(f"products with the stem of floats in {product_class}: {count}")35print(f"vocabulary without stemming: {len(plain.postings):,} terms")36print(f"vocabulary with stemming: {len(stemmed.postings):,} terms")37print(f"vocabulary reduction: {1 - len(stemmed.postings) / len(plain.postings):.0%}")
python stemmer-merges-word-forms.pyfloats: snowball float, by hand float
floating: snowball float, by hand float
molding: snowball mold, by hand mold
molded: snowball mold, by hand mold
moldings: snowball mold, by hand molding
shelves: snowball shelv, by hand shelv
shelving: snowball shelv, by hand shelv
shelf: snowball shelf, by hand shelf
products with floats: 11
products with the stem of floats: 288
products with molding: 123
products with the stem of molding: 262
products with the stem of floats that say floating: 244
products with the stem of floats in Wall Mounted Shelves: 57
products with the stem of floats in Desks: 36
vocabulary without stemming: 20,393 terms
vocabulary with stemming: 15,258 terms
vocabulary reduction: 25%
El stemmer escrito a mano coincide con Snowball en todas las palabras excepto moldings, donde se detiene tras cortar -s, mientras que las reglas de Snowball siguen hasta mold. Ambos convierten shelves en shelv y dejan shelf sin cambios: las reglas que cortan terminaciones no saben que shelves es el plural de shelf.
Los recuentos muestran las dos caras del intercambio. floats aparece en 11 productos y su raíz en 288, pero 244 de esos dicen floating. Las dos clases de producto más frecuentes entre ellos son las estanterías de pared, con 57, y los escritorios, con 36. Así, la raíz alcanza a las estanterías flotantes tanto como a los flotadores de piscina, y solo los juicios pueden decir qué efecto prevalece (sección siguiente).
molding aparece en 123 y su raíz en 262, porque mold también representa molded, moldings y a mold mismo, una palabra con más de un significado. El vocabulario se reduce en 25%, de 20,393 terms a 15,258 terms. La prueba de Porter usó otro texto y un algoritmo anterior, así que no son directamente comparables.
Para servir BM25 con stemming desde bm25s, pasa el mismo stemmer a bm25s.tokenize para los productos y para cada consulta. Después comprueba que bm25s, con el mismo stemmer, puntúa como el índice construido a mano con stemming, InvertedIndex(text, stem=True) desde lib.lexical_by_hand:
1"""Builds bm25s with the same stemmer as the hand-built index, then checks every score on every query against it. The prose's point rests on the line that prints the largest score difference from bm25s."""2import bm25s3import Stemmer45from lib.lexical_by_hand import InvertedIndex6from lib.store import load_products, load_queries, product_text78products, queries = load_products(), load_queries()9texts = product_text(products)10stemmer = Stemmer.Stemmer("english")1112library = bm25s.BM25() # k1=1.5, b=0.75, as in chapter 113# products and queries must go through the same stop list and stemmer, or their terms won't match14library.index(bm25s.tokenize(texts.tolist(), stopwords="en", stemmer=stemmer, show_progress=False),15 show_progress=False)16by_hand = InvertedIndex(texts, stem=True)1718gaps = []19for query in queries["query"]:20 tokens = bm25s.tokenize([query], stopwords="en", stemmer=stemmer, return_ids=False, show_progress=False)[0]21 scores = library.get_scores(tokens) # every product, in catalog order22 # search keeps only matching products, best first: reindex puts each in its catalog place, 0 for the rest23 gaps.append(abs(by_hand.search(query, k=len(products)).reindex(products.index, fill_value=0) - scores).max())24print("query terms for pool floats:", bm25s.tokenize(["pool floats"], stopwords="en", stemmer=stemmer,25 return_ids=False, show_progress=False)[0])26print(f"largest score difference from bm25s with a stemmer: {max(gaps):.0e}")
python bm25s-with-a-stemmer.pyquery terms for pool floats: ['pool', 'float']
largest score difference from bm25s with a stemmer: 2e-06
pool floats pasa a ser pool y float, y la mayor diferencia de puntuación entre todos los productos y consultas es 2e-06, el mismo redondeo que sin stemming.
Regla práctica: Aplica stemming al texto de productos y a las consultas en inglés con el stemmer Snowball para inglés, tanto al indexar como al consultar: en bm25s, pasa stemmer= a bm25s.tokenize en ambos lados. Revisa los productos que añade una raíz, como hacen los recuentos de floats, antes de confiar en una mejora. Cuando una raíz une palabras que tus clientes mantienen separadas, como molding y mold, lleva una lista de palabras a las que no aplicas stemming. Para texto en otro idioma, usa el stemmer de ese idioma.
Comprueba el stemming en las consultas de prueba
Stemming cambia precisión por exhaustividad, así que solo los juicios pueden decir si compensa para la tienda. La decisión de aplicar stemming surge de las 50 consultas de entrenamiento. Esta es la primera de las cinco comparaciones planificadas del capítulo, ejecutada sobre las 30 consultas de prueba. A continuación, el índice con stemming se enfrenta al índice sin stemming de la sección de BM25:
1"""Compares the stemmed index with the unstemmed one on train and test queries, and runs the planned test comparison for stemming. The prose's point rests on the test permutation p and t-test p lines, and on the line that reports the query with the largest gain."""2from lib.lexical_by_hand import THRESHOLD, InvertedIndex, report_test_comparison3from lib.metrics import evaluate4from lib.store import load_products, load_queries, product_text, qrels56text = product_text(load_products())7indexes = {"without stemming": InvertedIndex(text), "with stemming": InvertedIndex(text, stem=True)}8scores = {split: {name: evaluate(index.run(load_queries(split)), qrels(split)) for name, index in indexes.items()}9 for split in ["train", "test"]}1011for split in ["train", "test"]:12 for name, frame in scores[split].items():13 print(f"{split} ndcg@10 {name}: {frame['ndcg@10'].mean():.3f}")14 print(f"{split} judged@10 {name}: {frame['judged@10'].mean():.3f}")15change = (scores["train"]["with stemming"]["ndcg@10"] - scores["train"]["without stemming"]["ndcg@10"]).round(3)16print(f"train queries better, worse: {(change > 0).sum()}, {(change < 0).sum()}") # for choosing, not evidence17for query_id in [410, 359]: # pool floats and french molding, train queries18 for name, frame in scores["train"].items():19 print(f"query {query_id} {name}: {frame.at[query_id, 'ndcg@10']:.3f}")2021print(f"\nthe planned test comparison, threshold {THRESHOLD:.2f}:")22after, before = scores["test"]["with stemming"]["ndcg@10"], scores["test"]["without stemming"]["ndcg@10"]23# the planned test comparison: permutation test, t-test and bootstrap interval24report_test_comparison(after, before)25gain = after - before26print("test query with the largest gain:", gain.idxmax())27print(f"its gain: {gain.max():.3f}")28print(f"mean test gain without it: {gain.drop(gain.idxmax()).mean():.3f}")
python measure-stemming.pytrain ndcg@10 without stemming: 0.695
train judged@10 without stemming: 0.930
train ndcg@10 with stemming: 0.725
train judged@10 with stemming: 0.950
test ndcg@10 without stemming: 0.725
test judged@10 without stemming: 0.927
test ndcg@10 with stemming: 0.774
test judged@10 with stemming: 0.950
train queries better, worse: 24, 14
query 410 without stemming: 0.360
query 410 with stemming: 0.921
query 359 without stemming: 0.961
query 359 with stemming: 0.809
the planned test comparison, threshold 0.01:
mean difference: 0.050
wins, losses, ties: 16, 6, 8
permutation p: 0.005
established at 0.01: yes
t-test p: 0.037
t-test agrees: no
99% interval: 0.016 to 0.162
interval agrees: yes
test query with the largest gain: 133
its gain: 0.635
mean test gain without it: 0.029
En las consultas de entrenamiento, el stemming lleva el nDCG@10 medio de 0.695 a 0.725, y el judged@10 de 0.930 a 0.950. Las consultas de entrenamiento que mejoran y empeoran suman 24, 14. pool floats pasa de 0.360 a 0.921, y french molding de 0.961 a 0.809. Estas cifras de entrenamiento eligen el stemming. No son evidencia de que ayude.
En las consultas de prueba, la ganancia del stemming queda establecida con 0.01, aunque la prueba t discrepa (las comparaciones planificadas): el nDCG@10 medio pasa de 0.725 a 0.774, una diferencia media de 0.050. El judged@10 también sube, de 0.927 a 0.950, así que parte de esa ganancia puede venir de productos que la ejecución sin stemming dejó sin juzgar.
Una consulta explica por qué las dos pruebas se separan. La consulta 133, outdoor light fixtures, gana 0.635, y sin ella la ganancia media es 0.029. La prueba t supone que las diferencias son aproximadamente normales, así que una ganancia grande amplía su dispersión y baja t; la prueba de permutaciones no supone nada sobre su forma (capítulo 3). Esa consulta es además la que el capítulo 1 encontró llena de bombillas sin juzgar en sus diez primeros resultados sin stemming.
Regla práctica: Elige un cambio de procesamiento de texto con las consultas de entrenamiento, y consérvalo solo si su comparación planificada queda establecida. Cuando la prueba de permutaciones y la prueba t discrepan, lee las mayores diferencias por consulta, e informa la ganancia sin la mayor junto a la media. El stemming queda establecido, así que aplícalo al construir la búsqueda léxica. El BM25 compartido del libro sigue sin stemming, para que los resultados de los capítulos posteriores sigan siendo comparables (decisiones). Trata el tamaño de la ganancia como frágil.
Ajusta los parámetros de BM25 en consultas de entrenamiento
Los dos parámetros de BM25 no tienen un único valor correcto, y las bibliotecas traen valores por defecto distintos. bm25s usa k1=1.5 y b=0.75 (código fuente de bm25s). Lucene usa k1=1.2 y b=0.75 (Lucene BM25Similarity). Kamphuis et al. (2020) informan k1=0.9 y b=0.4 como los valores por defecto de Anserini, un kit de herramientas de investigación. Robertson y Zaragoza (2009) ofrecen una regla práctica, no una medición: b entre 0.5 y 0.8 y k1 entre 1.2 y 2 son razonablemente buenos en muchas circunstancias, pero los mejores valores dependen del tipo de documentos y consultas. Por eso los ajustas con tus propias consultas de entrenamiento y compruebas el resultado con las consultas de prueba.
El índice invertido almacena frecuencias de términos y longitudes, no puntuaciones, así que k1 y b pueden cambiar de una búsqueda a otra sin reconstruirlo. bm25s calcula cada puntuación al construir su índice (Lù, 2024), lo que hace rápidas sus búsquedas, pero cada nuevo k1 o b necesita un índice nuevo. Un barrido sobre el índice con stemming prueba una cuadrícula de 25 configuraciones con las 50 consultas de entrenamiento y elige la mejor. Luego compara la mejor con los valores por defecto usando las 30 consultas de prueba: la segunda comparación planificada, con el umbral de 0.01.
Antes de ejecutarlo, haz una predicción: con los valores por defecto, BM25 con raíces obtiene 0.774 en las consultas de prueba. ¿Cuánto añadirá la mejor configuración en entrenamiento?
1"""Sweeps k1 and b over the stemmed index on train queries, picks the best setting, and checks it against the defaults on test queries. The prose's point rests on the train best and grid-edge lines, and on the test permutation p line."""2import pandas as pd34from lib.lexical_by_hand import InvertedIndex, report_test_comparison5from lib.metrics import evaluate6from lib.store import load_products, load_queries, product_text, qrels78index = InvertedIndex(product_text(load_products()), stem=True) # stemmed terms, k1 and b set per search9train, test = load_queries("train"), load_queries("test")10# the grid: five values of k1 and five of b, with the defaults 1.5 and 0.75 among them11k1_values, b_values = [0.5, 0.9, 1.2, 1.5, 2.0], [0.0, 0.25, 0.5, 0.75, 1.0]121314def scores(queries, split, k1, b):15 """One row per query, with BM25 at these parameters."""16 return evaluate(index.run(queries, k1=k1, b=b), qrels(split))171819# one column per b, one row per k120grid = pd.DataFrame({b: {k1: scores(train, "train", k1, b)["ndcg@10"].mean() for k1 in k1_values} for b in b_values})21print("train ndcg@10, k1 down and b across:")22print(grid.round(3).to_string())23# the (k1, b) pair with the highest mean nDCG@10 on train24best_k1, best_b = grid.stack().idxmax()25print("settings in the grid:", grid.size)26print(f"best k1 on train: {best_k1}")27print(f"best b on train: {best_b}")28# a best value at an end of the grid can mean a better one lies beyond it29edge = best_k1 in (k1_values[0], k1_values[-1]) or best_b in (b_values[0], b_values[-1])30print("best setting on the grid's edge:", "yes" if edge else "no")31print(f"train ndcg@10 at the train best: {grid.at[best_k1, best_b]:.3f}")32print(f"train ndcg@10 at k1 1.5, b 0.75: {grid.at[1.5, 0.75]:.3f}")33print(f"train gain of the best over the defaults: {grid.at[best_k1, best_b] - grid.at[1.5, 0.75]:.3f}")34print(f"lowest train ndcg@10 in the grid: {grid.min().min():.3f}")35print()36runs = {"at k1 1.5, b 0.75": scores(test, "test", 1.5, 0.75), "at the train best": scores(test, "test", best_k1, best_b)}37for name, frame in runs.items():38 print(f"test ndcg@10 {name}: {frame['ndcg@10'].mean():.3f}")39 print(f"test judged@10 {name}: {frame['judged@10'].mean():.3f}")40# the planned test comparison: permutation test, t-test and bootstrap interval41report_test_comparison(runs["at the train best"]["ndcg@10"], runs["at k1 1.5, b 0.75"]["ndcg@10"])
python sweep-k1-and-b.pytrain ndcg@10, k1 down and b across:
0.00 0.25 0.50 0.75 1.00
0.5 0.707 0.710 0.716 0.720 0.720
0.9 0.711 0.711 0.716 0.722 0.720
1.2 0.709 0.711 0.715 0.723 0.720
1.5 0.709 0.714 0.719 0.725 0.715
2.0 0.714 0.720 0.726 0.729 0.713
settings in the grid: 25
best k1 on train: 2.0
best b on train: 0.75
best setting on the grid's edge: yes
train ndcg@10 at the train best: 0.729
train ndcg@10 at k1 1.5, b 0.75: 0.725
train gain of the best over the defaults: 0.004
lowest train ndcg@10 in the grid: 0.707
test ndcg@10 at k1 1.5, b 0.75: 0.774
test judged@10 at k1 1.5, b 0.75: 0.950
test ndcg@10 at the train best: 0.775
test judged@10 at the train best: 0.953
mean difference: 0.001
wins, losses, ties: 7, 6, 17
permutation p: 0.757
established at 0.01: no
t-test p: 0.754
t-test agrees: yes
99% interval: -0.008 to 0.008
interval agrees: yes
En entrenamiento, toda la cuadrícula se sitúa entre 0.707 y 0.729. La mejor configuración, k1 = 2.0 y b = 0.75, obtiene 0.729, frente a 0.725 con los valores por defecto. El ejemplo indica si se encuentra en el borde de la cuadrícula: yes. Una cuadrícula más amplia podría encontrar una puntuación de entrenamiento más alta, pero con toda la cuadrícula tan cerca, cambiaría poco.
El ajuste no muestra una mejora establecida en las consultas de prueba. La mejor configuración obtiene 0.775 frente a 0.774, con judged@10 de 0.953 y 0.950, y la diferencia no está establecida (las comparaciones planificadas).
Si predijiste una mejora de unas pocas centésimas, la cuadrícula de entrenamiento hace improbable ese resultado. En entrenamiento, la mejor configuración supera a los valores por defecto en 0.004, y aun esa cifra es una estimación optimista: de todas las configuraciones, es la que, por casualidad, mejor se ajustó a estas consultas, así que en otras consultas debes esperar menos.
Regla práctica: Parte de los valores por defecto de la biblioteca. Ajusta k1 y b con consultas de entrenamiento cuando cambies lo que indexas, como los campos o las raíces, y conserva una configuración ajustada solo si su comparación planificada está establecida. La configuración ajustada de la tienda no lo está, así que la tienda mantiene k1=1.5 y b=0.75.
Pondera el nombre del producto por encima de la descripción
El texto de un producto tiene partes, llamadas campos: los campos de texto de la tienda son nombre, clase, categoría y descripción. No son igual de informativos. Una palabra de la consulta que aparece en el nombre dice más sobre qué es el producto que la misma palabra en algún punto de una descripción. Hay dos formas de ponderar los campos. La primera que se le ocurre a uno puntúa cada campo con BM25 y suma las puntuaciones. Robertson y Zaragoza (2009, sección 3.6) defienden el orden contrario, "primero los flujos, luego los términos": combinar primero las frecuencias ponderadas de cada término en los campos y después saturar la evidencia total de ese término. Combinar las frecuencias ponderadas de un término entre campos antes de saturar el total es BM25F. Su regla implica que sumar puntuaciones por campo permite que un término que coincide en dos campos escape a la saturación, porque cada campo se satura por su cuenta. Con pesos enteros, el BM25F simple da el mismo resultado que el BM25 normal sobre un texto en el que cada campo se repite tantas veces como su peso (Robertson y Zaragoza, sección 3.6.4), así que puedes probarlo con cualquier biblioteca de BM25.
El buscador de la tienda indexa un solo campo: nombre, clase, categoría y descripción unidos. El primer intento es el que se le ocurre a uno: en las 50 consultas de entrenamiento con derivación a la raíz, el nombre y los otros tres campos se indexan por separado, se puntúan por separado y se suman. Indexados por separado, cada campo también obtiene su propio IDF y su propia longitud media, así que esto cambia más que la saturación. Según el argumento de Robertson y Zaragoza, esperamos que funcione peor. En las consultas de entrenamiento, el resultado orienta una decisión y no demuestra nada:
1"""Scores the name and the other fields as separate BM25 indexes and adds the scores, then compares the result with one field on train queries. The prose's point rests on the two train nDCG@10 lines and the line that counts the queries that get better and worse."""2from collections import Counter34from lib.lexical_by_hand import InvertedIndex5from lib.metrics import evaluate6from lib.store import load_products, load_queries, product_text, qrels78products, train = load_products(), load_queries("train")9others = products["product_class"] + ". " + products["category"] + ". " + products["description"]10one_field = InvertedIndex(product_text(products), stem=True) # name, class, category, description11name, rest = InvertedIndex(products["name"], stem=True), InvertedIndex(others, stem=True) # own IDF and lengths1213summed = {}14for query_id, query in train["query"].items():15 scores = Counter(name.bm25(query)) + Counter(rest.bm25(query)) # each field saturates on its own16 # the top 100, as in every other run17 summed[query_id] = [product_id for product_id, _ in scores.most_common(100)]1819runs = {"one field": one_field.run(train), "fields scored apart": summed}20scores = {label: evaluate(run, qrels("train")) for label, run in runs.items()}21for label, frame in scores.items():22 print(f"{label}, train ndcg@10: {frame['ndcg@10'].mean():.3f}")23 print(f"{label}, train judged@10: {frame['judged@10'].mean():.3f}")24change = (scores["fields scored apart"]["ndcg@10"] - scores["one field"]["ndcg@10"]).round(3)25print(f"train queries better, worse with fields scored apart: {(change > 0).sum()}, {(change < 0).sum()}")
python fields-scored-apart.pyone field, train ndcg@10: 0.725
one field, train judged@10: 0.950
fields scored apart, train ndcg@10: 0.686
fields scored apart, train judged@10: 0.970
train queries better, worse with fields scored apart: 15, 24
Puntuados por separado, los campos dan un nDCG@10 de entrenamiento de 0.686 frente a 0.725 para un solo campo, con judged@10 de 0.970 y 0.950. Las consultas de entrenamiento que mejoran y empeoran suman 15, 24. Eso basta para elegir un campo frente a este diseño, pero no para explicar por qué: la saturación, el IDF y la normalización por longitud cambiaron todos a la vez.
Un segundo intento usa BM25F con pesos enteros: el nombre se cuenta 1, 2, 3 o 5 veces en el texto indexado. Elige el peso con la mejor puntuación de entrenamiento y lo compara con un solo campo en las 30 consultas de prueba: la tercera comparación planificada.
1"""Repeats the product name in the indexed text, once per extra weight, and picks the weight with the best train nDCG@10 for the test comparison. The prose's point rests on the best-weight line and the test permutation p line."""2from lib.lexical_by_hand import InvertedIndex, report_test_comparison3from lib.metrics import evaluate4from lib.store import load_products, load_queries, product_text, qrels56products, train, test = load_products(), load_queries("train"), load_queries("test")7# product_text already holds the name once, so weight - 1 more copies make it weight in all8indexes = {weight: InvertedIndex((products["name"] + ". ") * (weight - 1) + product_text(products), stem=True)9 for weight in [1, 2, 3, 5]} # BM25F with whole-number weights: the name counted weight times1011train_scores = {weight: evaluate(index.run(train), qrels("train")) for weight, index in indexes.items()}12for weight, frame in train_scores.items():13 print(f"name weight {weight}, train ndcg@10: {frame['ndcg@10'].mean():.3f}")14 print(f"name weight {weight}, train judged@10: {frame['judged@10'].mean():.3f}")15# on a tie, max keeps the first weight, the smaller one16best = max(train_scores, key=lambda weight: train_scores[weight]["ndcg@10"].mean())17print("best name weight on train:", best)18print()19runs = {"one field": indexes[1].run(test), "best name weight": indexes[best].run(test)}20scores = {label: evaluate(run, qrels("test")) for label, run in runs.items()}21for label, frame in scores.items():22 print(f"{label}, test ndcg@10: {frame['ndcg@10'].mean():.3f}")23 print(f"{label}, test judged@10: {frame['judged@10'].mean():.3f}")24# the planned test comparison: permutation test, t-test and bootstrap interval25report_test_comparison(scores["best name weight"]["ndcg@10"], scores["one field"]["ndcg@10"])
python repeat-the-name-field.pyname weight 1, train ndcg@10: 0.725
name weight 1, train judged@10: 0.950
name weight 2, train ndcg@10: 0.734
name weight 2, train judged@10: 0.968
name weight 3, train ndcg@10: 0.729
name weight 3, train judged@10: 0.970
name weight 5, train ndcg@10: 0.722
name weight 5, train judged@10: 0.972
best name weight on train: 2
one field, test ndcg@10: 0.774
one field, test judged@10: 0.950
best name weight, test ndcg@10: 0.786
best name weight, test judged@10: 0.970
mean difference: 0.012
wins, losses, ties: 15, 9, 6
permutation p: 0.149
established at 0.01: no
t-test p: 0.153
t-test agrees: yes
99% interval: -0.009 to 0.032
interval agrees: yes
En entrenamiento, el mejor peso del nombre es 2, que puntúa 0.734 frente a 0.725 para un solo campo, con judged@10 de 0.968 y 0.950.
Repetir el nombre no muestra una mejora establecida en prueba: el mejor peso del nombre puntúa 0.786 frente a 0.774, con judged@10 de 0.970 y 0.950, y la mejora no queda establecida (las comparaciones planificadas). Ni la prueba t ni el intervalo contradicen esa conclusión.
Regla práctica: No sumes puntuaciones BM25 de campos separados. Para ponderar un campo, combina las frecuencias de los términos antes de la saturación, con BM25F o repitiendo el campo. Ajusta el peso con las consultas de entrenamiento y conserva el peso solo si su comparación planificada queda establecida. Para la tienda, se mantiene un único campo combinado.
Indexar los atributos de producto como un campo
Los compradores a menudo añaden un modificador, una palabra que acota lo que buscan: un color, un material, una talla. Los jueces de WANDS marcan un producto como parcial cuando coincide con lo pedido pero no con sus modificadores. Los nombres y las descripciones de los productos no siempre indican un modificador, pero un catálogo suele guardar datos de un producto como atributos estructurados, como color: clear o material: glass. Los productos de la tienda llevan algunos de WANDS: color, material, estilo, acabado, forma, talla, ancho, alto y profundidad (examples/data/wands/README.md). Indexados como un campo más, los atributos dan a un modificador algo con que coincidir. También añaden términos a cada producto que los tiene, así que si ayudan o no es una cuestión que deben decidir los juicios.
En el capítulo 1, los resultados de BM25 para clear shower curtain no podían mostrar qué cortinas eran transparentes. El ejemplo añade a cada producto sus atributos, nombres y valores, a su texto indexado, como un campo con peso 1, combinado antes de la saturación como recomienda la sección anterior. Cuenta los productos exactos para esa consulta de prueba que contienen clear, con y sin atributos. Mide este candidato, fijado de antemano, sobre las 50 consultas de entrenamiento y lo comprueba en las 30 consultas de prueba: la cuarta comparación planificada. Al estar planificada, se evalúa en prueba sea cual sea el resultado en entrenamiento.
1"""Adds each product's attributes, names and values, to its indexed text as one more field, and checks that single candidate on train and test. The prose's point rests on the two lines that count exact products with clear, and on the test permutation p line."""2from lib.lexical_by_hand import InvertedIndex, report_test_comparison, tokenize3from lib.metrics import evaluate4from lib.store import load_products, load_queries, product_text, qrels56products = load_products()7text = product_text(products)8with_attributes = text + ". " + products["attributes"] # names and values, one more field, weight 1910exact = [product_id for product_id, grade in qrels("test")[246].items() if grade == 2] # clear shower curtain11print("exact products for query 246:", len(exact))12print("exact, with clear in their text:", sum("clear" in tokenize(text[product_id]) for product_id in exact))13print("exact, with clear in text or attributes:", sum("clear" in tokenize(with_attributes[product_id]) for product_id in exact))14# a product whose attributes say clear and whose text does not, to show what the field adds15found = next(product_id for product_id in exact16 if "clear" in tokenize(products.at[product_id, "attributes"]) and "clear" not in tokenize(text[product_id]))17print(f"for example: {products.at[found, 'name']} -> {products.at[found, 'attributes']}")18names = {"color", "material", "style", "finish", "shape", "size", "width", "height", "depth"} # the attribute names19print("queries that contain an attribute name:", load_queries()["query"].map(lambda query: bool(names & set(tokenize(query)))).sum())20print("products whose attributes name size:", sum("size" in tokenize(value) for value in products["attributes"]))2122indexes = {"one field": InvertedIndex(text, stem=True), "with attributes": InvertedIndex(with_attributes, stem=True)}23scores = {split: {label: evaluate(index.run(load_queries(split)), qrels(split)) for label, index in indexes.items()}24 for split in ["train", "test"]} # one candidate, fixed in advance: tuned on nothing25for split in ["train", "test"]:26 print()27 for label, frame in scores[split].items():28 print(f"{split} ndcg@10, {label}: {frame['ndcg@10'].mean():.3f}")29 print(f"{split} judged@10, {label}: {frame['judged@10'].mean():.3f}")30print()31for query_id in [246, 58]: # clear shower curtain, medium size chandelier: test queries32 for label, frame in scores["test"].items():33 print(f"query {query_id} ndcg@10, {label}: {frame.at[query_id, 'ndcg@10']:.3f}")34# the planned test comparison: permutation test, t-test and bootstrap interval35report_test_comparison(scores["test"]["with attributes"]["ndcg@10"], scores["test"]["one field"]["ndcg@10"])
python add-attributes-field.pyexact products for query 246: 12
exact, with clear in their text: 4
exact, with clear in text or attributes: 8
for example: wynsum vinyl single shower curtain -> color: clear; width: 72; height: 84
queries that contain an attribute name: 1
products whose attributes name size: 950
train ndcg@10, one field: 0.725
train judged@10, one field: 0.950
train ndcg@10, with attributes: 0.717
train judged@10, with attributes: 0.948
test ndcg@10, one field: 0.774
test judged@10, one field: 0.950
test ndcg@10, with attributes: 0.787
test judged@10, with attributes: 0.963
query 246 ndcg@10, one field: 0.714
query 246 ndcg@10, with attributes: 0.844
query 58 ndcg@10, one field: 0.731
query 58 ndcg@10, with attributes: 0.667
mean difference: 0.013
wins, losses, ties: 8, 10, 12
permutation p: 0.303
established at 0.01: no
t-test p: 0.281
t-test agrees: yes
99% interval: -0.009 to 0.053
interval agrees: yes
Para clear shower curtain, los atributos hacen lo que deben: 4 de los 12 productos exactos dicen clear en su texto, y 8 lo hacen una vez que se cuentan los atributos, como la cortina de vinilo cuyos atributos dicen color: clear. Para esta consulta, nDCG@10 pasa de 0.714 a 0.844. Indexar los nombres de los atributos tiene un coste, sin embargo: size ahora coincide con los 950 productos cuyos atributos indican una talla. La tienda tiene 1 consulta que contiene un nombre de atributo, la consulta de prueba medium size chandelier, y pasa de 0.731 a 0.667.
En entrenamiento, judged@10 pasa de 0.950 a 0.948, y nDCG@10 de 0.725 a 0.717. En prueba, judged@10 pasa de 0.950 a 0.963, y nDCG@10 de 0.774 a 0.787, pero la prueba de permutación no establece la mejora (las comparaciones planificadas).
Regla práctica: Conserva los atributos estructurados y lee las consultas a las que ayudan, pero no los añadas al texto de BM25 basándote en unas pocas consultas. Indexa los valores sin los nombres, para que una palabra de consulta como size no coincida con todos los productos que tienen talla, y mantén el campo solo si su comparación planificada queda establecida. En la tienda, los atributos se quedan fuera del texto de BM25. Cuando un modificador nombra exactamente un valor de atributo, como un color, un filtro o una característica de ranking puede usarlo sin añadir sus palabras al texto de cada producto.
Emparejar frases con posiciones de términos
BM25 puntúa una bolsa de palabras: cuenta qué términos contiene un producto y con qué frecuencia, pero nunca su orden. Para BM25, barn door y door barn son la misma consulta. Una coincidencia de frase exige que los términos aparezcan uno junto a otro y en orden, y un índice de conteos no puede comprobar eso. Un índice posicional guarda, para cada término y producto, las posiciones donde aparece el término, de modo que una frase se convierte en una comprobación de posiciones (Manning et al., 2008). bm25s precalcula una puntuación para cada par de producto y término (Lù, 2024). Su índice no guarda posiciones (código fuente de bm25s), así que las frases necesitan un índice propio.
Primero construimos un índice posicional sobre los nombres de productos de la tienda, con términos reducidos a su raíz (stemming) como en la sección de stemming. Las posiciones cuentan los términos después de eliminar las palabras vacías, de modo que door for laundry contiene los términos contiguos door y laundri: una frase puede coincidir aunque se haya eliminado una palabra vacía entre ellos. Tomemos barn door, dos palabras de una de las consultas de la tienda: afirmamos que BM25 no puede distinguir sus dos órdenes, y contamos los nombres que contienen ambas palabras frente a los que contienen la frase:
1"""Builds a positional index over the product names, asserts that BM25 scores both word orders alike, and lists the names that have both words without the phrase. The prose's point rests on the two count lines, names with barn and door and names with the phrase barn door."""2from lib.lexical_by_hand import InvertedIndex, tokenize3from lib.store import load_products, product_text45products = load_products()6positions = {} # {term: {product_id: [where the term occurs in the name, counted after stop words go]}}7for product_id, name in products["name"].items():8 # positions count the terms left after stop words are removed, so a phrase can span one9 for place, term in enumerate(tokenize(name, stem=True)):10 positions.setdefault(term, {}).setdefault(product_id, []).append(place)111213def has_phrase(product_id, terms):14 """True if the terms occur next to each other, in this order, in the product's name."""15 def places(term):16 return positions.get(term, {}).get(product_id, [])17 # each term has to sit at the next position after the one before it18 return any(all(start + offset in places(term) for offset, term in enumerate(terms)) for start in places(terms[0]))192021index = InvertedIndex(product_text(products), stem=True)22# BM25 counts words, not their order, so both orders must score alike23assert index.bm25("barn door") == index.bm25("door barn")24both = set(positions["barn"]) & set(positions["door"])25print("names with barn and door:", len(both))26print("names with the phrase barn door:", sum(has_phrase(product_id, ["barn", "door"]) for product_id in both))27for product_id in sorted(product_id for product_id in both if not has_phrase(product_id, ["barn", "door"])):28 print(" ", products.at[product_id, "name"])
python phrase-positions-by-hand.pynames with barn and door: 71
names with the phrase barn door: 66
low ceiling single bypass double door barn hardware kit
artemas barn owl welcome non-slip outdoor door mat
vintage rustic wooden door of old barn duvet cover set
barnes entrance scraper non-slip outdoor door mat
glass barn 60 '' w x 76 '' h single sliding frameless shower door
BM25 da a barn door y a door barn las mismas puntuaciones, como afirma el código. De los 71 nombres que contienen tanto barn como door, 66 contienen la frase. Los nombres sin ella muestran qué detecta una comprobación de frase y qué cuesta. Dos felpudos y una funda nórdica coinciden con ambas palabras pero no son puertas de granero, y uno de los felpudos coincide solo porque barnes se reduce a su raíz barn. El kit de herrajes de bypass, en cambio, es herraje para puertas de granero, y la puerta de ducha corredera de cristal es una puerta de estilo granero. Un filtro estricto de frases eliminaría ambos.
Un bonus es más suave que un filtro: una cantidad fija que se suma a la puntuación BM25 de un producto por cada par de términos de consulta contiguos que aparezca, en orden, en su nombre. El ejemplo de bonus usa PositionalIndex de lib.lexical_by_hand, que guarda las mismas posiciones, y elige el bonus sobre las 50 consultas de entrenamiento, y luego lo comprueba sobre las 30 consultas de prueba: la última comparación planificada.
1"""Adds a bonus for each adjacent pair of query terms that appears in order in a product's name, picks the bonus on train and checks it on test. The prose's point rests on the test permutation p line and the test nDCG@10 lines."""2from lib.lexical_by_hand import InvertedIndex, PositionalIndex, report_test_comparison, tokenize3from lib.metrics import evaluate4from lib.store import load_products, load_queries, product_text, qrels56products = load_products()7index = InvertedIndex(product_text(products), stem=True)8names = PositionalIndex(products["name"], stem=True) # the positions phrase-positions-by-hand builds91011def with_bonus(split, bonus):12 """BM25's top 100, plus the bonus for each pair of adjacent query terms found, in order, in the name."""13 run = {}14 for query_id, query in load_queries(split)["query"].items():15 terms, scores = tokenize(query, stem=True), index.search(query)16 pairs = list(zip(terms, terms[1:]))17 # only BM25's top 100 get a bonus, so it reorders them and adds no product18 scores += [bonus * sum(names.has_phrase(product_id, list(pair)) for pair in pairs) for product_id in scores.index]19 run[query_id] = list(scores.sort_values(ascending=False, kind="stable").index)20 return evaluate(run, qrels(split))212223train_scores = {bonus: with_bonus("train", bonus) for bonus in [0, 0.5, 1, 2]}24for bonus, frame in train_scores.items():25 print(f"bonus {bonus}, train ndcg@10: {frame['ndcg@10'].mean():.3f}")26 print(f"bonus {bonus}, train judged@10: {frame['judged@10'].mean():.3f}")27best = max(train_scores, key=lambda bonus: train_scores[bonus]["ndcg@10"].mean())28print("best bonus on train:", best)29print()30# the defaults, with no bonus, and the best bonus on train31test_scores = {bonus: with_bonus("test", bonus) for bonus in [0, best]}32for bonus, frame in test_scores.items():33 print(f"bonus {bonus}, test ndcg@10: {frame['ndcg@10'].mean():.3f}")34 print(f"bonus {bonus}, test judged@10: {frame['judged@10'].mean():.3f}")35# the planned test comparison: permutation test, t-test and bootstrap interval36report_test_comparison(test_scores[best]["ndcg@10"], test_scores[0]["ndcg@10"])
python phrase-bonus-train-and-test.pybonus 0, train ndcg@10: 0.725
bonus 0, train judged@10: 0.950
bonus 0.5, train ndcg@10: 0.727
bonus 0.5, train judged@10: 0.956
bonus 1, train ndcg@10: 0.725
bonus 1, train judged@10: 0.964
bonus 2, train ndcg@10: 0.716
bonus 2, train judged@10: 0.968
best bonus on train: 0.5
bonus 0, test ndcg@10: 0.774
bonus 0, test judged@10: 0.950
bonus 0.5, test ndcg@10: 0.776
bonus 0.5, test judged@10: 0.950
mean difference: 0.002
wins, losses, ties: 6, 7, 17
permutation p: 0.758
established at 0.01: no
t-test p: 0.769
t-test agrees: yes
99% interval: -0.012 to 0.015
interval agrees: yes
En entrenamiento, el mejor bonus es 0.5, que obtiene 0.727 frente a 0.725 sin él, con judged@10 de 0.956 y 0.950.
El mejor bonus obtiene 0.776 frente a 0.774, con judged@10 de 0.950 y 0.950, y la mejora no está establecida (las comparaciones planificadas).
Regla práctica: No añadas un bonus de frase a todas las consultas por defecto, y conserva uno solo si su comparación planificada está establecida. Construye posiciones cuando los compradores citen frases, o cuando el orden de las palabras cambie lo que buscan, como entre table lamp y lamp table. Prefiere un bonus que midas sobre consultas de entrenamiento a un filtro, porque un filtro elimina productos como el kit de herrajes.
Qué sale mal en producción
El índice y las consultas se desfasan. Cada paso, desde el tokenizador hasta el stemmer, debe funcionar igual en los productos y en las consultas. Si aplicas stemming a las consultas pero no a los productos, un término de consulta como shelv no encuentra ningún posting. Nada te avisa: bm25s omite los tokens de la consulta que no están en su vocabulario (código fuente de bm25s). Cambia el procesamiento de texto para ambos lados en una misma versión y reconstruye el índice completo.
Los tamaños, las unidades y los códigos no sobreviven a la tokenización. 7qt y 7 qt nunca coinciden, como muestra la sección del tokenizador. La consulta 205 del conjunto de entrenamiento termina en un código de producto, w003096809, que no aparece en el texto de ningún producto de la muestra: sus postings contienen 0, así que ningún método léxico puede encontrarlo. Un término mal escrito, como el ligth de ligth bulb, solo coincide con productos que tengan la misma errata, y el capítulo 8 construye un corrector y muestra lo que todavía no acierta.
El IDF depende del catálogo. Todos los IDF de este capítulo provienen de la muestra, que contiene todos los productos evaluados para las consultas 80 más algunos sin evaluar elegidos al azar (examples/data/wands/README.md). En el catálogo completo, las frecuencias documentales son distintas, y también los IDF y las puntuaciones. Recalcúlalos cada vez que reconstruyas el índice.
Una puntuación BM25 no tiene una escala fija. Cada término de la consulta suma como máximo su propio IDF, así que la puntuación más alta posible depende de los términos que contenga la consulta, y una puntuación de 6 puede ser alta para una consulta y baja para otra. No conserves los resultados por encima de un umbral fijo de puntuación; recorta la lista por posición.
Las palabras vacías y el stemming cambian el significado en algunas consultas. Las consultas evaluadas de la tienda no tienen negaciones, pero los clientes sí las escriben, y la lista de palabras vacías predeterminada elimina not y no. El stemming perjudica gravemente algunas consultas, como muestra french molding en la comprobación de stemming. Las evaluaciones no pueden advertirte sobre las consultas que no incluyen.
Las consultas de prueba se desgastan. Este capítulo hace cinco comparaciones planificadas sobre las mismas consultas de prueba, y el umbral de Bonferroni de 0.01 mantiene la probabilidad de cualquier falso positivo entre ellas en 5 % o menos cuando ninguno de los cambios hace nada. No puede contar lo que nadie planificó: cada ajuste adicional probado con las consultas de prueba, y cada revisión de una consulta de prueba para explicar un resultado, es otra comparación. Confirma la mejora del stemming con consultas y evaluaciones que ninguna de estas decisiones haya visto.
Regla práctica: Mantén un conjunto de consultas de sondeo para negaciones, tamaños y códigos, y revisa sus resultados después de cada cambio en el procesamiento de texto. Guarda la configuración del tokenizador y del stemmer junto con el índice que construyeron, registra los términos en que se convierte cada consulta y vigila las consultas cuyos términos no tienen postings.
Decisiones de este capítulo
Cada ajuste de este capítulo se eligió con las consultas de entrenamiento. Antes de leer ningún resultado de prueba, el capítulo fijó cinco comparaciones planificadas sobre las consultas de prueba, leídas con el arnés del capítulo 3: el stemming y el campo de atributos como candidatos únicos fijados de antemano, y el mejor ajuste en entrenamiento para k1 y b, el peso del nombre y el bonus por frase. El campo de atributos se llevó a prueba con independencia de lo que mostrara el entrenamiento, porque estaba planificado. Solo una diferencia establecida cambia una decisión. Cada columna compara nDCG@10 en las consultas de prueba con el cambio frente a la misma búsqueda sin él, con el umbral de 0.01:
| Medida | Stemming | Mejores k1 y b |
Mejor peso del nombre | Campo de atributos | Mejor bonus por frase |
|---|---|---|---|---|---|
| Diferencia media | 0.050 | 0.001 | 0.012 | 0.013 | 0.002 |
| Intervalo del 99 % | 0.016 to 0.162 | -0.008 to 0.008 | -0.009 to 0.032 | -0.009 to 0.053 | -0.012 to 0.015 |
| p de permutación | 0.005 | 0.757 | 0.149 | 0.303 | 0.758 |
| p de la prueba t | 0.037 | 0.754 | 0.153 | 0.281 | 0.769 |
| Victorias, derrotas, empates | 16, 6, 8 | 7, 6, 17 | 15, 9, 6 | 8, 10, 12 | 6, 7, 17 |
| Establecida | yes | no | no | no | no |
| La prueba t coincide | no | yes | yes | yes | yes |
| El intervalo coincide | yes | yes | yes | yes | yes |
- Tokenizador: los valores por defecto de bm25s. Conversión a minúsculas, tokens de dos o más caracteres de palabra (letras, dígitos o guiones bajos) y sus 33 palabras vacías en inglés, reconstruidos a mano y con resultados idénticos en cada producto. Pierden las tallas de un solo dígito y las negaciones. Hay demasiado pocas consultas juzgadas para medir cualquiera de las dos: un patrón que respete las tallas cambia 4 consultas de entrenamiento y 0 consultas de prueba, y 0 consultas contienen una negación. Los valores por defecto se mantienen hasta que consultas de sondeo o nuevos juicios puedan medirlo.
- Stemming: Snowball en inglés de PyStemmer, sobre productos y consultas. Su ganancia en prueba, de 0.725 a 0.774, está establecida por la prueba de permutación, aunque la prueba t no coincide y una sola consulta explica buena parte de ella. La línea base compartida del libro,
lib.lexicaldel capítulo 1, se mantiene con los valores por defecto de bm25s sin stemming, para que los resultados de todos los capítulos sigan siendo comparables. El BM25 con stemming de este capítulo esInvertedIndex(text, stem=True)enlib.lexical_by_hand, o bm25s constemmer=. - Puntuación: BM25 tal como bm25s lo calcula por defecto, la fórmula de Lucene con longitudes exactas,
k1=1.5yb=0.75, con las puntuaciones iguales ordenadas por el ID del producto. El mejor ajuste en entrenamiento no está establecido en prueba, así que se mantienen los valores por defecto. - Campos: un solo campo que une nombre, clase, categoría y descripción. Las puntuaciones por campo, sumadas, dan resultados peores en entrenamiento. El mejor peso del nombre en entrenamiento y el campo de atributos no están establecidos en prueba.
- Frases: sin bonus por frase. Las posiciones sobre los nombres de producto son baratas de construir, pero el mejor bonus en entrenamiento no está establecido en prueba.
- Implementación: un índice hecho a mano para los experimentos, una biblioteca para el servicio. El índice hecho a mano permite que
k1ybcambien sin reconstruir nada, y bm25s precalcula las puntuaciones para que las búsquedas sean rápidas. Sobre las mismas consultas de prueba, la recuperación semántica con los embeddings registrados deSnowflake/snowflake-arctic-embed-m-v1.5obtiene 0.830 (capítulo 1). - Lo que mostró el capítulo: BM25 puede reconstruirse a mano y coincidir puntuación por puntuación. De las decisiones tomadas con las consultas de entrenamiento, solo el stemming se sostuvo en prueba, y aun así descansa en unas pocas consultas.
Este capítulo, en esta edición
Edición 2026.11.10Ejemplos verificados el 19 de nov de 2026Superan la prueba 13 de 13 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.10.