Recuperación híbrida

Unos 39 minutos de lectura, con 12 ejemplos en 12 secciones.

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

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

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

Al final de este capítulo podrás combinar un ranking léxico y un ranking semántico en uno solo, ya sea sumando puntuaciones normalizadas o mediante fusión recíproca de rangos, ajustar cuánto cuenta cada ranking con las consultas de entrenamiento, y decidir con una prueba pareada sobre las consultas de prueba si la combinación supera al mejor de sus dos componentes.

La tienda busca en su catálogo de muebles y artículos para el hogar con dos recuperadores, y el capítulo 1 los fusionó en un único ranking. Esa fusión no superó a la recuperación semántica por sí sola: en las consultas de prueba obtuvo 0.812 de nDCG@10 frente a 0.830 de la recuperación semántica, una diferencia que las pruebas del capítulo 3 tampoco permiten confirmar ni descartar. Por eso la tienda necesita saber si una mezcla mejor puede superar a la recuperación semántica, su mejor recuperador hasta ahora y, por tanto, el que hay que superar.

Así que este capítulo pregunta primero si BM25, la línea base sin lematización (stemming) de bm25s con sus valores por defecto, y la recuperación semántica, con embeddings del modelo abierto Snowflake/snowflake-arctic-embed-m-v1.5, fallan en consultas distintas. Una mezcla solo puede ayudar donde fallan en consultas distintas, de modo que después el capítulo ajusta dos maneras de mezclarlos.

Los sistemas de búsqueda de la industria suelen combinar ambos enfoques. Un modelo semántico de búsqueda de productos se diseñó "para complementar un motor de búsqueda léxico en la recuperación ad hoc de productos" (Nigam et al., 2019), y el motor de búsqueda de una red social usa recuperación por embeddings y coincidencia de palabras clave en conjunto para puntuar documentos (Huang et al., 2020).

La tienda tiene 50 consultas de entrenamiento para ajustar y 30 consultas de prueba para informar resultados. Este capítulo encuentra las consultas que gana cada recuperador y evalúa cada uno por separado. Después construye dos mezclas, formas de fusionar un ranking léxico y uno semántico con un peso que determina cuánto cuenta cada uno, y ajusta ese peso. Todo análisis y todo paso de ajuste se ejecuta sobre las consultas de entrenamiento. El capítulo planifica dos comparaciones sobre las consultas de prueba, hechas una sola vez, al final: cada mezcla ajustada, la suma ponderada y la fusión recíproca de rangos ponderada, frente a la recuperación semántica.

Encuentra las consultas que gana cada recuperador

Último cambio en la edición 2026.11.8

La recuperación híbrida combina los rankings de un recuperador léxico y uno semántico en un único ranking. Combinar rankings se llama fusión. La fusión solo puede ayudar si los dos recuperadores fallan en consultas distintas: si ambos ponen productos malos primero para una consulta, ninguna mezcla de sus rankings lo arregla. Los estudios publicados encuentran que sí fallan en consultas distintas. Los embeddings no detectan entidades raras ni palabras clave selectivas que BM25 sí encuentra (capítulo 6), y en un conjunto de datos diseñado para probar los límites de un único embedding por texto, BM25 encuentra lo que los embeddings pasan por alto, pero pierde la mayor parte de su puntuación cuando las palabras se sustituyen por sinónimos (capítulo 1). Por eso, la primera comprobación se hace por consulta, no como promedio.

Puntúa ambos recuperadores de la tienda por nDCG@10 en cada consulta de entrenamiento, conservando los 100 primeros de cada uno.

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 Superado
"""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())
Salidapython 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

Ningún recuperador gana todas las consultas. La recuperación semántica promedia 0.772 de nDCG@10 frente a los 0.695 de BM25, pero BM25 aún gana 15 consultas de entrenamiento frente a las 31 de la recuperación semántica, y 4 quedan empatadas.

Si pudieras elegir el mejor de los dos para cada consulta, el promedio sería 0.802. Eso no es un techo para la fusión, que mezcla las listas en lugar de elegir una, pero muestra lo que podrían valer las diferencias.

A continuación, comprueba si las dos listas contienen productos distintos y qué proporción de los productos exactos de cada consulta (los que los jueces calificaron como plenamente coincidentes) encuentra cada lista:

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 Superado
"""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}")
Salidapython 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

Los dos top 10 comparten en promedio 3.7 productos, así que la mayor parte de cada uno falta en el otro. La fusión no puede ordenar un producto que ninguna de las dos listas contiene, por lo que la profundidad de cada lista limita lo que la fusión puede alcanzar. La unión supera a cualquiera de las dos listas en ambas profundidades:

Proporción de productos exactos recuperados Top 20 Top 100
BM25 0.297 0.672
Recuperación semántica 0.353 0.759
Unión de ambos 0.445 0.810

