Recuperação lexical
Cerca de 42 minutos min de leitura, com 13 exemplos em 12 seções.
Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros
Traduzido do livro em inglês, edição 2026.11.10. Leia o original
Nesta página
- Divida o texto dos produtos em termos
- Construa um índice invertido
- Ponderar termos com TF-IDF
- Refaça o BM25 à mão para coincidir com o bm25s
- Radicalize termos para que as formas das palavras coincidam
- Verifique a radicalização nas consultas de teste
- Ajuste os parâmetros do BM25 nas consultas de treino
- Dê ao nome do produto mais peso do que à descrição
- Indexe atributos de produto como um campo
- Associe frases às posições dos termos
- O que dá errado em produção
- Decisões tomadas neste capítulo
Ao final deste capítulo, você será capaz de construir uma busca lexical do zero: transformar o texto dos produtos em termos, indexar os termos e pontuar os produtos com TF-IDF e BM25, obtendo a mesma pontuação da biblioteca bm25s em cada caso. Você também poderá decidir quais mudanças no processamento do texto e nos parâmetros do BM25 valem a pena manter, escolhendo-as com as consultas de treino e verificando-as nas consultas de teste.
Recuperação lexical encontra e ordena produtos pelas palavras que eles têm em comum com a consulta. Ela ordena os resultados quando um cliente pesquisa a loja de móveis e artigos para casa: o BM25, por meio da biblioteca bm25s. Quando um cliente digita 7qt slow cooker ou pool floats, os resultados do BM25 do capítulo 1 são fracos. Seu nDCG@10 médio nas consultas de teste, 0.725, mostra isso, mas não o porquê, pois o capítulo 1 o usou como caixa-preta, com os padrões da bm25s. Este capítulo abre a caixa. Você reconstrói cada etapa à mão sobre os 12,000 produtos da loja e a compara com a bm25s; em seguida, altera uma etapa de cada vez e mede cada mudança com os julgamentos da loja.
Cada mudança é escolhida com as 50 consultas de treino e verificada nas 30 consultas de teste. Antes de ler qualquer resultado de teste, o capítulo fixa as comparações planejadas nas consultas de teste. São cinco, cada uma contra a mesma busca sem a mudança:
- stemming
- os melhores
k1ebno treino, contra os padrões da bm25s (ajuste) - o melhor peso no treino para o nome do produto (campos)
- atributos do produto como campo (atributos)
- o melhor bônus de frase no treino (frases)
Com cinco comparações planejadas, a regra do livro fixa o limite em um valor-p de 0.01. Um ganho é estabelecido se o teste de permutação pareado der um valor-p abaixo desse limite. Cada comparação também relata o teste t pareado e um intervalo de bootstrap de 99%, e indica se cada um concorda com o teste de permutação.
Divida o texto dos produtos em termos
A busca nunca compara strings brutas. A consulta e o texto de cada produto passam primeiro pelas mesmas etapas. Dividir o texto em pedaços produz tokens. Passar tudo para minúsculas faz de Chair e chair um único token. Remover as palavras de parada, palavras muito comuns como the e with, deixa os termos que a busca compara, e todos os termos do catálogo formam o seu vocabulário. Um produto só pode casar com uma consulta pelos termos que os dois compartilham, então essas etapas decidem o que pode casar, antes de qualquer pontuação começar.
O bm25s, que executa o BM25 da loja, faz três escolhas aqui. Ele converte o texto para minúsculas. Mantém cada sequência de dois ou mais caracteres de palavra, isto é, letras, dígitos ou sublinhados, com a expressão regular (?u)\b\w\w+\b, que a sua docstring descreve como o mesmo método do CountVectorizer do scikit-learn. E remove 33 palavras de parada do inglês, entre elas no, not, with e for. Ele não faz stemming, a não ser que você lhe passe um stemmer (tokenizador do bm25s, palavras de parada). Para ver as etapas uma de cada vez, escreva-as à mão, confira o resultado com bm25s.tokenize em cada produto e rode a consulta de treino 7qt slow cooker por elas:
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
O número de produtos que o tokenizador escrito à mão e o bm25s dividem de forma diferente é 0, então o problema não está em nenhum dos dois, e sim nas regras que eles compartilham. Um comprador que digita 7qt slow cooker quer uma panela de 7 quartos, e 7qt sobrevive como um único token. Mas ele casa com 0 produtos, porque o texto dos produtos escreve o tamanho separado, como 7 qt em 8 produtos, e o tokenizador descarta o 7 de um caractere. Assim, o tamanho não entra na ordenação, de nenhum dos lados do casamento, e o BM25 não consegue distinguir uma panela de 7 quartos de qualquer outra panela de cozimento lento. Dos 9 produtos que os avaliadores marcaram como exatos para esta consulta, os 10 primeiros resultados do BM25 contêm 1.
Um padrão que mantém dígitos isolados e separa números de suas unidades, (?u)\d+|[^\W\d_]+, altera os termos de 4 consultas de treino e de 0 consultas de teste, então os julgamentos da loja dizem pouco sobre ele.
A lista de parada falha do mesmo modo, e o bm25s não emite nenhum erro. Tome rug not wool, uma consulta de sondagem: uma escrita para este capítulo para testar um comportamento, e não uma das consultas da loja. Ela se torna rug wool, de modo que um tapete de lã casa com os dois termos dela. Os julgamentos só podem medir esse dano nas consultas com negação, e 0 das consultas da loja contêm not ou no. Os sistemas de busca passaram de listas longas para listas curtas ou nenhuma, em parte porque palavras de parada carregam sentido em algumas consultas, e em parte porque mantê-las ficou barato (Manning et al., 2008).
Regra prática: Imprima os termos em que as suas consultas e os seus produtos se transformam antes de ajustar qualquer pontuação, e passe os dois pelo mesmo tokenizador. Comece pelos padrões do bm25s, como faz a loja. Quando os compradores digitarem tamanhos, quantidades ou números de modelo, use um padrão de tokens que mantenha dígitos isolados e separe um número de sua unidade, como o acima. Quando digitarem negações, desligue a lista de parada. Cada uma dessas é uma mudança na busca, então meça-a nas consultas de treino e confira-a nas consultas de teste antes de mantê-la.
Construa um índice invertido
Para pontuar uma consulta formada por esses termos, a busca precisa dos produtos que contêm cada um deles. Ler o texto de todos os produtos a cada consulta funciona para uma amostra pequena, mas não para um catálogo de milhões. Um índice invertido inverte a relação: para cada termo, ele guarda a lista de produtos que contêm o termo, chamada de postings do termo (Manning et al., 2008). Junto com cada produto, os postings armazenam a frequência do termo, isto é, o número de vezes que o termo aparece no texto desse produto. O número de produtos nos postings de um termo é a sua frequência de documentos: os mecanismos de busca chamam de documentos os itens que pesquisam, e neste livro eles são produtos. Uma consulta lê apenas os postings dos seus próprios termos.
O índice da loja associa cada termo a um dicionário de IDs de produtos e frequências de termo. Ele também guarda o tamanho de cada produto em termos, que o BM25 usa. A construção exige uma única passagem pelo texto de cada produto, usando o tokenizador da seção anterior. Em seguida, o código consulta os termos da consulta de treino 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
A loja tem 12,000 produtos, que usam um vocabulário de 20,393 terms termos, e o texto de um produto tem, em média, 50.3 terms termos. Cada par nos postings de cooker é um ID de produto e uma frequência de termo. O primeiro é o produto 1, a panela de cozimento lento de 7 qt da seção sobre o tokenizador.
Para 7qt slow cooker, os postings listam 157 produtos para slow, 141 para cooker e 0 para 7qt, e juntos eles cobrem 158 produtos. Esses são todos os que a pontuação desta consulta precisa ler. Os produtos que contêm os três termos somam 0, porque nenhum deles contém 7qt. Assim, uma consulta booleana AND, que retorna apenas os produtos que contêm todos os termos da consulta, não retorna nada para esta consulta. Uma busca que pontua todos os produtos que contêm qualquer um dos termos, como faz o BM25, ainda retorna panelas de cozimento lento e deixa para as pontuações decidirem quais vêm primeiro.
Regra prática: Quando os resultados de uma consulta parecerem errados, consulte os termos dela no índice antes de alterar a pontuação. Um termo sem postings, como 7qt, não pode ajudar nenhum produto, qualquer que seja o pontuador, então corrija o tokenizador ou a consulta. Para consultas que os clientes digitam, retorne produtos que contenham qualquer um dos termos, e não todos, pois uma única palavra sem correspondência esvaziaria os resultados. Atenda consultas a partir do índice de uma biblioteca, e mantenha um índice pequeno como este para verificar quais produtos cada termo encontra.
Ponderar termos com TF-IDF
Nem toda correspondência vale o mesmo. Duas ideias ponderam essas correspondências. Um termo que ocorre com frequência no texto de um produto tem maior probabilidade de ser o assunto do produto: essa é a sua frequência de termo, tf. E uma correspondência em um termo raro diz mais do que uma correspondência em um termo comum. Karen Spärck Jones propôs ponderar os termos pelo número de documentos que os contêm, de modo que "correspondências com termos menos frequentes, mais específicos, têm maior valor do que correspondências com termos frequentes" (Spärck Jones, 1972; reimpressão gratuita). Esse peso tornou-se a frequência inversa de documento, IDF: o logaritmo do número de produtos dividido pela frequência de documento do termo, alto para um termo raro e baixo para um termo comum (Manning et al., 2008). O TF-IDF multiplica tf e IDF para cada termo da consulta e soma os 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 é um termo comum nos produtos da loja. O TF-IDF baseia-se no índice invertido. O código mostra o IDF de furniture e de cada termo da consulta de treino laundry basket with wheels, depois os 3 primeiros resultados do TF-IDF para essa consulta, com o escore de cada produto e as frequências de termo. Por fim, ele calcula o escore de todas as 50 consultas de treino com o TF-IDF e com o BM25 como o capítulo 1 o executa:
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
O primeiro produto do TF-IDF é parcial, uma cesta que nunca diz wheels, mas repete basket mais do que qualquer um dos dois produtos abaixo dele. Os IDFs preparam esse resultado. furniture recebe 0.919, e os termos da consulta recebem 3.985 para laundry, 3.925 para basket e 4.839 para wheels: mais raros e próximos entre si. Com IDFs tão próximos, as repetições superam a ausência de wheels, como mostram os escores. O produto exato, o único dos três que diz wheels, fica em segundo. No TF-IDF, a frequência de termo não tem teto, então um produto pode superar outro ao repetir uma palavra.
Nas consultas de treino, o TF-IDF tem um nDCG@10 médio de 0.579, contra 0.695 do BM25, e o BM25 pontua mais alto em um número de consultas e mais baixo em outro, respectivamente, conforme 36, 10. O judged@10 do TF-IDF é 0.836, contra 0.930 do BM25; quando o judged@10 de uma execução é menor, parte da diferença pode vir de produtos que ninguém avaliou, e não de produtos piores. Essa comparação nas consultas de treino indica qual pontuador adotar como base, e o livro guarda suas evidências para as consultas de teste.
Regra prática: Pondere os termos por IDF em qualquer pontuador lexical, porque uma correspondência em um termo raro é uma evidência melhor. Não ordene os produtos pelo TF-IDF puro: limite o que um termo repetido pode acrescentar e corrija os textos longos, o que o BM25 faz. Mantenha o TF-IDF para explicar um ranking, em que você pode ler o tf e o idf de cada termo.
Refaça o BM25 à mão para coincidir com o bm25s
O BM25 mantém o IDF e muda a forma como a frequência do termo é contada, de duas maneiras. Com a saturação, cada repetição de um termo acrescenta menos do que a anterior, e nenhum número de repetições pode levar a contribuição do termo além de um teto (Robertson and Zaragoza, 2009). O parâmetro k1 define com que rapidez um termo se aproxima desse teto. Com a normalização pelo tamanho, um texto longo, que tem mais chances de conter qualquer termo, tem suas frequências de termos descontadas. O parâmetro b define o quanto: "b = 1 realiza a normalização completa pelo tamanho do documento, enquanto b = 0 desliga a normalização" (Robertson and Zaragoza). Na forma que o bm25s calcula por padrão (bm25s scoring):
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))
Duas particularidades diferem entre livros didáticos e bibliotecas. Uma variante comum multiplica a fração por k1 + 1, o que aumenta todas as pontuações pelo mesmo fator e, por isso, não altera o ranking (Robertson and Zaragoza, seção 3.5.1). E o IDF original de Robertson, sem o 1 dentro do logaritmo, é negativo para um termo presente em mais da metade dos documentos; por isso o Lucene, uma biblioteca de busca de código aberto, acrescenta o 1 (Kamphuis et al., 2020). O padrão do bm25s, method="lucene", é a fórmula do Lucene calculada com os tamanhos exatos dos documentos (bm25s README), enquanto o próprio Lucene aproxima esses tamanhos (Kamphuis et al.). "BM25" nomeia uma família dessas variantes, e um estudo de oito delas não encontrou diferenças significativas de eficácia em três coleções de notícias (Kamphuis et al.).
Escreva a fórmula sobre o índice invertido da loja, com os padrões do bm25s, k1=1.5 e b=0.75, e confira-a com o bm25s 0.3.16: primeiro a pontuação de cada produto para cada uma das 80 consultas, depois os dois rankings, pelos seus top 100 e pelo 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
A palavra your aparece em 6,135 dos 12,000 produtos. O IDF original de Robertson lhe atribui -0.045, e o do Lucene lhe atribui 0.671. Um IDF negativo faria a ocorrência de uma palavra diminuir a pontuação de um produto. Os pesos dos termos mostram a saturação: em um produto de tamanho médio, uma ocorrência de um termo rende 0.400 de seu IDF, e nove ocorrências rendem 0.857.
As pontuações coincidem. A maior diferença, considerando todos os produtos e consultas, é 1e-06, na precisão dos números float32 que o bm25s retorna. Pontuações iguais, porém, não definem um ranking por si sós: quando as pontuações empatam, a implementação ainda precisa escolher qual dos produtos empatados vem primeiro. A nossa ordena os empates pelo ID do produto. O mesmo faz o BM25 compartilhado do livro, lib.lexical do capítulo 1, que obtém a pontuação de cada produto do bm25s e depois ordena os empates pelo ID do produto. Perguntado se as duas dão o mesmo top 100 para todas as consultas, o exemplo responde yes.
Os rankings decorrem das pontuações. Nas consultas de treino, o nDCG@10 médio é 0.695 à mão e 0.695 com o bm25s; nas consultas de teste, 0.725 e 0.725.
Regra prática: Sirva o BM25 a partir de uma biblioteca como o bm25s, e mantenha uma versão pequena que você mesmo escreveu para conferi-la, pois a sua mostra de onde vem cada parte de uma pontuação. Compare duas implementações primeiro pelas pontuações e depois pelos rankings. Antes de comparar rankings, desempate da mesma forma nas duas, pelo ID do produto como faz o BM25 do livro, pois apenas produtos empatados podem fazer duas implementações corretas ordenarem de modo diferente. Quando dois sistemas BM25 ordenam de maneira diferente, compare seus tokenizers antes de suas fórmulas. O estudo sobre variantes manteve fixos a tokenização e as stop words, e observa que configurações mais banais, como a escolha das stop words, costumam causar diferenças maiores do que a fórmula (Kamphuis et al.).
Radicalize termos para que as formas das palavras coincidam
Um comprador digita pool floats, e um produto diz float ou floating. Para o tokenizador, são termos diferentes, então não coincidem. A radicalização corta terminações comuns das palavras, de modo que as formas de uma palavra compartilhem um único termo, o seu radical. Martin Porter projetou seu algoritmo de remoção de sufixos para recuperação de informação e, em seu teste, ele reduziu um vocabulário de 10,000 palavras para 6,370 radicais, uma redução de cerca de um terço (Porter, 1980). Sua página recomenda o seu sucessor, o radicalizador Snowball English ou Porter2 (Porter), que radicaliza um pouco mais de 5% das palavras de forma diferente (Snowball). A radicalização troca precisão por revocação. Ela aumenta a revocação, mas prejudica a precisão, e ajuda algumas consultas muito enquanto prejudica outras na mesma medida (Manning et al., 2008).
Um radicalizador simples cabe em poucas linhas. Escreva à mão um que corte -ing, -es, -ed ou -s quando restarem pelo menos três letras, e compare-o com o radicalizador Snowball English do PyStemmer, que o tokenizador do bm25s recomenda (tokenizador do bm25s) e que o livro fixa na versão 3.1.0 (PyStemmer). Depois conte os produtos cujo texto contém uma palavra e os que contêm o seu radical:
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%
O radicalizador escrito à mão concorda com o Snowball em todas as palavras, exceto moldings, em que ele para depois de cortar -s, enquanto as regras do Snowball continuam até mold. Ambos transformam shelves em shelv e deixam shelf como está: regras que cortam terminações não sabem que shelves é o plural de shelf.
As contagens mostram os dois lados da troca. floats aparece em 11 produtos, e o seu radical em 288, mas 244 desses dizem floating. As duas classes de produto mais comuns entre eles são as prateleiras de parede, com 57, e as mesas, com 36. Assim, o radical alcança prateleiras flutuantes assim como boias de piscina (pool floats), e só os julgamentos podem dizer qual efeito prevalece (próxima seção).
molding ocorre em 123, e o seu radical em 262, porque mold também representa molded, moldings e mold em si, uma palavra com mais de um significado. O vocabulário diminui em 25%, de 20,393 terms para 15,258 terms. O teste de Porter usou outro texto e um algoritmo anterior, por isso os números não se comparam diretamente.
Para servir o BM25 com radicalização a partir do bm25s, passe o mesmo stemmer para bm25s.tokenize tanto para os produtos quanto para cada consulta. Depois verifique se o bm25s, com o mesmo stemmer, pontua como o índice construído à mão com radicalização, InvertedIndex(text, stem=True) a partir de 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 torna-se pool e float, e a maior diferença de pontuação entre todos os produtos e consultas é 2e-06, o mesmo arredondamento de sem radicalização.
Regra prática: Radicalize o texto dos produtos e as consultas em inglês com o stemmer Snowball English, tanto na indexação quanto na consulta: no bm25s, passe stemmer= para bm25s.tokenize nos dois lados. Leia os produtos que um radical acrescenta, como fazem as contagens de floats, antes de confiar em um ganho. Quando um radical une palavras que seus compradores mantêm separadas, como molding e mold, mantenha uma lista de palavras que você não radicaliza. Para textos em outro idioma, use o radicalizador desse idioma.
Verifique a radicalização nas consultas de teste
Radicalização troca precisão por revocação, então só os julgamentos podem dizer se ela compensa para a loja. A decisão de radicalizar vem das 50 consultas de treino. Esta é a primeira das cinco comparações planejadas do capítulo, executada sobre as 30 consultas de teste. Em seguida, o índice com radicalização é comparado com o índice sem radicalização da seção sobre 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
Nas consultas de treino, a radicalização leva a média do nDCG@10 de 0.695 para 0.725, e o judged@10 de 0.930 para 0.950. O número de consultas de treino que melhoram e que pioram é 24, 14. pool floats passa de 0.360 para 0.921, e french molding de 0.961 para 0.809. Esses números de treino escolhem a radicalização. Eles não são evidência de que ela ajuda.
Nas consultas de teste, o ganho da radicalização é estabelecido no nível de 0.01, embora o teste t discorde (as comparações planejadas): a média do nDCG@10 vai de 0.725 para 0.774, com uma diferença média de 0.050. O judged@10 também sobe, de 0.927 para 0.950, então parte desse ganho pode vir de produtos que a execução sem radicalização deixou não julgados.
Uma consulta explica por que os dois testes divergem. A consulta 133, outdoor light fixtures, tem ganho de 0.635, e sem ela o ganho médio é 0.029. O teste t supõe que as diferenças são aproximadamente normais, então um ganho grande amplia a dispersão delas e reduz t; o teste de permutação não supõe nada sobre o formato delas (capítulo 3). Essa consulta é também aquela cujos dez primeiros resultados sem radicalização o capítulo 1 encontrou cheios de lâmpadas não julgadas.
Regra prática: Escolha uma mudança no processamento de texto usando as consultas de treino, e mantenha-a somente se sua comparação planejada estiver estabelecida. Quando o teste de permutação e o teste t divergirem, leia as maiores diferenças por consulta e informe, ao lado da média, o ganho sem a maior delas. A radicalização está estabelecida, então aplique-a ao construir buscas lexicais. O BM25 compartilhado do livro permanece sem radicalização, para que os resultados dos capítulos seguintes continuem comparáveis (decisões). Trate o tamanho do ganho como frágil.
Ajuste os parâmetros do BM25 nas consultas de treino
Os dois parâmetros do BM25 não têm um único valor correto, e as bibliotecas trazem padrões diferentes. O bm25s usa k1=1.5 e b=0.75 (código-fonte do bm25s). O Lucene usa k1=1.2 e b=0.75 (Lucene BM25Similarity). Kamphuis et al. (2020) informam k1=0.9 e b=0.4 como os padrões do Anserini, um toolkit de pesquisa. Robertson e Zaragoza (2009) oferecem uma regra prática, não uma medição: b entre 0.5 e 0.8 e k1 entre 1.2 e 2 são razoavelmente bons em muitas circunstâncias, mas os melhores valores dependem do tipo de documentos e consultas. Por isso, você os ajusta nas suas próprias consultas de treino e verifica o resultado nas consultas de teste.
O índice invertido armazena frequências de termos e tamanhos, não pontuações, então k1 e b podem mudar de uma busca para a seguinte sem que seja preciso reconstruí-lo. O bm25s calcula todas as pontuações ao construir seu índice (Lù, 2024), o que torna suas buscas rápidas, mas cada novo k1 ou b exige um novo índice. Uma varredura sobre o índice com stemming testa uma grade de 25 configurações nas 50 consultas de treino e escolhe a melhor. Em seguida, ela compara a melhor com os padrões nas 30 consultas de teste: a segunda comparação planejada, com o limiar de 0.01.
Antes de executar, faça uma previsão: com os padrões, o BM25 com stemming obtém 0.774 nas consultas de teste. Quanto a melhor configuração no treino acrescentará?
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
No treino, a grade inteira fica entre 0.707 e 0.729. A melhor configuração, k1 = 2.0 e b = 0.75, obtém 0.729, contra 0.725 com os padrões. O exemplo informa se ela está na borda da grade: yes. Uma grade mais ampla poderia encontrar uma pontuação de treino maior, mas, com a grade inteira tão concentrada em valores próximos, a mudança seria pequena.
O ajuste não mostra ganho estabelecido nas consultas de teste. A melhor configuração obtém 0.775 contra 0.774, com judged@10 de 0.953 e 0.950, e a diferença não é estabelecida (as comparações planejadas).
Se você previu um ganho de alguns centésimos, a grade de treino torna isso improvável. No treino, a melhor configuração supera os padrões em 0.004, e mesmo esse valor é uma estimativa otimista: entre todas as configurações, ela é a que por acaso se ajustou melhor a estas consultas, então, em outras consultas, você deve esperar menos.
Regra prática: Comece pelos padrões da biblioteca. Ajuste k1 e b nas consultas de treino quando você mudar o que indexa, como campos ou stemming, e mantenha uma configuração ajustada somente se a comparação planejada dela for estabelecida. A configuração ajustada da loja não é estabelecida, então a loja mantém k1=1.5 e b=0.75.
Dê ao nome do produto mais peso do que à descrição
O texto de um produto tem partes, chamadas campos: os campos de texto da loja são nome, classe, categoria e descrição. Eles não são evidências iguais. Uma palavra da consulta no nome diz mais sobre o que o produto é do que a mesma palavra em alguma descrição. Há duas formas de dar peso aos campos. A primeira que vem à mente pontua cada campo com BM25 e soma as pontuações. Robertson and Zaragoza (2009, seção 3.6) defendem a ordem oposta, "primeiro os fluxos, depois os termos": combine primeiro as frequências ponderadas de cada termo nos campos e, depois, sature a evidência total para aquele termo. Combinar as frequências ponderadas de um termo entre campos antes de saturar o total é o BM25F. A regra deles implica que somar pontuações por campo permite que um termo que casa em dois campos escape da saturação, porque cada campo satura por conta própria. Com pesos inteiros, o BM25F simples dá o mesmo resultado que o BM25 comum sobre um texto em que cada campo se repete tantas vezes quanto o seu peso (Robertson and Zaragoza, seção 3.6.4), então você pode testá-lo com qualquer biblioteca de BM25.
A busca da loja indexa um único campo, com nome, classe, categoria e descrição unidos. A primeira tentativa é a que vem à mente: nas 50 consultas de treino com stemming, o nome e os outros três campos são indexados separadamente, pontuados separadamente e somados. Indexados separadamente, cada campo também recebe seu próprio IDF e seu próprio comprimento médio, então isso muda mais do que a saturação. Pelo argumento de Robertson e Zaragoza, esperamos que isso se saia pior. Nas consultas de treino, o resultado orienta uma escolha e não prova 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
Pontuados separadamente, os campos dão um nDCG@10 de treino de 0.686 contra 0.725 para um campo, com judged@10 de 0.970 e 0.950. As consultas de treino que melhoram e que pioram são 15, 24. Isso basta para escolher um campo em vez deste desenho, e não basta para dizer por quê: saturação, IDF e normalização de comprimento mudaram todos ao mesmo tempo.
Uma segunda tentativa usa BM25F com pesos inteiros: o nome contado 1, 2, 3 ou 5 vezes no texto indexado. Ela escolhe o peso com a melhor pontuação de treino e o compara com um campo nas 30 consultas de teste: a terceira comparação planejada.
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
No treino, o melhor peso para o nome é 2, que pontua 0.734 contra 0.725 para um campo, com judged@10 de 0.968 e 0.950.
Repetir o nome não mostra ganho estabelecido no teste: o melhor peso para o nome pontua 0.786 contra 0.774, com judged@10 de 0.970 e 0.950, e o ganho não está estabelecido (as comparações planejadas). Nem o teste t nem o intervalo discorda.
Regra prática: Não some pontuações BM25 de campos separados. Para dar peso a um campo, combine as frequências dos termos antes da saturação, com BM25F ou repetindo o campo. Ajuste o peso nas consultas de treino e mantenha-o somente se a sua comparação planejada estiver estabelecida. Para a loja, fica um único campo combinado.
Indexe atributos de produto como um campo
Compradores costumam acrescentar um modificador, uma palavra que restringe o que desejam: uma cor, um material, um tamanho. Os julgamentos do WANDS marcam um produto como parcialmente relevante quando ele corresponde ao que foi pedido, mas não aos seus modificadores. Os nomes e as descrições dos produtos nem sempre informam um modificador, mas um catálogo costuma guardar fatos sobre um produto como atributos estruturados, como color: clear ou material: glass. Os produtos da loja trazem alguns deles do WANDS: cor, material, estilo, acabamento, forma, tamanho, largura, altura e profundidade (examples/data/wands/README.md). Indexados como mais um campo, os atributos dão a um modificador algo para corresponder. Eles também acrescentam termos a todo produto que os possui, por isso, se ajudam ou não, é uma questão a ser decidida pelos julgamentos.
No capítulo 1, os resultados do BM25 para clear shower curtain não conseguiam mostrar quais cortinas eram transparentes. O exemplo acrescenta os atributos de cada produto, seus nomes e valores, ao texto indexado, como um campo de peso 1, combinado antes da saturação, como a seção anterior recomenda. Ele conta os produtos exatos para essa consulta de teste que contêm clear, com e sem atributos. Ele mede esse único candidato, fixado de antemão, nas 50 consultas de treino e o verifica nas 30 consultas de teste: a quarta comparação planejada. Por estar planejada, ela segue para o teste qualquer que seja o resultado do treino.
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, os atributos fazem o que deveriam: 4 dos 12 produtos exatos contêm clear no texto, e 8 passam a contê-lo quando os atributos são contados, como a cortina de vinil cujos atributos dizem color: clear. Para essa consulta, o nDCG@10 vai de 0.714 para 0.844. Indexar os nomes dos atributos tem um custo, porém: size passa a corresponder aos 950 produtos cujos atributos informam um tamanho. A loja tem 1 consulta que contém um nome de atributo, a consulta de teste medium size chandelier, e ela vai de 0.731 para 0.667.
No treino, o judged@10 vai de 0.950 para 0.948, e o nDCG@10 vai de 0.725 para 0.717. No teste, o judged@10 vai de 0.950 para 0.963, e o nDCG@10 vai de 0.774 para 0.787, mas o teste de permutação não estabelece o ganho (as comparações planejadas).
Regra prática: Mantenha os atributos estruturados e leia as consultas que eles ajudam, mas não os acrescente ao texto do BM25 com base em poucas consultas. Indexe os valores sem os nomes, para que uma palavra da consulta como size não corresponda a todos os produtos que têm um tamanho, e mantenha o campo somente se sua comparação planejada for estabelecida. Para a loja, os atributos ficam fora do texto do BM25. Quando um modificador nomeia exatamente um valor de atributo, como uma cor, um filtro ou um recurso de ranqueamento pode usá-lo sem acrescentar suas palavras ao texto de todo produto.
Associe frases às posições dos termos
O BM25 pontua um saco de palavras: ele conta quais termos um produto contém e com que frequência, nunca a ordem deles. Para o BM25, barn door e door barn são a mesma consulta. Uma correspondência de frase exige que os termos estejam lado a lado e na ordem certa, e um índice de contagens não consegue verificar isso. Um índice posicional armazena, para cada termo e produto, as posições em que o termo ocorre, de modo que uma frase se torne uma verificação de posições (Manning et al., 2008). O bm25s pré-calcula uma pontuação para cada par de produto e termo (Lù, 2024). Seu índice não guarda posições (código-fonte do bm25s), então frases precisam de um índice próprio.
Um índice posicional sobre os nomes dos produtos da loja vem primeiro, com termos radicalizados como na seção sobre radicalização. As posições contam os termos depois que as palavras de parada são removidas, então door for laundry contém os termos adjacentes door e laundri: uma frase pode casar através de uma palavra de parada removida. Considere barn door, duas palavras de uma das consultas da loja: afirme que o BM25 não consegue distinguir as suas duas ordens, e conte os nomes que têm as duas palavras contra os que têm a 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
O BM25 dá a barn door e a door barn as mesmas pontuações, como o código afirma. Dos 71 nomes que contêm barn e door, 66 contêm a frase. Os nomes sem ela mostram o que uma verificação de frase captura e o que custa. Dois tapetes de porta e uma capa de edredom casam com as duas palavras, mas não são portas de celeiro, e um dos tapetes casa apenas porque barnes radicaliza para barn. O kit de ferragens de bypass, por outro lado, é ferragem para portas de celeiro, e a porta de box de vidro deslizante é uma porta em estilo celeiro. Um filtro de frase estrito removeria ambos.
Um bônus é mais suave que um filtro: um valor fixo somado à pontuação BM25 de um produto para cada par de termos adjacentes da consulta que aparece, na ordem, no seu nome. O exemplo de bônus usa PositionalIndex de lib.lexical_by_hand, que mantém as mesmas posições, e escolhe o bônus nas 50 consultas de treino, depois o verifica nas 30 consultas de teste: a última comparação planejada.
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
No treino, o melhor bônus é 0.5, que obtém 0.727 contra 0.725 sem ele, com judged@10 de 0.956 e 0.950.
O melhor bônus obtém 0.776 contra 0.774, com judged@10 de 0.950 e 0.950, e o ganho não está estabelecido (as comparações planejadas).
Regra prática: Não adicione um bônus de frase a todas as consultas por padrão, e mantenha um apenas se a sua comparação planejada estiver estabelecida. Construa as posições quando os compradores citarem frases, ou quando a ordem das palavras mudar o que eles querem, como entre table lamp e lamp table. Prefira um bônus medido nas consultas de treino a um filtro, porque um filtro remove produtos como o kit de ferragens.
O que dá errado em produção
O índice e as consultas se desalinham. Cada etapa, do tokenizador ao stemmer, precisa funcionar do mesmo modo nos produtos e nas consultas. Se você aplicar stemming às consultas, mas não aos produtos, um termo de consulta como shelv não encontra nenhum posting. Nada avisa você: o bm25s deixa de lado os tokens da consulta que não estão em seu vocabulário (código-fonte do bm25s). Altere o processamento de texto dos dois lados na mesma versão e reconstrua o índice inteiro.
Tamanhos, unidades e códigos não sobrevivem à tokenização. 7qt e 7 qt nunca se encontram, como mostra a seção sobre o tokenizador. A consulta de treino 205 termina em um código de produto, w003096809, que não aparece no texto de nenhum produto da amostra: seus postings contêm 0 produtos, de modo que nenhuma pontuação lexical consegue casar esse termo. Um termo com erro de digitação, como o ligth em ligth bulb, só pode casar com produtos que tenham o mesmo erro, e o capítulo 8 constrói um corretor e mostra o que ele ainda erra.
O IDF depende do catálogo. Todo IDF deste capítulo vem da amostra, que contém todos os produtos avaliados para as 80 consultas, além de outros não avaliados escolhidos ao acaso (examples/data/wands/README.md). No catálogo completo, as frequências de documentos são diferentes, e também os IDFs e as pontuações. Recalcule-os sempre que reconstruir o índice.
Uma pontuação BM25 não tem escala fixa. Cada termo da consulta soma no máximo o próprio IDF, de modo que a maior pontuação possível depende dos termos que a consulta contém, e uma pontuação de 6 pode ser alta para uma consulta e baixa para outra. Não mantenha resultados acima de um limite fixo de pontuação; corte a lista pela posição.
Palavras de parada e stemming mudam o sentido de algumas consultas. As consultas avaliadas da loja não têm negações, mas os clientes as digitam, e a lista de palavras de parada padrão remove not e no. O stemming prejudica gravemente algumas consultas, como mostra french molding na verificação de stemming. Os julgamentos não podem avisar sobre consultas que eles não incluem.
As consultas de teste se desgastam. Este capítulo faz cinco comparações planejadas sobre as mesmas consultas de teste, e o limiar de Bonferroni de 0.01 mantém a chance de qualquer falso positivo entre elas em 5% ou menos quando nenhuma das mudanças faz efeito. Ele não consegue contar o que ninguém planejou: cada configuração extra testada no conjunto de teste, e cada olhada em uma consulta de teste para explicar um resultado, é mais uma comparação. Confirme o ganho do stemming em consultas e julgamentos que nenhuma dessas escolhas tenha visto.
Regra prática: Mantenha um conjunto de consultas de sondagem para negações, tamanhos e códigos, e leia os resultados delas após cada mudança no processamento de texto. Guarde as configurações do tokenizador e do stemmer junto com o índice que elas construíram, registre os termos em que cada consulta se transforma, e fique atento a consultas cujos termos não têm postings.
Decisões tomadas neste capítulo
Cada configuração aqui foi escolhida com as consultas de treino. Antes de ler qualquer resultado de teste, o capítulo fixou cinco comparações planejadas nas consultas de teste, lidas com o arcabouço do capítulo 3: stemming e o campo de atributos como candidatos únicos, fixados de antemão, e a melhor configuração no treino para k1 e b, o peso do nome e o bônus de frase. O campo de atributos foi para o teste qualquer que fosse o resultado do treino, porque estava planejado. Só uma diferença estabelecida altera uma decisão. Cada coluna compara o nDCG@10 nas consultas de teste com a mudança contra a mesma busca sem ela, com o limiar de 0.01:
| Medida | Stemming | Melhores k1 e b |
Melhor peso do nome | Campo de atributos | Melhor bônus de frase |
|---|---|---|---|---|---|
| Diferença média | 0.050 | 0.001 | 0.012 | 0.013 | 0.002 |
| Intervalo de 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 da permutação | 0.005 | 0.757 | 0.149 | 0.303 | 0.758 |
| p do teste t | 0.037 | 0.754 | 0.153 | 0.281 | 0.769 |
| Vitórias, derrotas, empates | 16, 6, 8 | 7, 6, 17 | 15, 9, 6 | 8, 10, 12 | 6, 7, 17 |
| Estabelecido | yes | no | no | no | no |
| Teste t concorda | no | yes | yes | yes | yes |
| Intervalo concorda | yes | yes | yes | yes | yes |
- Tokenizer: os padrões do bm25s. Minúsculas, tokens de dois ou mais caracteres de palavra (letras, dígitos ou sublinhados) e suas 33 stop words em inglês, reconstruídas à mão e conferidas em cada produto. Elas perdem tamanhos de um dígito e negações. Poucas consultas julgadas poderiam medir qualquer um dos dois: um padrão sensível a tamanhos altera 4 consultas de treino e 0 consultas de teste, e 0 consultas contêm uma negação. Os padrões permanecem até que consultas-sonda ou novos julgamentos possam decidir.
- Stemming: Snowball English do PyStemmer, em produtos e consultas. Seu ganho no teste, de 0.725 para 0.774, é estabelecido pelo teste de permutação, embora o teste t discorde e uma consulta concentre grande parte dele. A linha de base compartilhada do livro,
lib.lexicaldo capítulo 1, permanece com os padrões do bm25s sem stemming, para que os resultados de todos os capítulos continuem comparáveis. O BM25 com stemming deste capítulo éInvertedIndex(text, stem=True)emlib.lexical_by_hand, ou o bm25s comstemmer=. - Pontuação: BM25 como o bm25s o calcula por padrão, a fórmula do Lucene com comprimentos exatos,
k1=1.5eb=0.75, com pontuações iguais ordenadas pelo ID do produto. A melhor configuração no treino não se estabelece no teste, então os padrões permanecem. - Campos: um único campo que une nome, classe, categoria e descrição. Somar pontuações por campo dá resultado mais baixo no treino. O melhor peso do nome no treino e o campo de atributos não se estabelecem no teste.
- Frases: sem bônus de frase. Posições sobre nomes de produtos são baratas de construir, mas o melhor bônus no treino não se estabelece no teste.
- Implementação: um índice feito à mão para experimentos, uma biblioteca para servir. O índice feito à mão permite que
k1ebmudem sem reconstrução, e o bm25s pré-calcula as pontuações para que as buscas sejam rápidas. Nas mesmas consultas de teste, a recuperação semântica com os embeddings registrados deSnowflake/snowflake-arctic-embed-m-v1.5obtém 0.830 (capítulo 1). - O que o capítulo mostrou: o BM25 pode ser reconstruído à mão e reproduzido pontuação por pontuação. Das escolhas feitas com as consultas de treino, só o stemming se sustentou no teste, e mesmo ele repousa em poucas consultas.
Este capítulo, nesta edição
Edição 2026.11.10Exemplos aprovados em 19 de nov de 202613 de 13 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.10.