Recuperação híbrida

Cerca de 45 minutos min de leitura, com 12 exemplos em 12 seções.

Edição 2026.11.10 Exemplos aprovados em 19 de nov de 2026 132 de 132 exemplos passam O que mudou

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

Ao final deste capítulo, você será capaz de combinar um ranking lexical e um semântico em um só, seja somando scores normalizados, seja por fusão de rank recíproco (reciprocal rank fusion), ajustar quanto cada ranking conta nas consultas de treino e decidir, com um teste pareado nas consultas de teste, se a combinação supera o melhor dos seus dois insumos.

A loja busca em seu catálogo de móveis e artigos para casa com dois recuperadores, e o capítulo 1 fundiu os dois em um único ranking. Essa fusão não superou a recuperação semântica isolada: nas consultas de teste, obteve 0.812 de nDCG@10, contra 0.830 da recuperação semântica, uma diferença que os testes do capítulo 3 também não permitem afirmar nem refutar. Por isso, a loja precisa saber se uma mistura melhor consegue superar a recuperação semântica, que é seu melhor ranqueador até agora e, portanto, o adversário a ser batido.

Assim, este capítulo pergunta primeiro se o BM25, a referência sem stemming do livro com os padrões do bm25s, e a recuperação semântica, com embeddings do modelo aberto Snowflake/snowflake-arctic-embed-m-v1.5, falham em consultas diferentes. Uma mistura só pode ajudar onde os dois falham de forma distinta, e por isso o capítulo então ajusta duas maneiras de combiná-los.

Sistemas de busca da indústria costumam combinar os dois. Um modelo semântico de busca de produtos foi construído "para complementar um mecanismo de busca lexical na recuperação ad hoc de produtos" (Nigam et al., 2019), e o mecanismo de busca de uma rede social usa recuperação por embeddings e correspondência de palavras-chave em conjunto para pontuar documentos (Huang et al., 2020).

A loja tem 50 consultas de treino para ajuste e 30 consultas de teste para relatório. Este capítulo encontra as consultas que cada recuperador vence e avalia cada um isoladamente. Em seguida, constrói duas misturas, formas de fundir um ranking lexical e um semântico com um peso que define quanto cada um conta, e ajusta esse peso. Toda análise e todo passo de ajuste são executados nas consultas de treino. O capítulo planeja duas comparações nas consultas de teste, feitas uma única vez, ao final: cada mistura ajustada, a soma ponderada e a fusão ponderada por rank recíproco, contra a recuperação semântica.

Descubra as consultas que cada recuperador vence

Última alteração na edição 2026.11.8

Recuperação híbrida combina os rankings de um recuperador lexical e de um recuperador semântico em um único ranking. Combinar rankings é chamado de fusão. A fusão só pode ajudar se os dois recuperadores falharem em consultas diferentes: se ambos colocarem produtos ruins no topo para uma consulta, nenhuma mistura dos rankings deles resolve o problema. Estudos publicados mostram que isso acontece. Embeddings deixam de encontrar entidades raras e palavras-chave seletivas que o BM25 encontra (capítulo 6), e em um conjunto de dados construído para testar os limites de um único embedding por texto, o BM25 encontra o que os embeddings não encontram, mas perde a maior parte da pontuação quando as palavras são substituídas por sinônimos (capítulo 1). Por isso, a primeira verificação deve ser feita por consulta, e não na média.

Avalie os dois recuperadores da loja pela nDCG@10 em cada consulta de treinamento, mantendo o top 100 de cada um.

bm25-semantic-wins-by-query.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Scores BM25 and semantic retrieval on each train query and counts the queries each one wins, ties included.The prose's point rests on the win counts and on the mean of the better score per query."""import numpy as npfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("train"), qrels("train")bm25 = LexicalSearch(products).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)bm25_scores, semantic_scores = evaluate(bm25, judgments)["ndcg@10"], evaluate(semantic, judgments)["ndcg@10"]print("train queries:", len(queries))print(f"bm25 ndcg@10: {bm25_scores.mean():.3f}")print(f"semantic ndcg@10: {semantic_scores.mean():.3f}")# rounded to 3 places, so differences that are float noise count as tieslead = (bm25_scores - semantic_scores).round(3)              # per train query; above 0 means BM25 winsprint("bm25 better:", (lead > 0).sum())print("semantic better:", (lead < 0).sum())print("tied:", (lead == 0).sum())print(f"better of the two, chosen per query: {np.maximum(bm25_scores, semantic_scores).mean():.3f}")has_digit = queries["query"].str.contains(r"\d")print("queries with a digit:", has_digit.sum())print("queries with a digit, bm25 better:", (lead[has_digit] > 0).sum())print()print("queries where bm25 leads by 0.1 or more:", (lead >= 0.1).sum())print(queries.loc[lead[lead >= 0.1].index, "query"].to_string())
Saídapython bm25-semantic-wins-by-query.py
train queries: 50
bm25 ndcg@10: 0.695
semantic ndcg@10: 0.772
bm25 better: 15
semantic better: 31
tied: 4
better of the two, chosen per query: 0.802
queries with a digit: 5
queries with a digit, bm25 better: 1

queries where bm25 leads by 0.1 or more: 6
query_id
44     chrome shower head and valve
146          laundry vanity cabinet
277             barstool patio sets
313                    malachi sled
359                  french molding
432            butcher block island

Nenhum dos recuperadores vence todas as consultas. A recuperação semântica tem média de 0.772 de nDCG@10, contra 0.695 do BM25, mas o BM25 ainda vence 15 consultas de treinamento contra 31 da recuperação semântica, e 4 empatam.

Se você pudesse escolher o melhor dos dois para cada consulta, a média seria 0.802. Esse não é um teto para a fusão, que mistura as listas em vez de escolher uma, mas mostra o que essas diferenças podem valer.

Em seguida, veja se as duas listas têm produtos diferentes e qual parcela dos produtos exatos de cada consulta (aqueles que os avaliadores classificaram como totalmente compatíveis) cada lista encontra:

overlap-and-union-recall.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Measures how much BM25's and semantic retrieval's top 10s overlap, and the share of each query's exact productsthat each list, and their union, holds at depths 100 and 20. The prose's point rests on the union's shares at both depths."""import numpy as npfrom lib.lexical import LexicalSearchfrom lib.metrics import recall_at_kfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("train"), qrels("train")bm25 = LexicalSearch(products).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)shared = [len(set(bm25[query_id][:10]) & set(semantic[query_id][:10])) for query_id in queries.index]print(f"products in both top 10s, mean: {np.mean(shared):.1f}")def share_retrieved(run):    """The share of each query's exact products that the run's list holds, averaged over queries."""    # k is the whole list, so this is the share of exact products (grade 2) anywhere in it    shares = [recall_at_k(ranking, judgments[query_id], k=len(ranking)) for query_id, ranking in run.items()]    return np.mean(shares)for depth in [100, 20]:    lists = {"bm25": {query_id: ranking[:depth] for query_id, ranking in bm25.items()},             "semantic": {query_id: ranking[:depth] for query_id, ranking in semantic.items()}}    # the union in first-seen order, without repeats    lists["union"] = {query_id: list(dict.fromkeys(lists["bm25"][query_id] + lists["semantic"][query_id]))                      for query_id in queries.index}    for name, run in lists.items():        print(f"{name} top {depth}, share of exact products retrieved: {share_retrieved(run):.3f}")
Saídapython overlap-and-union-recall.py
products in both top 10s, mean: 3.7
bm25 top 100, share of exact products retrieved: 0.672
semantic top 100, share of exact products retrieved: 0.759
union top 100, share of exact products retrieved: 0.810
bm25 top 20, share of exact products retrieved: 0.297
semantic top 20, share of exact products retrieved: 0.353
union top 20, share of exact products retrieved: 0.445

Os dois top 10 compartilham em média 3.7 produtos, então a maior parte de cada um está ausente do outro. A fusão não consegue ranquear um produto que nenhuma das listas contém, por isso a profundidade de cada lista limita o alcance da fusão. A união supera qualquer uma das listas nas duas profundidades:

Parcela de produtos exatos recuperados Top 20 Top 100
BM25 0.297 0.672
Recuperação semântica 0.353 0.759
União dos dois 0.445 0.810

Duas consultas de treinamento mostram os tipos de falha:

two-queries-two-winners.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Prints the top 5 products of BM25 and semantic retrieval for two train queries, with their judgments, and countsthe exact products in each top 10. The prose's point rests on those exact counts and on the two spellings of 7qt."""from lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, product_text, qrelsLABELS = {2: "exact", 1: "partial", 0: "irrelevant"}products, queries, judgments = load_products(), load_queries("train"), qrels("train")bm25 = LexicalSearch(products).run(queries, k=10)semantic = SemanticSearch().run(queries, k=10)text = product_text(products)# the size written as one token, `7qt`print("products containing 7qt:", text.str.contains(r"\b7qt\b", case=False).sum())# the size written apart, `7 qt`print("products containing 7 qt:", text.str.contains(r"\b7 qt\b", case=False).sum())for query_id in [432, 62]:                                   # butcher block island, 7qt slow cooker    query = queries.at[query_id, "query"]    for name, run in [("bm25", bm25), ("semantic", semantic)]:        # grade 2 is exact, 1 partial, 0 irrelevant; None for a product nobody judged        grades = [judgments[query_id].get(product_id) for product_id in run[query_id]]        print()        print(f"exact in {name} top 10 for {query}: {grades.count(2)}")        for product_id, grade in list(zip(run[query_id], grades))[:5]:            print(f"  {LABELS.get(grade, 'unjudged'):<10}  {products.at[product_id, 'name'][:55]}")
Saídapython two-queries-two-winners.py
products containing 7qt: 0
products containing 7 qt: 9