Dos consultas de entrenamiento muestran los tipos de fallo:

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 Superado
"""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]}")
Salidapython 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, el top 10 de BM25 contiene 9 productos exactos frente a los 3 de la recuperación semántica. BM25 premia los productos cuyo texto contiene las tres palabras: islas de cocina con encimera de tabla de carnicero. La recuperación semántica coloca también en lo alto mesas de preparación y carros con encimera de madera de carnicero, y los jueces los calificaron como parciales: el material correcto, pero no la isla que pide la consulta.

Para 7qt slow cooker ocurre lo contrario: el top 10 de BM25 contiene 1 exactos y el de la recuperación semántica 7. El catálogo tiene 0 productos cuyo texto contiene 7qt y 9 que contienen 7 qt, así que BM25 solo coincide con slow cooker y ordena ollas de cocción lenta de todos los tamaños, mientras que la recuperación semántica pone primero las ollas de 7 cuartos.

Son consultas individuales: muestran un tipo de fallo, no su frecuencia. El recuento por consulta enumera las 6 consultas de entrenamiento en las que BM25 aventaja en 0.1 o más de nDCG@10. La mayoría nombra un tipo concreto de producto con dos o más palabras que deben coincidir todas, y una, malachi sled, nombra una línea de productos.

El capítulo 1 encontró que BM25 iba por delante en 2 de las 2 consultas de prueba que indican una medida en pulgadas, pero de las 5 consultas de entrenamiento que contienen un dígito, BM25 gana 1.

Regla práctica: Antes de fusionar, cuenta por consulta dónde gana cada recuperador en tus consultas de entrenamiento, y comprueba cuántos productos relevantes contiene la unión de sus listas que el mejor de los dos no encuentra. Considera fusionar cuando cada uno gane una parte real de las consultas y la unión contenga más productos relevantes que cualquiera de las listas. Eso es necesario, pero no suficiente: a continuación, comprueba cada recuperador por separado y prueba la mezcla ajustada con consultas reservadas antes de adoptarla.

Verifica cada recuperador antes de fusionar

Último cambio en la edición 2026.11.10

Saber dónde gana cada recuperador no basta: la fusión da a cada entrada voz en el ranking final, incluida una entrada débil. Un estudio de búsqueda híbrida sobre 11 conjuntos de datos encontró un efecto de "eslabón más débil": un solo recuperador débil puede reducir sustancialmente la precisión del resultado fusionado, por lo que cada uno debe verificarse antes de fusionar (Wang et al., PVLDB 2026). Por eso compara la nDCG@10 media de los recuperadores, con judged@10 junto a ella. Luego compáralos consulta por consulta con una prueba pareada: ¿qué tan probable es una diferencia media así de grande si los dos fueran igual de buenos? La prueba del libro es la prueba de permutación, junto a la prueba t pareada.

Fusiona BM25 y la recuperación semántica como lo hizo el capítulo 1, con fusión recíproca de rangos (RRF): cada producto obtiene 1 / (60 + su rango) en cada ranking, sumado sobre los dos, de modo que cada ranking recibe un voto igual. Después separa las consultas de entrenamiento por ganador y compara la fusión con la recuperación semántica por sí sola:

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 Superado
"""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}")
Salidapython 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

El judged@10 de BM25 es 0.930 frente a 0.964 de la recuperación semántica, así que los 10 primeros de BM25 contienen algunos productos más que nadie evaluó, y el capítulo 2 muestra cómo estos pueden bajar una puntuación. La recuperación semántica lidera por 0.077 de nDCG@10, con un valor p de permutación de 0.003 y un valor p de la prueba t de 0.004. En las consultas de prueba, el capítulo 3 establece la misma ventaja. Así, la tienda tiene un recuperador fuerte y otro más débil.

Al separar por ganador, la fusión ayuda en promedio donde gana BM25 y perjudica donde gana la recuperación semántica:

Consultas donde Consultas Fusión mejor que semántica Fusión peor que semántica Cambio medio en nDCG@10
Gana BM25 15 12 2 0.101
Gana la recuperación semántica 31 5 25 -0.045

Agrupar las consultas por ganador incorpora este patrón, ya que casi cualquier mezcla ayuda donde gana BM25 y perjudica donde pierde. Lo que importa es el cambio neto sobre todas las consultas de entrenamiento. La fusión difiere de la recuperación semántica en 0.002 de nDCG@10 en promedio, con un valor p de permutación de 0.863. En estas consultas, los votos iguales no aportan ninguna ganancia medible.

La separación usa los juicios para decidir qué recuperador gana, así que diagnostica el patrón y no puede elegir un recuperador para una consulta en vivo, que no tiene juicios.

Regla práctica: Verifica cada recuperador por separado en las consultas de entrenamiento, con judged@10 y una prueba pareada, antes de fusionar. Cuando uno es más débil y gana menos consultas, no le des un voto igual: asígnale un peso y ajusta el peso, o déjalo fuera. Los votos iguales convienen a dos recuperadores de calidad parecida.

Normaliza las puntuaciones antes de sumarlas

Último cambio en la edición 2026.11.10

La forma más directa de dar al recuperador más débil, BM25 en la tienda, una menor influencia es sumar las puntuaciones de ambos recuperadores con un peso: α por la puntuación semántica más (1 − α) por la puntuación de BM25. Una suma cuyos pesos suman 1 es una combinación convexa, o suma ponderada. Solo funciona si las puntuaciones están en escalas comparables, y aquí no lo están: una puntuación BM25 no tiene un rango fijo y crece con el número y la rareza de las palabras de la consulta, mientras que la puntuación de la recuperación semántica, una similitud coseno, está entre −1 y 1. La normalización de puntuaciones reescala las puntuaciones de cada recuperador para cada consulta antes de sumarlas. El escalado min-max por consulta lleva la puntuación más baja entre los productos ordenados de la consulta a 0 y la más alta a 1. Un estudio de funciones de fusión lo llama «el método de facto en la literatura» y prueba dos alternativas (Bruch et al., 2023). El min-max teórico usa el valor más bajo posible de cada puntuación en lugar del más bajo observado: 0 para BM25 y −1 para el coseno. La puntuación z resta la media de las puntuaciones de una consulta y divide entre su desviación estándar. El módulo compartido de los ejemplos, lib/blend.py, escribe cada una en pocas líneas.

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

Una suma necesita ambas puntuaciones para cada producto que ordena. El conjunto de candidatos de una consulta es la unión de los 100 primeros de BM25 y de los 100 primeros de la recuperación semántica, y lib.blend.candidates busca ambas puntuaciones para cada producto de ese conjunto: la puntuación BM25, 0 cuando el producto no comparte ninguna palabra con la consulta, y la similitud coseno.

