Medir la búsqueda
Unos 37 minutos de lectura, con 12 ejemplos en 13 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.10. Lee el original
En esta página
- Cuenta los productos relevantes en los k primeros
- Puntúa el primer resultado relevante con el rango recíproco
- Construir nDCG a partir de ganancias descontadas
- Haz coincidir tu cálculo con el
ndcg_scorede scikit-learn - Elige una métrica antes de comparar
- Lee las diferencias por consulta, no solo la media
- Contrasta una diferencia con una prueba de permutación
- Obtén el valor p de una prueba t pareada
- Informa de cuán grande es la diferencia
- Decide por adelantado qué se considera establecido
- Compara ejecuciones en un arnés de evaluación
- Qué sale mal en producción
- Decisiones que tomó este capítulo
Al final de este capítulo podrás calcular desde cero las métricas estándar de ranking, compararlas con scikit-learn, elegir una antes de comparar rankers y decidir si la diferencia entre dos rankers en tus consultas de prueba está comprobada o podría deberse al azar.
El capítulo 1 terminó con un orden de los rankers, con la recuperación semántica como el ranker que hay que superar. En las consultas de prueba de la tienda, búsquedas con las que no se ajustó ningún ranker, BM25 obtiene un nDCG@10 de 0.725, la recuperación semántica 0.830, el híbrido 0.812 y el híbrido con reranking 0.798. Antes de poder confiar en ese orden hay que responder dos preguntas. ¿Miden las métricas lo que importa a una persona que compra, y están calculadas correctamente? ¿Son reales las diferencias, o podría el azar producirlas con 30 consultas? Este capítulo responde a ambas y termina con la regla del libro para una diferencia comprobada y con un arnés que la aplica.
Cuenta los productos relevantes en los k primeros
La mayoría de las métricas de ranking parten de una pregunta: ¿cuántos de los resultados que ve el comprador son relevantes? La precisión en k, escrita precision@k, es la proporción de los k primeros resultados que son relevantes. La exhaustividad en k, recall@k, es la proporción de todos los productos relevantes que aparecen entre los k primeros. Manning y sus colegas describen la precisión como la proporción de documentos recuperados que son relevantes, y la exhaustividad como la proporción de documentos relevantes que se recuperan, y señalan que subir una suele costar la otra (Manning et al., 2008, sección 8.3). Ambas necesitan una idea de relevante de sí o no. En este libro, un producto es relevante para una consulta cuando su juicio es exacto, grado 2. Un producto que nadie juzgó para la consulta se cuenta como no relevante.
Los 10 primeros resultados de BM25 para la consulta de prueba de la tienda clear shower curtain mezclan cortinas transparentes, cortinas que no son transparentes y ganchos para cortina de ducha. ¿Cuántos de esos diez son exactos, y cuál es la puntuación máxima que podría obtener cualquier consulta de prueba? El ejemplo responde ambas preguntas a mano y comprueba el recuento con lib.metrics:
1"""Counts the exact products in BM25's top 10 for one query, computes precision and recall by hand, and checks them against lib.metrics, then finds the best score each test query could reach. The prose's point rests on the "exact in the top 10" and "exact products judged" lines, and on the ceiling lines after the blank line."""2import pandas as pd34from lib.lexical import LexicalSearch5from lib.metrics import precision_at_k, recall_at_k6from lib.store import load_products, load_queries, qrels78queries, judgments = load_queries("test"), qrels("test")9ranking = list(LexicalSearch(load_products()).search(queries.at[246, "query"], k=10).index) # clear shower curtain10# grade 2 is exact; a product the judges never graded is absent from this dict, so it is not exact11exact = {product_id for product_id, grade in judgments[246].items() if grade == 2}1213found = sum(product_id in exact for product_id in ranking[:10])14print("exact in the top 10:", found)15print("exact products judged:", len(exact))16print(f"precision@10 by hand: {found / 10:.3f}")17print(f"recall@10 by hand: {found / len(exact):.3f}")18print(f"precision@10 from lib.metrics: {precision_at_k(ranking, judgments[246], 10):.3f}")19print(f"recall@10 from lib.metrics: {recall_at_k(ranking, judgments[246], 10):.3f}")2021# the best any ranking can do: a top 10 that holds as many exact products as the query has22exact_counts = pd.Series({query_id: sum(grade == 2 for grade in per_query.values())23 for query_id, per_query in judgments.items()})24# a top 10 can hold at most 10 exact products, and no more than the query has25best_precision = exact_counts.clip(upper=10) / 1026# only 10 results are shown, so at most 10 of a query's exact products can be retrieved27best_recall = exact_counts.clip(upper=10) / exact_counts28print()29print("queries where precision@10 can't reach 1:", (best_precision < 1).sum())30print("fewest exact products for a query:", exact_counts.min())31print("queries with that few:", (exact_counts == exact_counts.min()).sum())32print(f"best precision@10 for those queries: {best_precision.min():.3f}")33print("queries where recall@10 can't reach 1:", (best_recall < 1).sum())34most = exact_counts.idxmax()35print("query with the most exact products:", queries.at[most, "query"])36print("its exact products:", exact_counts[most])37print(f"its best recall@10: {best_recall[most]:.3f}")
python precision-recall-by-hand.pyexact in the top 10: 4
exact products judged: 12
precision@10 by hand: 0.400
recall@10 by hand: 0.333
precision@10 from lib.metrics: 0.400
recall@10 from lib.metrics: 0.333
queries where precision@10 can't reach 1: 7
fewest exact products for a query: 4
queries with that few: 4
best precision@10 for those queries: 0.400
queries where recall@10 can't reach 1: 22
query with the most exact products: outdoor light fixtures
its exact products: 170
its best recall@10: 0.059
lib.metrics coincide con el recuento a mano. De los 10 primeros, 4 son exactos, así que la precision@10 es 0.400. Frente a los 12 productos exactos que los jueces marcaron para esta consulta, el recall@10 es 0.333. precision_at_k y recall_at_k dan los mismos dos valores.
Ninguna de estas métricas tiene un techo único para todas las consultas. Una consulta con menos de 10 productos exactos no puede llenar sus 10 primeros con ellos, así que la precision@10 no puede llegar a 1. 7 consultas de prueba son así, y las 4 con solo 4 productos exactos puede alcanzar como mucho una precision@10 de 0.400.
Una consulta con más de 10 productos exactos no puede alcanzar la exhaustividad completa en 10 resultados. Eso ocurre con 22 de las consultas de prueba. La consulta con más, outdoor light fixtures, tiene 170 productos exactos, así que su recall@10 llega como máximo a 0.059. Una media sobre las consultas de prueba mezcla consultas que pueden puntuar 1 con consultas que no pueden.
La exhaustividad tiene un segundo problema, porque su denominador cuenta solo los productos exactos que los jueces encontraron. WANDS juzgó los candidatos reunidos para cada consulta, no el catálogo completo (capítulo 1), así que algunos productos exactos nunca se juzgaron. Zobel halló que los juicios reunidos así sobrestiman la exhaustividad (Sé de dónde vienen los juicios).
Regla práctica: Usa la precision@10 cuando te importe cuánta parte de la primera página es correcta, y léela junto al techo de cada consulta. No hagas de la recall@10 un titular en la búsqueda de productos, donde una consulta puede tener más de cien productos relevantes, como ocurre con outdoor light fixtures. Recomendamos la exhaustividad a un corte profundo, como los 100 primeros, para una sola tarea: comprobar que la recuperación pasa al reranker suficientes productos relevantes. Incluso así, léela como una sobrestimación.
Puntúa el primer resultado relevante con el rango recíproco
La precisión cuenta una página completa, pero algunas personas que compran quieren un único producto: una pieza de repuesto, o un modelo que ya conocen. Para ellas, lo que importa es qué tan abajo aparece el primer buen resultado. El rango recíproco (RR) puntúa una consulta como 1 dividido entre la posición del primer resultado relevante, o 0 si no hay ninguno, y la media del RR sobre las consultas es la media del rango recíproco (MRR). TREC, la Text REtrieval Conference, organiza evaluaciones compartidas de sistemas de búsqueda. La MRR fue la medida oficial de su pista de respuesta a preguntas en TREC-8, donde cada pregunta puntuaba el recíproco del rango de la primera respuesta correcta, o 0 cuando ninguna de las cinco respuestas era correcta. La pista la eligió en parte porque se mantiene entre 0 y 1 y se promedia bien (Voorhees, 1999).
Promediar el RR es objeto de debate. Fuhr señala que con el RR "la diferencia entre los rangos 1 y 2 es la misma que entre los rangos 2 y ∞", por lo que el RR no es una escala de intervalo, una en la que pasos iguales significan diferencias iguales, y sostiene que no debería calcularse su media (Fuhr, 2017, sección 2.1). Sakai no ve razón para prohibirlo (Sakai, 2020). Moffat sostiene que estas métricas tienen más sentido en su forma actual que en las versiones intervalizadas que se les han propuesto (Moffat, 2022). Usamos la MRR con esa salvedad: es un resumen grueso.
El RR depende de dónde trazas la línea de lo relevante, así que puntúa dos veces el ranking de BM25 para clear shower curtain: una contando solo los productos exactos, otra contando también los parciales. Después calcula la MRR de BM25 y de la recuperación semántica sobre las consultas de prueba:
1"""Writes reciprocal rank by hand for one query under two grade thresholds, then computes MRR for BM25 and semantic retrieval and checks it against lib.metrics. The prose's point rests on the two rr lines for clear shower curtain and the two MRR lines."""2import pandas as pd34from lib.lexical import LexicalSearch5from lib.metrics import evaluate6from lib.semantic import SemanticSearch7from lib.store import load_products, load_queries, qrels8910# relevant=2 counts only exact products; relevant=1 counts partial ones too11def reciprocal_rank(ranking, judgments, relevant=2):12 """1 / the position of the first relevant product, or 0 if the ranking has none."""13 # positions count from 1, as a shopper counts results14 for position, product_id in enumerate(ranking, start=1):15 # a product nobody judged has grade 0, so it never counts as relevant16 if judgments.get(product_id, 0) >= relevant:17 return 1 / position18 return 0.0192021queries, judgments = load_queries("test"), qrels("test")22# each run goes 100 products deep, so RR can look past the top 10 for the first exact product23runs = {"bm25": LexicalSearch(load_products()).run(queries, k=100), "semantic": SemanticSearch().run(queries, k=100)}2425ranking = runs["bm25"][246] # clear shower curtain26print(f"rr, exact counts as relevant: {reciprocal_rank(ranking, judgments[246]):.3f}")27print(f"rr, partial or better counts: {reciprocal_rank(ranking, judgments[246], relevant=1):.3f}")2829for name, run in runs.items():30 rr = pd.Series({query_id: reciprocal_rank(run[query_id], judgments[query_id]) for query_id in judgments})31 print(f"{name} mrr: {rr.mean():.3f}")32 print(f"{name} mrr from lib.metrics: {evaluate(run, judgments)['rr'].mean():.3f}")33 print(f"{name} queries with rr of 1:", (rr == 1).sum())
python reciprocal-rank-by-hand.pyrr, exact counts as relevant: 0.500
rr, partial or better counts: 1.000
bm25 mrr: 0.650
bm25 mrr from lib.metrics: 0.650
bm25 queries with rr of 1: 16
semantic mrr: 0.787
semantic mrr from lib.metrics: 0.787
semantic queries with rr of 1: 22
El umbral de calificación cambia el RR de esta única consulta. El primer resultado de BM25 para clear shower curtain es una coincidencia parcial y el segundo es exacto, así que el RR es 0.500 cuando solo cuentan los productos exactos, y 1.000 cuando también cuentan los parciales. Siempre que cites un RR, indica qué calificaciones cuentan. La media sobre las consultas de prueba coincide con la columna rr de lib.metrics.evaluate: BM25 obtiene 0.650 y la recuperación semántica 0.787. Esa columna busca el primer producto exacto en cualquier lugar de la ejecución, no solo en los 10 primeros.
El RR tiene un punto ciego. Vale 1 para 22 consultas de prueba con recuperación semántica y para 16 con BM25, y en esas consultas no ve nada por debajo del primer resultado. Un ranking que pone un producto exacto en primer lugar y nueve irrelevantes después puntúa igual que un top 10 perfecto.
Regla práctica: Informa de la MRR como cifra principal solo cuando las personas que compran necesiten un único producto correcto, como con un número de modelo o un producto con nombre, por ejemplo kohler whitehaven farmhouse kitchen sink. Para las consultas en las que las personas navegan por una página de opciones, como wooden chair outdoor, usa nDCG@10 como cifra principal e informa de la MRR junto a ella.
Construir nDCG a partir de ganancias descontadas
A diferencia de la precisión y de RR, nDCG@10, que el capítulo 1 usó para puntuar un ranking, lee las calificaciones. Cada resultado aporta su calificación como ganancia, reducida por un descuento que crece con su posición, y la suma es la ganancia acumulada descontada (DCG). El DCG normalizado (nDCG) divide el DCG de un ranking entre el DCG del ranking ideal. Dos de sus partes admiten varias versiones que cambian el resultado. La primera es el ranking ideal. Järvelin y Kekäläinen, que introdujeron DCG, lo basan en «la base de recuperación del tema de búsqueda y no en el resultado de alguna técnica de RI» (Järvelin y Kekäläinen, 2002). En la práctica, eso significa el mejor orden de todos los productos evaluados para la consulta, no solo el de los productos que devolvió un sistema de ranking. La segunda es el descuento: ellos propusieron dividir la puntuación de un documento entre el logaritmo de su posición, y las versiones difieren en qué logaritmo se usa y a partir de qué posición.
La fórmula en lib.metrics, donde grade(i) es la calificación del producto en la posición i:
DCG@k = sum over positions i from 1 to k of grade(i) / log2(i + 1)
nDCG@k = DCG@k / DCG@k of the ideal ranking
Esta no es la única versión en uso. Järvelin y Kekäläinen dejaron sin descuento las posiciones por debajo de la base del logaritmo, de modo que, con base 2, las dos primeras posiciones cuentan íntegras. Burges et al. usaron una ganancia exponencial, 2^grade − 1, con un descuento log(1 + rank) (Burges et al., 2005). Las herramientas de evaluación también difieren: la documentación de ir-measures enumera opciones de nDCG distintas para pytrec_eval y para gdeval (ir-measures). Por eso, siempre que cites un nDCG, indica la variante.
Escribe DCG y nDCG desde cero, y compáralos con lib.metrics en las ejecuciones de BM25, semántica e híbrida del capítulo 1. Una de las puntuaciones parece demasiado buena para ser cierta:
1"""Writes DCG and nDCG from scratch and checks them against lib.metrics on every test query of three runs, then prints one query's grades beside its best possible grades. The prose's point rests on the largest-difference line and on the ndcg@10 line for luau string lights, read with the grade lines above it."""2import math34from lib.fusion import reciprocal_rank_fusion5from lib.lexical import LexicalSearch6from lib.metrics import ndcg_at_k7from lib.semantic import SemanticSearch8from lib.store import load_products, load_queries, qrels91011def dcg(grades, k):12 """Each grade divided by log2 of its position plus one, added up over the top k."""13 # positions count from 1, so the first result is divided by log2(2)14 return sum(grade / math.log2(position + 1) for position, grade in enumerate(grades[:k], start=1))151617def ndcg(ranking, judgments, k=10):18 """DCG of the ranking over DCG of the best order of every judged product (unjudged counts as 0)."""19 # the ideal ranking: every judged product, best grade first20 ideal = dcg(sorted(judgments.values(), reverse=True), k)21 # a product nobody judged counts as grade 0 in the ranking22 return dcg([judgments.get(product_id, 0) for product_id in ranking], k) / ideal232425queries, judgments = load_queries("test"), qrels("test")26bm25 = LexicalSearch(load_products()).run(queries, k=100)27semantic = SemanticSearch().run(queries, k=100)28runs = {"bm25": bm25, "semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}2930gaps = [abs(ndcg(run[query_id], judgments[query_id]) - ndcg_at_k(run[query_id], judgments[query_id], 10))31 for run in runs.values() for query_id in judgments]32print("rankings checked:", len(gaps))33print(f"largest difference from lib.metrics: {max(gaps):.3f}")3435ranking, per_query = bm25[461], judgments[461] # luau string lights36print()37print("query:", queries.at[461, "query"])38print("grades in the top 10:", [per_query.get(product_id, 0) for product_id in ranking[:10]])39print("best possible grades:", sorted(per_query.values(), reverse=True)[:10])40print("exact products judged:", sum(grade == 2 for grade in per_query.values()))41print("exact in the top 10:", sum(per_query.get(product_id, 0) == 2 for product_id in ranking[:10]))42print(f"ndcg@10: {ndcg(ranking, per_query):.3f}")
python ndcg-from-scratch.pyrankings checked: 90
largest difference from lib.metrics: 0.000
query: luau string lights
grades in the top 10: [2, 2, 2, 2, 1, 1, 1, 1, 1, 1]
best possible grades: [2, 2, 2, 2, 1, 1, 1, 1, 1, 1]
exact products judged: 4
exact in the top 10: 4
ndcg@10: 1.000
En los 90 rankings, la versión escrita a mano nunca difiere de lib.metrics en más de 0.000.
Para luau string lights, el top 10 de BM25 contiene 4 productos exactos y obtiene 1.000. No es un error. La consulta solo tiene 4 productos exactos evaluados, así que el mejor top 10 posible contiene esos y luego los parciales, y BM25 encontró ese orden. Un nDCG@10 de 1 significa «tan bueno como el mejor orden de los productos evaluados», no «diez productos exactos».
Regla práctica: Usa la forma de ganancia lineal, log2(i + 1), con un corte en 10, con el ranking ideal construido a partir de todos los productos evaluados, e indica esa variante siempre que cites un número. Compara nDCG solo entre ejecuciones puntuadas con los mismos juicios: los juicios nuevos cambian el ranking ideal y, con él, todas las puntuaciones.
Haz coincidir tu cálculo con el ndcg_score de scikit-learn
Verifica una métrica contra una biblioteca que la calcula de forma independiente. En la versión 1.9.1 de scikit-learn, ndcg_score usa la misma variante que lib.metrics: las calificaciones son las ganancias, cada una se divide entre log2(rango + 1), y el DCG normalizador es el de esas mismas calificaciones ordenadas de la mejor manera, cortado en k (código fuente de scikit-learn). Su documentación cita a Järvelin y Kekäläinen, aunque el código implementa la forma posterior rango + 1 (documentación de scikit-learn). Tres detalles hacen que una llamada ingenua no coincida con la tuya:
- Solo puntúa los productos que le pasas, así que construye el ranking ideal a partir solo de ellos.
- Por defecto promedia las ganancias de los productos cuyas puntuaciones empatan ([documentación de scikit-learn]). Eso equivale al promedio sobre todos los órdenes de los productos empatados (McSherry y Najork, 2008).
- Recibe una fila por consulta, todas de la misma longitud, y devuelve la media sobre las filas ([código fuente de scikit-learn]).
Primero va la llamada ingenua: ndcg_score recibe las calificaciones de los 10 primeros de BM25 para clear shower curtain, con puntuaciones que los ponen en el orden de BM25. Después construye la fila de cada consulta como la ve lib.metrics, y compara las tres ejecuciones:
1"""Compares scikit-learn's ndcg_score with lib.metrics for one query, first with only the top 10 passed and then with every judged product in the row, and then on every test query of three runs. The prose's point rests on the ndcg@10 lines for clear shower curtain and on the 5-product lines."""2from sklearn.metrics import ndcg_score34from lib.fusion import reciprocal_rank_fusion5from lib.lexical import LexicalSearch6from lib.metrics import ndcg_at_k7from lib.semantic import SemanticSearch8from lib.store import load_products, load_queries, qrels91011def sklearn_ndcg(ranking, judgments, k=10):12 """One row for one query: every judged product, plus any retrieved product nobody judged."""13 # every judged product once, then the retrieved products nobody judged14 products = list(dict.fromkeys([*judgments, *ranking]))15 position = {product_id: i for i, product_id in enumerate(ranking)}16 grades = [[judgments.get(product_id, 0) for product_id in products]]17 # ndcg_score ranks by score, so the negated position puts rank 1 highest18 scores = [[-position.get(product_id, len(ranking)) for product_id in products]] # not retrieved: below all19 return ndcg_score(grades, scores, k=k)202122queries, judgments = load_queries("test"), qrels("test")23bm25 = LexicalSearch(load_products()).run(queries, k=100)24semantic = SemanticSearch().run(queries, k=100)25runs = {"bm25": bm25, "semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}2627top = bm25[246][:10] # clear shower curtain28# scores 10 down to 1 put the top 10 in BM25's order, so the first product scores highest29naive = ndcg_score([[judgments[246].get(product_id, 0) for product_id in top]], [list(range(10, 0, -1))], k=10)30print(f"ndcg@10, only the top 10 passed: {naive:.3f}")31print(f"ndcg@10 from lib.metrics: {ndcg_at_k(top, judgments[246], 10):.3f}")32print(f"ndcg@10, every judged product passed: {sklearn_ndcg(top, judgments[246]):.3f}")3334gaps = [abs(sklearn_ndcg(run[query_id], judgments[query_id]) - ndcg_at_k(run[query_id], judgments[query_id], 10))35 for run in runs.values() for query_id in judgments]36print("rankings compared:", len(gaps))37print(f"largest difference: {max(gaps):.3f}")3839short = bm25[246][:5] # a ranking shorter than k40print(f"5-product ranking, lib.metrics: {ndcg_at_k(short, judgments[246], 10):.3f}")41print(f"5-product ranking, scikit-learn: {sklearn_ndcg(short, judgments[246]):.3f}")
python ndcg-matches-scikit-learn.pyndcg@10, only the top 10 passed: 0.901
ndcg@10 from lib.metrics: 0.615
ndcg@10, every judged product passed: 0.615
rankings compared: 90
largest difference: 0.000
5-product ranking, lib.metrics: 0.539
5-product ranking, scikit-learn: 0.629
Al pasarle solo los 10 primeros, ndcg_score devuelve 0.901, frente a 0.615 de lib.metrics, porque divide entre el mejor orden de esos diez productos solamente, así que no puede ver los productos exactos que BM25 dejó fuera. lib.metrics divide entre el mejor orden de todos los 253 productos juzgados para la consulta. El ejemplo de sklearn_ndcg corrige eso con una receta. Cada fila contiene todos los productos juzgados, más cualquier producto recuperado que nadie haya juzgado, con calificación 0. La receta puntúa los productos recuperados según su rango, y da a todos los demás una misma puntuación inferior a la de todos ellos. Con esa receta, ambos coinciden en los 90 rankings (la diferencia máxima es 0.000). Llama a ndcg_score una vez por consulta y promedia los resultados tú mismo, porque la fila de cada consulta tiene una longitud distinta.
La receta tiene un límite, y las ejecuciones cortas lo muestran. ndcg_score trata los productos que una ejecución no recuperó como empatados por los lugares vacíos dentro de los k primeros, y acredita a esos lugares su ganancia promedio. lib.metrics no da nada a un lugar vacío, porque el comprador no ve nada allí. Si recortas el ranking de BM25 a 5 productos, las dos discrepan: 0.539 de lib.metrics frente a 0.629 de ndcg_score. Las ejecuciones cortas sí ocurren: LexicalSearch devuelve solo productos con una puntuación superior a 0.
Regla práctica: Informa tu propio nDCG, y usa ndcg_score como verificación independiente, con todos los productos juzgados en la fila de cada consulta y puntuaciones tomadas de los rangos. Antes de comparar ambos, comprueba que cada ejecución tenga al menos k productos. Si en cambio pasas las puntuaciones brutas de un ranker, rompe primero los empates en un orden fijo, por ejemplo por product_id, o ambos discreparán donde las puntuaciones empaten.
Elige una métrica antes de comparar
Cada métrica es un modelo de un comprador. Precision@10 supone que el comprador mira toda la primera página y cuenta los productos buenos que hay en ella. RR supone que el comprador se detiene en el primer producto bueno. nDCG@10 supone que la atención disminuye a medida que se baja por la página y que un producto exacto vale más que uno parcial: con las calificaciones del libro, el doble. Las ganancias exponenciales, 2^grado − 1 como en Burges et al. (2005), convierten las calificaciones en ganancias de 0, 1 y 3, de modo que un producto exacto vale tanto como tres parciales. Como regla general, estos modelos coinciden cuando dos sistemas de ranking están muy separados. Cuando están cerca, la métrica puede decidir al ganador, por eso eliges la métrica antes de mirar los resultados. Fuhr pide hipótesis enunciadas de antemano, en la forma «Queremos comparar los métodos A y B usando la métrica X» (Fuhr, 2017, sección 2.6).
Tomemos la recuperación semántica, el ranking que hay que superar, y el híbrido, que el capítulo 1 no logró separar de ella. Elegir una métrica es parte de ajustar la evaluación, así que haz la elección sobre las 50 consultas de entrenamiento y reserva las consultas de prueba para informar. Puntúa ambos sistemas de cuatro maneras:
1"""Scores semantic retrieval and the hybrid four ways on the train queries and names the higher scorer for each metric. The prose's point rests on the "higher" lines, the count of metrics each ranker wins, and the largest gap."""2from lib.fusion import reciprocal_rank_fusion3from lib.lexical import LexicalSearch4from lib.metrics import evaluate5from lib.semantic import SemanticSearch6from lib.store import load_products, load_queries, qrels78queries, judgments = load_queries("train"), qrels("train") # choosing a metric is tuning: use train9bm25 = LexicalSearch(load_products()).run(queries, k=100)10semantic = SemanticSearch().run(queries, k=100)11runs = {"semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}1213exponential = {query_id: {product_id: 2 ** grade - 1 for product_id, grade in per_query.items()}14 for query_id, per_query in judgments.items()} # gains 0, 1, 3 instead of 0, 1, 215means = {}16for name, run in runs.items():17 scores = evaluate(run, judgments)18 means[name] = {"precision@10": scores["precision@10"].mean(), "mrr": scores["rr"].mean(),19 "ndcg@10": scores["ndcg@10"].mean(),20 "ndcg@10 with exponential gains": evaluate(run, exponential)["ndcg@10"].mean()}2122print("train queries:", len(judgments))23winners = []24for metric in means["semantic"]:25 for name in runs:26 print(f"{name} {metric}: {means[name][metric]:.3f}")27 # max keeps the first name it meets, so on an exact tie the order of runs decides28 winners.append(max(runs, key=lambda name: means[name][metric]))29 print(f"higher {metric}: {winners[-1]}")30for name in runs:31 print(f"metrics won by {name}:", winners.count(name))32print(f"largest gap: {max(abs(means['semantic'][m] - means['hybrid'][m]) for m in means['semantic']):.3f}")
python metric-choice-on-train.pytrain queries: 50
semantic precision@10: 0.502
hybrid precision@10: 0.488
higher precision@10: semantic
semantic mrr: 0.673
hybrid mrr: 0.710
higher mrr: hybrid
semantic ndcg@10: 0.772
hybrid ndcg@10: 0.774
higher ndcg@10: hybrid
semantic ndcg@10 with exponential gains: 0.709
hybrid ndcg@10 with exponential gains: 0.708
higher ndcg@10 with exponential gains: semantic
metrics won by semantic: 2
metrics won by hybrid: 2
largest gap: 0.037
Las cuatro métricas no coinciden en un ganador. La recuperación semántica lidera en 2 de ellas y el híbrido en 2, y ninguna diferencia entre ambos es mayor que 0.037. Cuando dos sistemas están tan cerca, la métrica decide hacia qué lado cae la diferencia. nDCG@10, la métrica principal que eligió el capítulo 1, favorece a hybrid. Se trata de consultas de entrenamiento, así que nada de esto indica cuál sistema es mejor.
Por eso la elección debe seguir al comprador, no al resultado. La tienda muestra una página de productos y sus juicios son graduados, así que nDCG@10 con ganancias lineales sigue siendo la métrica principal, como eligió el capítulo 1, con precision@10 y MRR junto a ella.
Regla práctica: Elige una métrica principal, sus ganancias y su punto de corte antes de comparar sistemas, y anótalos. Recomendamos nDCG@10 con ganancias lineales cuando los juicios son graduados y los compradores navegan por una página. Cambia a ganancias exponenciales cuando una coincidencia exacta vale mucho más que una cercana, como en una pieza de repuesto que debe encajar, y a MRR cuando la mayoría de las consultas tienen una única respuesta correcta. Informa las demás métricas junto a la principal, y nunca cambies la métrica principal después de haber visto qué sistema favorece.
Lee las diferencias por consulta, no solo la media
La media de la métrica principal sobre las consultas es un resumen para la tienda, pero el comprador ve los resultados de una sola consulta. La pista TREC Robust se construyó sobre ese punto. Sus organizadores descubrieron que ajustar el sistema para el promedio puede mejorar las consultas que ya funcionan bien, a veces a costa de las que funcionan mal (Voorhees, 2004). Así que, antes de confiar en un cambio en la media, observa las diferencias por consulta: un número por consulta, la puntuación del nuevo ranker menos la del anterior. Son también la evidencia que usan las pruebas de significación.
En promedio, la ejecución híbrida de la tienda del capítulo 1 puntúa bastante por encima de BM25. Compara las dos consulta por consulta en nDCG@10:
1"""Compares the hybrid and BM25 query by query on nDCG@10, then lists the three largest losses and the largest gain with its judged@10. The prose's point rests on the mean and median difference lines and on the largest-gain lines."""2from lib.fusion import reciprocal_rank_fusion3from lib.lexical import LexicalSearch4from lib.metrics import evaluate5from lib.semantic import SemanticSearch6from lib.store import load_products, load_queries, qrels78queries, judgments = load_queries("test"), qrels("test")9bm25 = LexicalSearch(load_products()).run(queries, k=100)10hybrid = reciprocal_rank_fusion([bm25, SemanticSearch().run(queries, k=100)])11before, after = evaluate(bm25, judgments), evaluate(hybrid, judgments)1213# rounded to three decimals first, so a difference that rounds to 0 counts as a tie; sorted from the largest loss up14difference = (after["ndcg@10"] - before["ndcg@10"]).round(3).sort_values() # one value per test query15print(f"mean difference: {difference.mean():.3f}")16print(f"median difference: {difference.median():.3f}")17print("hybrid better:", (difference > 0).sum())18print("bm25 better:", (difference < 0).sum())19print("tied:", (difference == 0).sum())2021print("\nhybrid's three largest losses:")22print(queries.loc[difference.index[:3], "query"].to_frame().assign(difference=difference[:3]).to_string())23# the last one after sorting: the largest gain24largest = difference.index[-1]25print("\nlargest gain:", queries.at[largest, "query"])26print(f"its gain: {difference[largest]:.3f}")27print(f"its bm25 judged@10: {before.at[largest, 'judged@10']:.3f}")28print(f"share of the mean gain from this query: {difference[largest] / difference.sum():.3f}")2930relative = after["ndcg@10"] / before["ndcg@10"] - 1 # per-query relative gains31print(f"\nrelative gain of the means: {after['ndcg@10'].mean() / before['ndcg@10'].mean() - 1:.3f}")32print(f"mean of per-query relative gains: {relative.mean():.3f}")33print(f"its bm25 ndcg@10: {before.at[largest, 'ndcg@10']:.3f}")34print(f"its relative gain: {relative[largest]:.3f}")35print(f"mean of per-query relative gains without it: {relative.drop(largest).mean():.3f}")
python per-query-hybrid-versus-bm25.pymean difference: 0.087
median difference: 0.057
hybrid better: 17
bm25 better: 7
tied: 6
hybrid's three largest losses:
query difference
query_id
293 wood floor protector mat -0.072
292 decorative white pillow -0.069
249 bistro table and chairs -0.066
largest gain: outdoor light fixtures
its gain: 0.714
its bm25 judged@10: 0.200
share of the mean gain from this query: 0.274
relative gain of the means: 0.120
mean of per-query relative gains: 0.218
its bm25 ndcg@10: 0.286
its relative gain: 2.492
mean of per-query relative gains without it: 0.140
La ganancia media es 0.087, pero la mediana es 0.057. El híbrido gana en más consultas de las que pierde, 17 frente a 7, y empata en 6.
Una sola consulta hace buena parte del trabajo. outdoor light fixtures gana 0.714, una proporción de 0.274 de la ganancia total, y el judged@10 de BM25 en ella es 0.200. Para esta consulta, los 10 primeros de BM25 son sobre todo bombillas que nadie juzgó, y el capítulo 1 sostiene que su calificación de 0 es justa, así que la ganancia se mantiene. Para otra consulta, los productos sin juzgar que deja fuera un ranker podrían ser buenos. Las tres mayores pérdidas del híbrido son las consultas en las que un comprador vería que la búsqueda empeora, así que léelas primero.
Informa la diferencia como un número absoluto. La ganancia relativa de las medias es 0.120, pero la media de las ganancias relativas por consulta es 0.218, porque una media de cocientes por consulta da más peso a las consultas en las que BM25 puntúa bajo.
outdoor light fixtures, donde BM25 puntúa 0.286, aporta por sí sola una ganancia relativa de 2.492. Sin esa única consulta, la media de las ganancias relativas baja a 0.140. Fuhr muestra que el cambio relativo en una media no dice nada fiable sobre el cambio por consulta, y que «para la media aritmética, solo son significativas las mejoras absolutas» (Fuhr, 2017, sección 2.4).
Regla práctica: En cada comparación, imprime la diferencia media y mediana, los recuentos de victorias, derrotas y empates, y las consultas con las mayores pérdidas, y luego lee esas consultas. Revisa el judged@10 de las consultas que más se mueven antes de atribuir el mérito al ranker. Informa diferencias absolutas de medias, no porcentajes.
Contrasta una diferencia con una prueba de permutación
Una diferencia entre dos medias calculadas sobre unas pocas decenas de consultas puede deberse solo al azar: otra muestra de consultas daría una diferencia distinta. Las métricas superficiales empeoran esto: Buckley y Voorhees encontraron que, con una medida como la precisión en 10, los investigadores necesitan muchas más de 50 consultas para distinguir sistemas de forma fiable (Buckley y Voorhees, 2000). Una prueba de significación pregunta cuán sorprendente sería una diferencia entre dos clasificadores bajo la hipótesis nula, es decir, el supuesto de que ambos sistemas son igual de buenos. Su respuesta es el valor p: la probabilidad, bajo la hipótesis nula, de una diferencia al menos tan grande como la que has medido. Por convención, un valor p por debajo de 0.05 cuenta como evidencia de una diferencia real, y la regla del libro lo endurece cuando un capítulo hace varias comparaciones.
Las pruebas de este libro son pareadas: ambos sistemas se evalúan sobre las mismas consultas, de modo que cada prueba trabaja con las diferencias por consulta, y las puntuaciones bajas de una consulta difícil se cancelan. Una prueba de permutación construye directamente las diferencias que verías bajo la hipótesis nula. Si los dos sistemas fueran intercambiables, el signo de la diferencia de cada consulta sería igual de probable en un sentido que en el contrario. Así que cambia el signo de cada diferencia al azar, recalcula la media, repite el proceso miles de veces y cuenta con qué frecuencia la media con signos cambiados queda al menos tan lejos de 0 como la real. Para n consultas hay 2^n patrones de signos, 1,073,741,824 para las consultas de prueba, así que la prueba muestrea 9,999 de ellos, y su valor p es una estimación.
El híbrido queda por detrás de la recuperación semántica en las consultas de prueba, y el capítulo 1 dejó abierta la cuestión de si esa diferencia es real. Frente a la recuperación semántica, las victorias, derrotas y empates del híbrido en las consultas de prueba son 9 / 14 / 7. ¿Encontrará la prueba que el déficit del híbrido es mayor que el que cabría esperar por azar? Decide tu respuesta y luego ejecuta la prueba.
1"""Estimates the p-value of the hybrid's deficit against semantic retrieval by flipping each query's sign at random, once by hand and once with SciPy's permutation_test. The prose's point rests on the observed mean, the two p-value lines, and the line that compares the p-value with 0.05."""2import numpy as np3from scipy.stats import permutation_test45from lib.fusion import reciprocal_rank_fusion6from lib.lexical import LexicalSearch7from lib.metrics import evaluate8from lib.semantic import SemanticSearch9from lib.store import load_products, load_queries, qrels1011queries, judgments = load_queries("test"), qrels("test")12semantic = SemanticSearch().run(queries, k=100)13hybrid = reciprocal_rank_fusion([LexicalSearch(load_products()).run(queries, k=100), semantic])14after = evaluate(hybrid, judgments)["ndcg@10"].to_numpy()15before = evaluate(semantic, judgments)["ndcg@10"].to_numpy()16difference = after - before # hybrid minus semantic, per test query17print("test queries:", len(difference))18print(f"sign patterns for the test queries: {2 ** len(difference):,}")19print(f"observed mean difference: {difference.mean():.3f}")2021# if the two rankers were interchangeable, each query's difference would be as likely to have the other sign22# a fixed seed, so every run draws the same sign patterns23rng = np.random.default_rng(2026)24# 9,999 random sign patterns, one sign for each query in each25signs = rng.choice([-1, 1], size=(9999, len(difference)))26flipped = (signs * difference).mean(axis=1) # 9,999 mean differences under that assumption27# the 95th percentile of the flipped means' sizes28print(f"95% of flipped means are smaller than: {np.quantile(np.abs(flipped), 0.95):.3f}")29print(f"p-value by hand: {np.mean(np.abs(flipped) >= abs(difference.mean())):.3f}")3031result = permutation_test((after, before), lambda after_scores, before_scores, axis: np.mean(after_scores - before_scores, axis=axis),32 # samples: flip each query's pair of scores, which is the paired setting33 permutation_type="samples", rng=np.random.default_rng(2026))34print(f"p-value from scipy: {result.pvalue:.3f}")35print("difference at the 0.05 level:", "larger than chance" if result.pvalue < 0.05 else "within chance")
python permutation-test-by-hand.pytest queries: 30
sign patterns for the test queries: 1,073,741,824
observed mean difference: -0.018
95% of flipped means are smaller than: 0.022
p-value by hand: 0.117
p-value from scipy: 0.125
difference at the 0.05 level: within chance
El déficit del híbrido frente a la recuperación semántica es within chance al nivel 0.05. La diferencia media observada es -0.018, y el 95% de las medias con signos cambiados son menores que 0.022 en valor absoluto. El valor p, la proporción de medias con signos cambiados al menos tan grandes como la observada, es 0.117.
La función permutation_test de SciPy, ejecutada con permutation_type="samples", el ajuste que su documentación indica para las pruebas pareadas, devuelve 0.125 (documentación de SciPy). Las dos estimaciones difieren un poco porque cada una extrae sus propios patrones de signos aleatorios. Para que haya una diferencia real, la media tendría que pesar más que la dispersión, y unas pocas consultas que se inclinen en sentido contrario podrían cerrar la brecha.
Las funciones de remuestreo de SciPy reciben su generador aleatorio a través de rng, que sustituye al argumento random_state. Con 1.18.1 funcionan ambos, pero la documentación indica que "solo debe usarse la palabra clave rng en código nuevo", porque las llamadas que usen random_state emitirán advertencias tras un período de transición (documentación de SciPy). Cada ejemplo de este libro pasa rng con una semilla fija.
Regla práctica: Somete cada diferencia en la que pienses actuar a una prueba de permutación pareada sobre las diferencias por consulta. El libro decide con esta prueba, como establece su regla. Lee un valor p por encima del umbral como "no hay evidencia de una diferencia", nunca como "no hay diferencia": con tan pocas consultas, una prueba puede pasar por alto una diferencia real, y McKechnie et al. defienden que se midan esos fallos junto con los falsos positivos (McKechnie et al., 2025). Nunca expliques una diferencia que la prueba no puede distinguir del azar.
Obtén el valor p de una prueba t pareada
La prueba t pareada responde la misma pregunta con una fórmula en lugar de remuestreo. Divide la media de las diferencias por consulta entre su error estándar: la desviación estándar de las diferencias dividida entre la raíz cuadrada del número de consultas, lo que estima cuánto se movería la media de una muestra de consultas a otra. Si los rankers son igual de buenos y las diferencias son aproximadamente normales, ese cociente, t, sigue una distribución t: con forma de campana y colas más pesadas que la normal, cuya forma depende de sus grados de libertad, aquí uno menos que el número de consultas. El valor p es la probabilidad de una t al menos tan alejada de 0 en cualquier dirección (Sakai, 2014, sección 3.1.1):
t = mean(d) / (sd(d) / sqrt(n)) d: the per-query differences, n: the number of queries
Las diferencias de nDCG por consulta están acotadas entre −1 y 1 y tienen valores atípicos, como la ganancia en outdoor light fixtures, así que no son normales. En la práctica, la prueba t se sostiene bien. En ejecuciones de TREC evaluadas con precisión promedio media (MAP, otra métrica de ranking) sobre 50 temas, Smucker et al. encontraron poca diferencia práctica entre las pruebas de aleatorización, bootstrap y t, donde la prueba de aleatorización es la prueba de permutación (Smucker et al., 2007). En una simulación construida a partir de datos de TREC, con conjuntos de 25, 50 y 100 temas, Urbano et al. encontraron que "tanto la prueba t como la prueba de permutación se comportan casi de forma idéntica" (Urbano et al., 2019). Ambos estudios desaconsejan para esta tarea las pruebas de rangos con signo de Wilcoxon y la prueba de signos. La función wilcoxon de SciPy también descarta por defecto cada consulta cuya diferencia es exactamente 0, con zero_method='wilcox' (documentación de SciPy), y muchas consultas empatan cuando dos ejecuciones difieren un poco.
¿Coinciden la fórmula y el remuestreo en las brechas del capítulo 1? Tomemos dos de ellas, la recuperación semántica frente a BM25 y el híbrido frente a la recuperación semántica. La t de la fórmula, calculada a mano, debería coincidir con ttest_rel de SciPy:
1"""Computes the paired t statistic and its p-value by hand for two gaps, and checks each p-value against SciPy's ttest_rel. The prose's point rests on the t and p lines printed for each gap."""2import math34from scipy.stats import t, ttest_rel56from lib.fusion import reciprocal_rank_fusion7from lib.lexical import LexicalSearch8from lib.metrics import evaluate9from lib.semantic import SemanticSearch10from lib.store import load_products, load_queries, qrels1112queries, judgments = load_queries("test"), qrels("test")13bm25 = LexicalSearch(load_products()).run(queries, k=100)14semantic = SemanticSearch().run(queries, k=100)15runs = {"bm25": bm25, "semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}16ndcg = {name: evaluate(run, judgments)["ndcg@10"] for name, run in runs.items()} # per test query1718for after, before in [("semantic", "bm25"), ("hybrid", "semantic")]:19 difference = ndcg[after] - ndcg[before]20 n = len(difference)21 # ddof=1 divides by n - 1, the sample standard deviation the t-test uses22 standard_error = difference.std(ddof=1) / math.sqrt(n) # how much the mean would move between samples23 statistic = difference.mean() / standard_error24 p_value = 2 * t.sf(abs(statistic), df=n - 1) # both tails of the t distribution25 print(f"{after} minus {before}: {difference.mean():.3f}")26 print(f"{after} minus {before} t by hand: {statistic:.3f}")27 print(f"{after} minus {before} p by hand: {p_value:.3f}")28 print(f"{after} minus {before} p from ttest_rel: {ttest_rel(ndcg[after], ndcg[before]).pvalue:.3f}")
python paired-t-test-by-hand.pysemantic minus bm25: 0.105
semantic minus bm25 t by hand: 3.294
semantic minus bm25 p by hand: 0.003
semantic minus bm25 p from ttest_rel: 0.003
hybrid minus semantic: -0.018
hybrid minus semantic t by hand: -1.590
hybrid minus semantic p by hand: 0.123
hybrid minus semantic p from ttest_rel: 0.123
Para la recuperación semántica frente a BM25, la diferencia media de 0.105 da t = 3.294 y un valor p de 0.003, lo mismo que da ttest_rel. Es una brecha que el azar produciría rara vez.
Para el híbrido frente a la recuperación semántica, t = -1.590 y el valor p es 0.123. Está cerca del 0.125 de la prueba de permutación para la misma brecha.
Regla práctica: Informa la prueba t pareada, scipy.stats.ttest_rel, junto a la prueba de permutación, como una comprobación que no requiere remuestreo. Cuando ambas caigan a lados distintos del umbral, dilo y deja que la prueba de permutación decida. No uses la prueba de Wilcoxon ni la de signos para comparar puntuaciones medias.
Informa de cuán grande es la diferencia
Un valor p dice cuán sorprendente es una diferencia, no cuán grande es. En una muestra grande, casi cualquier modificación produce una diferencia significativa pero minúscula (Fuhr, 2017, sección 2.8). Sakai recomienda informar un tamaño del efecto y un intervalo de confianza junto con cada valor p (Sakai, 2014). Un intervalo de confianza es un rango de valores plausibles para la diferencia media verdadera: la media sobre todas las consultas como estas, puntuadas con estos juicios, y no sobre el tráfico de búsqueda de la tienda. Un intervalo del 95 % proviene de un procedimiento que pretende cubrir ese valor el 95 % de las veces.
El bootstrap construye un intervalo de confianza mediante remuestreo. Extrae tantas consultas como tengas, de las consultas que tienes, con reemplazo, de modo que algunas aparezcan dos veces y otras ninguna. Calcula la diferencia media y repite miles de veces. El intervalo percentil es el 95 % central de las medias remuestreadas. El tamaño del efecto de una comparación pareada es la diferencia media dividida por la desviación estándar de las diferencias (Sakai, 2014, sección 3.1.2). Indica cuán grande es la diferencia frente a cuánto varía de una consulta a otra. No es la d de Cohen, el tamaño del efecto para muestras no pareadas, y Sakai advierte contra comparar ambas directamente.
¿Puede un intervalo percentil construido a mano coincidir con el bootstrap de SciPy con method="percentile"? Construye uno a mano para la recuperación semántica frente a BM25 y para el híbrido frente a la recuperación semántica, compáralo con SciPy y luego ejecuta el método por defecto de SciPy:
1"""Builds a 95% percentile interval by hand from 9,999 resampled means, checks it against SciPy's percentile method, then reads SciPy's default BCa interval and the effect size for each gap. The prose's point rests on the BCa low and high lines and on the line that says whether each interval includes 0."""2import numpy as np3from scipy.stats import bootstrap45from lib.fusion import reciprocal_rank_fusion6from lib.lexical import LexicalSearch7from lib.metrics import evaluate8from lib.semantic import SemanticSearch9from lib.store import load_products, load_queries, qrels1011queries, judgments = load_queries("test"), qrels("test")12bm25 = LexicalSearch(load_products()).run(queries, k=100)13semantic = SemanticSearch().run(queries, k=100)14runs = {"bm25": bm25, "semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}15ndcg = {name: evaluate(run, judgments)["ndcg@10"] for name, run in runs.items()} # per test query1617for after, before in [("semantic", "bm25"), ("hybrid", "semantic")]:18 difference, name = (ndcg[after] - ndcg[before]).to_numpy(), f"{after} minus {before}"19 # choice draws with replacement, so a query can appear twice in one set and not at all in another20 resampled = np.random.default_rng(2026).choice(difference, size=(9999, len(difference))) # 9,999 sets of queries21 # 2.5% in each tail leaves the middle 95%22 low, high = np.percentile(resampled.mean(axis=1), [2.5, 97.5]) # the middle 95% of their means23 print(f"{name}: {difference.mean():.3f}")24 print(f"{name} interval by hand: {low:.3f} to {high:.3f}")25 percentile = bootstrap((difference,), np.mean, method="percentile", rng=np.random.default_rng(2026))26 print(f"{name} percentile interval from scipy: "27 f"{percentile.confidence_interval.low:.3f} to {percentile.confidence_interval.high:.3f}")28 # BCa is SciPy's default method, so no method argument is given29 bca = bootstrap((difference,), np.mean, rng=np.random.default_rng(2026)).confidence_interval30 print(f"{name} bca low: {bca.low:.3f}\n{name} bca high: {bca.high:.3f}")31 print(f"{name} bca interval and 0: {'includes 0' if bca.low <= 0 <= bca.high else 'excludes 0'}")32 # ddof=1: the standard deviation of the differences, with n - 1 in the denominator33 print(f"{name} effect size: {difference.mean() / difference.std(ddof=1):.3f}")
python bootstrap-interval-by-hand.pysemantic minus bm25: 0.105
semantic minus bm25 interval by hand: 0.049 to 0.172
semantic minus bm25 percentile interval from scipy: 0.049 to 0.172
semantic minus bm25 bca low: 0.055
semantic minus bm25 bca high: 0.185
semantic minus bm25 bca interval and 0: excludes 0
semantic minus bm25 effect size: 0.601
hybrid minus semantic: -0.018
hybrid minus semantic interval by hand: -0.041 to 0.003
hybrid minus semantic percentile interval from scipy: -0.041 to 0.003
hybrid minus semantic bca low: -0.042
hybrid minus semantic bca high: 0.002
hybrid minus semantic bca interval and 0: includes 0
hybrid minus semantic effect size: -0.290
El intervalo percentil de SciPy coincide con el construido a mano: 0.049 to 0.172 y -0.041 to 0.003. Su método por defecto, BCa (corregido por sesgo y aceleración), toma percentiles distintos de las mismas medias remuestreadas. Los desplaza según cuán descentradas están las medias remuestreadas respecto de la media observada, y los estira según la asimetría que estima dejando fuera una consulta a la vez (código fuente de SciPy). El arnés del libro informa BCa, diseñado para medias remuestreadas asimétricas como estas.
Para la recuperación semántica frente a BM25, BCa va de 0.055 a 0.185, por lo que excludes 0, y el tamaño del efecto es 0.601.
Para el híbrido frente a la recuperación semántica, el intervalo va de -0.042 a 0.002. includes 0, y el tamaño del efecto es -0.290. Ese intervalo admite cualquier valor desde una pérdida de unas pocas centésimas hasta una ganancia de como máximo 0.002: ninguna ganancia que valga la pena.
Un intervalo bootstrap solo aproxima su nivel, y con unas pocas decenas de consultas se queda corto. Para comprobarlo, trata las 30 diferencias por consulta del híbrido frente a la recuperación semántica como si fueran todas las consultas que existen, de modo que la diferencia verdadera sea conocida. Luego extrae de ellas 1000 nuevos conjuntos del mismo tamaño, construye un intervalo en cada uno y cuenta con qué frecuencia cubre la diferencia verdadera:
1"""Draws new samples from the test queries' differences and counts how often a BCa or a t interval covers the known gap, at two levels. The prose's point rests on the four coverage lines and the standard-error line."""2import numpy as np3from scipy.stats import bootstrap, ttest_1samp45from lib.fusion import reciprocal_rank_fusion6from lib.lexical import LexicalSearch7from lib.metrics import evaluate8from lib.semantic import SemanticSearch9from lib.store import load_products, load_queries, qrels1011queries, judgments = load_queries("test"), qrels("test")12semantic = SemanticSearch().run(queries, k=100)13hybrid = reciprocal_rank_fusion([LexicalSearch(load_products()).run(queries, k=100), semantic])14population = (evaluate(hybrid, judgments)["ndcg@10"] - evaluate(semantic, judgments)["ndcg@10"]).to_numpy()15true_gap = population.mean() # known, because these differences stand in for every query there is1617# a fixed seed, so the coverage counts repeat on every run18rng, trials = np.random.default_rng(2026), 100019print("trials:", trials)20# binomial standard error of a proportion near 0.95, over the trials21print(f"standard error of a coverage near 0.95: {(0.95 * 0.05 / trials) ** 0.5:.3f}")22for level in [0.95, round(1 - 0.05 / 3, 4)]: # the usual level, and the level for three comparisons23 covered = {"bca": 0, "t": 0}24 for _ in range(trials):25 sample = rng.choice(population, size=len(population)) # another set of 30 queries like these26 # 1,999 resamples per interval, fewer than SciPy's default, to keep 1,000 trials quick27 bca = bootstrap((sample,), np.mean, confidence_level=level, n_resamples=1999, rng=rng).confidence_interval28 t = ttest_1samp(sample, 0).confidence_interval(level) # the interval that matches the t-test29 covered["bca"] += bca.low <= true_gap <= bca.high30 covered["t"] += t.low <= true_gap <= t.high31 for method, count in covered.items():32 print(f"{method} coverage at {level}: {count / trials:.3f}")
python interval-coverage-check.pytrials: 1000
standard error of a coverage near 0.95: 0.007
bca coverage at 0.95: 0.927
t coverage at 0.95: 0.945
bca coverage at 0.9833: 0.955
t coverage at 0.9833: 0.975
Con un nivel nominal del 95 %, BCa cubre la diferencia verdadera el 0.927 de las veces y el intervalo de la prueba t el 0.945. Con 0.9833, el nivel que el arnés usa para sus comparaciones planificadas, BCa cubre el 0.955 y el intervalo t el 0.975.
Cada cifra es incierta en unos 0.007 en ambos sentidos. BCa se queda por debajo de su nivel en ambos casos, y el intervalo t se acerca más al suyo. Por tanto, un intervalo bootstrap que apenas excluye el 0 merece cautela. En una simulación, una prueba construida con el mismo remuestreo, la prueba de desplazamiento bootstrap, "muestra un sesgo sistemático hacia valores p pequeños" (Urbano et al., 2019).
Si una diferencia importa es un juicio que ninguna prueba toma por ti. Para la precisión@10, Fuhr señala que "una diferencia de 0.02 equivale a un documento relevante más cada cinco consultas" (Fuhr, 2017, sección 2.8). Para nDCG@10, decide antes de probar qué diferencia justificaría el coste de un cambio.
Regla práctica: Presenta cada comparación con su diferencia media, su intervalo bootstrap, su tamaño del efecto y su valor p. Si el intervalo incluye el 0, la comparación no muestra mejora. Si excluye el 0 pero queda por debajo de la diferencia más pequeña que vale la pena para el coste del cambio, la diferencia puede ser real y aun así no merecer su implantación. Usa el intervalo para describir el tamaño de una diferencia, no para decidir si existe.
Decide por adelantado qué se considera establecido
Cada prueba con 0.05 conlleva un 5% de probabilidad de falso positivo cuando la diferencia es ruido, y un capítulo que ejecuta varias pruebas corre ese riesgo varias veces. Comparar cada par de 10 sistemas de esta forma da una probabilidad de cerca de 0.90 de al menos un resultado "significativo" falso, si cada diferencia es ruido y las pruebas son independientes (Sakai, 2014, sección 3). La corrección de Bonferroni es un remedio sencillo y conservador: cuando pruebas m hipótesis, pruebas cada una con 0.05 dividido entre m (Fuhr, 2017, sección 2.7). Mantiene la probabilidad de cualquier falso positivo en 0.05 o por debajo, sean o no independientes las pruebas. Solo funciona si las m comparaciones se fijan antes de ver los resultados. Fuhr señala la forma habitual de romper esa condición: el autor primero averigua qué método competidor funciona mejor con los datos y después compara su propio enfoque solo con ese (Fuhr, 2017, sección 2.6).
Así que el libro usa una sola regla, en todos los capítulos:
- Enumera las comparaciones planificadas sobre las consultas de prueba antes de informar de cualquiera de ellas.
- Una diferencia se considera establecida cuando su prueba de permutación emparejada da un p-valor inferior al umbral de Bonferroni del capítulo: 0.05 dividido entre el número de comparaciones planificadas.
- Informa de la prueba t emparejada y de un intervalo de bootstrap junto a ella, el intervalo al nivel equivalente, 1 menos el umbral. Cuando cualquiera de los dos discrepe de la prueba de permutación, dilo.
- Una comparación elegida después de mirar los resultados de prueba es exploratoria. Márcala como tal, y nunca la llames establecida.
- Las comparaciones sobre las consultas de entrenamiento sirven para ajustar, no como evidencia.
Dejamos que la prueba de permutación decida porque no supone nada sobre la forma de las diferencias, solo que, bajo la hipótesis nula, el signo de cada consulta es como lanzar una moneda. Urbano et al. comprobaron que ambas se comportan casi igual (Urbano et al., 2019), lo que hace de la prueba t una buena verificación. Los intervalos de bootstrap sobre unas pocas docenas de consultas cubren con menos frecuencia de lo que indica su nivel (comprobación de cobertura), y por eso un intervalo describe una diferencia pero no la decide.
El capítulo 1 construye la canalización de la tienda una etapa cada vez, y ese orden por sí solo fija sus comparaciones planificadas: cada etapa frente a la anterior. Eso da recuperación semántica frente a BM25, el híbrido frente a la recuperación semántica y el híbrido reordenado frente al híbrido, 3 en total. El umbral es 0.0167, y los intervalos usan un nivel de 0.9833. Comparar el híbrido reordenado con la recuperación semántica es exploratorio, porque la recuperación semántica pasó a ser el ranker a superar al puntuar más alto en esas mismas consultas de prueba.
Regla práctica: Escribe la lista de comparaciones planificadas antes de puntuar nada sobre las consultas de prueba, y mantenla corta, ya que cada una eleva el listón para las demás. Cuando necesites comparar muchos rankers a la vez, Bonferroni se vuelve estricto. Sakai recomienda un análisis de varianza, que comprueba si alguno de los rankers difiere en algo, seguido de la prueba HSD de Tukey aleatorizada, que compara cada par manteniendo la probabilidad de cualquier falso positivo en el nivel establecido (0.05) (Sakai, 2014).
Compara ejecuciones en un arnés de evaluación
El libro aplica esa regla en un arnés de evaluación, que mantiene todo fijo excepto el ranker: las mismas consultas, juicios, métricas y pruebas, de modo que dos ejecuciones solo difieran en sus rankings. lib.metrics.evaluate devuelve una fila por consulta, que es la forma que necesitan las pruebas pareadas. compare en lib.significance, un módulo breve que reúne el código de este capítulo, ejecuta las pruebas sobre la columna de una métrica de dos ejecuciones. Devuelve la diferencia media, el intervalo bootstrap, los valores p de la prueba de permutación y de la prueba t, el tamaño del efecto y las victorias, derrotas y empates. Su función verdict aplica la regla del libro a un resultado. Conserva los marcos de datos por consulta y promedia solo al final.
Así que ejecuta los cuatro rankers del capítulo 1 a través de ella, y después haz las 3 comparaciones planificadas y la exploratoria:
1"""Runs chapter 1's four rankers through the harness and applies the Bonferroni threshold to the three planned comparisons and one exploratory comparison. The prose's point rests on the judged@10 lines, the established lines, and the exploratory comparison's p-value and agreement lines."""2from lib.fusion import reciprocal_rank_fusion3from lib.lexical import LexicalSearch4from lib.metrics import evaluate5from lib.recorded import cross_encoder_scores6from lib.semantic import SemanticSearch7from lib.significance import compare, verdict8from lib.store import load_products, load_queries, qrels910queries, judgments = load_queries("test"), qrels("test")11bm25 = LexicalSearch(load_products()).run(queries, k=100)12semantic = SemanticSearch().run(queries, k=100)13hybrid = reciprocal_rank_fusion([bm25, semantic])14score = {(query_id, product_id): value for query_id, product_id, value in cross_encoder_scores().itertuples(index=False)}15# chapter 1's rerank: only the top 50 are reordered; the rest keep their hybrid order16reranked = {query_id: sorted(ranking[:50], key=lambda product_id: score[(query_id, product_id)], reverse=True)17 + ranking[50:] for query_id, ranking in hybrid.items()}1819runs = {"bm25": bm25, "semantic": semantic, "hybrid": hybrid, "reranked": reranked}20scores = {name: evaluate(run, judgments) for name, run in runs.items()} # one row per test query21for name, frame in scores.items():22 print(f"{name} ndcg@10: {frame['ndcg@10'].mean():.3f}\n{name} judged@10: {frame['judged@10'].mean():.3f}")2324planned = [("semantic", "bm25"), ("hybrid", "semantic"), ("reranked", "hybrid")] # each stage against the last25exploratory = [("reranked", "semantic")] # chosen after chapter 1 saw the test means26threshold = 0.05 / len(planned) # Bonferroni, over the planned comparisons only27print(f"\nplanned comparisons: {len(planned)}\np-value threshold: {threshold:.4f}\ninterval level: {1 - threshold:.4f}")28# each planned test has a 0.95 chance of no false positive, if its gap is noise29print(f"chance of a false positive, all gaps noise, tests independent: {1 - 0.95 ** len(planned):.3f}")30established, disagreements = 0, 031for after, before in planned + exploratory:32 result, name = compare(scores[after]["ndcg@10"], scores[before]["ndcg@10"], confidence=1 - threshold), f"{after} minus {before}"33 # verdict runs on the exploratory one too, only for its agreement checks; it is never counted as established34 checks, kind = verdict(result, threshold), "planned" if (after, before) in planned else "exploratory"35 print(f"\n{name}: {result['mean difference']:.3f}\n{name} kind: {kind}")36 print(f"{name} interval: {result['ci low']:.3f} to {result['ci high']:.3f}")37 print(f"{name} permutation p: {result['permutation p']:.3f}\n{name} t-test p: {result['t-test p']:.3f}")38 print(f"{name} effect size: {result['effect size']:.3f}\n{name} wins, losses, ties: {result['wins']} / {result['losses']} / {result['ties']}")39 # only a planned comparison can be established; the exploratory one is labelled and never called so40 print(f"{name} established: {'yes' if checks['established'] and kind == 'planned' else 'no'}")41 for method in ["t-test", "interval"]:42 print(f"{name} {method} agrees: {'yes' if checks[method + ' agrees'] else 'no'}")43 if kind == "planned":44 established += checks["established"]45 # a planned comparison where the t-test or the interval disagrees with the permutation test46 disagreements += not (checks["t-test agrees"] and checks["interval agrees"])47print(f"\nplanned comparisons established: {established}\nplanned comparisons with a disagreement: {disagreements}")
python compare-chapter-one-rankers.pybm25 ndcg@10: 0.725
bm25 judged@10: 0.927
semantic ndcg@10: 0.830
semantic judged@10: 0.990
hybrid ndcg@10: 0.812
hybrid judged@10: 0.980
reranked ndcg@10: 0.798
reranked judged@10: 0.980
planned comparisons: 3
p-value threshold: 0.0167
interval level: 0.9833
chance of a false positive, all gaps noise, tests independent: 0.143
semantic minus bm25: 0.105
semantic minus bm25 kind: planned
semantic minus bm25 interval: 0.047 to 0.205
semantic minus bm25 permutation p: 0.001
semantic minus bm25 t-test p: 0.003
semantic minus bm25 effect size: 0.601
semantic minus bm25 wins, losses, ties: 21 / 7 / 2
semantic minus bm25 established: yes
semantic minus bm25 t-test agrees: yes
semantic minus bm25 interval agrees: yes
hybrid minus semantic: -0.018
hybrid minus semantic kind: planned
hybrid minus semantic interval: -0.048 to 0.006
hybrid minus semantic permutation p: 0.125
hybrid minus semantic t-test p: 0.123
hybrid minus semantic effect size: -0.290
hybrid minus semantic wins, losses, ties: 9 / 14 / 7
hybrid minus semantic established: no
hybrid minus semantic t-test agrees: yes
hybrid minus semantic interval agrees: yes
reranked minus hybrid: -0.014
reranked minus hybrid kind: planned
reranked minus hybrid interval: -0.053 to 0.020
reranked minus hybrid permutation p: 0.382
reranked minus hybrid t-test p: 0.375
reranked minus hybrid effect size: -0.165
reranked minus hybrid wins, losses, ties: 11 / 12 / 7
reranked minus hybrid established: no
reranked minus hybrid t-test agrees: yes
reranked minus hybrid interval agrees: yes
reranked minus semantic: -0.032
reranked minus semantic kind: exploratory
reranked minus semantic interval: -0.078 to -0.003
reranked minus semantic permutation p: 0.048
reranked minus semantic t-test p: 0.048
reranked minus semantic effect size: -0.377
reranked minus semantic wins, losses, ties: 9 / 16 / 5
reranked minus semantic established: no
reranked minus semantic t-test agrees: yes
reranked minus semantic interval agrees: no
planned comparisons established: 1
planned comparisons with a disagreement: 0
Los productos no juzgados pesan más en BM25, cuyo judged@10 es 0.927, frente a 0.990 para la recuperación semántica, 0.980 para el híbrido y 0.980 para el híbrido con reranking.
Con 3 pruebas al 0.05 cada una, la probabilidad de al menos un falso positivo sería 0.143 si todas las diferencias fueran ruido y las pruebas fueran independientes. La corrección de Bonferroni la limita a 0.05 en cualquier caso. En nDCG@10 sobre las consultas de prueba, con intervalos al nivel 0.9833:
| Medida | Semántico menos BM25 | Híbrido menos semántico | Con reranking menos híbrido | Con reranking menos semántico |
|---|---|---|---|---|
| Tipo | planned | planned | planned | exploratory |
| Diferencia media | 0.105 | -0.018 | -0.014 | -0.032 |
| Intervalo | 0.047 to 0.205 | -0.048 to 0.006 | -0.053 to 0.020 | -0.078 to -0.003 |
| p de permutación | 0.001 | 0.125 | 0.382 | 0.048 |
| p de la prueba t | 0.003 | 0.123 | 0.375 | 0.048 |
| Tamaño del efecto | 0.601 | -0.290 | -0.165 | -0.377 |
| Victorias / derrotas / empates | 21 / 7 / 2 | 9 / 14 / 7 | 11 / 12 / 7 | 9 / 16 / 5 |
| Establecida | yes | no | no | no |
De las 3 comparaciones planificadas, 1 está establecida: la ventaja de la recuperación semántica sobre BM25, con un valor p de permutación de 0.001. La diferencia del híbrido frente a la recuperación semántica y la del reranker frente al híbrido no están establecidas: en estas consultas ninguno de los dos cambios muestra una mejora, y tampoco se demuestra que sean peores. El arnés contrasta la prueba t y el intervalo con la prueba de permutación: 0 comparaciones planificadas presentan una discrepancia.
La comparación exploratoria es donde las comprobaciones empiezan a discrepar. Su valor p de permutación es 0.048, que hay que comparar con 0.05 sin corrección y con 0.0167 con corrección, y su intervalo va desde -0.078 to -0.003.
La prueba t coincide con la prueba de permutación, pero el intervalo, que excluye el 0, no. Al preguntar si cada comprobación concuerda con la prueba de permutación, el arnés responde yes para la prueba t y no para el intervalo: un intervalo que excluye el 0 junto a un valor p por encima del umbral es el tipo de discrepancia que advierte la comprobación de cobertura. Sean cuales sean sus números, esta comparación no puede establecerse, porque se eligió después de ver las medias de las pruebas. Como mucho, plantea una pregunta para consultas nuevas: ¿este reranker queda por detrás de la recuperación semántica?
La decisión del capítulo 1 se mantiene, según una regla que no depende de qué ranker obtuvo la puntuación más alta: el ranker a superar es la canalización más sencilla que ninguna comparación planificada haya demostrado que sea superada. La recuperación semántica superó a BM25, y ninguna de las etapas posteriores superó a la etapa anterior.
Regla práctica: Para cada cambio, informa de la nDCG@10 media y del judged@10 de cada ejecución, y después una tabla como esta, con una columna para cada comparación y las exploratorias rotuladas como tales. Un cambio solo se publica cuando está establecido frente al ranker a superar.
Qué sale mal en producción
Una sola muestra de consultas puede inducir a error. Los resultados sobre las consultas de prueba dependen de qué consultas cayeron en ese conjunto. Fuhr sostiene que el método simple de retención (holdout) no es fiable, porque sus resultados pueden depender en gran medida de la partición, y en su lugar pide validación cruzada (Fuhr, 2017, sección 2.5). Sakai coincide en que "particiones distintas de entrenamiento, validación y prueba pueden dar resultados distintos" (Sakai, 2020). El libro mantiene una partición fija para que cada capítulo informe sobre las mismas consultas de prueba. Para ver cuánto puede desplazarse una diferencia, ejecuta también sobre las consultas de entrenamiento la comparación exploratoria de el harness. Trata eso como una ilustración, no como evidencia, ya que las consultas de entrenamiento sirven para ajustar, como establece la regla:
1"""Runs the reranked-minus-semantic comparison on the test queries and on the train queries, so the verdict can be compared across the two samples. The prose's point rests on the two gap lines and the higher-scoring-run lines."""2from lib.fusion import reciprocal_rank_fusion3from lib.lexical import LexicalSearch4from lib.metrics import evaluate5from lib.recorded import cross_encoder_scores6from lib.semantic import SemanticSearch7from lib.significance import compare8from lib.store import load_products, load_queries, qrels910lexical, embeddings = LexicalSearch(load_products()), SemanticSearch()11score = {(query_id, product_id): value for query_id, product_id, value in cross_encoder_scores().itertuples(index=False)}1213for split in ["test", "train"]: # the same comparison on another sample of the store's queries14 queries, judgments = load_queries(split), qrels(split)15 semantic = embeddings.run(queries, k=100)16 hybrid = reciprocal_rank_fusion([lexical.run(queries, k=100), semantic])17 # as in chapter 1: rerank the top 50 and keep the rest in hybrid order18 reranked = {query_id: sorted(ranking[:50], key=lambda product_id: score[(query_id, product_id)], reverse=True)19 + ranking[50:] for query_id, ranking in hybrid.items()}20 result = compare(evaluate(reranked, judgments)["ndcg@10"], evaluate(semantic, judgments)["ndcg@10"])21 gap = result["mean difference"]22 print(f"{split} queries:", len(judgments))23 print(f"{split} reranked minus semantic: {gap:.3f}")24 print(f"{split} higher-scoring run:", "reranked" if gap > 0 else "semantic" if gap < 0 else "neither")25 if split == "test":26 print(f"test permutation p: {result['permutation p']:.3f}")
python split-changes-the-verdict.pytest queries: 30
test reranked minus semantic: -0.032
test higher-scoring run: semantic
test permutation p: 0.048
train queries: 50
train reranked minus semantic: 0.014
train higher-scoring run: reranked
La ejecución con mejor puntuación es semantic en las consultas de prueba y reranked en las consultas de entrenamiento, así que cuál ejecución puntúa más alto cambia según la partición.
En las 30 consultas de prueba, la recuperación híbrida con reordenación menos la recuperación semántica es -0.032 (p de permutación = 0.048). En las 50 consultas de entrenamiento es 0.014. Un valor p tan cercano a 0.05 en una sola muestra es un fundamento débil. El capítulo 11 explica cómo mantener las consultas de prueba fuera de cada decisión.
Reutilizar las consultas de prueba equivale a probar muchas hipótesis. Cada cambio que pruebes sobre las mismas consultas añade una comparación, incluso a lo largo de meses. Fuhr señala que "la reutilización de la colección también es un caso de pruebas de hipótesis múltiples" (Fuhr, 2017, sección 2.7). Lleva un registro de las comparaciones que ejecutes sobre tus consultas de prueba y cuéntalas al fijar el umbral.
Las puntuaciones empatadas hacen que las ejecuciones no sean repetibles. Dos productos con la misma puntuación pueden aparecer en cualquier orden, y la indexación con varios hilos puede hacer que el orden no sea determinista cuando hay empates (Lin y Yang, 2019). Incluso un orden repetible puede ser arbitrario: un empate queda según el orden que deje la selección de los k primeros de una biblioteca, o la entrada de una ordenación estable. Por eso los módulos del libro rompen los empates por product_id. LexicalSearch y lib.fusion ordenan las puntuaciones iguales por ese campo, y SemanticSearch ordena de forma estable los vectores almacenados en orden de product_id. Con todas las versiones fijadas, re-check examples vuelve a ejecutar cada ejemplo contra su salida registrada, de modo que un cambio en cualquiera de estos órdenes quedaría en evidencia. En tu propio sistema, rompe los empates con un orden fijo que no aporte información, como por product_id, antes de puntuar.
Los productos sin juzgar bajan la puntuación de un ranker. Un ranker que muestra productos que nadie juzgó pierde nDCG por ellos, aunque sean buenos. Revise judged@10 antes de probar, y haga juzgar los productos nuevos cuando baje.
Regla práctica: Registra cada comparación que ejecutes sobre las consultas de prueba, trata un resultado limítrofe o exploratorio como una pregunta para consultas nuevas, rompe los empates de puntuación en un orden fijo e informa judged@10 junto a cada nDCG@10.
Decisiones que tomó este capítulo
Cada elección siguiente es el valor por defecto del libro a partir de aquí. Un capítulo posterior cambia alguna solo por un motivo que él mismo expone.
- Métrica principal: nDCG@10 con ganancias lineales (las calificaciones 2, 1 y 0), un descuento log2(i + 1) y un ranking ideal a partir de cada producto evaluado. Informa precision@10 y MRR junto a ella. Relevante significa exacto.
- Nuestras propias métricas son la referencia. El libro informa
lib.metrics, y lo verifica conndcg_scorede scikit-learn, con cada producto evaluado en cada fila. - Cada comparación muestra las diferencias por consulta: media y mediana, victorias, derrotas y empates, las mayores pérdidas, y judged@10 en las consultas que más se mueven.
- La regla para una diferencia establecida: enumera primero las comparaciones planificadas sobre las consultas de prueba. Una diferencia se considera establecida cuando su prueba de permutación, con 9,999 cambios aleatorios de signo, da un valor p inferior a 0.05 dividido entre el número de comparaciones planificadas. Informa junto a ella la prueba t pareada y un intervalo de bootstrap BCa al nivel correspondiente, y di cuándo no coinciden. Etiqueta como exploratorias las comparaciones elegidas después de ver los resultados de prueba, y nunca las llames establecidas. Usa las consultas de entrenamiento solo para ajustar.
- Informa una diferencia no establecida como "no se mostró mejora", nunca como una pérdida, y nunca la expliques.
- Todo el remuestreo usa
rngcon una semilla fija, a través delib.significance. - Lo que enseñaron las comparaciones planificadas: de las del capítulo 1, la ventaja de la recuperación semántica sobre BM25 está establecida y las otras dos no, así que la recuperación semántica sigue siendo el ranker que hay que superar. Cada cambio posterior se prueba en el arnés frente al ranker que modifica, y solo se adopta si supera al ranker que hay que superar.
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.