exact in bm25 top 10 for butcher block island: 9
  exact       carol kitchen island with butcher block top
  exact       brunton kitchen island with butcher block top
  partial     brunton kitchen cart butcher block top
  exact       janigian kitchen island with butcher block
  exact       avelar kitchen island with butcher block

exact in semantic top 10 for butcher block island: 3
  partial     boosblock® prep table with butcher block top
  partial     boosblock® butcher block
  partial     prep table
  partial     pro chef kitchen cart with butcher block top
  exact       brunton kitchen island with butcher block top

exact in bm25 top 10 for 7qt slow cooker: 1
  partial     cuisinart 6.5 quart programmable slow cooker
  partial     midea 6.5 qt . slow cooker
  partial     delonghi cks1660d livenza programmable 6 qt . slow cook
  partial     nesco 1.5 qt . analog slow cooker
  partial     360 cookware gourmet slow cooker

exact in semantic top 10 for 7qt slow cooker: 7
  exact       7-qt . stay or go slow cooker
  exact       crock-pot 7 qt . slow cooker
  exact       zing 7 qt . digital slow cooker
  exact       black + decker 7 qt . digital slow cooker
  exact       crock-pot 7 qt . slow cooker

Para butcher block island, o top 10 do BM25 traz 9 produtos exatos, contra 3 da recuperação semântica. O BM25 favorece produtos cujo texto contém as três palavras: ilhas de cozinha com tampo de butcher block. A recuperação semântica também coloca no topo mesas de preparo e carrinhos com tampo de butcher block, e os avaliadores classificaram esses como parciais: o material certo, mas não a ilha que a consulta pede.

No caso de 7qt slow cooker, é o contrário: o top 10 do BM25 traz 1 produtos exatos, e o da recuperação semântica, 7. O catálogo tem 0 produtos cujo texto contém 7qt, e 9 que contêm 7 qt, então o BM25 casa apenas slow cooker e ranqueia panelas de todos os tamanhos, enquanto a recuperação semântica coloca as panelas de 7 quartos no topo.

Esses são casos isolados: eles mostram um tipo de falha, não a sua frequência. A contagem por consulta lista as 6 consultas de treinamento em que o BM25 lidera por 0.1 ou mais de nDCG@10. A maioria nomeia um tipo específico de produto com duas ou mais palavras que precisam aparecer todas, e uma delas, malachi sled, nomeia uma linha de produtos.

O capítulo 1 encontrou o BM25 à frente em 2 das 2 consultas de teste que informam um tamanho em polegadas, porém, das 5 consultas de treinamento que contêm um dígito, o BM25 vence 1.

Regra prática: Antes de fundir, conte, por consulta, em quais consultas de treinamento cada recuperador vence, e verifique quantos produtos relevantes a união das listas contém que o melhor dos dois deixa de fora. Considere a fusão quando cada um vencer uma parcela real das consultas e a união contiver mais produtos relevantes do que qualquer uma das listas. Isso é necessário, mas não suficiente: em seguida, verifique cada recuperador isoladamente e teste a combinação ajustada em consultas reservadas antes de adotá-la.

Verifique cada recuperador antes de fundir

Última alteração na edição 2026.11.10

Saber onde cada recuperador vence não basta: a fusão dá a cada entrada voz no ranking final, inclusive a entrada fraca. Um estudo de busca híbrida em 11 conjuntos de dados encontrou um efeito de "elo mais fraco": um único recuperador fraco pode reduzir substancialmente a acurácia do resultado fundido, por isso cada um deve ser verificado antes da fusão (Wang et al., PVLDB 2026). Portanto, compare a média de nDCG@10 dos recuperadores, com judged@10 ao lado. Depois, compare-os consulta por consulta com um teste pareado: qual a probabilidade de uma diferença média tão grande ocorrer se os dois fossem igualmente bons? O teste do livro é o teste de permutação, com o teste t pareado ao lado.

Funda a recuperação BM25 e a semântica como o capítulo 1 fez, com fusão recíproca de ranking (RRF): cada produto recebe 1 / (60 + sua posição) em cada ranking, somados os dois, de modo que cada ranking tenha um voto igual. Em seguida, divida as consultas de treino por vencedor e compare a fusão com a recuperação semântica isoladamente:

fusion-gain-by-winning-retriever.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Compares BM25, semantic retrieval and their RRF fusion on the train queries, then splits the queries by whichretriever wins. The prose's point rests on the hybrid-minus-semantic lines, which give the net change, and on the meanchange within each winning group."""from lib.fusion import reciprocal_rank_fusionfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("train"), qrels("train")bm25 = LexicalSearch(products).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)hybrid = reciprocal_rank_fusion([bm25, semantic])           # k = 60 and equal votes, as in chapter 1bm25_scores, semantic_scores, hybrid_scores = (evaluate(run, judgments) for run in (bm25, semantic, hybrid))print(f"bm25 judged@10: {bm25_scores['judged@10'].mean():.3f}")print(f"semantic judged@10: {semantic_scores['judged@10'].mean():.3f}")for name, after, before in [("semantic minus bm25", semantic_scores, bm25_scores),                            ("hybrid minus semantic", hybrid_scores, semantic_scores)]:    result = compare(after["ndcg@10"], before["ndcg@10"])                    # paired by query    print(f"{name}, mean ndcg@10: {result['mean difference']:.3f}")    print(f"{name}, permutation p: {result['permutation p']:.3f}")    print(f"{name}, t-test p: {result['t-test p']:.3f}")print()# rounded to 3 places, so float noise can't make a query a win or a losschange = (hybrid_scores["ndcg@10"] - semantic_scores["ndcg@10"]).round(3)   # fusion against semantic alonelead = (bm25_scores["ndcg@10"] - semantic_scores["ndcg@10"]).round(3)       # above 0 means BM25 winsfor name, group in [("bm25 wins", lead > 0), ("semantic wins", lead < 0)]:    print(f"{name}, queries: {group.sum()}")    print(f"{name}, fusion better than semantic: {(change[group] > 0).sum()}")    print(f"{name}, fusion worse than semantic: {(change[group] < 0).sum()}")    print(f"{name}, mean change in ndcg@10: {change[group].mean():.3f}")
Saídapython fusion-gain-by-winning-retriever.py
bm25 judged@10: 0.930
semantic judged@10: 0.964
semantic minus bm25, mean ndcg@10: 0.077
semantic minus bm25, permutation p: 0.003
semantic minus bm25, t-test p: 0.004
hybrid minus semantic, mean ndcg@10: 0.002
hybrid minus semantic, permutation p: 0.863
hybrid minus semantic, t-test p: 0.872

bm25 wins, queries: 15
bm25 wins, fusion better than semantic: 12
bm25 wins, fusion worse than semantic: 2
bm25 wins, mean change in ndcg@10: 0.101
semantic wins, queries: 31
semantic wins, fusion better than semantic: 5
semantic wins, fusion worse than semantic: 25
semantic wins, mean change in ndcg@10: -0.045

O judged@10 do BM25 é 0.930 contra 0.964 da recuperação semântica, então os 10 primeiros do BM25 contêm alguns produtos a mais que ninguém avaliou, e o capítulo 2 mostra como eles podem reduzir uma pontuação. A recuperação semântica lidera por 0.077 de nDCG@10, com valor-p de permutação de 0.003 e valor-p do teste t de 0.004. Nas consultas de teste, o capítulo 3 estabelece a mesma vantagem. Portanto, a loja tem um recuperador forte e outro mais fraco.

Dividindo por vencedor, a fusão ajuda em média onde o BM25 vence e prejudica onde a recuperação semântica vence:

Consultas em que Consultas Fusão melhor que a semântica Fusão pior que a semântica Variação média de nDCG@10
BM25 vence 15 12 2 0.101
Recuperação semântica vence 31 5 25 -0.045

Agrupar as consultas pelo vencedor já embute esse padrão, já que quase qualquer mistura ajuda onde o BM25 vence e prejudica onde ele perde. O que importa é a variação líquida em todas as consultas de treino. A fusão difere da recuperação semântica em 0.002 de nDCG@10 em média, com valor-p de permutação de 0.863. Nessas consultas, votos iguais não produzem ganho mensurável.

A divisão usa os julgamentos para decidir qual recuperador vence, então ela diagnostica o padrão e não pode escolher um recuperador para uma consulta em produção, que não tem julgamentos.

Regra prática: Verifique cada recuperador isoladamente nas consultas de treino, com judged@10 e um teste pareado, antes de fundir. Quando um for mais fraco e vencer menos consultas, não lhe dê um voto igual: atribua-lhe peso e ajuste o peso, ou deixe-o de fora. Votos iguais convêm a dois recuperadores de qualidade aproximadamente igual.

Normalize os escores antes de somá-los

Última alteração na edição 2026.11.10