Empieza con las puntuaciones brutas de la tienda, sumadas con α = 0.5 en las consultas de entrenamiento, y luego haz lo mismo tras el escalado min-max, desarrollado en el ejemplo y comprobado frente a 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 Superado
"""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}")
Salidapython 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, los 125 candidatos tienen puntuaciones BM25 de 2.059 to 8.229 y similitudes de 0.336 to 0.597. La dispersión de BM25 es muchas veces mayor, así que es BM25 quien decide el orden de la suma bruta. En las consultas de entrenamiento, los 10 primeros de la suma bruta comparten en promedio 9.6 productos con los 10 primeros de BM25 y 3.9 con los de la recuperación semántica.

El peso dice «la mitad para cada uno», pero el ranking depende sobre todo de BM25: el nDCG@10 de la suma bruta, 0.706, está cerca del 0.695 de BM25.

Tras el escalado min-max, ambos recuperadores tienen voz. Los 10 primeros de la suma escalada comparten 6.5 productos con los de BM25 y 6.2 con los de la recuperación semántica, y su nDCG@10 sube a 0.771. El valor p de permutación para esa diferencia respecto a la suma bruta es below 0.001. La versión hecha a mano ordena 50 of 50 consultas de entrenamiento exactamente igual que lib.blend.weighted_sum.

Las puntuaciones brutas pueden funcionar con un peso ajustado. Los autores de DPR, un recuperador basado en embeddings, ordenaron los candidatos por BM25 más 1.1 veces la similitud de DPR, con el 1.1 elegido sobre un conjunto de desarrollo (Karpukhin et al., 2020). La normalización da a α el mismo significado para todas las consultas; sin ella, la influencia de BM25 cambia con su rango de una consulta a otra. Sin embargo, el min-max no es una escala absoluta: es relativo a los candidatos de la consulta, así que el mejor candidato siempre recibe 1, por malo que sea.

Regla práctica: Nunca sumes puntuaciones brutas de BM25 y coseno con un peso adivinado. Recomendamos el min-max por consulta como opción predeterminada, porque no requiere conocer ninguna de las dos funciones de puntuación. Usa el min-max teórico cuando conozcas el valor mínimo posible de cada puntuación y quieras un suelo que no se mueva con los candidatos. En cualquier caso, ajusta α con las consultas de entrenamiento.

Prueba los ajustes de la fusión recíproca de rangos con las consultas de entrenamiento

Último cambio en la edición 2026.11.8

Los rangos, a diferencia de las puntuaciones, comparten una sola escala, así que fusionar por rango no requiere normalización. La fusión recíproca de rangos (RRF, por sus siglas en inglés) asigna a cada producto una puntuación que suma, sobre las listas de rangos que lo contienen, 1 dividido entre la suma de una constante k y su rango (Cormack et al., 2009), tal como lo escribe la fórmula del capítulo 1. El precio es la información: «como RRF es una función de los rangos, ignora la distribución de las puntuaciones y, por tanto, descarta información útil» (Bruch et al., 2023). Un producto apenas por detrás del líder y otro muy por detrás reciben puntuaciones fijadas solo por sus rangos.

La constante k determina cuánto dominan los primeros rangos. El capítulo 1 tomó k = 60 de los autores de RRF, quienes encontraron en un estudio piloto que 60 se acercaba al mejor valor y que la elección exacta importaba poco. Sus pilotos fusionaron 30 configuraciones de Wumpus Search, un motor de búsqueda, sobre colecciones de TREC, una serie de evaluaciones compartidas de recuperación (Cormack et al., 2009). Bruch et al. fusionaron un recuperador léxico y uno semántico, asignaron a cada uno su propia constante, η, y hallaron que los resultados son sensibles al equilibrio entre las constantes, que actúa como un peso: «cuando el modelo semántico ya rinde bien, por ejemplo, restar peso al sistema léxico aumentando η_Lex mejora el rendimiento». Una sola k compartida por ambos rankings, como en la tienda, no establece ningún equilibrio entre ellos.

La profundidad de cada lista también importa. Un producto que está entre los 20 primeros de un recuperador pero no del otro no obtiene nada del segundo ranking, aunque tenga un rango bajo allí. Como dicen Bruch et al., «los rangos no pueden calcularse exactamente a menos que toda la colección D sea ordenada por el sistema de recuperación o para cada consulta». En las consultas de entrenamiento de la tienda, la unión de dos listas de los 20 primeros contiene muchos menos productos exactos que la unión de dos listas de los 100 primeros, como muestran las proporciones de productos exactos en cada lista.

Prueba seis valores de k en las consultas de entrenamiento, fusionando listas de profundidad 100. Antes de ejecutarlo se planea una comprobación: ¿supera el mejor k al valor predeterminado, 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 Superado
"""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']}")
Salidapython 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

Con k = 1, el rango 1 gana 5.500 veces lo que gana el rango 10. Con k = 60, gana 1.148 veces lo que gana, de modo que un producto cerca de la cima de ambas listas supera a uno que está solo en la cima de una. Desde k = 1 hasta k = 300, los seis ajustes obtienen 0.753, 0.770, 0.771, 0.774, 0.778 y 0.777.

El mejor ajuste en entrenamiento, k = 100, supera a k = 60 en 0.004, con un valor p de permutación de 0.093 y un valor p de la prueba t de 0.103. El libro toma su veredicto de la prueba de permutación, que no puede distinguir esa ganancia del azar con 0.05. El intervalo bootstrap del 95 % de la ganancia, 0.001 to 0.011, excluye 0, así que el intervalo discrepa de ambas pruebas.

Los rankings de los dos ajustes difieren solo en unas pocas consultas (victorias, derrotas y empates: 6, 3, 41). Cuál es la mejor k también es frágil: al listar en el otro orden los productos empatados de BM25, gana k = 300. Esto encaja con el hallazgo de Cormack et al. de que la elección de k importa poco.

Regla práctica: Mantén k = 60 como valor predeterminado y fusiona listas de al menos 100 de profundidad, porque una lista más profunda solo puede añadir candidatos. Abandona k = 60 solo cuando la mejor k en entrenamiento lo supere por un margen que la prueba de permutación pueda distinguir del azar, con p por debajo de 0.05. Cuando un recuperador es el más fuerte, como en la tienda, k no es el ajuste que hay que cambiar: lo es el voto igualitario de RRF. Asigna pesos a los rankings y ajústalos.

Ajusta el peso de la mezcla con las consultas de entrenamiento

Último cambio en la edición 2026.11.8

Las dos mezclas del capítulo reciben cada una un peso, α, que es la proporción que se asigna a la recuperación semántica. En la suma ponderada, α multiplica la similitud normalizada y 1 − α la puntuación BM25 normalizada. En RRF ponderado, un producto obtiene (1 − α) / (k + su rango BM25) más α / (k + su rango semántico). En ambos casos, α = 0 es solo BM25 y α = 1 es solo recuperación semántica. Para RRF, α = 0.5 es la fusión sin ponderar del capítulo 1 con cada puntuación dividida entre dos. Aquí tienes el cálculo para el producto principal de una consulta de entrenamiento, con un α ilustrativo de 0.75:

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 Superado
"""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)}")
Salidapython 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, el producto principal, laundry sorter basket on wheels, ocupa el puesto 1 en el ranking de BM25 y el puesto 2 en el de recuperación semántica, así que obtiene 0.25 / (60 + 1) + 0.75 / (60 + 2) = 0.01620.

El ejemplo puntúa cada candidato de este modo; su ranking coincide con lib.blend.weighted_rrf en 100 of 100 posiciones.

El ajuste prueba una cuadrícula de valores de α en las consultas de entrenamiento y conserva el que tiene la mejor media de nDCG@10. Bruch et al. (2023) informan de tres hallazgos sobre el ajuste de una combinación convexa, CC: que una CC ajustada rinde casi igual con cualquier normalización de puntuaciones, que supera a RRF tanto dentro como fuera del dominio, y que es eficiente en muestras. Eficiente en muestras significaba que α convergía "con menos del 5 % de los datos de entrenamiento", una fracción de conjuntos de entrenamiento mucho mayores que el de la tienda.

Ajusta α sobre 0, 0.1, … 1 para la suma ponderada con cada una de las tres normalizaciones, y para RRF ponderado con k = 60. Después, como comprobaciones del ajuste, compara cada normalización con min-max y compara con la recuperación semántica las dos mezclas destinadas a las consultas de prueba:

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 Superado
"""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}")
Salidapython 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

La recuperación semántica sola obtiene 0.772 en las mismas consultas. El mejor α y la mejor puntuación de cada configuración:

Configuración Mejor α nDCG@10 medio p de permutación frente a min-max ajustado
Suma ponderada, min-max 0.7 0.784 —
Suma ponderada, min-max teórico 0.9 0.789 0.164
Suma ponderada, z-score 0.7 0.787 0.349
RRF ponderado, k = 60 0.6 0.787 0.776

Con 0.05, la prueba sobre las consultas de entrenamiento no puede distinguir de min-max ninguna de las dos normalizaciones alternativas, lo que encaja con el hallazgo de Bruch et al. de que la normalización apenas importa. Tampoco puede distinguir RRF ponderado del min-max ajustado. El segundo hallazgo de Bruch et al., que la suma ponderada supera a RRF, no se aprecia aquí, y estas consultas no permiten resolverlo.

Cada mezcla ajustada puntúa al menos igual que la recuperación semántica en las consultas de entrenamiento, ya que α = 1 está en la cuadrícula. Sin embargo, incluso en las consultas que las eligieron, la prueba de permutación no puede distinguir la ganancia de cualquiera de las dos mezclas del azar con 0.05. La suma ponderada gana 0.013, con un valor p de permutación de 0.177, y RRF ponderado gana 0.015, con 0.215. Además, cada ganancia es la mejor de 11 intentos sobre las mismas consultas, lo que la hace parecer aún mejor de lo que es.

Regla práctica: ajusta un solo peso con las consultas de entrenamiento sobre una cuadrícula gruesa, y mantén la normalización en min-max a menos que otra supere a esta por un margen que la prueba sobre las consultas de entrenamiento pueda distinguir del azar, con p por debajo de 0.05. Considera optimista la ganancia en entrenamiento sobre el mejor recuperador individual, y espera que se reduzca en las consultas de prueba, una regla general para cualquier configuración elegida como la mejor de varias. Antes de confiar en la configuración, comprueba que es estable, y después informa de ella con las consultas de prueba.

Comprueba que el peso ajustado sea estable

Último cambio en la edición 2026.11.10

Los pesos ajustados salen de unas pocas decenas de consultas, así que pueden depender de qué consultas tuviste. El bootstrap muestra cuánto: remuestrea las consultas de entrenamiento, ajusta α en cada muestra y repite muchas veces. Si el α elegido salta de un lado a otro, el valor ajustado refleja más la muestra que el almacén. El capítulo 3 usa el mismo remuestreo para calcular intervalos alrededor de las puntuaciones.

Remuestrea las consultas de entrenamiento 1000 veces con una semilla fija, y cuenta cuántas veces gana cada α en las dos mezclas ajustadas, la suma ponderada de puntuaciones min-max y el RRF ponderado, sobre los mismos remuestreos:

blend-weight-bootstrap.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""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}")
Salidapython 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