A maneira mais direta de dar ao recuperador mais fraco, o BM25 na loja, uma voz menor é somar os escores dos dois recuperadores com um peso: α vezes o escore semântico mais (1 − α) vezes o escore do BM25. Uma soma cujos pesos somam 1 é uma combinação convexa, ou soma ponderada. Ela só funciona se os escores estiverem em escalas comparáveis, e aqui não estão: um escore do BM25 não tem intervalo fixo e cresce com a quantidade e a raridade das palavras da consulta, enquanto o escore da recuperação semântica, uma similaridade de cosseno, fica entre −1 e 1. A normalização de escores redimensiona os escores de cada recuperador, para cada consulta, antes de somá-los. A normalização min-max por consulta leva o menor escore entre os produtos ranqueados da consulta para 0 e o maior para 1. Um estudo sobre funções de fusão a chama de "o método de fato na literatura" e testa duas alternativas (Bruch et al., 2023). O min-max teórico usa o menor valor possível de cada escore, em vez do menor observado: 0 para o BM25 e −1 para o cosseno. O z-score subtrai a média dos escores de uma consulta e divide pelo desvio padrão. O módulo compartilhado dos exemplos, lib/blend.py, escreve cada um em poucas linhas.

min-max(s) = (s − lowest score among the query's candidates) / (highest − lowest)
blend      = α · min-max(similarity) + (1 − α) · min-max(BM25)

A soma precisa dos dois escores para cada produto que ela ranqueia. O conjunto de candidatos de uma consulta é a união dos 100 primeiros do BM25 com os 100 primeiros da recuperação semântica, e lib.blend.candidates busca os dois escores de cada produto nele: o escore do BM25, 0 quando o produto não compartilha nenhuma palavra com a consulta, e a similaridade de cosseno.

Comece com os escores brutos da loja, somados com α = 0.5 nas consultas de treino, e depois faça o mesmo após a normalização min-max, escrita por extenso no exemplo e verificada contra lib.blend.weighted_sum:

raw-scores-versus-min-max.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Adds BM25 and cosine scores with equal weights, raw and after min-max scaling, and checks the scaled sum againstlib.blend.weighted_sum. The prose's point rests on the two sums' top 10 overlaps and nDCG@10, and on the count oftrain queries where the by-hand ranking matches the library's."""from lib.blend import candidates, weighted_sumfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("train"), qrels("train")lexical, semantic = LexicalSearch(products), SemanticSearch()tables = candidates(lexical, semantic, queries)              # both scores for each query's candidates# the candidate tables are keyed by query_idtable = tables[36]                                           # laundry basket with wheelsprint("candidates for laundry basket with wheels:", len(table))print(f"bm25 range: {table['bm25'].min():.3f} to {table['bm25'].max():.3f}")print(f"similarity range: {table['similarity'].min():.3f} to {table['similarity'].max():.3f}")def min_max(scores):    return (scores - scores.min()) / (scores.max() - scores.min())def blend(normalize, alpha=0.5):    run = {}    for query_id, table in tables.items():        score = alpha * normalize(table["similarity"]) + (1 - alpha) * normalize(table["bm25"])        # the top 100; the stable sort keeps the candidates' order on equal scores        run[query_id] = list(score.sort_values(ascending=False, kind="stable").index[:100])    return runtop_10s = {"bm25": lexical.run(queries, k=10), "semantic": semantic.run(queries, k=10)}per_query = {}for name, normalize in [("raw", lambda scores: scores), ("min-max", min_max)]:    run = blend(normalize)    per_query[name] = evaluate(run, judgments)["ndcg@10"]    print(f"{name} sum ndcg@10: {per_query[name].mean():.3f}")    for other, top in top_10s.items():        shared = [len(set(run[query_id][:10]) & set(top[query_id])) for query_id in queries.index]        print(f"{name} sum, products shared with the {other} top 10: {sum(shared) / len(shared):.1f}")# the library sorts equal scores by product_id; this blend keeps the candidates' orderby_hand, library = blend(min_max), weighted_sum(tables, 0.5)matches = sum(by_hand[query_id] == library[query_id] for query_id in tables)print(f"train queries ranked as lib.blend.weighted_sum ranks them: {matches} of {len(tables)}")p_value = compare(per_query["min-max"], per_query["raw"])["permutation p"]          # a tuning check on trainprint("min-max minus raw, permutation p:", "below 0.001" if p_value < 0.001 else f"{p_value:.3f}")
Saídapython raw-scores-versus-min-max.py
candidates for laundry basket with wheels: 125
bm25 range: 2.059 to 8.229
similarity range: 0.336 to 0.597
raw sum ndcg@10: 0.706
raw sum, products shared with the bm25 top 10: 9.6
raw sum, products shared with the semantic top 10: 3.9
min-max sum ndcg@10: 0.771
min-max sum, products shared with the bm25 top 10: 6.5
min-max sum, products shared with the semantic top 10: 6.2
train queries ranked as lib.blend.weighted_sum ranks them: 50 of 50
min-max minus raw, permutation p: below 0.001

Para laundry basket with wheels, os 125 candidatos têm escores do BM25 entre 2.059 to 8.229 e similaridades entre 0.336 to 0.597. A amplitude do BM25 é muitas vezes maior, então ele decide a ordem da soma bruta. Nas consultas de treino, o top 10 da soma bruta compartilha em média 9.6 produtos com o top 10 do BM25 e 3.9 com o da recuperação semântica.

O peso diz "metade para cada um", mas o ranking é em grande parte do BM25: o nDCG@10 da soma bruta, 0.706, fica próximo do BM25, 0.695.

Depois da normalização min-max, os dois recuperadores têm voz. O top 10 da soma normalizada compartilha 6.5 produtos com o do BM25 e 6.2 com o da recuperação semântica, e seu nDCG@10 sobe para 0.771. O valor-p de permutação para essa diferença em relação à soma bruta é below 0.001. A versão feita à mão ranqueia 50 of 50 consultas de treino exatamente como lib.blend.weighted_sum faz.

Escores brutos podem funcionar com um peso ajustado. Os autores do DPR, um recuperador baseado em embeddings, ranquearam os candidatos por BM25 mais 1.1 vez a similaridade do DPR, com o 1.1 escolhido em um conjunto de desenvolvimento (Karpukhin et al., 2020). A normalização dá a α o mesmo significado em todas as consultas; sem ela, a participação do BM25 muda com a amplitude dele de consulta para consulta. O min-max, porém, não é uma escala absoluta: é relativo aos candidatos da consulta, de modo que o melhor candidato sempre recebe 1, por pior que seja.

Regra prática: Nunca some escores brutos de BM25 e cosseno com um peso estimado no palpite. Recomendamos o min-max por consulta como padrão, porque ele não exige conhecimento de nenhuma das duas funções de pontuação. Use o min-max teórico quando você souber o menor valor possível de cada escore e quiser um piso que não se mova com os candidatos. Em qualquer caso, ajuste α nas consultas de treino.

Teste as configurações da fusão recíproca de ranks nas consultas de treino

Última alteração na edição 2026.11.8

Os ranks, diferentemente das pontuações, compartilham uma mesma escala, de modo que fundir por rank não exige normalização. A fusão recíproca de ranks (RRF) atribui a cada produto uma pontuação somando, sobre os rankings que o contêm, 1 dividido pela soma de uma constante k e de seu rank (Cormack et al., 2009), como escreve a fórmula do capítulo 1. O preço é a informação: "porque o RRF é uma função dos ranks, ele desconsidera a distribuição das pontuações e, por isso, descarta informação útil" (Bruch et al., 2023). Um produto logo atrás do líder e outro muito atrás dele recebem pontuações definidas apenas por seus ranks.

A constante k define o quanto os ranks mais altos dominam. O capítulo 1 adotou k = 60 a partir dos autores do RRF, que constataram, em um estudo piloto, que 60 ficava próximo do melhor valor e que a escolha exata pouco importava. Seus pilotos fundiram 30 configurações do Wumpus Search, um mecanismo de busca, em coleções do TREC, uma série de avaliações compartilhadas de recuperação (Cormack et al., 2009). Bruch et al. fundiram um recuperador lexical e um semântico, atribuíram a cada um sua própria constante, η, e constataram que os resultados são sensíveis ao equilíbrio entre as constantes, que funciona como um peso: "quando o modelo semântico já tem bom desempenho, por exemplo, reduzir o peso do sistema lexical ao aumentar η_Lex leva a um desempenho melhor". Um único k compartilhado pelas duas listas, como na loja, não define equilíbrio algum entre eles.

A profundidade de cada lista também importa. Um produto que está entre os 20 primeiros de um recuperador, mas não do outro, não recebe nada da segunda lista, mesmo que tenha um rank baixo ali. Como dizem Bruch et al., "os ranks não podem ser calculados exatamente, a menos que toda a coleção D seja ranqueada pelo sistema de recuperação o para cada consulta." Nas consultas de treino da loja, a união de duas listas dos 20 primeiros contém muito menos produtos exatos do que a união de duas listas dos 100 primeiros, como mostram as proporções de produtos exatos em cada lista.

Teste seis valores de k nas consultas de treino, fundindo listas de profundidade 100. Antes de executar, está planejada uma verificação: o melhor k supera o padrão, k = 60?

rrf-k-on-train.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Fuses BM25 and semantic retrieval with six values of k on the train queries, and tests the best k against thedefault k = 60. The prose's point rests on the rank ratios at k = 1 and k = 60, on the best k, and on its permutationp-value."""from lib.fusion import reciprocal_rank_fusionfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("train"), qrels("train")bm25 = LexicalSearch(products).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)# RRF gives rank r the score 1 / (k + r), so rank 1 over rank 10 is (k + 10) / (k + 1)for k in [1, 60]:    print(f"rank 1 over rank 10 at k={k}: {(1 / (k + 1)) / (1 / (k + 10)):.3f}")scores = {k: evaluate(reciprocal_rank_fusion([bm25, semantic], k=k), judgments)["ndcg@10"]          for k in [1, 10, 30, 60, 100, 300]}for k, per_query in scores.items():    print(f"k={k} ndcg@10: {per_query.mean():.3f}")best = max(scores, key=lambda k: scores[k].mean())           # ties go to the smaller kprint("best k on train:", best)result = compare(scores[best], scores[60])                     # the planned check: best k against the defaultprint(f"best k minus k=60: {result['mean difference']:.3f}")print(f"best k minus k=60, permutation p: {result['permutation p']:.3f}")print(f"best k minus k=60, t-test p: {result['t-test p']:.3f}")print(f"best k minus k=60, 95% interval: {result['ci low']:.3f} to {result['ci high']:.3f}")print(f"best k minus k=60, wins, losses, ties: {result['wins']}, {result['losses']}, {result['ties']}")
Saídapython rrf-k-on-train.py
rank 1 over rank 10 at k=1: 5.500
rank 1 over rank 10 at k=60: 1.148
k=1 ndcg@10: 0.753
k=10 ndcg@10: 0.770
k=30 ndcg@10: 0.771
k=60 ndcg@10: 0.774
k=100 ndcg@10: 0.778
k=300 ndcg@10: 0.777
best k on train: 100
best k minus k=60: 0.004
best k minus k=60, permutation p: 0.093
best k minus k=60, t-test p: 0.103
best k minus k=60, 95% interval: 0.001 to 0.011
best k minus k=60, wins, losses, ties: 6, 3, 41

Com k = 1, o rank 1 recebe 5.500 vezes o que recebe o rank 10. Com k = 60, ele recebe 1.148 vezes o que recebe o rank 10, de modo que um produto próximo do topo das duas listas supera um produto no topo de apenas uma. De k = 1 a k = 300, as seis configurações obtêm 0.753, 0.770, 0.771, 0.774, 0.778 e 0.777.

A melhor configuração no treino, k = 100, supera k = 60 em 0.004, com valor p de 0.093 no teste de permutação e valor p de 0.103 no teste t. O livro baseia seu veredito no teste de permutação, que não consegue distinguir esse ganho do acaso a 0.05. O intervalo bootstrap de 95% do ganho, 0.001 to 0.011, não inclui 0, de modo que o intervalo discorda dos dois testes.

Os rankings das duas configurações diferem em apenas um punhado de consultas (vitórias, derrotas e empates: 6, 3, 41). Qual k é o melhor também é frágil: com os produtos empatados do BM25 listados na ordem inversa, k = 300 vence em seu lugar. Isso se encaixa na constatação de Cormack et al. de que a escolha de k pouco importa.

Regra prática: Mantenha k = 60 como padrão e funda listas com profundidade de pelo menos 100, porque uma lista mais profunda só pode acrescentar candidatos. Afaste-se de k = 60 apenas quando o melhor k no treino o superar por uma margem que o teste de permutação consiga distinguir do acaso, com p abaixo de 0.05. Quando um dos recuperadores é o mais forte, como na loja, k não é a configuração a ser alterada: o que deve ser alterado é o voto igual do RRF. Atribua pesos às listas e ajuste-os.

Ajuste do peso da combinação nas consultas de treino

Última alteração na edição 2026.11.8

As duas combinações do capítulo recebem, cada uma, um peso, α, que é a parcela atribuída à recuperação semântica. Na soma ponderada, α multiplica a similaridade normalizada e 1 − α multiplica a pontuação BM25 normalizada. No RRF ponderado, um produto recebe (1 − α) / (k + sua posição no BM25) mais α / (k + sua posição na recuperação semântica). Nos dois casos, α = 0 corresponde somente ao BM25 e α = 1 corresponde somente à recuperação semântica. No caso do RRF, α = 0.5 equivale à fusão não ponderada do capítulo 1 com todas as pontuações reduzidas à metade. Veja a aritmética para o produto principal de uma consulta de treino, com α = 0.75 apenas como ilustração:

weighted-rrf-one-product.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Scores every candidate for one train query by weighted RRF, by hand, and checks the ranking againstlib.blend.weighted_rrf. The prose's point rests on the top product's two ranks and its score, and on the count ofplaces that match the library."""from lib.blend import weighted_rrffrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queriesalpha, k = 0.75, 60                                          # an illustrative weight; tuning picks one on trainproducts, queries = load_products(), load_queries("train")bm25 = LexicalSearch(products).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)query_id = 36                                                # laundry basket with wheelsdef part(ranking, weight, product_id):    """weight / (k + rank) from one ranking, or 0 when the product isn't in it."""    # index counts from 0, so one is added to get the rank    return weight / (k + ranking.index(product_id) + 1) if product_id in ranking else 0.0candidates = dict.fromkeys(bm25[query_id] + semantic[query_id])   # the union, in the order first seenscore = {product_id: part(bm25[query_id], 1 - alpha, product_id) + part(semantic[query_id], alpha, product_id)         for product_id in candidates}ranking = sorted(score, key=lambda product_id: (-score[product_id], product_id))   # ties by product_idfirst = ranking[0]print("first product:", products.at[first, "name"])print("its bm25 rank:", bm25[query_id].index(first) + 1)print("its semantic rank:", semantic[query_id].index(first) + 1)print(f"its weighted rrf score: {score[first]:.5f}")library = weighted_rrf(bm25, semantic, alpha)[query_id]          # the top 100matches = sum(mine == theirs for mine, theirs in zip(ranking, library))print(f"places that match lib.blend.weighted_rrf: {matches} of {len(library)}")
Saídapython weighted-rrf-one-product.py
first product: laundry sorter basket on wheels
its bm25 rank: 1
its semantic rank: 2
its weighted rrf score: 0.01620
places that match lib.blend.weighted_rrf: 100 of 100

Para laundry basket with wheels, o produto principal, laundry sorter basket on wheels, ocupa a posição 1 no ranking do BM25 e a posição 2 na recuperação semântica, então pontua 0.25 / (60 + 1) + 0.75 / (60 + 2) = 0.01620.

O exemplo pontua cada candidato dessa forma, e o ranking resultante coincide com lib.blend.weighted_rrf em 100 of 100 posições.

O ajuste testa uma grade de valores de α nas consultas de treino e mantém o que tiver a maior média de nDCG@10. Bruch et al. (2023) relatam três achados sobre o ajuste de uma combinação convexa, CC: que uma CC ajustada tem desempenho praticamente igual, qualquer que seja a normalização de pontuações usada; que ela supera o RRF tanto dentro do domínio quanto fora dele; e que é eficiente em amostras. Eficiente em amostras significa que α convergiu "com menos de 5% dos dados de treino", uma fração de conjuntos de treino bem maiores que os da loja.

Ajuste α em 0, 0.1, … 1 para a soma ponderada sob cada uma de as três normalizações, e para o RRF ponderado com k = 60. Depois, como verificações do ajuste, teste cada normalização contra a min-max, e teste as duas combinações destinadas às consultas de teste contra a recuperação semântica:

tune-blend-weights-on-train.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Tunes α on the train queries for the weighted sum under three normalizations and for weighted RRF, then comparesthe two blends that go to test with semantic retrieval. The prose's point rests on each setting's best α and nDCG@10,on the p-values against tuned min-max, and on the two gains over semantic retrieval."""from lib.blend import ALPHAS, NORMALIZATIONS, best_alpha, candidates, scores_by_alpha, weighted_rrf, weighted_sumfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("train"), qrels("train")lexical, semantic = LexicalSearch(products), SemanticSearch()tables = candidates(lexical, semantic, queries)bm25, semantic_run = lexical.run(queries, k=100), semantic.run(queries, k=100)per_query = {}                                               # nDCG@10 per query (rows) and alpha (columns)for name in NORMALIZATIONS:    per_query[name] = scores_by_alpha(lambda alpha: weighted_sum(tables, alpha, name), judgments)per_query["weighted rrf"] = scores_by_alpha(lambda alpha: weighted_rrf(bm25, semantic_run, alpha), judgments)semantic_alone = per_query["min-max"][1.0]                   # alpha = 1 is semantic retrieval in either blendprint("alphas tried:", len(ALPHAS))print("min-max ndcg@10 for alpha 0 to 1:", " ".join(f"{mean:.3f}" for mean in per_query["min-max"].mean()))print(f"semantic alone ndcg@10: {semantic_alone.mean():.3f}")# alpha 0.5 is unweighted RRF, chapter 1's fusionprint(f"unweighted rrf (alpha 0.5) ndcg@10: {per_query['weighted rrf'][0.5].mean():.3f}")best = {name: frame[best_alpha(frame)] for name, frame in per_query.items()}for name, frame in per_query.items():    print(f"{name} best alpha: {best_alpha(frame)}")    print(f"{name} best ndcg@10: {best[name].mean():.3f}")for name in ["theoretical min-max", "z-score", "weighted rrf"]:          # each tuned, against tuned min-max    print(f"{name} against min-max, permutation p: {compare(best[name], best['min-max'])['permutation p']:.3f}")for name in ["min-max", "weighted rrf"]:                                 # the two blends that go to test    gain = compare(best[name], semantic_alone)    print(f"{name} gain over semantic: {gain['mean difference']:.3f}")    print(f"{name} gain over semantic, permutation p: {gain['permutation p']:.3f}")    print(f"{name} gain over semantic, t-test p: {gain['t-test p']:.3f}")
Saídapython tune-blend-weights-on-train.py
alphas tried: 11
min-max ndcg@10 for alpha 0 to 1: 0.695 0.709 0.736 0.746 0.758 0.771 0.781 0.784 0.777 0.778 0.772
semantic alone ndcg@10: 0.772
unweighted rrf (alpha 0.5) ndcg@10: 0.774
min-max best alpha: 0.7
min-max best ndcg@10: 0.784
theoretical min-max best alpha: 0.9
theoretical min-max best ndcg@10: 0.789
z-score best alpha: 0.7
z-score best ndcg@10: 0.787
weighted rrf best alpha: 0.6
weighted rrf best ndcg@10: 0.787
theoretical min-max against min-max, permutation p: 0.164
z-score against min-max, permutation p: 0.349
weighted rrf against min-max, permutation p: 0.776
min-max gain over semantic: 0.013
min-max gain over semantic, permutation p: 0.177
min-max gain over semantic, t-test p: 0.161
weighted rrf gain over semantic: 0.015
weighted rrf gain over semantic, permutation p: 0.215
weighted rrf gain over semantic, t-test p: 0.205

A recuperação semântica sozinha obtém 0.772 nas mesmas consultas. Estes são o melhor α e a melhor pontuação de cada configuração:

Configuração Melhor α Média de nDCG@10 Valor p de permutação em relação à min-max ajustada
Soma ponderada, min-max 0.7 0.784 —
Soma ponderada, min-max teórica 0.9 0.789 0.164
Soma ponderada, z-score 0.7 0.787 0.349
RRF ponderado, k = 60 0.6 0.787 0.776

Ao nível de 0.05, o teste nas consultas de treino não consegue distinguir nenhuma das normalizações alternativas da min-max, o que está de acordo com o achado de Bruch et al. de que a normalização pouco importa. Também não consegue distinguir o RRF ponderado da min-max ajustada. O segundo achado de Bruch et al., de que a soma ponderada supera o RRF, não aparece aqui, e essas consultas não permitem resolver a questão.

Toda combinação ajustada obtém pelo menos o mesmo resultado que a recuperação semântica nas consultas de treino, já que α = 1 está na grade. Ainda assim, mesmo nas consultas que as escolheram, o teste de permutação não consegue distinguir o ganho de cada combinação do acaso, ao nível de 0.05. A soma ponderada ganha 0.013, com valor p de permutação de 0.177, e o RRF ponderado ganha 0.015, com 0.215. Cada ganho é, além disso, o melhor de 11 tentativas sobre as mesmas consultas, o que o favorece ainda mais.

Regra prática: Ajuste um único peso nas consultas de treino sobre uma grade grosseira, e mantenha a normalização em min-max, a menos que outra supere a min-max por uma margem que o teste nas consultas de treino consiga distinguir do acaso, com p abaixo de 0.05. Trate o ganho no treino sobre o melhor recuperador isolado como otimista, e espere que ele diminua nas consultas de teste, o que vale para qualquer configuração escolhida como a melhor entre várias. Antes de confiar na configuração, verifique se ela é estável, e só então reporte-a nas consultas de teste.

Verifique se o peso ajustado é estável

Última alteração na edição 2026.11.10

Os pesos ajustados vêm de algumas dezenas de consultas, por isso podem depender de quais consultas você tinha. O bootstrap mostra o quanto: reamostre as consultas de treino, ajuste α em cada amostra e repita muitas vezes. Se o α escolhido oscila muito, o valor ajustado reflete mais a amostra do que a loja. O Capítulo 3 usa a mesma reamostragem para colocar intervalos em torno das pontuações.

Reamostre as consultas de treino 1000 vezes com uma semente fixa e conte com que frequência cada α vence para as duas combinações ajustadas, a soma ponderada das pontuações min-max e o RRF ponderado, nas mesmas reamostragens:

blend-weight-bootstrap.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Resamples the train queries with a fixed seed and counts which α wins each resample, for the weighted sum and forweighted RRF on the same resamples. The prose's point rests on the α tuned on all train queries and on the counts ofresamples choosing each α."""import numpy as npimport pandas as pdfrom lib.blend import best_alpha, candidates, scores_by_alpha, weighted_rrf, weighted_sumfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("train"), qrels("train")lexical, semantic = LexicalSearch(products), SemanticSearch()tables = candidates(lexical, semantic, queries)bm25, semantic_run = lexical.run(queries, k=100), semantic.run(queries, k=100)blends = {"weighted sum": scores_by_alpha(lambda alpha: weighted_sum(tables, alpha), judgments),          "weighted rrf": scores_by_alpha(lambda alpha: weighted_rrf(bm25, semantic_run, alpha), judgments)}resamples = 1000print("resamples:", resamples)# a fixed seed, so every run draws the same resamplesrng = np.random.default_rng(2026)draws = [rng.integers(0, len(queries), len(queries)) for _ in range(resamples)]   # the same draws for bothfor name, per_query in blends.items():                       # per_query: train queries x alphas    print(f"{name} alpha tuned on all train queries: {best_alpha(per_query)}")    # best alpha per resample; idxmax takes the first, smaller alpha when two tie    chosen = pd.Series([per_query.iloc[draw].mean().idxmax() for draw in draws])    for alpha, count in chosen.value_counts().sort_index().items():        print(f"{name} resamples choosing alpha {alpha}: {count}")
Saídapython blend-weight-bootstrap.py
resamples: 1000
weighted sum alpha tuned on all train queries: 0.7
weighted sum resamples choosing alpha 0.5: 13
weighted sum resamples choosing alpha 0.6: 171
weighted sum resamples choosing alpha 0.7: 686
weighted sum resamples choosing alpha 0.8: 11
weighted sum resamples choosing alpha 0.9: 74
weighted sum resamples choosing alpha 1.0: 45
weighted rrf alpha tuned on all train queries: 0.6
weighted rrf resamples choosing alpha 0.5: 2
weighted rrf resamples choosing alpha 0.6: 513
weighted rrf resamples choosing alpha 0.7: 76
weighted rrf resamples choosing alpha 0.8: 365
weighted rrf resamples choosing alpha 0.9: 26
weighted rrf resamples choosing alpha 1.0: 18

O peso da soma ponderada se sustenta. Com todas as consultas de treino, seu α é 0.7, e α = 0.7 vence em 686 reamostragens, mais do que qualquer outra escolha. α = 0.6 vence em 171 reamostragens, e a recuperação semântica isolada, α = 1, vence em 45.

O RRF ponderado, ajustado em α = 0.6, está menos definido: seu peso oscila entre 0.6 e 0.8, com α = 0.6 vencendo em 513 reamostragens, α = 0.8 vencendo em 365 e α = 0.7 vencendo em 76.

Os dois pesos ficam do lado da grade que favorece a recuperação semântica, exceto pelo peso igual, α = 0.5, que vence em 13 reamostragens para a soma ponderada e em 2 para o RRF ponderado.

A reamostragem não é a única verificação. Produtos com pontuações BM25 iguais precisam de alguma ordem, e lib.lexical os lista por product_id, uma ordem que não carrega informação. A ordem decrescente por product_id também não carrega nenhuma. A soma ponderada dá aos produtos empatados o mesmo termo BM25, então a ordem deles quase não importa para ela, mas o RRF dá a eles posições consecutivas e, portanto, pontuações diferentes. Liste os empates do BM25 por product_id em ordem decrescente e ajuste novamente, nas consultas de treino, o melhor k do RRF e os dois pesos:

tuning-with-ties-reversed.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Tunes RRF's k and both blends' α again with BM25's equal scores listed in descending product_id order, to testwhether the order of ties matters. The prose's point rests on each setting's pair of lines, ties by product_id andties reversed."""import numpy as npfrom lib.blend import best_alpha, candidates, scores_by_alpha, weighted_rrf, weighted_sumfrom lib.fusion import reciprocal_rank_fusionfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsclass TiesReversed(LexicalSearch):    """BM25 with equal scores in descending product_id order, an order as arbitrary as ascending."""    def search(self, query, k=100):        scores = super().search(query, k=len(self.ids))           # every match, so the cut at k can move too        # highest score first, then descending product_id (np.lexsort sorts by its last key first)        order = np.lexsort((-scores.index.to_numpy(), -scores.to_numpy()))        return scores.iloc[order[:k]]products, queries, judgments = load_products(), load_queries("train"), qrels("train")semantic = SemanticSearch()semantic_run = semantic.run(queries, k=100)# each order runs in turn, against the same semantic runfor ties, lexical in [("ties by product_id", LexicalSearch(products)), ("ties reversed", TiesReversed(products))]:    bm25 = lexical.run(queries, k=100)    by_k = {k: evaluate(reciprocal_rank_fusion([bm25, semantic_run], k=k), judgments)["ndcg@10"].mean()            for k in [1, 10, 30, 60, 100, 300]}    print(f"best rrf k, {ties}: {max(by_k, key=by_k.get)}")                # ties go to the smaller k    rrf = scores_by_alpha(lambda alpha: weighted_rrf(bm25, semantic_run, alpha), judgments)    print(f"weighted rrf alpha, {ties}: {best_alpha(rrf)}")    tables = candidates(lexical, semantic, queries)    total = scores_by_alpha(lambda alpha: weighted_sum(tables, alpha), judgments)    print(f"weighted sum alpha, {ties}: {best_alpha(total)}")
Saídapython tuning-with-ties-reversed.py
best rrf k, ties by product_id: 100
weighted rrf alpha, ties by product_id: 0.6
weighted sum alpha, ties by product_id: 0.7
best rrf k, ties reversed: 300
weighted rrf alpha, ties reversed: 0.8
weighted sum alpha, ties reversed: 0.7

Inverter os empates altera os ajustes do RRF, mas não os da soma ponderada:

Configuração Empates por product_id Empates invertidos
Melhor k do RRF 100 300
α do RRF ponderado 0.6 0.8
α da soma ponderada 0.7 0.7

Quando uma ordem que não carrega informação altera um ajuste, as consultas de treino não conseguem distinguir os ajustes; por isso o k e o peso do RRF são frágeis, e o peso da soma ponderada não é. A loja não tem mais consultas de treino para definir o peso do RRF ponderado, e sua comparação de teste foi planejada com o peso ajustado com empates por product_id, então α = 0.6 vai para o teste.

Estabilidade significa que as consultas de treino concordam em um peso, e não que ele melhora a busca em outras consultas: as reamostragens reutilizam as mesmas consultas, por isso compartilham o que elas têm em comum.

Regra prática: Faça o bootstrap das consultas de treino e ajuste em cada amostra; depois, ajuste mais uma vez com os empates listados em outra ordem que não carregue informação. Se o peso escolhido se espalhar pela grade, use uma grade mais grossa ou mais consultas de treino, ou prefira a configuração mais simples. Se só a ordem dos empates mover o peso, diga isso em qualquer lugar onde o relatar. Se ele se mantiver estável nas duas verificações, leve-o às consultas de teste.

Apresente os blends ajustados nas consultas de teste

Última alteração na edição 2026.11.8

Somente as consultas reservadas mostram se uma configuração ajustada ajuda além das consultas que a escolheram. Execute cada blend ajustado uma única vez nas consultas de teste e compare-o consulta por consulta com a recuperação semântica, o melhor recuperador isolado, usando o harness do capítulo 3. O capítulo fixou essas duas comparações antes de olhar os resultados. Seguindo o capítulo 3, a correção de Bonferroni fixa o limite em um valor-p de permutação abaixo de 0.025, que é 0.05 dividido pelas duas comparações planejadas. O teste t e um intervalo bootstrap no nível de confiança correspondente, 0.975, acompanham esse critério.

Nas consultas de treino da loja, os blends ajustados ganharam 0.013 e 0.015 sobre a recuperação semântica, nenhum deles um ganho que o teste de permutação pudesse distinguir do acaso. Faça uma previsão antes: nas consultas de teste, a soma ponderada com α = 0.7 e o RRF ponderado com α = 0.6 terão pontuação acima da recuperação semântica, igual a ela ou abaixo dela?

tuned-blends-on-test.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Chooses each blend's α on the train queries, runs both once on the test queries, and compares each with semanticretrieval at the corrected threshold. The prose's point rests on the two mean differences and their permutationp-values, and the assert checks that neither clears the threshold."""from lib.blend import best_alpha, candidates, scores_by_alpha, weighted_rrf, weighted_sumfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelslexical, semantic = LexicalSearch(load_products()), SemanticSearch()def blends(queries):    tables, bm25, semantic_run = candidates(lexical, semantic, queries), lexical.run(queries), semantic.run(queries)    return {"weighted sum": lambda alpha: weighted_sum(tables, alpha),          # each blend's run at a given alpha            "weighted rrf": lambda alpha: weighted_rrf(bm25, semantic_run, alpha)}train, test = blends(load_queries("train")), blends(load_queries("test"))threshold = 0.05 / len(test)                                 # two planned comparisons, Bonferroni-correctedsemantic_scores = evaluate(semantic.run(load_queries("test")), qrels("test"))print("test queries:", len(semantic_scores))print(f"semantic ndcg@10: {semantic_scores['ndcg@10'].mean():.3f}")unweighted = evaluate(test["weighted rrf"](0.5), qrels("test"))          # alpha 0.5 is chapter 1's fusionprint(f"unweighted rrf ndcg@10: {unweighted['ndcg@10'].mean():.3f}")print(f"p-value threshold for each comparison: {threshold:.3f}")print(f"confidence level of each interval: {1 - threshold:.3f}")judged = [semantic_scores["judged@10"].mean()]for name, blend in test.items():    alpha = best_alpha(scores_by_alpha(train[name], qrels("train")))       # train only    scores = evaluate(blend(alpha), qrels("test"))    judged.append(scores["judged@10"].mean())    # the interval's level matches the corrected threshold    result = compare(scores["ndcg@10"], semantic_scores["ndcg@10"], confidence=1 - threshold)    print(f"{name} alpha chosen on train: {alpha}")    print(f"{name} ndcg@10: {scores['ndcg@10'].mean():.3f}")    print(f"{name} minus semantic: {result['mean difference']:.3f}")    print(f"{name} permutation p: {result['permutation p']:.3f}")    print(f"{name} t-test p: {result['t-test p']:.3f}")    print(f"{name} interval: {result['ci low']:.3f} to {result['ci high']:.3f}")    # neither difference is established: each permutation p-value stays at or above the corrected threshold    assert result['permutation p'] >= thresholdprint(f"lowest judged@10: {min(judged):.3f}")print(f"highest judged@10: {max(judged):.3f}")
Saídapython tuned-blends-on-test.py
test queries: 30
semantic ndcg@10: 0.830
unweighted rrf ndcg@10: 0.812
p-value threshold for each comparison: 0.025
confidence level of each interval: 0.975
weighted sum alpha chosen on train: 0.7
weighted sum ndcg@10: 0.816
weighted sum minus semantic: -0.014
weighted sum permutation p: 0.229
weighted sum t-test p: 0.221
weighted sum interval: -0.042 to 0.008
weighted rrf alpha chosen on train: 0.6
weighted rrf ndcg@10: 0.825
weighted rrf minus semantic: -0.005
weighted rrf permutation p: 0.650
weighted rrf t-test p: 0.643
weighted rrf interval: -0.029 to 0.016
lowest judged@10: 0.980
highest judged@10: 0.990

Nenhum dos blends supera a recuperação semântica. A recuperação semântica obtém 0.830, a soma ponderada das pontuações min-max 0.816 e o RRF ponderado 0.825.

Os valores de judged@10 das execuções estão entre 0.980 e 0.990, de modo que os julgamentos ausentes pesam aproximadamente da mesma forma nos três.

Nenhuma das diferenças foi comprovada: cada valor-p de permutação permanece igual ou acima de 0.025, o limite corrigido. A soma ponderada difere da recuperação semântica em -0.014, com valor-p de permutação de 0.229, valor-p do teste t de 0.221 e intervalo de -0.042 to 0.008. O RRF ponderado difere em -0.005, com valores-p de 0.650 e 0.643 e intervalo de -0.029 to 0.016. Os dois intervalos contêm 0, e os testes concordam com eles; portanto, o resultado é "nenhuma melhora", e não "pior". No caso do RRF ponderado, esse é o resultado para α = 0.6, um peso que a ordem dos empates do BM25 pode alterar.

Prever "acima" teria significado confiar em um ganho de treino que o teste de permutação não conseguiu distinguir do acaso nem nas consultas que o escolheram, e que foi o melhor de várias tentativas.

Regra prática: Adote um blend somente quando ele superar o melhor recuperador isolado em consultas reservadas, com valor-p de permutação abaixo de um limite corrigido pelo número de comparações planejadas. Quando não superar, mantenha o sistema mais simples. Isso deixa a recuperação semântica sozinha como o ranqueador da loja a ser superado. Mantenha os pesos ajustados e o código, e teste os blends novamente quando um recuperador ou o catálogo mudar.

Aprenda pesos de termos esparsos com SPLADE

Última alteração na edição 2026.11.10

Em vez de fundir dois recuperadores, você pode alterar um deles para que deixe escapar menos resultados. O BM25 só encontra palavras que aparecem no texto do produto. Recuperação esparsa aprendida mantém a maquinaria do BM25, um índice invertido de termos, mas faz com que um modelo neural escolha os termos de cada produto e seus pesos.

SPLADE é um modelo de recuperação esparsa aprendida (Formal et al., 2021). Um modelo de linguagem da família BERT, um transformador que lê o texto como tokens de subpalavras, lê o texto do produto e, em cada token i, atribui a cada termo j de seu vocabulário uma pontuação bruta w_ij. A ReLU define as pontuações negativas como 0, e o artigo original soma um logaritmo do que sobra sobre os tokens do texto:

weight of term j = sum over the text's tokens i of  log(1 + ReLU(w_ij))

O logaritmo é uma saturação, como a do BM25: nas palavras dos autores, ele “impede que alguns termos dominem e naturalmente garante a esparsidade das representações”. O SPLADE v2 substituiu a soma pelo máximo sobre os tokens, e os autores tornaram o max pooling o padrão (Formal et al., 2021, SPLADE v2). Um vetor SPLADE tem uma dimensão por entrada do vocabulário, 30,522 para um vocabulário BERT, e tipicamente mais de 99% delas são 0 (Sentence Transformers). Os termos não nulos de um vetor SPLADE incluem termos de expansão: palavras que o texto não contém, mas que o modelo pondera mesmo assim, de modo que um produto pode casar com uma palavra da consulta que nunca usa.

Os termos de expansão visam uma das falhas do BM25 na loja. Conte, nas consultas de treino, quantos produtos exatos não contêm pelo menos uma das palavras da consulta, como o tokenizador do BM25 as vê:

exact-products-missing-query-words.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""Counts the exact train pairs whose product lacks a word of its query, as BM25's tokenizer sees them, and counts theexact products of one query by term. The prose's point rests on the share missing a query word and on the per-termcounts for midcentury tv unit."""from collections import Counterimport bm25sfrom lib.store import load_products, load_queries, product_text, qrelsproducts, queries, judgments = load_products(), load_queries("train"), qrels("train")def words(texts):    """The tokens BM25 matches on: bm25s's default tokenizer with English stopwords, as in lib.lexical."""    tokenized = bm25s.tokenize(texts, stopwords="en", return_ids=False, show_progress=False)    return [set(tokens) for tokens in tokenized]product_words = dict(zip(products.index, words(product_text(products).tolist())))query_words = dict(zip(queries.index, words(queries["query"].tolist())))exact_pairs = [(query_id, product_id) for query_id in queries.index               for product_id, grade in judgments[query_id].items() if grade == 2]missed = Counter(word for query_id, product_id in exact_pairs                 for word in query_words[query_id] - product_words[product_id])# a pair counts as missing when some query word is absent from the product's set of tokensmissing = sum(not query_words[query_id] <= product_words[product_id] for query_id, product_id in exact_pairs)print("exact train pairs:", len(exact_pairs))print("exact pairs missing a query word:", missing)print(f"share missing a query word: {missing / len(exact_pairs):.3f}")print("most often missing:", ", ".join(f"{word} ({count})" for word, count in missed.most_common(8)))exact = [product_id for query_id, product_id in exact_pairs if query_id == 453]   # midcentury tv unitprint("exact products for midcentury tv unit:", len(exact))for word in ["midcentury", "unit", "stand"]:    print(f"exact products containing {word}:", sum(word in product_words[product_id] for product_id in exact))mid_century = product_text(products)[exact].str.contains("mid-century")print("exact products whose text says mid-century:", mid_century.sum())
Saídapython exact-products-missing-query-words.py
exact train pairs: 1937
exact pairs missing a query word: 1454
share missing a query word: 0.751
most often missing: ligth (193), decorative (134), modern (102), freestanding (78), floats (58), queen (57), dining (56), infant (43)
exact products for midcentury tv unit: 25
exact products containing midcentury: 0
exact products containing unit: 0
exact products containing stand: 25
exact products whose text says mid-century: 20

De 1937 pares exatos (consulta, produto), 1454 não contêm pelo menos uma palavra da consulta, uma proporção de 0.751. As palavras que mais faltaram, com suas contagens, são ligth (193), decorative (134), modern (102), freestanding (78), floats (58), queen (57), dining (56), infant (43). Algumas são erros de digitação, que o corretor do capítulo 8 visa, e formas no plural, que o capítulo 5 radicaliza; outras são palavras descritivas que o texto do produto deixa de fora, ou palavras diferentes para a mesma coisa.

Para midcentury tv unit, os produtos exatos usam outras palavras. Dos 25 produtos exatos, 0 contêm midcentury e 0 contêm unit. Em vez disso, o texto deles diz mid-century em 20, e stand em 25.

Os termos de expansão são voltados para lacunas como estas, embora saber se um modelo aprende que uma bancada de TV é uma unidade de TV seja algo que você precisaria medir.

O relatório técnico dos próprios autores do SPLADE dá ao SPLADE-v3 um MRR@10 acima de 0.40 no conjunto de desenvolvimento do MS MARCO, um benchmark de ranqueamento de passagens em que o MRR@10 mede em que posição fica a primeira passagem relevante, e o descreve como “se compara bem a re-rankers de cross-encoder” (Lassance et al., 2024). O livro não executa o SPLADE. Os checkpoints de referência, naver/splade-cocondenser-ensembledistil e naver/splade-v3, são licenciados sob CC-BY-NC-SA-4.0, o que exclui o uso comercial. Um modelo Apache-2.0, opensearch-neural-sparse-encoding-doc-v3-distill, executa seu modelo neural apenas sobre os produtos, e codifica as consultas com um tokenizador e uma tabela de pesos.

Regra prática: Considere a recuperação esparsa aprendida quando os erros do BM25 forem, em sua maioria, erros de vocabulário e você quiser manter um índice invertido. Verifique primeiro a licença do modelo, e meça-o como qualquer recuperador: sozinho, por consulta, nas consultas de treino e, depois, nas de teste.

Confronte token a token com ColBERT

Última alteração na edição 2026.11.10

Onde o SPLADE muda a recuperação lexical, a interação tardia muda a recuperação semântica. A recuperação semântica da loja é de vetor único: um embedding por produto e um por consulta, comparados uma única vez. A interação tardia mantém um vetor por token em vez de um por texto, por isso também é chamada de recuperação multivetor. O ColBERT codifica a consulta e o produto separadamente, como um modelo de embedding faz, e os compara somente no fim. Para cada token da consulta, o ColBERT encontra o token do produto mais semelhante e soma esses máximos, uma operação chamada MaxSim (Khattab and Zaharia, 2020):

score(query, product) = sum over query tokens q of  max over product tokens d of  cosine(q, d)

Como os produtos são codificados sem a consulta, seus vetores de token são calculados antecipadamente, o que um cross-encoder não consegue fazer: ele lê os dois textos como uma única entrada. O artigo do ColBERT relata eficácia "competitiva com os modelos baseados em BERT existentes" que leem a consulta e a passagem juntas, com velocidade "duas ordens de grandeza mais rápidos". O preço é o armazenamento: um vetor por token em vez de um por produto. O ColBERTv2 os comprime, reduzindo o espaço de que os modelos de interação tardia precisam em 6 a 10 vezes (Santhanam et al., 2022).

Volte a midcentury tv unit, cujos produtos exatos dizem stand, nunca unit. Um vetor único condensa a consulta inteira em uma direção e o texto inteiro do produto em outra. Com a interação tardia, o unit da consulta é comparado com cada token do produto, stand entre eles, e sua melhor correspondência conta por si só. A correspondência no nível de token ajuda em alguns casos difíceis. No NevIR, um benchmark de negação em que a escolha aleatória acerta 25%, o ColBERTv1 obteve 19.7% e o ColBERTv2 13.0%, acima de todos os modelos de vetor único testados (12% ou menos), embora ainda abaixo do acaso (Weller et al., 2024). No BEIR, um benchmark que testa os modelos em zero-shot, em conjuntos de dados com os quais não foram treinados, os reranqueadores e os modelos de interação tardia "em média alcançam os melhores desempenhos zero-shot", a um alto custo computacional (Thakur et al., 2021). Existem ferramentas abertas, como a biblioteca PyLate e o modelo Apache-2.0 lightonai/GTE-ModernColBERT-v1 (Chaffin and Sourty, 2025). O livro também não executa o ColBERT.

Regra prática: Considere a interação tardia quando a recuperação de vetor único deixar passar detalhes que dependem de uma única palavra, e você puder arcar com um vetor por token. Para um catálogo do tamanho do da loja, recomendamos testar primeiro um reranqueador sobre uma lista restrita (capítulo 9): ele lê os mesmos detalhes no momento da consulta e não exige um novo índice, embora nenhum dos reranqueadores do capítulo 9 mostre ganho consolidado sobre a recuperação semântica da loja.

Decida quando a recuperação híbrida compensa

Última alteração na edição 2026.11.8

A fusão ajudar ou não depende dos recuperadores que você funde, e os estudos publicados apontam em direções opostas. A recuperação lexical e a densa (denso, no sentido de baseado em embeddings) podem se complementar mesmo quando o modelo denso é mais fraco: fora do domínio, um híbrido zero-shot obteve ganho de 20.4% em termos relativos sobre o modelo de recuperação profunda, em média em três conjuntos de dados (T. Chen et al., 2022). A linha de base lexical importa. Os autores do DPR, um recuperador denso, encontraram pouco ganho com um híbrido, e uma replicação com um BM25 mais forte encontrou "ganhos estatisticamente significativos" (Ma et al., 2021). A força do recuperador semântico também importa. No BRIGHT, um benchmark de consultas que exigem muito raciocínio, a fusão do BM25 por uma soma ponderada de escores min-max com α = 0.5 acrescentou de 3.5 a 4.9 pontos de nDCG@10 a recuperadores densos de força intermediária e custou aos dois mais fortes de 2.0 a 2.9. Os autores alertam que a fusão pode prejudicar recuperadores que já são fortes, porque "a lista fundida promove documentos lexicamente semelhantes, mas semanticamente irrelevantes" (Abdallah et al., 2026).

Relatos de produção normalmente comparam um híbrido apenas com a busca lexical. Um pré-print de um varejista relata que a busca híbrida, lexical e vetorial, superou a busca somente lexical em um teste A/B online, elevando a taxa de cliques em 0.97% e a conversão em 0.98% (Sonagara et al., 2026). Essa é evidência para acrescentar recuperação semântica a um sistema lexical, não para acrescentar recuperação lexical a um sistema semântico forte, que é a questão da loja.

A loja está no caso de recuperador forte: nas consultas de teste, o capítulo 3 estabelece a vantagem da recuperação semântica sobre o BM25, e nenhuma mistura ajustada a supera. O BM25 da loja é a linha de base sem stemming do livro. O capítulo 5 constrói uma linha de base mais forte, e a replicação de Ma et al. é um motivo para testar as misturas novamente com ela.

Fundir escores não é o único tipo de híbrido. Um mecanismo de busca também pode usar correspondências lexicais como filtro sobre a recuperação semântica: um deles acrescenta um operador de embedding à sua linguagem de consulta, de modo que "expressões de recuperação híbrida, com combinações arbitrárias de embeddings e termos" são executadas como uma única consulta (Huang et al., 2020). Um filtro para a loja poderia exigir que um tamanho como 48 correspondesse exatamente e, em seguida, ordenar as correspondências por embedding. Isso é uma hipótese a testar, não um resultado, e um filtro ingênuo falha em 7qt slow cooker, cuja grafia nenhum produto usa. Decidir quando uma consulta traz uma restrição desse tipo é compreensão de consulta (capítulo 8), e o capítulo 8 testa um filtro desse tipo nas mensagens de acompanhamento de um comprador que citam uma cor, um formato, um tamanho ou um acabamento. Escolher um peso por consulta também é compreensão de consulta, e este livro não o constrói. Escolher, para cada consulta de treino, o ranking melhor marcaria 0.802, e um peso por consulta, que mistura as listas, não está limitado por esse número. Um método por consulta pede a um LLM, um modelo de linguagem de grande porte, que julgue o resultado principal de cada recuperador e define α a partir disso (Hsu and Tzeng, 2025). O estudo do BRIGHT considerou instável uma variante desse método baseada em escores (Abdallah et al., 2026).

Regra prática: Recomendamos testar um híbrido quando seus dois recuperadores estiverem próximos em qualidade, quando seu modelo de embeddings funcionar fora do domínio para o qual foi treinado, ou quando muitas consultas dependerem de termos exatos que seus embeddings não captam. Comece com RRF ponderado: ele precisa apenas de posições, e, nas consultas de treino da loja, o teste de permutação não conseguiu distingui-lo da soma ponderada. Passe para uma soma ponderada de escores normalizados quando os dois motores fornecerem escores para cada candidato: dois estudos a colocaram à frente do RRF em seus dados (Bruch et al., 2023; Abdallah et al., 2026), e, nas consultas de treino da loja, seu peso foi o mais estável. Quando um dos recuperadores se mostra o mais forte em consultas reservadas (held-out) e nenhuma mistura ajustada o supera ali, use-o sozinho, mantenha o outro como linha de base e teste um filtro lexical para as restrições exatas. Esse é o caso da loja.

O que dá errado em produção

Última alteração na edição 2026.11.8

Dois recuperadores custam duas vezes cada coisa. Os exemplos pontuam uma amostra do catálogo offline, mas uma busca híbrida em produção mantém dois índices atualizados e executa duas buscas por consulta. Elas podem rodar em paralelo, mas a mais lenta define o tempo de resposta, e uma falha em qualquer uma degrada o resultado. Some esse custo ao ganho que você mediu.

Listas curtas descartam candidatos. A fusão não consegue ranquear um produto que nenhum dos recuperadores devolveu. Nas consultas de treino da loja, a união de duas listas top-100 contém 0.810 dos produtos exatos de cada consulta, e a união de duas listas top-20, 0.445. Um limite de profundidade na configuração de um dos mecanismos pode cortar candidatos sem que ninguém perceba.

Pontuações ausentes exigem uma regra. Quando cada recuperador devolve apenas seus k primeiros, um produto ausente em uma lista não tem pontuação desse recuperador. A replicação do DPR atribui a ele "a pontuação mínima de recuperação densa entre os documentos recuperados", e o inverso para o BM25 (Ma et al., 2021). Bruch et al. calculam a pontuação ausente de forma exata, como lib.blend.candidates faz, o que um mecanismo de produção pode não permitir (Bruch et al., 2023).

Min-max é relativo. O melhor candidato de uma consulta sempre recebe 1, mesmo quando todos os candidatos são ruins. Uma consulta que não compartilha nenhuma palavra com produto algum do catálogo dá a todos os candidatos uma pontuação BM25 de 0. Nesse caso, o min-max simples divide por zero, e lib.blend devolve zeros, de modo que a mistura se torna, silenciosamente, apenas a recuperação semântica. Nenhuma consulta da loja faz isso; uma caixa de busca ao vivo fará.

Uma pontuação fundida não é uma confiança. As pontuações de recuperação são mal calibradas: "a calibração de confiança é consistentemente fraca em todas as famílias de modelos" (Abdallah et al., 2026). Não defina um limiar sobre a pontuação fundida para decidir que uma consulta não tem bons resultados.

Um peso ajustado pertence a um par de recuperadores. O α da loja se ajusta a estas configurações do BM25, a este modelo de embeddings e a este catálogo. Mude qualquer um deles e reajuste o peso com consultas de treino antes de confiar no valor antigo. Um RRF ajustado "generaliza mal para conjuntos de dados fora do domínio" (Bruch et al., 2023).

Regra prática: Registre as posições dos dois recuperadores ao lado do resultado fundido, verifique a profundidade da lista na configuração de todos os mecanismos e reajuste o α sempre que um recuperador mudar.

Decisões deste capítulo

Última alteração na edição 2026.11.8

Uma mudança posterior precisa superar cada uma delas por um motivo.

  • Ajustar no treino, reportar no teste. Toda análise e toda configuração ajustada usa as 50 consultas de treino. O capítulo lê as consultas de teste uma única vez, para reportar.
  • Duas comparações planejadas, cada mistura ajustada contra a recuperação semântica, decididas pelo teste de permutação com 0.05 dividido por 2, acompanhadas do teste t e de um intervalo de confiança por bootstrap.
  • Verificar cada recuperador antes de fundir, com judged@10 e um teste pareado, e contar, por consulta, onde cada um vence.
  • Candidatos: a união dos top 100 dos dois recuperadores, com as duas pontuações buscadas para cada candidato, de modo que nenhum produto fique sem pontuação.
  • Normalização: min-max por consulta. O teste de permutação no treino não consegue distinguir as outras duas normalizações desta a 0.05, e o min-max não precisa de conhecimento de nenhuma das funções de pontuação.
  • RRF: k = 60, com listas de profundidade 100. O melhor k no treino não ganha de 60 nada que o teste de permutação consiga distinguir do acaso a 0.05, e ele muda conforme a ordem dos empates do BM25. Uma lista mais profunda só pode acrescentar candidatos.
  • Um único peso, α, ajustado de 0 a 1 em passos de 0.1 para as duas misturas, escolhido pela média de nDCG@10 no treino, depois submetido a bootstrap e ajustado de novo com a ordem dos empates do BM25 invertida. O α da soma ponderada se mantém nas duas verificações; o do RRF ponderado não.
  • SPLADE e ColBERT são descritos, não registrados, porque nenhum dos dois é necessário para responder à pergunta da loja.
  • Adotar uma mistura somente se ela superar o melhor recuperador isolado no teste. Nenhuma das duas misturas ajustadas o faz; por isso, o rankeador da loja a ser superado continua sendo apenas a recuperação semântica, e o BM25, sem stemming, é mantido como linha de base.
  • O que o capítulo mostrou: uma mistura só pode ajudar onde os recuperadores que a compõem falham em consultas diferentes, e um peso que vence no treino precisa se sustentar no teste; na loja, nenhuma das duas misturas ajustadas superou a recuperação semântica.

Este capítulo, nesta edição

Edição 2026.11.10Exemplos aprovados em 19 de nov de 202612 de 12 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.10.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 7 de 11: Recuperação híbrida

  1. Descubra as consultas que cada recuperador vence
  2. Verifique cada recuperador antes de fundir
  3. Normalize os escores antes de somá-los
  4. Teste as configurações da fusão recíproca de ranks nas consultas de treino
  5. Ajuste do peso da combinação nas consultas de treino
  6. Verifique se o peso ajustado é estável
  7. Apresente os blends ajustados nas consultas de teste
  8. Aprenda pesos de termos esparsos com SPLADE
  9. Confronte token a token com ColBERT
  10. Decida quando a recuperação híbrida compensa
  11. O que dá errado em produção
  12. Decisões deste capítulo

Voltar ao topoTodos os capítulos