El peso de la suma ponderada se mantiene. Con todas las consultas de entrenamiento, su α es 0.7, y α = 0.7 gana en 686 remuestreos, más que cualquier otra opción. α = 0.6 gana en 171 remuestreos, y la recuperación semántica sola, α = 1, gana en 45.

El RRF ponderado, ajustado en α = 0.6, está menos asentado: su peso se mueve entre 0.6 y 0.8, con α = 0.6 ganando en 513 remuestreos, α = 0.8 en 365 y α = 0.7 en 76.

Ambos pesos se quedan del lado de la rejilla que favorece la recuperación semántica, salvo el peso igual, α = 0.5, que gana en 13 remuestreos para la suma ponderada y en 2 para el RRF ponderado.

El remuestreo no es la única comprobación. Los productos con puntuaciones BM25 iguales necesitan algún orden, y lib.lexical los ordena por product_id, un orden que no aporta información. El orden descendente por product_id tampoco aporta información. La suma ponderada da a los productos empatados el mismo término BM25, así que su orden apenas influye, pero RRF les asigna posiciones consecutivas, y por tanto puntuaciones distintas. Ordena los empates de BM25 de forma descendente por product_id, y vuelve a ajustar el mejor k de RRF y ambos pesos con las consultas de entrenamiento:

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 Superado
"""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)}")
Salidapython 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

Invertir los empates cambia los ajustes de RRF, pero no los de la suma ponderada:

Ajuste Empates por product_id Empates invertidos
Mejor k de RRF 100 300
α de RRF ponderado 0.6 0.8
α de suma ponderada 0.7 0.7

Cuando un orden que no aporta información cambia un ajuste, las consultas de entrenamiento no pueden distinguir entre esos ajustes, así que la k y el peso de RRF son frágiles y el peso de la suma ponderada no lo es. El almacén no tiene más consultas de entrenamiento para decidir el peso del RRF ponderado, y su comparación de prueba se planificó con el peso ajustado con los empates ordenados por product_id, así que α = 0.6 pasa a la prueba.

La estabilidad significa que las consultas de entrenamiento coinciden en un peso, no que ese peso mejore la búsqueda con otras consultas: los remuestreos reutilizan las mismas consultas, así que comparten lo que esas consultas tienen en común.

Regla práctica: Haz bootstrap de las consultas de entrenamiento y ajusta sobre cada muestra, y luego ajusta una vez más con los empates ordenados de otra forma que no aporte información. Si el peso elegido se dispersa por la rejilla, usa una rejilla más gruesa o más consultas de entrenamiento, o prefiere el ajuste más sencillo. Si solo el orden de los empates lo mueve, indícalo siempre que lo informes. Si se mantiene estable con ambas comprobaciones, llévalo a las consultas de prueba.

Informa de las mezclas ajustadas sobre las consultas de prueba

Último cambio en la edición 2026.11.8

Solo las consultas reservadas muestran si una configuración ajustada ayuda más allá de las consultas que la eligieron. Ejecuta cada mezcla ajustada una vez sobre las consultas de prueba, y compárala consulta por consulta con la recuperación semántica, el mejor recuperador individual, usando el arnés del capítulo 3. El capítulo fijó estas dos comparaciones antes de mirar los resultados. Siguiendo el capítulo 3, la corrección de Bonferroni fija el umbral en un valor p de permutación por debajo de 0.025, que es 0.05 dividido entre las dos comparaciones planificadas. Junto a él están la prueba t y un intervalo bootstrap al nivel de confianza correspondiente, 0.975.

En las consultas de entrenamiento de la tienda, las mezclas ajustadas ganaron 0.013 y 0.015 sobre la recuperación semántica, ninguna de ellas una ganancia que la prueba de permutación pudiera distinguir del azar. Predice primero: en las consultas de prueba, ¿la suma ponderada con α = 0.7 y el RRF ponderado con α = 0.6 puntuarán por encima de la recuperación semántica, igual que ella o por debajo?

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 Superado
"""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}")
Salidapython 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

Ninguna de las mezclas supera a la recuperación semántica. La recuperación semántica obtiene 0.830, la suma ponderada de puntuaciones min-max 0.816, y el RRF ponderado 0.825.

Los valores de judged@10 de las ejecuciones se sitúan entre 0.980 y 0.990, así que los juicios faltantes pesan aproximadamente igual en las tres.

Ninguna diferencia está establecida: cada valor p de permutación es igual o superior a 0.025, el umbral corregido. La suma ponderada difiere de la recuperación semántica en -0.014, con un valor p de permutación de 0.229, un valor p de la prueba t de 0.221 y un intervalo desde -0.042 to 0.008. El RRF ponderado difiere en -0.005, con valores p de 0.650 y 0.643 y un intervalo desde -0.029 to 0.016. Ambos intervalos contienen el 0, y las pruebas coinciden con ellos, así que la conclusión es «sin mejora», no «peor». En el caso del RRF ponderado, es la conclusión para α = 0.6, un peso que el orden de los empates de BM25 puede desplazar.

Decir «por encima» habría dado por buena una ganancia de entrenamiento que la prueba de permutación no pudo distinguir del azar ni siquiera en las consultas que la eligieron, y que fue la mejor de varios intentos.

Regla práctica: Adopta una mezcla solo cuando supere al mejor recuperador individual en consultas reservadas, con un valor p de permutación por debajo de un umbral corregido por el número de comparaciones planificadas. Cuando no lo haga, conserva el sistema más simple. Eso deja a la recuperación semántica como el ranker de la tienda que hay que superar. Conserva los pesos ajustados y el código, y vuelve a probar las mezclas cuando cambie un recuperador o el catálogo.

Aprende pesos de términos dispersos con SPLADE

Último cambio en la edición 2026.11.10

En lugar de fusionar dos recuperadores, puedes modificar uno para que se le escape menos. BM25 solo encuentra las palabras que aparecen en el texto de un producto. La recuperación dispersa aprendida conserva la maquinaria de BM25, un índice invertido de términos, pero hace que un modelo neuronal elija los términos de cada producto y sus pesos. SPLADE es un modelo de recuperación dispersa aprendida (Formal et al., 2021). Un modelo de lenguaje de la familia BERT, un transformador que lee el texto como tokens de subpalabras, lee el texto del producto y, en cada token i, asigna a cada término j de su vocabulario una puntuación bruta w_ij. ReLU pone a 0 las puntuaciones negativas, y el artículo original suma un logaritmo de lo que queda sobre los tokens del texto:

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

El logaritmo es una saturación, como la de BM25: en palabras de los autores, "evita que algunos términos dominen y garantiza de forma natural la dispersión de las representaciones". SPLADE v2 sustituyó la suma por el máximo sobre los tokens, y los autores hicieron del max pooling su opción por defecto (Formal et al., 2021, SPLADE v2). Un vector SPLADE tiene una dimensión por entrada del vocabulario, 30,522 en el vocabulario de BERT, y normalmente más del 99 % de ellas son cero (Sentence Transformers). Los términos no nulos de un vector SPLADE incluyen términos de expansión: palabras que el texto no contiene pero que el modelo pondera de todos modos, de modo que un producto puede coincidir con una palabra de la consulta que nunca usa.

Los términos de expansión atacan uno de los fallos de BM25 en la tienda. Cuenta, en las consultas de entrenamiento, cuántos productos exactos carecen de al menos una de las palabras de la consulta, tal como las ve el tokenizador de BM25:

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 Superado
"""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())
Salidapython 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 exactos (consulta, producto), 1454 no contienen al menos una palabra de la consulta, una proporción de 0.751. Las palabras que más a menudo faltan, con sus recuentos, son ligth (193), decorative (134), modern (102), freestanding (78), floats (58), queen (57), dining (56), infant (43). Algunas son erratas, a las que apunta el corrector del capítulo 8, y formas en plural, que el capítulo 5 reduce a raíz; otras son palabras descriptivas que el texto del producto omite, o palabras distintas para una misma cosa.

Para midcentury tv unit, los productos exactos usan otras palabras. De los 25 productos exactos, 0 contienen midcentury y 0 contienen unit. Su texto dice mid-century en cambio en 20, y stand en 25.

Los términos de expansión apuntan a huecos como estos, aunque que un modelo aprenda que un mueble para TV es una unidad para TV es algo que habría que medir.

El informe técnico de los propios autores de SPLADE da a SPLADE-v3 un MRR@10 superior a 0.40 en el conjunto de desarrollo de MS MARCO, un benchmark de ordenación de pasajes en el que MRR@10 mide en qué posición cae el primer pasaje relevante, y lo describe como "comparable a los re-rankers de tipo cross-encoder" (Lassance et al., 2024). El libro no ejecuta SPLADE. Los puntos de control de referencia, naver/splade-cocondenser-ensembledistil y naver/splade-v3, tienen licencia CC-BY-NC-SA-4.0, que impide el uso comercial. Un modelo con licencia Apache-2.0, opensearch-neural-sparse-encoding-doc-v3-distill, ejecuta su modelo neuronal solo sobre los productos, y codifica las consultas con un tokenizador y una tabla de pesos.

Regla práctica: Considera la recuperación dispersa aprendida cuando los fallos de BM25 se deban sobre todo a diferencias de vocabulario y quieras conservar un índice invertido. Revisa primero la licencia del modelo, y mídelo como a cualquier recuperador: por sí solo, por consulta, en las consultas de entrenamiento y luego en las de prueba.

Emparejar token por token con ColBERT

Último cambio en la edición 2026.11.10

Donde SPLADE cambia la recuperación léxica, la interacción tardía cambia la recuperación semántica. La recuperación semántica de la tienda es de vector único: un embedding por producto y uno por consulta, que se comparan una sola vez. La interacción tardía mantiene un vector por token en lugar de uno por texto, por lo que también se llama recuperación multivector. ColBERT codifica la consulta y el producto por separado, como lo hace un modelo de embeddings, y solo los compara al final. Para cada token de la consulta, ColBERT busca el token del producto más parecido y suma esos máximos, una operación llamada MaxSim (Khattab and Zaharia, 2020):

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

Como los productos se codifican sin la consulta, sus vectores de token se calculan de antemano, algo que un cross-encoder no puede hacer: lee ambos textos como una sola entrada. El artículo de ColBERT informa de una eficacia "competitiva con los modelos existentes basados en BERT" que leen la consulta y el pasaje juntos, con velocidades "dos órdenes de magnitud más rápidas". El precio es el almacenamiento: un vector por token en lugar de uno por producto. ColBERTv2 los comprime, reduciendo entre 6 y 10 veces el espacio que necesitan los modelos de interacción tardía (Santhanam et al., 2022).

Vuelve a midcentury tv unit, cuyos productos exactos di stand, nunca unit. Un vector único reduce toda la consulta a una dirección y todo el texto del producto a otra. Con la interacción tardía, el unit de la consulta se compara con cada token del producto, entre ellos stand, y su mejor coincidencia cuenta por sí sola. La comparación a nivel de token ayuda en algunos casos difíciles. En NevIR, un benchmark de negación en el que la elección aleatoria obtiene un 25%, ColBERTv1 obtuvo un 19.7% y ColBERTv2 un 13.0%, por encima de todos los modelos de vector único probados (12% o menos), aunque aún por debajo del azar (Weller et al., 2024). En BEIR, un benchmark que evalúa los modelos en modo zero-shot, con conjuntos de datos con los que no fueron entrenados, los rerankers y los modelos de interacción tardía "en promedio logran el mejor rendimiento zero-shot", a un alto coste computacional (Thakur et al., 2021). Existen herramientas abiertas, como la biblioteca PyLate y el modelo Apache-2.0 lightonai/GTE-ModernColBERT-v1 (Chaffin and Sourty, 2025). El libro tampoco ejecuta ColBERT.

Regla práctica: Considera la interacción tardía cuando la recuperación de vector único pasa por alto detalles que dependen de una sola palabra y puedes permitirte un vector por token. Para un catálogo del tamaño del de la tienda, te recomendamos probar primero un reranker sobre una lista corta de candidatos (capítulo 9): lee los mismos detalles en el momento de la consulta y no necesita un nuevo índice, aunque ninguno de los rerankers del capítulo 9 muestra una mejora establecida frente a la recuperación semántica de la tienda.

Decide cuándo la recuperación híbrida compensa

Último cambio en la edición 2026.11.8

Si la fusión ayuda depende de los recuperadores que se fusionan, y los estudios publicados apuntan en ambas direcciones. La recuperación léxica y la densa (densa significa basada en embeddings) pueden complementarse incluso cuando el modelo denso es más débil: fuera de su dominio, un híbrido zero-shot mejoró un 20.4% en términos relativos al modelo de recuperación profunda, como promedio de tres conjuntos de datos (T. Chen et al., 2022). La línea base léxica importa. Los autores de DPR, un recuperador denso, encontraron poca ganancia con un híbrido, y una replicación con un BM25 más fuerte halló "ganancias estadísticamente significativas" (Ma et al., 2021). La fuerza del recuperador semántico también importa. En BRIGHT, un banco de pruebas de consultas que exigen mucho razonamiento, fusionar BM25 mediante una suma ponderada de puntuaciones min-max con α = 0.5 añadió de 3.5 a 4.9 puntos de nDCG@10 a los recuperadores densos de nivel medio y costó a los dos más fuertes entre 2.0 y 2.9. Los autores advierten que la fusión puede perjudicar a recuperadores que ya son fuertes, porque "la lista fusionada promueve documentos léxicamente similares pero semánticamente irrelevantes" (Abdallah et al., 2026).

Los informes de producción suelen comparar un híbrido con la búsqueda solo léxica. Una preimpresión de un minorista informa que la búsqueda híbrida léxica y vectorial superó a la búsqueda solo léxica en una prueba A/B en línea, elevando la tasa de clics en un 0.97% y la de conversión en un 0.98% (Sonagara et al., 2026). Eso es evidencia para añadir recuperación semántica a un sistema léxico, no para añadir recuperación léxica a un sistema semántico fuerte, que es la pregunta de la tienda.

La tienda se encuentra en el caso de recuperador fuerte: en las consultas de prueba, el capítulo 3 establece la ventaja de la recuperación semántica sobre BM25, y ninguna mezcla ajustada la supera. El BM25 de la tienda es la línea base sin stemming del libro. El capítulo 5 construye una más fuerte, y la replicación de Ma et al. es una razón para volver a probar las mezclas con ella.

Fusionar puntuaciones no es el único tipo de híbrido. Un motor de búsqueda también puede usar coincidencias léxicas como filtro de la recuperación semántica: un motor añade un operador de embeddings a su lenguaje de consultas, de modo que "expresiones de recuperación híbrida, con combinaciones arbitrarias de embeddings y términos" se ejecutan como una sola consulta (Huang et al., 2020). Un filtro para la tienda podría exigir que una talla como 48 coincida exactamente, y luego ordenar las coincidencias por embedding. Es una hipótesis que hay que probar, no un resultado, y un filtro ingenuo falla con 7qt slow cooker, cuya ortografía ningún producto usa. Decidir cuándo una consulta lleva una restricción así es comprensión de consultas (capítulo 8), y el capítulo 8 prueba un filtro así sobre los mensajes de seguimiento de los clientes que mencionan un color, una forma, una talla o un acabado. Elegir un peso por consulta también es comprensión de consultas, y este libro no lo construye. Escoger el mejor ranking para cada consulta de entrenamiento daría 0.802, y un peso por consulta, que mezcla las listas, no está limitado por esa cifra. Un método por consulta pide a un LLM, un modelo de lenguaje grande, que juzgue el resultado superior de cada recuperador y fija α a partir de ello (Hsu and Tzeng, 2025). El estudio de BRIGHT encontró inestable una variante de este basada en puntuaciones (Abdallah et al., 2026).

Regla práctica: Recomendamos probar un híbrido cuando tus dos recuperadores son parecidos en calidad, cuando tu modelo de embeddings funciona fuera del dominio para el que se entrenó, o cuando muchas consultas dependen de términos exactos que tus embeddings no captan. Empieza con RRF ponderado: solo necesita rangos, y en las consultas de entrenamiento de la tienda la prueba de permutación no pudo distinguirlo de la suma ponderada. Pasa a una suma ponderada de puntuaciones normalizadas cuando ambos motores te den puntuaciones para cada candidato: dos estudios la encontraron por delante de RRF en sus datos (Bruch et al., 2023; Abdallah et al., 2026), y en las consultas de entrenamiento de la tienda su peso fue el más estable. Cuando un recuperador se establece como el más fuerte en consultas reservadas y ninguna mezcla ajustada lo supera allí, úsalo solo, conserva el otro como línea base y prueba un filtro léxico para las restricciones exactas. Ese es el caso de la tienda.

Qué sale mal en producción

Último cambio en la edición 2026.11.8

Dos recuperadores cuestan dos de todo. Los ejemplos puntúan una muestra del catálogo sin conexión, pero una búsqueda híbrida en vivo mantiene actualizados dos índices y ejecuta dos búsquedas por consulta. Pueden correr en paralelo, pero la más lenta fija el tiempo de respuesta, y un fallo en cualquiera de las dos degrada el resultado. Cuenta ese coste frente a la ganancia que mediste.

Las listas cortas descartan candidatos. La fusión no puede ordenar un producto que ninguno de los dos recuperadores devolvió. En las consultas de entrenamiento de la tienda, la unión de dos listas de los 100 primeros contiene 0.810 de los productos exactos de cada consulta, y la unión de dos listas de los 20 primeros, 0.445. Un límite de profundidad en la configuración de un motor puede eliminar candidatos sin que nadie lo note.

Las puntuaciones que faltan necesitan una regla. Cuando cada recuperador devuelve solo sus k primeros, un producto ausente de una lista no tiene puntuación de ese recuperador. La replicación de DPR le asigna "la puntuación mínima de recuperación densa entre los documentos recuperados", y lo contrario para BM25 (Ma et al., 2021). Bruch et al. calculan en cambio la puntuación que falta de forma exacta, como lo hace lib.blend.candidates, algo que un motor de producción quizá no te permita (Bruch et al., 2023).

El min-max es relativo. El mejor candidato de una consulta siempre obtiene 1, incluso cuando todos los candidatos son malos. Una consulta que no comparte ninguna palabra con ningún producto del catálogo da a todos los candidatos una puntuación BM25 de 0. El min-max simple divide entonces entre cero, y lib.blend devuelve ceros, de modo que la mezcla pasa en silencio a ser solo recuperación semántica. Ninguna consulta de la tienda hace esto; un cuadro de búsqueda en vivo sí lo hará.

Una puntuación fusionada no es una confianza. Las puntuaciones de recuperación están mal calibradas: "La calibración de la confianza es sistemáticamente débil en las familias de modelos" (Abdallah et al., 2026). No fijes un umbral sobre una puntuación fusionada para decidir que una consulta no tiene buenos resultados.

Un peso ajustado pertenece a un par de recuperadores. La α de la tienda está ajustada a esta configuración de BM25, a este modelo de incrustaciones y a este catálogo. Si cambias cualquiera de ellos, vuelve a ajustar con consultas de entrenamiento antes de confiar en el peso anterior. Un RRF ajustado "generaliza mal a conjuntos de datos fuera de dominio" (Bruch et al., 2023).

Regla práctica: Registra los rangos de ambos recuperadores junto al resultado fusionado, revisa la profundidad de las listas en la configuración de cada motor y vuelve a ajustar α cada vez que cambie un recuperador.

Decisiones que tomó este capítulo

Último cambio en la edición 2026.11.8

Un cambio posterior tendrá que superar cada una de estas por una razón.

  • Ajustar con el conjunto de entrenamiento, informar con el de prueba. Todo análisis y todo ajuste usa las 50 consultas de entrenamiento. El capítulo lee las consultas de prueba una sola vez, para informar.
  • Dos comparaciones planificadas, en cada una la mezcla ajustada frente a la recuperación semántica, decididas por la prueba de permutación con 0.05 dividido entre 2, junto con la prueba t y un intervalo de confianza bootstrap.
  • Comprobar cada recuperador antes de fusionar, con judged@10 y una prueba pareada, y contar por consulta dónde gana cada uno.
  • Candidatos: la unión de los 100 primeros de ambos recuperadores, con las dos puntuaciones buscadas para cada candidato, de modo que ningún producto quede sin puntuación.
  • Normalización: min-max por consulta. La prueba de permutación sobre el conjunto de entrenamiento no puede distinguir las otras dos normalizaciones de esta con 0.05, y min-max no requiere conocer ninguna de las dos funciones de puntuación.
  • RRF: k = 60, con listas de profundidad 100. El mejor k en entrenamiento no mejora sobre 60 de forma que la prueba de permutación pueda distinguir del azar con 0.05, y cambia con el orden de los empates de BM25. Una lista más profunda solo puede añadir candidatos.
  • Un peso, α, ajustado entre 0 y 1 en pasos de 0.1 para ambas mezclas, elegido por el nDCG@10 medio en entrenamiento, luego verificado con bootstrap y ajustado de nuevo invirtiendo los empates de BM25. El α de la suma ponderada se mantiene con ambas comprobaciones; el de RRF ponderado no.
  • SPLADE y ColBERT se describen, no se registran, porque ninguno de los dos es necesario para responder la pregunta de la tienda.
  • Adoptar una mezcla solo si supera al mejor recuperador individual en la prueba. Ninguna de las dos mezclas ajustadas lo hace, así que el ranker de la tienda que hay que superar sigue siendo la recuperación semántica por sí sola, con BM25, sin stemming, como línea base.
  • Lo que mostró el capítulo: una mezcla solo puede ayudar donde sus recuperadores fallan en consultas distintas, y un peso que gana en entrenamiento debe mantenerse en prueba; en la tienda, ninguna de las dos mezclas ajustadas superó a la recuperación semántica.

Este capítulo, en esta edición

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

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

Cita esta sección

Formato

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

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

En esta página

Capítulo 7 de 11: Recuperación híbrida

  1. Encuentra las consultas que gana cada recuperador
  2. Verifica cada recuperador antes de fusionar
  3. Normaliza las puntuaciones antes de sumarlas
  4. Prueba los ajustes de la fusión recíproca de rangos con las consultas de entrenamiento
  5. Ajusta el peso de la mezcla con las consultas de entrenamiento
  6. Comprueba que el peso ajustado sea estable
  7. Informa de las mezclas ajustadas sobre las consultas de prueba
  8. Aprende pesos de términos dispersos con SPLADE
  9. Emparejar token por token con ColBERT
  10. Decide cuándo la recuperación híbrida compensa
  11. Qué sale mal en producción
  12. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos